diff --git a/.github/workflows/aps-real-gam.yml b/.github/workflows/aps-real-gam.yml
new file mode 100644
index 000000000..71348d0e5
--- /dev/null
+++ b/.github/workflows/aps-real-gam.yml
@@ -0,0 +1,106 @@
+name: "APS real-GAM attestation"
+run-name: >-
+  APS real-GAM / ${{ inputs.evidence_id }} / ${{ inputs.release_id }}
+
+permissions:
+  contents: read
+
+on:
+  workflow_call:
+    inputs:
+      release_id:
+        description: Exact TSJS release id deployed to the protected test network
+        required: true
+        type: string
+      evidence_id:
+        description: Unique cutover evidence identifier
+        required: true
+        type: string
+      previous_artifact_id:
+        description: Immutable artifact identifier used for rollback
+        required: true
+        type: string
+  workflow_dispatch:
+    inputs:
+      release_id:
+        description: Exact TSJS release id deployed to the protected test network
+        required: true
+        type: string
+      evidence_id:
+        description: Unique cutover evidence identifier
+        required: true
+        type: string
+      previous_artifact_id:
+        description: Immutable artifact identifier used for rollback
+        required: true
+        type: string
+
+jobs:
+  attest:
+    name: Chromium, Firefox, and WebKit attestation
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    environment: aps-real-gam
+    env:
+      TS_REAL_GAM_PAGE_URL: ${{ secrets.TS_REAL_GAM_PAGE_URL }}
+      TS_REAL_GAM_AUTH_HEADER: ${{ secrets.TS_REAL_GAM_AUTH_HEADER }}
+      TS_REAL_GAM_EXPECTED_RELEASE_ID: ${{ vars.TS_REAL_GAM_EXPECTED_RELEASE_ID }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Validate protected inputs and release binding
+        env:
+          DISPATCH_EVIDENCE_ID: ${{ inputs.evidence_id }}
+          DISPATCH_PREVIOUS_ARTIFACT_ID: ${{ inputs.previous_artifact_id }}
+          DISPATCH_RELEASE_ID: ${{ inputs.release_id }}
+        run: bash scripts/ci/aps-real-gam.sh validate-inputs
+
+      - name: Read repository toolchain pins
+        id: toolchains
+        run: bash scripts/ci/read-toolchains.sh
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.toolchains.outputs.node }}
+          cache: npm
+          cache-dependency-path: crates/trusted-server-integration-tests/browser/package-lock.json
+
+      - name: Install isolated browser-test dependencies
+        working-directory: crates/trusted-server-integration-tests/browser
+        run: npm ci
+
+      - name: Install all required browsers
+        working-directory: crates/trusted-server-integration-tests/browser
+        run: npx playwright install --with-deps chromium firefox webkit
+
+      - name: Run protected real-GAM contract
+        id: real-gam
+        run: bash scripts/ci/aps-real-gam.sh run
+
+      - name: Write release attestation
+        if: always()
+        env:
+          EVIDENCE_ID: ${{ inputs.evidence_id }}
+          PREVIOUS_ARTIFACT_ID: ${{ inputs.previous_artifact_id }}
+          RELEASE_ID: ${{ inputs.release_id }}
+          TEST_OUTCOME: ${{ steps.real-gam.outcome }}
+        run: node scripts/ci/aps-tsjs-evidence.mjs write-real-gam
+
+      - name: Scrub browser evidence before upload
+        if: always()
+        env:
+          TEST_OUTCOME: ${{ steps.real-gam.outcome }}
+        run: node scripts/ci/aps-tsjs-evidence.mjs scrub-real-gam
+
+      - name: Upload real-GAM evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: aps-real-gam-${{ github.run_id }}
+          path: |
+            crates/trusted-server-integration-tests/browser/real-gam-evidence/
+            crates/trusted-server-integration-tests/browser/playwright-report/
+            crates/trusted-server-integration-tests/browser/test-results/
+          if-no-files-found: error
+          retention-days: 30
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 4973afe44..4761fd311 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -1,4 +1,6 @@
 name: "Integration Tests"
+run-name: >-
+  Integration Tests / ${{ inputs.evidence_id || format('PR {0}', github.event.pull_request.number) }}
 
 permissions:
   contents: read
@@ -9,6 +11,23 @@ on:
   pull_request:
     types: [opened, synchronize, reopened]
   workflow_dispatch:
+    inputs:
+      base_sha:
+        description: Exact rc/202608 base commit for performance comparison
+        required: true
+        type: string
+      evidence_id:
+        description: Unique identifier used to bind this run to an evidence artifact
+        required: true
+        type: string
+      release_id:
+        description: Exact generated TSJS release id
+        required: true
+        type: string
+      previous_artifact_id:
+        description: Immutable artifact identifier used for rollback
+        required: true
+        type: string
 
 env:
   ORIGIN_PORT: 8888
@@ -19,8 +38,32 @@ env:
   CF_BUILD_ARTIFACT_PATH: /tmp/integration-test-artifacts/cloudflare/build
 
 jobs:
+  tsjs-performance-gate:
+    name: TSJS first-display performance evidence
+    if: >-
+      github.event_name == 'workflow_dispatch' &&
+      (startsWith(inputs.evidence_id, 'aps-tsjs-preswitch-') ||
+       startsWith(inputs.evidence_id, 'aps-tsjs-postswitch-'))
+    uses: ./.github/workflows/tsjs-performance-gate.yml
+    with:
+      base_sha: ${{ inputs.base_sha }}
+      evidence_id: ${{ inputs.evidence_id }}
+      mode: ${{ startsWith(inputs.evidence_id, 'aps-tsjs-postswitch-') && 'postswitch' || 'preswitch' }}
+
+  real-gam-attestation:
+    name: protected real-GAM attestation
+    if: >-
+      github.event_name == 'workflow_dispatch' &&
+      startsWith(inputs.evidence_id, 'aps-tsjs-cutover-')
+    uses: ./.github/workflows/aps-real-gam.yml
+    with:
+      evidence_id: ${{ inputs.evidence_id }}
+      release_id: ${{ inputs.release_id }}
+      previous_artifact_id: ${{ inputs.previous_artifact_id }}
+
   prepare-artifacts:
     name: prepare integration artifacts
+    if: github.event_name == 'pull_request'
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -57,6 +100,7 @@ jobs:
 
   integration-tests:
     name: integration tests
+    if: github.event_name == 'pull_request'
     needs: prepare-artifacts
     runs-on: ubuntu-latest
     timeout-minutes: 20
@@ -116,6 +160,7 @@ jobs:
 
   integration-tests-fastly-ec:
     name: integration tests (Fastly EC lifecycle)
+    if: github.event_name == 'pull_request'
     needs: prepare-artifacts
     runs-on: ubuntu-latest
     timeout-minutes: 15
@@ -152,10 +197,60 @@ jobs:
           VICEROY_CONFIG_PATH: ${{ env.ARTIFACTS_DIR }}/configs/viceroy.toml
           RUST_LOG: info
 
+  aps-runner-proxy:
+    name: APS runner proxy (${{ matrix.runtime }})
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        runtime: [axum, fastly, cloudflare, spin]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up APS proxy test environment
+        id: shared-setup
+        uses: ./.github/actions/setup-integration-test-env
+        with:
+          origin-port: ${{ env.ORIGIN_PORT }}
+          install-viceroy: ${{ matrix.runtime == 'fastly' && 'true' || 'false' }}
+          build-wasm: "false"
+          build-axum: "false"
+          build-test-images: "false"
+          build-cloudflare: "false"
+
+      - name: Add Cloudflare wasm target
+        if: matrix.runtime == 'cloudflare'
+        run: rustup target add wasm32-unknown-unknown
+
+      - name: Set up Node.js for Wrangler
+        if: matrix.runtime == 'cloudflare'
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.shared-setup.outputs.node-version }}
+
+      - name: Install Wrangler
+        if: matrix.runtime == 'cloudflare'
+        run: npm install -g wrangler@4.64.0
+
+      - name: Install Spin
+        if: matrix.runtime == 'spin'
+        uses: fermyon/actions/spin/setup@v1
+        with:
+          version: "v4.0.2"
+
+      - name: Run actual-adapter APS runner-proxy corpus
+        run: ./scripts/integration-tests-aps-runner-proxy.sh --runtime ${{ matrix.runtime }}
+        env:
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+          RUST_LOG: info
+
   browser-tests:
     name: browser integration tests
+    if: github.event_name == 'pull_request'
     needs: prepare-artifacts
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     timeout-minutes: 15
     steps:
       - uses: actions/checkout@v4
@@ -175,6 +270,12 @@ jobs:
           name: integration-test-artifacts
           path: ${{ env.ARTIFACTS_DIR }}
 
+      - name: Generate browser Viceroy configs with APS enabled
+        run: ./scripts/generate-integration-viceroy-configs.sh
+        env:
+          INTEGRATION_ENABLE_AUCTION: "true"
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+
       - name: Load integration test Docker images
         run: docker load --input "$DOCKER_ARTIFACT_PATH"
 
@@ -244,3 +345,143 @@ jobs:
           name: playwright-traces
           path: crates/trusted-server-integration-tests/browser/test-results/
           retention-days: 7
+
+  browser-tests-aps-tsjs-conformance:
+    name: browser integration tests (APS/TSJS conformance)
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up APS/TSJS browser test runtime
+        id: shared-setup
+        uses: ./.github/actions/setup-integration-test-env
+        with:
+          origin-port: ${{ env.ORIGIN_PORT }}
+          install-viceroy: "true"
+          build-wasm: "false"
+          build-axum: "false"
+          build-test-images: "false"
+          build-cloudflare: "false"
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.shared-setup.outputs.node-version }}
+          cache: npm
+          cache-dependency-path: |
+            crates/trusted-server-integration-tests/browser/package-lock.json
+            crates/trusted-server-js/lib/package-lock.json
+
+      - name: Run focused APS/TSJS three-browser conformance matrix
+        env:
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+          TS_BROWSER_FRAMEWORKS: nextjs
+          TS_BROWSER_PROJECTS: chromium,firefox,webkit
+        run: ./scripts/integration-tests-browser.sh tests/shared/aps-renderer.spec.ts tests/shared/aps-puc-lifecycle.spec.ts tests/shared/tsjs-runtime.spec.ts tests/shared/tsjs-policy.spec.ts tests/shared/creative-sandbox.spec.ts tests/nextjs/gpt-diagnostics.spec.ts tests/nextjs/navigation.spec.ts --project=chromium --project=firefox --project=webkit
+
+      - name: Upload APS/TSJS Playwright report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: playwright-report-aps-tsjs-conformance
+          path: crates/trusted-server-integration-tests/browser/playwright-report/
+          retention-days: 7
+
+  cutover-suite:
+    name: exact APS/TSJS integration evidence
+    if: github.event_name == 'workflow_dispatch' && startsWith(inputs.evidence_id, 'aps-tsjs-cutover-')
+    runs-on: ubuntu-24.04
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up the complete integration environment
+        id: shared-setup
+        uses: ./.github/actions/setup-integration-test-env
+        with:
+          origin-port: ${{ env.ORIGIN_PORT }}
+          install-viceroy: "true"
+          build-cloudflare: "true"
+
+      - name: Set up pinned Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.shared-setup.outputs.node-version }}
+          cache: npm
+          cache-dependency-path: |
+            crates/trusted-server-js/lib/package-lock.json
+            crates/trusted-server-integration-tests/browser/package-lock.json
+
+      - name: Install exact integration runtimes
+        run: npm install -g wrangler@4.64.0
+
+      - name: Install pinned Spin
+        uses: fermyon/actions/spin/setup@v1
+        with:
+          version: "v4.0.2"
+
+      - name: Generate integration Viceroy configs
+        run: ./scripts/generate-integration-viceroy-configs.sh
+        env:
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+
+      - name: Build and validate the exact TSJS release
+        env:
+          EXPECTED_RELEASE_ID: ${{ inputs.release_id }}
+        shell: bash
+        run: bash scripts/ci/aps-tsjs-cutover.sh build-release
+
+      - name: Run route parity and the full adapter integration suite
+        env:
+          WASM_BINARY_PATH: ${{ github.workspace }}/target/wasm32-wasip1/release/trusted-server-adapter-fastly.wasm
+          AXUM_BINARY_PATH: ${{ github.workspace }}/target/debug/trusted-server-axum
+          CLOUDFLARE_WRANGLER_DIR: ${{ github.workspace }}/crates/trusted-server-adapter-cloudflare
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+          VICEROY_CONFIG_PATH: ${{ env.ARTIFACTS_DIR }}/configs/viceroy.toml
+          RUST_LOG: info
+        shell: bash
+        run: bash scripts/ci/aps-tsjs-cutover.sh run-adapters
+
+      - name: Install Chromium, Firefox, and WebKit
+        run: bash scripts/ci/aps-tsjs-cutover.sh install-browsers
+
+      - name: Run the focused three-browser APS/TSJS matrix
+        env:
+          WASM_BINARY_PATH: ${{ github.workspace }}/target/wasm32-wasip1/release/trusted-server-adapter-fastly.wasm
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+          VICEROY_CONFIG_PATH: ${{ env.ARTIFACTS_DIR }}/configs/viceroy.toml
+          TEST_FRAMEWORK: nextjs
+          TS_BROWSER_PROJECTS: chromium,firefox,webkit
+        shell: bash
+        run: bash scripts/ci/aps-tsjs-cutover.sh run-browser
+
+      - name: Run the APS runner-proxy corpus on every adapter
+        shell: bash
+        run: bash scripts/ci/aps-tsjs-cutover.sh run-proxies
+        env:
+          INTEGRATION_ORIGIN_PORT: ${{ env.ORIGIN_PORT }}
+          RUST_LOG: info
+
+      - name: Write exact integration evidence manifest
+        env:
+          EVIDENCE_ID: ${{ inputs.evidence_id }}
+          RELEASE_ID: ${{ inputs.release_id }}
+          PREVIOUS_ARTIFACT_ID: ${{ inputs.previous_artifact_id }}
+        run: node scripts/ci/aps-tsjs-evidence.mjs write-integration
+
+      - name: Scrub all integration evidence before upload
+        env:
+          INTEGRATION_AUTHORIZATION: integration-test-proxy-secret
+        run: node scripts/ci/aps-tsjs-evidence.mjs scrub-integration
+
+      - name: Upload exact integration evidence
+        uses: actions/upload-artifact@v4
+        with:
+          name: aps-tsjs-cutover-${{ github.sha }}
+          path: target/aps-tsjs-cutover-evidence/
+          if-no-files-found: error
+          retention-days: 30
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 1f1bbe27a..cc46491d6 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -1,4 +1,6 @@
 name: "Run Tests"
+run-name: >-
+  Run Tests / ${{ inputs.evidence_id || format('PR {0}', github.event.pull_request.number) }}
 
 permissions:
   contents: read
@@ -7,6 +9,16 @@ on:
   push:
     branches: [main]
   pull_request:
+  workflow_dispatch:
+    inputs:
+      evidence_id:
+        description: Unique cutover evidence identifier
+        required: true
+        type: string
+      release_id:
+        description: Exact generated TSJS release id
+        required: true
+        type: string
 
 jobs:
   test-rust:
@@ -248,6 +260,8 @@ jobs:
         working-directory: crates/trusted-server-js/lib
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Retrieve Node.js version
         id: node-version
@@ -268,5 +282,98 @@ jobs:
       - name: Build bundle
         run: npm run build
 
+      - name: Build pure external Prebid artifact
+        run: npm run build:prebid-external
+
+      - name: Verify release inventory
+        run: npm run test:release
+
+      - name: Enforce bundle budgets
+        run: npm run check:bundle
+
+      - name: Typecheck full TSJS package
+        run: npm run typecheck
+
+      - name: Lint full TSJS package
+        run: npm run lint
+
+      - name: Verify generated APS renderer contract
+        run: npm run check:aps-contract
+
+      - name: Verify APS/TSJS gate scripts
+        working-directory: ${{ github.workspace }}
+        run: bash scripts/ci/aps-tsjs-quality.sh contracts
+
+      - name: Enforce hard-cutover absence
+        run: npm run check:hard-cutover-absence
+
+      - name: Run embedded APS renderer contract
+        run: node --test test/contract/aps-renderer-es5.test.mjs
+
+      - name: Verify retired concept audit
+        run: npm run check:concept-audit
+
       - name: Run unit tests
         run: npm test -- --run
+
+  cutover-quality-evidence:
+    name: APS/TSJS cutover quality evidence
+    if: github.event_name == 'workflow_dispatch'
+    needs:
+      - test-rust
+      - test-axum
+      - test-cloudflare
+      - test-spin
+      - test-parity
+      - test-cli
+      - test-typescript
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Read repository toolchain pins
+        id: toolchains
+        shell: bash
+        run: bash scripts/ci/read-toolchains.sh
+
+      - name: Set up pinned Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.toolchains.outputs.node }}
+          cache: npm
+          cache-dependency-path: |
+            crates/trusted-server-js/lib/package-lock.json
+            docs/package-lock.json
+
+      - name: Set up pinned Rust quality targets
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ steps.toolchains.outputs.rust }}
+          components: clippy, rustfmt
+          target: wasm32-wasip1,wasm32-unknown-unknown
+          cache-shared-key: cargo-${{ runner.os }}-aps-tsjs-quality
+
+      - name: Install exact JavaScript dependencies
+        run: bash scripts/ci/aps-tsjs-quality.sh install
+
+      - name: Validate release id and run final quality gates
+        env:
+          EXPECTED_RELEASE_ID: ${{ inputs.release_id }}
+        shell: bash
+        run: bash scripts/ci/aps-tsjs-quality.sh run
+
+      - name: Write exact quality evidence manifest
+        env:
+          EVIDENCE_ID: ${{ inputs.evidence_id }}
+          RELEASE_ID: ${{ inputs.release_id }}
+        run: node scripts/ci/aps-tsjs-evidence.mjs write-quality
+
+      - name: Upload exact quality evidence
+        uses: actions/upload-artifact@v4
+        with:
+          name: aps-tsjs-quality-${{ github.run_id }}
+          path: target/aps-tsjs-quality-evidence/
+          if-no-files-found: error
+          retention-days: 30
diff --git a/.github/workflows/tsjs-performance-gate.yml b/.github/workflows/tsjs-performance-gate.yml
new file mode 100644
index 000000000..f2e9535ec
--- /dev/null
+++ b/.github/workflows/tsjs-performance-gate.yml
@@ -0,0 +1,137 @@
+name: "TSJS Performance Gate"
+run-name: >-
+  TSJS Performance Gate / ${{ inputs.evidence_id || format('tsjs-pr-{0}', github.run_id) }} / ${{ inputs.mode || 'pull-request' }}
+
+permissions:
+  contents: read
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/tsjs-performance-gate.yml"
+      - ".tool-versions"
+      - "Cargo.toml"
+      - "Cargo.lock"
+      - "crates/trusted-server-core/**"
+      - "crates/trusted-server-core/src/auction/**"
+      - "crates/trusted-server-core/src/html_processor.rs"
+      - "crates/trusted-server-core/src/publisher.rs"
+      - "crates/trusted-server-core/src/tsjs.rs"
+      - "crates/trusted-server-integration-tests/Cargo.toml"
+      - "crates/trusted-server-integration-tests/browser/**"
+      - "crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs"
+      - "crates/trusted-server-js/**"
+      - "scripts/ci/read-toolchains.sh"
+      - "scripts/ci/tsjs-performance.sh"
+      - "scripts/validate-tsjs-performance-evidence.mjs"
+  workflow_dispatch:
+    inputs:
+      base_sha:
+        description: Exact pull-request base commit reachable from origin/rc/202608
+        required: true
+        type: string
+      evidence_id:
+        description: Unique identifier bound to the uploaded evidence
+        required: true
+        type: string
+      mode:
+        description: Cutover side measured by this run
+        required: true
+        type: choice
+        options:
+          - preswitch
+          - postswitch
+  workflow_call:
+    inputs:
+      base_sha:
+        description: Exact pull-request base commit reachable from origin/rc/202608
+        required: true
+        type: string
+      evidence_id:
+        description: Unique identifier bound to the uploaded evidence
+        required: true
+        type: string
+      mode:
+        description: Cutover side measured by this run (preswitch or postswitch)
+        required: true
+        type: string
+
+env:
+  TSJS_PERF_MACHINE_CLASS: github-hosted:ubuntu-24.04
+  TSJS_PERF_RUNNER_IMAGE: ubuntu-24.04
+  TSJS_PERF_WORKFLOW_NAME: TSJS Performance Gate
+  TSJS_PERF_WORKFLOW_FILE: .github/workflows/tsjs-performance-gate.yml
+  TSJS_PERF_HEAD_SHA: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+  TSJS_PERF_BASE_SHA: ${{ github.event_name == 'pull_request' && github.event.pull_request.base.sha || inputs.base_sha }}
+
+jobs:
+  measure:
+    name: measure ${{ inputs.mode || 'pull-request' }} (${{ inputs.evidence_id || format('tsjs-pr-{0}', github.run_id) }})
+    runs-on: ubuntu-24.04
+    timeout-minutes: 50
+    env:
+      TSJS_EVIDENCE_ID: ${{ inputs.evidence_id || format('tsjs-pr-{0}', github.run_id) }}
+      TSJS_PERF_MODE: ${{ inputs.mode || 'pull-request' }}
+      TSJS_PERF_ARTIFACT_NAME: tsjs-performance-${{ inputs.evidence_id || format('tsjs-pr-{0}', github.run_id) }}
+      TSJS_PERF_OUTPUT: crates/trusted-server-integration-tests/browser/test-results/tsjs-performance-${{ inputs.mode || 'pull-request' }}.json
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
+
+      - name: Validate immutable measurement inputs
+        shell: bash
+        run: bash scripts/ci/tsjs-performance.sh validate-inputs
+
+      - name: Read repository toolchain pins
+        id: toolchains
+        shell: bash
+        run: bash scripts/ci/read-toolchains.sh
+
+      - name: Set up pinned Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ steps.toolchains.outputs.node }}
+          cache: npm
+          cache-dependency-path: |
+            crates/trusted-server-js/lib/package-lock.json
+            crates/trusted-server-integration-tests/browser/package-lock.json
+
+      - name: Set up pinned Rust for the generated controller fixture
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ steps.toolchains.outputs.rust }}
+          cache-shared-key: cargo-${{ runner.os }}-tsjs-performance
+
+      - name: Verify installed toolchain pins
+        shell: bash
+        run: bash scripts/ci/tsjs-performance.sh verify-toolchains
+
+      - name: Build the real TSJS artifacts once
+        run: bash scripts/ci/tsjs-performance.sh build-candidate
+
+      - name: Build the exact rc baseline artifacts
+        shell: bash
+        run: bash scripts/ci/tsjs-performance.sh build-baseline
+
+      - name: Install the lockfile-pinned Chromium setup
+        run: bash scripts/ci/tsjs-performance.sh install-browser
+
+      - name: Run the complete TSJS performance sample exactly once
+        env:
+          CI: "true"
+        run: bash scripts/ci/tsjs-performance.sh run-sample
+
+      - name: Validate the generated evidence before upload
+        if: always()
+        run: bash scripts/ci/tsjs-performance.sh validate-evidence
+
+      - name: Upload immutable TSJS performance evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.TSJS_PERF_ARTIFACT_NAME }}
+          path: ${{ env.TSJS_PERF_OUTPUT }}
+          if-no-files-found: error
+          retention-days: 30
diff --git a/.tool-versions b/.tool-versions
index 758146800..5330e3de6 100644
--- a/.tool-versions
+++ b/.tool-versions
@@ -1,5 +1,5 @@
 fastly 15.1.0
 rust 1.95.0
 nodejs 24.12.0
-viceroy 0.17.0
+viceroy 0.19.0
 wasmtime 44.0.1
diff --git a/CLAUDE.md b/CLAUDE.md
index 546a3bf52..dd1c4041f 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -36,7 +36,7 @@ Supporting files: `edgezero.toml`, `fastly.toml`,
 | WASM target | `wasm32-wasip1`                          |
 | Node        | 24.12.0 (from `.tool-versions`)          |
 | Fastly CLI  | 15.1.0 (from `.tool-versions`)           |
-| Viceroy     | 0.17.0 (from `.tool-versions`)           |
+| Viceroy     | 0.19.0 (from `.tool-versions`)           |
 | Wasmtime    | 44.0.1 (from `.tool-versions`)           |
 
 ---
@@ -139,7 +139,7 @@ cd crates/trusted-server-js/lib && node build-all.mjs
 ### Install prerequisites
 
 ```bash
-cargo install viceroy --version 0.17.0 --locked --force
+cargo install viceroy --version 0.19.0 --locked --force
 ```
 
 ---
diff --git a/Cargo.lock b/Cargo.lock
index ab29df9fa..ce4593339 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5402,6 +5402,7 @@ dependencies = [
  "trusted-server-core",
  "url",
  "urlencoding",
+ "web-time",
 ]
 
 [[package]]
@@ -5537,6 +5538,7 @@ dependencies = [
  "reqwest 0.12.28",
  "scraper",
  "serde_json",
+ "tempfile",
  "testcontainers",
  "tokio",
  "toml",
@@ -5554,6 +5556,8 @@ version = "0.1.0"
 dependencies = [
  "build-print",
  "hex",
+ "serde",
+ "serde_json",
  "sha2 0.10.9",
  "which",
 ]
diff --git a/crates/trusted-server-adapter-axum/Cargo.toml b/crates/trusted-server-adapter-axum/Cargo.toml
index 15b6ee59d..ab9a72942 100644
--- a/crates/trusted-server-adapter-axum/Cargo.toml
+++ b/crates/trusted-server-adapter-axum/Cargo.toml
@@ -18,8 +18,13 @@ path = "src/lib.rs"
 name = "trusted-server-axum"
 path = "src/main.rs"
 
+[features]
+default = []
+aps-runner-proxy-integration-test = ["trusted-server-core/test-utils"]
+
 [dependencies]
 async-trait = { workspace = true }
+axum = { workspace = true }
 edgezero-adapter-axum = { workspace = true, features = ["axum"] }
 edgezero-core = { workspace = true }
 error-stack = { workspace = true }
@@ -31,7 +36,6 @@ tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "ti
 trusted-server-core = { workspace = true }
 
 [dev-dependencies]
-axum = { workspace = true }
 base64 = { workspace = true }
 temp-env = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
diff --git a/crates/trusted-server-adapter-axum/src/app.rs b/crates/trusted-server-adapter-axum/src/app.rs
index 1deddcab5..03ecf5704 100644
--- a/crates/trusted-server-adapter-axum/src/app.rs
+++ b/crates/trusted-server-adapter-axum/src/app.rs
@@ -26,8 +26,8 @@ use trusted_server_core::proxy::{
     handle_first_party_proxy_sign,
 };
 use trusted_server_core::publisher::{
-    AuctionDispatch, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, buffer_publisher_response_async,
-    handle_page_bids, handle_publisher_request, handle_tsjs_dynamic, page_bids_preflight_denied,
+    AuctionDispatch, PAGE_BIDS_PATH, buffer_publisher_response_async, handle_page_bids,
+    handle_publisher_request, handle_tsjs_dynamic, page_bids_preflight_denied,
 };
 use trusted_server_core::request_signing::{
     handle_trusted_server_discovery, handle_verify_signature,
@@ -36,6 +36,7 @@ use trusted_server_core::settings::Settings;
 use trusted_server_core::settings_data::{
     default_config_key, default_config_store_name, get_settings_from_config_store,
 };
+use trusted_server_core::trace_cookie::handle_trace_mode;
 
 use trusted_server_core::platform::RuntimeServices;
 
@@ -93,6 +94,91 @@ fn build_state_with_settings(
     }))
 }
 
+async fn dispatch_reserved_for_state(state: &Arc<AppState>, req: Request) -> Option<Response> {
+    if !state.registry.has_reserved_path(req.uri().path()) {
+        return None;
+    }
+    let ctx = RequestContext::new(req, edgezero_core::params::PathParams::default());
+    let services = build_runtime_services(&ctx);
+    Some(
+        state
+            .registry
+            .handle_reserved_proxy(&state.settings, &services, ctx.into_request())
+            .await
+            .expect("reserved path should have a hard-cutover handler")
+            .unwrap_or_else(|report| http_error(&report)),
+    )
+}
+
+#[derive(Clone)]
+/// Dispatcher that owns one startup-built registry for hard-cutover route families.
+pub struct ReservedApsDispatcher {
+    state: Arc<AppState>,
+}
+
+impl ReservedApsDispatcher {
+    /// Build the dispatcher from the adapter's startup settings.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when settings, the orchestrator, or the integration
+    /// registry cannot be initialized.
+    pub fn from_startup_settings() -> Result<Self, Report<TrustedServerError>> {
+        // The outer Axum router cannot share EdgeZero's private application
+        // state, so the dev adapter builds one additional immutable startup
+        // snapshot for only the two reserved APS browser resources. Production
+        // adapters do not take this native development path.
+        Ok(Self {
+            state: build_state()?,
+        })
+    }
+
+    /// Build the dispatcher from explicit settings.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when the orchestrator or integration registry cannot be
+    /// initialized from `settings`.
+    pub fn from_settings(settings: Settings) -> Result<Self, Report<TrustedServerError>> {
+        Ok(Self {
+            state: build_state_with_settings(settings)?,
+        })
+    }
+
+    /// Dispatch a request when it belongs to the reserved APS family.
+    pub async fn dispatch(&self, req: Request) -> Option<Response> {
+        dispatch_reserved_for_state(&self.state, req).await
+    }
+}
+
+/// Dispatch a reserved APS request using explicit settings.
+///
+/// # Errors
+///
+/// Returns an error when the dispatcher cannot be initialized.
+pub async fn dispatch_reserved_with_settings(
+    settings: Settings,
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    Ok(ReservedApsDispatcher::from_settings(settings)?
+        .dispatch(req)
+        .await)
+}
+
+/// Dispatch a reserved APS request using startup settings.
+///
+/// # Errors
+///
+/// Returns an error when startup settings or the dispatcher
+/// cannot be initialized.
+pub async fn dispatch_reserved(
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    Ok(ReservedApsDispatcher::from_startup_settings()?
+        .dispatch(req)
+        .await)
+}
+
 // ---------------------------------------------------------------------------
 // Error helper
 // ---------------------------------------------------------------------------
@@ -200,7 +286,7 @@ async fn dispatch_fallback(
     let path = req.uri().path().to_string();
     let method = req.method().clone();
 
-    if method == Method::GET && path.starts_with("/static/tsjs=") {
+    if path.starts_with("/static/tsjs=") {
         return handle_tsjs_dynamic(&req, &state.registry, EdgeCacheHeader::SMaxageFallback);
     }
 
@@ -283,6 +369,7 @@ enum NamedRouteHandler {
     /// Legacy `/admin/keys/*` aliases — denied locally with 404 so they never
     /// reach the publisher fallback (which would leak admin credentials).
     LegacyAdminDenied,
+    TraceMode,
     Auction,
     PageBids,
     FirstPartyProxy,
@@ -307,7 +394,7 @@ const LEGACY_ADMIN_DENY_METHODS: &[Method] = &[
     Method::DELETE,
 ];
 
-fn named_routes() -> [NamedRoute; 16] {
+fn named_routes() -> [NamedRoute; 17] {
     [
         NamedRoute {
             path: "/.well-known/trusted-server.json",
@@ -368,6 +455,11 @@ fn named_routes() -> [NamedRoute; 16] {
             primary_methods: LEGACY_ADMIN_DENY_METHODS,
             handler: NamedRouteHandler::LegacyAdminDenied,
         },
+        NamedRoute {
+            path: "/_ts/trace",
+            primary_methods: &[Method::GET],
+            handler: NamedRouteHandler::TraceMode,
+        },
         NamedRoute {
             path: "/auction",
             primary_methods: &[Method::POST],
@@ -380,13 +472,12 @@ fn named_routes() -> [NamedRoute; 16] {
             primary_methods: &[Method::GET, Method::OPTIONS],
             handler: NamedRouteHandler::PageBids,
         },
-        // Deprecated double-underscore alias, kept so tsjs bundles served before
-        // the `/_ts/page-bids` rename keep getting ads on SPA navigations until
-        // they age out of browser caches. See `PAGE_BIDS_LEGACY_PATH`.
+        // This removed route must never reach the publisher fallback, which
+        // would make the hard cutover depend on the origin response.
         NamedRoute {
-            path: PAGE_BIDS_LEGACY_PATH,
-            primary_methods: &[Method::GET, Method::OPTIONS],
-            handler: NamedRouteHandler::PageBids,
+            path: "/__ts/page-bids",
+            primary_methods: LEGACY_ADMIN_DENY_METHODS,
+            handler: NamedRouteHandler::LegacyAdminDenied,
         },
         NamedRoute {
             path: "/first-party/proxy",
@@ -459,6 +550,9 @@ fn named_route_handler(
                         handle_admin_eids_lookup(&partner_registry, &req)
                     }
                     NamedRouteHandler::LegacyAdminDenied => Ok(legacy_admin_alias_denied()),
+                    NamedRouteHandler::TraceMode => {
+                        handle_trace_mode(&state.settings, req.uri().query())
+                    }
                     NamedRouteHandler::Auction => {
                         // Build the geo-aware EC context so the auction consent
                         // gate sees the caller's jurisdiction — `EcContext::default()`
diff --git a/crates/trusted-server-adapter-axum/src/main.rs b/crates/trusted-server-adapter-axum/src/main.rs
index 960982176..2899a22ac 100644
--- a/crates/trusted-server-adapter-axum/src/main.rs
+++ b/crates/trusted-server-adapter-axum/src/main.rs
@@ -1,9 +1,14 @@
-use edgezero_adapter_axum::dev_server::{AxumDevServer, AxumDevServerConfig};
+use edgezero_adapter_axum::dev_server::AxumDevServerConfig;
 use edgezero_core::app::Hooks as _;
 use trusted_server_adapter_axum::app::TrustedServerApp;
 
+#[tokio::main]
 #[allow(clippy::print_stderr)]
-fn main() {
+async fn main() {
+    use axum::Router;
+    use axum::routing::any;
+    use edgezero_adapter_axum::service::EdgeZeroAxumService;
+
     if let Err(e) = simple_logger::SimpleLogger::new().init() {
         eprintln!("warning: logger init failed: {e}");
     }
@@ -19,11 +24,65 @@ fn main() {
         None => AxumDevServerConfig::default(),
     };
 
+    let dispatcher =
+        trusted_server_adapter_axum::app::ReservedApsDispatcher::from_startup_settings()
+            .expect("should build the reserved APS dispatcher");
+    let reserved = any(move |request: axum::http::Request<axum::body::Body>| {
+        let dispatcher = dispatcher.clone();
+        async move {
+            // The core reserved dispatcher is intentionally `?Send`, while this
+            // native-only development adapter runs on Tokio's multi-threaded
+            // executor. Keep that bridge explicit: a runner request can occupy
+            // this blocking-pool thread for its bounded five-second budget.
+            let response = tokio::task::block_in_place(|| {
+                tokio::runtime::Handle::current().block_on(async move {
+                    let request =
+                        match edgezero_adapter_axum::request::into_core_request(request).await {
+                            Ok(request) => request,
+                            Err(error) => {
+                                log::warn!("reserved APS request conversion failed: {error:?}");
+                                return Err(axum::http::StatusCode::BAD_REQUEST);
+                            }
+                        };
+                    match dispatcher.dispatch(request).await {
+                        Some(response) => Ok(response),
+                        None => {
+                            log::error!(
+                                "reserved APS entry route reached a request outside its family"
+                            );
+                            Err(axum::http::StatusCode::INTERNAL_SERVER_ERROR)
+                        }
+                    }
+                })
+            });
+            match response {
+                Ok(response) => edgezero_adapter_axum::response::into_axum_response(response),
+                Err(status) => axum::response::IntoResponse::into_response(status),
+            }
+        }
+    });
+    let app = Router::new()
+        .route("/integrations/aps", reserved.clone())
+        .route("/integrations/aps/{*rest}", reserved)
+        .fallback_service(EdgeZeroAxumService::new(TrustedServerApp::routes()));
+    let listener = tokio::net::TcpListener::bind(config.addr)
+        .await
+        .expect("should bind the configured address");
     log::info!("Listening on http://{}", config.addr);
-    let router = TrustedServerApp::routes();
-    if let Err(err) = AxumDevServer::with_config(router, config).run() {
-        log::error!("trusted-server-adapter-axum failed: {err}");
-        std::process::exit(1);
+    let server = axum::serve(listener, app);
+    let result = if config.enable_ctrl_c {
+        server
+            .with_graceful_shutdown(async {
+                if let Err(error) = tokio::signal::ctrl_c().await {
+                    log::error!("failed to install Ctrl-C handler: {error}");
+                }
+            })
+            .await
+    } else {
+        server.await
+    };
+    if let Err(error) = result {
+        log::error!("trusted-server-adapter-axum failed: {error}");
     }
 }
 
diff --git a/crates/trusted-server-adapter-axum/src/platform.rs b/crates/trusted-server-adapter-axum/src/platform.rs
index 7dcdd53d8..24c5c360e 100644
--- a/crates/trusted-server-adapter-axum/src/platform.rs
+++ b/crates/trusted-server-adapter-axum/src/platform.rs
@@ -12,6 +12,7 @@ use trusted_server_core::platform::{
     BackendNamingPolicy, ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec,
     PlatformConfigStore, PlatformError, PlatformGeo, PlatformHttpClient, PlatformHttpRequest,
     PlatformPendingRequest, PlatformResponse, PlatformSecretStore, PlatformSelectResult,
+    ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1,
     RuntimeServices, StoreId, StoreName,
 };
 
@@ -277,6 +278,9 @@ pub struct AxumPlatformHttpClient {
     client: reqwest::Client,
 }
 
+#[cfg(feature = "aps-runner-proxy-integration-test")]
+const APS_RUNNER_PROXY_TEST_ENDPOINT_ENV: &str = "TS_APS_RUNNER_PROXY_TEST_ENDPOINT";
+
 impl AxumPlatformHttpClient {
     /// Create a new client with sensible dev-server timeouts.
     ///
@@ -299,6 +303,38 @@ impl AxumPlatformHttpClient {
         }
     }
 
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    fn aps_runner_proxy_test_transport_uri(
+        logical_uri: &str,
+    ) -> Result<Option<String>, Report<PlatformError>> {
+        use trusted_server_core::integrations::aps::APS_RUNNER_UPSTREAM_URL;
+
+        if logical_uri != APS_RUNNER_UPSTREAM_URL {
+            return Ok(None);
+        }
+        let endpoint = std::env::var(APS_RUNNER_PROXY_TEST_ENDPOINT_ENV).map_err(|_| {
+            Report::new(PlatformError::HttpClient).attach(
+                "APS runner proxy integration artifact requires its loopback fixture endpoint",
+            )
+        })?;
+        let parsed = reqwest::Url::parse(&endpoint)
+            .change_context(PlatformError::HttpClient)
+            .attach("invalid APS runner proxy integration fixture endpoint")?;
+        if parsed.scheme() != "http"
+            || !matches!(parsed.host_str(), Some("127.0.0.1" | "::1"))
+            || parsed.port().is_none()
+            || !parsed.username().is_empty()
+            || parsed.password().is_some()
+            || parsed.query().is_some()
+            || parsed.fragment().is_some()
+        {
+            return Err(Report::new(PlatformError::HttpClient).attach(
+                "APS runner proxy integration fixture endpoint must be an explicit loopback HTTP URL",
+            ));
+        }
+        Ok(Some(parsed.into()))
+    }
+
     /// Drain `body` to a `Vec<u8>`.
     ///
     /// For `Body::Stream` this awaits every chunk in the current async context
@@ -372,6 +408,127 @@ impl AxumPlatformHttpClient {
 
         Ok(PlatformResponse::new(edge_resp).with_backend_name(request.backend_name))
     }
+
+    fn raw_header_evidence(
+        headers: &reqwest::header::HeaderMap,
+        name: reqwest::header::HeaderName,
+    ) -> ProxyHeaderEvidenceV1 {
+        ProxyHeaderEvidenceV1::Occurrences(
+            headers
+                .get_all(name)
+                .iter()
+                .map(|value| value.as_bytes().to_vec())
+                .collect(),
+        )
+    }
+
+    fn canonical_declared_length(evidence: &ProxyHeaderEvidenceV1) -> Option<usize> {
+        let ProxyHeaderEvidenceV1::Occurrences(values) = evidence else {
+            return None;
+        };
+        let [value] = values.as_slice() else {
+            return None;
+        };
+        if value.is_empty()
+            || !value.iter().all(u8::is_ascii_digit)
+            || (value.len() > 1 && value[0] == b'0')
+        {
+            return None;
+        }
+        std::str::from_utf8(value).ok()?.parse().ok()
+    }
+
+    async fn execute_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        if request.image_optimizer.is_some() || request.stream_response {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("unsupported option on Axum raw proxy request"));
+        }
+
+        let logical_uri = request.request.uri().to_string();
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let transport_uri = Self::aps_runner_proxy_test_transport_uri(&logical_uri)?;
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let uri = transport_uri.as_deref().unwrap_or(&logical_uri);
+        #[cfg(not(feature = "aps-runner-proxy-integration-test"))]
+        let uri = logical_uri.as_str();
+        let method = reqwest::Method::from_bytes(request.request.method().as_str().as_bytes())
+            .change_context(PlatformError::HttpClient)?;
+        let mut builder = self.client.request(method, uri);
+        for (name, value) in request.request.headers() {
+            builder = builder.header(name.as_str(), value.as_bytes());
+        }
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        if transport_uri.is_some() {
+            builder = builder
+                .header(reqwest::header::HOST, "client.aps.amazon-adsystem.com")
+                .header("x-ts-aps-logical-url", logical_uri.as_str());
+        }
+        let (_, request_body) = request.request.into_parts();
+        let request_body = Self::buffer_body(request_body).await?;
+        if !request_body.is_empty() {
+            builder = builder.body(request_body);
+        }
+
+        tokio::time::timeout(policy.total_timeout, async move {
+            let mut response = tokio::time::timeout(policy.first_byte_timeout, builder.send())
+                .await
+                .map_err(|_| {
+                    Report::new(PlatformError::HttpClient)
+                        .attach("raw proxy first-byte deadline exceeded")
+                })?
+                .change_context(PlatformError::HttpClient)?;
+            let evidence = ProxyResponseEvidenceV1 {
+                status: response.status().as_u16(),
+                content_type: Self::raw_header_evidence(
+                    response.headers(),
+                    reqwest::header::CONTENT_TYPE,
+                ),
+                content_encoding: Self::raw_header_evidence(
+                    response.headers(),
+                    reqwest::header::CONTENT_ENCODING,
+                ),
+                content_length: Self::raw_header_evidence(
+                    response.headers(),
+                    reqwest::header::CONTENT_LENGTH,
+                ),
+            };
+            if Self::canonical_declared_length(&evidence.content_length)
+                .is_some_and(|length| length > policy.max_response_bytes)
+            {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy declared body exceeds configured cap"));
+            }
+
+            let mut body = Vec::new();
+            loop {
+                let chunk = tokio::time::timeout(policy.blocking_read_timeout, response.chunk())
+                    .await
+                    .map_err(|_| {
+                        Report::new(PlatformError::HttpClient)
+                            .attach("raw proxy blocking-read deadline exceeded")
+                    })?
+                    .change_context(PlatformError::HttpClient)?;
+                let Some(chunk) = chunk else { break };
+                let next_len = body.len().checked_add(chunk.len()).ok_or_else(|| {
+                    Report::new(PlatformError::HttpClient).attach("raw proxy body length overflow")
+                })?;
+                if next_len > policy.max_response_bytes {
+                    return Err(Report::new(PlatformError::HttpClient)
+                        .attach("raw proxy body exceeds configured cap"));
+                }
+                body.extend_from_slice(&chunk);
+            }
+            Ok(RawProxyResponseV1 { evidence, body })
+        })
+        .await
+        .map_err(|_| {
+            Report::new(PlatformError::HttpClient).attach("raw proxy total deadline exceeded")
+        })?
+    }
 }
 
 impl Default for AxumPlatformHttpClient {
@@ -389,6 +546,14 @@ impl PlatformHttpClient for AxumPlatformHttpClient {
         self.execute(request).await
     }
 
+    async fn send_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        self.execute_raw_proxy_v1(request, policy).await
+    }
+
     async fn send_async(
         &self,
         request: PlatformHttpRequest,
@@ -790,6 +955,223 @@ mod tests {
         );
     }
 
+    fn raw_proxy_request(url: &str) -> PlatformHttpRequest {
+        PlatformHttpRequest::new(
+            edgezero_core::http::request_builder()
+                .uri(url)
+                .header(header::ACCEPT_ENCODING, "identity")
+                .body(EdgeBody::empty())
+                .expect("should build raw proxy request"),
+            "test_backend",
+        )
+    }
+
+    fn raw_proxy_policy(timeout: Duration, max_response_bytes: usize) -> RawProxyPolicyV1 {
+        RawProxyPolicyV1 {
+            total_timeout: timeout,
+            first_byte_timeout: timeout,
+            blocking_read_timeout: timeout,
+            max_response_bytes,
+        }
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn raw_proxy_preserves_header_occurrences_and_exact_bytes() {
+        let url = serve_raw_response(
+            b"HTTP/1.1 200 OK\r\n\
+              Content-Type: application/javascript\r\n\
+              Content-Encoding: identity\r\n\
+              Content-Length: 2\r\n\
+              Set-Cookie: must-not-enter-core=1\r\n\
+              \r\n\
+              ok",
+        )
+        .await;
+
+        let response = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&url),
+                raw_proxy_policy(Duration::from_secs(1), 2),
+            )
+            .await
+            .expect("valid raw response should be collected");
+
+        assert_eq!(response.evidence.status, 200);
+        assert_eq!(
+            response.evidence.content_type,
+            ProxyHeaderEvidenceV1::one("application/javascript")
+        );
+        assert_eq!(
+            response.evidence.content_encoding,
+            ProxyHeaderEvidenceV1::one("identity")
+        );
+        assert_eq!(
+            response.evidence.content_length,
+            ProxyHeaderEvidenceV1::one("2")
+        );
+        assert_eq!(response.body, b"ok");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn raw_proxy_preserves_duplicate_security_headers_for_core_rejection() {
+        let url = serve_raw_response(
+            b"HTTP/1.1 200 OK\r\n\
+              Content-Type: application/javascript\r\n\
+              Content-Type: text/javascript\r\n\
+              Content-Length: 2\r\n\
+              \r\n\
+              ok",
+        )
+        .await;
+
+        let response = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&url),
+                raw_proxy_policy(Duration::from_secs(1), 2),
+            )
+            .await
+            .expect("transport should preserve duplicate evidence");
+
+        assert_eq!(
+            response.evidence.content_type,
+            ProxyHeaderEvidenceV1::Occurrences(vec![
+                b"application/javascript".to_vec(),
+                b"text/javascript".to_vec(),
+            ])
+        );
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn raw_proxy_cancels_on_body_overflow_and_total_deadline() {
+        let overflow_url = serve_raw_response(
+            b"HTTP/1.1 200 OK\r\n\
+              Content-Type: application/javascript\r\n\
+              Transfer-Encoding: chunked\r\n\
+              \r\n\
+              2\r\n\
+              ok\r\n\
+              0\r\n\
+              \r\n",
+        )
+        .await;
+        let overflow = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&overflow_url),
+                raw_proxy_policy(Duration::from_secs(1), 1),
+            )
+            .await;
+        assert!(overflow.is_err(), "one byte over the cap must fail");
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+            .await
+            .expect("should bind deadline test server");
+        let addr = listener.local_addr().expect("should read local address");
+        tokio::spawn(async move {
+            let (mut stream, _) = listener.accept().await.expect("should accept request");
+            let mut request = [0; 1024];
+            let _ = stream
+                .read(&mut request)
+                .await
+                .expect("should read request");
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            let _ = stream
+                .write_all(
+                    b"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: 2\r\n\r\nok",
+                )
+                .await;
+        });
+        let deadline = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&format!("http://{addr}/")),
+                raw_proxy_policy(Duration::from_millis(20), 2),
+            )
+            .await;
+        assert!(deadline.is_err(), "total deadline must cover first byte");
+    }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn raw_proxy_enforces_first_byte_and_blocking_read_deadlines() {
+        let first_byte_listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+            .await
+            .expect("should bind first-byte deadline server");
+        let first_byte_addr = first_byte_listener
+            .local_addr()
+            .expect("should read first-byte server address");
+        tokio::spawn(async move {
+            let (mut stream, _) = first_byte_listener
+                .accept()
+                .await
+                .expect("should accept first-byte request");
+            let mut request = [0; 1024];
+            let _ = stream
+                .read(&mut request)
+                .await
+                .expect("should read first-byte request");
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            let _ = stream
+                .write_all(
+                    b"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: 2\r\n\r\nok",
+                )
+                .await;
+        });
+        let first_byte = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&format!("http://{first_byte_addr}/")),
+                RawProxyPolicyV1 {
+                    total_timeout: Duration::from_secs(1),
+                    first_byte_timeout: Duration::from_millis(20),
+                    blocking_read_timeout: Duration::from_secs(1),
+                    max_response_bytes: 2,
+                },
+            )
+            .await;
+        assert!(
+            first_byte.is_err(),
+            "response headers after the first-byte deadline must fail"
+        );
+
+        let body_listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+            .await
+            .expect("should bind blocking-read deadline server");
+        let body_addr = body_listener
+            .local_addr()
+            .expect("should read blocking-read server address");
+        tokio::spawn(async move {
+            let (mut stream, _) = body_listener
+                .accept()
+                .await
+                .expect("should accept blocking-read request");
+            let mut request = [0; 1024];
+            let _ = stream
+                .read(&mut request)
+                .await
+                .expect("should read blocking-read request");
+            stream
+                .write_all(
+                    b"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nTransfer-Encoding: chunked\r\n\r\n1\r\no\r\n",
+                )
+                .await
+                .expect("should write first body chunk");
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            let _ = stream.write_all(b"1\r\nk\r\n0\r\n\r\n").await;
+        });
+        let blocking_read = AxumPlatformHttpClient::new()
+            .send_raw_proxy_v1(
+                raw_proxy_request(&format!("http://{body_addr}/")),
+                RawProxyPolicyV1 {
+                    total_timeout: Duration::from_secs(1),
+                    first_byte_timeout: Duration::from_secs(1),
+                    blocking_read_timeout: Duration::from_millis(20),
+                    max_response_bytes: 2,
+                },
+            )
+            .await;
+        assert!(
+            blocking_read.is_err(),
+            "a body read blocked past its deadline must fail"
+        );
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn select_attributes_failed_backend_name() {
         // Bind and immediately drop a listener so the port is closed — the
diff --git a/crates/trusted-server-adapter-axum/tests/routes.rs b/crates/trusted-server-adapter-axum/tests/routes.rs
index 6812b7421..458ed9217 100644
--- a/crates/trusted-server-adapter-axum/tests/routes.rs
+++ b/crates/trusted-server-adapter-axum/tests/routes.rs
@@ -26,6 +26,11 @@ fn test_settings() -> trusted_server_core::settings::Settings {
             username = "admin"
             password = "admin-pass"
 
+            [[handlers]]
+            path = "^/integrations/aps"
+            username = "aps-user"
+            password = "aps-pass"
+
             [publisher]
             domain = "test-publisher.example.com"
             cookie_domain = ".test-publisher.example.com"
@@ -34,6 +39,20 @@ fn test_settings() -> trusted_server_core::settings::Settings {
 
             [ec]
             passphrase = "test-secret-key-32-bytes-minimum"
+
+            [auction]
+            enabled = true
+            timeout_ms = 1000
+
+            [auction.providers.aps-main]
+            protocol = "openrtb-2.6"
+            profile = "aps"
+            endpoint = "https://aps.example/e/pb/bid"
+            routing = "all_eligible"
+
+            [auction.providers.aps-main.profile_config]
+            account_id = "route-test-aps-account"
+            allow_script_creatives = true
         "#,
     )
     .expect("should parse route test settings")
@@ -44,6 +63,18 @@ fn test_router() -> edgezero_core::router::RouterService {
         .expect("should build router from test settings")
 }
 
+async fn route_reserved(request: Request<AxumBody>) -> axum::http::Response<AxumBody> {
+    let request = edgezero_adapter_axum::request::into_core_request(request)
+        .await
+        .expect("should convert reserved APS request");
+    let response =
+        trusted_server_adapter_axum::app::dispatch_reserved_with_settings(test_settings(), request)
+            .await
+            .expect("should build APS dispatcher")
+            .expect("APS family should be reserved");
+    edgezero_adapter_axum::response::into_axum_response(response)
+}
+
 fn make_service() -> EdgeZeroAxumService {
     EdgeZeroAxumService::new(test_router())
 }
@@ -65,7 +96,7 @@ fn assert_route_registered(method: &str, path: &str) {
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn aps_profile_serves_renderer_through_adapter_fallback() {
+async fn aps_profile_serves_canonical_renderer_through_reserved_dispatcher() {
     let mut settings = test_settings();
     settings.auction.providers.insert(
         "aps-main".parse().expect("should parse APS provider ID"),
@@ -81,22 +112,19 @@ async fn aps_profile_serves_renderer_through_adapter_fallback() {
                 .expect("should parse APS profile config"),
         },
     );
-    let router = TrustedServerApp::routes_with_settings(settings)
-        .expect("should build router with APS profile");
-    let mut service = EdgeZeroAxumService::new(router);
     let request = Request::builder()
         .method("GET")
-        .uri("/integrations/aps/renderer")
+        .uri("/integrations/aps/renderer/v2")
         .body(AxumBody::empty())
         .expect("should build APS renderer request");
-
-    let response = service
-        .ready()
+    let request = edgezero_adapter_axum::request::into_core_request(request)
         .await
-        .expect("should be ready")
-        .call(request)
-        .await
-        .expect("should serve APS renderer");
+        .expect("should convert APS renderer request");
+    let response =
+        trusted_server_adapter_axum::app::dispatch_reserved_with_settings(settings, request)
+            .await
+            .expect("should build reserved APS dispatcher")
+            .expect("APS renderer should be reserved");
     assert_eq!(response.status().as_u16(), 200);
 }
 
@@ -118,16 +146,9 @@ fn all_explicit_routes_are_registered() {
         ("POST", "/admin/keys/rotate"),
         ("POST", "/admin/keys/deactivate"),
         ("POST", "/auction"),
-        // SPA re-auction endpoint, plus its deprecated `/__ts/` alias. Both
-        // paths are spelled out as literals rather than referencing
-        // `PAGE_BIDS_PATH` / `PAGE_BIDS_LEGACY_PATH` so this test pins the
-        // actual URL the tsjs client fetches — asserting a const against itself
-        // would still pass if the const's value changed out from under the
-        // client.
+        // Pin the canonical literal fetched by the hard-cutover client.
         ("GET", "/_ts/page-bids"),
         ("OPTIONS", "/_ts/page-bids"),
-        ("GET", "/__ts/page-bids"),
-        ("OPTIONS", "/__ts/page-bids"),
         ("GET", "/first-party/proxy"),
         ("GET", "/first-party/click"),
         ("GET", "/first-party/sign"),
@@ -139,6 +160,9 @@ fn all_explicit_routes_are_registered() {
     for (method, path) in expected {
         assert_route_registered(method, path);
     }
+    for method in LEGACY_ADMIN_DENY_METHODS {
+        assert_route_registered(method, "/__ts/page-bids");
+    }
 }
 
 /// Verify the legacy non-`/_ts` admin aliases ARE registered — to the local
@@ -250,39 +274,133 @@ async fn tsjs_route_prefix_is_handled_not_5xx() {
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn tsjs_route_matching_hash_uses_s_maxage_fallback() {
-    let mut svc = make_service();
-    let src = trusted_server_core::tsjs::tsjs_script_src(&["creative"]);
-    let req = Request::builder()
-        .method("GET")
-        .uri(src)
-        .body(AxumBody::empty())
-        .expect("should build request");
+async fn tsjs_wrong_methods_are_local_no_store_404s() {
+    for method in ["HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"] {
+        let req = Request::builder()
+            .method(method)
+            .uri(format!(
+                "/static/tsjs=tsjs-unified.min.js?v={}",
+                "0".repeat(64)
+            ))
+            .body(AxumBody::empty())
+            .expect("should build wrong-method TSJS request");
+        let response = make_service()
+            .oneshot(req)
+            .await
+            .expect("should reject TSJS request locally");
 
-    let resp = svc
-        .ready()
-        .await
-        .expect("should be ready")
-        .call(req)
-        .await
-        .expect("should respond");
+        assert_eq!(response.status().as_u16(), 404, "method {method}");
+        assert_eq!(
+            response
+                .headers()
+                .get("cache-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("no-store"),
+            "method {method}"
+        );
+        assert!(
+            !response.headers().contains_key("location"),
+            "method {method}"
+        );
+    }
+}
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn aps_cutover_renderer_and_family_failures_are_local() {
+    let renderer = Request::builder()
+        .method("GET")
+        .uri("/integrations/aps/renderer/v2")
+        .header("authorization", "Bearer must-not-reach-publisher")
+        .body(AxumBody::empty())
+        .expect("should build APS renderer request");
+    let response = route_reserved(renderer).await;
+    assert_eq!(response.status().as_u16(), 200);
     assert_eq!(
-        resp.status().as_u16(),
-        200,
-        "matching TSJS hash should serve OK"
+        response
+            .headers()
+            .get("content-type")
+            .and_then(|value| value.to_str().ok()),
+        Some("text/html; charset=utf-8")
     );
     assert_eq!(
-        resp.headers()
+        response
+            .headers()
             .get("cache-control")
             .and_then(|value| value.to_str().ok()),
-        Some("public, max-age=31536000, s-maxage=31536000, immutable"),
-        "Axum adapter should render the portable s-maxage fallback"
-    );
-    assert!(
-        resp.headers().get("surrogate-control").is_none(),
-        "s-maxage fallback must not emit Fastly Surrogate-Control"
+        Some("public, max-age=31536000, immutable")
     );
+    assert!(response.headers().get("x-frame-options").is_none());
+    let body = axum::body::to_bytes(response.into_body(), 1024 * 1024)
+        .await
+        .expect("renderer body should be bounded");
+    let body = std::str::from_utf8(&body).expect("renderer should be UTF-8");
+    assert!(body.contains("TS APS Bootstrap Ready"));
+    assert!(body.contains("TS APS Bootstrap Configure"));
+    assert!(body.contains("/integrations/aps/runner.js"));
+    assert!(body.contains("data:text/html;charset=utf-8,"));
+    assert!(!body.contains("client.aps.amazon-adsystem.com"));
+
+    for (method, path, expected) in [
+        ("POST", "/integrations/aps/runner.js", 405),
+        ("TRACE", "/integrations/aps/renderer/v2", 405),
+        ("CONNECT", "/integrations/aps/renderer/v2", 405),
+        ("PROPFIND", "/integrations/aps/renderer/v2", 405),
+        ("GET", "/integrations/aps/renderer", 404),
+        ("GET", "/integrations/aps/renderer/v1", 404),
+        ("GET", "/integrations/aps/runner/v1.js", 404),
+        ("GET", "/integrations/aps", 404),
+    ] {
+        let request = Request::builder()
+            .method(method)
+            .uri(path)
+            .header("authorization", "Bearer must-not-reach-publisher")
+            .body(AxumBody::empty())
+            .expect("should build APS family request");
+        let response = route_reserved(request).await;
+        assert_eq!(response.status().as_u16(), expected, "{method} {path}");
+        assert_eq!(
+            response
+                .headers()
+                .get("cache-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("no-store"),
+            "{method} {path}"
+        );
+        assert!(
+            response.headers().get("x-geo-info-available").is_none(),
+            "{method} {path} must not receive generic finalizer headers"
+        );
+        if expected == 405 {
+            assert_eq!(
+                response
+                    .headers()
+                    .get("allow")
+                    .and_then(|v| v.to_str().ok()),
+                Some("GET")
+            );
+            assert_eq!(response.headers().len(), 2, "{method} {path}");
+        } else {
+            assert_eq!(response.headers().len(), 1, "{method} {path}");
+        }
+        let body = axum::body::to_bytes(response.into_body(), 1)
+            .await
+            .expect("local APS failure body should be empty");
+        assert!(body.is_empty(), "{method} {path}");
+    }
+
+    let protected_control = Request::builder()
+        .method("GET")
+        .uri("/integrations/apsx")
+        .body(AxumBody::empty())
+        .expect("should build protected non-APS boundary request");
+    let response = make_service()
+        .ready()
+        .await
+        .expect("should be ready")
+        .call(protected_control)
+        .await
+        .expect("should auth-gate non-APS boundary request");
+    assert_eq!(response.status().as_u16(), 401);
 }
 
 // ---------------------------------------------------------------------------
diff --git a/crates/trusted-server-adapter-cloudflare/Cargo.toml b/crates/trusted-server-adapter-cloudflare/Cargo.toml
index 097844012..e4e5e4ca7 100644
--- a/crates/trusted-server-adapter-cloudflare/Cargo.toml
+++ b/crates/trusted-server-adapter-cloudflare/Cargo.toml
@@ -19,6 +19,7 @@ crate-type = ["cdylib", "rlib"]
 default = []
 # Keep for explicit `cargo check --features cloudflare --target wasm32-unknown-unknown`
 cloudflare = ["edgezero-adapter-cloudflare/cloudflare", "dep:worker"]
+aps-runner-proxy-integration-test = ["trusted-server-core/test-utils"]
 
 [dependencies]
 async-trait = { workspace = true }
diff --git a/crates/trusted-server-adapter-cloudflare/build.sh b/crates/trusted-server-adapter-cloudflare/build.sh
index dcabdee8e..cbd78c23a 100644
--- a/crates/trusted-server-adapter-cloudflare/build.sh
+++ b/crates/trusted-server-adapter-cloudflare/build.sh
@@ -33,4 +33,9 @@ if [ -z "$WORKER_VERSION" ]; then
   echo "error: could not determine the worker crate version from Cargo.lock" >&2
   exit 1
 fi
-cargo install -q --force --version "=$WORKER_VERSION" worker-build && worker-build --release
+cargo install -q --force --version "=$WORKER_VERSION" worker-build
+if [ -n "${TS_WORKER_BUILD_FEATURES:-}" ]; then
+  worker-build --release . --features "$TS_WORKER_BUILD_FEATURES"
+else
+  worker-build --release
+fi
diff --git a/crates/trusted-server-adapter-cloudflare/src/app.rs b/crates/trusted-server-adapter-cloudflare/src/app.rs
index b57c4a6b8..7625ce597 100644
--- a/crates/trusted-server-adapter-cloudflare/src/app.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/app.rs
@@ -31,14 +31,14 @@ use trusted_server_core::proxy::{
     handle_first_party_proxy_sign,
 };
 use trusted_server_core::publisher::{
-    AuctionDispatch, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, PublisherResponse,
-    buffer_publisher_response_async, handle_page_bids, handle_publisher_request,
-    handle_tsjs_dynamic, page_bids_preflight_denied,
+    AuctionDispatch, PAGE_BIDS_PATH, PublisherResponse, buffer_publisher_response_async,
+    handle_page_bids, handle_publisher_request, handle_tsjs_dynamic, page_bids_preflight_denied,
 };
 use trusted_server_core::request_signing::{
     handle_trusted_server_discovery, handle_verify_signature,
 };
 use trusted_server_core::settings::Settings;
+use trusted_server_core::trace_cookie::handle_trace_mode;
 
 use crate::middleware::{AuthMiddleware, FinalizeResponseMiddleware, SanitizeRequestMiddleware};
 use crate::platform::build_runtime_services;
@@ -154,6 +154,47 @@ fn build_state_with_settings(
     }))
 }
 
+async fn dispatch_reserved_for_state(state: &Arc<AppState>, req: Request) -> Option<Response> {
+    if !state.registry.has_reserved_path(req.uri().path()) {
+        return None;
+    }
+    let ctx = RequestContext::new(req, edgezero_core::params::PathParams::default());
+    let services = build_runtime_services(&ctx);
+    Some(
+        state
+            .registry
+            .handle_reserved_proxy(&state.settings, &services, ctx.into_request())
+            .await
+            .expect("reserved path should have a hard-cutover handler")
+            .unwrap_or_else(|report| http_error(&report)),
+    )
+}
+
+/// Dispatch a reserved request using explicit settings.
+///
+/// # Errors
+///
+/// Returns an error when the adapter state cannot be built from `settings`.
+pub async fn dispatch_reserved_with_settings(
+    settings: Settings,
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    let state = build_state_with_settings(settings)?;
+    Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
+/// Dispatch a reserved request using the configured adapter state.
+///
+/// # Errors
+///
+/// Returns an error when the configured adapter state cannot be built.
+pub async fn dispatch_reserved(
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    let state = build_state()?;
+    Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
 // ---------------------------------------------------------------------------
 // Per-request RuntimeServices
 // ---------------------------------------------------------------------------
@@ -402,7 +443,7 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
     {
         let state = Arc::clone(state);
 
-        // Shared fallback dispatch: routes to tsjs (GET only), integration proxy, or publisher.
+        // Shared fallback dispatch: routes to tsjs (GET/HEAD), integration proxy, or publisher.
         async fn dispatch(
             state: Arc<AppState>,
             ctx: RequestContext,
@@ -420,10 +461,7 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             }
             let path = req.uri().path().to_owned();
             let method = req.method().clone();
-            // tsjs assets are served for GET only, matching the Axum/Fastly adapters.
-            let allow_tsjs = method == Method::GET;
-
-            let result = if allow_tsjs && path.starts_with("/static/tsjs=") {
+            let result = if path.starts_with("/static/tsjs=") {
                 handle_tsjs_dynamic(
                     &req,
                     &state.registry,
@@ -528,19 +566,21 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             .post("/_ts/admin/keys/deactivate", |_ctx: RequestContext| async {
                 Ok::<Response, EdgeError>(admin_key_management_not_supported())
             })
-            // Admin EC lookup routes. Registered explicitly (like the key
-            // routes above) so they never fall through to the publisher
-            // fallback, and they match `Settings::ADMIN_ENDPOINTS` for auth
-            // coverage. The EC identity graph is Fastly KV backed, so this
-            // adapter has no store to read.
             .get("/_ts/admin/ec", |_ctx: RequestContext| async {
                 Ok::<Response, EdgeError>(admin_ec_lookup_not_supported())
             })
             .get("/_ts/admin/ec/{id}", |_ctx: RequestContext| async {
                 Ok::<Response, EdgeError>(admin_ec_lookup_not_supported())
             })
-            // Admin EIDs echo: pure request inspection (no KV), so this
-            // adapter serves the real handler.
+            .get(
+                "/_ts/trace",
+                make_handler(Arc::clone(&state), |s, _services, req| async move {
+                    handle_trace_mode(&s.settings, req.uri().query())
+                }),
+            )
+            // Render-trace toggle: arms/disarms the ts-trace cookie and
+            // redirects to `/`. Gated by [debug] trace_route_enabled (404 when
+            // off).
             .get(
                 "/_ts/admin/eids",
                 make_handler(Arc::clone(&state), |s, _services, req| async move {
@@ -608,15 +648,8 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
                 }),
             );
 
-        // SPA re-auction endpoint, registered on the canonical path and on the
-        // deprecated `PAGE_BIDS_LEGACY_PATH` double-underscore alias. The alias
-        // keeps tsjs bundles served before the `/_ts/page-bids` rename getting
-        // ads on SPA navigations until they age out of browser caches.
-        //
-        // The OPTIONS preflight is denied on both so the GET handler's
-        // `X-TSJS-Page-Bids` gate stays trustworthy — an alias that let the
-        // preflight fall through to a permissive origin would reopen exactly
-        // the cross-site hole the canonical path closes.
+        // SPA re-auction endpoint. OPTIONS is denied so the GET handler's
+        // `X-TSJS-Page-Bids` gate stays trustworthy.
         let page_bids = make_handler(Arc::clone(&state), |s, services, req| async move {
             let ec_context = build_ec_context(&s.settings, &services, &req);
             let auction = AuctionDispatch {
@@ -630,10 +663,8 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             make_handler(Arc::clone(&state), |_s, _services, _req| async move {
                 Ok(page_bids_preflight_denied())
             });
-        for path in [PAGE_BIDS_PATH, PAGE_BIDS_LEGACY_PATH] {
-            router = router.route(path, Method::GET, page_bids.clone());
-            router = router.route(path, Method::OPTIONS, page_bids_preflight.clone());
-        }
+        router = router.route(PAGE_BIDS_PATH, Method::GET, page_bids);
+        router = router.route(PAGE_BIDS_PATH, Method::OPTIONS, page_bids_preflight);
 
         let legacy_admin_deny =
             make_handler(Arc::clone(&state), |_s, _services, _req| async move {
@@ -647,6 +678,9 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             );
             router = router.route("/admin/keys/deactivate", method, legacy_admin_deny.clone());
         }
+        for method in publisher_fallback_methods() {
+            router = router.route("/__ts/page-bids", method, legacy_admin_deny.clone());
+        }
 
         for method in publisher_fallback_methods() {
             router = router.route("/", method.clone(), fallback.clone());
@@ -700,11 +734,10 @@ mod tests {
         let state = build_state_with_settings(aps_profile_settings())
             .expect("Cloudflare startup should register APS renderer");
         assert!(
-            state.registry.has_route(
-                &edgezero_core::http::Method::GET,
-                "/integrations/aps/renderer"
-            ),
-            "Cloudflare startup registry should expose the APS renderer"
+            state
+                .registry
+                .has_reserved_path("/integrations/aps/renderer/v2"),
+            "Cloudflare startup registry should reserve the APS v2 renderer"
         );
     }
 
diff --git a/crates/trusted-server-adapter-cloudflare/src/lib.rs b/crates/trusted-server-adapter-cloudflare/src/lib.rs
index 980a9b209..4f7eb687f 100644
--- a/crates/trusted-server-adapter-cloudflare/src/lib.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/lib.rs
@@ -15,6 +15,11 @@ pub mod platform;
 #[cfg(target_arch = "wasm32")]
 use worker::{Context, Env, Request, Response, Result, event};
 
+#[cfg(any(target_arch = "wasm32", test))]
+fn preserved_reserved_method(value: &str) -> Option<edgezero_core::http::Method> {
+    edgezero_core::http::Method::from_bytes(value.as_bytes()).ok()
+}
+
 #[cfg(target_arch = "wasm32")]
 #[event(fetch)]
 /// Dispatches an incoming Cloudflare Worker fetch event.
@@ -29,6 +34,31 @@ pub async fn main(req: Request, env: Env, ctx: Context) -> Result<Response> {
     }
     app::set_cloudflare_env(env.clone());
 
+    let is_reserved = req
+        .url()
+        .is_ok_and(|url| trusted_server_core::integrations::aps::is_aps_family_path(url.path()));
+    if is_reserved {
+        // workers-rs maps unknown methods to GET; the underlying Fetch request
+        // preserves the original method token, so capture it before conversion.
+        let method = preserved_reserved_method(&req.inner().method()).ok_or_else(|| {
+            worker::Error::RustError("reserved APS request method is invalid".to_string())
+        })?;
+        let mut request = edgezero_adapter_cloudflare::request::into_core_request(req, env, ctx)
+            .await
+            .map_err(|error| worker::Error::RustError(error.to_string()))?;
+        *request.method_mut() = method;
+        let response = app::dispatch_reserved(request)
+            .await
+            .map_err(|error| worker::Error::RustError(error.to_string()))?
+            .ok_or_else(|| {
+                worker::Error::RustError(
+                    "reserved APS path has no hard-cutover handler".to_string(),
+                )
+            })?;
+        return edgezero_adapter_cloudflare::response::from_core_response(response)
+            .map_err(|error| worker::Error::RustError(error.to_string()));
+    }
+
     match edgezero_adapter_cloudflare::run_app::<app::TrustedServerApp>(req, env, ctx).await {
         Ok(resp) => Ok(resp),
         Err(e) => {
@@ -37,3 +67,16 @@ pub async fn main(req: Request, env: Env, ctx: Context) -> Result<Response> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::preserved_reserved_method;
+
+    #[test]
+    fn reserved_method_parser_preserves_extension_methods() {
+        let method = preserved_reserved_method("PROPFIND")
+            .expect("should preserve a syntactically valid extension method");
+
+        assert_eq!(method.as_str(), "PROPFIND");
+    }
+}
diff --git a/crates/trusted-server-adapter-cloudflare/src/platform.rs b/crates/trusted-server-adapter-cloudflare/src/platform.rs
index cded42a0d..d9dfeabb1 100644
--- a/crates/trusted-server-adapter-cloudflare/src/platform.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/platform.rs
@@ -18,6 +18,7 @@ use trusted_server_core::platform::UnavailableHttpClient;
 #[cfg(target_arch = "wasm32")]
 use trusted_server_core::platform::{
     PlatformHttpRequest, PlatformPendingRequest, PlatformResponse, PlatformSelectResult,
+    ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1,
 };
 
 // ---------------------------------------------------------------------------
@@ -190,7 +191,13 @@ struct CloudflarePendingResponse {
 /// fetch layer; the Workers runtime's global CPU budget (~30 s on paid plans)
 /// is the only implicit deadline.
 #[cfg(target_arch = "wasm32")]
-pub struct CloudflareHttpClient;
+pub struct CloudflareHttpClient {
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    aps_runner_proxy_test_fetcher: Option<worker::Fetcher>,
+}
+
+#[cfg(all(target_arch = "wasm32", feature = "aps-runner-proxy-integration-test"))]
+const APS_RUNNER_PROXY_TEST_SERVICE_BINDING: &str = "APS_RUNNER_PROXY_FIXTURE";
 
 /// Maximum buffered upstream response body, mirroring the Fastly adapter's cap.
 ///
@@ -281,6 +288,27 @@ fn outbound_request_init(method: worker::Method, headers: worker::Headers) -> wo
 
 #[cfg(target_arch = "wasm32")]
 impl CloudflareHttpClient {
+    fn new(request_context: &edgezero_core::context::RequestContext) -> Self {
+        #[cfg(not(feature = "aps-runner-proxy-integration-test"))]
+        let _ = request_context;
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let aps_runner_proxy_test_fetcher =
+            edgezero_adapter_cloudflare::context::CloudflareRequestContext::get(
+                request_context.request(),
+            )
+            .and_then(|cloudflare_context| {
+                cloudflare_context
+                    .env()
+                    .service(APS_RUNNER_PROXY_TEST_SERVICE_BINDING)
+                    .ok()
+            });
+
+        Self {
+            #[cfg(feature = "aps-runner-proxy-integration-test")]
+            aps_runner_proxy_test_fetcher,
+        }
+    }
+
     async fn execute(
         &self,
         request: PlatformHttpRequest,
@@ -436,6 +464,219 @@ impl CloudflareHttpClient {
 
         Ok(PlatformResponse::new(edge_resp).with_backend_name(request.backend_name))
     }
+
+    fn raw_header_evidence(headers: &worker::Headers, name: &str) -> ProxyHeaderEvidenceV1 {
+        match headers.get(name) {
+            Ok(Some(value)) => ProxyHeaderEvidenceV1::Combined(value.into_bytes()),
+            Ok(None) => ProxyHeaderEvidenceV1::absent(),
+            Err(_) => ProxyHeaderEvidenceV1::Unavailable,
+        }
+    }
+
+    fn canonical_declared_length(evidence: &ProxyHeaderEvidenceV1) -> Option<usize> {
+        let value = match evidence {
+            ProxyHeaderEvidenceV1::Occurrences(values) => {
+                let [value] = values.as_slice() else {
+                    return None;
+                };
+                value.as_slice()
+            }
+            ProxyHeaderEvidenceV1::Combined(value) => value.as_slice(),
+            ProxyHeaderEvidenceV1::Unavailable => return None,
+        };
+        if value.is_empty()
+            || !value.iter().all(u8::is_ascii_digit)
+            || (value.len() > 1 && value[0] == b'0')
+        {
+            return None;
+        }
+        std::str::from_utf8(value).ok()?.parse().ok()
+    }
+
+    async fn execute_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        use futures::{FutureExt as _, StreamExt as _, future::Either};
+        use worker::{
+            AbortController, CacheMode, Fetch, Headers, Method, Request, RequestInit,
+            RequestRedirect, ResponseBody,
+        };
+
+        if request.image_optimizer.is_some() || request.stream_response {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("unsupported option on Cloudflare raw proxy request"));
+        }
+
+        let cache_mode = outbound_cache_mode(request.bypass_cache);
+        let uri = request.request.uri().to_string();
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let use_test_service_binding = {
+            use trusted_server_core::integrations::aps::APS_RUNNER_UPSTREAM_URL;
+
+            uri == APS_RUNNER_UPSTREAM_URL
+        };
+        let method = Method::from(request.request.method().to_string());
+        let headers = Headers::new();
+        for (name, value) in request.request.headers() {
+            let value =
+                std::str::from_utf8(value.as_bytes()).change_context(PlatformError::HttpClient)?;
+            headers
+                .append(name.as_str(), value)
+                .change_context(PlatformError::HttpClient)?;
+        }
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        if use_test_service_binding {
+            headers
+                .set("x-ts-aps-logical-url", &uri)
+                .change_context(PlatformError::HttpClient)?;
+        }
+
+        let (_, body) = request.request.into_parts();
+        let body = match body {
+            edgezero_core::body::Body::Once(bytes) => bytes.to_vec(),
+            edgezero_core::body::Body::Stream(_) => {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("streaming request bodies are not supported on Cloudflare raw proxy"));
+            }
+        };
+        let mut init = RequestInit::new();
+        init.with_method(method)
+            .with_headers(headers)
+            .with_redirect(RequestRedirect::Manual);
+        if cache_mode == OutboundCacheMode::NoStore {
+            init.with_cache(CacheMode::NoStore);
+        }
+        if !body.is_empty() {
+            init.with_body(Some(js_sys::Uint8Array::from(body.as_slice()).into()));
+        }
+        let worker_request =
+            Request::new_with_init(&uri, &init).change_context(PlatformError::HttpClient)?;
+
+        let controller = AbortController::default();
+        let signal = controller.signal();
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let test_fetcher = if use_test_service_binding {
+            Some(self.aps_runner_proxy_test_fetcher.clone().ok_or_else(|| {
+                Report::new(PlatformError::HttpClient)
+                    .attach("APS runner proxy integration service binding is unavailable")
+            })?)
+        } else {
+            None
+        };
+        let operation = async {
+            let fetch_operation = async {
+                #[cfg(feature = "aps-runner-proxy-integration-test")]
+                let response = if let Some(fetcher) = test_fetcher {
+                    let mut bound_request: worker::HttpRequest = worker_request
+                        .try_into()
+                        .change_context(PlatformError::HttpClient)?;
+                    bound_request.extensions_mut().insert(signal.clone());
+                    let bound_response = fetcher
+                        .fetch_request(bound_request)
+                        .await
+                        .change_context(PlatformError::HttpClient)?;
+                    worker::Response::try_from(bound_response)
+                        .change_context(PlatformError::HttpClient)?
+                } else {
+                    let fetch = Fetch::Request(worker_request);
+                    fetch
+                        .send_with_signal(&signal)
+                        .await
+                        .change_context(PlatformError::HttpClient)?
+                };
+                #[cfg(not(feature = "aps-runner-proxy-integration-test"))]
+                let response = {
+                    let fetch = Fetch::Request(worker_request);
+                    fetch
+                        .send_with_signal(&signal)
+                        .await
+                        .change_context(PlatformError::HttpClient)?
+                };
+                Ok::<worker::Response, Report<PlatformError>>(response)
+            }
+            .boxed_local();
+            let first_byte_deadline = worker::Delay::from(policy.first_byte_timeout).boxed_local();
+            let mut response =
+                match futures::future::select(fetch_operation, first_byte_deadline).await {
+                    Either::Left((response, _)) => response?,
+                    Either::Right(((), _)) => {
+                        return Err(Report::new(PlatformError::HttpClient)
+                            .attach("raw proxy first-byte deadline exceeded"));
+                    }
+                };
+            let evidence = ProxyResponseEvidenceV1 {
+                status: response.status_code(),
+                content_type: Self::raw_header_evidence(response.headers(), "content-type"),
+                content_encoding: Self::raw_header_evidence(response.headers(), "content-encoding"),
+                content_length: Self::raw_header_evidence(response.headers(), "content-length"),
+            };
+            if Self::canonical_declared_length(&evidence.content_length)
+                .is_some_and(|length| length > policy.max_response_bytes)
+            {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy declared body exceeds configured cap"));
+            }
+
+            let mut body = match response.body().clone() {
+                ResponseBody::Empty => Vec::new(),
+                ResponseBody::Body(bytes) => bytes,
+                ResponseBody::Stream(_) => {
+                    let mut stream = response
+                        .stream()
+                        .change_context(PlatformError::HttpClient)?;
+                    let mut body = Vec::new();
+                    loop {
+                        let read = stream.next().boxed_local();
+                        let read_deadline =
+                            worker::Delay::from(policy.blocking_read_timeout).boxed_local();
+                        let chunk = match futures::future::select(read, read_deadline).await {
+                            Either::Left((chunk, _)) => chunk,
+                            Either::Right(((), _)) => {
+                                return Err(Report::new(PlatformError::HttpClient)
+                                    .attach("raw proxy blocking-read deadline exceeded"));
+                            }
+                        };
+                        let Some(chunk) = chunk else { break };
+                        let chunk = chunk.change_context(PlatformError::HttpClient)?;
+                        let next_len = body.len().checked_add(chunk.len()).ok_or_else(|| {
+                            Report::new(PlatformError::HttpClient)
+                                .attach("raw proxy body length overflow")
+                        })?;
+                        if next_len > policy.max_response_bytes {
+                            return Err(Report::new(PlatformError::HttpClient)
+                                .attach("raw proxy body exceeds configured cap"));
+                        }
+                        body.extend_from_slice(&chunk);
+                    }
+                    body
+                }
+            };
+            if body.len() > policy.max_response_bytes {
+                body.clear();
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy buffered body exceeds configured cap"));
+            }
+            Ok(RawProxyResponseV1 { evidence, body })
+        }
+        .boxed_local();
+        let deadline = worker::Delay::from(policy.total_timeout).boxed_local();
+
+        match futures::future::select(operation, deadline).await {
+            Either::Left((result, _)) => {
+                if result.is_err() {
+                    controller.abort();
+                }
+                result
+            }
+            Either::Right(((), _)) => {
+                controller.abort();
+                Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy total deadline exceeded"))
+            }
+        }
+    }
 }
 
 #[cfg(target_arch = "wasm32")]
@@ -448,6 +689,14 @@ impl PlatformHttpClient for CloudflareHttpClient {
         self.execute(request).await
     }
 
+    async fn send_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        self.execute_raw_proxy_v1(request, policy).await
+    }
+
     fn supports_concurrent_fanout(&self) -> bool {
         // `send_async` executes each request eagerly, so multiple pending
         // requests run sequentially. The auction orchestrator checks this
@@ -594,7 +843,7 @@ pub fn build_runtime_services(ctx: &edgezero_core::context::RequestContext) -> R
     let client_ip = extract_client_ip(ctx);
 
     #[cfg(target_arch = "wasm32")]
-    let http_client: Arc<dyn PlatformHttpClient> = Arc::new(CloudflareHttpClient);
+    let http_client: Arc<dyn PlatformHttpClient> = Arc::new(CloudflareHttpClient::new(ctx));
     #[cfg(not(target_arch = "wasm32"))]
     let http_client: Arc<dyn PlatformHttpClient> = Arc::new(UnavailableHttpClient);
 
diff --git a/crates/trusted-server-adapter-cloudflare/tests/routes.rs b/crates/trusted-server-adapter-cloudflare/tests/routes.rs
index fb498ce4e..8499199af 100644
--- a/crates/trusted-server-adapter-cloudflare/tests/routes.rs
+++ b/crates/trusted-server-adapter-cloudflare/tests/routes.rs
@@ -21,14 +21,19 @@ const LEGACY_ADMIN_DENY_METHODS: &[&str] =
 /// The handler regex is the production-shaped `^/_ts/admin`, matching
 /// `Settings::ADMIN_ENDPOINTS` and the default config, so the canonical
 /// `/_ts/admin/keys/*` routes are auth-gated exactly as in production.
-fn test_router() -> RouterService {
-    let settings = Settings::from_toml(
+fn test_settings() -> Settings {
+    Settings::from_toml(
         r#"
             [[handlers]]
             path = "^/_ts/admin"
             username = "admin"
             password = "admin-pass"
 
+            [[handlers]]
+            path = "^/integrations/aps"
+            username = "aps-user"
+            password = "aps-pass"
+
             [publisher]
             domain = "test-publisher.example.com"
             cookie_domain = ".test-publisher.example.com"
@@ -37,11 +42,27 @@ fn test_router() -> RouterService {
 
             [ec]
             passphrase = "test-secret-key-32-bytes-minimum"
+
+            [auction]
+            enabled = true
+            timeout_ms = 1000
+
+            [auction.providers.aps-main]
+            protocol = "openrtb-2.6"
+            profile = "aps"
+            endpoint = "https://aps.example/e/pb/bid"
+            routing = "all_eligible"
+
+            [auction.providers.aps-main.profile_config]
+            account_id = "route-test-aps-account"
+            allow_script_creatives = true
         "#,
     )
-    .expect("should parse route test settings");
+    .expect("should parse route test settings")
+}
 
-    TrustedServerApp::routes_with_settings(settings)
+fn test_router() -> RouterService {
+    TrustedServerApp::routes_with_settings(test_settings())
         .expect("should build router from test settings")
 }
 
@@ -58,6 +79,13 @@ async fn route(router: RouterService, req: Request) -> Response {
     router.oneshot(req).await.expect("should route request")
 }
 
+async fn route_reserved(req: Request) -> Response {
+    trusted_server_adapter_cloudflare::app::dispatch_reserved_with_settings(test_settings(), req)
+        .await
+        .expect("should build APS dispatcher")
+        .expect("APS family should be reserved")
+}
+
 fn assert_route_registered(method: &str, path: &str) {
     let routes = registered_routes();
     assert!(
@@ -101,6 +129,77 @@ fn routes_build_without_panic() {
     let _router = TrustedServerApp::routes();
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn aps_cutover_renderer_and_family_failures_are_local() {
+    let renderer = request_builder()
+        .method("GET")
+        .uri("/integrations/aps/renderer/v2")
+        .header("authorization", "Bearer must-not-reach-publisher")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build APS renderer request");
+    let response = route_reserved(renderer).await;
+    assert_eq!(response.status().as_u16(), 200);
+    assert_eq!(
+        response.headers()["content-type"],
+        "text/html; charset=utf-8"
+    );
+    assert_eq!(
+        response.headers()["cache-control"],
+        "public, max-age=31536000, immutable"
+    );
+    assert!(!response.headers().contains_key("x-frame-options"));
+    let body = response.into_body().into_bytes().unwrap_or_default();
+    let body = std::str::from_utf8(&body).expect("renderer should be UTF-8");
+    assert!(body.contains("TS APS Bootstrap Ready"));
+    assert!(body.contains("TS APS Bootstrap Configure"));
+    assert!(body.contains("/integrations/aps/runner.js"));
+    assert!(body.contains("data:text/html;charset=utf-8,"));
+    assert!(!body.contains("client.aps.amazon-adsystem.com"));
+
+    for (method, path, expected) in [
+        ("POST", "/integrations/aps/runner.js", 405),
+        ("TRACE", "/integrations/aps/renderer/v2", 405),
+        ("CONNECT", "/integrations/aps/renderer/v2", 405),
+        ("PROPFIND", "/integrations/aps/renderer/v2", 405),
+        ("GET", "/integrations/aps/renderer", 404),
+        ("GET", "/integrations/aps/renderer/v1", 404),
+        ("GET", "/integrations/aps/runner/v1.js", 404),
+        ("GET", "/integrations/aps", 404),
+    ] {
+        let request = request_builder()
+            .method(method)
+            .uri(path)
+            .header("authorization", "Bearer must-not-reach-publisher")
+            .body(edgezero_core::body::Body::empty())
+            .expect("should build APS family request");
+        let response = route_reserved(request).await;
+        assert_eq!(response.status().as_u16(), expected, "{method} {path}");
+        assert_eq!(response.headers()["cache-control"], "no-store");
+        assert!(!response.headers().contains_key("x-geo-info-available"));
+        if expected == 405 {
+            assert_eq!(response.headers()["allow"], "GET");
+            assert_eq!(response.headers().len(), 2, "{method} {path}");
+        } else {
+            assert_eq!(response.headers().len(), 1, "{method} {path}");
+        }
+        assert!(
+            response
+                .into_body()
+                .into_bytes()
+                .unwrap_or_default()
+                .is_empty()
+        );
+    }
+
+    let protected_control = request_builder()
+        .method("GET")
+        .uri("/integrations/apsx")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build protected non-APS boundary request");
+    let response = route(test_router(), protected_control).await;
+    assert_eq!(response.status().as_u16(), 401);
+}
+
 // ---------------------------------------------------------------------------
 // Middleware regression tests — verify FinalizeResponseMiddleware and
 // AuthMiddleware are wired so they cannot be removed silently.
@@ -204,40 +303,32 @@ async fn tsjs_route_is_routed_not_5xx() {
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn tsjs_route_emits_cloudflare_cache_header_for_matching_hash() {
-    let router = test_router();
-    let src = trusted_server_core::tsjs::tsjs_script_src(&["creative"]);
-    let req = request_builder()
-        .method("GET")
-        .uri(src)
-        .body(edgezero_core::body::Body::empty())
-        .expect("should build request");
-
-    let resp = route(router, req).await;
+async fn tsjs_wrong_methods_are_local_no_store_404s() {
+    for method in ["HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"] {
+        let req = request_builder()
+            .method(method)
+            .uri(format!(
+                "/static/tsjs=tsjs-unified.min.js?v={}",
+                "0".repeat(64)
+            ))
+            .body(edgezero_core::body::Body::empty())
+            .expect("should build wrong-method TSJS request");
+        let response = route(test_router(), req).await;
 
-    assert_eq!(
-        resp.status().as_u16(),
-        200,
-        "matching TSJS hash should serve OK"
-    );
-    assert_eq!(
-        resp.headers()
-            .get("cache-control")
-            .and_then(|value| value.to_str().ok()),
-        Some("public, max-age=31536000, immutable"),
-        "browser cache policy should be immutable for matching TSJS hash"
-    );
-    assert_eq!(
-        resp.headers()
-            .get("cloudflare-cdn-cache-control")
-            .and_then(|value| value.to_str().ok()),
-        Some("max-age=31536000"),
-        "Cloudflare adapter should emit the Cloudflare-specific edge header"
-    );
-    assert!(
-        resp.headers().get("surrogate-control").is_none(),
-        "Cloudflare adapter must not emit Fastly Surrogate-Control"
-    );
+        assert_eq!(response.status().as_u16(), 404, "method {method}");
+        assert_eq!(
+            response
+                .headers()
+                .get("cache-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("no-store"),
+            "method {method}"
+        );
+        assert!(
+            !response.headers().contains_key("location"),
+            "method {method}"
+        );
+    }
 }
 
 /// Verify that every expected explicit route is registered in the route table.
@@ -256,16 +347,9 @@ fn all_explicit_routes_are_registered() {
         ("GET", "/_ts/admin/ec/{id}"),
         ("GET", "/_ts/admin/eids"),
         ("POST", "/auction"),
-        // SPA re-auction endpoint, plus its deprecated `/__ts/` alias. Both
-        // paths are spelled out as literals rather than referencing
-        // `PAGE_BIDS_PATH` / `PAGE_BIDS_LEGACY_PATH` so this test pins the
-        // actual URL the tsjs client fetches — asserting a const against itself
-        // would still pass if the const's value changed out from under the
-        // client.
+        // Pin the canonical literal fetched by the hard-cutover client.
         ("GET", "/_ts/page-bids"),
         ("OPTIONS", "/_ts/page-bids"),
-        ("GET", "/__ts/page-bids"),
-        ("OPTIONS", "/__ts/page-bids"),
         ("GET", "/first-party/proxy"),
         ("GET", "/first-party/click"),
         ("GET", "/first-party/sign"),
@@ -277,6 +361,9 @@ fn all_explicit_routes_are_registered() {
     for (method, path) in expected {
         assert_route_registered(method, path);
     }
+    for method in LEGACY_ADMIN_DENY_METHODS {
+        assert_route_registered(method, "/__ts/page-bids");
+    }
 
     for path in ["/admin/keys/rotate", "/admin/keys/deactivate"] {
         for method in LEGACY_ADMIN_DENY_METHODS {
diff --git a/crates/trusted-server-adapter-cloudflare/wrangler.aps-runner-proxy.toml b/crates/trusted-server-adapter-cloudflare/wrangler.aps-runner-proxy.toml
new file mode 100644
index 000000000..cdf6e4b07
--- /dev/null
+++ b/crates/trusted-server-adapter-cloudflare/wrangler.aps-runner-proxy.toml
@@ -0,0 +1,24 @@
+name = "trusted-server-aps-runner-proxy-integration"
+main = "build/index.js"
+compatibility_date = "2024-09-23"
+compatibility_flags = ["nodejs_compat", "cache_option_enabled"]
+
+[[kv_namespaces]]
+binding = "TRUSTED_SERVER_KV"
+id = "aps-runner-proxy-local-kv"
+
+[[services]]
+binding = "APS_RUNNER_PROXY_FIXTURE"
+service = "aps-runner-proxy-fixture"
+
+[vars]
+# Replaced in a temporary copy by the integration-test controller.
+TRUSTED_SERVER_CONFIG = "{}"
+
+# Fictitious integration-only values for the secret references in the shared
+# app-config fixture. Production values are provisioned with Worker secrets.
+integration_admin_password = "integration-admin-password-32-bytes-ok"
+integration_proxy_secret = "integration-test-proxy-secret-32-bytes-ok"
+integration_ec_passphrase = "integration-test-ec-secret-padded-32"
+integration_partner_token_alpha = "integration-test-token-alpha-32-bytes-ok"
+integration_partner_token_bravo = "integration-test-token-bravo-32-bytes-ok"
diff --git a/crates/trusted-server-adapter-fastly/Cargo.toml b/crates/trusted-server-adapter-fastly/Cargo.toml
index 65320faa6..8b50f4006 100644
--- a/crates/trusted-server-adapter-fastly/Cargo.toml
+++ b/crates/trusted-server-adapter-fastly/Cargo.toml
@@ -10,6 +10,10 @@ version = { workspace = true }
 [lints]
 workspace = true
 
+[features]
+default = []
+aps-runner-proxy-integration-test = ["trusted-server-core/test-utils"]
+
 [dependencies]
 async-trait = { workspace = true }
 base64 = { workspace = true }
@@ -30,6 +34,7 @@ serde_json = { workspace = true }
 trusted-server-core = { workspace = true }
 url = { workspace = true }
 urlencoding = { workspace = true }
+web-time = { workspace = true }
 
 [dev-dependencies]
 bytes = { workspace = true }
diff --git a/crates/trusted-server-adapter-fastly/src/app.rs b/crates/trusted-server-adapter-fastly/src/app.rs
index c1ba5ed6b..77e5367a3 100644
--- a/crates/trusted-server-adapter-fastly/src/app.rs
+++ b/crates/trusted-server-adapter-fastly/src/app.rs
@@ -132,9 +132,8 @@ use trusted_server_core::proxy::{
     handle_first_party_proxy, handle_first_party_proxy_rebuild, handle_first_party_proxy_sign,
 };
 use trusted_server_core::publisher::{
-    AuctionDispatch, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, handle_page_bids,
-    handle_publisher_request, handle_tsjs_dynamic, page_bids_preflight_denied,
-    publisher_response_into_streaming_response,
+    AuctionDispatch, PAGE_BIDS_PATH, handle_page_bids, handle_publisher_request,
+    handle_tsjs_dynamic, page_bids_preflight_denied, publisher_response_into_streaming_response,
 };
 use trusted_server_core::request_signing::{
     handle_deactivate_key, handle_rotate_key, handle_trusted_server_discovery,
@@ -143,6 +142,7 @@ use trusted_server_core::request_signing::{
 use trusted_server_core::settings::{ProxyAssetRoute, Settings};
 use trusted_server_core::settings_data::{DEFAULT_CONFIG_STORE_ID, get_settings_from_config_store};
 use trusted_server_core::tester_cookie::{handle_clear_tester, handle_set_tester};
+use trusted_server_core::trace_cookie::handle_trace_mode;
 
 use crate::middleware::{AuthMiddleware, FinalizeResponseMiddleware};
 use crate::platform::{
@@ -195,6 +195,25 @@ pub(crate) fn build_state(
     build_state_from_settings(load_settings_from_config_store(stores)?)
 }
 
+pub(crate) async fn dispatch_reserved_for_state(
+    state: &Arc<AppState>,
+    req: Request,
+) -> Option<Response> {
+    if !state.registry.has_reserved_path(req.uri().path()) {
+        return None;
+    }
+    let ctx = RequestContext::new(req, edgezero_core::params::PathParams::default());
+    let services = build_per_request_services(state, &ctx);
+    Some(
+        state
+            .registry
+            .handle_reserved_proxy(&state.settings, &services, ctx.into_request())
+            .await
+            .expect("reserved path should have a hard-cutover handler")
+            .unwrap_or_else(|report| http_error(&report)),
+    )
+}
+
 pub(crate) fn load_settings_from_config_store(
     stores: &RuntimeStoreConfig,
 ) -> Result<Settings, Report<TrustedServerError>> {
@@ -322,8 +341,8 @@ fn publisher_fallback_methods() -> [Method; 7] {
     ]
 }
 
-fn uses_dynamic_tsjs_fallback(method: &Method, path: &str) -> bool {
-    *method == Method::GET && path.starts_with("/static/tsjs=")
+fn uses_dynamic_tsjs_fallback(_method: &Method, path: &str) -> bool {
+    path.starts_with("/static/tsjs=")
 }
 
 // ---------------------------------------------------------------------------
@@ -667,6 +686,7 @@ async fn run_named_route(
         }
         NamedRouteHandler::SetTester => handle_set_tester(&state.settings),
         NamedRouteHandler::ClearTester => handle_clear_tester(&state.settings),
+        NamedRouteHandler::TraceMode => handle_trace_mode(&state.settings, req.uri().query()),
         NamedRouteHandler::Auction => {
             // The auction reads consent data, so the consent KV store must be
             // available — fail closed with 503 when it is configured but
@@ -1086,6 +1106,7 @@ enum NamedRouteHandler {
     Identify,
     SetTester,
     ClearTester,
+    TraceMode,
     Auction,
     PageBids,
     FirstPartyProxy,
@@ -1186,6 +1207,11 @@ const NAMED_ROUTES: &[NamedRoute] = &[
         primary_methods: &[Method::GET],
         handler: NamedRouteHandler::ClearTester,
     },
+    NamedRoute {
+        path: "/_ts/trace",
+        primary_methods: &[Method::GET],
+        handler: NamedRouteHandler::TraceMode,
+    },
     NamedRoute {
         path: "/auction",
         primary_methods: &[Method::POST],
@@ -1198,15 +1224,12 @@ const NAMED_ROUTES: &[NamedRoute] = &[
         primary_methods: &[Method::GET, Method::OPTIONS],
         handler: NamedRouteHandler::PageBids,
     },
-    // Deprecated double-underscore alias. tsjs bundles served before the
-    // `/_ts/page-bids` rename keep requesting this path from already-loaded
-    // pages and browser caches; dropping it would strand SPA navigations
-    // without ads until those bundles age out. See `PAGE_BIDS_LEGACY_PATH`;
-    // removal is tracked by IABTechLab/trusted-server#970.
+    // A removed route must be denied here, before the publisher fallback, so
+    // its response is always a local unknown-route result rather than an alias.
     NamedRoute {
-        path: PAGE_BIDS_LEGACY_PATH,
-        primary_methods: &[Method::GET, Method::OPTIONS],
-        handler: NamedRouteHandler::PageBids,
+        path: "/__ts/page-bids",
+        primary_methods: LEGACY_ADMIN_DENY_METHODS,
+        handler: NamedRouteHandler::LegacyAdminDenied,
     },
     NamedRoute {
         path: "/first-party/proxy",
@@ -1358,19 +1381,20 @@ mod tests {
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    use super::dispatch_reserved_for_state;
     use super::{
-        AppState, AuctionDispatch, EcContext, EdgeCacheHeader, HandlerFuture, NAMED_ROUTES,
-        NamedRouteHandler, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, RuntimeStoreConfig,
-        TrustedServerApp, build_orchestrator_with_plan, build_per_request_services,
-        build_state_from_settings, compile_auction_plan, handle_publisher_request,
-        publisher_response_into_streaming_response, startup_error_router,
+        AppState, AuctionDispatch, EcContext, EdgeCacheHeader, EnvConfig, HandlerFuture,
+        NAMED_ROUTES, NamedRouteHandler, PAGE_BIDS_PATH, RuntimeStoreConfig, TrustedServerApp,
+        build_orchestrator_with_plan, build_per_request_services, build_state_from_settings,
+        compile_auction_plan, handle_publisher_request, publisher_response_into_streaming_response,
+        startup_error_router,
     };
     use base64::Engine as _;
     use bytes::Bytes;
     use edgezero_core::app::Hooks as _;
     use edgezero_core::body::Body;
     use edgezero_core::context::RequestContext;
-    use edgezero_core::env_config::EnvConfig;
     use edgezero_core::http::{Method, Response, StatusCode, header, request_builder};
     use edgezero_core::key_value_store::NoopKvStore;
     use edgezero_core::params::PathParams;
@@ -1551,6 +1575,11 @@ mod tests {
             username = "admin"
             password = "admin-pass"
 
+            [[handlers]]
+            path = "^/integrations/aps"
+            username = "aps-user"
+            password = "aps-pass"
+
             [publisher]
             domain = "test-publisher.com"
             cookie_domain = ".test-publisher.com"
@@ -1572,6 +1601,11 @@ mod tests {
             enabled = true
             external_bundle_url = "https://assets.example/prebid/trusted-prebid.js"
 
+            [integrations.aps]
+            enabled = true
+            account_id = "route-test-aps-account"
+            allow_script_creatives = true
+
             [auction]
             enabled = true
             [auction.providers.prebid]
@@ -1619,6 +1653,103 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    fn route_reserved(request: edgezero_core::http::Request) -> Response {
+        let state = build_state_from_settings(test_settings()).expect("should build test state");
+        block_on(dispatch_reserved_for_state(&state, request))
+            .expect("APS family should be reserved")
+    }
+
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    #[test]
+    fn aps_cutover_renderer_and_family_failures_are_local() {
+        let response = route_reserved(empty_request(Method::GET, "/integrations/aps/renderer/v2"));
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers()[header::CONTENT_TYPE],
+            "text/html; charset=utf-8"
+        );
+        assert_eq!(
+            response.headers()[header::CACHE_CONTROL],
+            "public, max-age=31536000, immutable"
+        );
+        assert!(!response.headers().contains_key("x-frame-options"));
+        let body = response.into_body().into_bytes().unwrap_or_default();
+        let body = std::str::from_utf8(&body).expect("renderer should be UTF-8");
+        assert!(body.contains("TS APS Bootstrap Ready"));
+        assert!(body.contains("TS APS Bootstrap Configure"));
+        assert!(body.contains("/integrations/aps/runner.js"));
+        assert!(body.contains("data:text/html;charset=utf-8,"));
+        assert!(!body.contains("client.aps.amazon-adsystem.com"));
+
+        for (method, path, expected) in [
+            (
+                Method::POST,
+                "/integrations/aps/runner.js",
+                StatusCode::METHOD_NOT_ALLOWED,
+            ),
+            (
+                Method::TRACE,
+                "/integrations/aps/renderer/v2",
+                StatusCode::METHOD_NOT_ALLOWED,
+            ),
+            (
+                Method::CONNECT,
+                "/integrations/aps/renderer/v2",
+                StatusCode::METHOD_NOT_ALLOWED,
+            ),
+            (
+                Method::from_bytes(b"PROPFIND").expect("PROPFIND should be a valid method"),
+                "/integrations/aps/renderer/v2",
+                StatusCode::METHOD_NOT_ALLOWED,
+            ),
+            (
+                Method::GET,
+                "/integrations/aps/renderer",
+                StatusCode::NOT_FOUND,
+            ),
+            (
+                Method::GET,
+                "/integrations/aps/renderer/v1",
+                StatusCode::NOT_FOUND,
+            ),
+            (
+                Method::GET,
+                "/integrations/aps/runner/v1.js",
+                StatusCode::NOT_FOUND,
+            ),
+            (Method::GET, "/integrations/aps", StatusCode::NOT_FOUND),
+        ] {
+            let mut request = empty_request(method.clone(), path);
+            request.headers_mut().insert(
+                header::AUTHORIZATION,
+                "Bearer must-not-reach-publisher"
+                    .parse()
+                    .expect("should parse authorization header"),
+            );
+            let response = route_reserved(request);
+            assert_eq!(response.status(), expected, "{method} {path}");
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+            assert!(!response.headers().contains_key(HEADER_X_GEO_INFO_AVAILABLE));
+            if expected == StatusCode::METHOD_NOT_ALLOWED {
+                assert_eq!(response.headers()[header::ALLOW], "GET");
+            }
+            assert!(
+                response
+                    .into_body()
+                    .into_bytes()
+                    .unwrap_or_default()
+                    .is_empty()
+            );
+        }
+
+        let response = route(
+            &test_router(),
+            empty_request(Method::GET, "/integrations/apsx"),
+        );
+        assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
+    }
+
     /// Builds a router whose `AppState` uses a registry containing the given
     /// request filters (and no routes), so dispatch-level request-filter
     /// behavior can be exercised without a real integration.
@@ -1720,8 +1851,27 @@ mod tests {
 
     #[test]
     fn startup_registers_aps_renderer_route() {
-        let mut settings = test_settings();
-        settings.auction.providers.clear();
+        let mut settings = Settings::from_toml(
+            r#"
+                [[handlers]]
+                path = "^/_ts/admin"
+                username = "admin"
+                password = "admin-password"
+
+                [publisher]
+                domain = "publisher.example"
+                cookie_domain = ".publisher.example"
+                origin_url = "https://origin.publisher.example"
+                proxy_secret = "fictional-proxy-secret"
+
+                [ec]
+                passphrase = "fictional-secret-key-32-bytes-minimum"
+
+                [auction]
+                enabled = true
+            "#,
+        )
+        .expect("should parse APS startup settings");
         settings.auction.providers.insert(
             "aps-main".parse().expect("should parse APS provider ID"),
             trusted_server_core::auction::ProviderConfig {
@@ -1738,11 +1888,10 @@ mod tests {
         let state = build_state_from_settings(settings)
             .expect("Fastly startup should register APS renderer");
         assert!(
-            state.registry.has_route(
-                &edgezero_core::http::Method::GET,
-                "/integrations/aps/renderer"
-            ),
-            "Fastly startup registry should expose the APS renderer"
+            state
+                .registry
+                .has_reserved_path("/integrations/aps/renderer/v2"),
+            "Fastly startup registry should reserve the APS v2 renderer"
         );
     }
 
@@ -1785,18 +1934,18 @@ mod tests {
     }
 
     #[test]
-    fn dynamic_tsjs_fallback_is_get_only() {
+    fn dynamic_tsjs_fallback_rejects_every_wrong_method_locally() {
         assert!(
             super::uses_dynamic_tsjs_fallback(&Method::GET, "/static/tsjs=tsjs-unified.js"),
             "GET should use the dynamic tsjs shortcut"
         );
         assert!(
-            !super::uses_dynamic_tsjs_fallback(&Method::HEAD, "/static/tsjs=tsjs-unified.js"),
-            "HEAD should fall through to the publisher/integration fallback"
+            super::uses_dynamic_tsjs_fallback(&Method::HEAD, "/static/tsjs=tsjs-unified.js"),
+            "HEAD should use the local TSJS rejection path"
         );
         assert!(
-            !super::uses_dynamic_tsjs_fallback(&Method::OPTIONS, "/static/tsjs=tsjs-unified.js"),
-            "OPTIONS should fall through to the publisher/integration fallback"
+            super::uses_dynamic_tsjs_fallback(&Method::OPTIONS, "/static/tsjs=tsjs-unified.js"),
+            "OPTIONS should use the local TSJS rejection path"
         );
     }
 
@@ -1925,83 +2074,29 @@ mod tests {
     }
 
     #[test]
-    fn admin_ec_lookup_routes_are_registered() {
-        // Both lookup shapes must be explicitly routed to the admin EC
-        // handler: the bare cookie-based route and the parameterized route.
-        // Leaving either unrouted would fall through to the publisher
-        // fallback, forwarding the caller's `Authorization` header to the
-        // origin.
-        for path in ["/_ts/admin/ec", "/_ts/admin/ec/{id}"] {
-            let route = NAMED_ROUTES
-                .iter()
-                .find(|route| route.path == path)
-                .unwrap_or_else(|| panic!("{path} must be a named route"));
-            assert!(
-                matches!(route.handler, NamedRouteHandler::AdminEcLookup),
-                "{path} must map to the admin EC lookup handler"
-            );
-            assert_eq!(
-                route.primary_methods,
-                &[Method::GET],
-                "{path} must have GET as its only primary method"
-            );
-        }
-
-        let eids_route = NAMED_ROUTES
-            .iter()
-            .find(|route| route.path == "/_ts/admin/eids")
-            .expect("should register /_ts/admin/eids as a named route");
-        assert!(
-            matches!(eids_route.handler, NamedRouteHandler::AdminEidsLookup),
-            "/_ts/admin/eids must map to the admin EIDs lookup handler"
-        );
-        assert_eq!(
-            eids_route.primary_methods,
-            &[Method::GET],
-            "/_ts/admin/eids must have GET as its only primary method"
-        );
-    }
-
-    #[test]
-    fn page_bids_serves_canonical_path_and_deprecated_alias() {
-        // The SPA re-auction endpoint lives at the canonical single-underscore
-        // `/_ts/page-bids`, matching every other internal route. The deprecated
-        // `/__ts/page-bids` alias must stay registered to the same handler with
-        // the same methods until pre-rename tsjs bundles age out of browser
-        // caches — dropping it would leave those clients without ads on SPA
-        // navigations.
-        //
-        // The paths are literals, not `PAGE_BIDS_PATH` / `PAGE_BIDS_LEGACY_PATH`.
-        // Looking a route up by the same const it was registered with is
-        // tautological: it keeps passing if the const's value changes, which is
-        // exactly the break that would silently desync the server from the tsjs
-        // client's hardcoded fetch path. Pin the consts to their literals too so
-        // a rename has to be deliberate.
+    fn page_bids_keeps_the_canonical_handler_and_denies_the_removed_alias_locally() {
+        // The hard cutover exposes only the canonical single-underscore page-bids
+        // handler. The removed path is an explicit local 404, never an alias or
+        // publisher-fallback route.
         assert_eq!(
             PAGE_BIDS_PATH, "/_ts/page-bids",
             "canonical page-bids path must match the path tsjs fetches"
         );
-        assert_eq!(
-            PAGE_BIDS_LEGACY_PATH, "/__ts/page-bids",
-            "legacy alias must match the path pre-rename tsjs bundles fetch"
-        );
-
-        for path in ["/_ts/page-bids", "/__ts/page-bids"] {
-            let route = NAMED_ROUTES
-                .iter()
-                .find(|route| route.path == path)
-                .unwrap_or_else(|| panic!("{path} should be registered"));
-
-            assert!(
-                matches!(route.handler, NamedRouteHandler::PageBids),
-                "{path} must map to the page-bids handler"
-            );
-            assert_eq!(
-                route.primary_methods,
-                &[Method::GET, Method::OPTIONS],
-                "{path} must handle GET and OPTIONS directly, not fall through to the publisher"
-            );
-        }
+        let route = NAMED_ROUTES
+            .iter()
+            .find(|route| route.path == "/_ts/page-bids")
+            .expect("canonical page-bids path should be registered");
+        assert!(matches!(route.handler, NamedRouteHandler::PageBids));
+        assert_eq!(route.primary_methods, &[Method::GET, Method::OPTIONS]);
+        let removed = NAMED_ROUTES
+            .iter()
+            .find(|route| route.path == "/__ts/page-bids")
+            .expect("removed page-bids path should be denied locally");
+        assert!(matches!(
+            removed.handler,
+            NamedRouteHandler::LegacyAdminDenied
+        ));
+        assert_eq!(removed.primary_methods, super::LEGACY_ADMIN_DENY_METHODS);
     }
 
     #[test]
@@ -2950,6 +3045,7 @@ mod tests {
                     enabled = true
 
                     [creative_opportunities]
+                    enabled = true
                     gam_network_id = "99999"
                     assembly_mode = "esi"
 
diff --git a/crates/trusted-server-adapter-fastly/src/main.rs b/crates/trusted-server-adapter-fastly/src/main.rs
index b086467e3..46b631e4b 100644
--- a/crates/trusted-server-adapter-fastly/src/main.rs
+++ b/crates/trusted-server-adapter-fastly/src/main.rs
@@ -178,7 +178,20 @@ fn edgezero_main(mut req: FastlyRequest) {
             core_req.extensions_mut().insert(config_store);
             core_req.extensions_mut().insert(device_signals);
             core_req.extensions_mut().insert(client_info);
-            match futures::executor::block_on(app.router().oneshot(core_req)) {
+            let routed = if let Some(state) = app_state
+                .as_ref()
+                .filter(|state| state.registry.has_reserved_path(core_req.uri().path()))
+            {
+                Ok(
+                    futures::executor::block_on(crate::app::dispatch_reserved_for_state(
+                        state, core_req,
+                    ))
+                    .expect("reserved path should dispatch before RouterService"),
+                )
+            } else {
+                futures::executor::block_on(app.router().oneshot(core_req))
+            };
+            match routed {
                 Ok(response) => response,
                 Err(error) => edge_error_response(error),
             }
@@ -197,7 +210,12 @@ fn edgezero_main(mut req: FastlyRequest) {
     let asset_cache_policy = response.extensions_mut().remove::<AssetProxyCachePolicy>();
     let request_filter_effects = response.extensions_mut().remove::<RequestFilterEffects>();
 
-    if !take_finalize_sentinel(&mut response) {
+    let should_finalize = response
+        .extensions()
+        .get::<trusted_server_core::platform::ExactResponseHeadersV1>()
+        .is_none()
+        && !take_finalize_sentinel(&mut response);
+    if should_finalize {
         if let Some(settings) = settings_snapshot.as_deref() {
             apply_entry_point_finalize_headers(settings, &mut response, client_ip);
         } else {
@@ -339,7 +357,7 @@ fn send_edgezero_response(
     mut response: HttpResponse,
     request_filter_effects: Option<&RequestFilterEffects>,
 ) {
-    apply_terminal_response_effects(&mut response, request_filter_effects);
+    apply_send_response_effects(&mut response, request_filter_effects);
 
     let (parts, body) = response.into_parts();
 
@@ -368,6 +386,21 @@ fn send_edgezero_response(
     }
 }
 
+fn apply_send_response_effects(
+    response: &mut HttpResponse,
+    request_filter_effects: Option<&RequestFilterEffects>,
+) {
+    if response
+        .extensions()
+        .get::<trusted_server_core::platform::ExactResponseHeadersV1>()
+        .is_some()
+    {
+        return;
+    }
+    apply_terminal_response_effects(response, request_filter_effects);
+    crate::middleware::enforce_uncacheable_cache_privacy(response);
+}
+
 /// Apply every late response mutation, then restore privacy invariants before headers commit.
 fn apply_terminal_response_effects(
     response: &mut HttpResponse,
@@ -585,6 +618,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn exact_route_headers_bypass_terminal_cache_rewriting() {
+        let mut response = response_builder()
+            .header("cache-control", "no-store")
+            .body(EdgeBody::empty())
+            .expect("should build exact route response");
+        response
+            .extensions_mut()
+            .insert(trusted_server_core::platform::ExactResponseHeadersV1);
+
+        apply_send_response_effects(&mut response, None);
+
+        assert_eq!(response.headers()["cache-control"], "no-store");
+    }
+
     #[test]
     fn late_filter_effects_cannot_make_an_assembled_response_public() {
         let mut response = response_builder()
diff --git a/crates/trusted-server-adapter-fastly/src/platform.rs b/crates/trusted-server-adapter-fastly/src/platform.rs
index e612830b9..822cba246 100644
--- a/crates/trusted-server-adapter-fastly/src/platform.rs
+++ b/crates/trusted-server-adapter-fastly/src/platform.rs
@@ -13,13 +13,18 @@ use fastly::geo::{Geo, geo_lookup};
 use fastly::{ConfigStore, Request, SecretStore};
 
 use crate::backend::BackendConfig;
+#[cfg(feature = "aps-runner-proxy-integration-test")]
+use trusted_server_core::integrations::aps::{
+    APS_RUNNER_BLOCKING_READ_TIMEOUT, APS_RUNNER_FIRST_BYTE_TIMEOUT, APS_RUNNER_UPSTREAM_URL,
+};
 pub(crate) use trusted_server_core::platform::UnavailableKvStore;
 use trusted_server_core::platform::{
     BackendNamingPolicy, ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec,
     PlatformConfigStore, PlatformError, PlatformGeo, PlatformHttpClient, PlatformHttpRequest,
     PlatformImageOptimizerCrop, PlatformImageOptimizerCropMode, PlatformImageOptimizerOptions,
     PlatformImageOptimizerParams, PlatformImageOptimizerRegion, PlatformKvStore,
-    PlatformPendingRequest, PlatformResponse, PlatformSecretStore, PlatformSelectResult, StoreId,
+    PlatformPendingRequest, PlatformResponse, PlatformSecretStore, PlatformSelectResult,
+    ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1, StoreId,
     StoreName,
 };
 use trusted_server_core::settings::TrustedClientIpConfig;
@@ -448,6 +453,31 @@ fn apply_fastly_cache_bypass(request: &mut fastly::Request, bypass_cache: bool)
     }
 }
 
+fn fastly_raw_header_evidence(response: &fastly::Response, name: &str) -> ProxyHeaderEvidenceV1 {
+    ProxyHeaderEvidenceV1::Occurrences(
+        response
+            .get_header_all(name)
+            .map(|value| value.as_bytes().to_vec())
+            .collect(),
+    )
+}
+
+fn canonical_fastly_declared_length(evidence: &ProxyHeaderEvidenceV1) -> Option<usize> {
+    let ProxyHeaderEvidenceV1::Occurrences(values) = evidence else {
+        return None;
+    };
+    let [value] = values.as_slice() else {
+        return None;
+    };
+    if value.is_empty()
+        || !value.iter().all(u8::is_ascii_digit)
+        || (value.len() > 1 && value[0] == b'0')
+    {
+        return None;
+    }
+    std::str::from_utf8(value).ok()?.parse().ok()
+}
+
 /// Fastly implementation of [`PlatformHttpClient`].
 ///
 /// - [`send`](PlatformHttpClient::send) converts the platform request to a
@@ -470,6 +500,51 @@ fn apply_fastly_cache_bypass(request: &mut fastly::Request, bypass_cache: bool)
 /// tests cover request conversion and the single-send boundary.
 pub struct FastlyPlatformHttpClient;
 
+#[cfg(feature = "aps-runner-proxy-integration-test")]
+const APS_RUNNER_PROXY_TEST_BACKEND: &str = "aps_runner_proxy_fixture";
+
+#[cfg(feature = "aps-runner-proxy-integration-test")]
+fn aps_runner_proxy_test_backend(
+    policy: RawProxyPolicyV1,
+) -> Result<String, Report<PlatformError>> {
+    if policy.first_byte_timeout != APS_RUNNER_FIRST_BYTE_TIMEOUT
+        || policy.blocking_read_timeout != APS_RUNNER_BLOCKING_READ_TIMEOUT
+    {
+        return Err(Report::new(PlatformError::HttpClient)
+            .attach("APS runner raw proxy policy does not match the static fixture timeouts"));
+    }
+    let fixture = fastly::Backend::from_name(APS_RUNNER_PROXY_TEST_BACKEND)
+        .change_context(PlatformError::HttpClient)?;
+    if !fixture.exists() || fixture.is_ssl() {
+        return Err(Report::new(PlatformError::HttpClient)
+            .attach("APS runner fixture backend must exist as plain HTTP"));
+    }
+    let fixture_host = fixture.get_host();
+    let fixture_address = fixture_host.parse::<IpAddr>().map_err(|_| {
+        Report::new(PlatformError::HttpClient)
+            .attach("APS runner fixture backend host must be a literal IP address")
+    })?;
+    if !fixture_address.is_loopback() {
+        return Err(Report::new(PlatformError::HttpClient)
+            .attach("APS runner fixture backend host must be loopback"));
+    }
+    let logical_url =
+        url::Url::parse(APS_RUNNER_UPSTREAM_URL).change_context(PlatformError::HttpClient)?;
+    let logical_host = logical_url.host_str().ok_or_else(|| {
+        Report::new(PlatformError::HttpClient).attach("APS runner logical URL must contain a host")
+    })?;
+    if fixture
+        .get_host_override()
+        .as_ref()
+        .and_then(|host| host.to_str().ok())
+        != Some(logical_host)
+    {
+        return Err(Report::new(PlatformError::HttpClient)
+            .attach("APS runner fixture backend must preserve the logical host"));
+    }
+    Ok(APS_RUNNER_PROXY_TEST_BACKEND.to_string())
+}
+
 #[async_trait::async_trait(?Send)]
 impl PlatformHttpClient for FastlyPlatformHttpClient {
     fn supports_streaming_responses(&self) -> bool {
@@ -496,6 +571,88 @@ impl PlatformHttpClient for FastlyPlatformHttpClient {
         fastly_response_to_platform(fastly_resp, backend_name, stream_response, request_is_head)
     }
 
+    async fn send_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        if request.image_optimizer.is_some() || request.stream_response {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("unsupported option on Fastly raw proxy request"));
+        }
+
+        let started = web_time::Instant::now();
+        if policy.first_byte_timeout > policy.total_timeout {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("raw proxy first-byte timeout exceeds total deadline"));
+        }
+        let backend_name = request.backend_name;
+        let mut fastly_request = edge_request_to_fastly(request.request)?;
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let backend_name = {
+            if fastly_request.get_url_str() == APS_RUNNER_UPSTREAM_URL {
+                fastly_request.set_header("x-ts-aps-logical-url", APS_RUNNER_UPSTREAM_URL);
+                aps_runner_proxy_test_backend(policy)?
+            } else {
+                backend_name
+            }
+        };
+        apply_fastly_cache_bypass(&mut fastly_request, request.bypass_cache);
+        let pending = fastly_request
+            .send_async(&backend_name)
+            .change_context(PlatformError::HttpClient)?;
+        // The backend carries the requested first-byte timeout. Waiting in the
+        // SDK lets the host suspend the guest instead of guest-side polling.
+        let mut response = pending.wait().change_context(PlatformError::HttpClient)?;
+        if started.elapsed() >= policy.total_timeout {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("raw proxy total deadline exceeded before response headers"));
+        }
+
+        let evidence = ProxyResponseEvidenceV1 {
+            status: response.get_status().as_u16(),
+            content_type: fastly_raw_header_evidence(&response, "content-type"),
+            content_encoding: fastly_raw_header_evidence(&response, "content-encoding"),
+            content_length: fastly_raw_header_evidence(&response, "content-length"),
+        };
+        if canonical_fastly_declared_length(&evidence.content_length)
+            .is_some_and(|length| length > policy.max_response_bytes)
+        {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("raw proxy declared body exceeds configured cap"));
+        }
+
+        let mut reader = response.take_body();
+        let mut body = Vec::new();
+        let mut chunk = [0_u8; 64 * 1024];
+        loop {
+            if started.elapsed() >= policy.total_timeout {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy total deadline exceeded before blocking body read"));
+            }
+            let read = reader
+                .read(&mut chunk)
+                .change_context(PlatformError::HttpClient)?;
+            if started.elapsed() >= policy.total_timeout {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy total deadline exceeded while reading body"));
+            }
+            if read == 0 {
+                break;
+            }
+            let next_len = body.len().checked_add(read).ok_or_else(|| {
+                Report::new(PlatformError::HttpClient).attach("raw proxy body length overflow")
+            })?;
+            if next_len > policy.max_response_bytes {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy body exceeds configured cap"));
+            }
+            body.extend_from_slice(&chunk[..read]);
+        }
+
+        Ok(RawProxyResponseV1 { evidence, body })
+    }
+
     async fn send_async(
         &self,
         request: PlatformHttpRequest,
@@ -909,6 +1066,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn raw_proxy_waits_with_the_sdk_without_sleep_polling() {
+        let source = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/platform.rs"));
+        let raw_proxy = source
+            .split("async fn send_raw_proxy_v1(")
+            .nth(1)
+            .and_then(|source| source.split("fn supports_concurrent_fanout(").next())
+            .expect("should locate the Fastly raw proxy implementation");
+
+        assert!(
+            raw_proxy.contains("pending.wait()"),
+            "raw proxy should block in the Fastly SDK instead of guest-side polling"
+        );
+        assert!(!raw_proxy.contains("pending.poll()"));
+        assert!(!raw_proxy.contains("std::thread::sleep"));
+        assert!(
+            raw_proxy.contains("policy.total_timeout"),
+            "raw proxy should preserve the complete policy-owned total timeout"
+        );
+        assert!(
+            !raw_proxy.contains("call_start_deadline")
+                && !raw_proxy.contains("reduced deadline")
+                && !raw_proxy.contains("SAFETY_MARGIN"),
+            "raw proxy must not reserve time outside the exact transport window"
+        );
+    }
+
     // --- FastlyPlatformBackend::predict_name --------------------------------
 
     #[test]
diff --git a/crates/trusted-server-adapter-spin/Cargo.toml b/crates/trusted-server-adapter-spin/Cargo.toml
index 77c4139bc..43ba8741f 100644
--- a/crates/trusted-server-adapter-spin/Cargo.toml
+++ b/crates/trusted-server-adapter-spin/Cargo.toml
@@ -18,6 +18,7 @@ crate-type = ["cdylib", "rlib"]
 [features]
 default = []
 spin = ["edgezero-adapter-spin/spin"]
+aps-runner-proxy-integration-test = ["trusted-server-core/test-utils"]
 
 [dependencies]
 anyhow = { workspace = true }
diff --git a/crates/trusted-server-adapter-spin/src/app.rs b/crates/trusted-server-adapter-spin/src/app.rs
index e6abe75ea..073a3eb8e 100644
--- a/crates/trusted-server-adapter-spin/src/app.rs
+++ b/crates/trusted-server-adapter-spin/src/app.rs
@@ -1,11 +1,19 @@
 use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
 
-#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
 use edgezero_adapter_spin::config_store::SpinConfigStore;
 use edgezero_adapter_spin::context::SpinRequestContext;
 use edgezero_core::app::Hooks;
-#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
 use edgezero_core::config_store::ConfigStoreHandle;
 use edgezero_core::context::RequestContext;
 use edgezero_core::error::EdgeError;
@@ -29,37 +37,57 @@ use trusted_server_core::error::{IntoHttpResponse as _, TrustedServerError};
 use trusted_server_core::http_util::sanitize_forwarded_headers;
 use trusted_server_core::integrations::{IntegrationRegistry, ProxyDispatchInput};
 use trusted_server_core::platform::RuntimeServices;
-#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
 use trusted_server_core::platform::{PlatformConfigStore, StoreName};
 use trusted_server_core::proxy::{
     handle_first_party_click, handle_first_party_proxy, handle_first_party_proxy_rebuild,
     handle_first_party_proxy_sign,
 };
 use trusted_server_core::publisher::{
-    AuctionDispatch, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, PublisherResponse,
-    buffer_publisher_response_async, handle_page_bids, handle_publisher_request,
-    handle_tsjs_dynamic, page_bids_preflight_denied,
+    AuctionDispatch, PAGE_BIDS_PATH, PublisherResponse, buffer_publisher_response_async,
+    handle_page_bids, handle_publisher_request, handle_tsjs_dynamic, page_bids_preflight_denied,
 };
 use trusted_server_core::request_signing::{
     handle_trusted_server_discovery, handle_verify_signature,
 };
 use trusted_server_core::settings::Settings;
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
+use trusted_server_core::settings_data::default_config_key;
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
-use trusted_server_core::settings_data::{default_config_key, default_secret_store_name};
+use trusted_server_core::settings_data::default_secret_store_name;
+use trusted_server_core::trace_cookie::handle_trace_mode;
 
 use crate::middleware::{
     AuthMiddleware, FinalizeResponseMiddleware, NormalizeMiddleware, SanitizeRequestMiddleware,
 };
-use crate::platform::build_runtime_services;
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
+use crate::platform::ConfigStoreHandleAdapter;
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
-use crate::platform::{ConfigStoreHandleAdapter, SpinSecretStoreAdapter};
+use crate::platform::SpinSecretStoreAdapter;
+use crate::platform::build_runtime_services;
 
 // ---------------------------------------------------------------------------
 // AppState
 // ---------------------------------------------------------------------------
 
 /// Spin auto-provides this key-value store label without runtime configuration.
-#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
 const SPIN_DEFAULT_CONFIG_STORE: &str = "default";
 
 /// Application state built once at startup and shared across all requests.
@@ -75,12 +103,17 @@ pub struct AppState {
 ///
 /// Returns an error when settings, the auction orchestrator, or the integration
 /// registry fail to initialise.
+#[cfg(not(all(feature = "aps-runner-proxy-integration-test", target_arch = "wasm32")))]
 fn build_state() -> Result<Arc<AppState>, Report<TrustedServerError>> {
     let settings = load_startup_settings()?;
     build_state_with_settings(settings)
 }
 
-#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[cfg(all(
+    feature = "spin",
+    target_arch = "wasm32",
+    not(feature = "aps-runner-proxy-integration-test")
+))]
 fn load_startup_settings() -> Result<Settings, Report<TrustedServerError>> {
     let config_store_name = StoreName::from(SPIN_DEFAULT_CONFIG_STORE);
     let config_key = default_config_key();
@@ -114,6 +147,22 @@ fn load_startup_settings() -> Result<Settings, Report<TrustedServerError>> {
     .attach("use TrustedServerApp::routes_with_settings for host tests"))
 }
 
+#[cfg(all(feature = "aps-runner-proxy-integration-test", target_arch = "wasm32"))]
+fn build_state() -> Result<Arc<AppState>, Report<TrustedServerError>> {
+    let envelope =
+        futures::executor::block_on(spin_sdk::variables::get("v_trusted_x5fserver_x5fconfig"))
+            .map_err(|error| {
+                Report::new(TrustedServerError::Configuration {
+                    message: "failed to read the Spin APS proxy test app config".to_string(),
+                })
+                .attach(error.to_string())
+            })?;
+    let secret_store = SpinSecretStoreAdapter;
+    let settings =
+        settings_from_config_blob(&envelope, &secret_store, &default_secret_store_name())?;
+    build_state_with_settings(settings)
+}
+
 /// Build the application state from explicit settings.
 ///
 /// # Errors
@@ -135,6 +184,49 @@ fn build_state_with_settings(
     }))
 }
 
+async fn dispatch_reserved_for_state(state: &Arc<AppState>, req: Request) -> Option<Response> {
+    if !state.registry.has_reserved_path(req.uri().path()) {
+        return None;
+    }
+    let ctx = RequestContext::new(req, edgezero_core::params::PathParams::default());
+    let services = build_runtime_services(&ctx);
+    Some(
+        state
+            .registry
+            .handle_reserved_proxy(&state.settings, &services, ctx.into_request())
+            .await
+            .expect("reserved path should have a hard-cutover handler")
+            .unwrap_or_else(|report| http_error(&report)),
+    )
+}
+
+/// Dispatch a reserved APS request using explicit settings.
+///
+/// # Errors
+///
+/// Returns an error when the application state cannot be
+/// initialized from `settings`.
+pub async fn dispatch_reserved_with_settings(
+    settings: Settings,
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    let state = build_state_with_settings(settings)?;
+    Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
+/// Dispatch a reserved APS request using startup settings.
+///
+/// # Errors
+///
+/// Returns an error when startup settings or the application
+/// state cannot be initialized.
+pub async fn dispatch_reserved(
+    req: Request,
+) -> Result<Option<Response>, Report<TrustedServerError>> {
+    let state = build_state()?;
+    Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
 // ---------------------------------------------------------------------------
 // Publisher response helper
 // ---------------------------------------------------------------------------
@@ -204,7 +296,7 @@ const LEGACY_ADMIN_DENY_METHODS: &[Method] = &[
     Method::DELETE,
 ];
 
-fn named_fallback_paths() -> [(&'static str, &'static [Method]); 16] {
+fn named_fallback_paths() -> [(&'static str, &'static [Method]); 17] {
     [
         ("/.well-known/trusted-server.json", &[Method::GET]),
         ("/verify-signature", &[Method::POST]),
@@ -215,9 +307,10 @@ fn named_fallback_paths() -> [(&'static str, &'static [Method]); 16] {
         ("/_ts/admin/eids", &[Method::GET]),
         ("/admin/keys/rotate", LEGACY_ADMIN_DENY_METHODS),
         ("/admin/keys/deactivate", LEGACY_ADMIN_DENY_METHODS),
+        ("/_ts/trace", &[Method::GET]),
         ("/auction", &[Method::POST]),
         (PAGE_BIDS_PATH, &[Method::GET, Method::OPTIONS]),
-        (PAGE_BIDS_LEGACY_PATH, &[Method::GET, Method::OPTIONS]),
+        ("/__ts/page-bids", LEGACY_ADMIN_DENY_METHODS),
         ("/first-party/proxy", &[Method::GET]),
         ("/first-party/click", &[Method::GET]),
         ("/first-party/sign", &[Method::GET, Method::POST]),
@@ -751,9 +844,7 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             let path = req.uri().path().to_owned();
             let method = req.method().clone();
 
-            // Dynamic tsjs serving is GET-only; other methods fall through to the
-            // integration/publisher fallback.
-            let result = if method == Method::GET && path.starts_with("/static/tsjs=") {
+            let result = if path.starts_with("/static/tsjs=") {
                 handle_tsjs_dynamic(&req, &state.registry, EdgeCacheHeader::SMaxageFallback)
             } else if state.registry.has_route(&method, &path) {
                 let mut ec_context = EcContext::default();
@@ -820,6 +911,17 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
         };
         let legacy_admin_deny =
             |_ctx: RequestContext| async { Ok::<Response, EdgeError>(legacy_admin_alias_denied()) };
+        let s = Arc::clone(&state);
+        let trace_mode_handler = move |ctx: RequestContext| {
+            let s = Arc::clone(&s);
+            async move {
+                let req = ctx.into_request();
+                Ok::<Response, EdgeError>(
+                    handle_trace_mode(&s.settings, req.uri().query())
+                        .unwrap_or_else(|error| http_error(&error)),
+                )
+            }
+        };
 
         let mut builder = RouterService::builder()
             // Outermost middleware: strips the configured trusted-client-IP
@@ -853,27 +955,13 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
             // credentials and key-management payloads to the origin.
             .post("/_ts/admin/keys/rotate", admin_not_supported_handler)
             .post("/_ts/admin/keys/deactivate", admin_not_supported_handler)
-            // Admin EC lookup routes. Registered explicitly (like the key
-            // routes above) so they never fall through to the publisher
-            // fallback, and they match `Settings::ADMIN_ENDPOINTS` for auth
-            // coverage. The EC identity graph is Fastly KV backed, so this
-            // adapter has no store to read.
             .get("/_ts/admin/ec", admin_ec_not_supported_handler)
             .get("/_ts/admin/ec/{id}", admin_ec_not_supported_handler)
             .get("/_ts/admin/eids", admin_eids_handler)
+            .get("/_ts/trace", trace_mode_handler)
             .post("/auction", auction_handler)
-            .get(PAGE_BIDS_PATH, page_bids_handler.clone())
+            .get(PAGE_BIDS_PATH, page_bids_handler)
             .route(PAGE_BIDS_PATH, Method::OPTIONS, page_bids_options_handler)
-            // Deprecated double-underscore alias, kept so tsjs bundles served
-            // before the `/_ts/page-bids` rename keep getting ads on SPA
-            // navigations until they age out of browser caches. See
-            // `PAGE_BIDS_LEGACY_PATH`.
-            .get(PAGE_BIDS_LEGACY_PATH, page_bids_handler)
-            .route(
-                PAGE_BIDS_LEGACY_PATH,
-                Method::OPTIONS,
-                page_bids_options_handler,
-            )
             .get("/first-party/proxy", fp_proxy_handler)
             .get("/first-party/click", fp_click_handler)
             .get("/first-party/sign", fp_sign_handler)
@@ -884,6 +972,7 @@ fn build_router(state: &Arc<AppState>) -> RouterService {
         for method in LEGACY_ADMIN_DENY_METHODS {
             builder = builder.route("/admin/keys/rotate", method.clone(), legacy_admin_deny);
             builder = builder.route("/admin/keys/deactivate", method.clone(), legacy_admin_deny);
+            builder = builder.route("/__ts/page-bids", method.clone(), legacy_admin_deny);
         }
 
         // Mirror the Fastly/Axum publisher fallback: every supported method that is
@@ -975,11 +1064,10 @@ mod tests {
         let state =
             build_state_with_settings(settings).expect("Spin startup should register APS renderer");
         assert!(
-            state.registry.has_route(
-                &edgezero_core::http::Method::GET,
-                "/integrations/aps/renderer"
-            ),
-            "Spin startup registry should expose the APS renderer"
+            state
+                .registry
+                .has_reserved_path("/integrations/aps/renderer/v2"),
+            "Spin startup registry should reserve the APS v2 renderer"
         );
     }
 
diff --git a/crates/trusted-server-adapter-spin/src/lib.rs b/crates/trusted-server-adapter-spin/src/lib.rs
index f47877ff2..5a6b20bc1 100644
--- a/crates/trusted-server-adapter-spin/src/lib.rs
+++ b/crates/trusted-server-adapter-spin/src/lib.rs
@@ -13,5 +13,15 @@ use spin_sdk::http_service;
 #[http_service]
 // FORCED: edgezero_adapter_spin::run_app returns anyhow::Result — EdgeZero SDK constraint, not a project choice.
 async fn handle(req: Request) -> anyhow::Result<impl IntoResponse> {
+    if trusted_server_core::integrations::aps::is_aps_family_path(req.uri().path()) {
+        let request = edgezero_adapter_spin::request::into_core_request(req).await?;
+        let response = app::dispatch_reserved(request)
+            .await
+            .map_err(|error| anyhow::anyhow!("{error:?}"))?
+            .expect("reserved APS path should dispatch before RouterService");
+        return edgezero_adapter_spin::response::from_core_response(response)
+            .await
+            .map_err(Into::into);
+    }
     edgezero_adapter_spin::run_app::<app::TrustedServerApp>(req).await
 }
diff --git a/crates/trusted-server-adapter-spin/src/platform.rs b/crates/trusted-server-adapter-spin/src/platform.rs
index 8e7cb4bf3..d239cc4a1 100644
--- a/crates/trusted-server-adapter-spin/src/platform.rs
+++ b/crates/trusted-server-adapter-spin/src/platform.rs
@@ -23,7 +23,8 @@ use std::io::Read as _;
 use trusted_server_core::platform::PlatformHttpRequest;
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
 use trusted_server_core::platform::{
-    PlatformPendingRequest, PlatformResponse, PlatformSelectResult,
+    PlatformPendingRequest, PlatformResponse, PlatformSelectResult, ProxyHeaderEvidenceV1,
+    ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1,
 };
 
 // 8 MiB ceiling: conservative for ad-server responses while leaving headroom in
@@ -455,18 +456,61 @@ struct SpinPendingResponse {
 /// `StubHttpClient` driver records the one-send 3xx behavior while adapter tests
 /// cover request/response policy around that single boundary.
 ///
-/// # Known MVP limits
-///
-/// **No configurable outbound timeout.** `spin_sdk::http::send` does not
-/// expose per-request timeout control, and [`PlatformBackendSpec::first_byte_timeout`]
-/// is ignored by [`NoopBackend`]. A slow or hung origin will block the Spin
-/// invocation for whatever default the Spin runtime imposes. Operators requiring
-/// deterministic timeout behaviour should use the Fastly adapter.
+/// Per-request raw-proxy calls lower the core connect, first-byte, and
+/// between-byte deadlines into WASI HTTP [`RequestOptions`].
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
 pub struct SpinPlatformHttpClient;
 
+#[cfg(all(
+    feature = "aps-runner-proxy-integration-test",
+    any(test, all(feature = "spin", target_arch = "wasm32"))
+))]
+fn aps_runner_proxy_transport_uri(
+    logical_uri: &str,
+    endpoint: &str,
+) -> Result<Option<String>, Report<PlatformError>> {
+    use trusted_server_core::integrations::aps::APS_RUNNER_UPSTREAM_URL;
+
+    if logical_uri != APS_RUNNER_UPSTREAM_URL {
+        return Ok(None);
+    }
+    let parsed: edgezero_core::http::Uri = endpoint.parse().map_err(|_| {
+        Report::new(PlatformError::HttpClient)
+            .attach("invalid APS runner proxy integration fixture endpoint")
+    })?;
+    if parsed.scheme_str() != Some("http")
+        || !matches!(parsed.host(), Some("127.0.0.1" | "::1"))
+        || parsed.port_u16().is_none()
+        || parsed.path().is_empty()
+        || parsed.query().is_some()
+    {
+        return Err(Report::new(PlatformError::HttpClient).attach(
+            "APS runner proxy integration fixture endpoint must be an explicit loopback HTTP URL",
+        ));
+    }
+    Ok(Some(endpoint.to_owned()))
+}
+
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
 impl SpinPlatformHttpClient {
+    #[cfg(all(
+        feature = "aps-runner-proxy-integration-test",
+        feature = "spin",
+        target_arch = "wasm32"
+    ))]
+    async fn aps_runner_proxy_test_transport_uri(
+        logical_uri: &str,
+    ) -> Result<Option<String>, Report<PlatformError>> {
+        let endpoint = spin_sdk::variables::get("aps_runner_proxy_test_endpoint")
+            .await
+            .map_err(|_| {
+                Report::new(PlatformError::HttpClient).attach(
+                    "APS runner proxy integration artifact requires its loopback fixture endpoint",
+                )
+            })?;
+        aps_runner_proxy_transport_uri(logical_uri, &endpoint)
+    }
+
     async fn execute(
         &self,
         request: PlatformHttpRequest,
@@ -552,6 +596,190 @@ impl SpinPlatformHttpClient {
 
         Ok(PlatformResponse::new(edge_resp).with_backend_name(request.backend_name))
     }
+
+    fn raw_header_evidence(
+        headers: &spin_sdk::wasip3::http::types::Headers,
+        name: &str,
+    ) -> ProxyHeaderEvidenceV1 {
+        ProxyHeaderEvidenceV1::Occurrences(headers.get(name))
+    }
+
+    fn canonical_declared_length(evidence: &ProxyHeaderEvidenceV1) -> Option<usize> {
+        let ProxyHeaderEvidenceV1::Occurrences(values) = evidence else {
+            return None;
+        };
+        let [value] = values.as_slice() else {
+            return None;
+        };
+        if value.is_empty()
+            || !value.iter().all(u8::is_ascii_digit)
+            || (value.len() > 1 && value[0] == b'0')
+        {
+            return None;
+        }
+        std::str::from_utf8(value).ok()?.parse().ok()
+    }
+
+    async fn execute_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        use futures::{FutureExt as _, future::Either};
+        use spin_sdk::http::IntoRequest as _;
+        use spin_sdk::wasip3::http::types::RequestOptions;
+        use spin_sdk::wasip3::http_compat::{IncomingResponseBody, RequestOptionsExtension};
+
+        reject_unsupported_request_contracts(&request)?;
+        let method = request.request.method().clone();
+        let logical_uri = request.request.uri().to_string();
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        let transport_uri = Self::aps_runner_proxy_test_transport_uri(&logical_uri).await?;
+        let mut builder = spin_sdk::http::Request::builder()
+            .method(into_spin_method(&method))
+            .uri(&logical_uri);
+        for (name, value) in request.request.headers() {
+            if is_wasi_forbidden_outbound_header(name.as_str()) {
+                continue;
+            }
+            builder = builder.header(name.as_str(), value.as_bytes());
+        }
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        if transport_uri.is_some() {
+            builder = builder.header("x-ts-aps-logical-url", logical_uri);
+        }
+
+        let (_, request_body) = request.request.into_parts();
+        let request_body = match request_body {
+            edgezero_core::body::Body::Once(bytes) => bytes.to_vec(),
+            edgezero_core::body::Body::Stream(_) => {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("streaming request bodies are not supported on Spin raw proxy"));
+            }
+        };
+        let mut spin_request = builder
+            .body(spin_sdk::http::FullBody::new(Bytes::from(request_body)))
+            .map_err(|error| {
+                Report::new(PlatformError::HttpClient)
+                    .attach(format!("failed to build Spin raw proxy request: {error}"))
+            })?;
+
+        // Spin/Wasmtime owns the wire `Host` header and forbids guests from
+        // setting it. Keep the fixed APS URL through the core→adapter contract,
+        // then apply the loopback-only integration target at the final lowering
+        // boundary. Production builds have no transport override constructor.
+        #[cfg(feature = "aps-runner-proxy-integration-test")]
+        if let Some(transport_uri) = transport_uri {
+            *spin_request.uri_mut() = transport_uri.parse().map_err(|_| {
+                Report::new(PlatformError::HttpClient)
+                    .attach("failed to lower APS loopback transport URI")
+            })?;
+        }
+
+        let connect_timeout_nanos = policy.total_timeout.as_nanos().try_into().map_err(|_| {
+            Report::new(PlatformError::HttpClient)
+                .attach("raw proxy connect timeout exceeds WASI HTTP duration range")
+        })?;
+        let first_byte_timeout_nanos =
+            policy
+                .first_byte_timeout
+                .as_nanos()
+                .try_into()
+                .map_err(|_| {
+                    Report::new(PlatformError::HttpClient)
+                        .attach("raw proxy first-byte timeout exceeds WASI HTTP duration range")
+                })?;
+        let between_bytes_timeout_nanos = policy
+            .blocking_read_timeout
+            .as_nanos()
+            .try_into()
+            .map_err(|_| {
+                Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy between-bytes timeout exceeds WASI HTTP duration range")
+            })?;
+        let options = RequestOptions::new();
+        options
+            .set_connect_timeout(Some(connect_timeout_nanos))
+            .map_err(|_| {
+                Report::new(PlatformError::Unsupported)
+                    .attach("Spin raw proxy connect timeout is unavailable")
+            })?;
+        options
+            .set_first_byte_timeout(Some(first_byte_timeout_nanos))
+            .map_err(|_| {
+                Report::new(PlatformError::Unsupported)
+                    .attach("Spin raw proxy first-byte timeout is unavailable")
+            })?;
+        options
+            .set_between_bytes_timeout(Some(between_bytes_timeout_nanos))
+            .map_err(|_| {
+                Report::new(PlatformError::Unsupported)
+                    .attach("Spin raw proxy between-bytes timeout is unavailable")
+            })?;
+        spin_request
+            .extensions_mut()
+            .insert(RequestOptionsExtension(options));
+        let wasi_request = spin_request.into_request().map_err(|error| {
+            Report::new(PlatformError::HttpClient)
+                .attach(format!("failed to lower Spin raw proxy request: {error}"))
+        })?;
+
+        let operation = async move {
+            let response = spin_sdk::wasip3::http::client::send(wasi_request)
+                .await
+                .map_err(|error| {
+                    Report::new(PlatformError::HttpClient)
+                        .attach(format!("Spin raw proxy request failed: {error}"))
+                })?;
+            let status = response.get_status_code();
+            let headers = response.get_headers();
+            let evidence = ProxyResponseEvidenceV1 {
+                status,
+                content_type: Self::raw_header_evidence(&headers, "content-type"),
+                content_encoding: Self::raw_header_evidence(&headers, "content-encoding"),
+                content_length: Self::raw_header_evidence(&headers, "content-length"),
+            };
+            if Self::canonical_declared_length(&evidence.content_length)
+                .is_some_and(|length| length > policy.max_response_bytes)
+            {
+                return Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy declared body exceeds configured cap"));
+            }
+
+            let mut incoming = IncomingResponseBody::new(response).map_err(|error| {
+                Report::new(PlatformError::HttpClient)
+                    .attach(format!("failed to open Spin raw proxy body: {error}"))
+            })?;
+            let mut body = Vec::new();
+            while let Some(frame) = incoming.frame().await {
+                let frame = frame.map_err(|error| {
+                    Report::new(PlatformError::HttpClient)
+                        .attach(format!("failed to read Spin raw proxy body: {error}"))
+                })?;
+                let Ok(data) = frame.into_data() else {
+                    continue;
+                };
+                let next_len = body.len().checked_add(data.len()).ok_or_else(|| {
+                    Report::new(PlatformError::HttpClient).attach("raw proxy body length overflow")
+                })?;
+                if next_len > policy.max_response_bytes {
+                    return Err(Report::new(PlatformError::HttpClient)
+                        .attach("raw proxy body exceeds configured cap"));
+                }
+                body.extend_from_slice(&data);
+            }
+            Ok(RawProxyResponseV1 { evidence, body })
+        }
+        .boxed_local();
+        let deadline = spin_sdk::time::sleep(policy.total_timeout).boxed_local();
+        match futures::future::select(operation, deadline).await {
+            Either::Left((result, _)) => result,
+            Either::Right(((), _)) => {
+                Err(Report::new(PlatformError::HttpClient)
+                    .attach("raw proxy total deadline exceeded"))
+            }
+        }
+    }
 }
 
 #[cfg(all(feature = "spin", target_arch = "wasm32"))]
@@ -571,6 +799,14 @@ impl PlatformHttpClient for SpinPlatformHttpClient {
         self.execute(request).await
     }
 
+    async fn send_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        self.execute_raw_proxy_v1(request, policy).await
+    }
+
     async fn send_async(
         &self,
         request: PlatformHttpRequest,
@@ -815,6 +1051,22 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "aps-runner-proxy-integration-test")]
+    #[test]
+    fn aps_test_transport_mapping_preserves_logical_authority_until_lowering() {
+        use trusted_server_core::integrations::aps::APS_RUNNER_UPSTREAM_URL;
+
+        let endpoint = "http://127.0.0.1:49152/prebid-creative.js";
+        let transport = aps_runner_proxy_transport_uri(APS_RUNNER_UPSTREAM_URL, endpoint)
+            .expect("loopback integration endpoint should be accepted")
+            .expect("fixed APS URL should select the integration transport");
+        assert_eq!(transport.to_string(), endpoint);
+        let logical: edgezero_core::http::Uri = APS_RUNNER_UPSTREAM_URL
+            .parse()
+            .expect("fixed APS URL should parse");
+        assert_eq!(logical.host(), Some("client.aps.amazon-adsystem.com"));
+    }
+
     fn make_ctx_without_spin_context() -> RequestContext {
         let req = request_builder()
             .method("GET")
diff --git a/crates/trusted-server-adapter-spin/tests/routes.rs b/crates/trusted-server-adapter-spin/tests/routes.rs
index f75ea687e..d9cfa64c7 100644
--- a/crates/trusted-server-adapter-spin/tests/routes.rs
+++ b/crates/trusted-server-adapter-spin/tests/routes.rs
@@ -20,14 +20,19 @@ use trusted_server_core::settings::Settings;
 /// The handler regex is the production-shaped `^/_ts/admin`, matching
 /// `Settings::ADMIN_ENDPOINTS` and the default config, so the canonical
 /// `/_ts/admin/keys/*` routes are auth-gated exactly as in production.
-fn test_router() -> RouterService {
-    let settings = Settings::from_toml(
+fn test_settings() -> Settings {
+    Settings::from_toml(
         r#"
             [[handlers]]
             path = "^/_ts/admin"
             username = "admin"
             password = "admin-pass"
 
+            [[handlers]]
+            path = "^/integrations/aps"
+            username = "aps-user"
+            password = "aps-pass"
+
             [publisher]
             domain = "test-publisher.example.com"
             cookie_domain = ".test-publisher.example.com"
@@ -36,11 +41,27 @@ fn test_router() -> RouterService {
 
             [ec]
             passphrase = "test-secret-key-32-bytes-minimum"
+
+            [auction]
+            enabled = true
+            timeout_ms = 1000
+
+            [auction.providers.aps-main]
+            protocol = "openrtb-2.6"
+            profile = "aps"
+            endpoint = "https://aps.example/e/pb/bid"
+            routing = "all_eligible"
+
+            [auction.providers.aps-main.profile_config]
+            account_id = "route-test-aps-account"
+            allow_script_creatives = true
         "#,
     )
-    .expect("should parse route test settings");
+    .expect("should parse route test settings")
+}
 
-    TrustedServerApp::routes_with_settings(settings)
+fn test_router() -> RouterService {
+    TrustedServerApp::routes_with_settings(test_settings())
         .expect("should build router from test settings")
 }
 
@@ -48,6 +69,13 @@ async fn route(router: RouterService, req: Request) -> Response {
     router.oneshot(req).await.expect("should route request")
 }
 
+async fn route_reserved(req: Request) -> Response {
+    trusted_server_adapter_spin::app::dispatch_reserved_with_settings(test_settings(), req)
+        .await
+        .expect("should build APS dispatcher")
+        .expect("APS family should be reserved")
+}
+
 #[test]
 fn routes_build_without_panic() {
     // build_state() may fail (no real settings in CI) — startup_error_router
@@ -55,6 +83,77 @@ fn routes_build_without_panic() {
     let _router = TrustedServerApp::routes();
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn aps_cutover_renderer_and_family_failures_are_local() {
+    let renderer = request_builder()
+        .method("GET")
+        .uri("/integrations/aps/renderer/v2")
+        .header("authorization", "Bearer must-not-reach-publisher")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build APS renderer request");
+    let response = route_reserved(renderer).await;
+    assert_eq!(response.status().as_u16(), 200);
+    assert_eq!(
+        response.headers()["content-type"],
+        "text/html; charset=utf-8"
+    );
+    assert_eq!(
+        response.headers()["cache-control"],
+        "public, max-age=31536000, immutable"
+    );
+    assert!(!response.headers().contains_key("x-frame-options"));
+    let body = response.into_body().into_bytes().unwrap_or_default();
+    let body = std::str::from_utf8(&body).expect("renderer should be UTF-8");
+    assert!(body.contains("TS APS Bootstrap Ready"));
+    assert!(body.contains("TS APS Bootstrap Configure"));
+    assert!(body.contains("/integrations/aps/runner.js"));
+    assert!(body.contains("data:text/html;charset=utf-8,"));
+    assert!(!body.contains("client.aps.amazon-adsystem.com"));
+
+    for (method, path, expected) in [
+        ("POST", "/integrations/aps/runner.js", 405),
+        ("TRACE", "/integrations/aps/renderer/v2", 405),
+        ("CONNECT", "/integrations/aps/renderer/v2", 405),
+        ("PROPFIND", "/integrations/aps/renderer/v2", 405),
+        ("GET", "/integrations/aps/renderer", 404),
+        ("GET", "/integrations/aps/renderer/v1", 404),
+        ("GET", "/integrations/aps/runner/v1.js", 404),
+        ("GET", "/integrations/aps", 404),
+    ] {
+        let request = request_builder()
+            .method(method)
+            .uri(path)
+            .header("authorization", "Bearer must-not-reach-publisher")
+            .body(edgezero_core::body::Body::empty())
+            .expect("should build APS family request");
+        let response = route_reserved(request).await;
+        assert_eq!(response.status().as_u16(), expected, "{method} {path}");
+        assert_eq!(response.headers()["cache-control"], "no-store");
+        assert!(!response.headers().contains_key("x-geo-info-available"));
+        if expected == 405 {
+            assert_eq!(response.headers()["allow"], "GET");
+            assert_eq!(response.headers().len(), 2, "{method} {path}");
+        } else {
+            assert_eq!(response.headers().len(), 1, "{method} {path}");
+        }
+        assert!(
+            response
+                .into_body()
+                .into_bytes()
+                .unwrap_or_default()
+                .is_empty()
+        );
+    }
+
+    let protected_control = request_builder()
+        .method("GET")
+        .uri("/integrations/apsx")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build protected non-APS boundary request");
+    let response = route(test_router(), protected_control).await;
+    assert_eq!(response.status().as_u16(), 401);
+}
+
 #[test]
 fn edgezero_manifest_loads_and_resolves_spin_stores() {
     let loader = edgezero_core::manifest::ManifestLoader::load_from_str(include_str!(
@@ -366,33 +465,32 @@ async fn tsjs_route_is_routed_not_5xx() {
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn tsjs_route_matching_hash_uses_s_maxage_fallback() {
-    let router = test_router();
-    let src = trusted_server_core::tsjs::tsjs_script_src(&["creative"]);
-    let req = request_builder()
-        .method("GET")
-        .uri(src)
-        .body(edgezero_core::body::Body::empty())
-        .expect("should build request");
-
-    let resp = route(router, req).await;
+async fn tsjs_wrong_methods_are_local_no_store_404s() {
+    for method in ["HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"] {
+        let req = request_builder()
+            .method(method)
+            .uri(format!(
+                "/static/tsjs=tsjs-unified.min.js?v={}",
+                "0".repeat(64)
+            ))
+            .body(edgezero_core::body::Body::empty())
+            .expect("should build wrong-method TSJS request");
+        let response = route(test_router(), req).await;
 
-    assert_eq!(
-        resp.status().as_u16(),
-        200,
-        "matching TSJS hash should serve OK"
-    );
-    assert_eq!(
-        resp.headers()
-            .get("cache-control")
-            .and_then(|value| value.to_str().ok()),
-        Some("public, max-age=31536000, s-maxage=31536000, immutable"),
-        "Spin adapter should render the portable s-maxage fallback"
-    );
-    assert!(
-        resp.headers().get("surrogate-control").is_none(),
-        "s-maxage fallback must not emit Fastly Surrogate-Control"
-    );
+        assert_eq!(response.status().as_u16(), 404, "method {method}");
+        assert_eq!(
+            response
+                .headers()
+                .get("cache-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("no-store"),
+            "method {method}"
+        );
+        assert!(
+            !response.headers().contains_key("location"),
+            "method {method}"
+        );
+    }
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -516,54 +614,30 @@ async fn auction_is_routed() {
     assert_ne!(resp.status().as_u16(), 404, "/auction must be routed");
 }
 
-/// `GET` on the SPA re-auction endpoint must reach the page-bids handler on
-/// both the canonical path and its deprecated `/__ts/` alias.
-///
-/// The alias is what pre-rename tsjs bundles still request, and on a SPA that
-/// path is what delivers ads for in-session navigations — so a dropped or
-/// misspelled registration silently costs revenue rather than erroring loudly.
-/// Spin registers `GET` and `OPTIONS` separately, so the preflight-denial parity
-/// test does not imply the `GET` side is wired.
-///
-/// Paths are literals rather than `PAGE_BIDS_PATH` / `PAGE_BIDS_LEGACY_PATH`:
-/// this pins the actual URL the client fetches, which asserting a const against
-/// itself would not.
-///
-/// These test settings configure no creative opportunities, so the handler's own
-/// deterministic answer is a 404 `Creative opportunities not configured`. That
-/// body is the anchor: an unregistered path would instead fall through to the
-/// publisher fallback and attempt an outbound fetch to the (nonexistent) test
-/// origin, which cannot produce this message. A bare `!= 404` check would be
-/// wrong here — the handler legitimately returns 404 under this config.
+/// The canonical SPA re-auction path reaches page-bids, while the removed
+/// double-underscore alias is denied locally with 404.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn page_bids_get_is_routed_on_canonical_path_and_alias() {
-    let mut responses = Vec::new();
-
-    for path in ["/_ts/page-bids", "/__ts/page-bids"] {
-        let req = request_builder()
-            .method("GET")
-            .uri(path)
-            .header("sec-fetch-site", "same-origin")
-            .body(edgezero_core::body::Body::empty())
-            .expect("should build request");
-        let resp = route(test_router(), req).await;
-        let status = resp.status().as_u16();
-        let body = String::from_utf8_lossy(&resp.into_body().into_bytes().unwrap_or_default())
+async fn page_bids_get_is_routed_only_on_the_canonical_path() {
+    let canonical = request_builder()
+        .method("GET")
+        .uri("/_ts/page-bids")
+        .header("sec-fetch-site", "same-origin")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build request");
+    let canonical = route(test_router(), canonical).await;
+    let canonical_body =
+        String::from_utf8_lossy(&canonical.into_body().into_bytes().unwrap_or_default())
             .into_owned();
+    assert!(canonical_body.contains("Creative opportunities not configured"));
 
-        assert!(
-            body.contains("Creative opportunities not configured"),
-            "GET {path} must reach the page-bids handler, \
-             got status {status} body {body:?}"
-        );
-
-        responses.push((status, body));
-    }
-
-    assert_eq!(
-        responses[0], responses[1],
-        "the deprecated alias must answer identically to the canonical path"
-    );
+    let former_alias = request_builder()
+        .method("GET")
+        .uri("/__ts/page-bids")
+        .header("sec-fetch-site", "same-origin")
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build request");
+    let former_alias = route(test_router(), former_alias).await;
+    assert_eq!(former_alias.status().as_u16(), 404);
 }
 
 // ---------------------------------------------------------------------------
diff --git a/crates/trusted-server-cli/src/ad_templates/expected.rs b/crates/trusted-server-cli/src/ad_templates/expected.rs
index 9392963ff..1f210dda6 100644
--- a/crates/trusted-server-cli/src/ad_templates/expected.rs
+++ b/crates/trusted-server-cli/src/ad_templates/expected.rs
@@ -152,7 +152,8 @@ mod tests {
             .collect::<Vec<_>>()
             .join(", ");
         let toml = format!(
-            "gam_network_id = \"123\"\n\
+            "enabled = true\n\
+             gam_network_id = \"123\"\n\
              \n\
              [[slot]]\n\
              id = \"atf\"\n\
@@ -202,7 +203,8 @@ mod tests {
 
     #[test]
     fn expected_slots_default_resolution_without_overrides() {
-        let toml = "gam_network_id = \"42\"\n\
+        let toml = "enabled = true\n\
+             gam_network_id = \"42\"\n\
              \n\
              [[slot]]\n\
              id = \"footer\"\n\
@@ -223,7 +225,8 @@ mod tests {
 
     #[test]
     fn expected_slots_render_section_templates_per_path() {
-        let toml = "gam_network_id = \"99999\"\n\
+        let toml = "enabled = true\n\
+             gam_network_id = \"99999\"\n\
              section_root = \"homepage\"\n\
              \n\
              [[slot]]\n\
@@ -256,9 +259,10 @@ mod tests {
     #[test]
     fn expected_slots_omit_dynamic_template_the_runtime_cannot_render() {
         // A `{section}` template that renders past GAM's 100-byte unit-path
-        // limit. The runtime omits this slot for the request path, so diagnostics
-        // must not match it against a truncated or otherwise different path.
-        let toml = "gam_network_id = \"99999\"\n\
+        // limit. `validate_runtime` rejects this config, so the verifier reports
+        // the slot as unconfirmable rather than matching a truncated path.
+        let toml = "enabled = true\n\
+             gam_network_id = \"99999\"\n\
              section_root = \"homepage\"\n\
              \n\
              [[slot]]\n\
diff --git a/crates/trusted-server-cli/src/commands/audit/ad_templates.rs b/crates/trusted-server-cli/src/commands/audit/ad_templates.rs
index 0e2b51371..8155e2724 100644
--- a/crates/trusted-server-cli/src/commands/audit/ad_templates.rs
+++ b/crates/trusted-server-cli/src/commands/audit/ad_templates.rs
@@ -632,7 +632,8 @@ mod tests {
     }
 
     fn news_config() -> CreativeOpportunitiesConfig {
-        let toml = "gam_network_id = \"123\"\n\
+        let toml = "enabled = true\n\
+             gam_network_id = \"123\"\n\
              \n\
              [[slot]]\n\
              id = \"atf\"\n\
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 490ccba80..61952c1a8 100644
--- a/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
+++ b/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
@@ -1724,7 +1724,7 @@ mod tests {
     #[test]
     fn merge_refuses_to_change_policy_used_by_preserved_templates() {
         let existing: CreativeOpportunitiesConfig = toml::from_str(
-            "gam_network_id = \"123\"\nsection_root = \"home\"\nsection_segment = 0\n\
+            "enabled = true\ngam_network_id = \"123\"\nsection_root = \"home\"\nsection_segment = 0\n\
              [[slot]]\nid = \"header\"\ndiv_id = \"ad-header\"\n\
              gam_unit_path = \"/{network_id}/site/{section}\"\npage_patterns = [\"/\"]\n\
              formats = [{ width = 728, height = 90 }]\n",
@@ -1804,7 +1804,7 @@ mod tests {
         // rather than demand `--replace` (which would discard the hand-tuned
         // slots it is preserving).
         let existing: CreativeOpportunitiesConfig = toml::from_str(
-            "gam_network_id = \"123\"\n\
+            "enabled = true\ngam_network_id = \"123\"\n\
              [[slot]]\nid = \"header\"\ndiv_id = \"ad-header\"\n\
              gam_unit_path = \"/{network_id}/site/{section}\"\npage_patterns = [\"/\"]\n\
              formats = [{ width = 728, height = 90 }]\n",
@@ -1822,7 +1822,7 @@ mod tests {
     #[test]
     fn merge_preserves_an_explicit_segment_when_section_root_is_unset() {
         let existing: CreativeOpportunitiesConfig = toml::from_str(
-            "gam_network_id = \"123\"\nsection_segment = 1\n\
+            "enabled = true\ngam_network_id = \"123\"\nsection_segment = 1\n\
              [[slot]]\nid = \"header\"\ndiv_id = \"ad-header\"\n\
              gam_unit_path = \"/{network_id}/site/{section}\"\npage_patterns = [\"/\"]\n\
              formats = [{ width = 728, height = 90 }]\n",
@@ -2143,7 +2143,7 @@ mod tests {
         let config_path = temp.path().join("trusted-server.toml");
         fs::write(
             &config_path,
-            "[creative_opportunities]\ngam_network_id = \"111\"\n",
+            "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n",
         )
         .expect("should write config");
         // The requested URL redirects; slots are scraped from the final page.
@@ -2862,7 +2862,7 @@ mod tests {
     fn update_slots_rejects_invalid_page_pattern_without_touching_config() {
         let temp = TempDir::new().expect("should create temp dir");
         let config_path = temp.path().join("trusted-server.toml");
-        let original = "[creative_opportunities]\ngam_network_id = \"111\"\n";
+        let original = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n";
         fs::write(&config_path, original).expect("should write config");
         let collector = FakeCollector::new(collected_page_with_header_slot());
         let mut out = Vec::new();
@@ -2971,7 +2971,7 @@ mod tests {
         let config_path = temp.path().join("trusted-server.toml");
         fs::write(
             &config_path,
-            "[creative_opportunities]\ngam_network_id = \"111\"\n",
+            "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n",
         )
         .expect("should write config");
         let collector = FakeCollector::new(collected_page_with_header_slot());
@@ -3009,7 +3009,7 @@ mod tests {
         let config_path = temp.path().join("trusted-server.toml");
         fs::write(
             &config_path,
-            "[creative_opportunities]\ngam_network_id = \"111\"\n",
+            "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n",
         )
         .expect("should write config");
         let collector = FakeCollector::new(collected_page_with_header_slot());
diff --git a/crates/trusted-server-cli/src/commands/audit/generate/slot_toml.rs b/crates/trusted-server-cli/src/commands/audit/generate/slot_toml.rs
index f795ea41b..2215010cf 100644
--- a/crates/trusted-server-cli/src/commands/audit/generate/slot_toml.rs
+++ b/crates/trusted-server-cli/src/commands/audit/generate/slot_toml.rs
@@ -673,6 +673,9 @@ pub(super) fn splice_creative_slots(
     // retain positions from their source document, so anchor the whole subtree
     // here to keep the parent, slots, and provider tables together.
     creative.set_position(section_position);
+    if !had_section {
+        creative["enabled"] = toml_edit::value(true);
+    }
     if let Some(network_id) = keys.network_id {
         creative["gam_network_id"] = toml_edit::value(network_id);
     }
@@ -688,13 +691,17 @@ pub(super) fn splice_creative_slots(
     if uses_crlf(existing) {
         result = convert_document_lf_to_crlf(&result);
     }
-    ensure_only_managed_fields_changed(existing, &result)?;
+    ensure_only_managed_fields_changed(existing, &result, !had_section)?;
     Ok(result)
 }
 
 /// Verifies that the structural update changed only generator-managed fields.
-fn ensure_only_managed_fields_changed(before: &str, after: &str) -> CliResult<()> {
-    fn unmanaged(document: &str) -> CliResult<toml::Value> {
+fn ensure_only_managed_fields_changed(
+    before: &str,
+    after: &str,
+    generated_enabled: bool,
+) -> CliResult<()> {
+    fn unmanaged(document: &str, remove_enabled: bool) -> CliResult<toml::Value> {
         let mut value = toml::from_str::<toml::Value>(document)
             .map_err(|error| report_error(format!("failed to validate updated config: {error}")))?;
         if let Some(root) = value.as_table_mut() {
@@ -705,6 +712,9 @@ fn ensure_only_managed_fields_changed(before: &str, after: &str) -> CliResult<()
                 for key in ["slot", "gam_network_id", "section_root", "section_segment"] {
                     creative.remove(key);
                 }
+                if remove_enabled {
+                    creative.remove("enabled");
+                }
                 creative.is_empty()
             } else {
                 false
@@ -716,7 +726,7 @@ fn ensure_only_managed_fields_changed(before: &str, after: &str) -> CliResult<()
         Ok(value)
     }
 
-    if unmanaged(before)? != unmanaged(after)? {
+    if unmanaged(before, false)? != unmanaged(after, generated_enabled)? {
         return cli_error(
             "refusing to update config because fields outside the managed \
              creative-opportunities keys would change",
@@ -955,13 +965,14 @@ slot_id = "sidebar"
     }
 
     fn existing_config(toml_str: &str) -> CreativeOpportunitiesConfig {
-        toml::from_str::<CreativeOpportunitiesConfig>(toml_str).expect("valid creative config")
+        toml::from_str::<CreativeOpportunitiesConfig>(&format!("enabled = true\n{toml_str}"))
+            .expect("valid creative config")
     }
 
     #[test]
     fn splice_replaces_slots_and_preserves_other_sections() {
         let existing = "[publisher]\ndomain = \"x\"\n\n\
-             [creative_opportunities]\ngam_network_id = \"111\"\nprice_granularity = \"dense\"\n\n\
+             [creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\nprice_granularity = \"dense\"\n\n\
              [[creative_opportunities.slot]]\nid = \"old\"\ndiv_id = \"old\"\n\
              gam_unit_path = \"/111/old\"\npage_patterns = [\"/\"]\n\
              formats = [{ width = 300, height = 250 }]\n\n\
@@ -974,6 +985,10 @@ slot_id = "sidebar"
             out.contains("gam_network_id = \"222\""),
             "network id updated"
         );
+        assert!(
+            out.contains("enabled = true"),
+            "hard-cutover enablement should be preserved"
+        );
         assert!(!out.contains("id = \"old\""), "old slot removed");
         assert!(
             out.contains("gam_unit_path = \"/222/homepage/header\""),
@@ -991,8 +1006,11 @@ slot_id = "sidebar"
     }
 
     #[test]
-    fn splice_updates_a_quoted_section_header_structurally() {
-        let existing = "[\"creative_opportunities\"]\ngam_network_id = \"111\"\n";
+    fn splice_rejects_quoted_section_header_instead_of_duplicating_it() {
+        // A quoted header is valid TOML but the line-based splice does not
+        // recognise it; appending a second `[creative_opportunities]` would
+        // produce a document that no longer parses.
+        let existing = "[\"creative_opportunities\"]\nenabled = true\ngam_network_id = \"111\"\n";
 
         let updated = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
             .expect("should update quoted table structurally");
@@ -1094,7 +1112,7 @@ slot_id = "sidebar"
 
     #[test]
     fn splice_rejects_top_level_inline_creative_opportunities_table() {
-        let existing = "creative_opportunities = { gam_network_id = \"111\" }\n";
+        let existing = "creative_opportunities = { enabled = true, gam_network_id = \"111\" }\n";
 
         let error = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
             .expect_err("should refuse a top-level inline table");
@@ -1122,7 +1140,7 @@ slot_id = "sidebar"
     fn splice_inserts_section_policy_keys_a_config_does_not_have_yet() {
         // The whole point of `upsert`: every config predating templating lacks
         // these keys, so a replace-only writer could never add them.
-        let existing = "[creative_opportunities]\ngam_network_id = \"111\"\n\n\
+        let existing = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n\n\
              [auction]\nenabled = true\n";
 
         let out = splice_creative_slots(
@@ -1146,7 +1164,7 @@ slot_id = "sidebar"
 
     #[test]
     fn splice_replaces_section_policy_keys_that_are_already_present() {
-        let existing = "[creative_opportunities]\ngam_network_id = \"111\"\n\
+        let existing = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n\
              section_root = \"old\"\nsection_segment = 2\n";
 
         let out = splice_creative_slots(
@@ -1172,7 +1190,7 @@ slot_id = "sidebar"
         // `section_root`/`section_segment` are `deny_unknown_fields` additions:
         // writing them into a config that does not need them would make it
         // unloadable by an older binary for no benefit.
-        let existing = "[creative_opportunities]\ngam_network_id = \"111\"\n";
+        let existing = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n";
 
         let out = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
             .expect("should splice");
@@ -1196,11 +1214,35 @@ slot_id = "sidebar"
 
         let value = toml::from_str::<toml::Value>(&out).expect("valid TOML");
         let creative = &value["creative_opportunities"];
+        assert_eq!(creative["enabled"].as_bool(), Some(true));
         assert_eq!(creative["gam_network_id"].as_str(), Some("222"));
         assert_eq!(creative["section_root"].as_str(), Some("homepage"));
         assert_eq!(creative["section_segment"].as_integer(), Some(0));
     }
 
+    #[test]
+    fn splice_keeps_an_inserted_key_inside_the_section_scalar_block() {
+        // Appending at the end of the section would land the key after a
+        // subtable, where TOML reads it as part of that subtable instead.
+        let document = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n\n\
+             [[creative_opportunities.slot]]\nid = \"a\"\n\
+             page_patterns = [\"/\"]\nformats = [{ width = 1, height = 1 }]\n";
+
+        let out = splice_creative_slots(
+            document,
+            &template_keys("111", "homepage", 0),
+            &header_rendered(),
+        )
+        .expect("should insert");
+
+        let value = toml::from_str::<toml::Value>(&out).expect("valid TOML");
+        assert_eq!(
+            value["creative_opportunities"]["section_root"].as_str(),
+            Some("homepage"),
+            "the key must belong to the section, not the slot subtable"
+        );
+    }
+
     #[test]
     fn splice_refuses_fresh_section_without_a_network_id() {
         // Reachable whenever the scraped unit path has no all-digit leading
@@ -1234,6 +1276,10 @@ slot_id = "sidebar"
             value["creative_opportunities"]["gam_network_id"].as_str(),
             Some("222")
         );
+        assert_eq!(
+            value["creative_opportunities"]["enabled"].as_bool(),
+            Some(true)
+        );
     }
 
     #[test]
@@ -1241,6 +1287,7 @@ slot_id = "sidebar"
         // Mirrors the templated operator shape: section policy scalars in the
         // head block and a per-slot prebid provider subtable.
         let existing = "[creative_opportunities]\n\
+             enabled = true\n\
              gam_network_id = \"111\"\n\
              auction_timeout_ms = 2000\n\
              section_root = \"homepage\"\n\n\
@@ -1256,6 +1303,7 @@ slot_id = "sidebar"
         let existing_config = existing_config(
             &existing
                 .replace("[creative_opportunities]\n", "")
+                .replacen("enabled = true\n", "", 1)
                 .replace("[[creative_opportunities.slot]]", "[[slot]]")
                 .replace("[creative_opportunities.slot.", "[slot.")
                 .replace("\n[auction]\nenabled = true\n", ""),
@@ -1297,7 +1345,7 @@ slot_id = "sidebar"
 
     #[test]
     fn splice_preserves_crlf_line_endings() {
-        let existing = "[creative_opportunities]\r\ngam_network_id = \"111\"\r\n\r\n\
+        let existing = "[creative_opportunities]\r\nenabled = true\r\ngam_network_id = \"111\"\r\n\r\n\
              [auction]\r\nenabled = true\r\n";
 
         let out = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
@@ -1487,7 +1535,7 @@ slot_id = "sidebar"
     fn splice_recognizes_inline_commented_section_header() {
         // `[creative_opportunities] # comment` is valid TOML; the splice must
         // update it in place instead of appending a duplicate section.
-        let existing = "[creative_opportunities] # ad templates\ngam_network_id = \"111\"\n\n\
+        let existing = "[creative_opportunities] # ad templates\nenabled = true\ngam_network_id = \"111\"\n\n\
              [auction] # flags\nenabled = true\n";
 
         let out = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
@@ -1519,8 +1567,7 @@ slot_id = "sidebar"
 
     #[test]
     fn splice_inserts_when_no_existing_slots() {
-        let existing =
-            "[creative_opportunities]\ngam_network_id = \"111\"\n\n[auction]\nenabled = true\n";
+        let existing = "[creative_opportunities]\nenabled = true\ngam_network_id = \"111\"\n\n[auction]\nenabled = true\n";
 
         let out = splice_creative_slots(existing, &network_keys("222"), &header_rendered())
             .expect("should splice");
@@ -1545,6 +1592,7 @@ slot_id = "sidebar"
     #[test]
     fn splice_replaces_inline_slot_array() {
         let existing = "[creative_opportunities]\n\
+             enabled = true\n\
              gam_network_id = \"111\"\n\
              slot = [{ id = \"old\", div_id = \"old\", gam_unit_path = \"/111/old\", page_patterns = [\"/\"], formats = [{ width = 300, height = 250 }] }]\n\n\
              [auction]\nenabled = true\n";
@@ -1568,6 +1616,7 @@ slot_id = "sidebar"
     #[test]
     fn splice_replaces_inline_slot_map() {
         let existing = "[creative_opportunities]\n\
+             enabled = true\n\
              gam_network_id = \"111\"\n\
              slot = { \"0\" = { id = \"old\", div_id = \"old\", gam_unit_path = \"/111/old\", page_patterns = [\"/\"], formats = [{ width = 300, height = 250 }] } }\n";
 
@@ -2205,7 +2254,7 @@ slot_id = "sidebar"
 
     #[test]
     fn replace_key_handles_inline_commented_headers() {
-        let document = "[creative_opportunities] # managed\ngam_network_id = \"111\"\n\n\
+        let document = "[creative_opportunities] # managed\nenabled = true\ngam_network_id = \"111\"\n\n\
              [auction] # flags\nenabled = true\n";
 
         let updated = replace_key_in_section(
@@ -2242,7 +2291,7 @@ slot_id = "sidebar"
             false,
         );
         let doc = format!(
-            "[creative_opportunities]\ngam_network_id = \"1\"\n{}",
+            "[creative_opportunities]\nenabled = true\ngam_network_id = \"1\"\n{}",
             render_slots(&merged)
         );
 
diff --git a/crates/trusted-server-cli/src/commands/audit/mod.rs b/crates/trusted-server-cli/src/commands/audit/mod.rs
index 211060662..d2f549f96 100644
--- a/crates/trusted-server-cli/src/commands/audit/mod.rs
+++ b/crates/trusted-server-cli/src/commands/audit/mod.rs
@@ -484,7 +484,7 @@ mod tests {
     #[test]
     fn invalid_setting_outside_the_section_still_yields_creative_config() {
         let document = "unknown_runtime_key = true\n\
-            [creative_opportunities]\ngam_network_id = \"123\"\n";
+            [creative_opportunities]\nenabled = true\ngam_network_id = \"123\"\n";
 
         let creative = creative_config(document, std::path::Path::new("trusted-server.toml"))
             .expect("an unrelated invalid setting must not hide creative config")
diff --git a/crates/trusted-server-cli/tests/config_env_overlay.rs b/crates/trusted-server-cli/tests/config_env_overlay.rs
index 45eab5cc9..abe0006cb 100644
--- a/crates/trusted-server-cli/tests/config_env_overlay.rs
+++ b/crates/trusted-server-cli/tests/config_env_overlay.rs
@@ -47,11 +47,12 @@ fn migrated_project() -> MigratedProject {
     let mut document = LEGACY_CONFIG
         .parse::<DocumentMut>()
         .expect("should parse legacy integration config");
-    // EdgeZero environment overlays cannot create missing TOML leaves,
-    // so a migrated config must carry every leaf whose environment override is
+    // EdgeZero environment overlays cannot create missing TOML leaves, so a
+    // migrated config must carry every leaf whose environment override is
     // expected to take effect.
     document["auction"]["rewrite_creatives"] = value(true);
     document["auction"]["sanitize_creatives"] = value(false);
+    document["integrations"]["gpt"]["gam_attribution_enabled"] = value(false);
     document["creative_opportunities"]["enabled"] = value(true);
     document["creative_opportunities"]["gam_network_id"] = value("123456789");
     document["auction"]["providers"]["pbs-main"] = toml_edit::table();
@@ -165,7 +166,7 @@ fn migrated_config_applies_boolean_environment_overrides() {
     assert_eq!(
         envelope["data"]["integrations"]["gpt"]["gam_attribution_enabled"],
         serde_json::Value::Bool(true),
-        "pushed config should contain the GAM attribution environment override"
+        "pushed config should contain the GAM attribution environment override: {envelope}"
     );
     assert_eq!(
         envelope["data"]["creative_opportunities"]["enabled"],
diff --git a/crates/trusted-server-core/benches/html_processor_bench.rs b/crates/trusted-server-core/benches/html_processor_bench.rs
index 19aa0b82f..ead5be30f 100644
--- a/crates/trusted-server-core/benches/html_processor_bench.rs
+++ b/crates/trusted-server-core/benches/html_processor_bench.rs
@@ -8,6 +8,7 @@ use trusted_server_core::streaming_processor::StreamProcessor as _;
 fn make_config() -> HtmlProcessorConfig {
     HtmlProcessorConfig {
         csp_nonce_observed: None,
+        csp_nonce: None,
         origin_host: "origin.bench.example.com".to_string(),
         request_host: "proxy.bench.example.com".to_string(),
         request_scheme: "https".to_string(),
@@ -16,11 +17,9 @@ fn make_config() -> HtmlProcessorConfig {
         ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(None)),
         max_buffered_body_bytes: 16 * 1024 * 1024,
         gpt_diagnostics: None,
-        // The benchmark measures URL rewriting, not ad injection, and
-        // `ad_slots_script` is `None` here — matching the previous behaviour,
-        // which inferred no body-close work from that.
-        body_close: BodyCloseInjection::None,
+        render_trace_overlay: false,
         suppress_datadome_client_side_tag: false,
+        body_close: BodyCloseInjection::None,
     }
 }
 
diff --git a/crates/trusted-server-core/src/auction/endpoints.rs b/crates/trusted-server-core/src/auction/endpoints.rs
index de05dfdd8..1966ce9ee 100644
--- a/crates/trusted-server-core/src/auction/endpoints.rs
+++ b/crates/trusted-server-core/src/auction/endpoints.rs
@@ -1,6 +1,6 @@
 //! HTTP endpoint handlers for auction requests.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt};
@@ -20,20 +20,21 @@ use crate::ec::log_id;
 use crate::ec::prebid_eids::parse_prebid_eids_cookie;
 use crate::ec::registry::PartnerRegistry;
 use crate::error::TrustedServerError;
+use crate::http_util::RequestInfo;
 use crate::openrtb::{Eid, Uid};
 use crate::platform::RuntimeServices;
 use crate::settings::Settings;
 
 use super::AuctionOrchestrator;
-use super::formats::{
-    convert_to_openrtb_response, convert_to_openrtb_response_with_report,
-    convert_tsjs_to_auction_request,
-};
+use super::formats::{attach_auction_response_headers, convert_tsjs_to_auction_request};
 use super::telemetry::{
     AuctionObservationContext, AuctionSource, AuctionTerminalOutcome, build_auction_events,
     emit_auction_events_best_effort_lazy,
 };
-use super::types::AuctionContext;
+use super::types::{
+    AuctionContext, AuctionDecisionSetV1, AuctionRequest, AuctionSlotFailureReason,
+    SlotAuctionDecisionV1, SystemAuctionIdentityGenerator,
+};
 
 const MAX_CLIENT_EID_SOURCES: usize = 64;
 const MAX_CLIENT_UIDS_PER_SOURCE: usize = 32;
@@ -45,6 +46,66 @@ const MAX_CLIENT_EID_SOURCE_BYTES: usize = 255;
 /// arbitrary WASM linear memory.
 const MAX_AUCTION_BODY_SIZE: usize = 256 * 1024;
 
+struct ExactAuctionResponseV1 {
+    response: Response<EdgeBody>,
+    delivered_winner_slots: HashSet<String>,
+    dropped_winner_count: usize,
+}
+
+fn exact_auction_response_v1(
+    result: &OrchestrationResult,
+    settings: &Settings,
+    auction_request: &AuctionRequest,
+    request_origin: &str,
+    ec_allowed: bool,
+) -> Result<ExactAuctionResponseV1, Report<TrustedServerError>> {
+    let price_granularity = settings
+        .creative_opportunities
+        .as_ref()
+        .map(|config| config.price_granularity)
+        .unwrap_or_default();
+    let canonical = crate::publisher::coordinated_cutover_v1::build_browser_auction_projection_v1(
+        result,
+        price_granularity,
+        settings,
+        request_origin,
+        None,
+        &SystemAuctionIdentityGenerator,
+    )?;
+    let body = crate::auction::formats::coordinated_cutover_v1::serialize_trusted_server_auction_response_v1(
+        &canonical,
+    )?;
+    let delivered_winner_slots: HashSet<String> = canonical
+        .projection
+        .auction
+        .results
+        .iter()
+        .filter_map(|decision| match decision {
+            SlotAuctionDecisionV1::Winner { slot, .. } => Some(slot.clone()),
+            _ => None,
+        })
+        .collect();
+    let projected_winner_count = result
+        .decision_set
+        .results
+        .iter()
+        .filter(|decision| matches!(decision, SlotAuctionDecisionV1::Winner { .. }))
+        .count();
+    let mut response = Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "application/json")
+        .body(EdgeBody::from(body))
+        .change_context(TrustedServerError::Auction {
+            message: "Failed to build exact auction response".to_string(),
+        })?;
+    attach_auction_response_headers(&mut response, auction_request, ec_allowed)?;
+    Ok(ExactAuctionResponseV1 {
+        response,
+        dropped_winner_count: projected_winner_count.saturating_sub(delivered_winner_slots.len()),
+        delivered_winner_slots,
+    })
+}
+
 /// Handle auction request from `POST /auction`.
 ///
 /// Accepts a JSON body matching [`AdRequest`][`super::formats::AdRequest`].
@@ -168,6 +229,22 @@ pub async fn handle_auction(
     );
 
     let http_req = Request::from_parts(parts, EdgeBody::empty());
+    let request_info = RequestInfo::from_request(&http_req, services.client_info());
+    let request_scheme = if request_info.scheme.is_empty() {
+        http_req.uri().scheme_str().unwrap_or("https")
+    } else {
+        &request_info.scheme
+    };
+    let request_host = if request_info.host.is_empty() {
+        http_req
+            .uri()
+            .authority()
+            .map(http::uri::Authority::as_str)
+            .unwrap_or(&settings.publisher.domain)
+    } else {
+        &request_info.host
+    };
+    let request_origin = format!("{request_scheme}://{request_host}");
 
     // Story 5 middleware contract: auction is a read-only EC route.
     // It must not generate EC IDs; it only consumes pre-routed context.
@@ -196,13 +273,19 @@ pub async fn handle_auction(
             winning_bids: HashMap::new(),
             total_time_ms: 0,
             metadata: HashMap::new(),
+            decision_set: AuctionDecisionSetV1::failed(
+                &auction_request,
+                AuctionSlotFailureReason::AuctionDisabled,
+            ),
         };
-        return convert_to_openrtb_response(
+        return Ok(exact_auction_response_v1(
             &empty_result,
             settings,
             &auction_request,
+            &request_origin,
             ec_context.ec_allowed(),
-        );
+        )?
+        .response);
     }
 
     // Server-side auction consent gate. The publisher-navigation and
@@ -247,15 +330,21 @@ pub async fn handle_auction(
             provider_responses: Vec::new(),
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1::failed(
+                &auction_request,
+                AuctionSlotFailureReason::ConsentDenied,
+            ),
             total_time_ms: 0,
             metadata: HashMap::new(),
         };
-        return convert_to_openrtb_response(
+        return Ok(exact_auction_response_v1(
             &empty_result,
             settings,
             &auction_request,
+            &request_origin,
             ec_context.ec_allowed(),
-        );
+        )?
+        .response);
     }
 
     // Parse client-provided EIDs from the current request body. When the
@@ -353,10 +442,11 @@ pub async fn handle_auction(
         }
     };
 
-    let conversion = match convert_to_openrtb_response_with_report(
+    let conversion = match exact_auction_response_v1(
         &result,
         settings,
         &auction_request,
+        &request_origin,
         ec_context.ec_allowed(),
     ) {
         Ok(conversion) => conversion,
@@ -384,7 +474,7 @@ pub async fn handle_auction(
             AuctionTerminalOutcome::Completed {
                 request: &auction_request,
                 result: &result,
-                delivered_winner_slots: Some(&conversion.delivery.delivered_winner_slots),
+                delivered_winner_slots: Some(&conversion.delivered_winner_slots),
             },
         )
     })
@@ -393,8 +483,8 @@ pub async fn handle_auction(
     log::info!(
         "Auction completed: {} providers, {} delivered winning bids, {} dropped winners, {}ms total",
         result.provider_responses.len(),
-        conversion.delivery.delivered_winner_slots.len(),
-        conversion.delivery.dropped_winner_count,
+        conversion.delivered_winner_slots.len(),
+        conversion.dropped_winner_count,
         result.total_time_ms
     );
 
@@ -599,10 +689,9 @@ mod tests {
     use crate::consent::types::ConsentContext;
     use crate::openrtb::Uid;
     use crate::platform::test_support::{
-        NoopBackend, NoopConfigStore, NoopGeo, NoopHttpClient, NoopSecretStore, StubHttpClient,
-        noop_services,
+        NoopBackend, NoopConfigStore, NoopGeo, NoopHttpClient, NoopSecretStore, noop_services,
     };
-    use crate::platform::{ClientInfo, PlatformHttpClient, PlatformHttpRequest, PlatformResponse};
+    use crate::platform::{ClientInfo, PlatformResponse};
     use crate::test_support::tests::{crate_test_settings_str, create_test_settings};
     use base64::Engine as _;
     use base64::engine::general_purpose::STANDARD as BASE64;
@@ -688,14 +777,12 @@ mod tests {
         }
     }
 
-    /// Provider used to prove that direct `/auction` remains available when
-    /// publisher server-side ad templates are disabled.
-    struct TemplateSwitchProbeProvider {
-        calls: Arc<Mutex<usize>>,
+    struct CallRecordingProvider {
+        called: Arc<Mutex<bool>>,
     }
 
     #[async_trait::async_trait(?Send)]
-    impl AuctionProvider for TemplateSwitchProbeProvider {
+    impl AuctionProvider for CallRecordingProvider {
         fn provider_name(&self) -> &'static str {
             "template-switch-probe"
         }
@@ -703,26 +790,12 @@ mod tests {
         async fn request_bids(
             &self,
             _request: &AuctionRequest,
-            context: &AuctionContext<'_>,
+            _context: &AuctionContext<'_>,
         ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
-            *self.calls.lock().expect("should lock provider call count") += 1;
-            let request = Request::builder()
-                .method("POST")
-                .uri("https://bidder.example/auction")
-                .body(EdgeBody::empty())
-                .expect("should build probe provider request");
-            context
-                .services
-                .http_client()
-                .send_async(PlatformHttpRequest::new(
-                    request,
-                    "template-switch-probe-backend",
-                ))
-                .await
-                .change_context(TrustedServerError::Auction {
-                    message: "probe provider launch failed".to_string(),
-                })
-                .map(ProviderRequestOutcome::pending)
+            *self.called.lock().expect("should lock provider call flag") = true;
+            Err(Report::new(TrustedServerError::Auction {
+                message: "call recorded".to_string(),
+            }))
         }
 
         async fn parse_response(
@@ -730,11 +803,7 @@ mod tests {
             _response: PlatformResponse,
             _response_time_ms: u64,
         ) -> Result<AuctionResponse, Report<TrustedServerError>> {
-            Ok(AuctionResponse::success(
-                self.provider_name(),
-                Vec::new(),
-                0,
-            ))
+            panic!("parse_response must not run when the launch returns an error");
         }
 
         fn timeout_ms(&self) -> u32 {
@@ -742,7 +811,7 @@ mod tests {
         }
 
         fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option<String> {
-            Some("template-switch-probe-backend".to_string())
+            Some("call-recording-backend".to_string())
         }
     }
 
@@ -754,23 +823,12 @@ mod tests {
         );
         let settings = Settings::from_toml(&settings_toml)
             .expect("should parse settings with disabled templates");
-        let calls = Arc::new(Mutex::new(0));
+        let called = Arc::new(Mutex::new(false));
         let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-        orchestrator.register_provider(Arc::new(TemplateSwitchProbeProvider {
-            calls: Arc::clone(&calls),
+        orchestrator.register_provider(Arc::new(CallRecordingProvider {
+            called: Arc::clone(&called),
         }));
-
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response(200, b"probe response".to_vec());
-        let services = RuntimeServices::builder()
-            .config_store(Arc::new(NoopConfigStore))
-            .secret_store(Arc::new(NoopSecretStore))
-            .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
-            .backend(Arc::new(NoopBackend))
-            .http_client(Arc::clone(&stub) as Arc<dyn PlatformHttpClient>)
-            .geo(Arc::new(NoopGeo))
-            .client_info(ClientInfo::default())
-            .build();
+        let services = noop_services();
         let ec_context = make_ec_context(Jurisdiction::NonRegulated, None);
         let body = json!({
             "adUnits": [{
@@ -786,7 +844,7 @@ mod tests {
             ))
             .expect("should build auction request");
 
-        let response = handle_auction(
+        let _ = handle_auction(
             &settings,
             &orchestrator,
             None,
@@ -795,15 +853,12 @@ mod tests {
             &services,
             req,
         )
-        .await
-        .expect("direct auction should remain available");
+        .await;
 
-        assert_eq!(
-            *calls.lock().expect("should lock provider call count"),
-            1,
-            "disabling publisher templates must not disable direct /auction"
+        assert!(
+            *called.lock().expect("should lock provider call flag"),
+            "direct /auction must remain live when publisher template delivery is disabled"
         );
-        assert_eq!(response.status(), StatusCode::OK);
     }
 
     #[tokio::test]
@@ -871,6 +926,20 @@ mod tests {
             seatbid_empty,
             "gated auction must return no bids, got: {parsed}"
         );
+        assert_eq!(parsed["cur"], "USD");
+        assert_eq!(
+            parsed["ext"]["trusted_server"]["slot_results"]["results"][0],
+            json!({
+                "slot": "div-gpt-ad-1",
+                "outcome": "failed",
+                "reason": "consent_denied"
+            }),
+            "the production endpoint must emit the exact decision-set extension"
+        );
+        assert!(
+            parsed["ext"].get("orchestrator").is_none(),
+            "the removed legacy response extension must not survive the hard cutover"
+        );
 
         let batches = telemetry_sink
             .batches
diff --git a/crates/trusted-server-core/src/auction/formats.rs b/crates/trusted-server-core/src/auction/formats.rs
index 571d9d484..b3474abc7 100644
--- a/crates/trusted-server-core/src/auction/formats.rs
+++ b/crates/trusted-server-core/src/auction/formats.rs
@@ -7,7 +7,7 @@
 use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt, ensure};
 use http::{HeaderValue, Request, Response, StatusCode, header};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use std::collections::{BTreeMap, HashMap, HashSet};
 use url::Url;
@@ -29,8 +29,12 @@ use crate::settings::Settings;
 
 use super::orchestrator::OrchestrationResult;
 use super::types::{
-    AdFormat, AdSlot, AuctionRequest, BidRenderer, DeviceInfo, MediaType, OrchestratorExt,
-    ProviderSummary, PublisherInfo, SiteInfo, UserInfo,
+    AdFormat, AdSlot, AuctionDecisionSetV1, AuctionDropReason, AuctionDropReasons, AuctionRequest,
+    AuctionSlotFailureReason, BidRenderSourceV1, BrowserAuctionBidV1, BrowserAuctionProjectionV1,
+    BrowserAuctionSlotV1, DeviceInfo, MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+    MAX_BROWSER_AUCTION_RESULTS, MAX_BROWSER_AUCTION_TARGETING_ENTRIES, MediaType, OrchestratorExt,
+    ProviderSummary, PublisherInfo, RENDER_DIMENSION_MAX, RENDER_DIMENSION_MIN, SiteInfo,
+    SlotAuctionDecisionV1, UserInfo, classify_aps_renderer_v1, record_auction_drop,
 };
 
 /// Request body for `POST /auction` (tsjs / Prebid.js wire format).
@@ -281,6 +285,499 @@ pub fn convert_tsjs_to_auction_request(
     })
 }
 
+/// Attach the consent/EID headers shared by every `/auction` response wire.
+pub(crate) fn attach_auction_response_headers(
+    response: &mut Response<EdgeBody>,
+    auction_request: &AuctionRequest,
+    ec_allowed: bool,
+) -> Result<(), Report<TrustedServerError>> {
+    if ec_allowed {
+        response
+            .headers_mut()
+            .insert(HEADER_X_TS_EC_CONSENT, HeaderValue::from_static("ok"));
+    }
+
+    if let Some(ref eids) = auction_request.user.eids {
+        let (encoded, truncated) = encode_eids_header(eids)?;
+        let header_val =
+            HeaderValue::from_str(&encoded).change_context(TrustedServerError::Auction {
+                message: "Failed to encode EIDs header value".to_string(),
+            })?;
+        response.headers_mut().insert(HEADER_X_TS_EIDS, header_val);
+        if truncated {
+            response
+                .headers_mut()
+                .insert(HEADER_X_TS_EIDS_TRUNCATED, HeaderValue::from_static("true"));
+        }
+    }
+
+    Ok(())
+}
+
+#[allow(
+    dead_code,
+    reason = "pure coordinated-cutover contract is exercised directly until Task 19 wires endpoints"
+)]
+pub(crate) mod coordinated_cutover_v1 {
+    use super::*;
+
+    /// Validated projection plus its exact canonical UTF-8 representation.
+    #[derive(Debug, Clone)]
+    pub(crate) struct CanonicalBrowserAuctionProjectionV1 {
+        /// Deep-owned, validated projection in canonical result/bid/targeting order.
+        pub projection: BrowserAuctionProjectionV1,
+        /// Whitespace-free JSON using schema field order.
+        pub json: Vec<u8>,
+        /// Whether the exact aggregate overflow rule replaced every winner.
+        pub reduced_for_size: bool,
+    }
+
+    fn projection_contract_error(message: impl Into<String>) -> Report<TrustedServerError> {
+        Report::new(TrustedServerError::Auction {
+            message: message.into(),
+        })
+    }
+
+    fn is_base64url_byte(byte: u8) -> bool {
+        byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-')
+    }
+
+    fn valid_auction_id(value: &str) -> bool {
+        !value.is_empty()
+            && value.len() <= 128
+            && value.bytes().all(|byte| {
+                byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b':' | b'-')
+            })
+    }
+
+    fn valid_candidate_id(value: &str) -> bool {
+        value.len() == 12 && value.bytes().all(is_base64url_byte)
+    }
+
+    pub(crate) fn valid_renderer_reservation_id(value: &str) -> bool {
+        value
+            .strip_prefix("r1_")
+            .is_some_and(|token| token.len() == 22 && token.bytes().all(is_base64url_byte))
+    }
+
+    fn valid_provider_name(value: &str) -> bool {
+        let bytes = value.as_bytes();
+        (1..=64).contains(&bytes.len())
+            && bytes[0].is_ascii_alphanumeric()
+            && bytes[1..]
+                .iter()
+                .all(|byte| byte.is_ascii_alphanumeric() || matches!(*byte, b'.' | b'_' | b'-'))
+    }
+
+    fn valid_bounded_text(value: &str, maximum_bytes: usize) -> bool {
+        !value.is_empty()
+            && value.len() <= maximum_bytes
+            && !value
+                .chars()
+                .any(|character| matches!(character, '\0'..='\u{1f}' | '\u{7f}'))
+    }
+
+    fn valid_targeting_key(value: &str) -> bool {
+        !value.is_empty()
+            && value.len() <= 20
+            && value
+                .bytes()
+                .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
+    }
+
+    fn valid_targeting(targeting: &BTreeMap<String, String>) -> bool {
+        targeting.len() <= MAX_BROWSER_AUCTION_TARGETING_ENTRIES
+            && targeting.iter().all(|(key, value)| {
+                key != "hb_adid"
+                    && valid_targeting_key(key)
+                    && valid_bounded_text(value, 160)
+                    && value.chars().count() <= 40
+            })
+    }
+
+    fn valid_render_dimension(value: u32) -> bool {
+        (RENDER_DIMENSION_MIN..=RENDER_DIMENSION_MAX).contains(&u64::from(value))
+    }
+
+    fn render_source_dimensions(source: &BidRenderSourceV1) -> (u32, u32) {
+        match source {
+            BidRenderSourceV1::Aps(source) => (source.width, source.height),
+            BidRenderSourceV1::Adm(source) => (source.width, source.height),
+            BidRenderSourceV1::PbsCache(source) => (source.width, source.height),
+        }
+    }
+
+    fn valid_render_source(source: &BidRenderSourceV1, publisher_origin: &str) -> bool {
+        match source {
+            BidRenderSourceV1::Aps(source) => {
+                valid_render_dimension(source.width)
+                    && valid_render_dimension(source.height)
+                    && source.version == 1
+                    && serde_json::to_value(BidRenderSourceV1::Aps(source.clone())).is_ok_and(
+                        |value| {
+                            classify_aps_renderer_v1(&value, publisher_origin)
+                                == crate::auction::types::ApsRendererValidationResult::Accepted
+                        },
+                    )
+            }
+            BidRenderSourceV1::Adm(source) => {
+                valid_render_dimension(source.width)
+                    && valid_render_dimension(source.height)
+                    && source.version == 1
+                    && !source.adm.is_empty()
+                    && source.adm.len() <= 512 * 1024
+            }
+            BidRenderSourceV1::PbsCache(source) => {
+                source.version == 1
+                    && !source.cache_id.is_empty()
+                    && !source.cache_host.is_empty()
+                    && !source.cache_path.is_empty()
+            }
+        }
+    }
+
+    fn valid_browser_bid(bid: &BrowserAuctionBidV1, publisher_origin: &str) -> bool {
+        valid_candidate_id(&bid.candidate_id)
+            && valid_bounded_text(&bid.slot, 256)
+            && valid_provider_name(&bid.provider)
+            && valid_bounded_text(&bid.upstream_bid_id, 64)
+            && bid.cpm.is_finite()
+            && bid.cpm >= 0.0
+            && bid.currency == "USD"
+            && valid_targeting(&bid.targeting)
+            && valid_render_source(&bid.render_source, publisher_origin)
+            && match &bid.render_source {
+                BidRenderSourceV1::Aps(_) | BidRenderSourceV1::Adm(_) => bid
+                    .renderer_reservation_id
+                    .as_deref()
+                    .is_some_and(valid_renderer_reservation_id),
+                BidRenderSourceV1::PbsCache(_) => bid.renderer_reservation_id.is_none(),
+            }
+    }
+
+    fn valid_browser_slot(slot: &BrowserAuctionSlotV1) -> bool {
+        valid_bounded_text(&slot.slot, 256)
+            && valid_bounded_text(&slot.gam_unit_path, 256)
+            && valid_bounded_text(&slot.div_id, 256)
+            && !slot.formats.is_empty()
+            && slot.formats.len() <= 64
+            && slot.formats.iter().all(|[width, height]| {
+                valid_render_dimension(*width) && valid_render_dimension(*height)
+            })
+            && valid_targeting(&slot.targeting)
+    }
+
+    fn validate_decision_set(
+        decision_set: &AuctionDecisionSetV1,
+    ) -> Result<(), Report<TrustedServerError>> {
+        ensure!(
+            decision_set.version == 1,
+            projection_contract_error("Browser auction decision version must be 1")
+        );
+        ensure!(
+            valid_auction_id(&decision_set.auction_id),
+            projection_contract_error("Browser auction id violates the version-1 grammar")
+        );
+        ensure!(
+            decision_set.results.len() <= MAX_BROWSER_AUCTION_RESULTS,
+            projection_contract_error("Browser auction result count exceeds 256")
+        );
+
+        let mut slots = HashSet::new();
+        let mut candidates = HashSet::new();
+        for result in &decision_set.results {
+            ensure!(
+                valid_bounded_text(result.slot(), 256) && slots.insert(result.slot()),
+                projection_contract_error("Browser auction result slots must be valid and unique")
+            );
+            if let SlotAuctionDecisionV1::Winner { candidate_id, .. } = result {
+                ensure!(
+                    valid_candidate_id(candidate_id) && candidates.insert(candidate_id),
+                    projection_contract_error(
+                        "Browser auction winner candidates must be valid and unique"
+                    )
+                );
+            }
+        }
+        Ok(())
+    }
+
+    /// Validate, reorder, and canonically serialize a complete browser auction projection.
+    ///
+    /// Winner-local projection failures become `winner_not_renderable`. Aggregate
+    /// overflow applies the contract's all-winners reduction; it never selects a
+    /// response-order-dependent subset.
+    pub(crate) fn canonicalize_browser_auction_projection_v1(
+        input: BrowserAuctionProjectionV1,
+        publisher_origin: &str,
+    ) -> Result<CanonicalBrowserAuctionProjectionV1, Report<TrustedServerError>> {
+        ensure!(
+            input.version == 1,
+            projection_contract_error("Browser auction projection version must be 1")
+        );
+        validate_decision_set(&input.auction)?;
+        ensure!(
+            input.slots.len() <= MAX_BROWSER_AUCTION_RESULTS,
+            projection_contract_error("Browser auction slot count exceeds 256")
+        );
+        if !input.slots.is_empty() {
+            ensure!(
+                input.slots.len() == input.auction.results.len(),
+                projection_contract_error(
+                    "Browser auction slots must cover every decision or be empty for direct serialization"
+                )
+            );
+            let mut slot_ids = HashSet::with_capacity(input.slots.len());
+            for (index, slot) in input.slots.iter().enumerate() {
+                ensure!(
+                    valid_browser_slot(slot)
+                        && slot_ids.insert(slot.slot.as_str())
+                        && input.auction.results[index].slot() == slot.slot,
+                    projection_contract_error(
+                        "Browser auction slots must be valid, unique, and follow decision order"
+                    )
+                );
+            }
+        }
+        ensure!(
+            input.bids.len() <= MAX_BROWSER_AUCTION_RESULTS,
+            projection_contract_error("Browser auction bid count exceeds 256")
+        );
+
+        let publisher_origin = Url::parse(publisher_origin)
+            .ok()
+            .filter(|url| matches!(url.scheme(), "http" | "https") && url.host_str().is_some())
+            .map(|url| url.origin().ascii_serialization())
+            .ok_or_else(|| projection_contract_error("Publisher origin is invalid"))?;
+
+        let mut bids_by_candidate = HashMap::with_capacity(input.bids.len());
+        for bid in input.bids {
+            let candidate_id = bid.candidate_id.clone();
+            ensure!(
+                bids_by_candidate.insert(candidate_id, bid).is_none(),
+                projection_contract_error("Browser auction candidate bids must be unique")
+            );
+        }
+
+        let mut reservation_ids = HashSet::new();
+        let mut canonical_bids = Vec::new();
+        let mut canonical_results = Vec::with_capacity(input.auction.results.len());
+        for result in input.auction.results {
+            match result {
+                SlotAuctionDecisionV1::Winner { slot, candidate_id } => {
+                    let bid = bids_by_candidate.remove(&candidate_id);
+                    if let Some(bid) = bid.filter(|bid| {
+                        bid.slot == slot
+                            && valid_browser_bid(bid, &publisher_origin)
+                            && bid
+                                .renderer_reservation_id
+                                .as_ref()
+                                .is_none_or(|id| reservation_ids.insert(id.clone()))
+                    }) {
+                        canonical_results
+                            .push(SlotAuctionDecisionV1::Winner { slot, candidate_id });
+                        canonical_bids.push(bid);
+                    } else {
+                        canonical_results.push(SlotAuctionDecisionV1::Failed {
+                            slot,
+                            reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                        });
+                    }
+                }
+                non_winner => canonical_results.push(non_winner),
+            }
+        }
+        ensure!(
+            bids_by_candidate.is_empty(),
+            projection_contract_error("Browser auction contains a bid without a winner decision")
+        );
+
+        let mut projection = BrowserAuctionProjectionV1 {
+            version: 1,
+            auction: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: input.auction.auction_id,
+                results: canonical_results,
+            },
+            slots: input.slots,
+            bids: canonical_bids,
+        };
+        let mut json =
+            serde_json::to_vec(&projection).change_context(TrustedServerError::Auction {
+                message: "Failed to serialize browser auction projection".to_string(),
+            })?;
+        let reduced_for_size = json.len() > MAX_BROWSER_AUCTION_PROJECTION_BYTES;
+        if reduced_for_size {
+            projection.auction.results = projection
+                .auction
+                .results
+                .into_iter()
+                .map(|result| match result {
+                    SlotAuctionDecisionV1::Winner { slot, .. } => SlotAuctionDecisionV1::Failed {
+                        slot,
+                        reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                    },
+                    non_winner => non_winner,
+                })
+                .collect();
+            projection.bids.clear();
+            json = serde_json::to_vec(&projection).change_context(TrustedServerError::Auction {
+                message: "Failed to serialize reduced browser auction projection".to_string(),
+            })?;
+            ensure!(
+                json.len() <= MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+                projection_contract_error("Reduced browser auction projection exceeds 8 MiB")
+            );
+        }
+
+        Ok(CanonicalBrowserAuctionProjectionV1 {
+            projection,
+            json,
+            reduced_for_size,
+        })
+    }
+
+    /// Parse and validate one browser-boot projection before it enters HTML.
+    ///
+    /// Browser boot requires full slot coverage, unlike the direct `/auction`
+    /// serializer that may carry an empty slot vector. The result is the exact
+    /// canonical JSON produced by the shared production validator.
+    pub(crate) fn canonicalize_browser_auction_projection_json_v1(
+        json: &str,
+        publisher_origin: &str,
+    ) -> Result<String, Report<TrustedServerError>> {
+        ensure!(
+            json.len() <= MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+            projection_contract_error("Browser auction projection exceeds 8 MiB")
+        );
+        let projection =
+            serde_json::from_str::<BrowserAuctionProjectionV1>(json).map_err(|_| {
+                projection_contract_error(
+                    "Browser auction projection violates the version-1 schema",
+                )
+            })?;
+        let canonical =
+            canonicalize_browser_auction_projection_v1(projection.clone(), publisher_origin)?;
+        ensure!(
+            !canonical.reduced_for_size && canonical.projection == projection,
+            projection_contract_error("Browser auction projection violates the version-1 contract")
+        );
+        String::from_utf8(canonical.json).map_err(|_| {
+            projection_contract_error("Browser auction projection serialization is not UTF-8")
+        })
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerOpenRtbBidExtV1<'a> {
+        candidate_id: &'a str,
+        slot_id: &'a str,
+        render_source: &'a BidRenderSourceV1,
+    }
+
+    #[derive(Serialize)]
+    struct OpenRtbBidExtV1<'a> {
+        trusted_server: TrustedServerOpenRtbBidExtV1<'a>,
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerOpenRtbBidV1<'a> {
+        id: &'a str,
+        impid: &'a str,
+        price: f64,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        adm: Option<&'a str>,
+        w: u32,
+        h: u32,
+        ext: OpenRtbBidExtV1<'a>,
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerSeatBidV1<'a> {
+        seat: &'a str,
+        bid: Vec<TrustedServerOpenRtbBidV1<'a>>,
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerResponseExtInnerV1<'a> {
+        slot_results: &'a AuctionDecisionSetV1,
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerResponseExtV1<'a> {
+        trusted_server: TrustedServerResponseExtInnerV1<'a>,
+    }
+
+    #[derive(Serialize)]
+    struct TrustedServerAuctionResponseWireV1<'a> {
+        id: &'a str,
+        seatbid: Vec<TrustedServerSeatBidV1<'a>>,
+        cur: &'static str,
+        ext: TrustedServerResponseExtV1<'a>,
+    }
+
+    /// Serialize the coordinated-cutover exact `/auction` winner wire.
+    ///
+    /// This remains a pure contract function until Task 19 switches the endpoint.
+    pub(crate) fn serialize_trusted_server_auction_response_v1(
+        canonical: &CanonicalBrowserAuctionProjectionV1,
+    ) -> Result<Vec<u8>, Report<TrustedServerError>> {
+        let seatbid = canonical
+            .projection
+            .bids
+            .iter()
+            .map(|bid| {
+                let (width, height) = render_source_dimensions(&bid.render_source);
+                let wire_id = match &bid.render_source {
+                    BidRenderSourceV1::Aps(_) | BidRenderSourceV1::Adm(_) => bid
+                        .renderer_reservation_id
+                        .as_deref()
+                        .expect("should retain the validated APS/ADM reservation"),
+                    BidRenderSourceV1::PbsCache(source) => source.cache_id.as_str(),
+                };
+                TrustedServerSeatBidV1 {
+                    seat: &bid.provider,
+                    bid: vec![TrustedServerOpenRtbBidV1 {
+                        id: wire_id,
+                        impid: &bid.slot,
+                        price: bid.cpm,
+                        // `render_source` is the sole browser authority. Standard
+                        // `adm` is optional on the exact wire and omitted by the
+                        // producer to avoid duplicating up to 512 KiB per winner.
+                        adm: None,
+                        w: width,
+                        h: height,
+                        ext: OpenRtbBidExtV1 {
+                            trusted_server: TrustedServerOpenRtbBidExtV1 {
+                                candidate_id: &bid.candidate_id,
+                                slot_id: &bid.slot,
+                                render_source: &bid.render_source,
+                            },
+                        },
+                    }],
+                }
+            })
+            .collect();
+        let response = TrustedServerAuctionResponseWireV1 {
+            id: &canonical.projection.auction.auction_id,
+            seatbid,
+            cur: "USD",
+            ext: TrustedServerResponseExtV1 {
+                trusted_server: TrustedServerResponseExtInnerV1 {
+                    slot_results: &canonical.projection.auction,
+                },
+            },
+        };
+        serde_json::to_vec(&response).change_context(TrustedServerError::Auction {
+            message: "Failed to serialize exact trusted-server auction response".to_string(),
+        })
+    }
+}
+
+#[cfg(test)]
+use coordinated_cutover_v1::{
+    canonicalize_browser_auction_projection_v1, serialize_trusted_server_auction_response_v1,
+};
+
 /// Delivery facts produced while serializing winning bids.
 #[derive(Debug, Default)]
 pub(crate) struct AuctionDeliveryReport {
@@ -289,20 +786,11 @@ pub(crate) struct AuctionDeliveryReport {
     /// Winners omitted because they could not be delivered safely.
     pub dropped_winner_count: usize,
     /// Machine-readable reasons for omitted winners.
-    pub dropped_winner_reasons: BTreeMap<String, usize>,
-}
-
-impl AuctionDeliveryReport {
-    fn record_drop(&mut self, reason: &str) {
-        self.dropped_winner_count += 1;
-        *self
-            .dropped_winner_reasons
-            .entry(reason.to_string())
-            .or_default() += 1;
-    }
+    pub dropped_winner_reasons: AuctionDropReasons,
 }
 
 /// Serialized response and the delivery facts used to produce it.
+#[cfg(test)]
 pub(crate) struct OpenRtbResponseConversion {
     /// HTTP response returned to the auction client.
     pub response: Response<EdgeBody>,
@@ -317,38 +805,63 @@ pub(crate) struct OpenRtbResponseConversion {
 /// ([`AuctionConfig::sanitize_creatives`], opt-in, and
 /// [`AuctionConfig::rewrite_creatives`], default-on); with both disabled the
 /// creative ships exactly as the bidder returned it, subject to the 1 MiB
-/// per-creative cap. Typed renderers are serialized in the response extension
-/// instead of entering that pipeline at all.
+/// per-creative cap.
 ///
 /// [`AuctionConfig::sanitize_creatives`]: crate::auction_config_types::AuctionConfig::sanitize_creatives
 /// [`AuctionConfig::rewrite_creatives`]: crate::auction_config_types::AuctionConfig::rewrite_creatives
 ///
 /// # Errors
 ///
-/// Returns an error if response serialization fails.
-///
-/// Winners without a decoded price or a deliverable creative are omitted and
-/// recorded in the returned delivery report so other slots can still render.
+/// Returns an error if:
+/// - A winning bid is missing a price or render source
+/// - The response serialization fails
 pub fn convert_to_openrtb_response(
     result: &OrchestrationResult,
     settings: &Settings,
     auction_request: &AuctionRequest,
     ec_allowed: bool,
 ) -> Result<Response<EdgeBody>, Report<TrustedServerError>> {
-    Ok(
-        convert_to_openrtb_response_with_report(result, settings, auction_request, ec_allowed)?
-            .response,
-    )
+    convert_to_openrtb_response_impl(result, settings, auction_request, ec_allowed)
 }
 
+#[cfg(test)]
 pub(crate) fn convert_to_openrtb_response_with_report(
     result: &OrchestrationResult,
     settings: &Settings,
     auction_request: &AuctionRequest,
     ec_allowed: bool,
 ) -> Result<OpenRtbResponseConversion, Report<TrustedServerError>> {
+    let (response, delivery) = convert_to_openrtb_response_impl_with_report(
+        result,
+        settings,
+        auction_request,
+        ec_allowed,
+    )?;
+    Ok(OpenRtbResponseConversion { response, delivery })
+}
+
+fn convert_to_openrtb_response_impl(
+    result: &OrchestrationResult,
+    settings: &Settings,
+    auction_request: &AuctionRequest,
+    ec_allowed: bool,
+) -> Result<Response<EdgeBody>, Report<TrustedServerError>> {
+    let (response, _) = convert_to_openrtb_response_impl_with_report(
+        result,
+        settings,
+        auction_request,
+        ec_allowed,
+    )?;
+    Ok(response)
+}
+
+fn convert_to_openrtb_response_impl_with_report(
+    result: &OrchestrationResult,
+    settings: &Settings,
+    auction_request: &AuctionRequest,
+    ec_allowed: bool,
+) -> Result<(Response<EdgeBody>, AuctionDeliveryReport), Report<TrustedServerError>> {
     let mut seatbids = Vec::with_capacity(result.winning_bids.len());
-    let rewrite_creatives = settings.auction.rewrite_creatives;
     let mut delivery = AuctionDeliveryReport::default();
 
     for (slot_id, bid) in &result.winning_bids {
@@ -359,7 +872,11 @@ pub(crate) fn convert_to_openrtb_response_with_report(
                 slot_id,
                 bid.bidder
             );
-            delivery.record_drop("no_decoded_price");
+            delivery.dropped_winner_count += 1;
+            record_auction_drop(
+                &mut delivery.dropped_winner_reasons,
+                AuctionDropReason::InvalidPrice,
+            );
             continue;
         };
 
@@ -370,29 +887,29 @@ pub(crate) fn convert_to_openrtb_response_with_report(
         let width = to_openrtb_i32(bid.width, "width", &bid_context);
         let height = to_openrtb_i32(bid.height, "height", &bid_context);
 
-        // Ordinary markup goes through the configured creative processing:
-        // sanitization is opt-in, rewriting is on by default, and with both
-        // disabled the creative ships exactly as the bidder returned it. A typed
-        // renderer is serialized separately and never enters that pipeline.
-        let serialize_renderer = |renderer: &BidRenderer| {
-            (BidExt {
-                trusted_server: BidTrustedServerExt { renderer },
-            })
-            .to_ext()
-        };
-        let (adm, ext) = if let Some(raw_creative) = bid
+        let creative = bid
             .creative
             .as_deref()
-            .filter(|creative| !creative.trim().is_empty())
-        {
-            if bid.renderer.is_some() {
-                log::warn!(
-                    "Auction {}: winning bid for slot '{}' from '{}' has both creative markup and a renderer; using creative markup when it remains renderable",
-                    auction_request.id,
-                    slot_id,
-                    bid.bidder
-                );
-            }
+            .filter(|creative| !creative.trim().is_empty());
+        if creative.is_some() && bid.renderer.is_some() {
+            log::warn!(
+                "Auction {}: skipping winning bid for slot '{}' from '{}' because it has multiple render sources",
+                auction_request.id,
+                slot_id,
+                bid.bidder
+            );
+            delivery.dropped_winner_count += 1;
+            record_auction_drop(
+                &mut delivery.dropped_winner_reasons,
+                AuctionDropReason::MultipleRenderSources,
+            );
+            continue;
+        }
+
+        // Ordinary markup follows the independently configured processing
+        // path: sanitization is opt-in and rewriting is default-on. A typed
+        // render source is serialized separately and never enters either pass.
+        let (adm, ext) = if let Some(raw_creative) = creative {
             let processed = creative::process_auction_creative(settings, raw_creative);
 
             log::debug!(
@@ -401,45 +918,43 @@ pub(crate) fn convert_to_openrtb_response_with_report(
                 slot_id,
                 bid.bidder,
                 settings.auction.sanitize_creatives,
-                rewrite_creatives,
+                settings.auction.rewrite_creatives,
                 raw_creative.len(),
                 processed.len()
             );
 
             if processed.trim().is_empty() {
-                let Some(renderer) = bid.renderer.as_ref() else {
-                    log::warn!(
-                        "Auction {}: skipping winning bid for slot '{}' from '{}' because creative processing rejected its only render source",
-                        auction_request.id,
-                        slot_id,
-                        bid.bidder
-                    );
-                    delivery.record_drop("creative_processing_rejected");
-                    continue;
-                };
-                let Some(ext) = serialize_renderer(renderer) else {
-                    log::warn!(
-                        "Auction {}: skipping winning bid for slot '{}' from '{}' because its renderer extension could not be serialized",
-                        auction_request.id,
-                        slot_id,
-                        bid.bidder
-                    );
-                    delivery.record_drop("renderer_extension_serialization_failed");
-                    continue;
-                };
-                (None, Some(ext))
-            } else {
-                (Some(processed), None)
+                log::warn!(
+                    "Auction {}: skipping winning bid for slot '{}' from '{}' because creative processing rejected its only render source",
+                    auction_request.id,
+                    slot_id,
+                    bid.bidder
+                );
+                delivery.dropped_winner_count += 1;
+                record_auction_drop(
+                    &mut delivery.dropped_winner_reasons,
+                    AuctionDropReason::CreativeProcessingRejected,
+                );
+                continue;
             }
+
+            (Some(processed), None)
         } else if let Some(renderer) = bid.renderer.as_ref() {
-            let Some(ext) = serialize_renderer(renderer) else {
+            let Some(ext) = (BidExt {
+                trusted_server: BidTrustedServerExt { renderer },
+            })
+            .to_ext() else {
                 log::warn!(
                     "Auction {}: skipping winning bid for slot '{}' from '{}' because its renderer extension could not be serialized",
                     auction_request.id,
                     slot_id,
                     bid.bidder
                 );
-                delivery.record_drop("renderer_extension_serialization_failed");
+                delivery.dropped_winner_count += 1;
+                record_auction_drop(
+                    &mut delivery.dropped_winner_reasons,
+                    AuctionDropReason::RendererExtensionSerializationFailed,
+                );
                 continue;
             };
             (None, Some(ext))
@@ -450,7 +965,11 @@ pub(crate) fn convert_to_openrtb_response_with_report(
                 slot_id,
                 bid.bidder
             );
-            delivery.record_drop("no_render_source");
+            delivery.dropped_winner_count += 1;
+            record_auction_drop(
+                &mut delivery.dropped_winner_reasons,
+                AuctionDropReason::NoRenderSource,
+            );
             continue;
         };
 
@@ -524,29 +1043,9 @@ pub(crate) fn convert_to_openrtb_response_with_report(
             message: "Failed to build auction response".to_string(),
         })?;
 
-    // Signal consent status independently of whether EIDs were resolved.
-    if ec_allowed {
-        response
-            .headers_mut()
-            .insert(HEADER_X_TS_EC_CONSENT, HeaderValue::from_static("ok"));
-    }
-
-    // Attach EID response headers when consent-gated EIDs are available.
-    if let Some(ref eids) = auction_request.user.eids {
-        let (encoded, truncated) = encode_eids_header(eids)?;
-        let header_val =
-            HeaderValue::from_str(&encoded).change_context(TrustedServerError::Auction {
-                message: "Failed to encode EIDs header value".to_string(),
-            })?;
-        response.headers_mut().insert(HEADER_X_TS_EIDS, header_val);
-        if truncated {
-            response
-                .headers_mut()
-                .insert(HEADER_X_TS_EIDS_TRUNCATED, HeaderValue::from_static("true"));
-        }
-    }
+    attach_auction_response_headers(&mut response, auction_request, ec_allowed)?;
 
-    Ok(OpenRtbResponseConversion { response, delivery })
+    Ok((response, delivery))
 }
 
 #[cfg(test)]
@@ -557,7 +1056,8 @@ mod tests {
     };
     use crate::auction::routing::route_auction;
     use crate::auction::types::{
-        ApsRendererV1, ApsTagType, AuctionResponse, Bid, BidRenderer, BidStatus,
+        ApsRendererV1, ApsTagType, AuctionDecisionSetV1, AuctionResponse, Bid, BidRenderSourceV1,
+        BidStatus,
     };
     use crate::openrtb::{Eid, Uid};
     use crate::platform::test_support::noop_services;
@@ -636,6 +1136,11 @@ mod tests {
             provider_responses: Vec::new(),
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 10,
             metadata: HashMap::new(),
         }
@@ -644,6 +1149,9 @@ mod tests {
     fn make_bid(slot_id: &str, bidder: &str, price: Option<f64>) -> Bid {
         Bid {
             slot_id: slot_id.to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price,
             currency: "USD".to_string(),
             creative: Some("<div>Ad</div>".to_string()),
@@ -685,6 +1193,11 @@ mod tests {
             }],
             mediator_response: None,
             winning_bids: HashMap::from([(bid.slot_id.clone(), bid)]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 50,
             metadata: HashMap::new(),
         }
@@ -1212,7 +1725,8 @@ mod tests {
 
     #[test]
     fn convert_to_openrtb_response_serializes_winning_bid_and_orchestrator_ext() {
-        let settings = make_settings();
+        let mut settings = make_settings();
+        settings.auction.rewrite_creatives = false;
         let auction_request = make_auction_request();
         let result = make_result(make_bid("div-gpt-top", "appnexus", Some(2.75)));
 
@@ -1252,18 +1766,7 @@ mod tests {
         assert_eq!(bid["id"], json!("appnexus-div-gpt-top"));
         assert_eq!(bid["impid"], json!("div-gpt-top"));
         assert_eq!(bid["price"], json!(2.75));
-        // Rewriting is on by default, and a body-less fragment still receives
-        // the creative runtime (prepended), so the markup is carried rather
-        // than returned verbatim.
-        let adm = bid["adm"].as_str().expect("should serialize adm");
-        assert!(
-            adm.contains("<div>Ad</div>"),
-            "should carry the creative: {adm}"
-        );
-        assert!(
-            adm.contains("/static/tsjs=tsjs-unified.min.js"),
-            "should inject the creative runtime into a body-less fragment: {adm}"
-        );
+        assert_eq!(bid["adm"], json!("<div>Ad</div>"));
         assert_eq!(bid["crid"], json!("appnexus-creative"));
         assert_eq!(bid["w"], json!(300));
         assert_eq!(bid["h"], json!(250));
@@ -1328,7 +1831,7 @@ mod tests {
             "should remove malicious script content before rewriting: {adm}"
         );
         assert!(
-            !adm.contains("auction-handler-marker") && !adm.contains("onerror"),
+            !adm.contains("auction-handler-marker") && !adm.contains(r#" onerror=""#),
             "should remove event handlers before rewriting: {adm}"
         );
     }
@@ -1341,7 +1844,6 @@ mod tests {
         // markup cannot reach the publisher origin — can opt out and deliver the
         // creative exactly as the bidder returned it.
         let mut settings = make_settings();
-        settings.auction.sanitize_creatives = false;
         settings.auction.rewrite_creatives = false;
         let auction_request = make_auction_request();
         let result = make_result(make_complete_creative_bid());
@@ -1351,7 +1853,7 @@ mod tests {
             .expect("should have a creative fixture");
 
         let response = convert_to_openrtb_response(&result, &settings, &auction_request, false)
-            .expect("should convert creative with sanitization disabled");
+            .expect("should convert creative with rewriting disabled");
         let adm = response_adm(response);
 
         assert_eq!(
@@ -1394,7 +1896,7 @@ mod tests {
     }
 
     #[test]
-    fn sanitize_creatives_defaults_to_disabled() {
+    fn rewrite_creatives_defaults_to_enabled() {
         let config = crate::auction_config_types::AuctionConfig::default();
         assert!(
             !config.sanitize_creatives,
@@ -1408,8 +1910,6 @@ mod tests {
 
     #[test]
     fn convert_to_openrtb_response_can_skip_rewriting_while_sanitizing() {
-        // The two controls are independent: sanitization can stay on while URL
-        // rewriting is off.
         let mut settings = make_settings();
         settings.auction.rewrite_creatives = false;
         settings.auction.sanitize_creatives = true;
@@ -1453,7 +1953,7 @@ mod tests {
             "should still remove malicious script content: {adm}"
         );
         assert!(
-            !adm.contains("auction-handler-marker") && !adm.contains("onerror"),
+            !adm.contains("auction-handler-marker") && !adm.contains(r#" onerror=""#),
             "should still remove event handlers: {adm}"
         );
     }
@@ -1485,6 +1985,11 @@ mod tests {
             }],
             mediator_response: None,
             winning_bids: HashMap::from([(bid.slot_id.clone(), bid)]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 50,
             metadata: HashMap::new(),
         };
@@ -1501,26 +2006,19 @@ mod tests {
 
     #[test]
     fn convert_to_openrtb_response_skips_invalid_winners_without_dropping_valid_slots() {
-        // Sanitization is opt-in, so enable it here: script-only markup is what
-        // makes the `rejected` and `renderer` fixtures below reach the
-        // processing-rejected path. Left at the default they would survive
-        // processing as ordinary (script-bearing) creatives.
         let mut settings = make_settings();
-        settings.auction.sanitize_creatives = true;
+        settings.auction.rewrite_creatives = false;
         let auction_request = make_auction_request();
         let mut missing = make_bid("missing", "invalid", Some(3.0));
         missing.creative = None;
         let mut whitespace = make_bid("whitespace", "invalid", Some(2.9));
         whitespace.creative = Some(" \n\t ".to_string());
-        let mut rejected = make_bid("rejected", "invalid", Some(2.8));
-        rejected.creative = Some("<script>reject()</script>".to_string());
-        let unpriced = make_bid("unpriced", "invalid", None);
         let ordinary = make_bid("ordinary", "appnexus", Some(2.75));
         let mut renderer = make_bid("renderer", "aps", Some(2.5));
-        renderer.creative = Some("<script>reject()</script>".to_string());
+        renderer.creative = Some("  ".to_string());
         renderer.bid_id = Some("upstream-renderer-bid".to_string());
         renderer.creative_id = None;
-        renderer.renderer = Some(BidRenderer::Aps(ApsRendererV1 {
+        renderer.renderer = Some(BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: "example-account".to_string(),
             bid_id: "upstream-renderer-bid".to_string(),
@@ -1537,37 +2035,21 @@ mod tests {
             winning_bids: HashMap::from([
                 (missing.slot_id.clone(), missing),
                 (whitespace.slot_id.clone(), whitespace),
-                (rejected.slot_id.clone(), rejected),
-                (unpriced.slot_id.clone(), unpriced),
                 (ordinary.slot_id.clone(), ordinary),
                 (renderer.slot_id.clone(), renderer),
             ]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 50,
             metadata: HashMap::new(),
         };
 
-        let conversion =
-            convert_to_openrtb_response_with_report(&result, &settings, &auction_request, false)
-                .expect("should omit invalid winners and preserve valid slots");
-        assert_eq!(
-            conversion.delivery.delivered_winner_slots,
-            HashSet::from(["ordinary".to_string(), "renderer".to_string()]),
-            "should report only serialized winners as delivered"
-        );
-        assert_eq!(conversion.delivery.dropped_winner_count, 4);
-        assert_eq!(
-            conversion.delivery.dropped_winner_reasons["no_render_source"],
-            2
-        );
-        assert_eq!(
-            conversion.delivery.dropped_winner_reasons["no_decoded_price"],
-            1
-        );
-        assert_eq!(
-            conversion.delivery.dropped_winner_reasons["creative_processing_rejected"],
-            1
-        );
-        let json = response_json(conversion.response);
+        let response = convert_to_openrtb_response(&result, &settings, &auction_request, false)
+            .expect("should omit invalid winners and preserve valid slots");
+        let json = response_json(response);
         let bids: Vec<&JsonValue> = json["seatbid"]
             .as_array()
             .expect("should include valid seatbids")
@@ -1576,30 +2058,16 @@ mod tests {
             .collect();
 
         assert_eq!(bids.len(), 2, "should omit only invalid winners");
-        assert_eq!(json["ext"]["orchestrator"]["dropped_winner_count"], 4);
+        assert_eq!(json["ext"]["orchestrator"]["dropped_winner_count"], 2);
         assert_eq!(
             json["ext"]["orchestrator"]["dropped_winner_reasons"]["no_render_source"],
             2
         );
-        assert_eq!(
-            json["ext"]["orchestrator"]["dropped_winner_reasons"]["no_decoded_price"],
-            1
-        );
-        assert_eq!(
-            json["ext"]["orchestrator"]["dropped_winner_reasons"]["creative_processing_rejected"],
-            1
-        );
         let ordinary = bids
             .iter()
             .find(|bid| bid["impid"] == "ordinary")
             .expect("should preserve ordinary winner");
-        assert!(
-            ordinary["adm"]
-                .as_str()
-                .is_some_and(|adm| adm.contains("<div>Ad</div>")),
-            "should preserve ordinary creative markup: {}",
-            ordinary["adm"]
-        );
+        assert_eq!(ordinary["adm"], "<div>Ad</div>");
         let renderer = bids
             .iter()
             .find(|bid| bid["impid"] == "renderer")
@@ -1614,11 +2082,38 @@ mod tests {
     }
 
     #[test]
-    fn convert_to_openrtb_response_prefers_creative_when_both_render_sources_exist() {
-        let settings = make_settings();
+    fn convert_to_openrtb_response_drops_creative_rejected_by_processing() {
+        let mut settings = make_settings();
+        settings.auction.sanitize_creatives = true;
+        settings.auction.rewrite_creatives = false;
+        let auction_request = make_auction_request();
+        let mut bid = make_bid("div-gpt-top", "appnexus", Some(2.75));
+        bid.creative = Some("<script>window.fictionalCreative = true;</script>".to_string());
+        let result = make_result(bid);
+
+        let response = convert_to_openrtb_response(&result, &settings, &auction_request, false)
+            .expect("should omit a creative rejected by configured processing");
+        let json = response_json(response);
+
+        assert!(
+            json["seatbid"].as_array().is_none_or(Vec::is_empty),
+            "should not serialize an empty adm"
+        );
+        assert_eq!(json["ext"]["orchestrator"]["dropped_winner_count"], 1);
+        assert_eq!(
+            json["ext"]["orchestrator"]["dropped_winner_reasons"]["creative_processing_rejected"],
+            1,
+            "should report the exact processing rejection"
+        );
+    }
+
+    #[test]
+    fn convert_to_openrtb_response_rejects_multiple_render_sources() {
+        let mut settings = make_settings();
+        settings.auction.rewrite_creatives = false;
         let auction_request = make_auction_request();
         let mut bid = make_bid("div-gpt-top", "aps", Some(2.75));
-        bid.renderer = Some(BidRenderer::Aps(ApsRendererV1 {
+        bid.renderer = Some(BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: "example-account".to_string(),
             bid_id: "fictional-bid".to_string(),
@@ -1632,20 +2127,16 @@ mod tests {
         let result = make_result(bid);
 
         let response = convert_to_openrtb_response(&result, &settings, &auction_request, false)
-            .expect("should prefer ordinary creative markup");
+            .expect("should reject an ambiguous render source");
         let json = response_json(response);
-        let bid = &json["seatbid"][0]["bid"][0];
-
-        // Rewriting is on by default and a body-less fragment still receives the
-        // creative runtime, so the markup is carried rather than returned verbatim.
-        let adm = bid["adm"].as_str().expect("should serialize adm");
         assert!(
-            adm.contains("<div>Ad</div>"),
-            "should carry the creative markup: {adm}"
+            json["seatbid"].as_array().is_none_or(Vec::is_empty),
+            "should not serialize an ambiguous winner"
         );
-        assert!(
-            bid.get("ext").is_none(),
-            "should omit renderer extension when creative markup wins precedence"
+        assert_eq!(json["ext"]["orchestrator"]["dropped_winner_count"], 1);
+        assert_eq!(
+            json["ext"]["orchestrator"]["dropped_winner_reasons"]["multiple_render_sources"], 1,
+            "should report the exact ambiguous-source reason"
         );
     }
 
@@ -1658,7 +2149,7 @@ mod tests {
         bid.bid_id = Some("fictional-bid".to_string());
         bid.ad_id = Some("fictional-ad".to_string());
         bid.creative_id = Some("fictional-creative".to_string());
-        bid.renderer = Some(BidRenderer::Aps(ApsRendererV1 {
+        bid.renderer = Some(BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: "example-account".to_string(),
             bid_id: "fictional-bid".to_string(),
@@ -1726,6 +2217,11 @@ mod tests {
             provider_responses: vec![],
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 50,
             metadata: HashMap::new(),
         };
@@ -1748,7 +2244,8 @@ mod tests {
 
     #[test]
     fn convert_to_openrtb_response_serializes_multiple_winning_bids() {
-        let settings = make_settings();
+        let mut settings = make_settings();
+        settings.auction.rewrite_creatives = false;
         let auction_request = make_auction_request();
         let top_bid = make_bid("div-gpt-top", "appnexus", Some(2.75));
         let mut sidebar_bid = make_bid("div-gpt-sidebar", "rubicon", Some(1.25));
@@ -1766,6 +2263,11 @@ mod tests {
                 (top_bid.slot_id.clone(), top_bid),
                 (sidebar_bid.slot_id.clone(), sidebar_bid),
             ]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 50,
             metadata: HashMap::new(),
         };
@@ -1800,12 +2302,10 @@ mod tests {
             "should preserve top slot impid"
         );
         assert_eq!(top_bid["price"], json!(2.75), "should preserve top price");
-        assert!(
-            top_bid["adm"]
-                .as_str()
-                .is_some_and(|adm| adm.contains("<div>Ad</div>")),
-            "should preserve top creative: {}",
-            top_bid["adm"]
+        assert_eq!(
+            top_bid["adm"],
+            json!("<div>Ad</div>"),
+            "should preserve top creative"
         );
 
         let sidebar_seatbid = seatbids
@@ -1833,12 +2333,10 @@ mod tests {
             json!(1.25),
             "should preserve sidebar price"
         );
-        assert!(
-            sidebar_bid["adm"]
-                .as_str()
-                .is_some_and(|adm| adm.contains("<div>Sidebar</div>")),
-            "should preserve sidebar creative: {}",
-            sidebar_bid["adm"]
+        assert_eq!(
+            sidebar_bid["adm"],
+            json!("<div>Sidebar</div>"),
+            "should preserve sidebar creative"
         );
         assert_eq!(
             json["ext"]["orchestrator"]["total_bids"],
@@ -1877,9 +2375,15 @@ mod tests {
         assert!(conversion.delivery.delivered_winner_slots.is_empty());
         assert_eq!(conversion.delivery.dropped_winner_count, 1);
         assert_eq!(
-            conversion.delivery.dropped_winner_reasons["no_decoded_price"], 1,
+            conversion.delivery.dropped_winner_reasons[&AuctionDropReason::InvalidPrice],
+            1,
             "should report the omitted malformed winner"
         );
+        assert_eq!(
+            conversion.response.status(),
+            StatusCode::OK,
+            "should still return a successful partial auction response"
+        );
     }
 
     #[test]
@@ -1904,10 +2408,16 @@ mod tests {
 #[cfg(test)]
 mod convert_tests {
     use super::*;
+    use crate::auction::types::{
+        AdmRenderSourceV1, AuctionDecisionSetV1, BidRenderSourceV1, BrowserAuctionBidV1,
+        BrowserAuctionProjectionV1, MAX_BROWSER_AUCTION_PROJECTION_BYTES, SlotAuctionDecisionV1,
+    };
     use crate::consent::ConsentContext;
     use crate::platform::test_support::noop_services;
     use crate::test_support::tests::crate_test_settings_str;
     use http::Method;
+    use serde_json::json;
+    use std::collections::BTreeMap;
 
     fn make_settings() -> Settings {
         Settings::from_toml(&crate_test_settings_str()).expect("should parse test settings")
@@ -2080,4 +2590,273 @@ mod convert_tests {
             "3-element banner size should return an error"
         );
     }
+
+    fn projection_candidate_id(index: usize) -> String {
+        format!("{index:012x}")
+    }
+
+    fn projection_reservation_id(index: usize) -> String {
+        format!("r1_{index:022x}")
+    }
+
+    fn projection_adm_bid(index: usize, slot: &str, adm: String) -> BrowserAuctionBidV1 {
+        BrowserAuctionBidV1 {
+            candidate_id: projection_candidate_id(index),
+            slot: slot.to_string(),
+            provider: "prebid".to_string(),
+            upstream_bid_id: format!("upstream-{index}"),
+            cpm: index as f64,
+            currency: "USD".to_string(),
+            targeting: BTreeMap::from([
+                ("z_key".to_string(), "last".to_string()),
+                ("a_key".to_string(), "first".to_string()),
+            ]),
+            renderer_reservation_id: Some(projection_reservation_id(index)),
+            render_source: BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+                version: 1,
+                adm,
+                width: 300,
+                height: 250,
+            }),
+        }
+    }
+
+    fn projection_with_adm_lengths(lengths: &[usize]) -> BrowserAuctionProjectionV1 {
+        let results = lengths
+            .iter()
+            .enumerate()
+            .map(|(index, _)| SlotAuctionDecisionV1::Winner {
+                slot: format!("slot-{index}"),
+                candidate_id: projection_candidate_id(index),
+            })
+            .collect();
+        let bids = lengths
+            .iter()
+            .enumerate()
+            .map(|(index, length)| {
+                projection_adm_bid(index, &format!("slot-{index}"), "x".repeat(*length))
+            })
+            .rev()
+            .collect();
+        BrowserAuctionProjectionV1 {
+            version: 1,
+            auction: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "auction-1".to_string(),
+                results,
+            },
+            slots: Vec::new(),
+            bids,
+        }
+    }
+
+    #[test]
+    fn canonical_projection_orders_bids_and_targeting_by_contract() {
+        let input = projection_with_adm_lengths(&[1, 1]);
+        let mut permuted = input.clone();
+        permuted.bids.reverse();
+
+        let canonical =
+            canonicalize_browser_auction_projection_v1(input, "https://publisher.example")
+                .expect("valid projection should canonicalize");
+        let canonical_permuted =
+            canonicalize_browser_auction_projection_v1(permuted, "https://publisher.example")
+                .expect("response-order permutation should canonicalize");
+
+        assert!(!canonical.reduced_for_size);
+        assert_eq!(canonical.json, canonical_permuted.json);
+        assert_eq!(canonical.projection.bids[0].slot, "slot-0");
+        assert_eq!(canonical.projection.bids[1].slot, "slot-1");
+        let json = String::from_utf8(canonical.json).expect("canonical JSON should be UTF-8");
+        assert!(
+            json.find("\"a_key\"") < json.find("\"z_key\""),
+            "targeting keys should be lexically sorted"
+        );
+        assert!(
+            json.starts_with("{\"version\":1,\"auction\":{\"version\":1,\"auctionId\":"),
+            "top-level and decision-set fields should retain schema order: {json}"
+        );
+    }
+
+    #[test]
+    fn pbs_cache_wire_is_the_exact_thin_deny_unknown_carrier() {
+        let value = serde_json::json!({
+            "type": "pbs_cache",
+            "version": 1,
+            "cacheId": "f47447a0-b759-4f2f-9887-af458b79b570",
+            "cacheHost": "cache.example:8443",
+            "cachePath": "/pbc/v1/cache/opaque%2Fpath",
+            "width": 0,
+            "height": u32::MAX
+        });
+        let source: BidRenderSourceV1 = serde_json::from_value(value.clone())
+            .expect("the final tagged union should admit the thin pbs_cache carrier");
+        assert_eq!(
+            serde_json::to_value(source).expect("cache carrier should serialize"),
+            value
+        );
+
+        let mut unknown = value;
+        unknown["fetchUrl"] = serde_json::Value::String(
+            "https://cache.example/pbc/v1/cache?uuid=not-authoritative".to_string(),
+        );
+        assert!(serde_json::from_value::<BidRenderSourceV1>(unknown).is_err());
+    }
+
+    #[test]
+    fn invalid_selected_winner_becomes_winner_not_renderable() {
+        let mut input = projection_with_adm_lengths(&[1]);
+        input.bids[0].renderer_reservation_id = Some("not-a-reservation".to_string());
+
+        let canonical =
+            canonicalize_browser_auction_projection_v1(input, "https://publisher.example")
+                .expect("selected projection failure should remain an explicit slot result");
+
+        assert!(canonical.projection.bids.is_empty());
+        assert_eq!(
+            canonical.projection.auction.results,
+            vec![SlotAuctionDecisionV1::Failed {
+                slot: "slot-0".to_string(),
+                reason: crate::auction::types::AuctionSlotFailureReason::WinnerNotRenderable,
+            }]
+        );
+    }
+
+    #[test]
+    fn canonical_projection_enforces_exact_eight_mib_all_winner_reduction() {
+        let mut lengths = vec![512 * 1024; 15];
+        lengths.push(1);
+        let baseline = projection_with_adm_lengths(&lengths);
+        let baseline_len = serde_json::to_vec(&baseline)
+            .expect("typed baseline should serialize")
+            .len();
+        let exact_tail = 1 + MAX_BROWSER_AUCTION_PROJECTION_BYTES - baseline_len;
+        assert!(
+            exact_tail <= 512 * 1024,
+            "tail ADM should remain individually valid"
+        );
+
+        for (delta, should_reduce) in [(-1_isize, false), (0, false), (1, true)] {
+            lengths[15] = exact_tail
+                .checked_add_signed(delta)
+                .expect("positive exact tail");
+            let input = projection_with_adm_lengths(&lengths);
+            let canonical =
+                canonicalize_browser_auction_projection_v1(input, "https://publisher.example")
+                    .expect("boundary projection should canonicalize or reduce");
+            assert_eq!(canonical.reduced_for_size, should_reduce, "delta {delta}");
+            assert!(canonical.json.len() <= MAX_BROWSER_AUCTION_PROJECTION_BYTES);
+            if should_reduce {
+                assert!(canonical.projection.bids.is_empty());
+                assert!(canonical.projection.auction.results.iter().all(|result| matches!(
+                    result,
+                    SlotAuctionDecisionV1::Failed {
+                        reason: crate::auction::types::AuctionSlotFailureReason::WinnerNotRenderable,
+                        ..
+                    }
+                )));
+                let wire: JsonValue = serde_json::from_slice(
+                    &serialize_trusted_server_auction_response_v1(&canonical)
+                        .expect("reduced exact response should serialize"),
+                )
+                .expect("reduced exact response should be JSON");
+                assert_eq!(wire["seatbid"], json!([]));
+            } else {
+                assert_eq!(
+                    canonical.json.len(),
+                    MAX_BROWSER_AUCTION_PROJECTION_BYTES
+                        .checked_add_signed(delta)
+                        .expect("boundary size should remain positive")
+                );
+                if delta == 0 {
+                    let wire = serialize_trusted_server_auction_response_v1(&canonical)
+                        .expect("exact-boundary response should serialize");
+                    assert!(
+                        wire.len() <= MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+                        "exact response should not exceed the admitted projection cap"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn exact_openrtb_serializer_uses_reservation_and_trusted_server_join_only() {
+        let canonical = canonicalize_browser_auction_projection_v1(
+            projection_with_adm_lengths(&[7]),
+            "https://publisher.example",
+        )
+        .expect("projection should canonicalize");
+
+        let json: JsonValue = serde_json::from_slice(
+            &serialize_trusted_server_auction_response_v1(&canonical)
+                .expect("exact response should serialize"),
+        )
+        .expect("exact response should be JSON");
+
+        let bid = &json["seatbid"][0]["bid"][0];
+        assert_eq!(bid["id"], projection_reservation_id(0));
+        assert_eq!(bid["impid"], "slot-0");
+        assert!(
+            bid.get("adm").is_none(),
+            "tagged render_source should be the sole browser authority"
+        );
+        assert_eq!(json["cur"], "USD");
+        assert_eq!(
+            bid["ext"]["trusted_server"],
+            json!({
+                "candidate_id": projection_candidate_id(0),
+                "slot_id": "slot-0",
+                "render_source": {
+                    "type": "adm",
+                    "version": 1,
+                    "adm": "xxxxxxx",
+                    "width": 300,
+                    "height": 250,
+                }
+            })
+        );
+        assert_eq!(
+            json["ext"]["trusted_server"]["slot_results"],
+            serde_json::to_value(&canonical.projection.auction)
+                .expect("decision set should serialize")
+        );
+    }
+
+    #[test]
+    fn exact_openrtb_serializer_carries_identity_generation_failure_without_a_bid() {
+        let canonical = canonicalize_browser_auction_projection_v1(
+            BrowserAuctionProjectionV1 {
+                version: 1,
+                auction: AuctionDecisionSetV1 {
+                    version: 1,
+                    auction_id: "auction-identity-failure".to_string(),
+                    results: vec![SlotAuctionDecisionV1::Failed {
+                        slot: "slot-0".to_string(),
+                        reason: crate::auction::types::AuctionSlotFailureReason::IdentityGenerationFailed,
+                    }],
+                },
+                slots: Vec::new(),
+                bids: Vec::new(),
+            },
+            "https://publisher.example",
+        )
+        .expect("identity failure decision should canonicalize");
+
+        let json: JsonValue = serde_json::from_slice(
+            &serialize_trusted_server_auction_response_v1(&canonical)
+                .expect("identity failure response should serialize"),
+        )
+        .expect("identity failure response should be JSON");
+
+        assert_eq!(json["seatbid"], json!([]));
+        assert_eq!(
+            json["ext"]["trusted_server"]["slot_results"]["results"][0],
+            json!({
+                "slot": "slot-0",
+                "outcome": "failed",
+                "reason": "identity_generation_failed",
+            })
+        );
+    }
 }
diff --git a/crates/trusted-server-core/src/auction/mod.rs b/crates/trusted-server-core/src/auction/mod.rs
index 432303928..e2923d250 100644
--- a/crates/trusted-server-core/src/auction/mod.rs
+++ b/crates/trusted-server-core/src/auction/mod.rs
@@ -228,6 +228,6 @@ mod plan_sharing_tests {
         let registry = IntegrationRegistry::with_plan(&settings, plan)
             .expect("should build APS renderer registry");
 
-        assert!(registry.has_route(&http::Method::GET, "/integrations/aps/renderer"));
+        assert!(registry.has_reserved_path("/integrations/aps/renderer/v2"));
     }
 }
diff --git a/crates/trusted-server-core/src/auction/openrtb.rs b/crates/trusted-server-core/src/auction/openrtb.rs
index d9f20c42e..89ef5f426 100644
--- a/crates/trusted-server-core/src/auction/openrtb.rs
+++ b/crates/trusted-server-core/src/auction/openrtb.rs
@@ -629,6 +629,9 @@ fn extract_standard_bid(value: &Value, returned_seat: Option<&str>) -> Option<Bi
         .map(str::to_string)?;
     Some(Bid {
         slot_id,
+        candidate_id: None,
+        candidate_provider: None,
+        renderer_reservation_id: None,
         price: Some(price),
         currency: DEFAULT_CURRENCY.to_string(),
         creative: Some(creative),
diff --git a/crates/trusted-server-core/src/auction/orchestrator.rs b/crates/trusted-server-core/src/auction/orchestrator.rs
index 763c3bef5..31bf1e476 100644
--- a/crates/trusted-server-core/src/auction/orchestrator.rs
+++ b/crates/trusted-server-core/src/auction/orchestrator.rs
@@ -16,14 +16,28 @@ use super::openrtb::unused_bidder_params_count;
 use super::plan::AuctionPlan;
 use super::provider::{
     AuctionProvider, GenericOpenRtbProvider, ProviderParseState, ProviderRequestOutcome,
+    ProviderSlotDisposition, ProviderSlotOutcome,
 };
-#[cfg(test)]
-use super::routing::RoutedAuction;
-use super::routing::route_auction;
+use super::routing::{RoutedAuction, route_auction};
 use super::telemetry::AbandonedProviderCall;
-use super::types::{AuctionContext, AuctionRequest, AuctionResponse, Bid, BidStatus};
+use super::types::{
+    AuctionContext, AuctionDecisionSetV1, AuctionDropReason, AuctionIdentityGenerator,
+    AuctionRequest, AuctionResponse, AuctionSlotFailureReason, Bid, BidStatus,
+    SlotAuctionDecisionV1, SystemAuctionIdentityGenerator, mint_response_unique_base64url_identity,
+};
 use crate::request_signing::RequestSigner;
 
+const CANDIDATE_ID_BYTES: usize = 9;
+const CANDIDATE_ID_COLLISION_RETRIES: usize = 8;
+const MAX_UPSTREAM_BID_ID_BYTES: usize = 64;
+
+type EligibleSlotsByProvider = HashMap<String, HashSet<String>>;
+
+struct NormalizedProviderResponses {
+    outcomes: Vec<ProviderSlotOutcome>,
+    candidates: HashMap<String, Bid>,
+}
+
 /// In-flight auction requests dispatched to SSP backends.
 ///
 /// Created by [`AuctionOrchestrator::dispatch_auction`] and consumed by
@@ -45,6 +59,7 @@ pub struct DispatchedAuction {
     planned_unused_bidder_params: HashMap<String, u32>,
     planned_unroutable_bidder_count: u32,
     planned_provider_order: HashMap<String, usize>,
+    eligible_slots_by_provider: EligibleSlotsByProvider,
 }
 
 struct ProviderLaunchState {
@@ -75,11 +90,18 @@ pub enum DispatchAuctionOutcome {
         metadata: HashMap<String, serde_json::Value>,
         /// Elapsed dispatch time.
         elapsed_ms: u64,
+        /// Exact provider-to-slot eligibility established during routing.
+        eligible_slots_by_provider: EligibleSlotsByProvider,
     },
     /// One or more providers produced an immediate response or started a request.
     Dispatched(DispatchedAuction),
 }
 
+/// A dispatch attempt either has in-flight transport to collect or is already terminal.
+pub(crate) enum ResolvedDispatchOutcome {
+    InFlight(Box<DispatchedAuction>),
+    Complete(Box<OrchestrationResult>),
+}
 impl DispatchedAuction {
     /// Consume the dispatch token without collecting provider responses.
     #[must_use]
@@ -133,6 +155,7 @@ impl DispatchedAuction {
             planned_unused_bidder_params: HashMap::new(),
             planned_unroutable_bidder_count: 0,
             planned_provider_order: HashMap::new(),
+            eligible_slots_by_provider: HashMap::new(),
         }
     }
 }
@@ -219,6 +242,23 @@ fn provider_skipped_response(provider_name: &str) -> AuctionResponse {
     )
 }
 
+fn canonical_provider_response(
+    expected_provider: &str,
+    response: AuctionResponse,
+) -> AuctionResponse {
+    if response.provider == expected_provider {
+        response
+    } else {
+        log::warn!(
+            "Provider '{}' returned response identity '{}'; rejecting mismatched response",
+            expected_provider,
+            response.provider
+        );
+        AuctionResponse::error(expected_provider, response.response_time_ms)
+            .with_drop_reason(AuctionDropReason::InvalidProviderResponse)
+    }
+}
+
 /// Compute the remaining time budget from a deadline.
 ///
 /// Returns the number of milliseconds left before `timeout_ms` is exceeded,
@@ -259,6 +299,23 @@ fn routing_metadata(unroutable_bidder_count: u32) -> HashMap<String, serde_json:
     )])
 }
 
+fn routed_eligible_slots(routed: &RoutedAuction) -> EligibleSlotsByProvider {
+    routed
+        .inputs()
+        .iter()
+        .map(|input| {
+            (
+                input.provider_id().as_str().to_string(),
+                input
+                    .slots()
+                    .iter()
+                    .map(|slot| slot.slot().id.clone())
+                    .collect(),
+            )
+        })
+        .collect()
+}
+
 /// Attach only the count derived from the routed provider input at dispatch.
 ///
 /// This is intentionally applied after every provider outcome is materialized,
@@ -311,6 +368,7 @@ pub struct AuctionOrchestrator {
     config: AuctionConfig,
     #[cfg(test)]
     providers: HashMap<String, Arc<dyn AuctionProvider>>,
+    identity_generator: Arc<dyn AuctionIdentityGenerator>,
 }
 
 /// Test harness for the live plan-backed orchestrator semantics.
@@ -319,6 +377,7 @@ pub(crate) struct AuctionOrchestratorHarness {
     plan: Arc<AuctionPlan>,
     providers: Vec<Arc<GenericOpenRtbProvider>>,
     mediator: Option<Arc<dyn AuctionProvider>>,
+    identity_generator: Arc<dyn AuctionIdentityGenerator>,
 }
 
 struct PlannedLaunchState {
@@ -349,9 +408,18 @@ impl AuctionOrchestratorHarness {
             plan,
             providers,
             mediator,
+            identity_generator: Arc::new(SystemAuctionIdentityGenerator),
         }
     }
 
+    pub(crate) fn with_identity_generator(
+        mut self,
+        identity_generator: Arc<dyn AuctionIdentityGenerator>,
+    ) -> Self {
+        self.identity_generator = identity_generator;
+        self
+    }
+
     pub(crate) fn provider_count(&self) -> usize {
         self.providers.len()
     }
@@ -621,12 +689,21 @@ impl AuctionOrchestratorHarness {
                 .unwrap_or(usize::MAX)
         });
 
+        let helper = AuctionOrchestrator::with_identity_generator(
+            AuctionConfig::default(),
+            Arc::clone(&self.identity_generator),
+        );
+        let eligible_slots_by_provider = routed_eligible_slots(routed);
+        let normalized = helper.normalize_provider_responses_with_eligibility(
+            original_request,
+            &mut responses,
+            &eligible_slots_by_provider,
+        );
         let floor_prices = original_request
             .slots
             .iter()
             .filter_map(|slot| slot.floor_price.map(|floor| (slot.id.clone(), floor)))
             .collect::<HashMap<_, _>>();
-        let helper = AuctionOrchestrator::new(AuctionConfig::default());
         let local_winners = || helper.select_winning_bids(&responses, &floor_prices);
         let (mediator_response, winning_bids) = if let Some(mediator) = &self.mediator {
             let remaining_ms = remaining_budget_ms(auction_start, context.timeout_ms);
@@ -646,10 +723,17 @@ impl AuctionOrchestratorHarness {
                         "Planned mediator transport budget canonicalized to zero; using local ranking"
                     );
                     let winning_bids = local_winners();
+                    let decision_set = helper.build_decision_set(
+                        original_request,
+                        &normalized.outcomes,
+                        &winning_bids,
+                        true,
+                    );
                     return Ok(OrchestrationResult {
                         provider_responses: responses,
                         mediator_response: None,
                         winning_bids,
+                        decision_set,
                         total_time_ms: auction_start.elapsed().as_millis() as u64,
                         metadata: routing_metadata(routed.diagnostics().unroutable_bidder_count()),
                     });
@@ -752,10 +836,18 @@ impl AuctionOrchestratorHarness {
             "Auction routing diagnostics: unroutable_bidder_count={}",
             unroutable_bidder_count
         );
+        let mediation_failed = self.mediator.is_some() && mediator_response.is_none();
+        let decision_set = helper.build_decision_set(
+            original_request,
+            &normalized.outcomes,
+            &winning_bids,
+            mediation_failed,
+        );
         Ok(OrchestrationResult {
             provider_responses: responses,
             mediator_response,
             winning_bids,
+            decision_set,
             total_time_ms: auction_start.elapsed().as_millis() as u64,
             metadata: routing_metadata(unroutable_bidder_count),
         })
@@ -786,6 +878,7 @@ impl AuctionOrchestrator {
             planned_providers: Vec::new(),
             mediator: None,
             providers: HashMap::new(),
+            identity_generator: Arc::new(SystemAuctionIdentityGenerator),
         }
     }
 
@@ -809,15 +902,32 @@ impl AuctionOrchestrator {
             config: AuctionConfig::default(),
             #[cfg(test)]
             providers: HashMap::new(),
+            identity_generator: Arc::new(SystemAuctionIdentityGenerator),
         }
     }
 
+    #[cfg(test)]
+    fn with_identity_generator(
+        config: AuctionConfig,
+        identity_generator: Arc<dyn AuctionIdentityGenerator>,
+    ) -> Self {
+        let mut orchestrator = Self::new(config);
+        orchestrator.identity_generator = identity_generator;
+        orchestrator
+    }
+
     /// Return whether this orchestrator and another plan consumer share the same plan allocation.
     #[must_use]
     pub fn shares_plan(&self, plan: &Arc<AuctionPlan>) -> bool {
         Arc::ptr_eq(&self.plan, plan)
     }
 
+    /// Return whether the compiled plan contains the named provider profile.
+    #[must_use]
+    pub fn has_profile(&self, profile_id: &str) -> bool {
+        self.plan.has_profile(profile_id)
+    }
+
     /// Register an auction provider in the legacy parity harness.
     #[cfg(test)]
     pub(crate) fn register_provider(&mut self, provider: Arc<dyn AuctionProvider>) {
@@ -837,15 +947,32 @@ impl AuctionOrchestrator {
         request: &AuctionRequest,
         context: &AuctionContext<'_>,
     ) -> Result<OrchestrationResult, Report<TrustedServerError>> {
-        match self.dispatch_auction(request, context).await {
-            DispatchAuctionOutcome::Dispatched(dispatched) => Ok(self
-                .collect_dispatched_auction(dispatched, context.services, context)
+        match self
+            .resolve_dispatch_outcome(request, self.dispatch_auction(request, context).await)?
+        {
+            ResolvedDispatchOutcome::InFlight(dispatched) => Ok(self
+                .collect_dispatched_auction(*dispatched, context.services, context)
                 .await),
+            ResolvedDispatchOutcome::Complete(result) => Ok(*result),
+        }
+    }
+
+    /// Normalize a split dispatch result without starting any additional transport.
+    pub(crate) fn resolve_dispatch_outcome(
+        &self,
+        request: &AuctionRequest,
+        outcome: DispatchAuctionOutcome,
+    ) -> Result<ResolvedDispatchOutcome, Report<TrustedServerError>> {
+        match outcome {
+            DispatchAuctionOutcome::Dispatched(dispatched) => {
+                Ok(ResolvedDispatchOutcome::InFlight(Box::new(dispatched)))
+            }
             DispatchAuctionOutcome::DispatchFailed {
-                provider_responses,
+                mut provider_responses,
                 fatal_admission_error,
                 metadata,
                 elapsed_ms,
+                eligible_slots_by_provider,
                 ..
             } => {
                 if let Some(error) = fatal_admission_error {
@@ -853,17 +980,33 @@ impl AuctionOrchestrator {
                         message: "Planned auction admission failed".to_string(),
                     }));
                 }
-                Ok(OrchestrationResult {
-                    provider_responses,
-                    mediator_response: None,
-                    winning_bids: HashMap::new(),
-                    total_time_ms: elapsed_ms,
-                    metadata,
-                })
+                let normalized = self.normalize_provider_responses_with_eligibility(
+                    request,
+                    &mut provider_responses,
+                    &eligible_slots_by_provider,
+                );
+                let winning_bids = HashMap::new();
+                let decision_set =
+                    self.build_decision_set(request, &normalized.outcomes, &winning_bids, false);
+                Ok(ResolvedDispatchOutcome::Complete(Box::new(
+                    OrchestrationResult {
+                        provider_responses,
+                        mediator_response: None,
+                        winning_bids,
+                        decision_set,
+                        total_time_ms: elapsed_ms,
+                        metadata,
+                    },
+                )))
             }
             DispatchAuctionOutcome::NotStarted => {
                 if self.planned_providers.is_empty() {
-                    Ok(OrchestrationResult::no_bid())
+                    Ok(ResolvedDispatchOutcome::Complete(Box::new(
+                        OrchestrationResult::no_bid(
+                            request,
+                            AuctionSlotFailureReason::SlotNotEligible,
+                        ),
+                    )))
                 } else {
                     Err(Report::new(TrustedServerError::Auction {
                         message: "No planned provider request was started".to_string(),
@@ -873,7 +1016,395 @@ impl AuctionOrchestrator {
         }
     }
 
-    /// Execute an auction through the compiled plan.
+    #[cfg(test)]
+    fn provider_is_eligible_for_slot(
+        &self,
+        provider_name: &str,
+        slot: &super::types::AdSlot,
+    ) -> bool {
+        self.providers.get(provider_name).is_some_and(|provider| {
+            provider.is_enabled()
+                && slot
+                    .formats
+                    .iter()
+                    .any(|format| provider.supports_media_type(&format.media_type))
+        })
+    }
+
+    #[cfg(test)]
+    fn eligible_slot_ids(&self, provider_name: &str, request: &AuctionRequest) -> HashSet<String> {
+        request
+            .slots
+            .iter()
+            .filter(|slot| self.provider_is_eligible_for_slot(provider_name, slot))
+            .map(|slot| slot.id.clone())
+            .collect()
+    }
+
+    fn valid_upstream_bid_id(value: &str) -> bool {
+        !value.is_empty()
+            && value.len() <= MAX_UPSTREAM_BID_ID_BYTES
+            && !value.bytes().any(|byte| byte <= 0x1f || byte == 0x7f)
+    }
+
+    fn mint_candidate_id(&self, issued: &mut HashSet<String>) -> Option<String> {
+        let candidate_id = mint_response_unique_base64url_identity(
+            self.identity_generator.as_ref(),
+            issued,
+            "",
+            CANDIDATE_ID_BYTES,
+            CANDIDATE_ID_COLLISION_RETRIES,
+        )?;
+        debug_assert_eq!(candidate_id.len(), 12);
+        Some(candidate_id)
+    }
+
+    fn response_failure_reason(response: &AuctionResponse) -> Option<AuctionSlotFailureReason> {
+        if response.status == BidStatus::Error || response.status == BidStatus::Pending {
+            return match response
+                .metadata
+                .get("error_type")
+                .and_then(serde_json::Value::as_str)
+            {
+                Some(ERROR_TYPE_TIMEOUT) => Some(AuctionSlotFailureReason::ProviderTimeout),
+                Some(ERROR_TYPE_PARSE_RESPONSE) => {
+                    Some(AuctionSlotFailureReason::InvalidProviderResponse)
+                }
+                _ => {
+                    let invalid = response
+                        .metadata
+                        .get("drop_reasons")
+                        .and_then(serde_json::Value::as_object)
+                        .is_some_and(|reasons| reasons.contains_key("invalid_provider_response"));
+                    Some(if invalid {
+                        AuctionSlotFailureReason::InvalidProviderResponse
+                    } else {
+                        AuctionSlotFailureReason::ProviderError
+                    })
+                }
+            };
+        }
+
+        None
+    }
+
+    #[cfg(test)]
+    fn normalize_provider_responses(
+        &self,
+        request: &AuctionRequest,
+        responses: &mut [AuctionResponse],
+    ) -> NormalizedProviderResponses {
+        let eligible_slots_by_provider = self
+            .config
+            .providers
+            .keys()
+            .map(super::plan::ProviderId::as_str)
+            .map(|provider| {
+                (
+                    provider.to_string(),
+                    self.eligible_slot_ids(provider, request),
+                )
+            })
+            .collect();
+        self.normalize_provider_responses_with_eligibility(
+            request,
+            responses,
+            &eligible_slots_by_provider,
+        )
+    }
+
+    fn normalize_provider_responses_with_eligibility(
+        &self,
+        request: &AuctionRequest,
+        responses: &mut [AuctionResponse],
+        eligible_slots_by_provider: &EligibleSlotsByProvider,
+    ) -> NormalizedProviderResponses {
+        let requested_slots: HashMap<&str, &super::types::AdSlot> = request
+            .slots
+            .iter()
+            .map(|slot| (slot.id.as_str(), slot))
+            .collect();
+        let mut issued_candidate_ids = HashSet::new();
+        let mut candidates = HashMap::new();
+        let mut outcomes = Vec::new();
+
+        for response in responses {
+            let eligible_slots = eligible_slots_by_provider
+                .get(&response.provider)
+                .cloned()
+                .unwrap_or_default();
+            let response_failure = Self::response_failure_reason(response);
+            let mut upstream_counts = HashMap::<String, usize>::new();
+            for bid in &response.bids {
+                if let Some(upstream_id) = bid.bid_id.as_deref()
+                    && Self::valid_upstream_bid_id(upstream_id)
+                {
+                    *upstream_counts.entry(upstream_id.to_string()).or_default() += 1;
+                }
+            }
+
+            let mut invalid_slots = response
+                .metadata
+                .get("invalid_slots")
+                .and_then(serde_json::Value::as_object)
+                .map(|slots| {
+                    slots
+                        .iter()
+                        .filter_map(|(slot, reason)| {
+                            (reason.as_str() == Some("invalid_provider_response")).then_some((
+                                slot.clone(),
+                                AuctionSlotFailureReason::InvalidProviderResponse,
+                            ))
+                        })
+                        .collect::<HashMap<_, _>>()
+                })
+                .unwrap_or_default();
+            let mut global_invalid = response
+                .metadata
+                .get("global_invalid_provider_response")
+                .and_then(serde_json::Value::as_bool)
+                .unwrap_or(false);
+            let mut accepted = Vec::new();
+            for mut bid in core::mem::take(&mut response.bids) {
+                let requested_slot = requested_slots.get(bid.slot_id.as_str()).copied();
+                let slot_is_eligible = eligible_slots.contains(&bid.slot_id);
+                let dimensions_match = requested_slot.is_some_and(|slot| {
+                    slot.formats.iter().any(|format| {
+                        format.width == bid.width
+                            && format.height == bid.height
+                            && format.media_type == super::types::MediaType::Banner
+                    })
+                });
+                let upstream_id = bid.bid_id.as_deref();
+                let upstream_is_valid = upstream_id.is_some_and(Self::valid_upstream_bid_id);
+                let upstream_is_unique = upstream_id.is_some_and(|upstream_id| {
+                    upstream_counts.get(upstream_id).copied() == Some(1)
+                });
+                let bid_is_valid = response.status == BidStatus::Success
+                    && slot_is_eligible
+                    && dimensions_match
+                    && upstream_is_valid
+                    && upstream_is_unique
+                    && bid.currency == "USD"
+                    && bid
+                        .price
+                        .is_some_and(|price| price.is_finite() && price >= 0.0);
+
+                if !bid_is_valid {
+                    if requested_slot.is_some() {
+                        invalid_slots
+                            .entry(bid.slot_id.clone())
+                            .or_insert(AuctionSlotFailureReason::InvalidProviderResponse);
+                    } else {
+                        global_invalid = true;
+                    }
+                    continue;
+                }
+
+                let Some(candidate_id) = self.mint_candidate_id(&mut issued_candidate_ids) else {
+                    invalid_slots
+                        .insert(bid.slot_id.clone(), AuctionSlotFailureReason::InternalError);
+                    continue;
+                };
+                bid.candidate_id = Some(candidate_id.clone());
+                bid.candidate_provider = Some(response.provider.clone());
+                bid.renderer_reservation_id = None;
+                candidates.insert(candidate_id, bid.clone());
+                accepted.push(bid);
+            }
+            let internally_failed_slots: HashSet<&str> = invalid_slots
+                .iter()
+                .filter_map(|(slot, reason)| {
+                    (*reason == AuctionSlotFailureReason::InternalError).then_some(slot.as_str())
+                })
+                .collect();
+            if !internally_failed_slots.is_empty() {
+                accepted.retain(|bid| !internally_failed_slots.contains(bid.slot_id.as_str()));
+                candidates.retain(|_, bid| {
+                    bid.candidate_provider.as_deref() != Some(response.provider.as_str())
+                        || !internally_failed_slots.contains(bid.slot_id.as_str())
+                });
+            }
+            response.bids = accepted;
+
+            for slot in &request.slots {
+                if !eligible_slots.contains(&slot.id) {
+                    continue;
+                }
+                let slot_candidates: Vec<Bid> = response
+                    .bids
+                    .iter()
+                    .filter(|bid| bid.slot_id == slot.id)
+                    .cloned()
+                    .collect();
+                let disposition = if !slot_candidates.is_empty() {
+                    ProviderSlotDisposition::Candidates(slot_candidates)
+                } else if let Some(reason) = invalid_slots.get(&slot.id).copied() {
+                    ProviderSlotDisposition::Failed(reason)
+                } else if global_invalid {
+                    ProviderSlotDisposition::Failed(
+                        AuctionSlotFailureReason::InvalidProviderResponse,
+                    )
+                } else if let Some(reason) = response_failure {
+                    ProviderSlotDisposition::Failed(reason)
+                } else {
+                    ProviderSlotDisposition::NoBid
+                };
+                outcomes.push(ProviderSlotOutcome {
+                    provider: response.provider.clone(),
+                    slot: slot.id.clone(),
+                    disposition,
+                });
+            }
+        }
+
+        NormalizedProviderResponses {
+            outcomes,
+            candidates,
+        }
+    }
+
+    fn build_decision_set(
+        &self,
+        request: &AuctionRequest,
+        outcomes: &[ProviderSlotOutcome],
+        winning_bids: &HashMap<String, Bid>,
+        mediation_failed: bool,
+    ) -> AuctionDecisionSetV1 {
+        let results = request
+            .slots
+            .iter()
+            .map(|slot| {
+                if let Some(winner) = winning_bids.get(&slot.id) {
+                    return winner.candidate_id.as_ref().map_or_else(
+                        || SlotAuctionDecisionV1::Failed {
+                            slot: slot.id.clone(),
+                            reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                        },
+                        |candidate_id| SlotAuctionDecisionV1::Winner {
+                            slot: slot.id.clone(),
+                            candidate_id: candidate_id.clone(),
+                        },
+                    );
+                }
+
+                let eligible_provider_count = outcomes
+                    .iter()
+                    .filter(|outcome| outcome.slot == slot.id)
+                    .count();
+                if eligible_provider_count == 0 {
+                    return SlotAuctionDecisionV1::Failed {
+                        slot: slot.id.clone(),
+                        reason: AuctionSlotFailureReason::SlotNotEligible,
+                    };
+                }
+
+                let mut failures: Vec<AuctionSlotFailureReason> = outcomes
+                    .iter()
+                    .filter(|outcome| outcome.slot == slot.id)
+                    .filter_map(|outcome| match outcome.disposition {
+                        ProviderSlotDisposition::Failed(reason) => Some(reason),
+                        ProviderSlotDisposition::Candidates(_) | ProviderSlotDisposition::NoBid => {
+                            None
+                        }
+                    })
+                    .collect();
+                if mediation_failed {
+                    failures.push(AuctionSlotFailureReason::MediationFailed);
+                }
+                failures.sort_by_key(|reason| reason.priority());
+                failures.first().copied().map_or_else(
+                    || SlotAuctionDecisionV1::NoBid {
+                        slot: slot.id.clone(),
+                    },
+                    |reason| SlotAuctionDecisionV1::Failed {
+                        slot: slot.id.clone(),
+                        reason,
+                    },
+                )
+            })
+            .collect();
+
+        AuctionDecisionSetV1 {
+            version: 1,
+            auction_id: request.id.clone(),
+            results,
+        }
+    }
+
+    fn resolve_mediator_candidates(
+        mediator_response: AuctionResponse,
+        candidates: &HashMap<String, Bid>,
+    ) -> Result<AuctionResponse, ()> {
+        if mediator_response.status == BidStatus::Error
+            || mediator_response.status == BidStatus::Pending
+        {
+            return Err(());
+        }
+
+        let mut seen = HashSet::new();
+        let mut seen_slots = HashSet::new();
+        let mut resolved = Vec::with_capacity(mediator_response.bids.len());
+        for selection in &mediator_response.bids {
+            let Some(candidate_id) = selection.candidate_id.as_deref() else {
+                return Err(());
+            };
+            if !seen.insert(candidate_id.to_string()) {
+                return Err(());
+            }
+            let Some(source) = candidates.get(candidate_id) else {
+                return Err(());
+            };
+            let Some(selected_price) = selection
+                .price
+                .filter(|price| price.is_finite() && *price >= 0.0)
+            else {
+                return Err(());
+            };
+            let source_authority_matches = selection.slot_id == source.slot_id
+                && selection.candidate_provider == source.candidate_provider
+                && selection.currency == source.currency
+                && selection.creative == source.creative
+                && selection.adomain == source.adomain
+                && selection.bidder == source.bidder
+                && selection.width == source.width
+                && selection.height == source.height
+                && selection.nurl == source.nurl
+                && selection.burl == source.burl
+                && selection.bid_id == source.bid_id
+                && selection.ad_id == source.ad_id
+                && selection.creative_id == source.creative_id
+                && selection.renderer == source.renderer
+                && selection.cache_id == source.cache_id
+                && selection.cache_host == source.cache_host
+                && selection.cache_path == source.cache_path;
+            if !seen_slots.insert(source.slot_id.as_str()) || !source_authority_matches {
+                return Err(());
+            }
+
+            let mut restored = source.clone();
+            restored.price = Some(selected_price);
+            resolved.push(restored);
+        }
+
+        Ok(AuctionResponse {
+            provider: mediator_response.provider,
+            status: if resolved.is_empty() {
+                BidStatus::NoBid
+            } else {
+                BidStatus::Success
+            },
+            bids: resolved,
+            response_time_ms: mediator_response.response_time_ms,
+            metadata: mediator_response.metadata,
+        })
+    }
+
+    /// Execute an auction using the auto-detected strategy.
+    ///
+    /// Strategy is determined by mediator configuration:
+    /// - If mediator is configured: runs parallel mediation (bidders → mediator decides)
+    /// - If no mediator: runs parallel only (bidders → highest CPM wins)
     ///
     /// # Errors
     ///
@@ -885,7 +1416,10 @@ impl AuctionOrchestrator {
         context: &AuctionContext<'_>,
     ) -> Result<OrchestrationResult, Report<TrustedServerError>> {
         if !self.enabled {
-            return Ok(OrchestrationResult::no_bid());
+            return Ok(OrchestrationResult::no_bid(
+                request,
+                AuctionSlotFailureReason::AuctionDisabled,
+            ));
         }
         #[cfg(not(test))]
         return self.run_planned_auction(request, context).await;
@@ -936,138 +1470,145 @@ impl AuctionOrchestrator {
         context: &AuctionContext<'_>,
     ) -> Result<OrchestrationResult, Report<TrustedServerError>> {
         let mediation_start = Instant::now();
-        let provider_responses = self.run_providers_parallel(request, context).await?;
+        let mut provider_responses = self.run_providers_parallel(request, context).await?;
+        let normalized = self.normalize_provider_responses(request, &mut provider_responses);
 
         let floor_prices = self.floor_prices_by_slot(request);
-        let (mediator_response, winning_bids) = if let Some(mediator_name) = &self.config.mediator {
-            let mediator = self.get_provider(mediator_name)?;
-
-            log::info!(
-                "Sending {} provider responses to mediator: {}",
-                provider_responses.len(),
-                mediator.provider_name()
-            );
-
-            // Give the mediator only the remaining time from the auction
-            // deadline, not the full timeout — the bidding phase already
-            // consumed part of it. Canonicalize the transport timeout so the
-            // backend name remains stable across equivalent budget values.
-            let remaining_ms = remaining_budget_ms(mediation_start, context.timeout_ms);
-            let mediator_timeout = context
-                .services
-                .backend()
-                .canonicalize_transport_timeout_ms(remaining_ms, mediator.timeout_ms());
-
-            if mediator_timeout == 0 {
-                log::warn!("Auction timeout exhausted during bidding phase; skipping mediator");
-                let winning = self.select_winning_bids(&provider_responses, &floor_prices);
-                return Ok(OrchestrationResult {
-                    provider_responses,
-                    mediator_response: None,
-                    winning_bids: winning,
-                    total_time_ms: 0,
-                    metadata: HashMap::new(),
-                });
-            }
-
-            let mediator_context = AuctionContext {
-                settings: context.settings,
-                request: context.request,
-                timeout_ms: mediator_timeout,
-                transport_timeout_ms: mediator_timeout,
-                provider_responses: Some(&provider_responses),
-                services: context.services,
-            };
+        let mut mediation_failed = false;
+        let mut mediator_response = None;
+        let mut winning_bids = None;
 
-            let start_time = Instant::now();
-            let mediator_resp = match mediator
-                .request_bids(request, &mediator_context)
-                .await
-                .change_context(TrustedServerError::Auction {
-                    message: format!("Mediator {} failed to launch", mediator.provider_name()),
-                })? {
-                ProviderRequestOutcome::Immediate(response) => response,
-                ProviderRequestOutcome::Pending {
-                    request: pending,
-                    parse_state,
-                } => {
-                    let platform_resp = mediator_context
-                        .services
-                        .http_client()
-                        .wait(pending)
-                        .await
-                        .change_context(TrustedServerError::Auction {
-                            message: format!(
-                                "Mediator {} request failed",
-                                mediator.provider_name()
-                            ),
-                        })?;
-                    let response_time_ms = start_time.elapsed().as_millis() as u64;
-                    if AuctionDeadlinePolicy::for_runtime(context.services)
-                        .rejects_late_completion(mediation_start, context.timeout_ms)
+        if let Some(mediator_name) = &self.config.mediator {
+            if let Some(mediator) = self.providers.get(mediator_name) {
+                log::info!(
+                    "Sending {} provider responses to mediator: {}",
+                    provider_responses.len(),
+                    mediator.provider_name()
+                );
+                let remaining_ms = remaining_budget_ms(mediation_start, context.timeout_ms);
+                let logical_budget_ms = remaining_ms.min(mediator.timeout_ms());
+                let transport_timeout_ms = context
+                    .services
+                    .backend()
+                    .canonicalize_transport_timeout_ms(logical_budget_ms, mediator.timeout_ms());
+                if logical_budget_ms == 0 || transport_timeout_ms == 0 {
+                    log::warn!("Auction timeout exhausted during bidding phase; skipping mediator");
+                    mediation_failed = true;
+                } else {
+                    let mediator_context = AuctionContext {
+                        settings: context.settings,
+                        request: context.request,
+                        timeout_ms: logical_budget_ms,
+                        transport_timeout_ms,
+                        provider_responses: Some(&provider_responses),
+                        services: context.services,
+                    };
+                    let start_time = Instant::now();
+                    let raw_response = match mediator.request_bids(request, &mediator_context).await
                     {
-                        log::warn!(
-                            "Mediator '{}' completed after the hard auction deadline; using local ranking ({}ms)",
-                            mediator.provider_name(),
-                            response_time_ms
-                        );
-                        let winning = self.select_winning_bids(&provider_responses, &floor_prices);
-                        return Ok(OrchestrationResult {
-                            provider_responses,
-                            mediator_response: None,
-                            winning_bids: winning,
-                            total_time_ms: 0,
-                            metadata: HashMap::new(),
-                        });
-                    }
-
-                    mediator
-                        .parse_response_with_context_and_state(
-                            platform_resp,
-                            response_time_ms,
-                            request,
-                            &mediator_context,
-                            parse_state.as_deref(),
-                        )
-                        .await
-                        .change_context(TrustedServerError::Auction {
-                            message: format!("Mediator {} parse failed", mediator.provider_name()),
-                        })?
-                }
-            };
+                        Ok(ProviderRequestOutcome::Immediate(response)) => Some(
+                            canonical_provider_response(mediator.provider_name(), response),
+                        ),
+                        Ok(ProviderRequestOutcome::Pending {
+                            request: pending,
+                            parse_state,
+                        }) => match mediator_context.services.http_client().wait(pending).await {
+                            Ok(platform_response) => {
+                                let response_time_ms = start_time.elapsed().as_millis() as u64;
+                                if AuctionDeadlinePolicy::for_runtime(context.services)
+                                    .rejects_late_completion(mediation_start, context.timeout_ms)
+                                {
+                                    None
+                                } else {
+                                    mediator
+                                        .parse_response_with_context_and_state(
+                                            platform_response,
+                                            response_time_ms,
+                                            request,
+                                            &mediator_context,
+                                            parse_state.as_deref(),
+                                        )
+                                        .await
+                                        .inspect_err(|error| {
+                                            log::warn!(
+                                                "Mediator '{}' parse failed: {error:?}",
+                                                mediator.provider_name()
+                                            );
+                                        })
+                                        .ok()
+                                        .map(|response| {
+                                            canonical_provider_response(
+                                                mediator.provider_name(),
+                                                response,
+                                            )
+                                        })
+                                }
+                            }
+                            Err(error) => {
+                                log::warn!(
+                                    "Mediator '{}' request failed: {error:?}",
+                                    mediator.provider_name()
+                                );
+                                None
+                            }
+                        },
+                        Err(error) => {
+                            log::warn!(
+                                "Mediator '{}' failed to launch: {error:?}",
+                                mediator.provider_name()
+                            );
+                            None
+                        }
+                    };
 
-            // Extract only mediator bids with comparable numeric prices.
-            let winning = mediator_resp
-                .bids
-                .iter()
-                .filter_map(|bid| {
-                    if bid.price.is_none() {
-                        log::warn!(
-                            "Mediator '{}' returned bid for slot '{}' without a price - skipping",
-                            mediator.provider_name(),
-                            bid.slot_id
-                        );
-                        None
+                    if let Some(raw_response) = raw_response {
+                        mediator_response = Some(raw_response.clone());
+                        match Self::resolve_mediator_candidates(
+                            raw_response,
+                            &normalized.candidates,
+                        ) {
+                            Ok(resolved) => {
+                                let selected = resolved
+                                    .bids
+                                    .iter()
+                                    .map(|bid| (bid.slot_id.clone(), bid.clone()))
+                                    .collect();
+                                winning_bids =
+                                    Some(self.apply_floor_prices(selected, &floor_prices));
+                                mediator_response = Some(resolved);
+                            }
+                            Err(()) => {
+                                log::warn!(
+                                    "Mediator '{}' returned invalid candidate provenance",
+                                    mediator.provider_name()
+                                );
+                                mediation_failed = true;
+                            }
+                        }
                     } else {
-                        Some((bid.slot_id.clone(), bid.clone()))
+                        mediation_failed = true;
                     }
-                })
-                .collect();
+                }
+            } else {
+                log::warn!("Mediator '{}' not registered", mediator_name);
+                mediation_failed = true;
+            }
+        }
 
-            (
-                Some(mediator_resp),
-                self.apply_floor_prices(winning, &floor_prices),
-            )
-        } else {
-            // No mediator - select best bid per slot from bidder responses
-            let winning = self.select_winning_bids(&provider_responses, &floor_prices);
-            (None, winning)
-        };
+        let winning_bids = winning_bids
+            .unwrap_or_else(|| self.select_winning_bids(&provider_responses, &floor_prices));
+        let decision_set = self.build_decision_set(
+            request,
+            &normalized.outcomes,
+            &winning_bids,
+            mediation_failed,
+        );
 
         Ok(OrchestrationResult {
             provider_responses,
             mediator_response,
             winning_bids,
+            decision_set,
             total_time_ms: 0, // Will be set by caller
             metadata: HashMap::new(),
         })
@@ -1080,14 +1621,18 @@ impl AuctionOrchestrator {
         request: &AuctionRequest,
         context: &AuctionContext<'_>,
     ) -> Result<OrchestrationResult, Report<TrustedServerError>> {
-        let provider_responses = self.run_providers_parallel(request, context).await?;
+        let mut provider_responses = self.run_providers_parallel(request, context).await?;
+        let normalized = self.normalize_provider_responses(request, &mut provider_responses);
         let floor_prices = self.floor_prices_by_slot(request);
         let winning_bids = self.select_winning_bids(&provider_responses, &floor_prices);
+        let decision_set =
+            self.build_decision_set(request, &normalized.outcomes, &winning_bids, false);
 
         Ok(OrchestrationResult {
             provider_responses,
             mediator_response: None,
             winning_bids,
+            decision_set,
             total_time_ms: 0,
             metadata: HashMap::new(),
         })
@@ -1111,9 +1656,7 @@ impl AuctionOrchestrator {
             .collect::<Vec<_>>();
 
         if provider_names.is_empty() {
-            return Err(Report::new(TrustedServerError::Auction {
-                message: "No providers configured".to_string(),
-            }));
+            return Ok(Vec::new());
         }
 
         // Reject multi-provider fan-out before any request launches when the
@@ -1122,14 +1665,14 @@ impl AuctionOrchestrator {
         // blow the auction budget before a later `select` could reject it.
         if provider_names.len() > 1 && !context.services.http_client().supports_concurrent_fanout()
         {
-            return Err(Report::new(TrustedServerError::Auction {
-                message: format!(
-                    "{} auction providers configured, but this platform's HTTP \
-                     client executes requests sequentially — configure a single \
-                     provider, or use an adapter with concurrent fan-out support",
-                    provider_names.len(),
-                ),
-            }));
+            log::warn!(
+                "{} auction providers configured, but this platform's HTTP client executes requests sequentially",
+                provider_names.len(),
+            );
+            return Ok(provider_names
+                .iter()
+                .map(|provider_name| provider_launch_failed_response(provider_name, 0))
+                .collect());
         }
 
         log::info!(
@@ -1145,8 +1688,6 @@ impl AuctionOrchestrator {
         let mut backend_to_provider: HashMap<String, ProviderLaunchState> = HashMap::new();
         let mut pending_requests: Vec<PlatformPendingRequest> = Vec::new();
         let mut responses = Vec::new();
-        let mut immediate_response_count = 0usize;
-
         for provider_name in &provider_names {
             let provider = match self.providers.get(*provider_name) {
                 Some(p) => p,
@@ -1177,20 +1718,23 @@ impl AuctionOrchestrator {
             // budget skips every provider, including one that might respond immediately.
             if effective_timeout == 0 {
                 log::warn!("Auction timeout exhausted before launching provider request; skipping");
+                responses.push(provider_timeout_response(provider.provider_name(), 0));
                 continue;
             }
 
-            // Immediate providers have no backend name and must remain eligible
-            // to return a synchronous result. Pending providers are still
-            // guarded before dispatch when their name can be predicted.
-            let predicted_backend_name = provider.backend_name(context.services, effective_timeout);
-            if let Some(backend_name) = predicted_backend_name.as_ref()
-                && backend_to_provider.contains_key(backend_name)
+            // Pre-launch guard: `request_bids` fires the outbound send, and
+            // discarding the returned pending handle afterwards does not retract
+            // it. If another provider this auction already claimed the predicted
+            // backend name, skip *before* dispatching so a duplicate never hits
+            // the wire. The post-launch check below stays as a defense for a
+            // provider that resolves to an unexpected name.
+            if let Some(predicted) = provider.backend_name(context.services, effective_timeout)
+                && backend_to_provider.contains_key(&predicted)
             {
                 log::warn!(
                     "Provider '{}' predicted backend name '{}' already belongs to another provider; skipping launch",
                     provider.provider_name(),
-                    backend_name,
+                    predicted,
                 );
                 responses.push(provider_launch_failed_response(provider.provider_name(), 0));
                 continue;
@@ -1218,14 +1762,13 @@ impl AuctionOrchestrator {
                     parse_state,
                 }) => {
                     let request_backend_name = pending.backend_name().map(str::to_string).or_else(|| {
-                        if let Some(backend_name) = predicted_backend_name.as_ref() {
+                        provider.backend_name(context.services, effective_timeout).inspect(|name| {
                             log::warn!(
                                 "Provider '{}' pending request returned no backend name; using predicted name '{}'",
                                 provider.provider_name(),
-                                backend_name,
+                                name,
                             );
-                        }
-                        predicted_backend_name.clone()
+                        })
                     });
                     let Some(request_backend_name) = request_backend_name else {
                         log::warn!(
@@ -1238,6 +1781,10 @@ impl AuctionOrchestrator {
                         ));
                         continue;
                     };
+                    // Post-launch defense: a resolved backend name already
+                    // claimed by another provider would misattribute that
+                    // provider's response, so fail this launch attributably
+                    // instead of overwriting the correlation entry.
                     if backend_to_provider.contains_key(&request_backend_name) {
                         log::warn!(
                             "Provider '{}' resolved backend name '{}' already belongs to another provider; skipping launch",
@@ -1267,12 +1814,14 @@ impl AuctionOrchestrator {
                     );
                 }
                 Ok(ProviderRequestOutcome::Immediate(response)) => {
-                    immediate_response_count += 1;
                     log::debug!(
                         "Provider '{}' completed without an upstream request",
                         provider.provider_name()
                     );
-                    responses.push(response);
+                    responses.push(canonical_provider_response(
+                        provider.provider_name(),
+                        response,
+                    ));
                 }
                 Err(e) => {
                     let response_time_ms = start_time.elapsed().as_millis() as u64;
@@ -1290,18 +1839,7 @@ impl AuctionOrchestrator {
         }
 
         if pending_requests.is_empty() {
-            // An immediate response (for example, an APS-only Prebid no-bid) is
-            // a completed provider outcome. Launch failures alone remain a
-            // terminal auction error rather than being converted to a 200 no-bid.
-            if immediate_response_count > 0 {
-                return Ok(responses);
-            }
-            return Err(Report::new(TrustedServerError::Auction {
-                message: format!(
-                    "All {} configured provider(s) skipped or failed to launch",
-                    provider_names.len()
-                ),
-            }));
+            return Ok(responses);
         }
 
         let deadline_policy = AuctionDeadlinePolicy::for_runtime(context.services);
@@ -1318,7 +1856,7 @@ impl AuctionOrchestrator {
         // some adapters, buffers the selected response body before returning.
         // Backend first-byte and between-bytes timeouts are capped to the
         // remaining auction budget in Phase 1. They are transport timers, not
-        // absolute wall-clock limits, so connection setup and byte-trickling
+        // absolute wall-clock limits, so connection setup and byte trickling
         // remain bounded operational risks rather than strict deadline proof.
         let mut remaining = pending_requests;
 
@@ -1385,7 +1923,10 @@ impl AuctionOrchestrator {
                                     auction_response.status,
                                     auction_response.response_time_ms
                                 );
-                                responses.push(auction_response);
+                                responses.push(canonical_provider_response(
+                                    &state.provider_name,
+                                    auction_response,
+                                ));
                             }
                             Err(e) => {
                                 // lgtm[rust/cleartext-logging]
@@ -1487,9 +2028,20 @@ impl AuctionOrchestrator {
                 };
 
                 let should_replace = match winning_bids.get(&bid.slot_id) {
-                    Some(current_winner) => current_winner
-                        .price
-                        .is_none_or(|current_price| bid_price > current_price),
+                    Some(current_winner) => current_winner.price.is_none_or(|current_price| {
+                        bid_price > current_price
+                            || (bid_price == current_price
+                                && (
+                                    bid.candidate_provider.as_deref().unwrap_or(&bid.bidder),
+                                    bid.bid_id.as_deref().unwrap_or_default(),
+                                ) < (
+                                    current_winner
+                                        .candidate_provider
+                                        .as_deref()
+                                        .unwrap_or(&current_winner.bidder),
+                                    current_winner.bid_id.as_deref().unwrap_or_default(),
+                                ))
+                    }),
                     None => true,
                 };
 
@@ -1556,24 +2108,6 @@ impl AuctionOrchestrator {
             .collect()
     }
 
-    /// Get a provider by name.
-    #[cfg(test)]
-    fn get_provider(
-        &self,
-        name: &str,
-    ) -> Result<&Arc<dyn AuctionProvider>, Report<TrustedServerError>> {
-        self.providers.get(name).ok_or_else(|| {
-            log::warn!(
-                "Provider '{}' configured but not registered. Available providers: {:?}",
-                name,
-                self.providers.keys().collect::<Vec<_>>()
-            );
-            Report::new(TrustedServerError::Auction {
-                message: format!("Provider '{}' not registered", name),
-            })
-        })
-    }
-
     async fn dispatch_planned_auction(
         &self,
         request: &AuctionRequest,
@@ -1600,6 +2134,7 @@ impl AuctionOrchestrator {
             plan,
             context.services.client_info().client_ip,
         );
+        let eligible_slots_by_provider = routed_eligible_slots(&routed);
         let planned_unused_bidder_params = routed
             .inputs()
             .iter()
@@ -1666,6 +2201,7 @@ impl AuctionOrchestrator {
                     fatal_admission_error: Some(error),
                     metadata: routing_metadata(planned_unroutable_bidder_count),
                     elapsed_ms: auction_start.elapsed().as_millis() as u64,
+                    eligible_slots_by_provider,
                 };
             }
         };
@@ -1755,7 +2291,10 @@ impl AuctionOrchestrator {
                 }
                 Ok(ProviderRequestOutcome::Immediate(response)) => {
                     immediate_response_count += 1;
-                    completed_responses.push(response);
+                    completed_responses.push(canonical_provider_response(
+                        provider.provider_name(),
+                        response,
+                    ));
                 }
                 Err(error) => {
                     log::warn!(
@@ -1790,6 +2329,7 @@ impl AuctionOrchestrator {
             planned_unused_bidder_params,
             planned_unroutable_bidder_count,
             planned_provider_order,
+            eligible_slots_by_provider,
         })
     }
 
@@ -1800,10 +2340,10 @@ impl AuctionOrchestrator {
     /// [`DispatchedAuction`] token. The Fastly host begins the SSP round-trips
     /// while WASM continues to `pending_origin.wait()`.
     ///
-    /// Returns [`DispatchAuctionOutcome::NotStarted`] when no providers are configured or
-    /// all providers are disabled / over budget. Returns
-    /// [`DispatchAuctionOutcome::DispatchFailed`] when provider launch attempts
-    /// happened but none could be started.
+    /// The token is returned even when no transport starts. Collection then
+    /// routes zero-budget, launch-failure, disabled, and unconfigured-provider
+    /// cases through the same exhaustive terminal decision builder as ordinary
+    /// responses instead of silently dropping their slot outcomes.
     #[must_use]
     pub async fn dispatch_auction(
         &self,
@@ -1827,6 +2367,18 @@ impl AuctionOrchestrator {
         if provider_names.is_empty() {
             return DispatchAuctionOutcome::NotStarted;
         }
+        #[cfg(test)]
+        let eligible_slots_by_provider = provider_names
+            .iter()
+            .map(|provider| {
+                (
+                    (*provider).to_string(),
+                    self.eligible_slot_ids(provider, request),
+                )
+            })
+            .collect::<EligibleSlotsByProvider>();
+        #[cfg(not(test))]
+        let eligible_slots_by_provider = EligibleSlotsByProvider::new();
 
         // Mirror run_providers_parallel: reject multi-provider fan-out before
         // any request launches when the platform executes `send_async` eagerly
@@ -1843,7 +2395,17 @@ impl AuctionOrchestrator {
                  concurrent fan-out support",
                 provider_names.len(),
             );
-            return DispatchAuctionOutcome::NotStarted;
+            return DispatchAuctionOutcome::DispatchFailed {
+                request: request.clone(),
+                provider_responses: provider_names
+                    .iter()
+                    .map(|provider| provider_launch_failed_response(provider, 0))
+                    .collect(),
+                fatal_admission_error: None,
+                metadata: HashMap::new(),
+                elapsed_ms: 0,
+                eligible_slots_by_provider,
+            };
         }
 
         let auction_start = Instant::now();
@@ -1872,6 +2434,7 @@ impl AuctionOrchestrator {
                     // lgtm[rust/cleartext-logging]
                     // The provider name is a static config identifier (e.g. "prebid"), not a secret.
                     log::warn!("Provider '{}' not registered, skipping", provider_name);
+                    completed_responses.push(provider_launch_failed_response(provider_name, 0));
                     continue;
                 }
             };
@@ -1898,20 +2461,24 @@ impl AuctionOrchestrator {
                     context.timeout_ms,
                     provider.provider_name()
                 );
+                completed_responses.push(provider_timeout_response(
+                    provider.provider_name(),
+                    auction_start.elapsed().as_millis() as u64,
+                ));
                 continue;
             }
 
-            // Do not require a backend name before dispatch: an immediate
-            // provider intentionally has none. Guard predicted names when
-            // available; pending requests without either name fail below.
-            let predicted_backend_name = provider.backend_name(context.services, effective_timeout);
-            if let Some(backend_name) = predicted_backend_name.as_ref()
-                && backend_to_provider.contains_key(backend_name)
+            // Pre-launch guard: skip before `request_bids` fires the outbound
+            // send when another provider this auction already claimed the
+            // predicted backend name (see the parallel path). Dropping the
+            // pending handle afterwards would not retract the request.
+            if let Some(predicted) = provider.backend_name(context.services, effective_timeout)
+                && backend_to_provider.contains_key(&predicted)
             {
                 log::warn!(
                     "Provider '{}' predicted backend name '{}' already belongs to another provider; skipping dispatch",
                     provider.provider_name(),
-                    backend_name,
+                    predicted,
                 );
                 completed_responses
                     .push(provider_launch_failed_response(provider.provider_name(), 0));
@@ -1933,16 +2500,10 @@ impl AuctionOrchestrator {
                     request: pending,
                     parse_state,
                 }) => {
-                    let backend_name = pending.backend_name().map(str::to_string).or_else(|| {
-                        if let Some(backend_name) = predicted_backend_name.as_ref() {
-                            log::warn!(
-                                "Provider '{}' pending request returned no backend name; using predicted name '{}'",
-                                provider.provider_name(),
-                                backend_name,
-                            );
-                        }
-                        predicted_backend_name.clone()
-                    });
+                    let backend_name = pending
+                        .backend_name()
+                        .map(str::to_string)
+                        .or_else(|| provider.backend_name(context.services, effective_timeout));
                     let Some(backend_name) = backend_name else {
                         log::warn!(
                             "Provider '{}' pending request has no backend name; response cannot be correlated",
@@ -1954,9 +2515,14 @@ impl AuctionOrchestrator {
                         ));
                         continue;
                     };
+                    // Post-launch defense: a resolved backend name already
+                    // claimed by another provider would misattribute that
+                    // provider's response, so fail this dispatch attributably
+                    // instead of overwriting the correlation entry.
                     if backend_to_provider.contains_key(&backend_name) {
                         log::warn!(
-                            "Provider '{}' resolved backend name '{}' already belongs to another provider; skipping dispatch",
+                            "Provider '{}' resolved to backend name '{}' already claimed by another \
+                             provider this auction; skipping launch to avoid response misattribution",
                             provider.provider_name(),
                             backend_name,
                         );
@@ -1986,7 +2552,10 @@ impl AuctionOrchestrator {
                 }
                 Ok(ProviderRequestOutcome::Immediate(response)) => {
                     immediate_response_count += 1;
-                    completed_responses.push(response);
+                    completed_responses.push(canonical_provider_response(
+                        provider.provider_name(),
+                        response,
+                    ));
                 }
                 Err(e) => {
                     let response_time_ms = start_time.elapsed().as_millis() as u64;
@@ -2013,6 +2582,7 @@ impl AuctionOrchestrator {
                     fatal_admission_error: None,
                     metadata: HashMap::new(),
                     elapsed_ms: auction_start.elapsed().as_millis() as u64,
+                    eligible_slots_by_provider,
                 }
             };
         }
@@ -2037,6 +2607,7 @@ impl AuctionOrchestrator {
             planned_unused_bidder_params: HashMap::new(),
             planned_unroutable_bidder_count: 0,
             planned_provider_order: HashMap::new(),
+            eligible_slots_by_provider,
         })
     }
 
@@ -2069,6 +2640,7 @@ impl AuctionOrchestrator {
             planned_unused_bidder_params,
             planned_unroutable_bidder_count,
             planned_provider_order,
+            eligible_slots_by_provider,
         } = dispatched;
 
         log::info!(
@@ -2160,7 +2732,10 @@ impl AuctionOrchestrator {
                             )
                             .await
                         {
-                            Ok(auction_response) => responses.push(auction_response),
+                            Ok(auction_response) => responses.push(canonical_provider_response(
+                                &state.provider_name,
+                                auction_response,
+                            )),
                             Err(error) => responses.push(provider_error_response(
                                 &state.provider_name,
                                 response_time_ms,
@@ -2186,7 +2761,10 @@ impl AuctionOrchestrator {
                             )
                             .await
                         {
-                            Ok(response) => responses.push(response),
+                            Ok(response) => responses.push(canonical_provider_response(
+                                state.provider.provider_name(),
+                                response,
+                            )),
                             Err(error) => responses.push(provider_error_response(
                                 state.provider.provider_name(),
                                 response_time_ms,
@@ -2286,6 +2864,12 @@ impl AuctionOrchestrator {
             });
         }
 
+        let normalized = self.normalize_provider_responses_with_eligibility(
+            &request,
+            &mut responses,
+            &eligible_slots_by_provider,
+        );
+
         #[cfg(not(test))]
         let mediator = self.mediator.as_ref();
         #[cfg(test)]
@@ -2295,171 +2879,152 @@ impl AuctionOrchestrator {
                 .as_ref()
                 .and_then(|name| self.providers.get(name))
         });
-        let (mediator_response, winning_bids) = if let Some(mediator) = mediator {
-            {
-                // Cap the mediator at whichever is tighter: its own configured
-                // timeout or the remaining auction budget (A_deadline). Backend
-                // first-byte and between-bytes timeouts bound normal collection, but
-                // they are transport timers rather than absolute wall-clock limits:
-                // connection setup and byte-trickling can still consume more of the
-                // auction budget. Recomputing the remaining budget here prevents the
-                // mediator from extending that bounded response hold.
-                let remaining = remaining_budget_ms(auction_start, timeout_ms);
-                let logical_budget_ms = remaining.min(mediator.timeout_ms());
-                if logical_budget_ms == 0 {
-                    log::warn!(
-                        "A_deadline exhausted before mediator '{}' — returning {} SSP bids without mediation",
-                        mediator.provider_name(),
-                        responses.len(),
-                    );
-                    let winning = self.select_winning_bids(&responses, &floor_prices);
-                    return OrchestrationResult {
-                        provider_responses: responses,
-                        mediator_response: None,
-                        winning_bids: winning,
-                        total_time_ms: auction_start.elapsed().as_millis() as u64,
-                        metadata: routing_metadata(planned_unroutable_bidder_count),
-                    };
-                }
+        let mut mediation_failed = false;
+        let mut mediator_response = None;
+        let mut mediated_winners = None;
+
+        if let Some(mediator) = mediator {
+            let remaining = remaining_budget_ms(auction_start, timeout_ms);
+            let logical_budget_ms = remaining.min(mediator.timeout_ms());
+            if logical_budget_ms == 0 {
+                log::warn!(
+                    "A_deadline exhausted before mediator '{}' — using direct fallback",
+                    mediator.provider_name(),
+                );
+                mediation_failed = true;
+            } else {
                 let transport_timeout_ms = services
                     .backend()
                     .canonicalize_transport_timeout_ms(logical_budget_ms, mediator.timeout_ms());
                 if transport_timeout_ms == 0 {
                     log::warn!(
-                        "Mediator '{}' transport budget canonicalized to zero — returning {} SSP bids without mediation",
+                        "Mediator '{}' transport budget canonicalized to zero — using direct fallback",
                         mediator.provider_name(),
-                        responses.len(),
                     );
-                    let winning = self.select_winning_bids(&responses, &floor_prices);
-                    return OrchestrationResult {
-                        provider_responses: responses,
-                        mediator_response: None,
-                        winning_bids: winning,
-                        total_time_ms: auction_start.elapsed().as_millis() as u64,
-                        metadata: routing_metadata(planned_unroutable_bidder_count),
+                    mediation_failed = true;
+                } else {
+                    let mediator_start = Instant::now();
+                    let placeholder = http::Request::builder()
+                        .uri(crate::auction::types::MEDIATOR_PLACEHOLDER_URL)
+                        .body(edgezero_core::body::Body::empty())
+                        .unwrap_or_else(|_| http::Request::new(edgezero_core::body::Body::empty()));
+                    let mediator_context = AuctionContext {
+                        settings: context.settings,
+                        request: &placeholder,
+                        timeout_ms: logical_budget_ms,
+                        transport_timeout_ms,
+                        provider_responses: Some(&responses),
+                        services: context.services,
                     };
-                }
-                let mediator_start = Instant::now();
-                log::info!(
-                    "Running mediator '{}' with {}ms logical budget and {}ms transport timeout (A_deadline remaining: {}ms, configured: {}ms)",
-                    mediator.provider_name(),
-                    logical_budget_ms,
-                    transport_timeout_ms,
-                    remaining,
-                    mediator.timeout_ms(),
-                );
-                // The mediator runs on the collect path. See the doc-comment on
-                // `AuctionContext::request`: the real client request was already
-                // consumed by `send_async` during dispatch, so we substitute a
-                // canonical placeholder URL. Any future mediator that needs real
-                // client headers must snapshot them at dispatch time onto
-                // `DispatchedAuction` rather than reading `context.request` here.
-                let placeholder = http::Request::builder()
-                    .uri(crate::auction::types::MEDIATOR_PLACEHOLDER_URL)
-                    .body(edgezero_core::body::Body::empty())
-                    .unwrap_or_else(|_| http::Request::new(edgezero_core::body::Body::empty()));
-                let mediator_context = AuctionContext {
-                    settings: context.settings,
-                    request: &placeholder,
-                    timeout_ms: logical_budget_ms,
-                    transport_timeout_ms,
-                    provider_responses: Some(&responses),
-                    services: context.services,
-                };
-                let mediator_response = match mediator
-                    .request_bids(&request, &mediator_context)
-                    .await
-                {
-                    Ok(ProviderRequestOutcome::Immediate(response)) => Some(response),
-                    Ok(ProviderRequestOutcome::Pending {
-                        request: pending,
-                        parse_state,
-                    }) => match services.http_client().wait(pending).await.change_context(
-                        TrustedServerError::Auction {
-                            message: format!(
-                                "Mediator {} request failed",
-                                mediator.provider_name()
-                            ),
-                        },
-                    ) {
-                        Ok(platform_resp) => {
-                            let response_time_ms = mediator_start.elapsed().as_millis() as u64;
-                            if deadline_policy.rejects_late_completion(auction_start, timeout_ms) {
+                    let raw_response = match mediator
+                        .request_bids(&request, &mediator_context)
+                        .await
+                    {
+                        Ok(ProviderRequestOutcome::Immediate(response)) => Some(
+                            canonical_provider_response(mediator.provider_name(), response),
+                        ),
+                        Ok(ProviderRequestOutcome::Pending {
+                            request: pending,
+                            parse_state,
+                        }) => match services.http_client().wait(pending).await {
+                            Ok(platform_response) => {
+                                let response_time_ms = mediator_start.elapsed().as_millis() as u64;
+                                if deadline_policy
+                                    .rejects_late_completion(auction_start, timeout_ms)
+                                {
+                                    log::warn!(
+                                        "Mediator '{}' completed after the hard auction deadline; using direct fallback ({}ms)",
+                                        mediator.provider_name(),
+                                        response_time_ms,
+                                    );
+                                    None
+                                } else {
+                                    mediator
+                                        .parse_response_with_context_and_state(
+                                            platform_response,
+                                            response_time_ms,
+                                            &request,
+                                            &mediator_context,
+                                            parse_state.as_deref(),
+                                        )
+                                        .await
+                                        .inspect_err(|error| {
+                                            log::warn!(
+                                                "Mediator '{}' parse failed: {error:?}",
+                                                mediator.provider_name(),
+                                            );
+                                        })
+                                        .ok()
+                                        .map(|response| {
+                                            canonical_provider_response(
+                                                mediator.provider_name(),
+                                                response,
+                                            )
+                                        })
+                                }
+                            }
+                            Err(error) => {
                                 log::warn!(
-                                    "Mediator '{}' completed after the hard auction deadline; using local ranking ({}ms)",
+                                    "Mediator '{}' request failed: {error:?}",
                                     mediator.provider_name(),
-                                    response_time_ms
                                 );
                                 None
-                            } else {
-                                match mediator
-                                    .parse_response_with_context_and_state(
-                                        platform_resp,
-                                        response_time_ms,
-                                        &request,
-                                        &mediator_context,
-                                        parse_state.as_deref(),
-                                    )
-                                    .await
-                                {
-                                    Ok(response) => Some(response),
-                                    Err(error) => {
-                                        log::warn!(
-                                            "Mediator '{}' parse failed: {:?}",
-                                            mediator.provider_name(),
-                                            error
-                                        );
-                                        None
-                                    }
-                                }
                             }
-                        }
+                        },
                         Err(error) => {
-                            log::warn!("Mediator request failed: {:?}", error);
+                            log::warn!(
+                                "Mediator '{}' failed to dispatch: {error:?}",
+                                mediator.provider_name(),
+                            );
                             None
                         }
-                    },
-                    Err(error) => {
-                        log::warn!(
-                            "Mediator '{}' failed to dispatch: {:?}",
-                            mediator.provider_name(),
-                            error
-                        );
-                        None
-                    }
-                };
+                    };
 
-                if let Some(mediator_response) = mediator_response {
-                    let winning = mediator_response
-                            .bids
-                            .iter()
-                            .filter_map(|bid| {
-                                if bid.price.is_none() {
-                                    log::warn!(
-                                        "Mediator '{}' returned bid for slot '{}' without decoded price - skipping",
-                                        mediator.provider_name(),
-                                        bid.slot_id
-                                    );
-                                    None
-                                } else {
-                                    Some((bid.slot_id.clone(), bid.clone()))
-                                }
-                            })
-                            .collect();
-                    let winning = self.apply_floor_prices(winning, &floor_prices);
-                    (Some(mediator_response), winning)
-                } else {
-                    (None, self.select_winning_bids(&responses, &floor_prices))
+                    if let Some(raw_response) = raw_response {
+                        mediator_response = Some(raw_response.clone());
+                        match Self::resolve_mediator_candidates(
+                            raw_response,
+                            &normalized.candidates,
+                        ) {
+                            Ok(resolved) => {
+                                let selected = resolved
+                                    .bids
+                                    .iter()
+                                    .map(|bid| (bid.slot_id.clone(), bid.clone()))
+                                    .collect();
+                                mediated_winners =
+                                    Some(self.apply_floor_prices(selected, &floor_prices));
+                                mediator_response = Some(resolved);
+                            }
+                            Err(()) => {
+                                log::warn!(
+                                    "Mediator '{}' returned invalid candidate provenance",
+                                    mediator.provider_name(),
+                                );
+                                mediation_failed = true;
+                            }
+                        }
+                    } else {
+                        mediation_failed = true;
+                    }
                 }
             }
-        } else {
-            (None, self.select_winning_bids(&responses, &floor_prices))
-        };
+        }
+
+        let winning_bids =
+            mediated_winners.unwrap_or_else(|| self.select_winning_bids(&responses, &floor_prices));
+        let decision_set = self.build_decision_set(
+            &request,
+            &normalized.outcomes,
+            &winning_bids,
+            mediation_failed,
+        );
 
         OrchestrationResult {
             provider_responses: responses,
             mediator_response,
             winning_bids,
+            decision_set,
             total_time_ms: auction_start.elapsed().as_millis() as u64,
             metadata: routing_metadata(planned_unroutable_bidder_count),
         }
@@ -2481,6 +3046,8 @@ pub struct OrchestrationResult {
     pub mediator_response: Option<AuctionResponse>,
     /// Winning bids per slot
     pub winning_bids: HashMap<String, Bid>,
+    /// Exact ordered decision for every requested slot.
+    pub decision_set: AuctionDecisionSetV1,
     /// Total orchestration time in milliseconds
     pub total_time_ms: u64,
     /// Metadata about the auction
@@ -2488,11 +3055,12 @@ pub struct OrchestrationResult {
 }
 
 impl OrchestrationResult {
-    fn no_bid() -> Self {
+    pub(crate) fn no_bid(request: &AuctionRequest, reason: AuctionSlotFailureReason) -> Self {
         Self {
             provider_responses: Vec::new(),
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1::failed(request, reason),
             total_time_ms: 0,
             metadata: HashMap::new(),
         }
@@ -2535,13 +3103,14 @@ mod tests {
         AuctionPlan, AuctionPlanConfig, NotificationConfig, ProviderConfig, ProviderId, RoutingMode,
     };
     use crate::auction::provider::{
-        AuctionProvider, GenericOpenRtbProvider, ProviderRequestOutcome,
+        AuctionProvider, GenericOpenRtbProvider, ProviderRequestOutcome, ProviderSlotDisposition,
     };
     use crate::auction::routing::{RoutingDiagnostics, route_auction};
     use crate::auction::test_support::create_test_auction_context;
     use crate::auction::types::{
-        AdFormat, AdSlot, ApsRendererV1, ApsTagType, AuctionContext, AuctionRequest,
-        AuctionResponse, Bid, BidRenderer, BidStatus, MediaType, PublisherInfo, UserInfo,
+        AdFormat, AdSlot, ApsRendererV1, ApsTagType, AuctionContext, AuctionDropReason,
+        AuctionRequest, AuctionResponse, AuctionSlotFailureReason, Bid, BidRenderSourceV1,
+        BidStatus, MediaType, PublisherInfo, SlotAuctionDecisionV1, UserInfo,
     };
     use crate::error::TrustedServerError;
     use crate::integrations::adserver_mock::{AdServerMockConfig, AdServerMockProvider};
@@ -2562,10 +3131,20 @@ mod tests {
     use std::sync::{Arc, Mutex};
 
     use super::{
-        AuctionOrchestrator, AuctionOrchestratorHarness, DispatchedAuction, ERROR_TYPE_TIMEOUT,
-        OrchestrationResult,
+        AuctionIdentityGenerator, AuctionOrchestrator, AuctionOrchestratorHarness,
+        DispatchedAuction, ERROR_TYPE_TIMEOUT, OrchestrationResult,
     };
 
+    fn expect_dispatched(outcome: DispatchAuctionOutcome) -> DispatchedAuction {
+        match outcome {
+            DispatchAuctionOutcome::Dispatched(dispatched) => dispatched,
+            DispatchAuctionOutcome::NotStarted => panic!("auction should dispatch"),
+            DispatchAuctionOutcome::DispatchFailed { .. } => {
+                panic!("auction dispatch should not fail")
+            }
+        }
+    }
+
     fn planned_config(providers: &[(&str, RoutingMode)], signing: bool) -> AuctionPlanConfig {
         AuctionPlanConfig {
             timeout_ms: 777,
@@ -3097,6 +3676,46 @@ mod tests {
     struct StubAuctionProvider {
         name: &'static str,
         backend: &'static str,
+        configured_timeout_ms: u32,
+        predicted_timeouts: Option<Arc<Mutex<Vec<u32>>>>,
+        request_timeouts: Option<Arc<Mutex<Vec<u32>>>>,
+    }
+
+    impl StubAuctionProvider {
+        fn new(name: &'static str, backend: &'static str) -> Self {
+            Self {
+                name,
+                backend,
+                configured_timeout_ms: 125,
+                predicted_timeouts: None,
+                request_timeouts: None,
+            }
+        }
+
+        fn recording(
+            name: &'static str,
+            backend: &'static str,
+            configured_timeout_ms: u32,
+            predicted_timeouts: Arc<Mutex<Vec<u32>>>,
+            request_timeouts: Arc<Mutex<Vec<u32>>>,
+        ) -> Self {
+            Self {
+                name,
+                backend,
+                configured_timeout_ms,
+                predicted_timeouts: Some(predicted_timeouts),
+                request_timeouts: Some(request_timeouts),
+            }
+        }
+
+        fn record(slot: &Option<Arc<Mutex<Vec<u32>>>>, timeout_ms: u32) {
+            if let Some(observed) = slot {
+                observed
+                    .lock()
+                    .expect("should lock observed timeouts")
+                    .push(timeout_ms);
+            }
+        }
     }
 
     #[async_trait::async_trait(?Send)]
@@ -3110,6 +3729,7 @@ mod tests {
             _request: &AuctionRequest,
             context: &AuctionContext<'_>,
         ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
+            Self::record(&self.request_timeouts, context.transport_timeout_ms);
             let req = PlatformHttpRequest::new(
                 http::Request::builder()
                     .method("POST")
@@ -3161,10 +3781,11 @@ mod tests {
         }
 
         fn timeout_ms(&self) -> u32 {
-            125
+            self.configured_timeout_ms
         }
 
-        fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option<String> {
+        fn backend_name(&self, _services: &RuntimeServices, timeout_ms: u32) -> Option<String> {
+            Self::record(&self.predicted_timeouts, timeout_ms);
             Some(self.backend.to_string())
         }
     }
@@ -3209,9 +3830,11 @@ mod tests {
             _response: PlatformResponse,
             response_time_ms: u64,
         ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+            let mut bid = auction_bid(self.name, 3.0);
+            bid.bid_id = Some(format!("{}-bid", self.name));
             Ok(AuctionResponse::success(
                 self.name,
-                vec![auction_bid(self.name, 3.0)],
+                vec![bid],
                 response_time_ms,
             ))
         }
@@ -3245,7 +3868,7 @@ mod tests {
             _request: &AuctionRequest,
             context: &AuctionContext<'_>,
         ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
-            let request = PlatformHttpRequest::new(
+            let req = PlatformHttpRequest::new(
                 http::Request::builder()
                     .method("POST")
                     .uri("https://example.com/mediate")
@@ -3256,7 +3879,7 @@ mod tests {
             context
                 .services
                 .http_client()
-                .send_async(request)
+                .send_async(req)
                 .await
                 .change_context(TrustedServerError::Auction {
                     message: "pending mediator launch failed".to_string(),
@@ -3265,13 +3888,30 @@ mod tests {
         }
 
         async fn parse_response(
+            &self,
+            _response: PlatformResponse,
+            _response_time_ms: u64,
+        ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+            panic!("pending deadline mediator should parse with provider context")
+        }
+
+        async fn parse_response_with_context(
             &self,
             _response: PlatformResponse,
             response_time_ms: u64,
+            _request: &AuctionRequest,
+            context: &AuctionContext<'_>,
         ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+            let mut selection = context
+                .provider_responses
+                .and_then(|responses| responses.first())
+                .and_then(|response| response.bids.first())
+                .cloned()
+                .expect("pending deadline mediator should receive one candidate");
+            selection.price = Some(9.0);
             Ok(AuctionResponse::success(
                 self.provider_name(),
-                vec![auction_bid("mediated", 9.0)],
+                vec![selection],
                 response_time_ms,
             ))
         }
@@ -3322,73 +3962,6 @@ mod tests {
         }
     }
 
-    struct RecordingTimeoutProvider {
-        name: &'static str,
-        backend: &'static str,
-        configured_timeout_ms: u32,
-        predicted: Arc<Mutex<Vec<u32>>>,
-        requested: Arc<Mutex<Vec<u32>>>,
-    }
-
-    #[async_trait::async_trait(?Send)]
-    impl AuctionProvider for RecordingTimeoutProvider {
-        fn provider_name(&self) -> &str {
-            self.name
-        }
-
-        async fn request_bids(
-            &self,
-            _request: &AuctionRequest,
-            context: &AuctionContext<'_>,
-        ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
-            self.requested
-                .lock()
-                .expect("should lock requested timeouts")
-                .push(context.transport_timeout_ms);
-            let request = PlatformHttpRequest::new(
-                http::Request::builder()
-                    .method("POST")
-                    .uri("https://example.com/bid")
-                    .body(edgezero_core::body::Body::empty())
-                    .expect("should build recording request"),
-                self.backend,
-            );
-            context
-                .services
-                .http_client()
-                .send_async(request)
-                .await
-                .change_context(TrustedServerError::Auction {
-                    message: "recording launch failed".to_string(),
-                })
-                .map(ProviderRequestOutcome::pending)
-        }
-
-        async fn parse_response(
-            &self,
-            _response: PlatformResponse,
-            response_time_ms: u64,
-        ) -> Result<AuctionResponse, Report<TrustedServerError>> {
-            Ok(AuctionResponse::success(
-                self.name,
-                vec![],
-                response_time_ms,
-            ))
-        }
-
-        fn timeout_ms(&self) -> u32 {
-            self.configured_timeout_ms
-        }
-
-        fn backend_name(&self, _services: &RuntimeServices, timeout_ms: u32) -> Option<String> {
-            self.predicted
-                .lock()
-                .expect("should lock predicted timeouts")
-                .push(timeout_ms);
-            Some(self.backend.to_string())
-        }
-    }
-
     struct DivergentBackendProvider {
         name: &'static str,
         predicted: &'static str,
@@ -3482,14 +4055,14 @@ mod tests {
         configured_timeout_ms: u32,
         predicted: &Arc<Mutex<Vec<u32>>>,
         requested: &Arc<Mutex<Vec<u32>>>,
-    ) -> RecordingTimeoutProvider {
-        RecordingTimeoutProvider {
+    ) -> StubAuctionProvider {
+        StubAuctionProvider::recording(
             name,
             backend,
             configured_timeout_ms,
-            predicted: Arc::clone(predicted),
-            requested: Arc::clone(requested),
-        }
+            Arc::clone(predicted),
+            Arc::clone(requested),
+        )
     }
 
     /// Mediator whose context-aware parse restores `nurl`/`ad_id` (mirroring
@@ -3499,7 +4072,7 @@ mod tests {
 
     fn auction_bid(bidder: &str, price: f64) -> Bid {
         let renderer = (bidder == "aps").then(|| {
-            BidRenderer::Aps(ApsRendererV1 {
+            BidRenderSourceV1::Aps(ApsRendererV1 {
                 version: 1,
                 account_id: "example-account".to_string(),
                 bid_id: "aps-selected-bid".to_string(),
@@ -3513,6 +4086,9 @@ mod tests {
         });
         Bid {
             slot_id: "slot-1".to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(price),
             currency: "USD".to_string(),
             creative: renderer
@@ -3536,9 +4112,112 @@ mod tests {
         }
     }
 
+    struct CounterIdentityGenerator {
+        draws: AtomicUsize,
+    }
+
+    impl CounterIdentityGenerator {
+        fn new() -> Self {
+            Self {
+                draws: AtomicUsize::new(0),
+            }
+        }
+    }
+
+    impl AuctionIdentityGenerator for CounterIdentityGenerator {
+        fn fill(&self, destination: &mut [u8]) -> Result<(), ()> {
+            destination.fill(0);
+            let draw = self.draws.fetch_add(1, Ordering::SeqCst) + 1;
+            let last = destination.last_mut().ok_or(())?;
+            *last = u8::try_from(draw).map_err(|_| ())?;
+            Ok(())
+        }
+    }
+
+    struct FixedIdentityGenerator {
+        draws: AtomicUsize,
+    }
+
+    impl FixedIdentityGenerator {
+        fn new() -> Self {
+            Self {
+                draws: AtomicUsize::new(0),
+            }
+        }
+    }
+
+    impl AuctionIdentityGenerator for FixedIdentityGenerator {
+        fn fill(&self, destination: &mut [u8]) -> Result<(), ()> {
+            self.draws.fetch_add(1, Ordering::SeqCst);
+            destination.fill(0);
+            Ok(())
+        }
+    }
+
+    struct SourceBidProvider {
+        nurl: &'static str,
+    }
+
+    #[async_trait::async_trait(?Send)]
+    impl AuctionProvider for SourceBidProvider {
+        fn provider_name(&self) -> &'static str {
+            "bidder"
+        }
+
+        async fn request_bids(
+            &self,
+            _request: &AuctionRequest,
+            context: &AuctionContext<'_>,
+        ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
+            let request = PlatformHttpRequest::new(
+                http::Request::builder()
+                    .method("POST")
+                    .uri("https://example.com/bid")
+                    .body(edgezero_core::body::Body::empty())
+                    .expect("should build source bid request"),
+                "bidder-backend",
+            );
+            context
+                .services
+                .http_client()
+                .send_async(request)
+                .await
+                .change_context(TrustedServerError::Auction {
+                    message: "source bidder launch failed".to_string(),
+                })
+                .map(ProviderRequestOutcome::pending)
+        }
+
+        async fn parse_response(
+            &self,
+            _response: PlatformResponse,
+            response_time_ms: u64,
+        ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+            let mut bid = mediated_bid(Some(self.nurl.to_string()));
+            bid.price = Some(1.0);
+            bid.bid_id = Some("source-bid-id".to_string());
+            Ok(AuctionResponse::success(
+                self.provider_name(),
+                vec![bid],
+                response_time_ms,
+            ))
+        }
+
+        fn timeout_ms(&self) -> u32 {
+            2000
+        }
+
+        fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option<String> {
+            Some("bidder-backend".to_string())
+        }
+    }
+
     fn mediated_bid(nurl: Option<String>) -> Bid {
         Bid {
             slot_id: "header-banner".to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(2.5),
             currency: "USD".to_string(),
             creative: Some("<div>ad</div>".to_string()),
@@ -3608,12 +4287,18 @@ mod tests {
             _response: PlatformResponse,
             response_time_ms: u64,
             _request: &AuctionRequest,
-            _context: &AuctionContext<'_>,
+            context: &AuctionContext<'_>,
         ) -> Result<AuctionResponse, Report<TrustedServerError>> {
-            // Context-aware path: restores nurl/ad_id from the collected SSP bids.
+            let mut selection = context
+                .provider_responses
+                .and_then(|responses| responses.first())
+                .and_then(|response| response.bids.first())
+                .cloned()
+                .expect("should provide one source candidate to mediator");
+            selection.price = Some(2.5);
             Ok(AuctionResponse::success(
                 "mediator",
-                vec![mediated_bid(Some("https://nurl.example/win".to_string()))],
+                vec![selection],
                 response_time_ms,
             ))
         }
@@ -3638,13 +4323,18 @@ mod tests {
         async fn request_bids(
             &self,
             _request: &AuctionRequest,
-            _context: &AuctionContext<'_>,
+            context: &AuctionContext<'_>,
         ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
+            let mut selection = context
+                .provider_responses
+                .and_then(|responses| responses.first())
+                .and_then(|response| response.bids.first())
+                .cloned()
+                .expect("should provide one source candidate to immediate mediator");
+            selection.price = Some(2.5);
             Ok(ProviderRequestOutcome::Immediate(AuctionResponse::success(
                 self.provider_name(),
-                vec![mediated_bid(Some(
-                    "https://nurl.example/immediate".to_string(),
-                ))],
+                vec![selection],
                 0,
             )))
         }
@@ -3683,9 +4373,8 @@ mod tests {
             ..Default::default()
         };
         let mut orchestrator = AuctionOrchestrator::new(config);
-        orchestrator.register_provider(Arc::new(StubAuctionProvider {
-            name: "bidder",
-            backend: "bidder-backend",
+        orchestrator.register_provider(Arc::new(SourceBidProvider {
+            nurl: "https://nurl.example/win",
         }));
         orchestrator.register_provider(Arc::new(CacheRestoringMediator));
 
@@ -3740,9 +4429,8 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "bidder",
-                backend: "bidder-backend",
+            orchestrator.register_provider(Arc::new(SourceBidProvider {
+                nurl: "https://nurl.example/immediate",
             }));
             orchestrator.register_provider(Arc::new(ImmediateMediator));
             let request = create_test_auction_request();
@@ -3758,11 +4446,8 @@ mod tests {
             };
 
             let result = if split {
-                let DispatchAuctionOutcome::Dispatched(dispatched) =
-                    orchestrator.dispatch_auction(&request, &context).await
-                else {
-                    panic!("bidder request should dispatch");
-                };
+                let dispatched =
+                    expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
                 orchestrator
                     .collect_dispatched_auction(dispatched, &services, &context)
                     .await
@@ -3815,7 +4500,7 @@ mod tests {
             name: "late-two",
             backend: "late-two-backend",
         }));
-        let request = create_test_auction_request();
+        let request = one_slot_request();
         let settings = create_test_settings();
         let downstream = http::Request::new(edgezero_core::body::Body::empty());
         let context = AuctionContext {
@@ -3827,23 +4512,393 @@ mod tests {
             services: &services,
         };
 
-        if split {
-            let DispatchAuctionOutcome::Dispatched(dispatched) =
-                orchestrator.dispatch_auction(&request, &context).await
-            else {
-                panic!("deadline test providers should dispatch");
-            };
-            orchestrator
-                .collect_dispatched_auction(dispatched, &services, &context)
-                .await
-        } else {
-            orchestrator
-                .run_auction(&request, &context)
-                .await
-                .expect("deadline test auction should complete")
+        if split {
+            let DispatchAuctionOutcome::Dispatched(dispatched) =
+                orchestrator.dispatch_auction(&request, &context).await
+            else {
+                panic!("deadline test providers should dispatch");
+            };
+            orchestrator
+                .collect_dispatched_auction(dispatched, &services, &context)
+                .await
+        } else {
+            orchestrator
+                .run_auction(&request, &context)
+                .await
+                .expect("deadline test auction should complete")
+        }
+    }
+
+    fn one_slot_request() -> AuctionRequest {
+        let mut request = create_test_auction_request();
+        request.slots = vec![AdSlot {
+            id: "slot-1".to_string(),
+            formats: vec![AdFormat {
+                media_type: MediaType::Banner,
+                width: 300,
+                height: 250,
+            }],
+            floor_price: None,
+            targeting: HashMap::new(),
+            bidders: HashMap::new(),
+        }];
+        request
+    }
+
+    fn enabled_config(providers: &[&str]) -> AuctionConfig {
+        AuctionConfig {
+            enabled: true,
+            providers: AuctionConfig::legacy_provider_map(providers),
+            ..AuctionConfig::default()
+        }
+    }
+
+    #[test]
+    fn normalized_provider_outcomes_cover_every_dispatched_slot() {
+        let generator = Arc::new(CounterIdentityGenerator::new());
+        let mut orchestrator =
+            AuctionOrchestrator::with_identity_generator(enabled_config(&["alpha"]), generator);
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        let request = one_slot_request();
+        let mut candidate = auction_bid("aps", 2.0);
+        candidate.slot_id = "slot-1".to_string();
+        let mut responses = vec![AuctionResponse::success("alpha", vec![candidate], 10)];
+
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut responses);
+
+        assert_eq!(normalized.outcomes.len(), 1);
+        assert_eq!(normalized.outcomes[0].provider, "alpha");
+        assert_eq!(normalized.outcomes[0].slot, "slot-1");
+        assert!(matches!(
+            &normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Candidates(candidates)
+                if candidates.len() == 1
+                    && candidates[0].candidate_id.as_deref().is_some_and(|id| id.len() == 12)
+        ));
+
+        let mut no_bid = vec![AuctionResponse::no_bid("alpha", 10)];
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut no_bid);
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::NoBid
+        ));
+
+        let mut timeout = vec![super::provider_timeout_response("alpha", 10)];
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut timeout);
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Failed(AuctionSlotFailureReason::ProviderTimeout)
+        ));
+
+        let mut attributable_invalid = vec![AuctionResponse::no_bid("alpha", 10)];
+        attributable_invalid[0].metadata.insert(
+            "invalid_slots".to_string(),
+            serde_json::json!({"slot-1": "invalid_provider_response"}),
+        );
+        let normalized =
+            orchestrator.normalize_provider_responses(&request, &mut attributable_invalid);
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Failed(AuctionSlotFailureReason::InvalidProviderResponse)
+        ));
+    }
+
+    #[test]
+    fn provider_failure_classes_map_to_closed_slot_reasons() {
+        let mut orchestrator = AuctionOrchestrator::new(enabled_config(&["alpha"]));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        let request = one_slot_request();
+
+        for (error_type, expected) in [
+            (
+                super::ERROR_TYPE_LAUNCH_FAILED,
+                AuctionSlotFailureReason::ProviderError,
+            ),
+            (
+                super::ERROR_TYPE_TRANSPORT,
+                AuctionSlotFailureReason::ProviderError,
+            ),
+            (
+                super::ERROR_TYPE_HTTP_STATUS,
+                AuctionSlotFailureReason::ProviderError,
+            ),
+            (
+                super::ERROR_TYPE_PARSE_RESPONSE,
+                AuctionSlotFailureReason::InvalidProviderResponse,
+            ),
+        ] {
+            let error = Report::new(TrustedServerError::Auction {
+                message: "provider failed".to_string(),
+            });
+            let mut responses = vec![super::provider_error_response(
+                "alpha", 1, error_type, &error,
+            )];
+            let normalized = orchestrator.normalize_provider_responses(&request, &mut responses);
+            assert!(matches!(
+                normalized.outcomes[0].disposition,
+                ProviderSlotDisposition::Failed(reason) if reason == expected
+            ));
+        }
+    }
+
+    #[test]
+    fn candidate_collision_exhaustion_fails_only_the_affected_slot() {
+        let generator = Arc::new(FixedIdentityGenerator::new());
+        let mut orchestrator = AuctionOrchestrator::with_identity_generator(
+            enabled_config(&["alpha"]),
+            generator.clone(),
+        );
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        let mut request = one_slot_request();
+        request.slots.push(AdSlot {
+            id: "slot-2".to_string(),
+            formats: request.slots[0].formats.clone(),
+            floor_price: None,
+            targeting: HashMap::new(),
+            bidders: HashMap::new(),
+        });
+        let mut first = auction_bid("aps", 2.0);
+        first.slot_id = "slot-1".to_string();
+        first.bid_id = Some("upstream-1".to_string());
+        let mut second = auction_bid("aps", 1.0);
+        second.slot_id = "slot-2".to_string();
+        second.bid_id = Some("upstream-2".to_string());
+        let mut responses = vec![AuctionResponse::success("alpha", vec![first, second], 10)];
+
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut responses);
+
+        assert_eq!(generator.draws.load(Ordering::SeqCst), 10);
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Candidates(_)
+        ));
+        assert!(matches!(
+            normalized.outcomes[1].disposition,
+            ProviderSlotDisposition::Failed(AuctionSlotFailureReason::InternalError)
+        ));
+    }
+
+    #[test]
+    fn candidate_collision_exhaustion_discards_earlier_sibling_for_same_slot() {
+        let generator = Arc::new(FixedIdentityGenerator::new());
+        let mut orchestrator = AuctionOrchestrator::with_identity_generator(
+            enabled_config(&["alpha"]),
+            generator.clone(),
+        );
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        let request = one_slot_request();
+        let mut first = auction_bid("aps", 2.0);
+        first.bid_id = Some("upstream-1".to_string());
+        let mut second = auction_bid("aps", 1.0);
+        second.bid_id = Some("upstream-2".to_string());
+        let mut responses = vec![AuctionResponse::success("alpha", vec![first, second], 10)];
+
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut responses);
+
+        assert_eq!(generator.draws.load(Ordering::SeqCst), 10);
+        assert!(responses[0].bids.is_empty());
+        assert!(normalized.candidates.is_empty());
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Failed(AuctionSlotFailureReason::InternalError)
+        ));
+    }
+
+    #[test]
+    fn per_bid_drop_does_not_poison_an_unrelated_missing_slot() {
+        let mut orchestrator = AuctionOrchestrator::new(enabled_config(&["alpha"]));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        let mut request = one_slot_request();
+        request.slots.push(AdSlot {
+            id: "slot-2".to_string(),
+            formats: request.slots[0].formats.clone(),
+            floor_price: None,
+            targeting: HashMap::new(),
+            bidders: HashMap::new(),
+        });
+        let mut valid = auction_bid("aps", 2.0);
+        valid.bid_id = Some("upstream-1".to_string());
+        let mut response = AuctionResponse::success("alpha", vec![valid], 10);
+        response = response.with_drop_reason(AuctionDropReason::InvalidDimensions);
+        let mut responses = vec![response];
+
+        let normalized = orchestrator.normalize_provider_responses(&request, &mut responses);
+
+        assert!(matches!(
+            normalized.outcomes[0].disposition,
+            ProviderSlotDisposition::Candidates(_)
+        ));
+        assert!(matches!(
+            normalized.outcomes[1].disposition,
+            ProviderSlotDisposition::NoBid
+        ));
+    }
+
+    #[test]
+    fn final_decisions_are_request_ordered_and_use_closed_failure_priority() {
+        let mut orchestrator = AuctionOrchestrator::new(enabled_config(&["alpha", "zeta"]));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("zeta", "zeta")));
+        let request = one_slot_request();
+        let outcomes = vec![
+            crate::auction::provider::ProviderSlotOutcome {
+                provider: "alpha".to_string(),
+                slot: "slot-1".to_string(),
+                disposition: ProviderSlotDisposition::Failed(
+                    AuctionSlotFailureReason::ProviderTimeout,
+                ),
+            },
+            crate::auction::provider::ProviderSlotOutcome {
+                provider: "zeta".to_string(),
+                slot: "slot-1".to_string(),
+                disposition: ProviderSlotDisposition::Failed(
+                    AuctionSlotFailureReason::InvalidProviderResponse,
+                ),
+            },
+        ];
+
+        let decisions = orchestrator.build_decision_set(&request, &outcomes, &HashMap::new(), true);
+
+        assert_eq!(decisions.results.len(), 1);
+        assert!(matches!(
+            &decisions.results[0],
+            SlotAuctionDecisionV1::Failed { slot, reason }
+                if slot == "slot-1" && *reason == AuctionSlotFailureReason::MediationFailed
+        ));
+        assert_eq!(
+            serde_json::to_string(&decisions).expect("decision set should serialize"),
+            r#"{"version":1,"auctionId":"test-auction-123","results":[{"slot":"slot-1","outcome":"failed","reason":"mediation_failed"}]}"#
+        );
+        assert_eq!(
+            serde_json::to_string(&SlotAuctionDecisionV1::Failed {
+                slot: "slot-1".to_string(),
+                reason: AuctionSlotFailureReason::IdentityGenerationFailed,
+            })
+            .expect("direct identity-generation failure should serialize"),
+            r#"{"slot":"slot-1","outcome":"failed","reason":"identity_generation_failed"}"#
+        );
+    }
+
+    #[test]
+    fn deliverable_winner_beats_a_sibling_provider_failure() {
+        let mut orchestrator = AuctionOrchestrator::new(enabled_config(&["alpha", "zeta"]));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("alpha", "alpha")));
+        orchestrator.register_provider(Arc::new(StubAuctionProvider::new("zeta", "zeta")));
+        let request = one_slot_request();
+        let mut winner = auction_bid("alpha-seat", 2.0);
+        winner.candidate_id = Some("AAAAAAAAAAAA".to_string());
+        winner.candidate_provider = Some("alpha".to_string());
+        winner.bid_id = Some("upstream-alpha".to_string());
+        let outcomes = vec![crate::auction::provider::ProviderSlotOutcome {
+            provider: "zeta".to_string(),
+            slot: "slot-1".to_string(),
+            disposition: ProviderSlotDisposition::Failed(AuctionSlotFailureReason::ProviderTimeout),
+        }];
+
+        let decisions = orchestrator.build_decision_set(
+            &request,
+            &outcomes,
+            &HashMap::from([("slot-1".to_string(), winner)]),
+            true,
+        );
+
+        assert_eq!(
+            decisions.results,
+            vec![SlotAuctionDecisionV1::Winner {
+                slot: "slot-1".to_string(),
+                candidate_id: "AAAAAAAAAAAA".to_string(),
+            }]
+        );
+    }
+
+    #[test]
+    fn direct_ties_ignore_arrival_and_candidate_ids() {
+        let orchestrator = AuctionOrchestrator::new(enabled_config(&["alpha", "zeta"]));
+        let mut alpha = auction_bid("seat-a", 2.0);
+        alpha.candidate_provider = Some("alpha".to_string());
+        alpha.candidate_id = Some("zzzzzzzzzzzz".to_string());
+        alpha.bid_id = Some("upstream-z".to_string());
+        let mut zeta = auction_bid("seat-z", 2.0);
+        zeta.candidate_provider = Some("zeta".to_string());
+        zeta.candidate_id = Some("AAAAAAAAAAAA".to_string());
+        zeta.bid_id = Some("upstream-a".to_string());
+        let left = AuctionResponse::success("alpha", vec![alpha], 1);
+        let right = AuctionResponse::success("zeta", vec![zeta], 1);
+
+        for responses in [vec![left.clone(), right.clone()], vec![right, left]] {
+            let winners = orchestrator.select_winning_bids(&responses, &HashMap::new());
+            assert_eq!(
+                winners["slot-1"].candidate_provider.as_deref(),
+                Some("alpha")
+            );
         }
     }
 
+    #[test]
+    fn mediator_can_select_only_known_candidate_provenance() {
+        let mut source = auction_bid("aps", 1.0);
+        source.candidate_id = Some("AAAAAAAAAAAA".to_string());
+        source.candidate_provider = Some("aps".to_string());
+        source.nurl = Some("https://source.example/win".to_string());
+        let candidates = HashMap::from([("AAAAAAAAAAAA".to_string(), source.clone())]);
+        let mut selection = source.clone();
+        selection.price = Some(9.0);
+
+        let resolved = AuctionOrchestrator::resolve_mediator_candidates(
+            AuctionResponse::success("mediator", vec![selection], 2),
+            &candidates,
+        )
+        .expect("known candidate should resolve");
+        assert_eq!(resolved.bids[0].price, Some(9.0));
+        assert_eq!(resolved.bids[0].width, source.width);
+        assert_eq!(resolved.bids[0].height, source.height);
+        assert_eq!(resolved.bids[0].renderer, source.renderer);
+        assert_eq!(resolved.bids[0].nurl, source.nurl);
+
+        let mut substituted = source.clone();
+        substituted.price = Some(9.0);
+        substituted.width = 1;
+        assert!(
+            AuctionOrchestrator::resolve_mediator_candidates(
+                AuctionResponse::success("mediator", vec![substituted], 2),
+                &candidates,
+            )
+            .is_err(),
+            "mediator source-field substitutions should fail provenance validation"
+        );
+
+        let mut second_source = source.clone();
+        second_source.candidate_id = Some("BBBBBBBBBBBB".to_string());
+        second_source.bid_id = Some("upstream-2".to_string());
+        let same_slot_candidates = HashMap::from([
+            ("AAAAAAAAAAAA".to_string(), source.clone()),
+            ("BBBBBBBBBBBB".to_string(), second_source.clone()),
+        ]);
+        assert!(
+            AuctionOrchestrator::resolve_mediator_candidates(
+                AuctionResponse::success("mediator", vec![source.clone(), second_source], 2),
+                &same_slot_candidates,
+            )
+            .is_err(),
+            "a mediator may select at most one candidate for a slot"
+        );
+
+        let mut unknown = source;
+        unknown.candidate_id = Some("BBBBBBBBBBBB".to_string());
+        assert!(
+            AuctionOrchestrator::resolve_mediator_candidates(
+                AuctionResponse::success("mediator", vec![unknown], 2),
+                &candidates,
+            )
+            .is_err()
+        );
+    }
+
+    fn create_test_settings() -> crate::settings::Settings {
+        let settings_str = crate_test_settings_str();
+        crate::settings::Settings::from_toml(&settings_str).expect("should parse test settings")
+    }
+
     #[tokio::test]
     async fn current_adapter_deadline_drains_late_responses_in_both_paths() {
         for split in [false, true] {
@@ -3905,7 +4960,7 @@ mod tests {
             backend: "local-backend",
         }));
         orchestrator.register_provider(Arc::new(PendingDeadlineMediator));
-        let request = create_test_auction_request();
+        let request = one_slot_request();
         let settings = create_test_settings();
         let downstream = http::Request::new(edgezero_core::body::Body::empty());
         let context = AuctionContext {
@@ -3946,11 +5001,13 @@ mod tests {
                 current_mediator.response_time_ms >= 50,
                 "mediator timing should preserve actual elapsed duration"
             );
-            assert_eq!(current.winning_bids["slot-1"].bidder, "mediated");
+            assert_eq!(current.winning_bids["slot-1"].bidder, "local");
+            assert_eq!(current.winning_bids["slot-1"].price, Some(9.0));
 
             let hard = pending_mediator_deadline_test_result(split, true).await;
             assert!(hard.mediator_response.is_none());
             assert_eq!(hard.winning_bids["slot-1"].bidder, "local");
+            assert_eq!(hard.winning_bids["slot-1"].price, Some(3.0));
             assert!(
                 hard.total_time_ms >= 50,
                 "discarding a late mediator must retain actual total elapsed time"
@@ -3981,7 +5038,7 @@ mod tests {
             launches: Arc::clone(&launches),
             budgets: None,
         }));
-        let request = create_test_auction_request();
+        let request = one_slot_request();
         let settings = create_test_settings();
         let downstream = http::Request::new(edgezero_core::body::Body::empty());
         let context = AuctionContext {
@@ -4029,7 +5086,7 @@ mod tests {
             launches: Arc::clone(&launches),
             budgets: None,
         }));
-        let request = create_test_auction_request();
+        let request = one_slot_request();
         let settings = create_test_settings();
         let downstream = http::Request::new(edgezero_core::body::Body::empty());
         let context = AuctionContext {
@@ -4092,11 +5149,6 @@ mod tests {
         }
     }
 
-    fn create_test_settings() -> crate::settings::Settings {
-        let settings_str = crate_test_settings_str();
-        crate::settings::Settings::from_toml(&settings_str).expect("should parse test settings")
-    }
-
     struct ImmediateNoBidProvider;
 
     #[async_trait::async_trait(?Send)]
@@ -4204,6 +5256,17 @@ mod tests {
         assert_eq!(result.provider_responses.len(), 1);
         assert_eq!(result.provider_responses[0].status, BidStatus::NoBid);
         assert!(result.winning_bids.is_empty());
+        assert_eq!(
+            result.decision_set.results,
+            vec![
+                SlotAuctionDecisionV1::NoBid {
+                    slot: "header-banner".to_string(),
+                },
+                SlotAuctionDecisionV1::NoBid {
+                    slot: "sidebar".to_string(),
+                },
+            ]
+        );
     }
 
     #[tokio::test]
@@ -4221,12 +5284,11 @@ mod tests {
         let downstream = http::Request::new(edgezero_core::body::Body::empty());
         let context = immediate_test_context(&settings, &downstream, &services);
 
-        let DispatchAuctionOutcome::Dispatched(dispatched) = orchestrator
-            .dispatch_auction(&create_test_auction_request(), &context)
-            .await
-        else {
-            panic!("enabled immediate provider should dispatch");
-        };
+        let dispatched = expect_dispatched(
+            orchestrator
+                .dispatch_auction(&create_test_auction_request(), &context)
+                .await,
+        );
         let result = orchestrator
             .collect_dispatched_auction(dispatched, &services, &context)
             .await;
@@ -4234,6 +5296,17 @@ mod tests {
         assert_eq!(result.provider_responses.len(), 1);
         assert_eq!(result.provider_responses[0].status, BidStatus::NoBid);
         assert!(result.winning_bids.is_empty());
+        assert_eq!(
+            result.decision_set.results,
+            vec![
+                SlotAuctionDecisionV1::NoBid {
+                    slot: "header-banner".to_string(),
+                },
+                SlotAuctionDecisionV1::NoBid {
+                    slot: "sidebar".to_string(),
+                },
+            ]
+        );
     }
 
     #[tokio::test]
@@ -4247,10 +5320,10 @@ mod tests {
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
             orchestrator.register_provider(Arc::new(ImmediateNoBidProvider));
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "pending",
-                backend: "pending-backend",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "pending",
+                "pending-backend",
+            )));
             let stub = Arc::new(StubHttpClient::new());
             stub.push_response(200, b"{}".to_vec());
             let services = build_services_with_http_client(stub);
@@ -4260,11 +5333,8 @@ mod tests {
             let request = create_test_auction_request();
 
             let result = if split {
-                let DispatchAuctionOutcome::Dispatched(dispatched) =
-                    orchestrator.dispatch_auction(&request, &context).await
-                else {
-                    panic!("mixed immediate/pending auction should dispatch");
-                };
+                let dispatched =
+                    expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
                 orchestrator
                     .collect_dispatched_auction(dispatched, &services, &context)
                     .await
@@ -4394,6 +5464,9 @@ mod tests {
             "slot-1".to_string(),
             Bid {
                 slot_id: "slot-1".to_string(),
+                candidate_id: None,
+                candidate_provider: None,
+                renderer_reservation_id: None,
                 price: Some(0.50),
                 currency: "USD".to_string(),
                 creative: Some("<div>Ad</div>".to_string()),
@@ -4418,6 +5491,9 @@ mod tests {
             "slot-2".to_string(),
             Bid {
                 slot_id: "slot-2".to_string(),
+                candidate_id: None,
+                candidate_provider: None,
+                renderer_reservation_id: None,
                 price: Some(2.00),
                 currency: "USD".to_string(),
                 creative: Some("<div>Ad</div>".to_string()),
@@ -4490,14 +5566,25 @@ mod tests {
 
             let result = orchestrator.run_auction(&request, &context).await;
 
-            assert!(result.is_err());
-            let err = result.unwrap_err();
-            assert!(format!("{}", err).contains("No providers configured"));
+            let result = result.expect("should return one decision per requested slot");
+            assert_eq!(
+                result.decision_set.results,
+                vec![
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "header-banner".to_string(),
+                        reason: AuctionSlotFailureReason::SlotNotEligible,
+                    },
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "sidebar".to_string(),
+                        reason: AuctionSlotFailureReason::SlotNotEligible,
+                    },
+                ]
+            );
         });
     }
 
     #[test]
-    fn provider_launch_failures_error_when_no_requests_launch() {
+    fn provider_launch_failures_are_explicit_when_no_requests_launch() {
         futures::executor::block_on(async {
             let config = AuctionConfig {
                 enabled: true,
@@ -4517,16 +5604,20 @@ mod tests {
                 .expect("should build request");
             let context = create_test_auction_context(&settings, &req, 2000);
 
-            let error = orchestrator
-                .run_auction(&request, &context)
-                .await
-                .expect_err("should fail when every provider launch fails");
-
-            assert!(
-                error
-                    .to_string()
-                    .contains("All 1 configured provider(s) skipped or failed to launch"),
-                "should explain that no configured provider request launched"
+            let result = orchestrator.run_auction(&request, &context).await;
+            let result = result.expect("should preserve launch failures as slot decisions");
+            assert_eq!(
+                result.decision_set.results,
+                vec![
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "header-banner".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderError,
+                    },
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "sidebar".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderError,
+                    },
+                ]
             );
         });
     }
@@ -4541,14 +5632,14 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-a",
-                backend: "shared-backend",
-            }));
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-b",
-                backend: "shared-backend",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-a",
+                "shared-backend",
+            )));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-b",
+                "shared-backend",
+            )));
             let stub = Arc::new(StubHttpClient::new());
             stub.push_response(200, b"{}".to_vec());
             let services = build_services_with_http_client(stub);
@@ -4558,11 +5649,8 @@ mod tests {
             let request = create_test_auction_request();
 
             let result = if split {
-                let DispatchAuctionOutcome::Dispatched(dispatched) =
-                    orchestrator.dispatch_auction(&request, &context).await
-                else {
-                    panic!("should dispatch the first provider");
-                };
+                let dispatched =
+                    expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
                 orchestrator
                     .collect_dispatched_auction(dispatched, &services, &context)
                     .await
@@ -4683,13 +5771,17 @@ mod tests {
     #[test]
     fn zero_canonical_timeout_skips_parallel_launch() {
         futures::executor::block_on(async {
+            // A platform that canonicalizes to zero signals "budget exhausted";
+            // the orchestrator must skip the launch and retain an attributable
+            // timeout decision for every eligible requested slot.
+            let stub = Arc::new(StubHttpClient::new());
             let calls = Arc::new(Mutex::new(Vec::new()));
             let services = build_services_with_backend_and_http_client(
                 Arc::new(CanonicalTimeoutBackend {
                     canonical_ms: 0,
                     calls,
                 }),
-                Arc::new(StubHttpClient::new()),
+                stub,
             );
             let predicted = Arc::new(Mutex::new(Vec::new()));
             let requested = Arc::new(Mutex::new(Vec::new()));
@@ -4709,14 +5801,88 @@ mod tests {
             let settings = create_test_settings();
             let downstream = http::Request::new(edgezero_core::body::Body::empty());
             let context = immediate_test_context(&settings, &downstream, &services);
+            let request = create_test_auction_request();
 
             let result = orchestrator
-                .run_auction(&create_test_auction_request(), &context)
-                .await;
+                .run_auction(&request, &context)
+                .await
+                .expect("should preserve an exhausted budget as slot decisions");
+            assert_eq!(
+                result.decision_set.results,
+                vec![
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "header-banner".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderTimeout,
+                    },
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "sidebar".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderTimeout,
+                    },
+                ]
+            );
+        });
+    }
+
+    #[test]
+    fn zero_canonical_timeout_is_attributable_in_split_dispatch() {
+        futures::executor::block_on(async {
+            let stub = Arc::new(StubHttpClient::new());
+            let calls = Arc::new(Mutex::new(Vec::new()));
+            let services = build_services_with_backend_and_http_client(
+                Arc::new(CanonicalTimeoutBackend {
+                    canonical_ms: 0,
+                    calls,
+                }),
+                stub,
+            );
+            let predicted = Arc::new(Mutex::new(Vec::new()));
+            let requested = Arc::new(Mutex::new(Vec::new()));
+            let mut orchestrator = AuctionOrchestrator::new(AuctionConfig {
+                enabled: true,
+                providers: AuctionConfig::legacy_provider_map(&["bidder"]),
+                timeout_ms: 2000,
+                ..Default::default()
+            });
+            orchestrator.register_provider(Arc::new(recording_provider(
+                "bidder",
+                "bidder-backend",
+                1000,
+                &predicted,
+                &requested,
+            )));
+            let settings = create_test_settings();
+            let downstream = http::Request::new(edgezero_core::body::Body::empty());
+            let context = immediate_test_context(&settings, &downstream, &services);
+            let request = create_test_auction_request();
+
+            let outcome = orchestrator.dispatch_auction(&request, &context).await;
+            let result = match orchestrator
+                .resolve_dispatch_outcome(&request, outcome)
+                .expect("zero canonical timeout should resolve attributably")
+            {
+                super::ResolvedDispatchOutcome::InFlight(dispatched) => {
+                    orchestrator
+                        .collect_dispatched_auction(*dispatched, &services, &context)
+                        .await
+                }
+                super::ResolvedDispatchOutcome::Complete(result) => *result,
+            };
 
-            assert!(result.is_err(), "zero budget should skip every provider");
             assert!(predicted.lock().expect("should lock predicted").is_empty());
             assert!(requested.lock().expect("should lock requested").is_empty());
+            assert_eq!(
+                result.decision_set.results,
+                vec![
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "header-banner".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderTimeout,
+                    },
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "sidebar".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderTimeout,
+                    },
+                ]
+            );
         });
     }
 
@@ -4743,10 +5909,10 @@ mod tests {
                 timeout_ms: 2000,
                 ..Default::default()
             });
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "bidder",
-                backend: "bidder-backend",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "bidder",
+                "bidder-backend",
+            )));
             orchestrator.register_provider(Arc::new(recording_provider(
                 "mediator",
                 "mediator-backend",
@@ -4812,11 +5978,8 @@ mod tests {
             let context = immediate_test_context(&settings, &downstream, &services);
             let request = create_test_auction_request();
 
-            let DispatchAuctionOutcome::Dispatched(dispatched) =
-                orchestrator.dispatch_auction(&request, &context).await
-            else {
-                panic!("should dispatch bidder request");
-            };
+            let dispatched =
+                expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
             orchestrator
                 .collect_dispatched_auction(dispatched, &services, &context)
                 .await;
@@ -4922,18 +6085,22 @@ mod tests {
             let context = immediate_test_context(&settings, &downstream, &services);
             let request = create_test_auction_request();
 
-            let DispatchAuctionOutcome::Dispatched(dispatched) =
-                orchestrator.dispatch_auction(&request, &context).await
-            else {
-                panic!("should dispatch provider");
-            };
+            let dispatched =
+                expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
             let result = orchestrator
                 .collect_dispatched_auction(dispatched, &services, &context)
                 .await;
 
-            assert!(result.provider_responses.iter().any(|response| {
-                response.provider == "provider-a" && response.status == BidStatus::Success
-            }));
+            let provider_a = result
+                .provider_responses
+                .iter()
+                .find(|response| response.provider == "provider-a")
+                .expect("should have provider-a response");
+            assert_eq!(
+                provider_a.status,
+                BidStatus::Success,
+                "response should correlate by the resolved backend name, not the prediction"
+            );
         });
     }
 
@@ -4965,21 +6132,24 @@ mod tests {
             let context = immediate_test_context(&settings, &downstream, &services);
             let request = create_test_auction_request();
 
-            let DispatchAuctionOutcome::Dispatched(dispatched) =
-                orchestrator.dispatch_auction(&request, &context).await
-            else {
-                panic!("should dispatch first provider");
-            };
+            let dispatched =
+                expect_dispatched(orchestrator.dispatch_auction(&request, &context).await);
             let result = orchestrator
                 .collect_dispatched_auction(dispatched, &services, &context)
                 .await;
 
-            assert!(result.provider_responses.iter().any(|response| {
-                response.provider == "provider-a" && response.status == BidStatus::Success
-            }));
-            assert!(result.provider_responses.iter().any(|response| {
-                response.provider == "provider-b" && response.status == BidStatus::Error
-            }));
+            let provider_a = result
+                .provider_responses
+                .iter()
+                .find(|response| response.provider == "provider-a")
+                .expect("should have provider-a response");
+            let provider_b = result
+                .provider_responses
+                .iter()
+                .find(|response| response.provider == "provider-b")
+                .expect("should have provider-b response");
+            assert_eq!(provider_a.status, BidStatus::Success);
+            assert_eq!(provider_b.status, BidStatus::Error);
         });
     }
 
@@ -5007,14 +6177,14 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-a",
-                backend: "backend-a",
-            }));
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-b",
-                backend: "backend-b",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-a",
+                "backend-a",
+            )));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-b",
+                "backend-b",
+            )));
 
             let request = create_test_auction_request();
             let settings = create_test_settings();
@@ -5146,10 +6316,9 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-a",
-                backend: "backend-a",
-            }));
+            let mut provider = StubAuctionProvider::new("provider-a", "backend-a");
+            provider.configured_timeout_ms = 125;
+            orchestrator.register_provider(Arc::new(provider));
             let request = create_test_auction_request();
             let settings = create_test_settings();
             let downstream = http::Request::builder()
@@ -5165,13 +6334,11 @@ mod tests {
                 provider_responses: None,
                 services: &services,
             };
-            let dispatched = match orchestrator
-                .dispatch_auction(&request, &dispatch_context)
-                .await
-            {
-                DispatchAuctionOutcome::Dispatched(dispatched) => dispatched,
-                _ => panic!("should dispatch provider request"),
-            };
+            let dispatched = expect_dispatched(
+                orchestrator
+                    .dispatch_auction(&request, &dispatch_context)
+                    .await,
+            );
             let placeholder = http::Request::builder()
                 .uri("https://placeholder.invalid/")
                 .body(edgezero_core::body::Body::empty())
@@ -5226,14 +6393,14 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-a",
-                backend: "backend-a",
-            }));
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-b",
-                backend: "backend-b",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-a",
+                "backend-a",
+            )));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-b",
+                "backend-b",
+            )));
 
             let request = create_test_auction_request();
             let settings = create_test_settings();
@@ -5254,11 +6421,21 @@ mod tests {
             // Act
             let result = orchestrator.run_auction(&request, &context).await;
 
-            // Assert: rejected before any provider request launches.
-            let err = result.expect_err("should reject multi-provider fan-out");
-            assert!(
-                format!("{err}").contains("sequentially"),
-                "should explain the sequential-execution limitation"
+            // Assert: every affected slot gets an explicit provider failure
+            // without launching either provider request.
+            let result = result.expect("should preserve sequential-platform failures");
+            assert_eq!(
+                result.decision_set.results,
+                vec![
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "header-banner".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderError,
+                    },
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "sidebar".to_string(),
+                        reason: AuctionSlotFailureReason::ProviderError,
+                    },
+                ]
             );
             assert!(
                 stub_for_assertion.recorded_backend_names().is_empty(),
@@ -5292,14 +6469,14 @@ mod tests {
                 ..Default::default()
             };
             let mut orchestrator = AuctionOrchestrator::new(config);
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-a",
-                backend: "backend-a",
-            }));
-            orchestrator.register_provider(Arc::new(StubAuctionProvider {
-                name: "provider-b",
-                backend: "backend-b",
-            }));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-a",
+                "backend-a",
+            )));
+            orchestrator.register_provider(Arc::new(StubAuctionProvider::new(
+                "provider-b",
+                "backend-b",
+            )));
 
             let request = create_test_auction_request();
             let settings = create_test_settings();
@@ -5318,17 +6495,53 @@ mod tests {
             };
 
             // Act
-            let dispatched = orchestrator.dispatch_auction(&request, &context).await;
+            let DispatchAuctionOutcome::DispatchFailed {
+                mut provider_responses,
+                eligible_slots_by_provider,
+                ..
+            } = orchestrator.dispatch_auction(&request, &context).await
+            else {
+                panic!("sequential-platform rejection should preserve dispatch failures");
+            };
 
-            // Assert: no dispatch and no provider request launched.
-            assert!(
-                matches!(dispatched, DispatchAuctionOutcome::NotStarted),
-                "should skip initial-page dispatch on sequential platforms"
-            );
+            // Assert: no network request launches, but every configured provider
+            // remains attributable through the normal terminal decision path.
             assert!(
                 stub_for_assertion.recorded_backend_names().is_empty(),
                 "should not launch any provider request on a sequential platform"
             );
+            let normalized = orchestrator.normalize_provider_responses_with_eligibility(
+                &request,
+                &mut provider_responses,
+                &eligible_slots_by_provider,
+            );
+            let winning_bids = HashMap::new();
+            let decision_set = orchestrator.build_decision_set(
+                &request,
+                &normalized.outcomes,
+                &winning_bids,
+                false,
+            );
+            let result = OrchestrationResult {
+                provider_responses,
+                mediator_response: None,
+                winning_bids,
+                decision_set,
+                total_time_ms: 0,
+                metadata: HashMap::new(),
+            };
+            assert!(result.winning_bids.is_empty());
+            assert!(result.provider_responses.iter().all(|response| {
+                response.status == BidStatus::Error
+                    && response.metadata["error_type"] == "launch_failed"
+            }));
+            assert!(result.decision_set.results.iter().all(|decision| matches!(
+                decision,
+                SlotAuctionDecisionV1::Failed {
+                    reason: AuctionSlotFailureReason::ProviderError,
+                    ..
+                }
+            )));
         });
     }
 
@@ -5468,14 +6681,10 @@ mod tests {
                 .map(|response| response.provider.as_str()),
             Some("immediate-mediator")
         );
-        assert_eq!(
-            result.winning_bids["header-banner"].nurl.as_deref(),
-            Some("https://nurl.example/immediate")
-        );
-        assert!(
-            !result.winning_bids.contains_key("fictional-slot"),
-            "mediator output owns final selection"
-        );
+        let winner = &result.winning_bids["fictional-slot"];
+        assert_eq!(winner.bid_id.as_deref(), Some("provider"));
+        assert_eq!(winner.price, Some(2.5));
+        assert!(!result.winning_bids.contains_key("header-banner"));
     }
 
     async fn planned_pending_mediator_deadline_result(
@@ -5534,7 +6743,11 @@ mod tests {
             .as_ref()
             .expect("current adapters should accept completed late mediator responses");
         assert!(current_mediator.response_time_ms >= 50);
-        assert_eq!(current.winning_bids["slot-1"].bidder, "mediated");
+        assert_eq!(
+            current.winning_bids["fictional-slot"].bid_id.as_deref(),
+            Some("provider")
+        );
+        assert_eq!(current.winning_bids["fictional-slot"].price, Some(9.0));
 
         let hard = planned_pending_mediator_deadline_result(true).await;
         assert!(hard.mediator_response.is_none());
@@ -5760,7 +6973,8 @@ mod tests {
             serde_json::to_vec(&serde_json::json!({
                 "seatbid": [{"seat": "aps-instance", "bid": [{
                     "id": "mediated-aps", "impid": "fictional-slot", "price": 2.0,
-                    "adm": "ignored", "w": 300, "h": 250, "crid": "aps-creative"
+                    "w": 300, "h": 250,
+                    "ext": {"trusted_server": {"candidate_id": "AAAAAAAAAAAA"}}
                 }]}]
             }))
             .expect("should serialize mediator response"),
@@ -5778,7 +6992,8 @@ mod tests {
             timeout_ms: 500,
             ..AdServerMockConfig::default()
         });
-        let orchestrator = AuctionOrchestratorHarness::new(plan, Some(Arc::new(mediator)));
+        let orchestrator = AuctionOrchestratorHarness::new(plan, Some(Arc::new(mediator)))
+            .with_identity_generator(Arc::new(FixedIdentityGenerator::new()));
         let request = planned_request();
         let settings = create_test_settings();
         let inbound = http::Request::new(edgezero_core::body::Body::empty());
@@ -5956,7 +7171,7 @@ mod tests {
         let renderer = bid
             .renderer
             .as_ref()
-            .and_then(BidRenderer::as_aps)
+            .and_then(BidRenderSourceV1::as_aps)
             .expect("should construct typed APS renderer");
         assert_eq!(renderer.account_id, "example-account");
         let decoded = base64::engine::general_purpose::STANDARD
@@ -5976,13 +7191,13 @@ mod tests {
         for reason in [
             "lost_to_higher_bid",
             "script_rendering_disabled",
-            "unknown_impid",
+            "unknown_impression",
             "invalid_dimensions",
             "invalid_price",
             "unsupported_media_type",
-            "unsupported_tagtype",
+            "invalid_tag_type",
             "creative_id_too_large",
-            "missing_render_source",
+            "missing_upstream_bid_id",
             "empty_seatbid_bids",
         ] {
             assert_eq!(response.metadata["drop_reasons"][reason], 1, "{reason}");
@@ -6138,28 +7353,28 @@ mod tests {
                 200,
                 b"not-json".to_vec(),
                 BidStatus::Error,
-                Some("unexpected_response_shape"),
+                Some("invalid_provider_response"),
                 Some("parse_response"),
             ),
             (
                 200,
                 b"[]".to_vec(),
                 BidStatus::Error,
-                Some("unexpected_response_shape"),
+                Some("invalid_provider_response"),
                 Some("parse_response"),
             ),
             (
                 200,
                 br#"{"contextual":true}"#.to_vec(),
                 BidStatus::Error,
-                Some("unexpected_response_shape"),
-                Some("parse_response"),
+                Some("invalid_provider_response"),
+                None,
             ),
             (
                 200,
                 br#"{"cur":"EUR","seatbid":[]}"#.to_vec(),
-                BidStatus::NoBid,
-                Some("unsupported_currency"),
+                BidStatus::Error,
+                Some("invalid_provider_response"),
                 None,
             ),
         ];
@@ -6311,7 +7526,7 @@ mod tests {
         let renderer = parsed.bids[0]
             .renderer
             .as_ref()
-            .and_then(BidRenderer::as_aps)
+            .and_then(BidRenderSourceV1::as_aps)
             .expect("should construct APS renderer");
         let decoded = base64::engine::general_purpose::STANDARD
             .decode(&renderer.aax_response)
@@ -7490,6 +8705,9 @@ mod tests {
             "slot-1".to_string(),
             Bid {
                 slot_id: "slot-1".to_string(),
+                candidate_id: None,
+                candidate_provider: None,
+                renderer_reservation_id: None,
                 price: None,
                 currency: "USD".to_string(),
                 creative: Some("<div>Ad</div>".to_string()),
@@ -7535,6 +8753,9 @@ mod tests {
             "atf".to_string(),
             Bid {
                 slot_id: "atf".to_string(),
+                candidate_id: None,
+                candidate_provider: None,
+                renderer_reservation_id: None,
                 price: Some(0.30), // decoded APS price — below $0.50 floor
                 currency: "USD".to_string(),
                 creative: Some("<div>APS Ad</div>".to_string()),
@@ -7575,6 +8796,9 @@ mod tests {
             "atf".to_string(),
             Bid {
                 slot_id: "atf".to_string(),
+                candidate_id: None,
+                candidate_provider: None,
+                renderer_reservation_id: None,
                 price: Some(0.75), // decoded APS price — above floor
                 currency: "USD".to_string(),
                 creative: Some("<div>APS Ad</div>".to_string()),
diff --git a/crates/trusted-server-core/src/auction/provider.rs b/crates/trusted-server-core/src/auction/provider.rs
index 28f6dbd96..01380a070 100644
--- a/crates/trusted-server-core/src/auction/provider.rs
+++ b/crates/trusted-server-core/src/auction/provider.rs
@@ -25,7 +25,31 @@ use super::openrtb::{
 use super::plan::ProviderPlan;
 use super::profile::CompiledOpenRtbProfile;
 use super::routing::{ProviderAuctionInput, RoutedAuction};
-use super::types::{AuctionContext, AuctionRequest, AuctionResponse};
+use super::types::{
+    AuctionContext, AuctionRequest, AuctionResponse, AuctionSlotFailureReason, Bid,
+};
+
+/// Exactly one normalized outcome for a slot dispatched to one provider.
+#[derive(Debug, Clone)]
+pub struct ProviderSlotOutcome {
+    /// Provider integration that received the slot.
+    pub provider: String,
+    /// Exact dispatched slot identifier.
+    pub slot: String,
+    /// Candidate, successful no-bid, or typed failure.
+    pub disposition: ProviderSlotDisposition,
+}
+
+/// Closed normalized provider result for one dispatched slot.
+#[derive(Debug, Clone)]
+pub enum ProviderSlotDisposition {
+    /// One or more independently validated candidates returned for the slot.
+    Candidates(Vec<Bid>),
+    /// Provider completed successfully without a candidate for this slot.
+    NoBid,
+    /// Provider failed for this slot.
+    Failed(AuctionSlotFailureReason),
+}
 
 const MAX_PLANNED_RESPONSE_BYTES: usize = 1024 * 1024;
 
diff --git a/crates/trusted-server-core/src/auction/telemetry.rs b/crates/trusted-server-core/src/auction/telemetry.rs
index 2c7c9cc45..7cc113285 100644
--- a/crates/trusted-server-core/src/auction/telemetry.rs
+++ b/crates/trusted-server-core/src/auction/telemetry.rs
@@ -944,7 +944,7 @@ mod tests {
 
     use serde_json::json;
 
-    use crate::auction::types::{AdFormat, AdSlot, PublisherInfo, UserInfo};
+    use crate::auction::types::{AdFormat, AdSlot, AuctionDecisionSetV1, PublisherInfo, UserInfo};
 
     use super::*;
 
@@ -980,6 +980,9 @@ mod tests {
     fn bid(slot_id: &str, bidder: &str, ad_id: Option<&str>, price: Option<f64>) -> Bid {
         Bid {
             slot_id: slot_id.to_owned(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price,
             currency: "USD".to_owned(),
             creative: None,
@@ -1061,6 +1064,11 @@ mod tests {
             provider_responses: vec![provider_success, provider_no_bid, provider_error],
             mediator_response: None,
             winning_bids: HashMap::from([("slot-1".to_owned(), winning)]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: request.id.clone(),
+                results: Vec::new(),
+            },
             total_time_ms: 99,
             metadata: HashMap::new(),
         };
@@ -1122,6 +1130,10 @@ mod tests {
             provider_responses: vec![provider],
             mediator_response: None,
             winning_bids: HashMap::from([("slot-1".to_owned(), aps_bid.clone())]),
+            decision_set: crate::auction::types::AuctionDecisionSetV1::failed(
+                &request,
+                crate::auction::types::AuctionSlotFailureReason::WinnerNotRenderable,
+            ),
             total_time_ms: 12,
             metadata: HashMap::new(),
         };
@@ -1158,6 +1170,10 @@ mod tests {
             )],
             mediator_response: None,
             winning_bids: HashMap::from([("slot-1".to_owned(), fallback_bid)]),
+            decision_set: crate::auction::types::AuctionDecisionSetV1::failed(
+                &request,
+                crate::auction::types::AuctionSlotFailureReason::WinnerNotRenderable,
+            ),
             total_time_ms: 12,
             metadata: HashMap::new(),
         };
@@ -1190,6 +1206,10 @@ mod tests {
             provider_responses: vec![provider],
             mediator_response: Some(mediator),
             winning_bids: HashMap::from([("slot-1".to_owned(), aps_bid.clone())]),
+            decision_set: crate::auction::types::AuctionDecisionSetV1::failed(
+                &request,
+                crate::auction::types::AuctionSlotFailureReason::WinnerNotRenderable,
+            ),
             total_time_ms: 15,
             metadata: HashMap::new(),
         };
@@ -1230,6 +1250,11 @@ mod tests {
             provider_responses: vec![provider_success.clone()],
             mediator_response: None,
             winning_bids: HashMap::from([("slot-1".to_owned(), provider_success.bids[0].clone())]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: request.id.clone(),
+                results: Vec::new(),
+            },
             total_time_ms: 42,
             metadata: HashMap::new(),
         };
@@ -1271,6 +1296,11 @@ mod tests {
             provider_responses: vec![provider_http_error],
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: request.id.clone(),
+                results: Vec::new(),
+            },
             total_time_ms: 12,
             metadata: HashMap::new(),
         };
@@ -1309,6 +1339,11 @@ mod tests {
             provider_responses: vec![provider_success],
             mediator_response: Some(mediator_response),
             winning_bids: HashMap::from([("slot-1".to_owned(), mediator_bid)]),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: request.id.clone(),
+                results: Vec::new(),
+            },
             total_time_ms: 80,
             metadata: HashMap::new(),
         };
@@ -1349,6 +1384,11 @@ mod tests {
             provider_responses: Vec::new(),
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: request.id.clone(),
+                results: Vec::new(),
+            },
             total_time_ms: 1,
             metadata: HashMap::new(),
         };
diff --git a/crates/trusted-server-core/src/auction/types.rs b/crates/trusted-server-core/src/auction/types.rs
index 406915706..c5dbfc441 100644
--- a/crates/trusted-server-core/src/auction/types.rs
+++ b/crates/trusted-server-core/src/auction/types.rs
@@ -1,9 +1,15 @@
 //! Core types for auction requests and responses.
 
+use base64::{
+    Engine as _,
+    engine::general_purpose::{STANDARD as BASE64_STANDARD, URL_SAFE_NO_PAD},
+};
 use edgezero_core::body::Body as EdgeBody;
 use http::Request;
+use rand::{RngCore as _, rngs::OsRng};
 use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use url::Url;
 
 use crate::auction::context::ContextValue;
 use crate::geo::GeoInfo;
@@ -14,6 +20,42 @@ fn is_zero(value: &usize) -> bool {
     *value == 0
 }
 
+/// Injectable CSPRNG boundary for server-minted response-local identities.
+pub(crate) trait AuctionIdentityGenerator: Send + Sync {
+    /// Fill the complete destination or report that secure randomness is unavailable.
+    fn fill(&self, destination: &mut [u8]) -> Result<(), ()>;
+}
+
+/// Production CSPRNG for server-minted auction identities.
+pub(crate) struct SystemAuctionIdentityGenerator;
+
+impl AuctionIdentityGenerator for SystemAuctionIdentityGenerator {
+    fn fill(&self, destination: &mut [u8]) -> Result<(), ()> {
+        OsRng.try_fill_bytes(destination).map_err(|_| ())
+    }
+}
+
+/// Mint one response-unique unpadded base64url identity.
+pub(crate) fn mint_response_unique_base64url_identity(
+    generator: &dyn AuctionIdentityGenerator,
+    issued: &mut HashSet<String>,
+    prefix: &str,
+    random_byte_count: usize,
+    collision_retries: usize,
+) -> Option<String> {
+    for _ in 0..=collision_retries {
+        let mut bytes = vec![0_u8; random_byte_count];
+        if generator.fill(&mut bytes).is_err() {
+            return None;
+        }
+        let identity = format!("{prefix}{}", URL_SAFE_NO_PAD.encode(bytes));
+        if issued.insert(identity.clone()) {
+            return Some(identity);
+        }
+    }
+    None
+}
+
 /// Represents a unified auction request across all providers.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AuctionRequest {
@@ -161,6 +203,353 @@ pub struct AuctionContext<'a> {
     pub services: &'a RuntimeServices,
 }
 
+/// Closed, local reason set for rejecting provider bids or undeliverable winners.
+///
+/// These values are serialized only into existing auction debug/diagnostic
+/// surfaces. They are not a persistence or external-event taxonomy.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AuctionDropReason {
+    /// Configured processing rejected an ordinary creative's only render source.
+    CreativeProcessingRejected,
+    /// Optional creative ID is present with an invalid type or value.
+    InvalidCreativeId,
+    /// Optional creative ID exceeds its UTF-8 byte bound.
+    CreativeIdTooLarge,
+    /// A positive integral dimension exceeds the supported range.
+    DimensionsOutOfRange,
+    /// An otherwise valid upstream bid ID is repeated in one provider response.
+    DuplicateUpstreamBidId,
+    /// A response contains no seat bids.
+    #[serde(rename = "empty_seatbid")]
+    EmptySeatBid,
+    /// A seat bid contains no usable bid array.
+    #[serde(rename = "empty_seatbid_bids")]
+    EmptySeatBidBids,
+    /// A creative URL is malformed, unsafe, or self-origin.
+    InvalidCreativeUrl,
+    /// A dimension is missing, malformed, nonpositive, or not requested.
+    InvalidDimensions,
+    /// A price is missing, malformed, nonfinite, or negative.
+    InvalidPrice,
+    /// The provider response violates the response-level contract.
+    InvalidProviderResponse,
+    /// The APS tag type is missing or unsupported.
+    InvalidTagType,
+    /// An upstream bid ID contains a forbidden control value or has the wrong type.
+    InvalidUpstreamBidId,
+    /// A valid sibling was preferred by deterministic per-slot reduction.
+    LostToHigherBid,
+    /// A provider bid is not an object.
+    MalformedBid,
+    /// APS creative metadata does not contain `creativeurl`.
+    MissingCreativeUrl,
+    /// Provider parsing was invoked without its request-local context.
+    MissingRequestContext,
+    /// A required upstream bid ID is absent or empty.
+    MissingUpstreamBidId,
+    /// A winner carries more than one render source.
+    MultipleRenderSources,
+    /// A winner has no render source.
+    NoRenderSource,
+    /// A typed renderer extension could not be serialized.
+    RendererExtensionSerializationFailed,
+    /// A validated renderer projection exceeds its bound.
+    RenderPayloadTooLarge,
+    /// APS script rendering is disabled by configuration.
+    ScriptRenderingDisabled,
+    /// A provider bid references an impression that was not dispatched.
+    UnknownImpression,
+    /// A provider bid declares a non-banner media type.
+    UnsupportedMediaType,
+    /// An upstream bid ID exceeds 64 UTF-8 bytes.
+    UpstreamBidIdTooLarge,
+}
+
+impl AuctionDropReason {
+    /// Return the exact existing debug/projection literal.
+    ///
+    /// This hand-written mapping also drives [`Ord`] so serialized-map output stays
+    /// alphabetically stable even when declaration order changes.
+    #[must_use]
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::CreativeProcessingRejected => "creative_processing_rejected",
+            Self::InvalidCreativeId => "invalid_creative_id",
+            Self::CreativeIdTooLarge => "creative_id_too_large",
+            Self::DimensionsOutOfRange => "dimensions_out_of_range",
+            Self::DuplicateUpstreamBidId => "duplicate_upstream_bid_id",
+            Self::EmptySeatBid => "empty_seatbid",
+            Self::EmptySeatBidBids => "empty_seatbid_bids",
+            Self::InvalidCreativeUrl => "invalid_creative_url",
+            Self::InvalidDimensions => "invalid_dimensions",
+            Self::InvalidPrice => "invalid_price",
+            Self::InvalidProviderResponse => "invalid_provider_response",
+            Self::InvalidTagType => "invalid_tag_type",
+            Self::InvalidUpstreamBidId => "invalid_upstream_bid_id",
+            Self::LostToHigherBid => "lost_to_higher_bid",
+            Self::MalformedBid => "malformed_bid",
+            Self::MissingCreativeUrl => "missing_creative_url",
+            Self::MissingRequestContext => "missing_request_context",
+            Self::MissingUpstreamBidId => "missing_upstream_bid_id",
+            Self::MultipleRenderSources => "multiple_render_sources",
+            Self::NoRenderSource => "no_render_source",
+            Self::RendererExtensionSerializationFailed => "renderer_extension_serialization_failed",
+            Self::RenderPayloadTooLarge => "render_payload_too_large",
+            Self::ScriptRenderingDisabled => "script_rendering_disabled",
+            Self::UnknownImpression => "unknown_impression",
+            Self::UnsupportedMediaType => "unsupported_media_type",
+            Self::UpstreamBidIdTooLarge => "upstream_bid_id_too_large",
+        }
+    }
+}
+
+impl Ord for AuctionDropReason {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl PartialOrd for AuctionDropReason {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// Typed counts projected into the existing `drop_reasons` debug object.
+pub type AuctionDropReasons = BTreeMap<AuctionDropReason, u64>;
+
+/// Increment one typed local drop reason.
+pub(crate) fn record_auction_drop(reasons: &mut AuctionDropReasons, reason: AuctionDropReason) {
+    *reasons.entry(reason).or_default() += 1;
+}
+
+/// Closed failure set for one requested slot's server-auction decision.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum AuctionSlotFailureReason {
+    /// The auction orchestrator is disabled.
+    AuctionDisabled,
+    /// Request consent does not permit a server-side auction.
+    ConsentDenied,
+    /// No enabled configured provider can bid on the slot.
+    SlotNotEligible,
+    /// A dispatched provider exceeded its deadline.
+    ProviderTimeout,
+    /// A provider could not launch or complete its transport/HTTP exchange.
+    ProviderError,
+    /// A provider response failed structural, currency, identity, or bid validation.
+    InvalidProviderResponse,
+    /// The configured mediator failed or returned invalid provenance.
+    MediationFailed,
+    /// A selected candidate cannot be represented by the exact browser contract.
+    WinnerNotRenderable,
+    /// A unique renderer reservation could not be minted.
+    IdentityGenerationFailed,
+    /// An internal invariant or candidate-identity operation failed.
+    InternalError,
+}
+
+impl AuctionSlotFailureReason {
+    /// Return the exact wire literal.
+    #[must_use]
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::AuctionDisabled => "auction_disabled",
+            Self::ConsentDenied => "consent_denied",
+            Self::SlotNotEligible => "slot_not_eligible",
+            Self::ProviderTimeout => "provider_timeout",
+            Self::ProviderError => "provider_error",
+            Self::InvalidProviderResponse => "invalid_provider_response",
+            Self::MediationFailed => "mediation_failed",
+            Self::WinnerNotRenderable => "winner_not_renderable",
+            Self::IdentityGenerationFailed => "identity_generation_failed",
+            Self::InternalError => "internal_error",
+        }
+    }
+
+    /// Closed multi-provider aggregation priority; lower values win.
+    #[must_use]
+    pub const fn priority(self) -> u8 {
+        match self {
+            Self::InternalError => 0,
+            Self::MediationFailed => 1,
+            Self::InvalidProviderResponse => 2,
+            Self::ProviderError => 3,
+            Self::ProviderTimeout => 4,
+            Self::ConsentDenied => 5,
+            Self::AuctionDisabled => 6,
+            Self::SlotNotEligible => 7,
+            Self::WinnerNotRenderable | Self::IdentityGenerationFailed => u8::MAX,
+        }
+    }
+}
+
+/// Exactly one final server-auction decision for a requested slot.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(
+    tag = "outcome",
+    rename_all = "snake_case",
+    rename_all_fields = "camelCase",
+    deny_unknown_fields
+)]
+pub enum SlotAuctionDecisionV1 {
+    /// A candidate won and joins exactly one projected bid.
+    Winner {
+        /// Exact request slot identifier.
+        slot: String,
+        /// Opaque response-local candidate identifier.
+        candidate_id: String,
+    },
+    /// Every dispatched provider completed successfully without a candidate.
+    NoBid {
+        /// Exact request slot identifier.
+        slot: String,
+    },
+    /// The slot failed with one closed reason.
+    Failed {
+        /// Exact request slot identifier.
+        slot: String,
+        /// Exact failure reason.
+        reason: AuctionSlotFailureReason,
+    },
+}
+
+impl SlotAuctionDecisionV1 {
+    /// Return the exact slot identifier shared by every variant.
+    #[must_use]
+    pub fn slot(&self) -> &str {
+        match self {
+            Self::Winner { slot, .. } | Self::NoBid { slot } | Self::Failed { slot, .. } => slot,
+        }
+    }
+}
+
+impl Serialize for SlotAuctionDecisionV1 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+
+        match self {
+            Self::Winner { slot, candidate_id } => {
+                let mut state = serializer.serialize_struct("SlotAuctionDecisionV1", 3)?;
+                state.serialize_field("slot", slot)?;
+                state.serialize_field("outcome", "winner")?;
+                state.serialize_field("candidateId", candidate_id)?;
+                state.end()
+            }
+            Self::NoBid { slot } => {
+                let mut state = serializer.serialize_struct("SlotAuctionDecisionV1", 2)?;
+                state.serialize_field("slot", slot)?;
+                state.serialize_field("outcome", "no_bid")?;
+                state.end()
+            }
+            Self::Failed { slot, reason } => {
+                let mut state = serializer.serialize_struct("SlotAuctionDecisionV1", 3)?;
+                state.serialize_field("slot", slot)?;
+                state.serialize_field("outcome", "failed")?;
+                state.serialize_field("reason", reason)?;
+                state.end()
+            }
+        }
+    }
+}
+
+/// Ordered version-1 decision set for one server auction.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct AuctionDecisionSetV1 {
+    /// Contract version.
+    pub version: u8,
+    /// Exact auction identifier.
+    pub auction_id: String,
+    /// Exactly one decision per requested slot, in request order.
+    pub results: Vec<SlotAuctionDecisionV1>,
+}
+
+impl AuctionDecisionSetV1 {
+    /// Construct an ordered decision set for a request-wide gate.
+    #[must_use]
+    pub fn failed(request: &AuctionRequest, reason: AuctionSlotFailureReason) -> Self {
+        Self {
+            version: 1,
+            auction_id: request.id.clone(),
+            results: request
+                .slots
+                .iter()
+                .map(|slot| SlotAuctionDecisionV1::Failed {
+                    slot: slot.id.clone(),
+                    reason,
+                })
+                .collect(),
+        }
+    }
+}
+
+/// Maximum canonical UTF-8 size of the browser auction projection.
+pub const MAX_BROWSER_AUCTION_PROJECTION_BYTES: usize = 8 * 1024 * 1024;
+/// Maximum number of requested results or projected winner bids.
+pub const MAX_BROWSER_AUCTION_RESULTS: usize = 256;
+/// Maximum number of publisher targeting entries on one projected bid.
+pub const MAX_BROWSER_AUCTION_TARGETING_ENTRIES: usize = 32;
+
+/// One exact browser-facing winner projection.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct BrowserAuctionBidV1 {
+    /// Response-local mediator candidate identity.
+    pub candidate_id: String,
+    /// Exact requested server slot identity.
+    pub slot: String,
+    /// Canonical provider integration name.
+    pub provider: String,
+    /// Exact provider-native upstream bid identity.
+    pub upstream_bid_id: String,
+    /// Selected finite, nonnegative CPM.
+    pub cpm: f64,
+    /// Exact auction currency; version 1 admits only `USD`.
+    pub currency: String,
+    /// Lexically ordered publisher targeting, excluding runtime-owned `hb_adid`.
+    pub targeting: BTreeMap<String, String>,
+    /// Server-minted renderer capability identity for APS/ADM only.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub renderer_reservation_id: Option<String>,
+    /// Sole tagged render authority for the winner.
+    pub render_source: BidRenderSourceV1,
+}
+
+/// Exact GAM placement metadata required to publish one server-projected slot.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct BrowserAuctionSlotV1 {
+    /// Exact server slot identity joined to one auction decision.
+    pub slot: String,
+    /// Fully rendered GAM ad-unit path for this navigation.
+    pub gam_unit_path: String,
+    /// Stable configured DOM id/prefix for responsive resolution.
+    pub div_id: String,
+    /// Accepted banner dimensions in configured order.
+    pub formats: Vec<[u32; 2]>,
+    /// Static publisher targeting applied before winner targeting.
+    pub targeting: BTreeMap<String, String>,
+}
+
+/// Complete browser-facing version-1 auction projection.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct BrowserAuctionProjectionV1 {
+    /// Contract version.
+    pub version: u8,
+    /// Ordered decision set for every requested slot.
+    pub auction: AuctionDecisionSetV1,
+    /// Ordered GAM placement definitions; empty only for direct `/auction` serialization.
+    pub slots: Vec<BrowserAuctionSlotV1>,
+    /// Winner bids in matching decision order.
+    pub bids: Vec<BrowserAuctionBidV1>,
+}
+
 /// URL used by the orchestrator when invoking a mediator from the collect
 /// path. Providers can `debug_assert` against this value to catch a mediator
 /// that has accidentally started depending on `context.request` carrying real
@@ -194,7 +583,7 @@ pub enum ApsTagType {
 
 /// Version 1 APS renderer descriptor shared with browser clients.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct ApsRendererV1 {
     /// Renderer contract version.
     pub version: u8,
@@ -217,22 +606,308 @@ pub struct ApsRendererV1 {
     pub height: u32,
 }
 
-/// Typed browser renderer capability carried by a bid.
+/// Version 1 inline ADM render source shared with browser clients.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct AdmRenderSourceV1 {
+    /// Render-source contract version.
+    pub version: u8,
+    /// Exact creative markup.
+    pub adm: String,
+    /// Creative width.
+    pub width: u32,
+    /// Creative height.
+    pub height: u32,
+}
+
+/// Thin version 1 carrier for the current GPT-owned PBS Cache behavior.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct BaselinePbsCacheSourceV1 {
+    /// Render-source contract version.
+    pub version: u8,
+    /// Exact native PBS Cache identity.
+    pub cache_id: String,
+    /// Exact current-main `hb_cache_host` value.
+    pub cache_host: String,
+    /// Exact current-main `hb_cache_path` value.
+    pub cache_path: String,
+    /// Winning width transported without cache-specific validation.
+    pub width: u32,
+    /// Winning height transported without cache-specific validation.
+    pub height: u32,
+}
+
+/// Typed browser render source carried by a bid.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "lowercase")]
-pub enum BidRenderer {
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum BidRenderSourceV1 {
     /// APS renderer version 1.
     Aps(ApsRendererV1),
+    /// Inline ADM version 1.
+    Adm(AdmRenderSourceV1),
+    /// Current-main GPT-owned PBS Cache carrier.
+    PbsCache(BaselinePbsCacheSourceV1),
 }
 
-impl BidRenderer {
+impl BidRenderSourceV1 {
     /// Return the APS renderer descriptor when this is an APS renderer.
     #[must_use]
     pub fn as_aps(&self) -> Option<&ApsRendererV1> {
         match self {
             Self::Aps(renderer) => Some(renderer),
+            Self::Adm(_) | Self::PbsCache(_) => None,
+        }
+    }
+}
+
+/// Smallest accepted renderer dimension in CSS pixels.
+pub const RENDER_DIMENSION_MIN: u64 = 1;
+/// Largest accepted renderer dimension in CSS pixels.
+pub const RENDER_DIMENSION_MAX: u64 = 4096;
+
+const MAX_APS_ACCOUNT_ID_BYTES: usize = 1024;
+const MAX_APS_BID_ID_BYTES: usize = 64;
+const MAX_APS_CREATIVE_ID_BYTES: usize = 1024;
+const MAX_APS_CREATIVE_URL_BYTES: usize = 4096;
+const MAX_APS_RENDER_ENVELOPE_BYTES: usize = 256 * 1024;
+const MAX_APS_RENDER_ENVELOPE_BASE64_BYTES: usize = 4 * MAX_APS_RENDER_ENVELOPE_BYTES.div_ceil(3);
+
+/// Cross-language APS descriptor validation result.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ApsRendererValidationResult {
+    /// Descriptor and decoded envelope are valid and agree.
+    Accepted,
+    /// Descriptor or decoded envelope is malformed.
+    DescriptorInvalid,
+    /// A dimension has the wrong type or is nonfinite, fractional, zero, or negative.
+    InvalidDimensions,
+    /// An otherwise integral positive dimension is outside the supported range.
+    DimensionsOutOfRange,
+}
+
+impl ApsRendererValidationResult {
+    /// Return the exact browser failure/result literal.
+    #[must_use]
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Accepted => "accepted",
+            Self::DescriptorInvalid => "descriptor_invalid",
+            Self::InvalidDimensions => "invalid_dimensions",
+            Self::DimensionsOutOfRange => "dimensions_out_of_range",
+        }
+    }
+}
+
+fn has_exact_json_keys(value: &serde_json::Value, expected: &[&str]) -> bool {
+    value.as_object().is_some_and(|object| {
+        object.len() == expected.len() && expected.iter().all(|key| object.contains_key(*key))
+    })
+}
+
+fn classify_render_dimension(value: &serde_json::Value) -> ApsRendererValidationResult {
+    let Some(number) = value.as_f64() else {
+        return ApsRendererValidationResult::InvalidDimensions;
+    };
+    if !number.is_finite() || number.fract() != 0.0 || number <= 0.0 {
+        return ApsRendererValidationResult::InvalidDimensions;
+    }
+    if number < RENDER_DIMENSION_MIN as f64 || number > RENDER_DIMENSION_MAX as f64 {
+        return ApsRendererValidationResult::DimensionsOutOfRange;
+    }
+    ApsRendererValidationResult::Accepted
+}
+
+fn valid_aps_creative_url(value: &str, publisher_origin: &str) -> bool {
+    if value.len() > MAX_APS_CREATIVE_URL_BYTES {
+        return false;
+    }
+    let Ok(url) = Url::parse(value) else {
+        return false;
+    };
+    url.scheme() == "https"
+        && url.host_str().is_some()
+        && url.username().is_empty()
+        && url.password().is_none()
+        && url.origin().ascii_serialization() != publisher_origin
+}
+
+/// Classify a raw APS renderer descriptor using the cross-language version-1 contract.
+#[must_use]
+pub fn classify_aps_renderer_v1(
+    value: &serde_json::Value,
+    publisher_origin: &str,
+) -> ApsRendererValidationResult {
+    const REQUIRED_KEYS: &[&str] = &[
+        "aaxResponse",
+        "accountId",
+        "bidId",
+        "creativeUrl",
+        "height",
+        "tagType",
+        "type",
+        "version",
+        "width",
+    ];
+    const KEYS_WITH_CREATIVE_ID: &[&str] = &[
+        "aaxResponse",
+        "accountId",
+        "bidId",
+        "creativeId",
+        "creativeUrl",
+        "height",
+        "tagType",
+        "type",
+        "version",
+        "width",
+    ];
+
+    if !has_exact_json_keys(value, REQUIRED_KEYS)
+        && !has_exact_json_keys(value, KEYS_WITH_CREATIVE_ID)
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+
+    let Some(descriptor) = value.as_object() else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if descriptor.get("type").and_then(serde_json::Value::as_str) != Some("aps")
+        || descriptor
+            .get("version")
+            .and_then(serde_json::Value::as_f64)
+            .is_none_or(|version| version != 1.0)
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+
+    let Some(account_id) = descriptor
+        .get("accountId")
+        .and_then(serde_json::Value::as_str)
+    else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    let Some(bid_id) = descriptor.get("bidId").and_then(serde_json::Value::as_str) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if account_id.is_empty()
+        || account_id.len() > MAX_APS_ACCOUNT_ID_BYTES
+        || bid_id.is_empty()
+        || bid_id.len() > MAX_APS_BID_ID_BYTES
+        || bid_id.bytes().any(|byte| byte <= 0x1f || byte == 0x7f)
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    if let Some(creative_id) = descriptor.get("creativeId") {
+        let Some(creative_id) = creative_id.as_str() else {
+            return ApsRendererValidationResult::DescriptorInvalid;
+        };
+        if creative_id.is_empty() || creative_id.len() > MAX_APS_CREATIVE_ID_BYTES {
+            return ApsRendererValidationResult::DescriptorInvalid;
         }
     }
+    let Some(tag_type) = descriptor
+        .get("tagType")
+        .and_then(serde_json::Value::as_str)
+    else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if tag_type != "iframe" && tag_type != "script" {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+
+    let width_result =
+        classify_render_dimension(descriptor.get("width").unwrap_or(&serde_json::Value::Null));
+    if width_result != ApsRendererValidationResult::Accepted {
+        return width_result;
+    }
+    let height_result =
+        classify_render_dimension(descriptor.get("height").unwrap_or(&serde_json::Value::Null));
+    if height_result != ApsRendererValidationResult::Accepted {
+        return height_result;
+    }
+
+    let Some(creative_url) = descriptor
+        .get("creativeUrl")
+        .and_then(serde_json::Value::as_str)
+    else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    let Some(aax_response) = descriptor
+        .get("aaxResponse")
+        .and_then(serde_json::Value::as_str)
+    else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if !valid_aps_creative_url(creative_url, publisher_origin)
+        || aax_response.is_empty()
+        || aax_response.len() > MAX_APS_RENDER_ENVELOPE_BASE64_BYTES
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    let Ok(decoded_bytes) = BASE64_STANDARD.decode(aax_response) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if decoded_bytes.len() > MAX_APS_RENDER_ENVELOPE_BYTES
+        || BASE64_STANDARD.encode(&decoded_bytes) != aax_response
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    let Ok(decoded_utf8) = core::str::from_utf8(&decoded_bytes) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    let Ok(decoded) = serde_json::from_str::<serde_json::Value>(decoded_utf8) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if !has_exact_json_keys(&decoded, &["seatbid"]) {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    let Some(seats) = decoded.get("seatbid").and_then(serde_json::Value::as_array) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if seats.len() != 1 || !has_exact_json_keys(&seats[0], &["bid"]) {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    let Some(bids) = seats[0].get("bid").and_then(serde_json::Value::as_array) else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if bids.len() != 1 || !has_exact_json_keys(&bids[0], &["ext", "h", "id", "price", "w"]) {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+    let bid = &bids[0];
+    let Some(ext) = bid.get("ext") else {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    };
+    if !has_exact_json_keys(ext, &["creativeurl", "tagtype"]) {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+
+    let bid_width_result =
+        classify_render_dimension(bid.get("w").unwrap_or(&serde_json::Value::Null));
+    if bid_width_result != ApsRendererValidationResult::Accepted {
+        return bid_width_result;
+    }
+    let bid_height_result =
+        classify_render_dimension(bid.get("h").unwrap_or(&serde_json::Value::Null));
+    if bid_height_result != ApsRendererValidationResult::Accepted {
+        return bid_height_result;
+    }
+    let price_is_valid = bid
+        .get("price")
+        .and_then(serde_json::Value::as_f64)
+        .is_some_and(|price| price.is_finite() && price >= 0.0);
+    if bid.get("id").and_then(serde_json::Value::as_str) != Some(bid_id)
+        || bid.get("w").and_then(serde_json::Value::as_f64)
+            != descriptor.get("width").and_then(serde_json::Value::as_f64)
+        || bid.get("h").and_then(serde_json::Value::as_f64)
+            != descriptor.get("height").and_then(serde_json::Value::as_f64)
+        || ext.get("creativeurl").and_then(serde_json::Value::as_str) != Some(creative_url)
+        || ext.get("tagtype").and_then(serde_json::Value::as_str) != Some(tag_type)
+        || !price_is_valid
+    {
+        return ApsRendererValidationResult::DescriptorInvalid;
+    }
+
+    ApsRendererValidationResult::Accepted
 }
 
 /// Individual bid from a provider.
@@ -240,13 +915,22 @@ impl BidRenderer {
 pub struct Bid {
     /// Slot this bid is for
     pub slot_id: String,
+    /// Server-minted opaque identifier used only for this auction response.
+    #[serde(skip)]
+    pub candidate_id: Option<String>,
+    /// Provider integration name paired with the upstream bid ID for provenance.
+    #[serde(skip)]
+    pub candidate_provider: Option<String>,
+    /// Server-minted renderer capability identifier (populated during projection).
+    #[serde(skip)]
+    pub renderer_reservation_id: Option<String>,
     /// Bid price in CPM.
     pub price: Option<f64>,
     /// Currency code (e.g., "USD")
     pub currency: String,
     /// Creative markup (HTML/VAST).
     ///
-    /// `None` when the bid uses a typed [`BidRenderer`] instead.
+    /// `None` when the bid uses a typed [`BidRenderSourceV1`] instead.
     pub creative: Option<String>,
     /// Advertiser domain
     pub adomain: Option<Vec<String>>,
@@ -277,11 +961,11 @@ pub struct Bid {
     pub creative_id: Option<String>,
     /// Typed browser renderer capability.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub renderer: Option<BidRenderer>,
+    pub renderer: Option<BidRenderSourceV1>,
     /// Prebid Cache UUID for this bid.
     ///
     /// Populated from `ext.prebid.cache.bids.cacheId` in the PBS response.
-    /// Used as `hb_adid` targeting value in `window.tsjs.bids`. `None` for
+    /// Used as the `hb_adid` value in the initial browser auction projection. `None` for
     /// non-PBS providers (e.g., APS) and PBS bids without Prebid Cache enabled.
     pub cache_id: Option<String>,
     /// Prebid Cache host (e.g., `"openads.adsrvr.org"`).
@@ -298,6 +982,28 @@ pub struct Bid {
     pub metadata: HashMap<String, serde_json::Value>,
 }
 
+/// Length of the hex-encoded creative trace hash.
+const ADM_TRACE_HASH_LEN: usize = 16;
+
+/// Compute the trace hash for delivered creative markup.
+#[must_use]
+pub fn adm_trace_hash(adm: &str) -> String {
+    use sha2::{Digest as _, Sha256};
+
+    let digest = Sha256::digest(adm.as_bytes());
+    let mut hex = hex::encode(digest);
+    hex.truncate(ADM_TRACE_HASH_LEN);
+    hex
+}
+
+impl Bid {
+    /// Trace hash of this bid's creative markup, when present.
+    #[must_use]
+    pub fn creative_trace_hash(&self) -> Option<String> {
+        self.creative.as_deref().map(adm_trace_hash)
+    }
+}
+
 /// Per-provider summary included in the auction response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProviderSummary {
@@ -348,7 +1054,7 @@ pub struct OrchestratorExt {
     pub dropped_winner_count: usize,
     /// Machine-readable reasons for omitted winners.
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
-    pub dropped_winner_reasons: BTreeMap<String, usize>,
+    pub dropped_winner_reasons: AuctionDropReasons,
 }
 
 /// Status of bid response.
@@ -404,6 +1110,30 @@ impl AuctionResponse {
         self.metadata.insert(key.into(), value);
         self
     }
+
+    /// Project typed local drop reasons into the existing provider metadata surface.
+    #[must_use]
+    pub fn with_drop_reasons(mut self, reasons: &AuctionDropReasons) -> Self {
+        if !reasons.is_empty() {
+            let values = reasons
+                .iter()
+                .map(|(reason, count)| {
+                    (reason.as_str().to_string(), serde_json::Value::from(*count))
+                })
+                .collect();
+            self.metadata.insert(
+                "drop_reasons".to_string(),
+                serde_json::Value::Object(values),
+            );
+        }
+        self
+    }
+
+    /// Project one typed local drop reason into provider metadata.
+    #[must_use]
+    pub fn with_drop_reason(self, reason: AuctionDropReason) -> Self {
+        self.with_drop_reasons(&BTreeMap::from([(reason, 1)]))
+    }
 }
 
 #[cfg(test)]
@@ -411,9 +1141,59 @@ mod tests {
     use super::*;
     use serde_json::json;
 
+    #[test]
+    fn typed_drop_reasons_use_exact_literals_in_provider_summary_metadata() {
+        let reasons = [
+            AuctionDropReason::CreativeProcessingRejected,
+            AuctionDropReason::InvalidCreativeId,
+            AuctionDropReason::CreativeIdTooLarge,
+            AuctionDropReason::DimensionsOutOfRange,
+            AuctionDropReason::DuplicateUpstreamBidId,
+            AuctionDropReason::EmptySeatBid,
+            AuctionDropReason::EmptySeatBidBids,
+            AuctionDropReason::InvalidCreativeUrl,
+            AuctionDropReason::InvalidDimensions,
+            AuctionDropReason::InvalidPrice,
+            AuctionDropReason::InvalidProviderResponse,
+            AuctionDropReason::InvalidTagType,
+            AuctionDropReason::InvalidUpstreamBidId,
+            AuctionDropReason::LostToHigherBid,
+            AuctionDropReason::MalformedBid,
+            AuctionDropReason::MissingCreativeUrl,
+            AuctionDropReason::MissingRequestContext,
+            AuctionDropReason::MissingUpstreamBidId,
+            AuctionDropReason::MultipleRenderSources,
+            AuctionDropReason::NoRenderSource,
+            AuctionDropReason::RendererExtensionSerializationFailed,
+            AuctionDropReason::RenderPayloadTooLarge,
+            AuctionDropReason::ScriptRenderingDisabled,
+            AuctionDropReason::UnknownImpression,
+            AuctionDropReason::UnsupportedMediaType,
+            AuctionDropReason::UpstreamBidIdTooLarge,
+        ];
+        for reason in reasons {
+            assert_eq!(
+                serde_json::to_value(reason).expect("drop reason should serialize"),
+                json!(reason.as_str()),
+                "serde and diagnostic literal should agree for {reason:?}"
+            );
+        }
+
+        let response = AuctionResponse::no_bid("aps", 12)
+            .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
+        let summary = ProviderSummary::from(&response);
+        assert_eq!(
+            summary.metadata["drop_reasons"]["invalid_provider_response"], 1,
+            "publisher provider-summary projection should retain the typed reason"
+        );
+    }
+
     fn make_bid(bidder: &str) -> Bid {
         Bid {
             slot_id: "slot-1".to_owned(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(1.0),
             currency: "USD".to_owned(),
             creative: None,
@@ -561,6 +1341,9 @@ mod tests {
     fn bid_with_cache_fields_round_trips_through_json() {
         let bid = Bid {
             slot_id: "atf".to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(1.50),
             currency: "USD".to_string(),
             creative: None,
@@ -601,7 +1384,7 @@ mod tests {
 
     #[test]
     fn aps_renderer_serializes_to_versioned_camel_case_contract() {
-        let renderer = BidRenderer::Aps(ApsRendererV1 {
+        let renderer = BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: "example-account-id".to_string(),
             bid_id: "fictional-bid-id".to_string(),
@@ -635,7 +1418,7 @@ mod tests {
 
     #[test]
     fn aps_renderer_omits_absent_creative_id() {
-        let renderer = BidRenderer::Aps(ApsRendererV1 {
+        let renderer = BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: "example-account-id".to_string(),
             bid_id: "fictional-bid-id".to_string(),
@@ -664,10 +1447,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn slot_failure_priority_matches_the_closed_contract() {
+        let ordered = [
+            AuctionSlotFailureReason::InternalError,
+            AuctionSlotFailureReason::MediationFailed,
+            AuctionSlotFailureReason::InvalidProviderResponse,
+            AuctionSlotFailureReason::ProviderError,
+            AuctionSlotFailureReason::ProviderTimeout,
+            AuctionSlotFailureReason::ConsentDenied,
+            AuctionSlotFailureReason::AuctionDisabled,
+            AuctionSlotFailureReason::SlotNotEligible,
+        ];
+
+        assert_eq!(
+            ordered.map(AuctionSlotFailureReason::priority),
+            [0, 1, 2, 3, 4, 5, 6, 7]
+        );
+        assert_eq!(
+            AuctionSlotFailureReason::WinnerNotRenderable.priority(),
+            u8::MAX
+        );
+        assert_eq!(
+            AuctionSlotFailureReason::IdentityGenerationFailed.priority(),
+            u8::MAX
+        );
+    }
+
     #[test]
     fn bid_has_ad_id_field() {
         let bid = Bid {
             slot_id: "s".to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(1.0),
             currency: "USD".to_string(),
             creative: None,
diff --git a/crates/trusted-server-core/src/auth.rs b/crates/trusted-server-core/src/auth.rs
index f5e45bbd3..0f4c2353b 100644
--- a/crates/trusted-server-core/src/auth.rs
+++ b/crates/trusted-server-core/src/auth.rs
@@ -507,9 +507,8 @@ mod tests {
     /// handler covers is the operator's decision, and silently carving holes in
     /// it would be worse than a documented constraint. Operators must scope
     /// handler patterns to the paths they mean (`^/_ts/admin`) — see the
-    /// configuration guide. The tsjs client's `/__ts/page-bids` fallback keeps
-    /// affected deployments serving SPA ads until they do, but it disappears
-    /// with the alias in IABTechLab/trusted-server#970.
+    /// configuration guide. A broad pattern will block the canonical page-bids
+    /// endpoint; the hard-cutover client does not retry a compatibility alias.
     #[test]
     fn broad_handler_regex_also_covers_browser_facing_endpoints() {
         let config = crate_test_settings_str().replace(r#"path = "^/secure""#, r#"path = "^/_ts""#);
diff --git a/crates/trusted-server-core/src/config.rs b/crates/trusted-server-core/src/config.rs
index fb88448a0..be1146796 100644
--- a/crates/trusted-server-core/src/config.rs
+++ b/crates/trusted-server-core/src/config.rs
@@ -440,19 +440,6 @@ mod tests {
     use crate::test_support::tests::crate_test_settings_str;
     use edgezero_core::app_config::AppConfigMeta;
 
-    #[derive(Debug, Deserialize)]
-    #[serde(deny_unknown_fields)]
-    #[allow(dead_code)]
-    struct LegacyCreativeOpportunitiesConfig {
-        gam_network_id: String,
-        #[serde(default)]
-        auction_timeout_ms: Option<u32>,
-        #[serde(default)]
-        price_granularity: serde_json::Value,
-        #[serde(default)]
-        slot: Vec<serde_json::Value>,
-    }
-
     fn app_config_with_creative_opportunities(
         gam_unit_path: Option<&str>,
     ) -> TrustedServerAppConfig {
@@ -461,6 +448,7 @@ mod tests {
             r#"
 
 [creative_opportunities]
+enabled = true
 gam_network_id = "99999"
 
 [[creative_opportunities.slot]]
@@ -811,49 +799,6 @@ formats = [{ width = 300, height = 250 }]
         );
     }
 
-    #[test]
-    fn static_gam_unit_template_is_accepted_by_legacy_schema() {
-        let creative_opportunities = serialized_creative_opportunities(Some("/99999/example/home"));
-
-        serde_json::from_value::<LegacyCreativeOpportunitiesConfig>(creative_opportunities)
-            .expect("should accept static GAM unit template");
-    }
-
-    #[test]
-    fn absent_gam_unit_template_is_accepted_by_legacy_schema() {
-        let creative_opportunities = serialized_creative_opportunities(None);
-
-        assert!(
-            creative_opportunities.get("enabled").is_none(),
-            "default template switch should be omitted for legacy binaries"
-        );
-        serde_json::from_value::<LegacyCreativeOpportunitiesConfig>(creative_opportunities)
-            .expect("should accept absent GAM unit template");
-    }
-
-    #[test]
-    fn disabled_creative_opportunities_flag_is_rejected_by_legacy_schema() {
-        let mut toml = crate_test_settings_str();
-        toml.push_str(
-            r#"
-
-[creative_opportunities]
-enabled = false
-gam_network_id = "99999"
-"#,
-        );
-        let app_config: TrustedServerAppConfig =
-            toml::from_str(&toml).expect("should deserialize app config wrapper");
-        let creative_opportunities = serde_json::to_value(app_config)
-            .expect("should serialize app config wrapper")
-            .get("creative_opportunities")
-            .cloned()
-            .expect("should contain creative opportunities");
-
-        serde_json::from_value::<LegacyCreativeOpportunitiesConfig>(creative_opportunities)
-            .expect_err("legacy binaries should reject an explicit disabled switch");
-    }
-
     #[test]
     fn app_config_new_rejects_empty_secret_key_reference() {
         let mut settings = valid_settings();
diff --git a/crates/trusted-server-core/src/constants.rs b/crates/trusted-server-core/src/constants.rs
index e1152b1e7..828311f12 100644
--- a/crates/trusted-server-core/src/constants.rs
+++ b/crates/trusted-server-core/src/constants.rs
@@ -5,6 +5,7 @@ pub const COOKIE_TS_EC: &str = "ts-ec";
 /// JSON array of Extended User IDs (`[{ source, uids }]`) from identity providers.
 pub const COOKIE_TS_EIDS: &str = "ts-eids";
 pub const COOKIE_TS_TESTER: &str = "ts-tester";
+pub const COOKIE_TS_TRACE: &str = "ts-trace";
 pub const COOKIE_SHAREDID: &str = "sharedId";
 
 pub const HEADER_X_PUB_USER_ID: HeaderName = HeaderName::from_static("x-pub-user-id");
diff --git a/crates/trusted-server-core/src/creative.rs b/crates/trusted-server-core/src/creative.rs
index a4d641bdf..095247142 100644
--- a/crates/trusted-server-core/src/creative.rs
+++ b/crates/trusted-server-core/src/creative.rs
@@ -574,8 +574,8 @@ fn process_auction_creative_with_rewriter(
 /// - 1x1 `<img>` pixels → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
 /// - Non-pixel absolute images → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
 /// - `<iframe src>` (absolute or protocol-relative) → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
-/// - Injects the `tsjs-creative` script once at the top of `<body>` to safeguard click URLs inside creatives
-///   (served from `/static/tsjs=tsjs-creative.min.js`).
+/// - Injects one exact creative boot controller and content-addressed runtime
+///   artifact at the top of `<body>` to safeguard click URLs inside creatives.
 ///
 /// The proxy/click URLs are emitted **root-relative** (`/first-party/…`), which
 /// resolves only when the creative's document base URL is the first-party origin.
@@ -671,6 +671,18 @@ fn rewrite_creative_html_impl(
     if markup.is_empty() {
         return String::new();
     }
+    let creative_tsjs = if inject_tsjs {
+        match tsjs::creative_tsjs_bootstrap_v1(settings) {
+            Ok(bootstrap) => bootstrap,
+            Err(error) => {
+                log::warn!("rewrite_creative_html: invalid TSJS creative bootstrap: {error}");
+                return String::new();
+            }
+        }
+    } else {
+        None
+    };
+    let creative_tsjs = std::rc::Rc::new(creative_tsjs);
     // No size parsing needed now; all absolute/protocol-relative URLs are proxied uniformly.
     let mut out = Vec::with_capacity(markup.len() + 64);
     // Shared with the `body` handler through an `Rc` so the outcome is readable
@@ -698,13 +710,15 @@ fn rewrite_creative_html_impl(
                     el.remove();
                     Ok(())
                 }),
-                // Inject unified tsjs bundle at the top of body once
+                // Inject the exact document-local creative bootstrap at the top of body once.
                 element!("body", {
                     let injected = std::rc::Rc::clone(&injected_ts_creative);
+                    let creative_tsjs = std::rc::Rc::clone(&creative_tsjs);
                     move |el| {
-                        if inject_tsjs && !injected.get() {
-                            let script_tag = tsjs::tsjs_unified_script_tag();
-                            el.prepend(&script_tag, ContentType::Html);
+                        if let Some(bootstrap) = creative_tsjs.as_deref()
+                            && !injected.get()
+                        {
+                            el.prepend(bootstrap, ContentType::Html);
                             injected.set(true);
                         }
                         Ok(())
@@ -922,8 +936,11 @@ fn rewrite_creative_html_impl(
     // Empty output is never injected into: the markup was rejected upstream or
     // rewrote to nothing, and a script-only result would read as an accepted
     // creative that renders blank.
-    if inject_tsjs && !injected_ts_creative.get() && !rewritten.is_empty() {
-        rewritten.insert_str(0, &tsjs::tsjs_unified_script_tag());
+    if let Some(bootstrap) = creative_tsjs.as_deref()
+        && !injected_ts_creative.get()
+        && !rewritten.is_empty()
+    {
+        rewritten.insert_str(0, bootstrap);
         if rewritten.len() > max_output_size {
             log::warn!(
                 "rewrite_creative_html: output exceeds {} byte cap after runtime injection; rejecting",
@@ -1032,6 +1049,7 @@ mod tests {
         process_auction_creative, rewrite_creative_html, rewrite_inline_creative_html,
         rewrite_srcset, rewrite_style_urls, sanitize_creative_html, to_abs,
     };
+    use crate::test_support::tests::bootstrap_transport;
 
     fn rewrite_srcset_attr(attr_name: &str, attr_value: &str) -> String {
         let settings = crate::test_support::tests::create_test_settings();
@@ -1103,8 +1121,25 @@ mod tests {
             out.contains("/static/tsjs=tsjs-unified.min.js"),
             "expected unified tsjs injection: {out}"
         );
-        // Inject only once
-        assert_eq!(out.matches("/static/tsjs=tsjs-unified.min.js").count(), 1);
+        assert!(out.contains("__TSJS_SERVER_BOOT_TRANSPORT_V1__"));
+        let transport = bootstrap_transport(&out);
+        assert_eq!(
+            transport["boot"]["manifest"]["integrations"],
+            serde_json::json!([
+                {"id":"render_runtime","phase":"takeover"},
+                {"id":"creative","phase":"takeover"}
+            ]),
+            "expected exact creative runtime membership: {out}"
+        );
+        assert!(
+            transport["boot"]["manifest"]["integrations"]
+                .as_array()
+                .is_some_and(|entries| entries.iter().all(|entry| entry["id"] != "gpt")),
+            "must not ship GPT into a creative: {out}"
+        );
+        // The source appears in both the authenticated manifest and the tag;
+        // the executable tag itself is still emitted exactly once.
+        assert_eq!(out.matches("id=\"trustedserver-js\"").count(), 1);
     }
 
     #[test]
@@ -1112,7 +1147,7 @@ mod tests {
         let settings = crate::test_support::tests::create_test_settings();
         let html = "<html><body>one</body><body>two</body></html>";
         let out = rewrite_creative_html(&settings, html);
-        assert_eq!(out.matches("/static/tsjs=tsjs-unified.min.js").count(), 1);
+        assert_eq!(out.matches("id=\"trustedserver-js\"").count(), 1);
     }
 
     #[test]
@@ -1789,11 +1824,7 @@ mod tests {
             out.contains("/static/tsjs=tsjs-unified.min.js"),
             "should inject the creative runtime without a body token: {out}"
         );
-        assert_eq!(
-            out.matches("/static/tsjs=tsjs-unified.min.js").count(),
-            1,
-            "should inject exactly once: {out}"
-        );
+        assert_eq!(out.matches("id=\"trustedserver-js\"").count(), 1, "{out}");
         assert!(
             out.contains("/first-party/click?tsurl="),
             "should still rewrite click URLs: {out}"
diff --git a/crates/trusted-server-core/src/creative_opportunities.rs b/crates/trusted-server-core/src/creative_opportunities.rs
index 044d49ed3..55afe5aee 100644
--- a/crates/trusted-server-core/src/creative_opportunities.rs
+++ b/crates/trusted-server-core/src/creative_opportunities.rs
@@ -189,41 +189,14 @@ pub fn derive_section(path: &str, section_root: &str, section_segment: usize) ->
     }
 }
 
-const fn default_enabled() -> bool {
-    true
-}
-
-const fn is_default_enabled(value: &bool) -> bool {
-    *value == default_enabled()
-}
-
-/// How per-user ad state reaches the page.
-///
-/// `Inline` is the shipped behaviour: the auction result is injected before
-/// `</body>` and the root document is therefore uncacheable. `Esi` stores a
-/// request-neutral shared template and fills its per-request byte seam at the edge.
-///
-/// Spike-only, for the #1009 ESI validation. Remove with the spike.
-///
-/// # Why the template must be request-neutral
-///
-/// Under `Esi` the template is shared across visitors, so
-/// nothing whose *presence* depends on the request may appear in it — not merely
-/// nothing whose *value* does. `tsjs.adSlots` is the trap: its content is derived
-/// from config and path, but whether it is emitted at all is gated on consent,
-/// bot classification, prefetch status and the auction kill switch. A template
-/// filled by the first request would freeze that request's decision for every
-/// later reader.
+/// How per-request ad state is assembled into publisher HTML.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AssemblyMode {
-    /// Inject bids inline before `</body>`. Root uncacheable. Shipped behaviour.
+    /// Inject the request projection into the transformed response directly.
     #[default]
     Inline,
-    /// Serve a shared template; assemble its inert marker with an exact byte split.
-    ///
-    /// The operator-facing spelling remains `esi` for continuity, but no general
-    /// purpose ESI parser executes on this path.
+    /// Store a reader-neutral template and fill its single inert byte seam.
     Esi,
 }
 
@@ -231,14 +204,10 @@ pub enum AssemblyMode {
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct CreativeOpportunitiesConfig {
-    /// Enables server-side ad template delivery on publisher HTML and page-bids requests.
+    /// Enables template delivery on publisher HTML and page-bids requests.
     ///
-    /// This does not disable the direct `POST /auction` endpoint. The default is
-    /// `true` so existing creative-opportunity configurations retain their behavior.
-    #[serde(
-        default = "default_enabled",
-        skip_serializing_if = "is_default_enabled"
-    )]
+    /// This switch does not disable direct `POST /auction`. It is required in
+    /// the hard-cutover schema so an operator must choose the delivery state.
     pub enabled: bool,
     /// GAM network ID used to build default unit paths.
     pub gam_network_id: String,
@@ -297,15 +266,7 @@ pub struct CreativeOpportunitiesConfig {
     /// [`section_root`](Self::section_root) are omitted.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub section_segment: Option<usize>,
-    /// How per-user ad state reaches the page. Absent means
-    /// [`AssemblyMode::Inline`], the shipped behaviour.
-    ///
-    /// `Option` rather than a bare enum, and `skip_serializing_if`, deliberately:
-    /// these structs use `deny_unknown_fields`, so a pushed key makes an older
-    /// binary fail configuration load. Keeping it absent when unset means a
-    /// deployment that never sets it stays rollback-compatible.
-    ///
-    /// Spike-only. See [`AssemblyMode`].
+    /// How per-request state is delivered. Absent resolves to inline assembly.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub assembly_mode: Option<AssemblyMode>,
     /// Request headers the origin varies on, which the shared-template cache key must
@@ -325,34 +286,13 @@ pub struct CreativeOpportunitiesConfig {
     /// Spike-only. Same `Option` + `skip_serializing_if` reasoning as `assembly_mode`.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub template_cache_vary: Option<Vec<String>>,
-    /// Maximum time a reader-neutral transformed template may remain in the shared template cache.
-    ///
-    /// This is a safety ceiling, not freshness authorization. The origin must still
-    /// provide positive shared freshness, and the stored lifetime is the smaller of
-    /// the origin's remaining edge freshness and this value. Defaults to 60 seconds
-    /// and may be configured from 1 second through 1 day.
-    ///
-    /// Spike-only. Same `Option` + `skip_serializing_if` reasoning as `assembly_mode`.
+    /// Safety ceiling for one shared transformed-template cache entry.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub template_cache_max_age_seconds: Option<u32>,
-    /// Operator assertion that the origin's HTML does not depend on request cookies.
-    ///
-    /// Unset or `false` disqualifies **every cookie-bearing request** from the shared
-    /// template cache, in both directions. That is safe and it is also very nearly a
-    /// disable switch: Trusted Server sets its own identity cookie, so essentially every
-    /// repeat visitor carries one. Left at the default, the cache can only ever serve
-    /// first-ever page views and cookie-less clients.
-    ///
-    /// Setting `true` asserts the origin serves the same HTML with or without cookies.
-    /// It is not taken on trust alone — if the origin ever declares `Vary: Cookie`, the
-    /// response is refused regardless of this flag or the configured key. So a wrong
-    /// assertion is caught whenever the origin is honest about it, and this only widens
-    /// the window where the origin personalizes *silently*.
-    ///
-    /// Spike-only. Same `Option` + `skip_serializing_if` reasoning as `assembly_mode`.
+    /// Whether cookie-bearing requests may use a reader-neutral template.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub origin_is_cookie_independent: Option<bool>,
-    /// Slot templates. An empty vec or `enabled = false` disables template delivery.
+    /// Slot templates. Empty vec = no matching template work.
     #[serde(default, deserialize_with = "vec_from_seq_or_map")]
     pub slot: Vec<CreativeOpportunitySlot>,
 }
@@ -1648,32 +1588,6 @@ mod tests {
         assert_eq!(derive_section("/%%%/x", "home", 0), "_");
     }
 
-    #[test]
-    fn enabled_defaults_true_and_is_omitted_from_serialized_config() {
-        let config = make_config_with_section_template(None);
-        assert!(
-            config.enabled,
-            "template delivery should default to enabled"
-        );
-        let value = serde_json::to_value(&config).expect("should serialize config");
-        assert!(
-            value.get("enabled").is_none(),
-            "default enabled value should be omitted for rollback compatibility"
-        );
-    }
-
-    #[test]
-    fn disabled_template_switch_is_serialized() {
-        let mut config = make_config_with_section_template(None);
-        config.enabled = false;
-        let value = serde_json::to_value(&config).expect("should serialize config");
-        assert_eq!(
-            value.get("enabled"),
-            Some(&serde_json::Value::Bool(false)),
-            "explicitly disabled template delivery must remain in config blobs"
-        );
-    }
-
     fn make_config_with_section_template(
         section_root: Option<&str>,
     ) -> CreativeOpportunitiesConfig {
@@ -2067,14 +1981,13 @@ mod tests {
 
     #[test]
     fn validate_runtime_allows_blank_network_id_when_no_slots_configured() {
-        // An empty slot list disables the feature, so the id is never rendered.
-        // Failing startup there would break a deploy over an unused value.
+        // With no slot definitions, the network id is not consumed.
         let mut config = make_config_with_section_template(Some("home"));
         config.gam_network_id = String::new();
         config.slot.clear();
         config
             .validate_runtime()
-            .expect("a disabled creative_opportunities stack should not fail on a blank id");
+            .expect("an unused creative_opportunities network id should not fail validation");
     }
 
     #[test]
@@ -2401,13 +2314,21 @@ mod tests {
     fn config_rejects_unknown_top_level_key() {
         // A typo such as `slots` instead of `slot` must surface as a config
         // error rather than silently deserializing to an empty (disabled) stack.
-        let typo = serde_json::json!({ "gam_network_id": "12345", "slots": [] });
+        let typo = serde_json::json!({
+            "enabled": true,
+            "gam_network_id": "12345",
+            "slots": []
+        });
         assert!(
             serde_json::from_value::<CreativeOpportunitiesConfig>(typo).is_err(),
             "unknown top-level key should be rejected by deny_unknown_fields"
         );
 
-        let correct = serde_json::json!({ "gam_network_id": "12345", "slot": [] });
+        let correct = serde_json::json!({
+            "enabled": true,
+            "gam_network_id": "12345",
+            "slot": []
+        });
         assert!(
             serde_json::from_value::<CreativeOpportunitiesConfig>(correct).is_ok(),
             "the correct `slot` key should still deserialize"
@@ -2440,8 +2361,9 @@ mod tests {
 
     #[test]
     fn assembly_mode_defaults_to_inline_when_absent() {
-        // Arrange: the minimal config an existing deployment would have.
+        // Arrange: the minimal hard-cutover config without an assembly mode.
         let toml = r#"
+            enabled = true
             gam_network_id = "99999"
         "#;
 
@@ -2461,11 +2383,79 @@ mod tests {
         );
     }
 
+    #[test]
+    fn creative_opportunities_enabled_is_required() {
+        let missing = r#"
+            gam_network_id = "99999"
+        "#;
+        assert!(
+            toml::from_str::<CreativeOpportunitiesConfig>(missing).is_err(),
+            "hard-cutover configuration must reject a present table without `enabled`"
+        );
+
+        for enabled in [true, false] {
+            let config: CreativeOpportunitiesConfig = toml::from_str(&format!(
+                r#"
+                    enabled = {enabled}
+                    gam_network_id = "99999"
+                "#
+            ))
+            .unwrap_or_else(|error| panic!("explicit enabled={enabled} should parse: {error}"));
+            assert_eq!(config.enabled, enabled);
+        }
+    }
+
+    #[test]
+    fn disabled_creative_opportunities_still_validate_every_field() {
+        let invalid_slot: CreativeOpportunitiesConfig = toml::from_str(
+            r#"
+                enabled = false
+                gam_network_id = "99999"
+
+                [[slot]]
+                id = "invalid-pattern"
+                page_patterns = ["["]
+                formats = [{ width = 300, height = 250 }]
+            "#,
+        )
+        .expect("disabled slot shape should deserialize before runtime validation");
+        assert!(
+            invalid_slot.validate_runtime().is_err(),
+            "disabled delivery must not bypass slot validation"
+        );
+
+        let invalid_cache: CreativeOpportunitiesConfig = toml::from_str(
+            r#"
+                enabled = false
+                gam_network_id = "99999"
+                template_cache_vary = ["not a header"]
+            "#,
+        )
+        .expect("disabled cache shape should deserialize before runtime validation");
+        assert!(
+            invalid_cache.validate_runtime().is_err(),
+            "disabled delivery must not bypass cache-field validation"
+        );
+
+        assert!(
+            toml::from_str::<CreativeOpportunitiesConfig>(
+                r#"
+                    enabled = false
+                    gam_network_id = "99999"
+                    assembly_mode = "client_fill"
+                "#,
+            )
+            .is_err(),
+            "disabled delivery must not bypass assembly-mode parsing"
+        );
+    }
+
     #[test]
     fn assembly_mode_deserializes_each_variant() {
         for (raw, expected) in [("inline", AssemblyMode::Inline), ("esi", AssemblyMode::Esi)] {
             let toml = format!(
                 r#"
+                    enabled = true
                     gam_network_id = "99999"
                     assembly_mode = "{raw}"
                 "#
@@ -2480,6 +2470,7 @@ mod tests {
         }
 
         let removed_mode = r#"
+            enabled = true
             gam_network_id = "99999"
             assembly_mode = "client_fill"
         "#;
@@ -2493,6 +2484,7 @@ mod tests {
     fn template_cache_vary_rejects_invalid_header_names() {
         let config: CreativeOpportunitiesConfig = toml::from_str(
             r#"
+                enabled = true
                 gam_network_id = "99999"
                 template_cache_vary = ["rsc", "not a header"]
             "#,
@@ -2505,6 +2497,7 @@ mod tests {
 
         let cookie_key: CreativeOpportunitiesConfig = toml::from_str(
             r#"
+                enabled = true
                 gam_network_id = "99999"
                 template_cache_vary = ["Cookie"]
             "#,
@@ -2518,6 +2511,7 @@ mod tests {
         for name in ["Authorization", "aUtHoRiZaTiOn"] {
             let authorization_key: CreativeOpportunitiesConfig = toml::from_str(&format!(
                 r#"
+                    enabled = true
                     gam_network_id = "99999"
                     template_cache_vary = ["{name}"]
                 "#,
@@ -2535,6 +2529,7 @@ mod tests {
         for seconds in [1_u32, 1_200, 86_400] {
             let config: CreativeOpportunitiesConfig = toml::from_str(&format!(
                 r#"
+                    enabled = true
                     gam_network_id = "99999"
                     template_cache_max_age_seconds = {seconds}
                 "#
@@ -2560,6 +2555,7 @@ mod tests {
         for seconds in [0_u32, 86_401] {
             let config: CreativeOpportunitiesConfig = toml::from_str(&format!(
                 r#"
+                    enabled = true
                     gam_network_id = "99999"
                     template_cache_max_age_seconds = {seconds}
                 "#
@@ -2577,9 +2573,10 @@ mod tests {
     }
 
     #[test]
-    fn unset_template_cache_max_age_is_omitted_for_rollback_compatibility() {
+    fn unset_template_cache_max_age_is_omitted_from_serialized_config() {
         let config: CreativeOpportunitiesConfig =
-            toml::from_str("gam_network_id = \"99999\"").expect("should deserialize");
+            toml::from_str("enabled = true\ngam_network_id = \"99999\"")
+                .expect("should deserialize");
 
         assert_eq!(
             config.template_cache_max_age(),
@@ -2590,17 +2587,16 @@ mod tests {
 
         assert!(
             !serialized.contains("template_cache_max_age_seconds"),
-            "an unset new key must not break rollback to an older binary: {serialized}"
+            "an unset cache ceiling should remain absent: {serialized}"
         );
     }
 
     #[test]
     fn unset_assembly_mode_is_omitted_from_serialized_config() {
-        // `deny_unknown_fields` means a pushed key breaks config load on an older
-        // binary. A deployment that never sets this must not gain the key just by
-        // round-tripping through a newer one.
+        // A deployment that never sets this should not gain it by round-tripping.
         let config: CreativeOpportunitiesConfig =
-            toml::from_str("gam_network_id = \"99999\"").expect("should deserialize");
+            toml::from_str("enabled = true\ngam_network_id = \"99999\"")
+                .expect("should deserialize");
 
         let serialized = toml::to_string(&config).expect("should serialize");
 
diff --git a/crates/trusted-server-core/src/html_processor.rs b/crates/trusted-server-core/src/html_processor.rs
index 62ecab229..00f8c508a 100644
--- a/crates/trusted-server-core/src/html_processor.rs
+++ b/crates/trusted-server-core/src/html_processor.rs
@@ -20,7 +20,6 @@ use crate::integrations::{
     IntegrationHtmlContext, IntegrationHtmlPostProcessor, IntegrationRegistry,
     IntegrationScriptContext, ScriptRewriteAction,
 };
-use crate::publisher::build_empty_bids_script;
 use crate::settings::Settings;
 use crate::streaming_processor::{HtmlRewriterAdapter, StreamProcessor};
 use crate::tsjs;
@@ -54,6 +53,7 @@ struct HtmlWithPostProcessing {
     origin_host: String,
     request_host: String,
     request_scheme: String,
+    csp_nonce: Option<String>,
     document_state: IntegrationDocumentState,
 }
 
@@ -108,6 +108,7 @@ impl StreamProcessor for HtmlWithPostProcessing {
             request_host: &self.request_host,
             request_scheme: &self.request_scheme,
             origin_host: &self.origin_host,
+            csp_nonce: self.csp_nonce.as_deref(),
             document_state: &self.document_state,
         };
 
@@ -167,12 +168,9 @@ impl StreamProcessor for HtmlWithPostProcessing {
 /// §6.7.
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub enum BodyCloseInjection {
-    /// Emit nothing because no slots matched under the inline path.
+    /// Emit nothing on the inline path.
     #[default]
     None,
-    /// Read the auction result from `ad_bids_state` and inject it, falling back to
-    /// an empty payload. Today's shipped behaviour.
-    InlineBids,
     /// Emit this markup verbatim — an inert marker the assembly step splits on.
     /// Must be identical for every request that reaches the transform, or the
     /// cached template is not shared-safe.
@@ -186,12 +184,12 @@ pub struct HtmlProcessorConfig {
     pub request_host: String,
     pub request_scheme: String,
     pub integrations: IntegrationRegistry,
-    /// Pre-computed `<script>(window.tsjs=window.tsjs||{}).adSlots=...;</script>`.
-    /// Injected at `<head>` open. `None` when no slots matched.
+    /// Pre-computed canonical browser-slot JSON used to build the immutable boot
+    /// auction projection. `None` when no slots matched.
     pub ad_slots_script: Option<String>,
     /// Shared auction result — written by auction task before HTML processing begins.
     /// Handler reads this in `el.on_end_tag()` on the body element.
-    /// `None` means no auction ran; inject empty `tsjs.bids = {}` as fallback.
+    /// `None` means no auction ran; inject an empty boot auction projection.
     pub ad_bids_state: std::sync::Arc<std::sync::Mutex<Option<String>>>,
     /// Maximum bytes the post-processing accumulator may buffer before the
     /// processor aborts. Mirrors `publisher.max_buffered_body_bytes` so the
@@ -199,16 +197,16 @@ pub struct HtmlProcessorConfig {
     pub max_buffered_body_bytes: usize,
     /// Request-scoped conditional diagnostics delivery decision.
     pub gpt_diagnostics: Option<GptDiagnosticsRequestDecision>,
-    /// What the `</body>` seam injects. Decided by the caller rather than inferred
-    /// from [`Self::ad_slots_script`].
+    /// What the `</body>` seam injects for shared-template assembly.
     pub body_close: BodyCloseInjection,
+    /// Server-owned request-scoped render-trace overlay decision.
+    pub render_trace_overlay: bool,
     /// Whether to omit Trusted Server's automatic `DataDome` client-side tag.
     pub suppress_datadome_client_side_tag: bool,
-    /// Set when the document delivers a response-bound CSP nonce in its own markup.
-    ///
-    /// `None` on every path that cannot store a shared template, so an ordinary inline
-    /// request does not pay for handlers whose only consumer is the template-cache gate.
+    /// Set when publisher markup contains a response-bound CSP nonce.
     pub csp_nonce_observed: Option<Arc<AtomicBool>>,
+    /// Unique nonce admitted by the response's enforcing CSP headers, if any.
+    pub csp_nonce: Option<String>,
 }
 
 impl HtmlProcessorConfig {
@@ -231,8 +229,10 @@ impl HtmlProcessorConfig {
             max_buffered_body_bytes: settings.publisher.max_buffered_body_bytes,
             gpt_diagnostics: None,
             body_close: BodyCloseInjection::None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
             csp_nonce_observed: None,
+            csp_nonce: None,
         }
     }
 
@@ -272,16 +272,27 @@ impl HtmlProcessorConfig {
         self
     }
 
-    /// Watch the document for a response-bound CSP nonce delivered in its own markup.
-    ///
-    /// Pass `Some` only when the completed transform may be stored as a shared template;
-    /// nothing else reads the observation.
+    /// Watch publisher markup for response-bound CSP nonces before template storage.
     #[must_use]
     pub fn with_csp_nonce_observer(mut self, observed: Option<Arc<AtomicBool>>) -> Self {
         self.csp_nonce_observed = observed;
         self
     }
 
+    /// Attach the exact response-header CSP nonce to Trusted Server script tags.
+    #[must_use]
+    pub fn with_csp_nonce(mut self, nonce: Option<String>) -> Self {
+        self.csp_nonce = nonce;
+        self
+    }
+
+    /// Attach the server-owned request-scoped render-trace overlay decision.
+    #[must_use]
+    pub fn with_render_trace_overlay(mut self, active: bool) -> Self {
+        self.render_trace_overlay = active;
+        self
+    }
+
     /// Attach the request-scoped `DataDome` client-tag suppression decision.
     #[must_use]
     pub fn with_datadome_client_tag_suppression(mut self, suppress: bool) -> Self {
@@ -368,13 +379,14 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
     });
 
     let injected_tsjs = Rc::new(Cell::new(false));
-    let injected_bids = Arc::new(AtomicBool::new(false));
+    let injected_body_close = Arc::new(AtomicBool::new(false));
     let integration_registry = config.integrations.clone();
     let script_rewriters = integration_registry.script_rewriters();
-    let ad_slots_script = config.ad_slots_script.clone();
-    let body_close = config.body_close.clone();
     let ad_bids_state = config.ad_bids_state.clone();
     let gpt_diagnostics = config.gpt_diagnostics.clone();
+    let body_close = config.body_close.clone();
+    let render_trace_overlay = config.render_trace_overlay;
+    let csp_nonce = config.csp_nonce.clone();
 
     // No source-comment neutralization here: rewriting a publisher comment that happens
     // to match the reserved marker would change publisher content bytes. Collisions are
@@ -383,13 +395,13 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
     let mut document_content_handlers = Vec::new();
     if let BodyCloseInjection::Marker(marker) = &body_close {
         let marker = marker.clone();
-        let injected_bids = Arc::clone(&injected_bids);
+        let injected_body_close = Arc::clone(&injected_body_close);
         document_content_handlers.push(end!(move |document_end| {
             // HTML fragments and malformed-but-renderable documents may never expose a
             // body end tag. Always mint a transform-owned terminal seam in that case;
             // otherwise source bytes equal to the reserved marker could be mistaken for
             // ownership by the post-transform exact-count validator.
-            if !injected_bids.swap(true, Ordering::SeqCst) {
+            if !injected_body_close.swap(true, Ordering::SeqCst) {
                 document_end.append(&marker, ContentType::Html);
             }
             Ok(())
@@ -403,111 +415,136 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
             let integrations = integration_registry.clone();
             let patterns = patterns.clone();
             let document_state = document_state.clone();
-            let ad_slots_script = ad_slots_script.clone();
+            let ad_bids_state = ad_bids_state.clone();
             let gpt_diagnostics = gpt_diagnostics.clone();
+            let body_close = body_close.clone();
+            let csp_nonce = csp_nonce.clone();
             move |el| {
                 if !injected_tsjs.get() {
-                    let mut snippet = String::new();
-                    // Inject ad slots script first so it appears before tsjs bundle.
-                    if let Some(ref slots_script) = ad_slots_script {
-                        snippet.push_str(slots_script);
+                    // A shared C2 template must contain no request-scoped boot
+                    // data. Its single inert marker receives the complete boot
+                    // fragment during per-reader assembly at the body seam.
+                    if matches!(body_close, BodyCloseInjection::Marker(_)) {
+                        return Ok(());
+                    }
+                    let mut interstitial = String::new();
+                    // The server has already interpreted and removed the reserved
+                    // directive. This request-scoped inline cleanup only updates the
+                    // browser-visible URL and must run before publisher/core code.
+                    if let Some(cleanup_tag) = gpt_diagnostics
+                        .as_ref()
+                        .and_then(|decision| decision.url_cleanup_script_tag(csp_nonce.as_deref()))
+                    {
+                        interstitial.push_str(&cleanup_tag);
                     }
                     let ctx = IntegrationHtmlContext {
                         request_host: &patterns.request_host,
                         request_scheme: &patterns.request_scheme,
                         origin_host: &patterns.origin_host,
+                        csp_nonce: csp_nonce.as_deref(),
                         document_state: &document_state,
                     };
-                    // First inject integration-specific config (e.g., window.__tsjs_prebid)
-                    // so it's available when the bundle's auto-init code reads it.
-                    for insert in integrations.head_inserts(&ctx) {
-                        snippet.push_str(&insert);
-                    }
-                    if let Some(bootstrap) = gpt_diagnostics
+                    let diagnostics_requested = gpt_diagnostics
                         .as_ref()
-                        .and_then(GptDiagnosticsRequestDecision::bootstrap_script)
+                        .is_some_and(GptDiagnosticsRequestDecision::active);
+                    let creative = integrations.tsjs_creative_boot();
+                    let selection = crate::integrations::TsjsCatalogSelectionV1 {
+                        creative_enabled: creative.enabled,
+                        creative_click_guard: creative.click_guard,
+                        creative_render_guard: creative.render_guard,
+                        gpt_diagnostics_active: diagnostics_requested,
+                        render_trace_overlay,
+                    };
+                    let manifest_ids = integrations.tsjs_catalog_module_ids(selection);
+                    let diagnostics_active = manifest_ids.contains(&"gpt_diagnostics");
+                    let integration_configs = match integrations
+                        .tsjs_integration_configs_v1(&manifest_ids)
                     {
-                        snippet.push_str(&bootstrap);
+                        Ok(configs) => configs,
+                        Err(error) => {
+                            log::error!("invalid TSJS integration config projection: {error:?}");
+                            return Ok(());
+                        }
+                    };
+                    let state = ad_bids_state
+                        .lock()
+                        .expect("should lock boot projection state");
+                    let state_value = state.as_deref();
+                    let (debug_comment, projection_json) = match state_value {
+                        Some(value) if value.starts_with("<!-- ts-debug:") => {
+                            value.rsplit_once('\n').map_or(
+                                (Some(value), tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1),
+                                |(debug, json)| (Some(debug), json),
+                            )
+                        }
+                        Some(value) => (None, value),
+                        None => (None, tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1),
+                    };
+                    if let Some(debug_comment) = debug_comment {
+                        interstitial.push_str(debug_comment);
+                        interstitial.push('\n');
                     }
-                    // Main bundle: core + non-deferred integrations (synchronous).
-                    let immediate_ids = integrations.js_module_ids_immediate();
-                    let script_attributes = integrations.tsjs_script_tag_attributes();
-                    snippet.push_str(&tsjs::tsjs_script_tag_with_attributes(
-                        &immediate_ids,
-                        &script_attributes,
-                    ));
-                    // Active diagnostics loads synchronously after core so its
-                    // GPT listeners precede publisher scripts in the origin head.
-                    if let Some(module_tag) = gpt_diagnostics
-                        .as_ref()
-                        .and_then(GptDiagnosticsRequestDecision::module_script_tag)
-                    {
-                        snippet.push_str(&module_tag);
+                    // Non-TSJS vendor tags remain ordinary integration head inserts.
+                    for insert in integrations.head_inserts(&ctx) {
+                        interstitial.push_str(&insert);
                     }
-                    // Deferred bundles: large modules like prebid loaded after
-                    // HTML parsing completes. Empty when none are enabled.
-                    let deferred_ids = integrations.js_module_ids_deferred();
-                    snippet.push_str(&tsjs::tsjs_deferred_script_tags(&deferred_ids));
-                    el.prepend(&snippet, ContentType::Html);
+                    let publisher_origin = patterns.replacement_url();
+                    let boot = tsjs::tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(
+                        tsjs::TsjsBootScriptConfigV1 {
+                            module_ids: &manifest_ids,
+                            integration_configs: &integration_configs,
+                            auction_projection_json: projection_json,
+                            creative,
+                            render_trace_overlay,
+                            gpt_diagnostics_active: diagnostics_active,
+                        },
+                        &publisher_origin,
+                        csp_nonce.as_deref(),
+                        &interstitial,
+                    )
+                    .or_else(|error| {
+                        log::error!("invalid TSJS document boot projection: {error:?}");
+                        tsjs::tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(
+                            tsjs::TsjsBootScriptConfigV1 {
+                                module_ids: &manifest_ids,
+                                integration_configs: &integration_configs,
+                                auction_projection_json: tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1,
+                                creative,
+                                render_trace_overlay,
+                                gpt_diagnostics_active: diagnostics_active,
+                            },
+                            &publisher_origin,
+                            csp_nonce.as_deref(),
+                            &interstitial,
+                        )
+                    })
+                    .unwrap_or_default();
+                    el.prepend(&boot, ContentType::Html);
                     injected_tsjs.set(true);
                 }
                 Ok(())
             }
         }),
-        // Inject tsjs.bids before </body> via end_tag_handlers — only when
-        // slots matched this URL. When no slots matched, skip injection entirely
-        // so the publisher's existing client-side Prebid/GPT flow is unmodified
-        // (dual-mode rollout: calling tsjs.adInit with empty slots would invoke
-        // enableSingleRequest/enableServices and conflict with the publisher's GPT init).
-        // Guard with AtomicBool so the script is only injected once even if
-        // the origin HTML contains multiple <body> elements (e.g. template fragments).
+        // Emit the shared-template marker immediately before the first body end
+        // tag. A document-end handler above provides the malformed-HTML fallback.
         element!("body", {
-            let state = ad_bids_state.clone();
-            let injected_bids = injected_bids.clone();
             let body_close = body_close.clone();
+            let injected_body_close = Arc::clone(&injected_body_close);
             move |el| {
-                if matches!(body_close, BodyCloseInjection::None) {
+                let BodyCloseInjection::Marker(marker) = &body_close else {
                     return Ok(());
-                }
-                let state = state.clone();
-                let injected_bids = injected_bids.clone();
-                let body_close = body_close.clone();
+                };
                 if let Some(handlers) = el.end_tag_handlers() {
+                    let marker = marker.clone();
+                    let injected_body_close = Arc::clone(&injected_body_close);
                     let handler: EndTagHandler<'static> =
                         Box::new(move |end_tag: &mut EndTag<'_>| {
-                            if injected_bids.swap(true, Ordering::SeqCst) {
-                                return Ok(());
+                            if !injected_body_close.swap(true, Ordering::SeqCst) {
+                                end_tag.before(&marker, ContentType::Html);
                             }
-                            let markup = match &body_close {
-                                // Verbatim, and identical on every request that
-                                // reaches the transform — that is what makes the
-                                // cached template shared-safe.
-                                BodyCloseInjection::Marker(marker) => marker.clone(),
-                                BodyCloseInjection::InlineBids => {
-                                    let script_guard = state.lock().expect("should lock bid state");
-                                    match &*script_guard {
-                                        Some(s) => s.clone(),
-                                        None => build_empty_bids_script(),
-                                    }
-                                }
-                                // Unreachable: the element handler returned early
-                                // above. Kept exhaustive rather than using `_` so a
-                                // new variant is a compile error here.
-                                BodyCloseInjection::None => return Ok(()),
-                            };
-                            end_tag.before(&markup, ContentType::Html);
                             Ok(())
                         });
                     handlers.push(handler);
-                } else if matches!(body_close, BodyCloseInjection::InlineBids) {
-                    // No end tag (implicitly closed or EOF `<body>`): lol_html
-                    // cannot attach an end-tag handler, so tsjs.bids/adInit() are
-                    // never injected even though adSlots was injected at `<head>`.
-                    // The whole server-side ad feature then silently fails to
-                    // render — warn so the failure is diagnosable.
-                    log::warn!(
-                        "`<body>` has no end tag (implicitly closed or EOF); tsjs.bids and adInit() were not injected — server-side ads will not render"
-                    );
                 }
                 Ok(())
             }
@@ -798,6 +835,7 @@ pub fn create_html_processor(config: HtmlProcessorConfig) -> impl StreamProcesso
         origin_host: config.origin_host,
         request_host: config.request_host,
         request_scheme: config.request_scheme,
+        csp_nonce: config.csp_nonce,
         document_state,
     }
 }
@@ -810,7 +848,7 @@ mod tests {
         IntegrationHeadInjector, IntegrationHtmlContext,
     };
     use crate::streaming_processor::{Compression, PipelineConfig, StreamingPipeline};
-    use crate::test_support::tests::create_test_settings;
+    use crate::test_support::tests::{bootstrap_transport, create_test_settings};
     use serde_json::json;
     use std::io::Cursor;
     use std::sync::Arc;
@@ -823,6 +861,7 @@ mod tests {
     fn create_test_config() -> HtmlProcessorConfig {
         HtmlProcessorConfig {
             csp_nonce_observed: None,
+            csp_nonce: None,
             body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_owned(),
             request_host: "test.example.com".to_owned(),
@@ -832,6 +871,7 @@ mod tests {
             ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(None)),
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         }
     }
@@ -891,7 +931,7 @@ mod tests {
     }
 
     #[test]
-    fn integration_head_injector_prepends_after_tsjs_once() {
+    fn controller_precedes_live_head_inserts_which_precede_selected_runtime() {
         struct TestHeadInjector;
 
         impl IntegrationHeadInjector for TestHeadInjector {
@@ -899,14 +939,18 @@ mod tests {
                 "test"
             }
 
-            fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-                vec!["<script>window.__testHeadInjector=true;</script>".to_owned()]
+            fn head_inserts(&self, ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
+                let nonce = ctx.csp_nonce.expect("should receive response CSP nonce");
+                vec![format!(
+                    "<script nonce=\"{nonce}\">window.__testHeadInjector=true;</script>"
+                )]
             }
         }
 
         let html = "<html><head><title>Test</title></head><body></body></html>";
 
         let mut config = create_test_config();
+        config.csp_nonce = Some("response-nonce_123=".to_owned());
         config.integrations = IntegrationRegistry::from_rewriters_with_head_injectors(
             Vec::new(),
             Vec::new(),
@@ -928,7 +972,9 @@ mod tests {
         let processed = String::from_utf8(output).expect("output should be valid UTF-8");
 
         let tsjs_marker = "id=\"trustedserver-js\"";
+        let controller_marker = "const __TSJS_SERVER_BOOT_TRANSPORT_V1__=";
         let head_marker = "window.__testHeadInjector=true";
+        let nonce_marker = "<script nonce=\"response-nonce_123=\">window.__testHeadInjector=true";
 
         assert_eq!(
             processed.matches(tsjs_marker).count(),
@@ -940,6 +986,10 @@ mod tests {
             1,
             "should inject head snippet once"
         );
+        assert!(
+            processed.contains(nonce_marker),
+            "server-generated integration scripts must share the response CSP nonce"
+        );
 
         let tsjs_index = processed
             .find(tsjs_marker)
@@ -947,13 +997,20 @@ mod tests {
         let head_index = processed
             .find(head_marker)
             .expect("should include head snippet");
+        let controller_index = processed
+            .find(controller_marker)
+            .expect("should include the bootstrap controller");
         let title_index = processed
             .find("<title>")
             .expect("should keep existing head content");
 
+        assert!(
+            controller_index < head_index,
+            "the authenticated controller must run before any live integration insert"
+        );
         assert!(
             head_index < tsjs_index,
-            "should inject config before tsjs bundle so auto-init can read it"
+            "live upstream tags must remain before the selected parser runtime"
         );
         assert!(
             tsjs_index < title_index,
@@ -962,83 +1019,17 @@ mod tests {
     }
 
     #[test]
-    fn integration_head_injector_marks_only_attribution_enabled_gpt_bundle() {
-        fn process(gpt_config: Option<(bool, bool)>) -> String {
-            let integrations = if let Some((enabled, gam_attribution_enabled)) = gpt_config {
-                let mut settings = create_test_settings();
-                settings
-                    .integrations
-                    .insert_config(
-                        "gpt",
-                        &json!({
-                            "enabled": enabled,
-                            "gam_attribution_enabled": gam_attribution_enabled
-                        }),
-                    )
-                    .expect("should insert GPT config");
-                IntegrationRegistry::new(&settings).expect("should build GPT registry")
-            } else {
-                IntegrationRegistry::empty_for_tests()
-            };
-            let mut config = create_test_config();
-            config.integrations = integrations;
-            let mut processor = create_html_processor(config);
-            let output = processor
-                .process_chunk(b"<html><head></head><body></body></html>", true)
-                .expect("should process HTML");
-
-            String::from_utf8(output).expect("should produce valid UTF-8")
-        }
-
-        let attributed = process(Some((true, true)));
-        let unattributed = process(Some((true, false)));
-        let disabled_gpt = process(Some((false, true)));
-        let without_gpt = process(None);
-
-        for html in [&attributed, &unattributed, &disabled_gpt, &without_gpt] {
-            assert_eq!(
-                html.matches("id=\"trustedserver-js\"").count(),
-                1,
-                "should emit exactly one publisher bundle tag: {html}"
-            );
-        }
-        assert!(
-            attributed.contains("data-ts-gam-attribution=\"true\""),
-            "should mark only an attribution-enabled GPT publisher bundle"
-        );
-        assert!(
-            !unattributed.contains("data-ts-gam-attribution"),
-            "should leave an attribution-disabled GPT publisher bundle unmarked"
-        );
-        assert!(
-            !disabled_gpt.contains("data-ts-gam-attribution"),
-            "should let the GPT master switch suppress attribution metadata"
-        );
-        assert!(
-            !without_gpt.contains("data-ts-gam-attribution"),
-            "should leave a non-GPT publisher bundle unmarked"
-        );
-
-        let head_insert_index = attributed
-            .find("window.__tsjs_installGptShim")
-            .expect("should include the GPT head insert");
-        let publisher_bundle_index = attributed
-            .find("id=\"trustedserver-js\"")
-            .expect("should include the publisher bundle");
-        assert!(
-            head_insert_index < publisher_bundle_index,
-            "should keep integration head inserts before the publisher bundle"
-        );
-    }
-
-    #[test]
-    fn active_gpt_diagnostics_loads_standalone_after_unified_bundle_once() {
+    fn active_gpt_diagnostics_uses_unified_transport_and_inline_url_cleanup() {
         let html = "<html><head><title>Test</title></head><body></body></html>";
         let mut settings = create_test_settings();
         settings
             .integrations
             .insert_config("gpt_diagnostics", &json!({ "enabled": true }))
             .expect("should insert GPT diagnostics config");
+        settings
+            .integrations
+            .insert_config("gpt", &json!({}))
+            .expect("should insert the GPT event provider config");
 
         let mut request = http::Request::builder()
             .method(http::Method::GET)
@@ -1073,42 +1064,138 @@ mod tests {
             .process(Cursor::new(html.as_bytes()), &mut output)
             .expect("should process HTML");
         let processed = String::from_utf8(output).expect("should produce valid UTF-8");
-        let bootstrap_marker = "__tsjs_gpt_diagnostics_active";
         let bundle_marker = "id=\"trustedserver-js\"";
-        let diagnostics_marker = "tsjs-gpt_diagnostics.min.js";
+        let diagnostics_script_marker = "tsjs-gpt_diagnostics.min.js";
+        let cleanup_asset_marker = "tsjs-gpt_diagnostics-bootstrap.min.js";
+        let cleanup_program_marker = "history.replaceState";
 
         assert_eq!(
-            processed.matches(bootstrap_marker).count(),
-            1,
-            "should inject the diagnostics bootstrap once"
+            processed.matches("__tsjs_gpt_diagnostics_active").count(),
+            0,
+            "server boot data must be the only browser-visible activation result"
         );
         assert_eq!(
             processed.matches(bundle_marker).count(),
             1,
             "should inject the immediate TSJS bundle once"
         );
+        let transport = bootstrap_transport(&processed);
         assert_eq!(
-            processed.matches(diagnostics_marker).count(),
+            transport["boot"]["manifest"]["integrations"]
+                .as_array()
+                .expect("manifest integrations should be an array")
+                .iter()
+                .filter(|entry| entry["id"] == "gpt_diagnostics")
+                .count(),
             1,
-            "should inject one standalone diagnostics module"
+            "should select diagnostics once in immutable boot data"
         );
-        let bootstrap_index = processed
-            .find(bootstrap_marker)
-            .expect("should include diagnostics bootstrap");
+        assert_eq!(
+            processed.matches(diagnostics_script_marker).count(),
+            0,
+            "should not emit a standalone diagnostics module"
+        );
+        assert_eq!(processed.matches(cleanup_asset_marker).count(), 0);
+        assert_eq!(processed.matches(cleanup_program_marker).count(), 1);
+        let cleanup_index = processed
+            .find(cleanup_program_marker)
+            .expect("should include the request-scoped inline cleanup");
         let bundle_index = processed
             .find(bundle_marker)
-            .expect("should include immediate TSJS bundle");
-        let diagnostics_index = processed
-            .find(diagnostics_marker)
-            .expect("should include standalone diagnostics module");
+            .expect("should include the selected TSJS artifact");
         assert!(
-            bootstrap_index < bundle_index,
-            "should activate before core executes"
+            cleanup_index < bundle_index,
+            "request-scoped URL cleanup must run before publisher/core work"
         );
-        assert!(
-            bundle_index < diagnostics_index,
-            "should load diagnostics after core"
+        assert_eq!(transport["boot"]["diagnostics"]["gpt"]["active"], true);
+    }
+
+    #[test]
+    fn shared_template_is_reader_neutral_across_request_scoped_boot_inputs() {
+        const MARKER: &str = "<!--ts-ad-seam-->";
+        const HTML: &[u8] =
+            b"<html><head><title>Test</title></head><body><p>content</p></body></html>";
+
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt_diagnostics", &json!({ "enabled": true }))
+            .expect("should insert GPT diagnostics config");
+        settings
+            .integrations
+            .insert_config("gpt", &json!({}))
+            .expect("should insert the GPT event provider config");
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should build integration registry");
+
+        let mut request = http::Request::builder()
+            .method(http::Method::GET)
+            .uri("https://publisher.example/page?ts_console=1")
+            .header("sec-fetch-dest", "document")
+            .body(edgezero_core::body::Body::empty())
+            .expect("should build activation request");
+        let diagnostics =
+            crate::integrations::gpt_diagnostics::prepare_request(&settings, &mut request)
+                .expect("should prepare diagnostics request");
+
+        let render = |ad_slots_script: Option<String>,
+                      projection: Option<String>,
+                      diagnostics: Option<GptDiagnosticsRequestDecision>,
+                      render_trace_overlay: bool| {
+            let config = HtmlProcessorConfig {
+                csp_nonce_observed: None,
+                csp_nonce: None,
+                body_close: BodyCloseInjection::Marker(MARKER.to_string()),
+                origin_host: "origin.example.com".to_string(),
+                request_host: "example.com".to_string(),
+                request_scheme: "https".to_string(),
+                integrations: registry.clone(),
+                ad_slots_script,
+                ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(projection)),
+                max_buffered_body_bytes: 16 * 1024 * 1024,
+                gpt_diagnostics: diagnostics,
+                render_trace_overlay,
+                suppress_datadome_client_side_tag: false,
+            };
+            let mut processor = create_html_processor(config);
+            String::from_utf8(
+                processor
+                    .process_chunk(HTML, true)
+                    .expect("should process shared template"),
+            )
+            .expect("shared template should be UTF-8")
+        };
+
+        let baseline = render(None, None, None, false);
+        let varied = render(
+            Some("request-specific-slot-data".to_string()),
+            Some(
+                r#"{"version":1,"auction":{"version":1,"auctionId":"request-specific-auction","results":[]},"slots":[],"bids":[]}"#
+                    .to_string(),
+            ),
+            Some(diagnostics),
+            true,
         );
+
+        assert_eq!(
+            varied, baseline,
+            "shared template bytes must not depend on request-scoped boot inputs"
+        );
+        assert_eq!(baseline.matches(MARKER).count(), 1);
+        for forbidden in [
+            "request-specific-slot-data",
+            "request-specific-auction",
+            "__TSJS_SERVER_BOOT_INPUT_V1__",
+            "trustedserver-js",
+            "history.replaceState",
+            ".adSlots",
+            ".bids=",
+        ] {
+            assert!(
+                !baseline.contains(forbidden),
+                "shared template must not contain request-scoped `{forbidden}`: {baseline}"
+            );
+        }
     }
 
     #[test]
@@ -1174,62 +1261,6 @@ mod tests {
         assert_eq!(config.request_scheme, "https");
     }
 
-    #[test]
-    fn suppressed_datadome_tag_preserves_and_rewrites_publisher_tag() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "datadome",
-                &json!({
-                    "enabled": true,
-                    "client_side_key": "test-client-key",
-                }),
-            )
-            .expect("should configure DataDome integration");
-        let registry = IntegrationRegistry::new(&settings)
-            .expect("should create integration registry with DataDome");
-        let config = HtmlProcessorConfig::from_settings(
-            &settings,
-            &registry,
-            "origin.example.com",
-            "test.example.com",
-            "https",
-        )
-        .with_datadome_client_tag_suppression(true);
-        let mut processor = create_html_processor(config);
-
-        let output = processor
-            .process_chunk(
-                br#"<html><head><script id="publisher-datadome" src="https://js.datadome.co/tags.js"></script></head><body>content</body></html>"#,
-                true,
-            )
-            .expect("should process HTML");
-        let html = String::from_utf8(output).expect("should produce UTF-8 HTML");
-
-        assert!(
-            !html.contains("window.ddjskey"),
-            "should omit the DataDome client configuration"
-        );
-        assert!(
-            html.contains("id=\"publisher-datadome\""),
-            "should preserve the publisher-originated DataDome tag"
-        );
-        assert!(
-            html.contains("src=\"/integrations/datadome/tags.js\""),
-            "should rewrite the publisher-originated DataDome tag"
-        );
-        assert!(
-            !html.contains("https://js.datadome.co/tags.js"),
-            "should remove the original third-party DataDome URL"
-        );
-        assert_eq!(
-            html.matches("/integrations/datadome/tags.js").count(),
-            1,
-            "should leave exactly one publisher-originated DataDome tag"
-        );
-    }
-
     #[test]
     fn test_real_publisher_html() {
         // Test with publisher HTML from test_publisher.html
@@ -1579,6 +1610,7 @@ mod tests {
             origin_host: String::new(),
             request_host: String::new(),
             request_scheme: String::new(),
+            csp_nonce: None,
             document_state: IntegrationDocumentState::default(),
         };
 
@@ -1621,6 +1653,7 @@ mod tests {
             origin_host: String::new(),
             request_host: String::new(),
             request_scheme: String::new(),
+            csp_nonce: None,
             document_state: IntegrationDocumentState::default(),
         };
 
@@ -1678,6 +1711,7 @@ mod tests {
             origin_host: String::new(),
             request_host: String::new(),
             request_scheme: String::new(),
+            csp_nonce: None,
             document_state: IntegrationDocumentState::default(),
         };
 
@@ -1726,6 +1760,7 @@ mod tests {
             origin_host: String::new(),
             request_host: String::new(),
             request_scheme: String::new(),
+            csp_nonce: None,
             document_state: IntegrationDocumentState::default(),
         };
 
@@ -1776,6 +1811,7 @@ mod tests {
             origin_host: String::new(),
             request_host: String::new(),
             request_scheme: String::new(),
+            csp_nonce: None,
             document_state: IntegrationDocumentState::default(),
         };
 
@@ -1813,9 +1849,10 @@ mod tests {
     }
 
     #[test]
-    fn injects_ad_slots_at_head_open() {
+    fn ignores_the_removed_legacy_ad_slots_transport() {
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
+            csp_nonce: None,
             body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
@@ -1828,6 +1865,7 @@ mod tests {
             ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(None)),
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
@@ -1838,13 +1876,14 @@ mod tests {
             )
             .expect("should process");
         let html = std::str::from_utf8(&output).expect("should be utf8");
-        assert!(
-            html.contains("window.tsjs=window.tsjs||{}"),
-            "should inject ad slots namespace at head-open"
+        assert_eq!(
+            bootstrap_transport(html)["boot"]["abi"],
+            1,
+            "should inject the sealed hard-cutover boot at head-open"
         );
         assert!(
-            html.contains(".adSlots=JSON.parse"),
-            "should inject adSlots at head-open"
+            !html.contains(".adSlots"),
+            "must not emit the removed adSlots surface"
         );
         assert!(
             !html.contains("__ts_request_id"),
@@ -1889,12 +1928,68 @@ mod tests {
     }
 
     #[test]
-    fn injects_ts_bids_before_body_close() {
-        let bids_script = r#"<script>(window.tsjs=window.tsjs||{}).bids=JSON.parse("{\"atf\":{\"hb_pb\":\"1.00\"}}");</script>"#;
-        let state = std::sync::Arc::new(std::sync::Mutex::new(Some(bids_script.to_string())));
+    fn injects_exact_boot_projection_before_core_without_legacy_slot_or_bid_surfaces() {
+        let projection = r#"{"version":1,"auction":{"version":1,"auctionId":"auction-1","results":[{"slot":"slot-a","outcome":"no_bid"}]},"slots":[],"bids":[]}"#;
+        let config = HtmlProcessorConfig {
+            csp_nonce_observed: None,
+            csp_nonce: None,
+            origin_host: "origin.example.com".to_owned(),
+            request_host: "example.com".to_owned(),
+            request_scheme: "https".to_owned(),
+            integrations: IntegrationRegistry::default(),
+            ad_slots_script: Some(
+                "<script>(window.tsjs=window.tsjs||{}).adSlots=['legacy'];</script>".to_owned(),
+            ),
+            ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(Some(projection.to_owned()))),
+            max_buffered_body_bytes: 16 * 1024 * 1024,
+            gpt_diagnostics: None,
+            body_close: BodyCloseInjection::None,
+            render_trace_overlay: false,
+            suppress_datadome_client_side_tag: false,
+        };
+        let mut processor = create_html_processor(config);
+        let output = processor
+            .process_chunk(
+                b"<html><head></head><body><body>x</body></body></html>",
+                true,
+            )
+            .expect("should process HTML");
+        let html = std::str::from_utf8(&output).expect("should produce UTF-8");
+        let boot = html
+            .find("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+            .expect("should emit exact sealed server boot transport");
+        let core = html
+            .find("id=\"trustedserver-js\"")
+            .expect("should emit core bundle");
+
+        assert!(boot < core, "boot transport must precede core execution");
+        let transport = bootstrap_transport(html);
+        assert_eq!(
+            transport["boot"]["auctionProjection"]["auction"]["auctionId"],
+            "auction-1"
+        );
+        assert_eq!(
+            transport["boot"]["creative"],
+            json!({"version":1,"enabled":true,"clickGuard":true,"renderGuard":false})
+        );
+        assert!(html.contains(r#"performance.mark("tsjs:bids-script")"#));
+        assert_eq!(
+            html.matches("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+                .count(),
+            1
+        );
+        assert!(!html.contains(".adSlots"));
+        assert!(!html.contains(".bids="));
+    }
+
+    #[test]
+    fn injects_projection_in_boot_before_core_instead_of_bids_at_body_close() {
+        let projection = r#"{"version":1,"auction":{"version":1,"auctionId":"auction-body","results":[]},"slots":[],"bids":[]}"#;
+        let state = std::sync::Arc::new(std::sync::Mutex::new(Some(projection.to_owned())));
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
-            body_close: BodyCloseInjection::InlineBids,
+            csp_nonce: None,
+            body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
             request_scheme: "https".to_string(),
@@ -1905,6 +2000,7 @@ mod tests {
             ad_bids_state: state,
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
@@ -1912,28 +2008,29 @@ mod tests {
             .process_chunk(b"<html><head></head><body>content</body></html>", true)
             .expect("should process");
         let html = std::str::from_utf8(&output).expect("should be utf8");
-        assert!(
-            html.contains("window.tsjs=window.tsjs||{}"),
-            "should inject _ts namespace for bids before </body>"
-        );
-        assert!(
-            html.contains(".bids=JSON.parse"),
-            "should inject bids before </body>"
-        );
-        let bids_pos = html
-            .find("window.tsjs=window.tsjs||{}")
-            .expect("bids namespace should be in output");
-        let body_close_pos = html.find("</body>").expect("</body> should be in output");
-        assert!(bids_pos < body_close_pos, "bids must appear before </body>");
+        assert_eq!(
+            bootstrap_transport(html)["boot"]["auctionProjection"]["auction"]["auctionId"],
+            "auction-body",
+            "should inject the exact projection into immutable boot"
+        );
+        let boot_pos = html
+            .find("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+            .expect("sealed server boot transport should be in output");
+        let core_pos = html
+            .find("id=\"trustedserver-js\"")
+            .expect("core should be in output");
+        assert!(boot_pos < core_pos, "projection boot must precede core");
+        assert!(!html.contains(".bids="));
     }
 
     #[test]
-    fn injects_ts_bids_only_once_with_multiple_body_elements() {
-        let bids_script = r#"<script>(window.tsjs=window.tsjs||{}).bids=JSON.parse("{\"atf\":{\"hb_pb\":\"1.00\"}}");</script>"#;
-        let state = std::sync::Arc::new(std::sync::Mutex::new(Some(bids_script.to_string())));
+    fn injects_boot_only_once_with_multiple_body_elements() {
+        let projection = r#"{"version":1,"auction":{"version":1,"auctionId":"auction-many-bodies","results":[]},"bids":[]}"#;
+        let state = std::sync::Arc::new(std::sync::Mutex::new(Some(projection.to_owned())));
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
-            body_close: BodyCloseInjection::InlineBids,
+            csp_nonce: None,
+            body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
             request_scheme: "https".to_string(),
@@ -1944,19 +2041,25 @@ mod tests {
             ad_bids_state: state,
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
         // Malformed HTML with two <body> elements (common in CMS template pages)
         let output = processor
-            .process_chunk(b"<html><body><body>content</body></body></html>", true)
+            .process_chunk(
+                b"<html><head></head><body><body>content</body></body></html>",
+                true,
+            )
             .expect("should process");
         let html = std::str::from_utf8(&output).expect("should be utf8");
         assert_eq!(
-            html.matches(".bids=JSON.parse").count(),
+            html.matches("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+                .count(),
             1,
-            "should inject tsjs.bids exactly once even with multiple <body> elements"
+            "should inject immutable boot exactly once even with multiple body elements"
         );
+        assert!(!html.contains(".bids="));
     }
 
     #[test]
@@ -1973,6 +2076,7 @@ mod tests {
         let request_host = "proxy.test-publisher.example.com";
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
+            csp_nonce: None,
             body_close: BodyCloseInjection::None,
             origin_host: "origin.test-publisher.example.com".to_string(),
             request_host: request_host.to_string(),
@@ -1982,6 +2086,7 @@ mod tests {
             ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(None)),
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
@@ -2013,7 +2118,7 @@ mod tests {
             .expect("should process HTML");
         let output_str = std::str::from_utf8(&output).expect("should be valid UTF-8");
 
-        let script_count = output_str.matches("/static/tsjs=").count();
+        let script_count = output_str.matches("id=\"trustedserver-js\"").count();
         assert_eq!(
             script_count, 1,
             "script tag must appear exactly once, found {script_count} occurrences"
@@ -2021,13 +2126,12 @@ mod tests {
     }
 
     #[test]
-    fn injects_empty_ts_bids_when_slots_matched_but_auction_returned_nothing() {
-        // Slots matched (ad_slots_script is Some) but auction task never wrote a result
-        // (state is None) — e.g. auction timed out with zero bids. Fallback to {}.
+    fn injects_safe_empty_projection_when_auction_returned_nothing() {
         let state = std::sync::Arc::new(std::sync::Mutex::new(None));
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
-            body_close: BodyCloseInjection::InlineBids,
+            csp_nonce: None,
+            body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
             request_scheme: "https".to_string(),
@@ -2038,6 +2142,7 @@ mod tests {
             ad_bids_state: state,
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
@@ -2045,20 +2150,25 @@ mod tests {
             .process_chunk(b"<html><head></head><body>content</body></html>", true)
             .expect("should process");
         let html = std::str::from_utf8(&output).expect("should be utf8");
-        assert!(
-            html.contains("JSON.parse(\"{}\")"),
-            "should inject empty bids fallback when auction produced nothing"
-        );
+        assert_eq!(
+            bootstrap_transport(html)["boot"]["auctionProjection"],
+            json!({
+                "version": 1,
+                "auction": {"version": 1, "auctionId": "initial", "results": []},
+                "slots": [],
+                "bids": []
+            }),
+            "should inject the exact safe empty initial projection"
+        );
+        assert!(!html.contains(".bids="));
     }
 
     #[test]
-    fn does_not_inject_ts_bids_when_no_slots_matched() {
-        // No slots matched this URL — ad_slots_script is None. tsjs.bids must be
-        // omitted entirely so the publisher's existing client-side GPT flow is
-        // unmodified (spec §8: "Existing client-side Prebid/GPT flow runs unmodified").
+    fn emits_empty_boot_but_no_legacy_bids_when_no_slots_matched() {
         let state = std::sync::Arc::new(std::sync::Mutex::new(None));
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
+            csp_nonce: None,
             body_close: BodyCloseInjection::None,
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
@@ -2068,6 +2178,7 @@ mod tests {
             ad_bids_state: state,
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let mut processor = create_html_processor(config);
@@ -2075,15 +2186,19 @@ mod tests {
             .process_chunk(b"<html><head></head><body>content</body></html>", true)
             .expect("should process");
         let html = std::str::from_utf8(&output).expect("should be utf8");
-        assert!(
-            !html.contains("JSON.parse"),
-            "should NOT inject tsjs.bids when no slots matched"
+        assert_eq!(
+            html.matches("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+                .count(),
+            1,
+            "every document should receive one complete server boot input"
         );
+        assert!(!html.contains(".bids="));
     }
 
     fn marker_mode_config(marker: &str, observer: Option<Arc<AtomicBool>>) -> HtmlProcessorConfig {
         HtmlProcessorConfig {
             csp_nonce_observed: observer,
+            csp_nonce: None,
             body_close: BodyCloseInjection::Marker(marker.to_string()),
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
@@ -2094,6 +2209,7 @@ mod tests {
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
             suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
         }
     }
 
@@ -2220,6 +2336,7 @@ mod tests {
         const MARKER: &str = "<!--reserved-template-cache-seam-->";
         let config = HtmlProcessorConfig {
             csp_nonce_observed: None,
+            csp_nonce: None,
             body_close: BodyCloseInjection::Marker(MARKER.to_string()),
             origin_host: "origin.example.com".to_string(),
             request_host: "example.com".to_string(),
@@ -2229,6 +2346,7 @@ mod tests {
             ad_bids_state: std::sync::Arc::new(std::sync::Mutex::new(None)),
             max_buffered_body_bytes: 16 * 1024 * 1024,
             gpt_diagnostics: None,
+            render_trace_overlay: false,
             suppress_datadome_client_side_tag: false,
         };
         let source =
diff --git a/crates/trusted-server-core/src/integrations/adserver_mock.rs b/crates/trusted-server-core/src/integrations/adserver_mock.rs
index b9e628111..a06412050 100644
--- a/crates/trusted-server-core/src/integrations/adserver_mock.rs
+++ b/crates/trusted-server-core/src/integrations/adserver_mock.rs
@@ -98,36 +98,43 @@ impl IntegrationConfig for AdServerMockConfig {
 /// mediation response to restore render/accounting fields that the mock
 /// mediator endpoint does not echo back.
 ///
-/// Keyed by `(provider_name, slot_id, bidder_name)`.
-type BidIndex = HashMap<(String, String, String), Bid>;
+/// Keyed only by the server-minted opaque candidate identifier.
+type BidIndex = HashMap<String, Bid>;
+
+fn optional_selection_field_matches<T: Serialize>(
+    selection: &serde_json::Map<String, Json>,
+    field: &str,
+    expected: &Option<T>,
+) -> bool {
+    let Some(actual) = selection.get(field) else {
+        return true;
+    };
+    expected
+        .as_ref()
+        .and_then(|expected| serde_json::to_value(expected).ok())
+        .is_some_and(|expected| expected == *actual)
+}
 
 /// Builds the SSP-bid lookup index from the orchestrator-provided
 /// bidder responses on the auction context.
-fn build_bid_index(bidder_responses: &[AuctionResponse]) -> BidIndex {
+fn build_bid_index(bidder_responses: &[AuctionResponse]) -> Option<BidIndex> {
     let mut index = BidIndex::new();
     for response in bidder_responses {
         for bid in &response.bids {
-            let key = (
-                response.provider.clone(),
-                bid.slot_id.clone(),
-                bid.bidder.clone(),
-            );
-            // OpenRTB permits a seat to return multiple bids per imp. This index
-            // is last-write-wins, so a collision means an earlier bid's
-            // nurl/burl/cache_* are dropped and win/billing-URL restoration can
-            // be mis-attributed during mediation. Low severity for the mock
-            // mediator, but log it so the collision is visible.
-            if index.insert(key, bid.clone()).is_some() {
+            let Some(candidate_id) = bid.candidate_id.as_ref() else {
                 log::warn!(
-                    "adserver_mock: duplicate bid for (provider '{}', slot '{}', bidder '{}'); keeping the last — win/billing URL restoration may be mis-attributed",
-                    response.provider,
-                    bid.slot_id,
-                    bid.bidder
+                    "adserver_mock: source bid from provider '{}' lacks a candidate id",
+                    response.provider
                 );
+                return None;
+            };
+            if index.insert(candidate_id.clone(), bid.clone()).is_some() {
+                log::warn!("adserver_mock: duplicate source candidate id");
+                return None;
             }
         }
     }
-    index
+    Some(index)
 }
 
 /// Mock ad server mediator provider.
@@ -180,14 +187,26 @@ impl AdServerMockProvider {
                             );
                             return None;
                         };
+                        let Some(candidate_id) = bid.candidate_id.as_deref() else {
+                            log::warn!(
+                                "adserver_mock: omitting source bid for slot '{}' without a candidate id",
+                                bid.slot_id
+                            );
+                            return None;
+                        };
                         Some(json!({
                             "imp_id": bid.slot_id,
                             "price": price,
                             "adm": bid.creative,
                             "w": bid.width,
                             "h": bid.height,
-                            "crid": format!("{}-creative", bid.bidder),
+                            "crid": bid.creative_id,
                             "adomain": bid.adomain,
+                            "ext": {
+                                "trusted_server": {
+                                    "candidate_id": candidate_id
+                                }
+                            }
                         }))
                     })
                     .collect();
@@ -255,94 +274,115 @@ impl AdServerMockProvider {
     /// Mediation returns decoded prices for all selected bids.
     ///
     /// `bid_index` is the SSP-bid lookup built from the auction context's
-    /// bidder responses. The mock mediator does not echo render/accounting
-    /// fields back, so they are restored from the index using
-    /// `(seat, impid, bidder)` where bidder is recovered from the echoed `crid`
-    /// field (`"{bidder}-creative"` format set during request construction).
+    /// bidder responses. The mediator may select only by echoing one exact
+    /// server-minted candidate id; all render and accounting authority is
+    /// restored from the indexed source candidate.
     fn parse_mediation_response(
         &self,
         json: &Json,
         response_time_ms: u64,
         bid_index: &BidIndex,
     ) -> AuctionResponse {
-        let empty_array = vec![];
-        let seatbid = json["seatbid"].as_array().unwrap_or(&empty_array);
-
+        let Some(seatbids) = json.get("seatbid").and_then(Json::as_array) else {
+            return AuctionResponse::error("adserver_mock", response_time_ms)
+                .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+        };
         let mut all_bids = Vec::new();
-
-        for seat in seatbid {
-            let seat_name = seat["seat"].as_str().unwrap_or("unknown");
-            let empty_bids = vec![];
-            let bids = seat["bid"].as_array().unwrap_or(&empty_bids);
-
+        let mut seen = std::collections::HashSet::new();
+        let mut seen_slots = std::collections::HashSet::new();
+        for seat in seatbids {
+            let Some(seat_object) = seat.as_object() else {
+                return AuctionResponse::error("adserver_mock", response_time_ms)
+                    .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+            };
+            if !seat_object
+                .keys()
+                .all(|key| matches!(key.as_str(), "seat" | "bid"))
+            {
+                return AuctionResponse::error("adserver_mock", response_time_ms)
+                    .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+            }
+            let Some(bids) = seat_object.get("bid").and_then(Json::as_array) else {
+                return AuctionResponse::error("adserver_mock", response_time_ms)
+                    .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+            };
             for bid in bids {
-                let slot_id = bid["impid"].as_str().unwrap_or("").to_string();
-
-                // Recover bidder name from crid ("{bidder}-creative") to look up the
-                // original SSP bid and restore render/accounting fields the mediator drops.
-                let crid = bid["crid"].as_str().unwrap_or("");
-                let bidder = crid.strip_suffix("-creative").unwrap_or_else(|| {
-                    log::debug!(
-                        "adserver_mock: crid '{crid}' does not match '<bidder>-creative'; render/accounting fields may be missing"
-                    );
-                    ""
-                });
-                let key = (seat_name.to_string(), slot_id.clone(), bidder.to_string());
-                let original = bid_index.get(&key);
-                let restored_bidder =
-                    original.map_or_else(|| seat_name.to_string(), |b| b.bidder.clone());
-
-                let width = bid["w"].as_u64().unwrap_or(0) as u32;
-                let height = bid["h"].as_u64().unwrap_or(0) as u32;
-                if width == 0 || height == 0 {
-                    log::debug!(
-                        "adserver_mock: bid for slot '{slot_id}' has zero dimension ({width}×{height}), skipping"
-                    );
-                    continue;
+                let Some(selection) = bid.as_object() else {
+                    return AuctionResponse::error("adserver_mock", response_time_ms)
+                        .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+                };
+                if !selection.keys().all(|key| {
+                    matches!(
+                        key.as_str(),
+                        "id" | "impid"
+                            | "price"
+                            | "ext"
+                            | "adm"
+                            | "w"
+                            | "h"
+                            | "crid"
+                            | "adomain"
+                            | "nurl"
+                            | "burl"
+                    )
+                }) {
+                    return AuctionResponse::error("adserver_mock", response_time_ms)
+                        .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+                }
+                let trusted = selection
+                    .get("ext")
+                    .and_then(Json::as_object)
+                    .filter(|ext| ext.len() == 1)
+                    .and_then(|ext| ext.get("trusted_server"))
+                    .and_then(Json::as_object);
+                let candidate_id = trusted
+                    .filter(|trusted| trusted.len() == 1)
+                    .and_then(|trusted| trusted.get("candidate_id"))
+                    .and_then(Json::as_str);
+                let Some(candidate_id) = candidate_id else {
+                    return AuctionResponse::error("adserver_mock", response_time_ms)
+                        .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+                };
+                let Some(original) = bid_index.get(candidate_id) else {
+                    return AuctionResponse::error("adserver_mock", response_time_ms)
+                        .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
+                };
+                let seat_matches = seat_object
+                    .get("seat")
+                    .is_none_or(|seat| seat.as_str() == original.candidate_provider.as_deref());
+                let currency_matches = json
+                    .get("cur")
+                    .is_none_or(|currency| currency.as_str() == Some(original.currency.as_str()));
+                let authority_matches = selection
+                    .get("w")
+                    .is_none_or(|width| width.as_u64() == Some(u64::from(original.width)))
+                    && selection
+                        .get("h")
+                        .is_none_or(|height| height.as_u64() == Some(u64::from(original.height)))
+                    && optional_selection_field_matches(selection, "adm", &original.creative)
+                    && optional_selection_field_matches(selection, "crid", &original.creative_id)
+                    && optional_selection_field_matches(selection, "adomain", &original.adomain)
+                    && optional_selection_field_matches(selection, "nurl", &original.nurl)
+                    && optional_selection_field_matches(selection, "burl", &original.burl);
+                if !seen.insert(candidate_id)
+                    || !seen_slots.insert(original.slot_id.as_str())
+                    || selection.get("impid").and_then(Json::as_str)
+                        != Some(original.slot_id.as_str())
+                    || selection
+                        .get("price")
+                        .and_then(Json::as_f64)
+                        .is_none_or(|price| !price.is_finite() || price < 0.0)
+                    || !seat_matches
+                    || !currency_matches
+                    || !authority_matches
+                {
+                    return AuctionResponse::error("adserver_mock", response_time_ms)
+                        .with_metadata("mediation_error", json!("invalid_candidate_provenance"));
                 }
 
-                all_bids.push(Bid {
-                    slot_id,
-                    price: bid["price"].as_f64(),
-                    currency: "USD".to_string(),
-                    creative: if original.is_some_and(|bid| bid.renderer.is_some()) {
-                        None
-                    } else {
-                        bid["adm"].as_str().map(String::from)
-                    },
-                    width,
-                    height,
-                    bidder: restored_bidder,
-                    returned_seat: original.map_or_else(
-                        || (seat_name != "unknown").then(|| seat_name.to_string()),
-                        |bid| bid.returned_seat.clone(),
-                    ),
-                    adomain: bid["adomain"].as_array().map(|arr| {
-                        arr.iter()
-                            .filter_map(|v| v.as_str().map(String::from))
-                            .collect()
-                    }),
-                    nurl: original.and_then(|b| b.nurl.clone()),
-                    burl: original.and_then(|b| b.burl.clone()),
-                    // The mediation response is itself `OpenRTB`, so the mediated
-                    // bid's own `id` is this bid's identifier. Fall back to the
-                    // original SSP bid's id when the mediator omits one. Without
-                    // either, a mediated bid whose only `hb_adid` source is the bid
-                    // id would lose it and never render — including APS bids, which
-                    // carry no `ad_id` or `cache_id` for the restore to recover.
-                    bid_id: bid["id"]
-                        .as_str()
-                        .filter(|id| !id.is_empty())
-                        .map(String::from)
-                        .or_else(|| original.and_then(|bid| bid.bid_id.clone())),
-                    ad_id: original.and_then(|bid| bid.ad_id.clone()),
-                    creative_id: original.and_then(|bid| bid.creative_id.clone()),
-                    renderer: original.and_then(|bid| bid.renderer.clone()),
-                    cache_id: original.and_then(|b| b.cache_id.clone()),
-                    cache_host: original.and_then(|b| b.cache_host.clone()),
-                    cache_path: original.and_then(|b| b.cache_path.clone()),
-                    metadata: HashMap::new(),
-                });
+                let mut resolved = original.clone();
+                resolved.price = selection.get("price").and_then(Json::as_f64);
+                all_bids.push(resolved);
             }
         }
 
@@ -522,7 +562,10 @@ impl AuctionProvider for AdServerMockProvider {
         // Rebuild the SSP-bid lookup from the orchestrator-provided bidder
         // responses so nurl/burl/ad_id survive mediation. Request-scoped data
         // travels on the context instead of provider-instance state.
-        let bid_index = build_bid_index(context.provider_responses.unwrap_or(&[]));
+        let Some(bid_index) = build_bid_index(context.provider_responses.unwrap_or(&[])) else {
+            return Ok(AuctionResponse::error("adserver_mock", response_time_ms)
+                .with_metadata("mediation_error", json!("invalid_candidate_provenance")));
+        };
         self.parse_response_inner(response, response_time_ms, &bid_index)
             .await
     }
@@ -640,6 +683,12 @@ mod tests {
     fn aps_bid(bid_id: &str, price: f64) -> Bid {
         Bid {
             slot_id: "header-banner".to_string(),
+            candidate_id: Some(format!(
+                "{:012x}",
+                bid_id.bytes().map(u64::from).sum::<u64>()
+            )),
+            candidate_provider: Some("aps".to_string()),
+            renderer_reservation_id: None,
             price: Some(price),
             currency: "USD".to_string(),
             creative: None,
@@ -653,7 +702,7 @@ mod tests {
             bid_id: Some(bid_id.to_string()),
             ad_id: None,
             creative_id: Some(format!("creative-{bid_id}")),
-            renderer: Some(BidRenderer::Aps(ApsRendererV1 {
+            renderer: Some(BidRenderSourceV1::Aps(ApsRendererV1 {
                 version: 1,
                 account_id: "example-account".to_string(),
                 bid_id: bid_id.to_string(),
@@ -690,6 +739,9 @@ mod tests {
                 status: BidStatus::Success,
                 bids: vec![Bid {
                     slot_id: "header-banner".to_string(),
+                    candidate_id: Some("AAAAAAAAAAAA".to_string()),
+                    candidate_provider: Some("aps".to_string()),
+                    renderer_reservation_id: None,
                     price: Some(3.00),
                     currency: "USD".to_string(),
                     creative: Some("<div>APS Ad</div>".to_string()),
@@ -717,6 +769,9 @@ mod tests {
                 status: BidStatus::Success,
                 bids: vec![Bid {
                     slot_id: "header-banner".to_string(),
+                    candidate_id: Some("BBBBBBBBBBBB".to_string()),
+                    candidate_provider: Some("test-bidder".to_string()),
+                    renderer_reservation_id: None,
                     price: Some(3.50),
                     currency: "USD".to_string(),
                     creative: Some("<div>Test Ad</div>".to_string()),
@@ -762,28 +817,38 @@ mod tests {
             2
         );
         assert_eq!(mediation_req["ext"]["config"]["price_floor"], 1.00);
+        assert_eq!(
+            mediation_req["ext"]["bidder_responses"][0]["bids"][0]["ext"]["trusted_server"]["candidate_id"],
+            "AAAAAAAAAAAA"
+        );
+        assert_eq!(
+            mediation_req["ext"]["bidder_responses"][1]["bids"][0]["ext"]["trusted_server"]["candidate_id"],
+            "BBBBBBBBBBBB"
+        );
     }
 
     #[test]
     fn test_parse_mediation_response() {
         let config = AdServerMockConfig::default();
         let provider = AdServerMockProvider::new(config);
+        let source = aps_bid("selected", 1.0);
+        let candidate_id = source
+            .candidate_id
+            .clone()
+            .expect("source should have candidate id");
+        let bid_index = HashMap::from([(candidate_id.clone(), source)]);
 
         let mediation_response = json!({
             "id": "test-auction-123",
             "seatbid": [
                 {
-                    "seat": "test-bidder",
+                    "seat": "aps",
                     "bid": [
                         {
                             "id": "bid-001",
                             "impid": "header-banner",
                             "price": 3.50,
-                            "adm": "<div>Test Ad</div>",
-                            "w": 728,
-                            "h": 90,
-                            "crid": "test-creative",
-                            "adomain": ["test.com"]
+                            "ext": {"trusted_server": {"candidate_id": candidate_id}}
                         }
                     ]
                 }
@@ -792,7 +857,7 @@ mod tests {
         });
 
         let auction_response =
-            provider.parse_mediation_response(&mediation_response, 200, &BidIndex::new());
+            provider.parse_mediation_response(&mediation_response, 200, &bid_index);
 
         assert_eq!(auction_response.provider, "adserver_mock");
         assert_eq!(auction_response.status, BidStatus::Success);
@@ -802,7 +867,7 @@ mod tests {
         let bid = &auction_response.bids[0];
         assert_eq!(bid.slot_id, "header-banner");
         assert_eq!(bid.price, Some(3.50)); // Mediation returns decoded price
-        assert_eq!(bid.bidder, "test-bidder");
+        assert_eq!(bid.bidder, "aps");
         assert_eq!(bid.width, 728);
         assert_eq!(bid.height, 90);
     }
@@ -810,6 +875,7 @@ mod tests {
     #[test]
     fn parse_mediation_response_restores_original_bid_render_fields() {
         let provider = AdServerMockProvider::new(AdServerMockConfig::default());
+        let candidate_id = "AAAAAAAAAAAA";
         let mediation_response = json!({
             "id": "test-auction-123",
             "seatbid": [
@@ -820,11 +886,7 @@ mod tests {
                             "id": "mediated-bid-001",
                             "impid": "header-banner",
                             "price": 0.20,
-                            "adm": "<div>Mediated Ad</div>",
-                            "w": 728,
-                            "h": 90,
-                            "crid": "mocktioneer-creative",
-                            "adomain": ["example.com"]
+                            "ext": {"trusted_server": {"candidate_id": candidate_id}}
                         }
                     ]
                 }
@@ -833,13 +895,12 @@ mod tests {
         });
         let mut bid_index = BidIndex::new();
         bid_index.insert(
-            (
-                "prebid".to_string(),
-                "header-banner".to_string(),
-                "mocktioneer".to_string(),
-            ),
+            candidate_id.to_string(),
             Bid {
                 slot_id: "header-banner".to_string(),
+                candidate_id: Some(candidate_id.to_string()),
+                candidate_provider: Some("prebid".to_string()),
+                renderer_reservation_id: None,
                 price: Some(0.20),
                 currency: "USD".to_string(),
                 creative: Some("<div>Original Ad</div>".to_string()),
@@ -853,7 +914,7 @@ mod tests {
                 bid_id: Some("source-bid-id".to_string()),
                 ad_id: Some("bid-impression-id".to_string()),
                 creative_id: Some("source-creative-id".to_string()),
-                renderer: Some(BidRenderer::Aps(ApsRendererV1 {
+                renderer: Some(BidRenderSourceV1::Aps(ApsRendererV1 {
                     version: 1,
                     account_id: "example-account".to_string(),
                     bid_id: "source-bid-id".to_string(),
@@ -893,8 +954,8 @@ mod tests {
         );
         assert_eq!(
             bid.bid_id.as_deref(),
-            Some("mediated-bid-001"),
-            "should carry the mediated OpenRTB bid id so hb_adid always has a source"
+            Some("source-bid-id"),
+            "should preserve the source provider's upstream bid id"
         );
         assert_eq!(
             bid.ad_id.as_deref(),
@@ -925,9 +986,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_mediation_response_falls_back_to_original_bid_id() {
-        // A mediator that omits the per-bid `id` must not strand a pass-through
-        // bid whose only hb_adid source is its OpenRTB bid id.
+    fn parse_mediation_response_preserves_source_bid_id_when_selection_id_is_absent() {
         let provider = AdServerMockProvider::new(AdServerMockConfig::default());
         let mediation_response = json!({
             "id": "test-auction-123",
@@ -936,23 +995,21 @@ mod tests {
                 "bid": [{
                     "impid": "header-banner",
                     "price": 0.20,
-                    "adm": "<div>Mediated Ad</div>",
                     "w": 728,
                     "h": 90,
-                    "crid": "example-bidder-creative"
+                    "ext": {"trusted_server": {"candidate_id": "AAAAAAAAAAAA"}}
                 }]
             }],
             "cur": "USD"
         });
         let mut bid_index = BidIndex::new();
         bid_index.insert(
-            (
-                "prebid".to_string(),
-                "header-banner".to_string(),
-                "example-bidder".to_string(),
-            ),
+            "AAAAAAAAAAAA".to_string(),
             Bid {
                 slot_id: "header-banner".to_string(),
+                candidate_id: Some("AAAAAAAAAAAA".to_string()),
+                candidate_provider: Some("prebid".to_string()),
+                renderer_reservation_id: None,
                 price: Some(0.20),
                 currency: "USD".to_string(),
                 creative: Some("<div>Original Ad</div>".to_string()),
@@ -977,53 +1034,113 @@ mod tests {
         let auction_response =
             provider.parse_mediation_response(&mediation_response, 42, &bid_index);
 
+        assert_eq!(auction_response.status, BidStatus::Success);
+        assert_eq!(auction_response.bids.len(), 1);
         assert_eq!(
             auction_response.bids[0].bid_id.as_deref(),
             Some("019f7e2a-b45b-70b0-a2d1-b651c430700b"),
-            "should restore the original SSP bid id when the mediator omits one"
+            "should preserve the source provider's upstream bid id"
         );
     }
 
     #[test]
-    fn reduced_aps_bid_avoids_mediation_index_renderer_collision() {
+    fn mediation_response_rejects_every_source_authority_substitution() {
         let provider = AdServerMockProvider::new(AdServerMockConfig::default());
+        let candidate_id = "AAAAAAAAAAAA";
+        let mut source = aps_bid("source-bid", 1.0);
+        source.candidate_id = Some(candidate_id.to_string());
+        source.renderer = None;
+        source.creative = Some("<div>source creative</div>".to_string());
+        source.nurl = Some("https://ssp.example/win".to_string());
+        source.burl = Some("https://ssp.example/bill".to_string());
+        let bid_index = BidIndex::from([(candidate_id.to_string(), source)]);
+
+        for substitution in [
+            "seat", "w", "h", "crid", "adomain", "nurl", "burl", "adm", "native", "renderer",
+        ] {
+            let mut response = json!({
+                "id": "test-auction-123",
+                "seatbid": [{
+                    "seat": "aps",
+                    "bid": [{
+                        "id": "selection-1",
+                        "impid": "header-banner",
+                        "price": 2.0,
+                        "ext": {"trusted_server": {"candidate_id": candidate_id}}
+                    }]
+                }],
+                "cur": "USD"
+            });
+            match substitution {
+                "seat" => response["seatbid"][0]["seat"] = json!("substituted-provider"),
+                "w" => response["seatbid"][0]["bid"][0]["w"] = json!(1),
+                "h" => response["seatbid"][0]["bid"][0]["h"] = json!(1),
+                "crid" => response["seatbid"][0]["bid"][0]["crid"] = json!("other"),
+                "adomain" => {
+                    response["seatbid"][0]["bid"][0]["adomain"] = json!(["evil.example"]);
+                }
+                "nurl" => {
+                    response["seatbid"][0]["bid"][0]["nurl"] = json!("https://evil.example/win");
+                }
+                "burl" => {
+                    response["seatbid"][0]["bid"][0]["burl"] = json!("https://evil.example/bill");
+                }
+                "adm" => {
+                    response["seatbid"][0]["bid"][0]["adm"] =
+                        json!("<script>substituted()</script>");
+                }
+                "native" => {
+                    response["seatbid"][0]["bid"][0]["native"] = json!({"ver": "1.2"});
+                }
+                "renderer" => {
+                    response["seatbid"][0]["bid"][0]["renderer"] =
+                        json!({"url": "https://evil.example/render.js"});
+                }
+                _ => unreachable!("closed substitution corpus"),
+            }
 
-        // Document why APS must reduce before mediation: the mediator index is
-        // intentionally last-write-wins for identical provider/slot/bidder keys.
-        let unreduced = AuctionResponse::success(
+            let parsed = provider.parse_mediation_response(&response, 1, &bid_index);
+            assert_eq!(
+                parsed.status,
+                BidStatus::Error,
+                "{substitution} authority must not survive mediation"
+            );
+            assert!(parsed.bids.is_empty());
+        }
+    }
+
+    #[test]
+    fn candidate_index_preserves_multiple_same_provider_slot_bids() {
+        let provider = AdServerMockProvider::new(AdServerMockConfig::default());
+        let response = AuctionResponse::success(
             "aps",
-            vec![aps_bid("selected", 2.0), aps_bid("losing-last", 1.0)],
+            vec![aps_bid("selected", 2.0), aps_bid("losing", 1.0)],
             1,
         );
-        let collision_index = build_bid_index(&[unreduced]);
-        let key = (
-            "aps".to_string(),
-            "header-banner".to_string(),
-            "aps".to_string(),
-        );
-        assert_eq!(
-            collision_index
-                .get(&key)
-                .and_then(|bid| bid.bid_id.as_deref()),
-            Some("losing-last"),
-            "an unreduced response would restore the last candidate's renderer"
-        );
-
-        let reduced = AuctionResponse::success("aps", vec![aps_bid("selected", 2.0)], 1);
+        let index = build_bid_index(std::slice::from_ref(&response))
+            .expect("unique candidates should build an exact index");
+        assert_eq!(index.len(), 2);
+        let selected_candidate_id = response.bids[0]
+            .candidate_id
+            .clone()
+            .expect("selected bid should have candidate id");
         let mediation_request = provider
             .build_mediation_request(
                 &create_test_auction_request(),
-                std::slice::from_ref(&reduced),
+                std::slice::from_ref(&response),
             )
-            .expect("should build mediation request from reduced APS response");
+            .expect("should build mediation request with candidate provenance");
         assert_eq!(
             mediation_request["ext"]["bidder_responses"][0]["bids"]
                 .as_array()
                 .map(Vec::len),
-            Some(1)
+            Some(2)
+        );
+        assert_eq!(
+            mediation_request["ext"]["bidder_responses"][0]["bids"][0]["ext"]["trusted_server"]["candidate_id"],
+            selected_candidate_id
         );
 
-        let reduced_index = build_bid_index(&[reduced]);
         let mediated = provider.parse_mediation_response(
             &json!({
                 "seatbid": [{
@@ -1031,14 +1148,12 @@ mod tests {
                     "bid": [{
                         "impid": "header-banner",
                         "price": 2.0,
-                        "w": 728,
-                        "h": 90,
-                        "crid": "aps-creative"
+                        "ext": {"trusted_server": {"candidate_id": selected_candidate_id}}
                     }]
                 }]
             }),
             2,
-            &reduced_index,
+            &index,
         );
         let winner = mediated
             .bids
@@ -1076,6 +1191,19 @@ mod tests {
         assert_eq!(auction_response.bids.len(), 0);
     }
 
+    #[test]
+    fn missing_seatbid_is_mediation_failure_not_no_bid() {
+        let provider = AdServerMockProvider::new(AdServerMockConfig::default());
+
+        let response = provider.parse_mediation_response(&json!({}), 100, &BidIndex::new());
+
+        assert_eq!(response.status, BidStatus::Error);
+        assert_eq!(
+            response.metadata["mediation_error"],
+            "invalid_candidate_provenance"
+        );
+    }
+
     #[test]
     fn test_mediation_request_handles_decoded_bid_without_creative() {
         // Typed-renderer bids retain their decoded price when sent to mediation.
@@ -1114,6 +1242,9 @@ mod tests {
             status: BidStatus::Success,
             bids: vec![Bid {
                 slot_id: "slot-1".to_string(),
+                candidate_id: Some("CCCCCCCCCCCC".to_string()),
+                candidate_provider: Some("aps".to_string()),
+                renderer_reservation_id: None,
                 price: Some(1.75),
                 currency: "USD".to_string(),
                 creative: None,
@@ -1149,6 +1280,7 @@ mod tests {
 
         let bid = &bidder_resp["bids"][0];
         assert_eq!(bid["imp_id"], "slot-1");
+        assert_eq!(bid["ext"]["trusted_server"]["candidate_id"], "CCCCCCCCCCCC");
 
         assert_eq!(
             bid["price"].as_f64(),
@@ -1229,8 +1361,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_mediation_response_with_missing_prices() {
-        // A malformed mediator response can still omit a selected bid price.
+    fn malformed_mediator_selection_fails_closed() {
         let config = AdServerMockConfig::default();
         let provider = AdServerMockProvider::new(config);
 
@@ -1265,20 +1396,11 @@ mod tests {
         let auction_response =
             provider.parse_mediation_response(&mediation_response, 200, &BidIndex::new());
 
-        assert_eq!(auction_response.status, BidStatus::Success);
-        assert_eq!(auction_response.bids.len(), 2);
-
-        // First bid should have decoded price
-        let bid1 = &auction_response.bids[0];
-        assert_eq!(bid1.slot_id, "header-banner");
-        assert_eq!(bid1.price, Some(3.50));
-
-        // Second bid should have None price (failed decode)
-        let bid2 = &auction_response.bids[1];
-        assert_eq!(bid2.slot_id, "sidebar");
+        assert_eq!(auction_response.status, BidStatus::Error);
+        assert!(auction_response.bids.is_empty());
         assert_eq!(
-            bid2.price, None,
-            "Bid without price field should have None price"
+            auction_response.metadata["mediation_error"],
+            "invalid_candidate_provenance"
         );
     }
 
diff --git a/crates/trusted-server-core/src/integrations/aps.rs b/crates/trusted-server-core/src/integrations/aps.rs
index 6bffddf16..697d64004 100644
--- a/crates/trusted-server-core/src/integrations/aps.rs
+++ b/crates/trusted-server-core/src/integrations/aps.rs
@@ -1,8 +1,8 @@
 //! Amazon Publisher Services (APS/TAM) `OpenRTB` integration.
 
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::sync::Arc;
 #[cfg(test)]
+use std::sync::Arc;
 use std::time::Duration;
 
 use async_trait::async_trait;
@@ -11,7 +11,7 @@ use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt};
 use http::header::HeaderName;
 use http::{HeaderMap, Method, StatusCode, header};
-use serde::de::{self, Visitor};
+use serde::de::Error as _;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value as Json, json};
 use url::Url;
@@ -27,12 +27,15 @@ use crate::auction::routing::ProviderAuctionInput;
 #[cfg(test)]
 use crate::auction::types::{AdSlot, AuctionContext, AuctionRequest};
 use crate::auction::types::{
-    ApsRendererV1, ApsTagType, AuctionResponse, Bid, BidRenderer, MediaType,
+    ApsRendererV1, ApsRendererValidationResult, ApsTagType, AuctionDropReason, AuctionDropReasons,
+    AuctionResponse, Bid, BidRenderSourceV1, MediaType, RENDER_DIMENSION_MAX,
+    classify_aps_renderer_v1, record_auction_drop,
 };
 use crate::error::TrustedServerError;
+use crate::integrations::ensure_integration_backend_with_transport_timeouts;
 use crate::integrations::{
-    IntegrationEndpoint, IntegrationHeadInjector, IntegrationHtmlContext, IntegrationProxy,
-    IntegrationRegistration, UPSTREAM_RTB_MAX_RESPONSE_BYTES, collect_response_bounded,
+    IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
+    UPSTREAM_RTB_MAX_RESPONSE_BYTES, collect_response_bounded,
 };
 #[cfg(test)]
 use crate::integrations::{
@@ -45,19 +48,26 @@ use crate::openrtb::{
     Banner, Device, Format, Geo, Imp, OpenRtbRequest, Publisher, Regs, RegsExt, Site, User,
     UserExt, to_openrtb_i32,
 };
-#[cfg(test)]
-use crate::platform::PlatformHttpRequest;
-use crate::platform::{PlatformResponse, RuntimeServices};
+use crate::platform::{
+    PlatformHttpRequest, PlatformResponse, ProxyHeaderEvidenceV1, RawProxyPolicyV1,
+    RawProxyResponseV1, RuntimeServices,
+};
 use crate::settings::{IntegrationConfig, Settings};
 
 const APS_INTEGRATION_ID: &str = "aps";
-const APS_RENDERER_ROUTE: &str = "/integrations/aps/renderer";
+pub const APS_RENDERER_V2_ROUTE: &str = "/integrations/aps/renderer/v2";
+pub const APS_RUNNER_ROUTE: &str = "/integrations/aps/runner.js";
+pub const APS_RUNNER_UPSTREAM_URL: &str =
+    "https://client.aps.amazon-adsystem.com/prebid-creative.js";
+pub const APS_RUNNER_MAX_RESPONSE_BYTES: usize = 8 * 1024 * 1024;
+pub const APS_RENDERER_SANDBOX: &str = "allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation";
 const DEFAULT_CURRENCY: &str = "USD";
 #[cfg(test)]
 const APS_SDK_SOURCE: &str = "prebid";
 #[cfg(test)]
 const APS_SDK_VERSION: &str = "2.2.0";
 const MAX_ACCOUNT_ID_BYTES: usize = 1024;
+const MAX_BID_ID_BYTES: usize = 64;
 const MAX_CREATIVE_ID_BYTES: usize = 1024;
 const MAX_DEBUG_RESPONSE_PREVIEW_BYTES: usize = 512;
 const MAX_CREATIVE_URL_BYTES: usize = 4096;
@@ -66,96 +76,34 @@ const MAX_LANGUAGE_BYTES: usize = 8;
 #[cfg(test)]
 const MAX_PAGE_URL_BYTES: usize = 8192;
 const MAX_RENDER_ENVELOPE_BYTES: usize = 256 * 1024;
-const APS_RENDERER_CSP: &str = "default-src 'none'; sandbox allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation; script-src 'unsafe-inline' https:; connect-src https:; frame-src https:; img-src https: data:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:;";
-
-const APS_RENDERER_DOCUMENT: &str = r#"<!doctype html>
-<meta charset="utf-8">
-<style>html,body{margin:0;padding:0}body>iframe{display:block}</style>
-<script>
-(function(){
-'use strict';
-var match=/^#tsaps=([A-Za-z0-9_-]{22,128})$/.exec(location.hash);
-var expected=match&&match[1];
-try{history.replaceState(null,'',location.pathname+location.search);}catch(_error){}
-if(!expected)return;
-function keys(value,expectedKeys){
- if(!value||typeof value!=='object'||Array.isArray(value))return false;
- var actual=Object.keys(value).sort();
- return actual.length===expectedKeys.length&&actual.every(function(key,index){return key===expectedKeys[index];});
-}
-function validRenderer(renderer){
- if(!keys(renderer,['aaxResponse','accountId','bidId','creativeId','creativeUrl','height','tagType','type','version','width'])&&
-    !keys(renderer,['aaxResponse','accountId','bidId','creativeUrl','height','tagType','type','version','width']))return false;
- if(renderer.type!=='aps'||renderer.version!==1||typeof renderer.accountId!=='string'||!renderer.accountId||new TextEncoder().encode(renderer.accountId).length>1024)return false;
- if(typeof renderer.bidId!=='string'||!renderer.bidId||!Number.isInteger(renderer.width)||renderer.width<=0||!Number.isInteger(renderer.height)||renderer.height<=0)return false;
- if(Object.prototype.hasOwnProperty.call(renderer,'creativeId')&&(typeof renderer.creativeId!=='string'||!renderer.creativeId||new TextEncoder().encode(renderer.creativeId).length>1024))return false;
- if(renderer.tagType!=='iframe'&&renderer.tagType!=='script')return false;
- if(typeof renderer.creativeUrl!=='string'||new TextEncoder().encode(renderer.creativeUrl).length>4096)return false;
- if(typeof renderer.aaxResponse!=='string'||!renderer.aaxResponse||renderer.aaxResponse.length>349528)return false;
- try{
-  var url=new URL(renderer.creativeUrl);
-  if(url.protocol!=='https:'||url.username||url.password)return false;
-  var binary=atob(renderer.aaxResponse);
-  if(binary.length>262144||btoa(binary)!==renderer.aaxResponse)return false;
-  var bytes=Uint8Array.from(binary,function(character){return character.charCodeAt(0);});
-  var decoded=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(bytes));
-  if(!keys(decoded,['seatbid'])||!Array.isArray(decoded.seatbid)||decoded.seatbid.length!==1)return false;
-  var seat=decoded.seatbid[0];
-  if(!keys(seat,['bid'])||!Array.isArray(seat.bid)||seat.bid.length!==1)return false;
-  var bid=seat.bid[0];
-  if(!keys(bid,['ext','h','id','price','w'])||!keys(bid.ext,['creativeurl','tagtype']))return false;
-  return bid.id===renderer.bidId&&bid.w===renderer.width&&bid.h===renderer.height&&
-   bid.ext.creativeurl===renderer.creativeUrl&&bid.ext.tagtype===renderer.tagType&&
-   typeof bid.price==='number'&&Number.isFinite(bid.price)&&bid.price>=0;
- }catch(_error){return false;}
-}
-function receive(event){
- if(event.source!==parent)return;
- var message=event.data;
- if(!keys(message,['nonce','renderer'])||message.nonce!==expected||!validRenderer(message.renderer))return;
- removeEventListener('message',receive);
- var acceptedNonce=expected;
- expected='';
- var renderer=message.renderer;
- window._aps=window._aps instanceof Map?window._aps:new Map();
- var account=window._aps.get(renderer.accountId);
- if(!account){
-  account={queue:[],store:new Map([['listeners',new Map()]])};
-  window._aps.set(renderer.accountId,account);
- }
- account.queue.push(new CustomEvent('prebid/creative/render',{detail:{aaxResponse:renderer.aaxResponse,seatBidId:renderer.bidId}}));
- var script=document.createElement('script');
- script.src='https://client.aps.amazon-adsystem.com/prebid-creative.js';
- script.onload=function(){parent.postMessage({message:'trusted-server/aps/renderer-ready',nonce:acceptedNonce},'*');};
- script.onerror=function(){parent.postMessage({message:'trusted-server/aps/renderer-failed',nonce:acceptedNonce},'*');};
- document.head.appendChild(script);
-}
-addEventListener('message',receive);
-})();
-</script>
-"#;
-
-/// Rendering owner for selected APS bids.
-#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum ApsRenderingMode {
-    /// Render through Trusted Server's opaque static renderer route.
-    #[default]
-    TrustedServer,
-    /// Render through the injected APS runner in a publisher-origin friendly frame.
-    PublisherNative,
+// Exact transport window from dispatch through the final upstream byte.
+const APS_RUNNER_TOTAL_TIMEOUT: Duration = Duration::from_secs(5);
+/// Maximum wait for the APS runner response headers.
+pub const APS_RUNNER_FIRST_BYTE_TIMEOUT: Duration = Duration::from_secs(4);
+/// Maximum duration of one blocking APS runner response-body read.
+pub const APS_RUNNER_BLOCKING_READ_TIMEOUT: Duration = Duration::from_millis(250);
+/// Whether `path` belongs to the reserved APS integration family.
+#[must_use]
+pub fn is_aps_family_path(path: &str) -> bool {
+    path == "/integrations/aps" || path.starts_with("/integrations/aps/")
 }
+const APS_RENDERER_V2_CSP: &str = "default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;";
+
+// This document is served with an immutable v2 URL. Any semantic change must
+// ship at a new versioned route so cached v2 bytes retain their contract.
+const APS_RENDERER_V2_DOCUMENT: &str = include_str!("generated/aps_renderer_bootstrap_v2.html");
 
 /// Configuration for the APS `OpenRTB` integration.
 #[cfg(test)]
 #[derive(Debug, Clone, Deserialize, Serialize, Validate)]
+#[serde(deny_unknown_fields)]
 #[validate(schema(function = "validate_inventory_identity_override"))]
 pub struct LegacyApsProviderConfig {
     /// Whether APS integration is enabled.
     #[serde(default = "default_enabled")]
     pub enabled: bool,
-    /// APS account ID. `pub_id` remains a deserialization alias only.
-    #[serde(alias = "pub_id", deserialize_with = "deserialize_account_id")]
+    /// APS account ID.
+    #[serde(deserialize_with = "deserialize_account_id")]
     pub account_id: String,
     /// APS `OpenRTB` endpoint.
     #[serde(default = "default_endpoint")]
@@ -175,9 +123,6 @@ pub struct LegacyApsProviderConfig {
     /// Whether APS script creatives are eligible before winner selection.
     #[serde(default)]
     pub allow_script_creatives: bool,
-    /// Rendering owner for selected APS bids.
-    #[serde(default)]
-    pub rendering_mode: ApsRenderingMode,
     /// APS-authorized inventory domain used instead of the deployment hostname.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     #[validate(custom(function = "validate_inventory_domain"))]
@@ -192,52 +137,15 @@ fn deserialize_account_id<'de, D>(deserializer: D) -> Result<String, D::Error>
 where
     D: serde::Deserializer<'de>,
 {
-    struct AccountIdVisitor;
-
-    impl Visitor<'_> for AccountIdVisitor {
-        type Value = String;
-
-        fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            formatter.write_str("a non-empty string or integer for account_id")
-        }
-
-        fn visit_str<E>(self, value: &str) -> Result<String, E>
-        where
-            E: de::Error,
-        {
-            let value = value.trim();
-            if value.is_empty() {
-                return Err(E::custom("account_id must not be empty"));
-            }
-            if value.len() > MAX_ACCOUNT_ID_BYTES {
-                return Err(E::custom("account_id is too large"));
-            }
-            Ok(value.to_string())
-        }
-
-        fn visit_string<E>(self, value: String) -> Result<String, E>
-        where
-            E: de::Error,
-        {
-            self.visit_str(&value)
-        }
-
-        fn visit_i64<E>(self, value: i64) -> Result<String, E>
-        where
-            E: de::Error,
-        {
-            Ok(value.to_string())
-        }
-
-        fn visit_u64<E>(self, value: u64) -> Result<String, E>
-        where
-            E: de::Error,
-        {
-            Ok(value.to_string())
-        }
+    let value = String::deserialize(deserializer)?;
+    let value = value.trim();
+    if value.is_empty() {
+        return Err(D::Error::custom("account_id must not be empty"));
     }
-
-    deserializer.deserialize_any(AccountIdVisitor)
+    if value.len() > MAX_ACCOUNT_ID_BYTES {
+        return Err(D::Error::custom("account_id is too large"));
+    }
+    Ok(value.to_string())
 }
 
 #[cfg(test)]
@@ -366,7 +274,6 @@ impl Default for LegacyApsProviderConfig {
             timeout_ms: default_timeout_ms(),
             debug: false,
             allow_script_creatives: false,
-            rendering_mode: ApsRenderingMode::TrustedServer,
             inventory_domain: None,
             inventory_page_origin: None,
         }
@@ -380,9 +287,6 @@ pub struct ApsConfig {
     /// Whether browser-side APS integration behavior is enabled.
     #[serde(default)]
     pub enabled: bool,
-    /// Rendering owner for selected APS bids.
-    #[serde(default)]
-    pub rendering_mode: ApsRenderingMode,
 }
 
 #[cfg(test)]
@@ -497,7 +401,7 @@ struct PlannedApsResponsePolicy<'a> {
     account_id: &'a str,
     debug: bool,
     allow_script_creatives: bool,
-    publisher_domain: &'a str,
+    publisher_origin: &'a str,
 }
 
 fn aps_debug_headers(headers: &HeaderMap) -> BTreeMap<String, Vec<String>> {
@@ -579,7 +483,7 @@ fn attach_planned_aps_metadata(
 fn planned_aps_renderer(
     policy: &PlannedApsResponsePolicy<'_>,
     input: ApsRendererInput<'_>,
-) -> Option<BidRenderer> {
+) -> Result<BidRenderSourceV1, AuctionDropReason> {
     let tag_type_value = match input.tag_type {
         ApsTagType::Iframe => "iframe",
         ApsTagType::Script => "script",
@@ -598,11 +502,12 @@ fn planned_aps_renderer(
             }]
         }]
     });
-    let serialized = serde_json::to_vec(&envelope).ok()?;
+    let serialized =
+        serde_json::to_vec(&envelope).map_err(|_| AuctionDropReason::InvalidProviderResponse)?;
     if serialized.len() > MAX_RENDER_ENVELOPE_BYTES {
-        return None;
+        return Err(AuctionDropReason::RenderPayloadTooLarge);
     }
-    Some(BidRenderer::Aps(ApsRendererV1 {
+    let renderer = BidRenderSourceV1::Aps(ApsRendererV1 {
         version: 1,
         account_id: policy.account_id.to_string(),
         bid_id: input.bid_id.to_string(),
@@ -612,10 +517,18 @@ fn planned_aps_renderer(
         aax_response: BASE64_STANDARD.encode(serialized),
         width: input.width,
         height: input.height,
-    }))
+    });
+    let value =
+        serde_json::to_value(&renderer).map_err(|_| AuctionDropReason::InvalidProviderResponse)?;
+    if classify_aps_renderer_v1(&value, policy.publisher_origin)
+        != ApsRendererValidationResult::Accepted
+    {
+        return Err(AuctionDropReason::InvalidProviderResponse);
+    }
+    Ok(renderer)
 }
 
-fn planned_aps_valid_creative_url(value: &str, publisher_domain: &str) -> bool {
+fn planned_aps_valid_creative_url(value: &str, publisher_origin: &str) -> bool {
     if value.len() > MAX_CREATIVE_URL_BYTES {
         return false;
     }
@@ -623,11 +536,10 @@ fn planned_aps_valid_creative_url(value: &str, publisher_domain: &str) -> bool {
         return false;
     };
     parsed.scheme() == "https"
-        && parsed
-            .host_str()
-            .is_some_and(|host| !host.eq_ignore_ascii_case(publisher_domain))
+        && parsed.host_str().is_some()
         && parsed.username().is_empty()
         && parsed.password().is_none()
+        && parsed.origin().ascii_serialization() != publisher_origin
 }
 
 fn planned_aps_parse_bid(
@@ -635,68 +547,91 @@ fn planned_aps_parse_bid(
     value: &Json,
     slots: &HashMap<&str, HashSet<(u32, u32)>>,
     returned_seat: Option<&str>,
-) -> Result<Bid, &'static str> {
-    let bid_id = value
-        .get("id")
-        .and_then(Json::as_str)
-        .filter(|value| !value.is_empty())
-        .ok_or("missing_render_source")?;
+    duplicate_ids: &HashSet<String>,
+) -> Result<Bid, AuctionDropReason> {
+    let object = value.as_object().ok_or(AuctionDropReason::MalformedBid)?;
+    let Some(bid_id_value) = object.get("id") else {
+        return Err(AuctionDropReason::MissingUpstreamBidId);
+    };
+    let bid_id = bid_id_value
+        .as_str()
+        .ok_or(AuctionDropReason::InvalidUpstreamBidId)?;
+    if bid_id.is_empty() {
+        return Err(AuctionDropReason::MissingUpstreamBidId);
+    }
+    if bid_id.len() > MAX_BID_ID_BYTES {
+        return Err(AuctionDropReason::UpstreamBidIdTooLarge);
+    }
+    if bid_id.bytes().any(|byte| byte <= 0x1f || byte == 0x7f) {
+        return Err(AuctionDropReason::InvalidUpstreamBidId);
+    }
+    if duplicate_ids.contains(bid_id) {
+        return Err(AuctionDropReason::DuplicateUpstreamBidId);
+    }
     let slot_id = value
         .get("impid")
         .and_then(Json::as_str)
-        .ok_or("unknown_impid")?;
-    let dimensions = slots.get(slot_id).ok_or("unknown_impid")?;
+        .ok_or(AuctionDropReason::UnknownImpression)?;
+    let dimensions = slots
+        .get(slot_id)
+        .ok_or(AuctionDropReason::UnknownImpression)?;
     let price = value
         .get("price")
         .and_then(Json::as_f64)
         .filter(|price| price.is_finite() && *price >= 0.0)
-        .ok_or("invalid_price")?;
+        .ok_or(AuctionDropReason::InvalidPrice)?;
     if value
         .get("mtype")
         .is_some_and(|mtype| mtype.as_i64() != Some(1))
     {
-        return Err("unsupported_media_type");
-    }
-    let width = value
-        .get("w")
-        .and_then(Json::as_u64)
-        .and_then(|value| u32::try_from(value).ok())
-        .ok_or("invalid_dimensions")?;
-    let height = value
-        .get("h")
-        .and_then(Json::as_u64)
-        .and_then(|value| u32::try_from(value).ok())
-        .ok_or("invalid_dimensions")?;
-    if width == 0 || height == 0 || !dimensions.contains(&(width, height)) {
-        return Err("invalid_dimensions");
+        return Err(AuctionDropReason::UnsupportedMediaType);
+    }
+    let parse_dimension = |field: &str| {
+        let number = value
+            .get(field)
+            .and_then(Json::as_f64)
+            .filter(|number| number.is_finite() && number.fract() == 0.0 && *number > 0.0)
+            .ok_or(AuctionDropReason::InvalidDimensions)?;
+        if number > RENDER_DIMENSION_MAX as f64 {
+            return Err(AuctionDropReason::DimensionsOutOfRange);
+        }
+        u32::try_from(number as u64).map_err(|_| AuctionDropReason::DimensionsOutOfRange)
+    };
+    let width = parse_dimension("w")?;
+    let height = parse_dimension("h")?;
+    if !dimensions.contains(&(width, height)) {
+        return Err(AuctionDropReason::InvalidDimensions);
     }
     let ext = value
         .get("ext")
         .and_then(Json::as_object)
-        .ok_or("missing_render_source")?;
-    let creative_url = ext
-        .get("creativeurl")
-        .and_then(Json::as_str)
-        .ok_or("missing_render_source")?;
-    if !planned_aps_valid_creative_url(creative_url, policy.publisher_domain) {
-        return Err("invalid_creative_url");
+        .ok_or(AuctionDropReason::MissingCreativeUrl)?;
+    let Some(creative_url_value) = ext.get("creativeurl") else {
+        return Err(AuctionDropReason::MissingCreativeUrl);
+    };
+    let creative_url = creative_url_value
+        .as_str()
+        .ok_or(AuctionDropReason::InvalidCreativeUrl)?;
+    if !planned_aps_valid_creative_url(creative_url, policy.publisher_origin) {
+        return Err(AuctionDropReason::InvalidCreativeUrl);
     }
     let tag_type = match ext.get("tagtype").and_then(Json::as_str) {
         Some("iframe") => ApsTagType::Iframe,
         Some("script") if policy.allow_script_creatives => ApsTagType::Script,
-        Some("script") => return Err("script_rendering_disabled"),
-        _ => return Err("unsupported_tagtype"),
+        Some("script") => return Err(AuctionDropReason::ScriptRenderingDisabled),
+        _ => return Err(AuctionDropReason::InvalidTagType),
+    };
+    let creative_id = match value.get("crid") {
+        None => None,
+        Some(Json::String(creative_id)) if creative_id.is_empty() => None,
+        Some(Json::String(creative_id)) => Some(creative_id.clone()),
+        Some(_) => return Err(AuctionDropReason::InvalidCreativeId),
     };
-    let creative_id = value
-        .get("crid")
-        .and_then(Json::as_str)
-        .filter(|creative_id| !creative_id.is_empty())
-        .map(str::to_string);
     if creative_id
         .as_ref()
         .is_some_and(|creative_id| creative_id.len() > MAX_CREATIVE_ID_BYTES)
     {
-        return Err("creative_id_too_large");
+        return Err(AuctionDropReason::CreativeIdTooLarge);
     }
     let renderer = planned_aps_renderer(
         policy,
@@ -709,8 +644,7 @@ fn planned_aps_parse_bid(
             width,
             height,
         },
-    )
-    .ok_or("render_payload_too_large")?;
+    )?;
     let adomain = value
         .get("adomain")
         .and_then(Json::as_array)
@@ -724,6 +658,9 @@ fn planned_aps_parse_bid(
 
     Ok(Bid {
         slot_id: slot_id.to_string(),
+        candidate_id: None,
+        candidate_provider: None,
+        renderer_reservation_id: None,
         price: Some(price),
         currency: DEFAULT_CURRENCY.to_string(),
         creative: None,
@@ -745,10 +682,6 @@ fn planned_aps_parse_bid(
     })
 }
 
-fn increment_planned_aps_reason(reasons: &mut BTreeMap<String, u64>, reason: &'static str) {
-    *reasons.entry(reason.to_string()).or_default() += 1;
-}
-
 fn parse_planned_aps_value(
     value: &Json,
     response_time_ms: u64,
@@ -756,7 +689,6 @@ fn parse_planned_aps_value(
     policy: &PlannedApsResponsePolicy<'_>,
 ) -> AuctionResponse {
     if !value.is_object()
-        || value.get("contextual").is_some()
         || value
             .get("cur")
             .is_some_and(|currency| !currency.is_string())
@@ -766,15 +698,15 @@ fn parse_planned_aps_value(
     {
         return AuctionResponse::error(policy.provider_id, response_time_ms)
             .with_metadata("error_type", json!("parse_response"))
-            .with_metadata("drop_reasons", json!({"unexpected_response_shape": 1}));
+            .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
     }
     if value
         .get("cur")
         .and_then(Json::as_str)
         .is_some_and(|currency| !currency.eq_ignore_ascii_case(DEFAULT_CURRENCY))
     {
-        return AuctionResponse::no_bid(policy.provider_id, response_time_ms)
-            .with_metadata("drop_reasons", json!({"unsupported_currency": 1}));
+        return AuctionResponse::error(policy.provider_id, response_time_ms)
+            .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
     }
 
     let slots = input
@@ -793,9 +725,38 @@ fn parse_planned_aps_value(
         .collect::<HashMap<_, _>>();
     let seatbids = value.get("seatbid").and_then(Json::as_array);
     let seatbid_count = seatbids.map_or(0, Vec::len);
-    let mut reasons = BTreeMap::new();
+    let mut reasons = AuctionDropReasons::new();
     let mut selected: HashMap<String, Bid> = HashMap::new();
     let mut dropped = 0_u64;
+    let mut invalid_slots = HashSet::new();
+    let mut global_invalid = false;
+
+    if value.get("contextual").is_some() {
+        dropped += 1;
+        global_invalid = true;
+        record_auction_drop(&mut reasons, AuctionDropReason::InvalidProviderResponse);
+    }
+
+    let mut id_counts = HashMap::<&str, usize>::new();
+    for candidate in seatbids
+        .into_iter()
+        .flatten()
+        .filter_map(|seatbid| seatbid.get("bid").and_then(Json::as_array))
+        .flatten()
+    {
+        if let Some(bid_id) = candidate.get("id").and_then(Json::as_str)
+            && !bid_id.is_empty()
+            && bid_id.len() <= MAX_BID_ID_BYTES
+            && !bid_id.bytes().any(|byte| byte <= 0x1f || byte == 0x7f)
+        {
+            *id_counts.entry(bid_id).or_default() += 1;
+        }
+    }
+    let duplicate_ids = id_counts
+        .into_iter()
+        .filter(|(_, count)| *count > 1)
+        .map(|(bid_id, _)| bid_id.to_string())
+        .collect::<HashSet<_>>();
 
     for seatbid in seatbids.into_iter().flatten() {
         let returned_seat = seatbid
@@ -804,11 +765,11 @@ fn parse_planned_aps_value(
             .filter(|seat| !seat.is_empty());
         let Some(bids) = seatbid.get("bid").and_then(Json::as_array) else {
             dropped += 1;
-            increment_planned_aps_reason(&mut reasons, "empty_seatbid_bids");
+            record_auction_drop(&mut reasons, AuctionDropReason::EmptySeatBidBids);
             continue;
         };
         for value in bids {
-            match planned_aps_parse_bid(policy, value, &slots, returned_seat) {
+            match planned_aps_parse_bid(policy, value, &slots, returned_seat, &duplicate_ids) {
                 Ok(candidate) => {
                     let replace = selected.get(&candidate.slot_id).is_none_or(|current| {
                         let candidate_price = candidate.price.unwrap_or_default();
@@ -824,42 +785,66 @@ fn parse_planned_aps_value(
                             .is_some()
                         {
                             dropped += 1;
-                            increment_planned_aps_reason(&mut reasons, "lost_to_higher_bid");
+                            record_auction_drop(&mut reasons, AuctionDropReason::LostToHigherBid);
                         }
                     } else {
                         dropped += 1;
-                        increment_planned_aps_reason(&mut reasons, "lost_to_higher_bid");
+                        record_auction_drop(&mut reasons, AuctionDropReason::LostToHigherBid);
                     }
                 }
                 Err(reason) => {
                     dropped += 1;
-                    increment_planned_aps_reason(&mut reasons, reason);
+                    if let Some(slot_id) = value
+                        .get("impid")
+                        .and_then(Json::as_str)
+                        .filter(|slot_id| slots.contains_key(*slot_id))
+                    {
+                        invalid_slots.insert(slot_id.to_string());
+                    } else {
+                        global_invalid = true;
+                    }
+                    record_auction_drop(&mut reasons, reason);
                 }
             }
         }
     }
 
     if seatbid_count == 0 {
-        increment_planned_aps_reason(&mut reasons, "empty_seatbid");
+        record_auction_drop(&mut reasons, AuctionDropReason::EmptySeatBid);
     }
     let accepted = selected.len();
     let metadata = [
         ("seatbid_count".to_string(), json!(seatbid_count)),
         ("accepted_bid_count".to_string(), json!(accepted)),
         ("dropped_bid_count".to_string(), json!(dropped)),
-        ("drop_reasons".to_string(), json!(reasons)),
+        (
+            "invalid_slots".to_string(),
+            json!(
+                invalid_slots
+                    .into_iter()
+                    .map(|slot| (slot, "invalid_provider_response"))
+                    .collect::<HashMap<_, _>>()
+            ),
+        ),
+        (
+            "global_invalid_provider_response".to_string(),
+            json!(global_invalid),
+        ),
     ];
-    let mut response = if selected.is_empty() {
+    let mut response = if selected.is_empty() && global_invalid {
+        AuctionResponse::error(policy.provider_id, response_time_ms)
+    } else if selected.is_empty() {
         AuctionResponse::no_bid(policy.provider_id, response_time_ms)
     } else {
-        AuctionResponse::success(
-            policy.provider_id,
-            selected.into_values().collect(),
-            response_time_ms,
-        )
+        let bids = input
+            .slots()
+            .iter()
+            .filter_map(|slot| selected.remove(&slot.slot().id))
+            .collect();
+        AuctionResponse::success(policy.provider_id, bids, response_time_ms)
     };
     response.metadata.extend(metadata);
-    response
+    response.with_drop_reasons(&reasons)
 }
 
 /// Parse one APS-profile response using only provider-local routed state.
@@ -872,13 +857,21 @@ pub(crate) async fn parse_planned_aps_response(
     response_time_ms: u64,
     debug_request: Option<ApsDebugRequest>,
 ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+    let publisher_origin = input
+        .common_request()
+        .publisher
+        .page_url
+        .as_deref()
+        .and_then(|page_url| Url::parse(page_url).ok())
+        .map(|page_url| page_url.origin().ascii_serialization())
+        .unwrap_or_else(|| format!("https://{}", input.common_request().publisher.domain));
     let policy = PlannedApsResponsePolicy {
         provider_id,
         endpoint,
         account_id: &profile.account_id,
         debug: profile.debug,
         allow_script_creatives: profile.allow_script_creatives,
-        publisher_domain: &input.common_request().publisher.domain,
+        publisher_origin: &publisher_origin,
     };
     let response = response.response;
     let status = response.status();
@@ -945,7 +938,7 @@ pub(crate) async fn parse_planned_aps_response(
             log::warn!("Failed to parse APS profile {provider_id} response JSON: {error}");
             let parsed = AuctionResponse::error(provider_id, response_time_ms)
                 .with_metadata("error_type", json!("parse_response"))
-                .with_metadata("drop_reasons", json!({"unexpected_response_shape": 1}));
+                .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
             return Ok(attach_planned_aps_metadata(
                 parsed,
                 &policy,
@@ -1279,7 +1272,7 @@ impl ApsAuctionProvider {
             })
     }
 
-    fn valid_creative_url(&self, value: &str, publisher_domain: &str) -> bool {
+    fn valid_creative_url(&self, value: &str, publisher_origin: &str) -> bool {
         if value.len() > MAX_CREATIVE_URL_BYTES {
             return false;
         }
@@ -1287,14 +1280,17 @@ impl ApsAuctionProvider {
             return false;
         };
         parsed.scheme() == "https"
-            && parsed
-                .host_str()
-                .is_some_and(|host| !host.eq_ignore_ascii_case(publisher_domain))
+            && parsed.host_str().is_some()
             && parsed.username().is_empty()
             && parsed.password().is_none()
+            && parsed.origin().ascii_serialization() != publisher_origin
     }
 
-    fn build_renderer(&self, input: ApsRendererInput<'_>) -> Option<BidRenderer> {
+    fn build_renderer(
+        &self,
+        input: ApsRendererInput<'_>,
+        publisher_origin: &str,
+    ) -> Result<BidRenderSourceV1, AuctionDropReason> {
         let tag_type_value = match input.tag_type {
             ApsTagType::Iframe => "iframe",
             ApsTagType::Script => "script",
@@ -1313,11 +1309,12 @@ impl ApsAuctionProvider {
                 }]
             }]
         });
-        let serialized = serde_json::to_vec(&envelope).ok()?;
+        let serialized = serde_json::to_vec(&envelope)
+            .map_err(|_| AuctionDropReason::InvalidProviderResponse)?;
         if serialized.len() > MAX_RENDER_ENVELOPE_BYTES {
-            return None;
+            return Err(AuctionDropReason::RenderPayloadTooLarge);
         }
-        Some(BidRenderer::Aps(ApsRendererV1 {
+        let renderer = BidRenderSourceV1::Aps(ApsRendererV1 {
             version: 1,
             account_id: self.config.account_id.clone(),
             bid_id: input.bid_id.to_string(),
@@ -1327,83 +1324,110 @@ impl ApsAuctionProvider {
             aax_response: BASE64_STANDARD.encode(serialized),
             width: input.width,
             height: input.height,
-        }))
-    }
-
-    fn increment_reason(reasons: &mut BTreeMap<String, u64>, reason: &'static str) {
-        *reasons.entry(reason.to_string()).or_default() += 1;
+        });
+        let value = serde_json::to_value(&renderer)
+            .map_err(|_| AuctionDropReason::InvalidProviderResponse)?;
+        if classify_aps_renderer_v1(&value, publisher_origin)
+            != ApsRendererValidationResult::Accepted
+        {
+            return Err(AuctionDropReason::InvalidProviderResponse);
+        }
+        Ok(renderer)
     }
 
     fn parse_bid(
         &self,
         value: &Json,
         slots: &HashMap<&str, &AdSlot>,
-        publisher_domain: &str,
-    ) -> Result<Bid, &'static str> {
-        let bid_id = value
-            .get("id")
-            .and_then(Json::as_str)
-            .filter(|value| !value.is_empty())
-            .ok_or("missing_render_source")?;
+        publisher_origin: &str,
+        duplicate_ids: &HashSet<String>,
+    ) -> Result<Bid, AuctionDropReason> {
+        let object = value.as_object().ok_or(AuctionDropReason::MalformedBid)?;
+        let Some(bid_id_value) = object.get("id") else {
+            return Err(AuctionDropReason::MissingUpstreamBidId);
+        };
+        let bid_id = bid_id_value
+            .as_str()
+            .ok_or(AuctionDropReason::InvalidUpstreamBidId)?;
+        if bid_id.is_empty() {
+            return Err(AuctionDropReason::MissingUpstreamBidId);
+        }
+        if bid_id.len() > MAX_BID_ID_BYTES {
+            return Err(AuctionDropReason::UpstreamBidIdTooLarge);
+        }
+        if bid_id.bytes().any(|byte| byte <= 0x1f || byte == 0x7f) {
+            return Err(AuctionDropReason::InvalidUpstreamBidId);
+        }
+        if duplicate_ids.contains(bid_id) {
+            return Err(AuctionDropReason::DuplicateUpstreamBidId);
+        }
         let slot_id = value
             .get("impid")
             .and_then(Json::as_str)
-            .ok_or("unknown_impid")?;
-        let slot = slots.get(slot_id).ok_or("unknown_impid")?;
+            .ok_or(AuctionDropReason::UnknownImpression)?;
+        let slot = slots
+            .get(slot_id)
+            .ok_or(AuctionDropReason::UnknownImpression)?;
         let price = value
             .get("price")
             .and_then(Json::as_f64)
             .filter(|price| price.is_finite() && *price >= 0.0)
-            .ok_or("invalid_price")?;
+            .ok_or(AuctionDropReason::InvalidPrice)?;
         if value
             .get("mtype")
             .is_some_and(|mtype| mtype.as_i64() != Some(1))
         {
-            return Err("unsupported_media_type");
-        }
-        let width = value
-            .get("w")
-            .and_then(Json::as_u64)
-            .and_then(|value| u32::try_from(value).ok())
-            .ok_or("invalid_dimensions")?;
-        let height = value
-            .get("h")
-            .and_then(Json::as_u64)
-            .and_then(|value| u32::try_from(value).ok())
-            .ok_or("invalid_dimensions")?;
+            return Err(AuctionDropReason::UnsupportedMediaType);
+        }
+        let parse_dimension = |field: &str| {
+            let number = value
+                .get(field)
+                .and_then(Json::as_f64)
+                .filter(|number| number.is_finite() && number.fract() == 0.0 && *number > 0.0)
+                .ok_or(AuctionDropReason::InvalidDimensions)?;
+            if number > RENDER_DIMENSION_MAX as f64 {
+                return Err(AuctionDropReason::DimensionsOutOfRange);
+            }
+            u32::try_from(number as u64).map_err(|_| AuctionDropReason::DimensionsOutOfRange)
+        };
+        let width = parse_dimension("w")?;
+        let height = parse_dimension("h")?;
         if !Self::compatible_dimensions(slot, width, height) {
-            return Err("invalid_dimensions");
+            return Err(AuctionDropReason::InvalidDimensions);
         }
         let ext = value
             .get("ext")
             .and_then(Json::as_object)
-            .ok_or("missing_render_source")?;
-        let creative_url = ext
-            .get("creativeurl")
-            .and_then(Json::as_str)
-            .ok_or("missing_render_source")?;
-        if !self.valid_creative_url(creative_url, publisher_domain) {
-            return Err("invalid_creative_url");
+            .ok_or(AuctionDropReason::MissingCreativeUrl)?;
+        let Some(creative_url_value) = ext.get("creativeurl") else {
+            return Err(AuctionDropReason::MissingCreativeUrl);
+        };
+        let creative_url = creative_url_value
+            .as_str()
+            .ok_or(AuctionDropReason::InvalidCreativeUrl)?;
+        if !self.valid_creative_url(creative_url, publisher_origin) {
+            return Err(AuctionDropReason::InvalidCreativeUrl);
         }
         let tag_type = match ext.get("tagtype").and_then(Json::as_str) {
             Some("iframe") => ApsTagType::Iframe,
             Some("script") if self.config.allow_script_creatives => ApsTagType::Script,
-            Some("script") => return Err("script_rendering_disabled"),
-            _ => return Err("unsupported_tagtype"),
+            Some("script") => return Err(AuctionDropReason::ScriptRenderingDisabled),
+            _ => return Err(AuctionDropReason::InvalidTagType),
+        };
+        let creative_id = match value.get("crid") {
+            None => None,
+            Some(Json::String(creative_id)) if creative_id.is_empty() => None,
+            Some(Json::String(creative_id)) => Some(creative_id.clone()),
+            Some(_) => return Err(AuctionDropReason::InvalidCreativeId),
         };
-        let creative_id = value
-            .get("crid")
-            .and_then(Json::as_str)
-            .filter(|creative_id| !creative_id.is_empty())
-            .map(str::to_string);
         if creative_id
             .as_ref()
             .is_some_and(|creative_id| creative_id.len() > MAX_CREATIVE_ID_BYTES)
         {
-            return Err("creative_id_too_large");
+            return Err(AuctionDropReason::CreativeIdTooLarge);
         }
-        let renderer = self
-            .build_renderer(ApsRendererInput {
+        let renderer = self.build_renderer(
+            ApsRendererInput {
                 bid_id,
                 creative_id: creative_id.clone(),
                 tag_type,
@@ -1411,8 +1435,9 @@ impl ApsAuctionProvider {
                 price,
                 width,
                 height,
-            })
-            .ok_or("render_payload_too_large")?;
+            },
+            publisher_origin,
+        )?;
         let adomain = value
             .get("adomain")
             .and_then(Json::as_array)
@@ -1426,6 +1451,9 @@ impl ApsAuctionProvider {
 
         Ok(Bid {
             slot_id: slot_id.to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(price),
             currency: DEFAULT_CURRENCY.to_string(),
             creative: None,
@@ -1454,7 +1482,6 @@ impl ApsAuctionProvider {
         request: &AuctionRequest,
     ) -> AuctionResponse {
         if !value.is_object()
-            || value.get("contextual").is_some()
             || value
                 .get("cur")
                 .is_some_and(|currency| !currency.is_string())
@@ -1463,15 +1490,15 @@ impl ApsAuctionProvider {
                 .is_some_and(|seatbids| !seatbids.is_array())
         {
             return AuctionResponse::error(APS_INTEGRATION_ID, response_time_ms)
-                .with_metadata("drop_reasons", json!({"unexpected_response_shape": 1}));
+                .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
         }
         if value
             .get("cur")
             .and_then(Json::as_str)
             .is_some_and(|currency| !currency.eq_ignore_ascii_case(DEFAULT_CURRENCY))
         {
-            return AuctionResponse::no_bid(APS_INTEGRATION_ID, response_time_ms)
-                .with_metadata("drop_reasons", json!({"unsupported_currency": 1}));
+            return AuctionResponse::error(APS_INTEGRATION_ID, response_time_ms)
+                .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
         }
 
         let slots: HashMap<&str, &AdSlot> = request
@@ -1481,18 +1508,54 @@ impl ApsAuctionProvider {
             .collect();
         let seatbids = value.get("seatbid").and_then(Json::as_array);
         let seatbid_count = seatbids.map_or(0, Vec::len);
-        let mut reasons = BTreeMap::new();
+        let mut reasons = AuctionDropReasons::new();
         let mut selected: HashMap<String, Bid> = HashMap::new();
         let mut dropped = 0_u64;
+        let mut invalid_slots = HashSet::new();
+        let mut global_invalid = false;
+        if value.get("contextual").is_some() {
+            dropped += 1;
+            global_invalid = true;
+            record_auction_drop(&mut reasons, AuctionDropReason::InvalidProviderResponse);
+        }
+
+        let mut id_counts = HashMap::<&str, usize>::new();
+        for candidate in seatbids
+            .into_iter()
+            .flatten()
+            .filter_map(|seatbid| seatbid.get("bid").and_then(Json::as_array))
+            .flatten()
+        {
+            if let Some(bid_id) = candidate.get("id").and_then(Json::as_str)
+                && !bid_id.is_empty()
+                && bid_id.len() <= MAX_BID_ID_BYTES
+                && !bid_id.bytes().any(|byte| byte <= 0x1f || byte == 0x7f)
+            {
+                *id_counts.entry(bid_id).or_default() += 1;
+            }
+        }
+        let duplicate_ids: HashSet<String> = id_counts
+            .into_iter()
+            .filter(|(_, count)| *count > 1)
+            .map(|(bid_id, _)| bid_id.to_string())
+            .collect();
+
+        let publisher_origin = request
+            .publisher
+            .page_url
+            .as_deref()
+            .and_then(|page_url| Url::parse(page_url).ok())
+            .map(|page_url| page_url.origin().ascii_serialization())
+            .unwrap_or_else(|| format!("https://{}", request.publisher.domain));
 
         for seatbid in seatbids.into_iter().flatten() {
             let Some(bids) = seatbid.get("bid").and_then(Json::as_array) else {
                 dropped += 1;
-                Self::increment_reason(&mut reasons, "empty_seatbid_bids");
+                record_auction_drop(&mut reasons, AuctionDropReason::EmptySeatBidBids);
                 continue;
             };
             for value in bids {
-                match self.parse_bid(value, &slots, &request.publisher.domain) {
+                match self.parse_bid(value, &slots, &publisher_origin, &duplicate_ids) {
                     Ok(candidate) => {
                         let replace = selected.get(&candidate.slot_id).is_none_or(|current| {
                             let candidate_price = candidate.price.unwrap_or_default();
@@ -1508,42 +1571,69 @@ impl ApsAuctionProvider {
                                 .is_some()
                             {
                                 dropped += 1;
-                                Self::increment_reason(&mut reasons, "lost_to_higher_bid");
+                                record_auction_drop(
+                                    &mut reasons,
+                                    AuctionDropReason::LostToHigherBid,
+                                );
                             }
                         } else {
                             dropped += 1;
-                            Self::increment_reason(&mut reasons, "lost_to_higher_bid");
+                            record_auction_drop(&mut reasons, AuctionDropReason::LostToHigherBid);
                         }
                     }
                     Err(reason) => {
                         dropped += 1;
-                        Self::increment_reason(&mut reasons, reason);
+                        if let Some(slot_id) = value
+                            .get("impid")
+                            .and_then(Json::as_str)
+                            .filter(|slot_id| slots.contains_key(*slot_id))
+                        {
+                            invalid_slots.insert(slot_id.to_string());
+                        } else {
+                            global_invalid = true;
+                        }
+                        record_auction_drop(&mut reasons, reason);
                     }
                 }
             }
         }
 
         if seatbid_count == 0 {
-            Self::increment_reason(&mut reasons, "empty_seatbid");
+            record_auction_drop(&mut reasons, AuctionDropReason::EmptySeatBid);
         }
         let accepted = selected.len();
         let metadata = [
             ("seatbid_count".to_string(), json!(seatbid_count)),
             ("accepted_bid_count".to_string(), json!(accepted)),
             ("dropped_bid_count".to_string(), json!(dropped)),
-            ("drop_reasons".to_string(), json!(reasons)),
+            (
+                "invalid_slots".to_string(),
+                json!(
+                    invalid_slots
+                        .into_iter()
+                        .map(|slot| (slot, "invalid_provider_response"))
+                        .collect::<HashMap<_, _>>()
+                ),
+            ),
+            (
+                "global_invalid_provider_response".to_string(),
+                json!(global_invalid),
+            ),
         ];
-        let mut response = if selected.is_empty() {
+        let mut response = if selected.is_empty() && global_invalid {
+            AuctionResponse::error(APS_INTEGRATION_ID, response_time_ms)
+        } else if selected.is_empty() {
             AuctionResponse::no_bid(APS_INTEGRATION_ID, response_time_ms)
         } else {
-            AuctionResponse::success(
-                APS_INTEGRATION_ID,
-                selected.into_values().collect(),
-                response_time_ms,
-            )
+            let bids = request
+                .slots
+                .iter()
+                .filter_map(|slot| selected.remove(&slot.id))
+                .collect();
+            AuctionResponse::success(APS_INTEGRATION_ID, bids, response_time_ms)
         };
         response.metadata.extend(metadata);
-        response
+        response.with_drop_reasons(&reasons)
     }
 
     async fn parse_response_inner(
@@ -1615,7 +1705,7 @@ impl ApsAuctionProvider {
             Err(error) => {
                 log::warn!("Failed to parse APS response JSON: {error}");
                 let parsed = AuctionResponse::error(APS_INTEGRATION_ID, response_time_ms)
-                    .with_metadata("drop_reasons", json!({"unexpected_response_shape": 1}));
+                    .with_drop_reason(AuctionDropReason::InvalidProviderResponse);
                 return Ok(self.attach_debug_metadata(
                     parsed,
                     debug_enabled,
@@ -1631,7 +1721,7 @@ impl ApsAuctionProvider {
                 "APS cannot parse a successful bid response without the original auction request context"
             );
             let response = AuctionResponse::error(APS_INTEGRATION_ID, response_time_ms)
-                .with_metadata("drop_reasons", json!({"missing_request_context": 1}));
+                .with_drop_reason(AuctionDropReason::MissingRequestContext);
             return Ok(self.attach_debug_metadata(
                 response,
                 debug_enabled,
@@ -1801,66 +1891,273 @@ impl AuctionProvider for ApsAuctionProvider {
 }
 
 #[derive(Debug)]
-struct ApsRendererIntegration {
-    rendering_mode: ApsRenderingMode,
+pub(crate) struct ApsV1Integration {
+    enabled: bool,
 }
 
-#[async_trait(?Send)]
-impl IntegrationProxy for ApsRendererIntegration {
-    fn integration_name(&self) -> &'static str {
-        APS_INTEGRATION_ID
+impl ApsV1Integration {
+    fn mark_exact_headers(mut response: http::Response<EdgeBody>) -> http::Response<EdgeBody> {
+        response
+            .extensions_mut()
+            .insert(crate::platform::ExactResponseHeadersV1);
+        response
     }
 
-    fn routes(&self) -> Vec<IntegrationEndpoint> {
-        (self.rendering_mode == ApsRenderingMode::TrustedServer)
-            .then(|| IntegrationEndpoint::get(APS_RENDERER_ROUTE))
-            .into_iter()
-            .collect()
+    pub(crate) fn from_plan(plan: &crate::auction::AuctionPlan) -> Self {
+        Self {
+            enabled: plan.enabled() && plan.has_profile(APS_INTEGRATION_ID),
+        }
     }
 
-    async fn handle(
-        &self,
-        _settings: &Settings,
-        _services: &RuntimeServices,
-        request: http::Request<EdgeBody>,
+    fn local_status(
+        status: StatusCode,
+        allow_get: bool,
     ) -> Result<http::Response<EdgeBody>, Report<TrustedServerError>> {
-        if request.method() != Method::GET || request.uri().path() != APS_RENDERER_ROUTE {
-            return http::Response::builder()
-                .status(StatusCode::NOT_FOUND)
-                .body(EdgeBody::from("Not Found"))
-                .change_context(TrustedServerError::Integration {
-                    integration: APS_INTEGRATION_ID.to_string(),
-                    message: "Failed to build APS not-found response".to_string(),
-                });
+        let mut builder = http::Response::builder()
+            .status(status)
+            .header(header::CACHE_CONTROL, "no-store");
+        if allow_get {
+            builder = builder.header(header::ALLOW, "GET");
         }
+        builder
+            .body(EdgeBody::empty())
+            .change_context(TrustedServerError::Integration {
+                integration: APS_INTEGRATION_ID.to_string(),
+                message: "Failed to build local APS route response".to_string(),
+            })
+            .map(Self::mark_exact_headers)
+    }
+
+    fn renderer_response() -> Result<http::Response<EdgeBody>, Report<TrustedServerError>> {
         http::Response::builder()
             .status(StatusCode::OK)
             .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+            .header(header::CACHE_CONTROL, "public, max-age=31536000, immutable")
             .header("x-content-type-options", "nosniff")
             .header("referrer-policy", "no-referrer")
-            .header(header::CONTENT_SECURITY_POLICY, APS_RENDERER_CSP)
-            .body(EdgeBody::from(APS_RENDERER_DOCUMENT))
+            .header(header::CONTENT_SECURITY_POLICY, APS_RENDERER_V2_CSP)
+            .body(EdgeBody::from(APS_RENDERER_V2_DOCUMENT))
             .change_context(TrustedServerError::Integration {
                 integration: APS_INTEGRATION_ID.to_string(),
-                message: "Failed to build APS renderer response".to_string(),
+                message: "Failed to build APS renderer v2 response".to_string(),
             })
+            .map(Self::mark_exact_headers)
+    }
+
+    fn singleton_proxy_header(
+        evidence: &ProxyHeaderEvidenceV1,
+        required: bool,
+    ) -> Result<Option<&[u8]>, &'static str> {
+        match evidence {
+            ProxyHeaderEvidenceV1::Occurrences(values) => match values.as_slice() {
+                [] if !required => Ok(None),
+                [value] => Ok(Some(value.as_slice())),
+                [] => Err("missing_header"),
+                _ => Err("duplicate_header"),
+            },
+            ProxyHeaderEvidenceV1::Combined(value) if !value.contains(&b',') => {
+                Ok(Some(value.as_slice()))
+            }
+            ProxyHeaderEvidenceV1::Combined(_) => Err("listed_header"),
+            ProxyHeaderEvidenceV1::Unavailable => Err("unavailable_header"),
+        }
+    }
+
+    fn trim_http_ows(value: &[u8]) -> &[u8] {
+        let start = value
+            .iter()
+            .position(|byte| !matches!(byte, b' ' | b'\t'))
+            .unwrap_or(value.len());
+        let end = value
+            .iter()
+            .rposition(|byte| !matches!(byte, b' ' | b'\t'))
+            .map_or(start, |index| index + 1);
+        &value[start..end]
+    }
+
+    fn validate_runner_content_type(evidence: &ProxyHeaderEvidenceV1) -> Result<(), &'static str> {
+        let raw = Self::singleton_proxy_header(evidence, true)?;
+        let value = std::str::from_utf8(raw.ok_or("missing_content_type")?)
+            .map_err(|_| "invalid_content_type")?;
+        if !value.is_ascii() {
+            return Err("invalid_content_type");
+        }
+        if value.as_bytes().contains(&b',') {
+            return Err("listed_content_type");
+        }
+
+        let mut parts = value.split(';');
+        let essence = parts
+            .next()
+            .ok_or("missing_content_type")?
+            .trim_matches([' ', '\t']);
+        if !essence.eq_ignore_ascii_case("application/javascript")
+            && !essence.eq_ignore_ascii_case("text/javascript")
+        {
+            return Err("rejected_content_type");
+        }
+        let Some(parameter) = parts.next() else {
+            return Ok(());
+        };
+        if parts.next().is_some() {
+            return Err("duplicate_content_type_parameter");
+        }
+        let (name, value) = parameter
+            .split_once('=')
+            .ok_or("invalid_content_type_parameter")?;
+        if !name
+            .trim_matches([' ', '\t'])
+            .eq_ignore_ascii_case("charset")
+            || !value
+                .trim_matches([' ', '\t'])
+                .eq_ignore_ascii_case("utf-8")
+        {
+            return Err("rejected_content_type_parameter");
+        }
+        Ok(())
+    }
+
+    fn validate_runner_content_encoding(
+        evidence: &ProxyHeaderEvidenceV1,
+    ) -> Result<(), &'static str> {
+        let Some(raw) = Self::singleton_proxy_header(evidence, false)? else {
+            return Ok(());
+        };
+        let value = Self::trim_http_ows(raw);
+        if value.contains(&b',') || !value.eq_ignore_ascii_case(b"identity") {
+            return Err("rejected_content_encoding");
+        }
+        Ok(())
+    }
+
+    fn validate_runner_content_length(
+        evidence: &ProxyHeaderEvidenceV1,
+    ) -> Result<Option<usize>, &'static str> {
+        let Some(value) = Self::singleton_proxy_header(evidence, false)? else {
+            return Ok(None);
+        };
+        if value.is_empty()
+            || value.contains(&b',')
+            || !value.iter().all(u8::is_ascii_digit)
+            || (value.len() > 1 && value[0] == b'0')
+        {
+            return Err("invalid_content_length");
+        }
+        let value = std::str::from_utf8(value)
+            .map_err(|_| "invalid_content_length")?
+            .parse::<usize>()
+            .map_err(|_| "invalid_content_length")?;
+        if value > APS_RUNNER_MAX_RESPONSE_BYTES {
+            return Err("content_length_overflow");
+        }
+        Ok(Some(value))
+    }
+
+    fn validate_runner_response(response: &RawProxyResponseV1) -> Result<(), &'static str> {
+        if response.evidence.status != StatusCode::OK.as_u16() {
+            return Err("rejected_status");
+        }
+        Self::validate_runner_content_type(&response.evidence.content_type)?;
+        Self::validate_runner_content_encoding(&response.evidence.content_encoding)?;
+        let declared_length =
+            Self::validate_runner_content_length(&response.evidence.content_length)?;
+        if response.body.len() > APS_RUNNER_MAX_RESPONSE_BYTES {
+            return Err("body_overflow");
+        }
+        if declared_length.is_some_and(|length| length != response.body.len()) {
+            return Err("content_length_mismatch");
+        }
+        std::str::from_utf8(&response.body).map_err(|_| "invalid_utf8")?;
+        Ok(())
+    }
+
+    async fn runner_response(
+        services: &RuntimeServices,
+    ) -> Result<http::Response<EdgeBody>, &'static str> {
+        let outbound_request = http::Request::builder()
+            .method(Method::GET)
+            .uri(APS_RUNNER_UPSTREAM_URL)
+            .header(header::ACCEPT_ENCODING, "identity")
+            .header(header::CACHE_CONTROL, "no-cache")
+            .header(header::PRAGMA, "no-cache")
+            .body(EdgeBody::empty())
+            .map_err(|_| "request_build_failed")?;
+        let backend = ensure_integration_backend_with_transport_timeouts(
+            services,
+            APS_RUNNER_UPSTREAM_URL,
+            APS_INTEGRATION_ID,
+            APS_RUNNER_FIRST_BYTE_TIMEOUT,
+            APS_RUNNER_BLOCKING_READ_TIMEOUT,
+        )
+        .map_err(|_| "backend_unavailable")?;
+        let response = services
+            .http_client()
+            .send_raw_proxy_v1(
+                PlatformHttpRequest::new(outbound_request, backend).with_cache_bypass(),
+                RawProxyPolicyV1 {
+                    total_timeout: APS_RUNNER_TOTAL_TIMEOUT,
+                    first_byte_timeout: APS_RUNNER_FIRST_BYTE_TIMEOUT,
+                    blocking_read_timeout: APS_RUNNER_BLOCKING_READ_TIMEOUT,
+                    max_response_bytes: APS_RUNNER_MAX_RESPONSE_BYTES,
+                },
+            )
+            .await
+            .map_err(|_| "transport_failed")?;
+        Self::validate_runner_response(&response)?;
+
+        http::Response::builder()
+            .status(StatusCode::OK)
+            .header(
+                header::CONTENT_TYPE,
+                "application/javascript; charset=utf-8",
+            )
+            .header(header::ACCESS_CONTROL_ALLOW_ORIGIN, "*")
+            .header("cross-origin-resource-policy", "cross-origin")
+            .header("x-content-type-options", "nosniff")
+            .header("referrer-policy", "no-referrer")
+            .body(EdgeBody::from(response.body))
+            .map(Self::mark_exact_headers)
+            .map_err(|_| "response_build_failed")
     }
 }
 
-impl IntegrationHeadInjector for ApsRendererIntegration {
-    fn integration_id(&self) -> &'static str {
+#[async_trait(?Send)]
+impl IntegrationProxy for ApsV1Integration {
+    fn integration_name(&self) -> &'static str {
         APS_INTEGRATION_ID
     }
 
-    fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
+    fn routes(&self) -> Vec<IntegrationEndpoint> {
         Vec::new()
     }
 
-    fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-        (self.rendering_mode == ApsRenderingMode::PublisherNative)
-            .then_some(("data-ts-aps-rendering-mode", "publisher_native"))
-            .into_iter()
-            .collect()
+    async fn handle(
+        &self,
+        _settings: &Settings,
+        services: &RuntimeServices,
+        request: http::Request<EdgeBody>,
+    ) -> Result<http::Response<EdgeBody>, Report<TrustedServerError>> {
+        let path = request.uri().path();
+        if !path.starts_with("/integrations/aps/") {
+            return Self::local_status(StatusCode::NOT_FOUND, false);
+        }
+        if !self.enabled {
+            return Self::local_status(StatusCode::NOT_FOUND, false);
+        }
+        if request.method() != Method::GET {
+            return Self::local_status(StatusCode::METHOD_NOT_ALLOWED, true);
+        }
+        match path {
+            APS_RENDERER_V2_ROUTE => Self::renderer_response(),
+            APS_RUNNER_ROUTE => match Self::runner_response(services).await {
+                Ok(response) => Ok(response),
+                Err(reason) => {
+                    log::warn!("APS runner proxy failed closed: {reason}");
+                    Self::local_status(StatusCode::BAD_GATEWAY, false)
+                }
+            },
+            _ => Self::local_status(StatusCode::NOT_FOUND, false),
+        }
     }
 }
 
@@ -1873,23 +2170,16 @@ pub fn register_for_plan(
     settings: &Settings,
     plan: &crate::auction::AuctionPlan,
 ) -> Result<Option<IntegrationRegistration>, Report<TrustedServerError>> {
-    if !plan.has_profile(APS_INTEGRATION_ID) {
+    if !plan.enabled() || !plan.has_profile(APS_INTEGRATION_ID) {
         return Ok(None);
     }
-    let rendering_mode = settings
-        .integration_config::<ApsConfig>(APS_INTEGRATION_ID)?
-        .map(|config| config.rendering_mode)
-        .unwrap_or_default();
-    let integration = Arc::new(ApsRendererIntegration { rendering_mode });
-    let registration = IntegrationRegistration::builder(APS_INTEGRATION_ID)
-        .without_js()
-        .with_head_injector(integration.clone());
-    let registration = if rendering_mode == ApsRenderingMode::TrustedServer {
-        registration.with_proxy(integration)
-    } else {
-        registration
-    };
-    Ok(Some(registration.build()))
+    let _browser_config = settings.integration_config::<ApsConfig>(APS_INTEGRATION_ID)?;
+    Ok(Some(
+        IntegrationRegistration::builder(APS_INTEGRATION_ID)
+            .without_js()
+            .with_empty_browser_config_v1()?
+            .build(),
+    ))
 }
 
 /// Register the APS auction provider when enabled.
@@ -1902,19 +2192,15 @@ pub fn register_for_plan(
 pub fn register(
     settings: &Settings,
 ) -> Result<Option<IntegrationRegistration>, Report<TrustedServerError>> {
-    let Some(config) =
+    let Some(_config) =
         settings.integration_config::<LegacyApsProviderConfig>(APS_INTEGRATION_ID)?
     else {
         return Ok(None);
     };
     let mut browser_settings = settings.clone();
-    browser_settings.integrations.insert_config(
-        APS_INTEGRATION_ID,
-        &ApsConfig {
-            enabled: true,
-            rendering_mode: config.rendering_mode,
-        },
-    )?;
+    browser_settings
+        .integrations
+        .insert_config(APS_INTEGRATION_ID, &ApsConfig { enabled: true })?;
     register_for_plan(
         &browser_settings,
         &crate::auction::AuctionPlan::compile(AuctionPlanConfig {
@@ -1953,11 +2239,6 @@ pub fn register_providers(
             "APS debug mode is ON — raw request and response data, including creative markup, will be included in client-visible /auction responses"
         );
     }
-    if config.rendering_mode == ApsRenderingMode::PublisherNative && config.allow_script_creatives {
-        log::warn!(
-            "APS publisher-native rendering with script creatives is ON; selected bidder scripts execute with publisher-origin privileges"
-        );
-    }
     Ok(vec![Arc::new(ApsAuctionProvider::new(config))])
 }
 
@@ -1966,12 +2247,15 @@ mod tests {
     use super::*;
     use crate::auction::test_support::canonical_parity_auction_request;
     use crate::auction::types::{
-        AdFormat, AdSlot, AuctionContext, AuctionRequest, BidStatus, PublisherInfo, UserInfo,
+        AdFormat, AdSlot, AuctionContext, AuctionDropReason, AuctionRequest, BidStatus,
+        PublisherInfo, UserInfo,
     };
-    use crate::integrations::IntegrationDocumentState;
     use crate::platform::test_support::{
         StubHttpClient, build_services_with_http_client, noop_services,
     };
+    use crate::platform::{
+        ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1,
+    };
     use crate::test_support::tests::create_test_settings;
     use serde_json::json;
 
@@ -1983,7 +2267,6 @@ mod tests {
             timeout_ms: 800,
             debug: false,
             allow_script_creatives: false,
-            rendering_mode: ApsRenderingMode::TrustedServer,
             inventory_domain: None,
             inventory_page_origin: None,
         }
@@ -2037,40 +2320,420 @@ mod tests {
         })
     }
 
-    fn parse_with_context(
-        provider: &ApsAuctionProvider,
-        response: PlatformResponse,
-    ) -> AuctionResponse {
-        let settings = create_test_settings();
-        let services = noop_services();
-        let downstream = http::Request::builder()
-            .uri("https://publisher.example/auction")
-            .body(EdgeBody::empty())
-            .expect("should build downstream request");
-        let context = AuctionContext {
-            settings: &settings,
-            request: &downstream,
-            timeout_ms: 321,
-            transport_timeout_ms: 321,
-            provider_responses: None,
-            services: &services,
-        };
-        let auction_request = request();
-        let debug_request = provider.config.debug.then(|| {
-            let openrtb = provider.build_openrtb_request(&auction_request, &context);
-            let body = ApsAuctionProvider::serialize_openrtb_request(&openrtb)
-                .expect("should serialize APS debug request");
-            ApsDebugRequest {
-                body: String::from_utf8_lossy(&body).into_owned(),
-                headers: BTreeMap::from([(
-                    header::CONTENT_TYPE.as_str().to_string(),
-                    vec!["application/json".to_string()],
-                )]),
-            }
-        });
-        futures::executor::block_on(
-            provider.parse_response_with_context_and_state(
-                response,
+    fn drop_count(response: &AuctionResponse, reason: AuctionDropReason) -> u64 {
+        response.metadata["drop_reasons"][reason.as_str()]
+            .as_u64()
+            .unwrap_or_default()
+    }
+
+    #[derive(serde::Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct RendererCorpus {
+        publisher_origin: String,
+        base_descriptor: Json,
+        vectors: Vec<RendererCorpusVector>,
+    }
+
+    #[derive(serde::Deserialize)]
+    struct RendererCorpusVector {
+        id: String,
+        expected: String,
+        operation: Json,
+    }
+
+    fn corpus_value<'a>(operation: &'a Json, field: &str) -> &'a Json {
+        operation
+            .get(field)
+            .unwrap_or_else(|| panic!("should include corpus operation field {field}"))
+    }
+
+    fn corpus_string<'a>(operation: &'a Json, field: &str) -> &'a str {
+        corpus_value(operation, field)
+            .as_str()
+            .unwrap_or_else(|| panic!("corpus operation field {field} should be a string"))
+    }
+
+    fn corpus_usize(operation: &Json, field: &str) -> usize {
+        corpus_value(operation, field)
+            .as_u64()
+            .and_then(|value| usize::try_from(value).ok())
+            .unwrap_or_else(|| panic!("corpus operation field {field} should be a usize"))
+    }
+
+    fn set_json_path(root: &mut Json, path: &[Json], value: Json) {
+        let (segment, tail) = path
+            .split_first()
+            .expect("corpus JSON path should not be empty");
+        if tail.is_empty() {
+            if let Some(field) = segment.as_str() {
+                root.as_object_mut()
+                    .expect("corpus string path should address an object")
+                    .insert(field.to_string(), value);
+            } else {
+                let index = segment
+                    .as_u64()
+                    .and_then(|index| usize::try_from(index).ok())
+                    .expect("corpus numeric path should be a usize");
+                let slot = root
+                    .as_array_mut()
+                    .and_then(|array| array.get_mut(index))
+                    .expect("corpus numeric path should address an array element");
+                *slot = value;
+            }
+            return;
+        }
+
+        let child = if let Some(field) = segment.as_str() {
+            root.as_object_mut()
+                .and_then(|object| object.get_mut(field))
+                .expect("corpus string path should address an object field")
+        } else {
+            let index = segment
+                .as_u64()
+                .and_then(|index| usize::try_from(index).ok())
+                .expect("corpus numeric path should be a usize");
+            root.as_array_mut()
+                .and_then(|array| array.get_mut(index))
+                .expect("corpus numeric path should address an array element")
+        };
+        set_json_path(child, tail, value);
+    }
+
+    fn delete_json_path(root: &mut Json, path: &[Json]) {
+        let (segment, tail) = path
+            .split_first()
+            .expect("corpus JSON path should not be empty");
+        if tail.is_empty() {
+            let field = segment
+                .as_str()
+                .expect("corpus delete path should end in an object field");
+            root.as_object_mut()
+                .expect("corpus delete path should address an object")
+                .remove(field);
+            return;
+        }
+
+        let child = if let Some(field) = segment.as_str() {
+            root.as_object_mut()
+                .and_then(|object| object.get_mut(field))
+                .expect("corpus string path should address an object field")
+        } else {
+            let index = segment
+                .as_u64()
+                .and_then(|index| usize::try_from(index).ok())
+                .expect("corpus numeric path should be a usize");
+            root.as_array_mut()
+                .and_then(|array| array.get_mut(index))
+                .expect("corpus numeric path should address an array element")
+        };
+        delete_json_path(child, tail);
+    }
+
+    fn descriptor_field(descriptor: &mut Json, field: &str, value: Json) {
+        descriptor
+            .as_object_mut()
+            .expect("corpus descriptor should be an object")
+            .insert(field.to_string(), value);
+    }
+
+    fn materialize_renderer_corpus_vector(
+        corpus: &RendererCorpus,
+        vector: &RendererCorpusVector,
+    ) -> Json {
+        let mut descriptor = corpus.base_descriptor.clone();
+        let mut envelope: Json = serde_json::from_str(include_str!(
+            "../../../trusted-server-js/lib/test/fixtures/aps-renderer-v1.json"
+        ))
+        .expect("should parse shared APS renderer fixture");
+        let operation = &vector.operation;
+        let kind = corpus_string(operation, "kind");
+        let mut encoded_envelope = None;
+
+        match kind {
+            "none" => {}
+            "descriptor-delete" => {
+                descriptor
+                    .as_object_mut()
+                    .expect("corpus descriptor should be an object")
+                    .remove(corpus_string(operation, "field"));
+            }
+            "descriptor-set" => descriptor_field(
+                &mut descriptor,
+                corpus_string(operation, "field"),
+                corpus_value(operation, "value").clone(),
+            ),
+            "descriptor-repeat" => {
+                let mut repeated =
+                    corpus_string(operation, "unit").repeat(corpus_usize(operation, "count"));
+                if let Some(suffix) = operation.get("suffix").and_then(Json::as_str) {
+                    repeated.push_str(suffix);
+                }
+                descriptor_field(
+                    &mut descriptor,
+                    corpus_string(operation, "field"),
+                    json!(repeated),
+                );
+            }
+            "bid-id-repeat" => {
+                let mut repeated =
+                    corpus_string(operation, "unit").repeat(corpus_usize(operation, "count"));
+                if let Some(suffix) = operation.get("suffix").and_then(Json::as_str) {
+                    repeated.push_str(suffix);
+                }
+                descriptor_field(&mut descriptor, "bidId", json!(repeated));
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!("id"),
+                    ],
+                    json!(repeated),
+                );
+            }
+            "dimension" => {
+                let field = corpus_string(operation, "field");
+                let envelope_field = match field {
+                    "width" => "w",
+                    "height" => "h",
+                    _ => panic!("corpus dimension field should be width or height"),
+                };
+                let value = corpus_value(operation, "value").clone();
+                descriptor_field(&mut descriptor, field, value.clone());
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!(envelope_field),
+                    ],
+                    value,
+                );
+            }
+            "dimensions" => {
+                let width = corpus_value(operation, "width").clone();
+                let height = corpus_value(operation, "height").clone();
+                descriptor_field(&mut descriptor, "width", width.clone());
+                descriptor_field(&mut descriptor, "height", height.clone());
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!("w"),
+                    ],
+                    width,
+                );
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!("h"),
+                    ],
+                    height,
+                );
+            }
+            "creative-url" => {
+                let value = corpus_string(operation, "value").to_string();
+                descriptor_field(&mut descriptor, "creativeUrl", json!(value));
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!("ext"),
+                        json!("creativeurl"),
+                    ],
+                    json!(value),
+                );
+            }
+            "creative-url-bytes" => {
+                let prefix = "https://creative.example/";
+                let bytes = corpus_usize(operation, "bytes");
+                let value = format!(
+                    "{prefix}{}",
+                    "a".repeat(
+                        bytes
+                            .checked_sub(prefix.len())
+                            .expect("corpus URL size should include its prefix")
+                    )
+                );
+                descriptor_field(&mut descriptor, "creativeUrl", json!(value));
+                set_json_path(
+                    &mut envelope,
+                    &[
+                        json!("seatbid"),
+                        json!(0),
+                        json!("bid"),
+                        json!(0),
+                        json!("ext"),
+                        json!("creativeurl"),
+                    ],
+                    json!(value),
+                );
+            }
+            "aax-literal" => {
+                encoded_envelope = Some(corpus_string(operation, "value").to_string());
+            }
+            "aax-bytes" => {
+                let bytes: Vec<u8> = corpus_value(operation, "values")
+                    .as_array()
+                    .expect("corpus byte vector should be an array")
+                    .iter()
+                    .map(|value| {
+                        value
+                            .as_u64()
+                            .and_then(|value| u8::try_from(value).ok())
+                            .expect("corpus byte vector should contain u8 values")
+                    })
+                    .collect();
+                encoded_envelope = Some(BASE64_STANDARD.encode(bytes));
+            }
+            "aax-raw-json" => {
+                encoded_envelope =
+                    Some(BASE64_STANDARD.encode(corpus_string(operation, "value").as_bytes()));
+            }
+            "aax-decoded-bytes" => {
+                let mut serialized =
+                    serde_json::to_string(&envelope).expect("should serialize corpus envelope");
+                let target = corpus_usize(operation, "bytes");
+                serialized.push_str(
+                    &" ".repeat(
+                        target
+                            .checked_sub(serialized.len())
+                            .expect("corpus decoded size should exceed fixture size"),
+                    ),
+                );
+                encoded_envelope = Some(BASE64_STANDARD.encode(serialized.as_bytes()));
+            }
+            "aax-raw-price" => {
+                let serialized =
+                    serde_json::to_string(&envelope).expect("should serialize corpus envelope");
+                let replacement = format!("\"price\":{}", corpus_string(operation, "value"));
+                let raw = serialized.replacen("\"price\":1.23", &replacement, 1);
+                assert_ne!(raw, serialized, "should replace the corpus fixture price");
+                encoded_envelope = Some(BASE64_STANDARD.encode(raw.as_bytes()));
+            }
+            "envelope-set" => {
+                let path = corpus_value(operation, "path")
+                    .as_array()
+                    .expect("corpus path should be an array");
+                set_json_path(
+                    &mut envelope,
+                    path,
+                    corpus_value(operation, "value").clone(),
+                );
+            }
+            "envelope-delete" => {
+                let path = corpus_value(operation, "path")
+                    .as_array()
+                    .expect("corpus path should be an array");
+                delete_json_path(&mut envelope, path);
+            }
+            "duplicate-seat" => {
+                let seats = envelope
+                    .get_mut("seatbid")
+                    .and_then(Json::as_array_mut)
+                    .expect("corpus fixture should contain a seat array");
+                let first = seats
+                    .first()
+                    .cloned()
+                    .expect("corpus fixture should contain one seat");
+                seats.push(first);
+            }
+            "duplicate-bid" => {
+                let bids = envelope
+                    .get_mut("seatbid")
+                    .and_then(Json::as_array_mut)
+                    .and_then(|seats| seats.first_mut())
+                    .and_then(|seat| seat.get_mut("bid"))
+                    .and_then(Json::as_array_mut)
+                    .expect("corpus fixture should contain a bid array");
+                let first = bids
+                    .first()
+                    .cloned()
+                    .expect("corpus fixture should contain one bid");
+                bids.push(first);
+            }
+            _ => panic!("unknown APS renderer corpus operation: {kind}"),
+        }
+
+        let encoded = encoded_envelope.unwrap_or_else(|| {
+            BASE64_STANDARD.encode(
+                serde_json::to_vec(&envelope).expect("should serialize corpus renderer envelope"),
+            )
+        });
+        descriptor_field(&mut descriptor, "aaxResponse", json!(encoded));
+        descriptor
+    }
+
+    #[test]
+    fn aps_renderer_matches_shared_cross_language_contract_corpus() {
+        let corpus: RendererCorpus = serde_json::from_str(include_str!(
+            "../../../trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json"
+        ))
+        .expect("should parse shared APS renderer corpus");
+        assert_eq!(
+            corpus.publisher_origin, "https://publisher.example",
+            "should pin the corpus publisher origin"
+        );
+
+        for vector in &corpus.vectors {
+            let descriptor = materialize_renderer_corpus_vector(&corpus, vector);
+            let actual = classify_aps_renderer_v1(&descriptor, &corpus.publisher_origin).as_str();
+            assert_eq!(
+                actual, vector.expected,
+                "should match APS renderer corpus vector {}",
+                vector.id
+            );
+        }
+    }
+
+    fn parse_with_context(
+        provider: &ApsAuctionProvider,
+        response: PlatformResponse,
+    ) -> AuctionResponse {
+        let settings = create_test_settings();
+        let services = noop_services();
+        let downstream = http::Request::builder()
+            .uri("https://publisher.example/auction")
+            .body(EdgeBody::empty())
+            .expect("should build downstream request");
+        let context = AuctionContext {
+            settings: &settings,
+            request: &downstream,
+            timeout_ms: 321,
+            transport_timeout_ms: 321,
+            provider_responses: None,
+            services: &services,
+        };
+        let auction_request = request();
+        let debug_request = provider.config.debug.then(|| {
+            let openrtb = provider.build_openrtb_request(&auction_request, &context);
+            let body = ApsAuctionProvider::serialize_openrtb_request(&openrtb)
+                .expect("should serialize APS debug request");
+            ApsDebugRequest {
+                body: String::from_utf8_lossy(&body).into_owned(),
+                headers: BTreeMap::from([(
+                    header::CONTENT_TYPE.as_str().to_string(),
+                    vec!["application/json".to_string()],
+                )]),
+            }
+        });
+        futures::executor::block_on(
+            provider.parse_response_with_context_and_state(
+                response,
                 12,
                 &auction_request,
                 &context,
@@ -2083,39 +2746,45 @@ mod tests {
     }
 
     #[test]
-    fn config_defaults_to_the_800ms_aps_budget() {
-        let parsed: LegacyApsProviderConfig = serde_json::from_value(json!({
-            "account_id": "example-account"
-        }))
-        .expect("should parse APS defaults");
-
-        assert_eq!(
-            parsed.timeout_ms, 800,
-            "should preserve APS's 800ms default"
-        );
-    }
-
-    #[test]
-    fn config_accepts_canonical_alias_and_integer_ids() {
-        let canonical: LegacyApsProviderConfig = serde_json::from_value(json!({
+    fn profile_config_accepts_only_canonical_string_account_id() {
+        let canonical: ApsProfileConfig = serde_json::from_value(json!({
             "account_id": "  example-account  "
         }))
         .expect("should parse canonical account ID");
-        let alias: LegacyApsProviderConfig =
-            serde_json::from_value(json!({"pub_id": 1234})).expect("should parse legacy alias");
-        let debug: LegacyApsProviderConfig = serde_json::from_value(json!({
+        let integer = serde_json::from_value::<ApsProfileConfig>(json!({"account_id": 1234}));
+        let legacy_alias = serde_json::from_value::<ApsProfileConfig>(json!({
+            "pub_id": "legacy-account"
+        }));
+        let debug: ApsProfileConfig = serde_json::from_value(json!({
             "account_id": "example-account",
             "debug": true
         }))
         .expect("should parse debug flag");
         assert_eq!(canonical.account_id, "example-account");
-        assert_eq!(alias.account_id, "1234");
-        assert!(!canonical.enabled);
+        assert!(
+            integer.is_err(),
+            "integer account IDs must fail the hard cutover"
+        );
+        assert!(legacy_alias.is_err(), "pub_id must fail the hard cutover");
         assert!(!canonical.debug);
         assert!(debug.debug);
         assert!(!canonical.allow_script_creatives);
-        assert_eq!(canonical.rendering_mode, ApsRenderingMode::TrustedServer);
-        assert!(canonical.endpoint.ends_with("/e/pb/bid"));
+    }
+
+    #[test]
+    fn browser_config_rejects_provider_fields() {
+        let enabled: ApsConfig = serde_json::from_value(json!({"enabled": true}))
+            .expect("should accept the browser enablement toggle");
+        assert!(enabled.enabled);
+
+        assert!(
+            serde_json::from_value::<ApsConfig>(json!({
+                "enabled": true,
+                "account_id": "legacy-account"
+            }))
+            .is_err(),
+            "removed APS provider fields must fail the hard cutover"
+        );
     }
 
     #[test]
@@ -2172,21 +2841,11 @@ mod tests {
             )
             .is_err()
         );
-        assert!(
-            serde_json::from_value::<LegacyApsProviderConfig>(json!({
-                "account_id": "one",
-                "pub_id": "two"
-            }))
-            .is_err()
-        );
-        assert!(
-            serde_json::from_value::<ApsConfig>(json!({
-                "enabled": true,
-                "rendering_mode": "unsupported"
-            }))
-            .is_err(),
-            "should reject an unknown APS rendering mode"
-        );
+        let legacy_alias = serde_json::Value::Object(serde_json::Map::from_iter([(
+            ["pub", "id"].join("_"),
+            json!("two"),
+        )]));
+        assert!(serde_json::from_value::<LegacyApsProviderConfig>(legacy_alias).is_err());
         for endpoint in [
             "http://aps.example/e/pb/bid",
             "https://",
@@ -2522,12 +3181,250 @@ mod tests {
             let response = provider.parse_aps_response(&value, 12, &request());
             assert!(response.bids.is_empty());
             assert_eq!(
-                response.metadata["drop_reasons"]["unexpected_response_shape"],
+                drop_count(&response, AuctionDropReason::InvalidProviderResponse),
                 1
             );
         }
     }
 
+    #[test]
+    fn upstream_bid_ids_are_required_bounded_control_free_and_response_unique() {
+        let provider = ApsAuctionProvider::new(config());
+        let mut missing = bid("missing", 1.0, "iframe");
+        missing
+            .as_object_mut()
+            .expect("should build an object bid")
+            .remove("id");
+        let empty = bid("", 1.1, "iframe");
+        let oversized = bid(&format!("{}x", "é".repeat(32)), 1.2, "iframe");
+        let control = bid("control\u{0000}id", 1.3, "iframe");
+        let duplicate_low = bid("duplicate", 1.4, "iframe");
+        let duplicate_high = bid("duplicate", 9.0, "iframe");
+        let valid_boundary = bid(&"é".repeat(32), 2.0, "iframe");
+
+        let response = provider.parse_aps_response(
+            &json!({"seatbid": [{"bid": [
+                missing,
+                empty,
+                oversized,
+                control,
+                duplicate_low,
+                duplicate_high,
+                valid_boundary
+            ]}]}),
+            12,
+            &request(),
+        );
+
+        assert_eq!(response.status, BidStatus::Success);
+        assert_eq!(response.bids.len(), 1);
+        assert_eq!(
+            response.bids[0].bid_id.as_deref(),
+            Some("é".repeat(32).as_str())
+        );
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::MissingUpstreamBidId),
+            2
+        );
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::UpstreamBidIdTooLarge),
+            1
+        );
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::InvalidUpstreamBidId),
+            1
+        );
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::DuplicateUpstreamBidId),
+            2
+        );
+    }
+
+    #[test]
+    fn bid_validation_is_typed_and_isolated_from_a_valid_sibling() {
+        let provider = ApsAuctionProvider::new(config());
+        let mut unknown_imp = bid("unknown-imp", 1.0, "iframe");
+        unknown_imp["impid"] = json!("not-requested");
+        let negative_price = bid("negative-price", -0.1, "iframe");
+        let mut wrong_price = bid("wrong-price", 1.0, "iframe");
+        wrong_price["price"] = json!("1.0");
+        let mut zero_width = bid("zero-width", 1.0, "iframe");
+        zero_width["w"] = json!(0);
+        let mut over_height = bid("over-height", 1.0, "iframe");
+        over_height["h"] = json!(4097);
+        let mut unmatched_size = bid("unmatched-size", 1.0, "iframe");
+        unmatched_size["w"] = json!(728);
+        unmatched_size["h"] = json!(90);
+        let mut missing_url = bid("missing-url", 1.0, "iframe");
+        missing_url["ext"]
+            .as_object_mut()
+            .expect("should build a bid extension")
+            .remove("creativeurl");
+        let mut invalid_url = bid("invalid-url", 1.0, "iframe");
+        invalid_url["ext"]["creativeurl"] = json!("http://creative.example/render");
+        let invalid_tag = bid("invalid-tag", 1.0, "video");
+        let mut invalid_creative_id = bid("invalid-creative-id", 1.0, "iframe");
+        invalid_creative_id["crid"] = json!(42);
+        let mut unsupported_media = bid("unsupported-media", 1.0, "iframe");
+        unsupported_media["mtype"] = json!(2);
+        let valid = bid("valid-sibling", 2.0, "iframe");
+
+        let response = provider.parse_aps_response(
+            &json!({"seatbid": [{"bid": [
+                "malformed",
+                unknown_imp,
+                negative_price,
+                wrong_price,
+                zero_width,
+                over_height,
+                unmatched_size,
+                missing_url,
+                invalid_url,
+                invalid_tag,
+                invalid_creative_id,
+                unsupported_media,
+                valid
+            ]}]}),
+            12,
+            &request(),
+        );
+
+        assert_eq!(response.bids.len(), 1);
+        assert_eq!(response.bids[0].bid_id.as_deref(), Some("valid-sibling"));
+        for reason in [
+            AuctionDropReason::MalformedBid,
+            AuctionDropReason::UnknownImpression,
+            AuctionDropReason::DimensionsOutOfRange,
+            AuctionDropReason::MissingCreativeUrl,
+            AuctionDropReason::InvalidCreativeUrl,
+            AuctionDropReason::InvalidTagType,
+            AuctionDropReason::InvalidCreativeId,
+            AuctionDropReason::UnsupportedMediaType,
+        ] {
+            assert_eq!(drop_count(&response, reason), 1, "should report {reason:?}");
+        }
+        assert_eq!(drop_count(&response, AuctionDropReason::InvalidPrice), 2);
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::InvalidDimensions),
+            2
+        );
+    }
+
+    #[test]
+    fn dimensions_accept_exact_requested_membership_at_contract_boundaries() {
+        let provider = ApsAuctionProvider::new(config());
+        let mut auction_request = request();
+        auction_request.slots = vec![
+            AdSlot {
+                id: "minimum-slot".to_string(),
+                formats: vec![AdFormat {
+                    media_type: MediaType::Banner,
+                    width: 1,
+                    height: 1,
+                }],
+                floor_price: None,
+                targeting: HashMap::new(),
+                bidders: HashMap::new(),
+            },
+            AdSlot {
+                id: "maximum-slot".to_string(),
+                formats: vec![AdFormat {
+                    media_type: MediaType::Banner,
+                    width: 4096,
+                    height: 4096,
+                }],
+                floor_price: None,
+                targeting: HashMap::new(),
+                bidders: HashMap::new(),
+            },
+        ];
+        let mut minimum = bid("minimum", 1.0, "iframe");
+        minimum["impid"] = json!("minimum-slot");
+        minimum["w"] = json!(1);
+        minimum["h"] = json!(1);
+        let mut maximum = bid("maximum", 1.0, "iframe");
+        maximum["impid"] = json!("maximum-slot");
+        maximum["w"] = json!(4096);
+        maximum["h"] = json!(4096);
+
+        let response = provider.parse_aps_response(
+            &json!({"seatbid": [{"bid": [minimum, maximum]}]}),
+            12,
+            &auction_request,
+        );
+
+        assert_eq!(response.status, BidStatus::Success);
+        assert_eq!(response.bids.len(), 2);
+        assert_eq!(response.bids[0].slot_id, "minimum-slot");
+        assert_eq!(response.bids[1].slot_id, "maximum-slot");
+        assert_eq!(response.metadata["dropped_bid_count"], 0);
+    }
+
+    #[test]
+    fn contextual_isolated_from_valid_bids_while_currency_and_nonfinite_json_are_global() {
+        let provider = ApsAuctionProvider::new(config());
+        let contextual = provider.parse_aps_response(
+            &json!({"contextual": {"slots": []}, "seatbid": [{"bid": [bid("valid", 1.0, "iframe")]}]}),
+            12,
+            &request(),
+        );
+        assert_eq!(contextual.status, BidStatus::Success);
+        assert_eq!(contextual.bids.len(), 1);
+        assert_eq!(
+            drop_count(&contextual, AuctionDropReason::InvalidProviderResponse),
+            1
+        );
+
+        let value = json!({
+            "cur": "EUR",
+            "seatbid": [{"bid": [bid("eur", 1.0, "iframe")]}]
+        });
+        let response = provider.parse_aps_response(&value, 12, &request());
+        assert_eq!(response.status, BidStatus::Error);
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::InvalidProviderResponse),
+            1
+        );
+
+        let body = br#"{"seatbid":[{"bid":[{"id":"overflow","impid":"fictional-slot","price":1e400,"w":300,"h":250,"ext":{"creativeurl":"https://creative.example/render","tagtype":"iframe"}}]}]}"#;
+        let response = futures::executor::block_on(
+            provider.parse_response_inner(
+                PlatformResponse::new(
+                    edgezero_core::http::response_builder()
+                        .status(StatusCode::OK)
+                        .body(EdgeBody::from(body.to_vec()))
+                        .expect("should build nonfinite APS response"),
+                ),
+                12,
+                Some(&request()),
+                None,
+                false,
+            ),
+        )
+        .expect("should reject nonfinite APS JSON safely");
+        assert_eq!(response.status, BidStatus::Error);
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::InvalidProviderResponse),
+            1
+        );
+    }
+
+    #[test]
+    fn invalid_only_bid_retains_its_attributable_slot_failure() {
+        let provider = ApsAuctionProvider::new(config());
+        let mut invalid = bid("invalid", 1.0, "iframe");
+        invalid["ext"]["creativeurl"] = json!("http://creative.example/render");
+
+        let response =
+            provider.parse_aps_response(&json!({"seatbid": [{"bid": [invalid]}]}), 12, &request());
+
+        assert_eq!(response.status, BidStatus::NoBid);
+        assert_eq!(
+            response.metadata["invalid_slots"]["fictional-slot"],
+            "invalid_provider_response"
+        );
+    }
+
     #[test]
     fn debug_metadata_matches_pbs_httpcalls_shape() {
         let mut provider_config = config();
@@ -2716,7 +3613,7 @@ mod tests {
         let oversized = parse_with_context(&provider, oversized);
 
         assert_eq!(
-            malformed.metadata["drop_reasons"]["unexpected_response_shape"],
+            drop_count(&malformed, AuctionDropReason::InvalidProviderResponse),
             1
         );
         assert_eq!(
@@ -2796,7 +3693,7 @@ mod tests {
 
         assert!(response.bids.is_empty());
         assert_eq!(
-            response.metadata["drop_reasons"]["unexpected_response_shape"],
+            drop_count(&response, AuctionDropReason::InvalidProviderResponse),
             1
         );
     }
@@ -2876,15 +3773,18 @@ mod tests {
     }
 
     #[test]
-    fn unsupported_currency_is_a_no_bid() {
+    fn unsupported_currency_is_an_invalid_provider_response() {
         let provider = ApsAuctionProvider::new(config());
         let response = provider.parse_aps_response(
             &json!({"cur": "EUR", "seatbid": [{"bid": [bid("eur-bid", 1.0, "iframe")]}]}),
             12,
             &request(),
         );
-        assert_eq!(response.status, BidStatus::NoBid);
-        assert_eq!(response.metadata["drop_reasons"]["unsupported_currency"], 1);
+        assert_eq!(response.status, BidStatus::Error);
+        assert_eq!(
+            drop_count(&response, AuctionDropReason::InvalidProviderResponse),
+            1
+        );
     }
 
     #[test]
@@ -2897,10 +3797,7 @@ mod tests {
         );
         assert_eq!(response.bids.len(), 1);
         assert_eq!(response.bids[0].bid_id.as_deref(), Some("valid"));
-        assert_eq!(
-            response.metadata["drop_reasons"]["missing_render_source"],
-            1
-        );
+        assert_eq!(drop_count(&response, AuctionDropReason::MalformedBid), 1);
     }
 
     #[test]
@@ -2976,7 +3873,7 @@ mod tests {
         );
         assert!(response.bids.is_empty());
         assert_eq!(
-            response.metadata["drop_reasons"]["missing_render_source"],
+            drop_count(&response, AuctionDropReason::MissingCreativeUrl),
             1
         );
         assert_eq!(response.metadata["drop_reasons"]["invalid_dimensions"], 1);
@@ -3003,6 +3900,8 @@ mod tests {
 
         let mut uppercase_publisher = request();
         uppercase_publisher.publisher.domain = "Creative.Example".to_string();
+        uppercase_publisher.publisher.page_url =
+            Some("https://Creative.Example/article".to_string());
         let response = provider.parse_aps_response(
             &json!({"seatbid": [{"bid": [bid("same-origin", 1.0, "iframe")]}]}),
             12,
@@ -3013,49 +3912,7 @@ mod tests {
     }
 
     #[test]
-    fn registers_and_serves_only_static_renderer_route() {
-        let integration = ApsRendererIntegration {
-            rendering_mode: ApsRenderingMode::TrustedServer,
-        };
-        let routes = integration.routes();
-        assert_eq!(routes.len(), 1, "should register one route");
-        assert_eq!(routes[0].method, Method::GET);
-        assert_eq!(routes[0].path, APS_RENDERER_ROUTE);
-
-        let settings = create_test_settings();
-        let services = noop_services();
-        let request = http::Request::builder()
-            .method(Method::GET)
-            .uri(APS_RENDERER_ROUTE)
-            .body(EdgeBody::empty())
-            .expect("should build renderer request");
-        let response =
-            futures::executor::block_on(integration.handle(&settings, &services, request))
-                .expect("should serve renderer");
-        assert_eq!(response.status(), StatusCode::OK);
-        assert_eq!(
-            response.headers()[header::CONTENT_TYPE],
-            "text/html; charset=utf-8"
-        );
-        assert_eq!(response.headers()["x-content-type-options"], "nosniff");
-        assert_eq!(response.headers()["referrer-policy"], "no-referrer");
-        assert_eq!(
-            response.headers()[header::CONTENT_SECURITY_POLICY],
-            APS_RENDERER_CSP
-        );
-
-        let post = http::Request::builder()
-            .method(Method::POST)
-            .uri(APS_RENDERER_ROUTE)
-            .body(EdgeBody::empty())
-            .expect("should build method rejection request");
-        let response = futures::executor::block_on(integration.handle(&settings, &services, post))
-            .expect("should reject unsupported method");
-        assert_eq!(response.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[test]
-    fn enabled_config_registers_renderer_proxy() {
+    fn enabled_config_does_not_register_a_second_renderer_proxy() {
         let mut settings = create_test_settings();
         settings
             .integrations
@@ -3070,102 +3927,56 @@ mod tests {
             .expect("should return enabled registration");
 
         assert_eq!(registration.integration_id, APS_INTEGRATION_ID);
-        assert_eq!(registration.proxies.len(), 1);
-        assert_eq!(registration.head_injectors.len(), 1);
-        let document_state = IntegrationDocumentState::default();
-        let context = IntegrationHtmlContext {
-            request_host: "publisher.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-        assert!(
-            registration.head_injectors[0]
-                .head_inserts(&context)
-                .is_empty(),
-            "should not inject a native-mode head marker by default"
-        );
-        assert!(
-            registration.head_injectors[0]
-                .tsjs_script_tag_attributes()
-                .is_empty(),
-            "should not authorize native rendering by default"
-        );
+        assert!(registration.proxies.is_empty());
         assert!(registration.js_disabled);
     }
 
     #[test]
-    fn publisher_native_config_registers_runner_mode_without_renderer_route() {
+    fn disabled_auction_plan_does_not_register_or_expose_aps_routes() {
         let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                APS_INTEGRATION_ID,
-                &json!({
-                    "enabled": true,
-                    "account_id": "example-account",
-                    "rendering_mode": "publisher_native"
-                }),
-            )
-            .expect("should insert native APS config");
-
-        let registration = register(&settings)
-            .expect("should register APS")
-            .expect("should return enabled registration");
-        assert!(
-            registration.proxies.is_empty(),
-            "should not register the static renderer"
+        settings.auction.enabled = false;
+        settings.auction.providers.insert(
+            "aps-main".parse().expect("should parse APS provider ID"),
+            ProviderConfig {
+                protocol: "openrtb-2.6".to_string(),
+                profile: APS_INTEGRATION_ID.to_string(),
+                endpoint: default_endpoint(),
+                timeout_ms: None,
+                routing: RoutingMode::AllEligible,
+                notifications: NotificationConfig::default(),
+                profile_config: json!({"account_id": "example-account"}),
+            },
         );
-        assert_eq!(registration.head_injectors.len(), 1);
+        let plan = crate::auction::compile_auction_plan(&settings)
+            .expect("disabled APS auction plan should compile");
 
-        let integration = ApsRendererIntegration {
-            rendering_mode: ApsRenderingMode::PublisherNative,
-        };
         assert!(
-            integration.routes().is_empty(),
-            "should expose no renderer route"
-        );
-        let document_state = IntegrationDocumentState::default();
-        let context = IntegrationHtmlContext {
-            request_host: "publisher.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-        assert!(
-            integration.head_inserts(&context).is_empty(),
-            "should not inject a forgeable native-mode marker"
+            plan.has_profile(APS_INTEGRATION_ID),
+            "compiled plan should retain configured profile identity"
         );
-        assert_eq!(
-            integration.tsjs_script_tag_attributes(),
-            vec![("data-ts-aps-rendering-mode", "publisher_native")],
-            "should authorize native mode on the publisher bundle tag"
+        assert!(
+            register_for_plan(&settings, &plan)
+                .expect("disabled APS registration should be evaluated")
+                .is_none(),
+            "global auction kill switch should suppress APS registration"
         );
-    }
-
-    #[test]
-    fn publisher_native_script_creatives_remain_available_for_controlled_validation() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                APS_INTEGRATION_ID,
-                &json!({
-                    "enabled": true,
-                    "account_id": "example-account",
-                    "allow_script_creatives": true,
-                    "rendering_mode": "publisher_native"
-                }),
-            )
-            .expect("should insert native APS script config");
 
-        let providers = register_providers(&settings).expect("should register APS provider");
-
-        assert_eq!(
-            providers.len(),
-            1,
-            "should retain the controlled experiment"
-        );
+        let integration = ApsV1Integration::from_plan(&plan);
+        for path in [APS_RENDERER_V2_ROUTE, APS_RUNNER_ROUTE] {
+            let request = http::Request::builder()
+                .method(Method::GET)
+                .uri(path)
+                .body(EdgeBody::empty())
+                .expect("should build disabled APS request");
+            let response = futures::executor::block_on(integration.handle(
+                &settings,
+                &noop_services(),
+                request,
+            ))
+            .expect("disabled APS route should fail closed locally");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND, "path={path}");
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+        }
     }
 
     #[test]
@@ -3214,38 +4025,508 @@ mod tests {
     }
 
     #[test]
-    fn renderer_document_is_static_and_nonce_bound() {
-        assert!(APS_RENDERER_DOCUMENT.contains("^#tsaps="));
-        assert!(APS_RENDERER_DOCUMENT.contains("event.source!==parent"));
-        assert!(APS_RENDERER_DOCUMENT.contains("message.nonce!==expected"));
-        assert!(APS_RENDERER_DOCUMENT.contains("prebid/creative/render"));
-        assert!(APS_RENDERER_DOCUMENT.contains("window._aps instanceof Map"));
-        assert!(
-            APS_RENDERER_DOCUMENT
-                .contains("html,body{margin:0;padding:0}body>iframe{display:block}")
+    fn coordinated_cutover_routes_are_reserved_with_exact_local_method_policy() {
+        let enabled = ApsV1Integration { enabled: true };
+        let disabled = ApsV1Integration { enabled: false };
+        let settings = create_test_settings();
+        let services = noop_services();
+
+        for path in [APS_RENDERER_V2_ROUTE, APS_RUNNER_ROUTE] {
+            let disabled_get = http::Request::builder()
+                .method(Method::GET)
+                .uri(path)
+                .body(EdgeBody::empty())
+                .expect("should build disabled APS request");
+            let response =
+                futures::executor::block_on(disabled.handle(&settings, &services, disabled_get))
+                    .expect("disabled APS family should answer locally");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND);
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+
+            let disabled_post = http::Request::builder()
+                .method(Method::POST)
+                .uri(path)
+                .body(EdgeBody::empty())
+                .expect("should build disabled APS POST request");
+            let response =
+                futures::executor::block_on(disabled.handle(&settings, &services, disabled_post))
+                    .expect("disabled APS family should remain absent for every method");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND);
+            assert!(!response.headers().contains_key(header::ALLOW));
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+
+            for method in [
+                Method::HEAD,
+                Method::OPTIONS,
+                Method::PUT,
+                Method::PATCH,
+                Method::DELETE,
+                Method::TRACE,
+                Method::CONNECT,
+                Method::from_bytes(b"PROPFIND").expect("PROPFIND should be a valid method"),
+            ] {
+                let request = http::Request::builder()
+                    .method(method.clone())
+                    .uri(path)
+                    .body(EdgeBody::empty())
+                    .expect("should build APS method rejection");
+                let response =
+                    futures::executor::block_on(enabled.handle(&settings, &services, request))
+                        .expect("reserved APS family should reject unsupported methods locally");
+                assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
+                assert_eq!(response.headers()[header::ALLOW], "GET");
+                assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+                assert_eq!(response.headers().len(), 2, "method={method} path={path}");
+                assert!(
+                    response
+                        .into_body()
+                        .into_bytes()
+                        .unwrap_or_default()
+                        .is_empty()
+                );
+            }
+        }
+
+        for path in [
+            "/integrations/aps/renderer",
+            "/integrations/aps/renderer/v1",
+            "/integrations/aps/runner/v1.js",
+            "/integrations/aps/renderer/v2/extra",
+            "/integrations/aps/not-a-route",
+        ] {
+            let request = http::Request::builder()
+                .method(Method::GET)
+                .uri(path)
+                .body(EdgeBody::empty())
+                .expect("should build unknown APS family request");
+            let response =
+                futures::executor::block_on(enabled.handle(&settings, &services, request))
+                    .expect("unknown APS family path should answer locally");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND, "path={path}");
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+        }
+    }
+
+    #[test]
+    fn aps_family_classifier_has_an_exact_segment_boundary() {
+        assert!(is_aps_family_path("/integrations/aps"));
+        assert!(is_aps_family_path("/integrations/aps/renderer/v2"));
+        assert!(!is_aps_family_path("/integrations/apsx"));
+        assert!(!is_aps_family_path("/integrations/ap"));
+    }
+
+    #[test]
+    fn coordinated_cutover_renderer_has_exact_immutable_embedding_policy() {
+        let integration = ApsV1Integration { enabled: true };
+        let request = http::Request::builder()
+            .method(Method::GET)
+            .uri(APS_RENDERER_V2_ROUTE)
+            .body(EdgeBody::empty())
+            .expect("should build versioned renderer request");
+        let response = futures::executor::block_on(integration.handle(
+            &create_test_settings(),
+            &noop_services(),
+            request,
+        ))
+        .expect("versioned renderer should be served");
+
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers()[header::CONTENT_TYPE],
+            "text/html; charset=utf-8"
         );
-        assert!(APS_RENDERER_DOCUMENT.contains("store:new Map([['listeners',new Map()]])"));
-        assert!(APS_RENDERER_DOCUMENT.contains("account.queue.push(new CustomEvent"));
-        assert!(
-            APS_RENDERER_DOCUMENT.contains("trusted-server/aps/renderer-ready")
-                && APS_RENDERER_DOCUMENT.contains("trusted-server/aps/renderer-failed")
+        assert_eq!(
+            response.headers()[header::CACHE_CONTROL],
+            "public, max-age=31536000, immutable"
         );
-        assert!(!APS_RENDERER_DOCUMENT.contains("window.apstag"));
-        assert!(
-            APS_RENDERER_DOCUMENT
-                .contains("https://client.aps.amazon-adsystem.com/prebid-creative.js")
-        );
-        assert!(!APS_RENDERER_DOCUMENT.contains("<script src="));
-        let queue_index = APS_RENDERER_DOCUMENT
-            .find("account.queue.push(new CustomEvent")
-            .expect("should queue render event");
-        let runner_index = APS_RENDERER_DOCUMENT
-            .find("document.head.appendChild(script)")
-            .expect("should dynamically load the APS runner");
-        assert!(queue_index < runner_index);
-        assert!(!APS_RENDERER_DOCUMENT.contains("allow-same-origin"));
-        assert!(APS_RENDERER_CSP.contains("default-src 'none'"));
-        assert!(APS_RENDERER_CSP.contains("sandbox allow-forms"));
-        assert!(!APS_RENDERER_CSP.contains("allow-same-origin"));
+        assert_eq!(response.headers()["x-content-type-options"], "nosniff");
+        assert_eq!(response.headers()["referrer-policy"], "no-referrer");
+        assert_eq!(
+            response.headers()[header::CONTENT_SECURITY_POLICY],
+            APS_RENDERER_V2_CSP
+        );
+        assert!(!response.headers().contains_key("x-frame-options"));
+        assert_eq!(
+            APS_RENDERER_V2_CSP,
+            "default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;"
+        );
+        assert_eq!(
+            APS_RENDERER_SANDBOX,
+            "allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation"
+        );
+
+        let body = futures::executor::block_on(
+            response
+                .into_body()
+                .into_bytes_bounded(APS_RUNNER_MAX_RESPONSE_BYTES),
+        )
+        .expect("renderer body should stay within the runner cap");
+        assert_eq!(body.as_ref(), APS_RENDERER_V2_DOCUMENT.as_bytes());
+        assert!(APS_RENDERER_V2_DOCUMENT.contains("TS APS Bootstrap Ready"));
+        assert!(APS_RENDERER_V2_DOCUMENT.contains("TS APS Bootstrap Configure"));
+        assert!(APS_RENDERER_V2_DOCUMENT.contains("data:text/html;charset=utf-8,"));
+        assert!(APS_RENDERER_V2_DOCUMENT.contains("/integrations/aps/runner.js"));
+        for forbidden in [
+            "client.aps.amazon-adsystem.com",
+            "example-account",
+            "bid-123",
+            "creative.example/render",
+        ] {
+            assert!(
+                !APS_RENDERER_V2_DOCUMENT.contains(forbidden),
+                "renderer bootstrap should not contain a concrete descriptor or vendored runner value: {forbidden}"
+            );
+        }
+    }
+
+    fn raw_runner_response(
+        body: impl Into<Vec<u8>>,
+        content_type: ProxyHeaderEvidenceV1,
+        content_encoding: ProxyHeaderEvidenceV1,
+        content_length: ProxyHeaderEvidenceV1,
+    ) -> RawProxyResponseV1 {
+        RawProxyResponseV1 {
+            evidence: ProxyResponseEvidenceV1 {
+                status: 200,
+                content_type,
+                content_encoding,
+                content_length,
+            },
+            body: body.into(),
+        }
+    }
+
+    fn request_runner(
+        stub: &Arc<StubHttpClient>,
+    ) -> Result<http::Response<EdgeBody>, Report<TrustedServerError>> {
+        let services = build_services_with_http_client(
+            Arc::clone(stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = http::Request::builder()
+            .method(Method::GET)
+            .uri(APS_RUNNER_ROUTE)
+            .body(EdgeBody::empty())
+            .expect("should build APS runner request");
+        futures::executor::block_on(ApsV1Integration { enabled: true }.handle(
+            &create_test_settings(),
+            &services,
+            request,
+        ))
+    }
+
+    #[test]
+    fn coordinated_cutover_runner_proxies_exact_valid_identity_bytes() {
+        let body = b"window.fictionalApsRunner = true;".to_vec();
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_raw_proxy_response(raw_runner_response(
+            body.clone(),
+            ProxyHeaderEvidenceV1::one("application/javascript; charset=utf-8"),
+            ProxyHeaderEvidenceV1::absent(),
+            ProxyHeaderEvidenceV1::one(body.len().to_string()),
+        ));
+
+        let response = request_runner(&stub).expect("valid runner should be proxied");
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers()[header::CONTENT_TYPE],
+            "application/javascript; charset=utf-8"
+        );
+        assert_eq!(response.headers()[header::ACCESS_CONTROL_ALLOW_ORIGIN], "*");
+        assert_eq!(
+            response.headers()["cross-origin-resource-policy"],
+            "cross-origin"
+        );
+        assert_eq!(response.headers()["x-content-type-options"], "nosniff");
+        assert_eq!(response.headers()["referrer-policy"], "no-referrer");
+        assert!(response.headers().get(header::CACHE_CONTROL).is_none());
+        assert_eq!(response.headers().len(), 5);
+        let returned = futures::executor::block_on(
+            response
+                .into_body()
+                .into_bytes_bounded(APS_RUNNER_MAX_RESPONSE_BYTES),
+        )
+        .expect("valid runner body should remain bounded");
+        assert_eq!(returned.as_ref(), body.as_slice());
+
+        assert_eq!(stub.recorded_backend_names(), vec!["stub-backend"]);
+        assert_eq!(stub.recorded_request_uris(), vec![APS_RUNNER_UPSTREAM_URL]);
+        assert_eq!(stub.recorded_request_methods(), vec!["GET"]);
+        let request_headers = stub.recorded_request_headers();
+        let request_headers = request_headers
+            .first()
+            .expect("should record the runner request headers");
+        for expected in [
+            ("accept-encoding", "identity"),
+            ("cache-control", "no-cache"),
+            ("pragma", "no-cache"),
+        ] {
+            assert!(
+                request_headers
+                    .iter()
+                    .any(|(name, value)| name == expected.0 && value == expected.1),
+                "should force live runner cache bypass for {expected:?}: {request_headers:?}"
+            );
+        }
+        assert_eq!(stub.recorded_request_bodies(), vec![Vec::<u8>::new()]);
+        assert_eq!(
+            stub.recorded_cache_bypass_flags(),
+            vec![true],
+            "APS runner relay must bypass the platform cache"
+        );
+        assert_eq!(APS_RUNNER_TOTAL_TIMEOUT, Duration::from_secs(5));
+        assert_eq!(
+            stub.recorded_raw_proxy_policies(),
+            vec![RawProxyPolicyV1 {
+                total_timeout: APS_RUNNER_TOTAL_TIMEOUT,
+                first_byte_timeout: Duration::from_secs(4),
+                blocking_read_timeout: Duration::from_millis(250),
+                max_response_bytes: APS_RUNNER_MAX_RESPONSE_BYTES,
+            }]
+        );
+    }
+
+    #[test]
+    fn coordinated_cutover_runner_rejects_ambiguous_or_invalid_upstream_evidence() {
+        let valid_body = b"window.fictionalApsRunner = true;".to_vec();
+        let valid_length = valid_body.len().to_string();
+        let cases = [
+            (
+                "redirect",
+                RawProxyResponseV1 {
+                    evidence: ProxyResponseEvidenceV1 {
+                        status: 302,
+                        content_type: ProxyHeaderEvidenceV1::one("application/javascript"),
+                        content_encoding: ProxyHeaderEvidenceV1::absent(),
+                        content_length: ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                    },
+                    body: valid_body.clone(),
+                },
+            ),
+            (
+                "missing content type",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "duplicate content type",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::Occurrences(vec![
+                        b"application/javascript".to_vec(),
+                        b"text/javascript".to_vec(),
+                    ]),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "combined content type list",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::Combined(
+                        b"application/javascript, text/javascript".to_vec(),
+                    ),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "wrong charset",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::one("application/javascript; charset=iso-8859-1"),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "encoded body",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::one("application/javascript"),
+                    ProxyHeaderEvidenceV1::one("gzip"),
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "unavailable encoding evidence",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::one("application/javascript"),
+                    ProxyHeaderEvidenceV1::Unavailable,
+                    ProxyHeaderEvidenceV1::one(valid_length.clone()),
+                ),
+            ),
+            (
+                "leading-zero length",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::one("application/javascript"),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one(format!("0{valid_length}")),
+                ),
+            ),
+            (
+                "mismatched length",
+                raw_runner_response(
+                    valid_body.clone(),
+                    ProxyHeaderEvidenceV1::one("application/javascript"),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one("1"),
+                ),
+            ),
+            (
+                "invalid utf-8",
+                raw_runner_response(
+                    vec![0xff],
+                    ProxyHeaderEvidenceV1::one("application/javascript"),
+                    ProxyHeaderEvidenceV1::absent(),
+                    ProxyHeaderEvidenceV1::one("1"),
+                ),
+            ),
+        ];
+
+        for (name, response) in cases {
+            let stub = Arc::new(StubHttpClient::new());
+            stub.push_raw_proxy_response(response);
+            let response = request_runner(&stub).expect("invalid runner should fail locally");
+            assert_eq!(response.status(), StatusCode::BAD_GATEWAY, "case={name}");
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+            assert_eq!(response.headers().len(), 1, "case={name}");
+            let body = futures::executor::block_on(
+                response
+                    .into_body()
+                    .into_bytes_bounded(APS_RUNNER_MAX_RESPONSE_BYTES),
+            )
+            .expect("local failure body should be bounded");
+            assert!(body.is_empty(), "case={name}");
+        }
+    }
+
+    #[test]
+    fn coordinated_cutover_runner_header_grammars_are_closed_and_complete() {
+        for content_type in [
+            ProxyHeaderEvidenceV1::one("application/javascript"),
+            ProxyHeaderEvidenceV1::one("text/javascript"),
+            ProxyHeaderEvidenceV1::one(" Application/JavaScript ; Charset = UTF-8 "),
+            ProxyHeaderEvidenceV1::Combined(b"text/javascript; charset=utf-8".to_vec()),
+        ] {
+            assert!(
+                ApsV1Integration::validate_runner_content_type(&content_type).is_ok(),
+                "accepted content type: {content_type:?}"
+            );
+        }
+        for content_type in [
+            ProxyHeaderEvidenceV1::Unavailable,
+            ProxyHeaderEvidenceV1::absent(),
+            ProxyHeaderEvidenceV1::one("application/ecmascript"),
+            ProxyHeaderEvidenceV1::one("application/javascript; charset=\"utf-8\""),
+            ProxyHeaderEvidenceV1::one("application/javascript; charset=utf-8; level=1"),
+            ProxyHeaderEvidenceV1::one("application/javascript; boundary=x"),
+            ProxyHeaderEvidenceV1::one("application/javascript,"),
+            ProxyHeaderEvidenceV1::one("application/javascript\u{a0}"),
+        ] {
+            assert!(
+                ApsV1Integration::validate_runner_content_type(&content_type).is_err(),
+                "rejected content type: {content_type:?}"
+            );
+        }
+
+        for encoding in [
+            ProxyHeaderEvidenceV1::absent(),
+            ProxyHeaderEvidenceV1::one("identity"),
+            ProxyHeaderEvidenceV1::Combined(b" IDENTITY\t".to_vec()),
+        ] {
+            assert!(
+                ApsV1Integration::validate_runner_content_encoding(&encoding).is_ok(),
+                "accepted encoding: {encoding:?}"
+            );
+        }
+        for encoding in [
+            ProxyHeaderEvidenceV1::Unavailable,
+            ProxyHeaderEvidenceV1::one(""),
+            ProxyHeaderEvidenceV1::one("gzip"),
+            ProxyHeaderEvidenceV1::one("identity, identity"),
+            ProxyHeaderEvidenceV1::Occurrences(vec![b"identity".to_vec(), b"identity".to_vec()]),
+        ] {
+            assert!(
+                ApsV1Integration::validate_runner_content_encoding(&encoding).is_err(),
+                "rejected encoding: {encoding:?}"
+            );
+        }
+
+        assert_eq!(
+            ApsV1Integration::validate_runner_content_length(&ProxyHeaderEvidenceV1::absent()),
+            Ok(None)
+        );
+        assert_eq!(
+            ApsV1Integration::validate_runner_content_length(&ProxyHeaderEvidenceV1::one("0")),
+            Ok(Some(0))
+        );
+        assert_eq!(
+            ApsV1Integration::validate_runner_content_length(&ProxyHeaderEvidenceV1::Combined(
+                APS_RUNNER_MAX_RESPONSE_BYTES.to_string().into_bytes()
+            )),
+            Ok(Some(APS_RUNNER_MAX_RESPONSE_BYTES))
+        );
+        for length in [
+            ProxyHeaderEvidenceV1::Unavailable,
+            ProxyHeaderEvidenceV1::one(""),
+            ProxyHeaderEvidenceV1::one("00"),
+            ProxyHeaderEvidenceV1::one("01"),
+            ProxyHeaderEvidenceV1::one("+1"),
+            ProxyHeaderEvidenceV1::one(" 1"),
+            ProxyHeaderEvidenceV1::one("1 "),
+            ProxyHeaderEvidenceV1::one("1, 1"),
+            ProxyHeaderEvidenceV1::one((APS_RUNNER_MAX_RESPONSE_BYTES + 1).to_string()),
+            ProxyHeaderEvidenceV1::Occurrences(vec![b"1".to_vec(), b"1".to_vec()]),
+        ] {
+            assert!(
+                ApsV1Integration::validate_runner_content_length(&length).is_err(),
+                "rejected length: {length:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn coordinated_cutover_runner_accepts_exact_cap_and_rejects_one_byte_over() {
+        let exact = raw_runner_response(
+            vec![b' '; APS_RUNNER_MAX_RESPONSE_BYTES],
+            ProxyHeaderEvidenceV1::one("application/javascript"),
+            ProxyHeaderEvidenceV1::absent(),
+            ProxyHeaderEvidenceV1::absent(),
+        );
+        assert!(ApsV1Integration::validate_runner_response(&exact).is_ok());
+
+        let over = raw_runner_response(
+            vec![b' '; APS_RUNNER_MAX_RESPONSE_BYTES + 1],
+            ProxyHeaderEvidenceV1::one("application/javascript"),
+            ProxyHeaderEvidenceV1::absent(),
+            ProxyHeaderEvidenceV1::absent(),
+        );
+        assert_eq!(
+            ApsV1Integration::validate_runner_response(&over),
+            Err("body_overflow")
+        );
+    }
+
+    #[test]
+    fn coordinated_cutover_runner_transport_failure_is_empty_and_non_leaking() {
+        let stub = Arc::new(StubHttpClient::new());
+        let response = request_runner(&stub).expect("transport failure should answer locally");
+        assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
+        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+        assert_eq!(response.headers().len(), 1);
+        let body = futures::executor::block_on(
+            response
+                .into_body()
+                .into_bytes_bounded(APS_RUNNER_MAX_RESPONSE_BYTES),
+        )
+        .expect("local failure body should be bounded");
+        assert!(body.is_empty());
     }
 }
diff --git a/crates/trusted-server-core/src/integrations/datadome.rs b/crates/trusted-server-core/src/integrations/datadome.rs
index ba2a217c9..e98d11a40 100644
--- a/crates/trusted-server-core/src/integrations/datadome.rs
+++ b/crates/trusted-server-core/src/integrations/datadome.rs
@@ -75,6 +75,7 @@ use crate::integrations::{
     IntegrationHtmlContext, IntegrationProxy, IntegrationRegistration, IntegrationRequestFilter,
     RequestFilterDecision, RequestFilterInput, UPSTREAM_SDK_MAX_RESPONSE_BYTES,
     collect_body_bounded, collect_response_bounded, ensure_integration_backend,
+    html_script_nonce_attribute,
 };
 use crate::platform::{PlatformHttpRequest, RuntimeServices};
 use crate::redacted::Redacted;
@@ -893,9 +894,10 @@ impl IntegrationHeadInjector for DataDomeIntegration {
                 "{}".to_string()
             })
             .replace("</", "<\\/");
+        let nonce_attribute = html_script_nonce_attribute(ctx.csp_nonce).unwrap_or_default();
 
         vec![format!(
-            "<script>window.ddjskey={key};window.ddoptions={options};</script><script src=\"{tag_url}\" async></script>"
+            "<script{nonce_attribute}>window.ddjskey={key};window.ddoptions={options};</script><script{nonce_attribute} src=\"{tag_url}\" async></script>"
         )]
     }
 }
@@ -983,7 +985,8 @@ pub fn register(
     let mut builder = IntegrationRegistration::builder(DATADOME_INTEGRATION_ID)
         .with_proxy(integration.clone())
         .with_attribute_rewriter(integration.clone())
-        .with_head_injector(integration.clone());
+        .with_head_injector(integration.clone())
+        .with_empty_browser_config_v1()?;
 
     if integration.config.enable_protection {
         builder = builder.with_request_filter(integration);
@@ -1190,6 +1193,7 @@ mod tests {
             request_host: "publisher.example.com",
             request_scheme: "https",
             origin_host: "origin.example.com",
+            csp_nonce: None,
             document_state,
         }
     }
@@ -1412,7 +1416,10 @@ mod tests {
         config.client_side_configuration = serde_json::json!({ "ajaxListenerPath": true });
         let integration = DataDomeIntegration::new(config);
         let document_state = crate::integrations::IntegrationDocumentState::default();
-        let ctx = html_context_for_tests(&document_state);
+        let ctx = IntegrationHtmlContext {
+            csp_nonce: Some("response-nonce_123="),
+            ..html_context_for_tests(&document_state)
+        };
 
         let inserts = integration.head_inserts(&ctx);
 
@@ -1426,9 +1433,15 @@ mod tests {
             "should serialize DataDome client-side options"
         );
         assert!(
-            inserts[0].contains("<script src=\"/integrations/datadome/tags.js\" async></script>"),
+            inserts[0].contains(
+                "<script nonce=\"response-nonce_123=\" src=\"/integrations/datadome/tags.js\" async></script>"
+            ),
             "should load the configured DataDome tag URL"
         );
+        assert!(
+            inserts[0].starts_with("<script nonce=\"response-nonce_123=\">"),
+            "should propagate the response nonce to DataDome inline configuration"
+        );
     }
 
     #[test]
diff --git a/crates/trusted-server-core/src/integrations/didomi.rs b/crates/trusted-server-core/src/integrations/didomi.rs
index 4b0989183..98172b3b6 100644
--- a/crates/trusted-server-core/src/integrations/didomi.rs
+++ b/crates/trusted-server-core/src/integrations/didomi.rs
@@ -11,9 +11,8 @@ use validator::{Validate, ValidationError};
 
 use crate::error::TrustedServerError;
 use crate::integrations::{
-    INTEGRATION_MAX_BODY_BYTES, IntegrationEndpoint, IntegrationHeadInjector,
-    IntegrationHtmlContext, IntegrationProxy, IntegrationRegistration, collect_body_bounded,
-    ensure_integration_backend,
+    INTEGRATION_MAX_BODY_BYTES, IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
+    collect_body_bounded, ensure_integration_backend,
 };
 use crate::platform::{PlatformHttpRequest, RuntimeServices};
 use crate::settings::{IntegrationConfig, Settings};
@@ -253,10 +252,19 @@ pub fn register(
         return Ok(None);
     };
 
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct DidomiBrowserConfigV1 {
+        proxy_path: String,
+    }
+    let browser_config = DidomiBrowserConfigV1 {
+        proxy_path: format!("{}/", integration.resolved_prefix()),
+    };
+
     Ok(Some(
         IntegrationRegistration::builder(DIDOMI_INTEGRATION_ID)
             .with_proxy(integration.clone())
-            .with_head_injector(integration)
+            .with_browser_config_v1(&browser_config)?
             .build(),
     ))
 }
@@ -332,42 +340,12 @@ impl IntegrationProxy for DidomiIntegration {
     }
 }
 
-impl IntegrationHeadInjector for DidomiIntegration {
-    fn integration_id(&self) -> &'static str {
-        DIDOMI_INTEGRATION_ID
-    }
-
-    fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        #[derive(Serialize)]
-        #[serde(rename_all = "camelCase")]
-        struct InjectedDidomiClientConfig {
-            proxy_path: String,
-        }
-
-        let payload = InjectedDidomiClientConfig {
-            proxy_path: format!("{}/", self.resolved_prefix()),
-        };
-
-        // Escape `</` to prevent breaking out of the script tag.
-        let config_json = serde_json::to_string(&payload)
-            .unwrap_or_else(|e| {
-                log::warn!("Didomi: failed to serialize client config: {e}");
-                "{}".to_string()
-            })
-            .replace("</", "<\\/");
-
-        vec![format!(
-            r#"<script>window.__tsjs_didomi={config_json};</script>"#
-        )]
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
     use super::*;
-    use crate::integrations::{IntegrationDocumentState, IntegrationRegistry};
+    use crate::integrations::IntegrationRegistry;
     use crate::platform::test_support::{StubHttpClient, build_services_with_http_client};
     use crate::test_support::tests::create_test_settings;
     use http::Method;
@@ -568,26 +546,26 @@ mod tests {
     }
 
     #[test]
-    fn head_injector_emits_proxy_path() {
-        let custom_config = DidomiIntegrationConfig {
-            enabled: true,
-            proxy_path: Some("my-consent".to_string()),
-            sdk_origin: default_sdk_origin(),
-            api_origin: default_api_origin(),
-        };
-        let integration = DidomiIntegration::new(Arc::new(custom_config));
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let inserts = integration.head_inserts(&ctx);
-        assert_eq!(inserts.len(), 1);
+    fn registration_projects_custom_proxy_path_without_a_config_script() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                DIDOMI_INTEGRATION_ID,
+                &serde_json::json!({
+                    "enabled": true,
+                    "proxy_path": "my-consent",
+                }),
+            )
+            .expect("should insert Didomi config");
+        let registration = register(&settings)
+            .expect("config should parse")
+            .expect("Didomi should register");
+
+        assert!(registration.head_injectors.is_empty());
         assert_eq!(
-            inserts[0],
-            r#"<script>window.__tsjs_didomi={"proxyPath":"/my-consent/"};</script>"#
+            registration.browser_config_v1,
+            Some(serde_json::json!({ "proxyPath": "/my-consent/" }))
         );
     }
 
@@ -650,19 +628,24 @@ mod tests {
     }
 
     #[test]
-    fn head_injector_default_path() {
-        let integration = DidomiIntegration::new(Arc::new(config(true)));
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let inserts = integration.head_inserts(&ctx);
+    fn registration_projects_default_proxy_path() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                DIDOMI_INTEGRATION_ID,
+                &serde_json::json!({ "enabled": true }),
+            )
+            .expect("should insert Didomi config");
+        let registration = register(&settings)
+            .expect("config should parse")
+            .expect("Didomi should register");
+
         assert_eq!(
-            inserts[0],
-            r#"<script>window.__tsjs_didomi={"proxyPath":"/integrations/didomi/consent/"};</script>"#
+            registration.browser_config_v1,
+            Some(serde_json::json!({
+                "proxyPath": "/integrations/didomi/consent/"
+            }))
         );
     }
 }
diff --git a/crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html b/crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html
new file mode 100644
index 000000000..3b9e3fc9a
--- /dev/null
+++ b/crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html
@@ -0,0 +1,126 @@
+<!doctype html>
+<meta charset="utf-8">
+<script>
+(function(){
+'use strict';
+var MAX_CONFIGURATION_BYTES=16384;
+var MAX_CONTAINER_URL_BYTES=196663;
+var DATA_PREFIX='data:text/html;charset=utf-8,';
+var INNER_TEMPLATE="<!doctype html>\n<meta charset=\"utf-8\">\n<meta http-equiv=\"Content-Security-Policy\" content=\"__TS_INNER_CSP__\">\n<style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}</style>\n<body>\n<script>\n(function(){\n'use strict';\n__TS_RENDERER_VALIDATOR__\nvar EXPECTED_NONCE=__TS_RENDERER_NONCE_JSON__;\nvar EXPECTED_PUBLISHER_ORIGIN=__TS_PUBLISHER_ORIGIN_JSON__;\nvar EXPECTED_CREATIVE_ORIGIN=__TS_CREATIVE_ORIGIN_JSON__;\nvar EXPECTED_TAG_TYPE=__TS_TAG_TYPE_JSON__;\nvar RUNNER_URL=__TS_RUNNER_URL_JSON__;\nvar MAX_GLOBAL_MESSAGE_BYTES=4096;\nvar port=null;\nvar accepted=false;\nvar terminal=false;\nvar runnerLoaded=false;\nvar callbackOutcome=null;\nfunction utf8Length(value){return(new TextEncoder()).encode(value).length;}\nfunction exactPlain(value,keys){\n return !!value&&typeof value==='object'&&!Array.isArray(value)&&\n  Object.getPrototypeOf(value)===Object.prototype&&apsExactRecord(value,keys);\n}\nfunction hasForbiddenOriginCharacter(value){\n for(var index=0;index<value.length;index+=1){\n  var code=value.charCodeAt(index);\n  if(code<=32||code===127||value[index]===\"'\"||value[index]==='\"'||value[index]===';')return true;\n }\n return false;\n}\nfunction exactOrigin(value){\n if(typeof value!=='string'||utf8Length(value)>2048||hasForbiddenOriginCharacter(value))return false;\n try{\n  var parsed=new URL(value);\n  return (parsed.protocol==='https:'||parsed.protocol==='http:')&&parsed.hostname!==''&&\n   parsed.username===''&&parsed.password===''&&parsed.origin===value&&\n   parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';\n }catch(_error){return false;}\n}\nfunction rendererMatchesPolicy(renderer){\n try{\n  return renderer.tagType===EXPECTED_TAG_TYPE&&\n   (new URL(renderer.creativeUrl)).origin===EXPECTED_CREATIVE_ORIGIN;\n }catch(_error){return false;}\n}\nfunction send(message){\n if(!port)return;\n try{port.postMessage(message);}catch(_error){/* A closed terminal port has no fallback channel. */}\n}\nfunction close(){\n if(!port)return;\n try{port.close();}catch(_error){/* Port cleanup remains best-effort after settlement. */}\n}\nfunction fail(reason){\n if(terminal)return;\n terminal=true;\n send({message:'TS APS Render Failed',version:1,nonce:EXPECTED_NONCE,reason:reason});\n close();\n}\nfunction finishCallback(){\n if(terminal||!runnerLoaded||callbackOutcome===null)return;\n if(callbackOutcome==='rejected')return fail('runner_failed');\n terminal=true;\n send({message:'TS APS Render Completed',version:1,nonce:EXPECTED_NONCE});\n close();\n}\nfunction receiveEnvelope(event){\n if(accepted||terminal)return;\n var envelope=event&&event.data;\n if(!exactPlain(envelope,['nonce','publisherOrigin','renderer','version'])||\n    envelope.version!==1||envelope.nonce!==EXPECTED_NONCE||\n    envelope.publisherOrigin!==EXPECTED_PUBLISHER_ORIGIN||\n    !exactOrigin(envelope.publisherOrigin)||\n    classifyApsRendererV1(envelope.renderer,envelope.publisherOrigin)!=='accepted'||\n    !rendererMatchesPolicy(envelope.renderer)){\n  fail('descriptor_invalid');\n  return;\n }\n accepted=true;\n port.onmessage=null;\n send({message:'TS APS Document Accepted',version:1,nonce:EXPECTED_NONCE});\n window._aps=window._aps instanceof Map?window._aps:new Map();\n var renderer=envelope.renderer;\n var account=window._aps.get(renderer.accountId);\n if(!account){\n  account={queue:[],store:new Map([['listeners',new Map()]])};\n  window._aps.set(renderer.accountId,account);\n }\n var renderPromise=new Promise(function(resolve,reject){\n  account.queue.push(new CustomEvent('prebid/creative/render',{detail:{\n   aaxResponse:renderer.aaxResponse,\n   seatBidId:renderer.bidId,\n   source:'internal',\n   resolve:resolve,\n   reject:reject\n  }}));\n });\n renderPromise.then(function(){\n  callbackOutcome='resolved';\n  finishCallback();\n },function(){\n  callbackOutcome='rejected';\n  finishCallback();\n });\n var script=document.createElement('script');\n script.src=RUNNER_URL;\n script.crossOrigin='anonymous';\n script.referrerPolicy='no-referrer';\n script.onload=function(){\n  if(terminal)return;\n  runnerLoaded=true;\n  send({message:'TS APS Runner Loaded',version:1,nonce:EXPECTED_NONCE});\n  finishCallback();\n };\n script.onerror=function(){fail('runner_no_load');};\n document.head.appendChild(script);\n}\nfunction receiveBind(event){\n if(port||terminal||event.source!==parent||event.origin!=='null'||\n    !event.ports||event.ports.length!==1||typeof event.data!=='string'||\n    utf8Length(event.data)>MAX_GLOBAL_MESSAGE_BYTES)return;\n var value;\n try{value=JSON.parse(event.data);}catch(_error){return;}\n if(!exactPlain(value,['message','rendererNonce','version'])||\n    value.message!=='TS APS Inner Bind'||value.version!==1||\n    value.rendererNonce!==EXPECTED_NONCE||\n    event.data!==JSON.stringify({message:'TS APS Inner Bind',version:1,\n     rendererNonce:EXPECTED_NONCE}))return;\n port=event.ports[0];\n removeEventListener('message',receiveBind);\n port.onmessage=receiveEnvelope;\n port.onmessageerror=function(){fail(accepted?'runner_failed':'descriptor_invalid');};\n try{port.start();}catch(_error){fail('descriptor_invalid');}\n}\nvar match=/^#(n1_[A-Za-z0-9_-]{22})$/.exec(location.hash);\nif(!match||match[1]!==EXPECTED_NONCE)return;\ntry{history.replaceState(null,'',location.pathname+location.search);}catch(_error){\n /* Fragment clearing has no authority over envelope acceptance. */\n}\naddEventListener('message',receiveBind);\nparent.postMessage(JSON.stringify({message:'TS APS Inner Ready',version:1,\n rendererNonce:EXPECTED_NONCE}),'*');\n})();\n<\/script>\n";
+var OUTER_TEMPLATE="<!doctype html>\n<meta charset=\"utf-8\">\n<meta http-equiv=\"Content-Security-Policy\" content=\"__TS_OUTER_CSP__\">\n<style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}iframe{border:0;display:block;height:100%;margin:0;overflow:hidden;width:100%}</style>\n<body>\n<script>\n(function(){\n'use strict';\nvar EXPECTED_BOOTSTRAP_NONCE=__TS_BOOTSTRAP_NONCE_JSON__;\nvar EXPECTED_RENDERER_NONCE=__TS_RENDERER_NONCE_JSON__;\nvar INNER_URL=__TS_INNER_URL_JSON__;\nvar PERMANENT_SANDBOX=__TS_PERMANENT_SANDBOX_JSON__;\nvar MAX_GLOBAL_MESSAGE_BYTES=4096;\nvar consumed=false;\nfunction utf8Length(value){return(new TextEncoder()).encode(value).length;}\nfunction exact(value,keys){\n if(!value||typeof value!=='object'||Array.isArray(value)||\n    Object.getPrototypeOf(value)!==Object.prototype)return false;\n if(typeof Object.getOwnPropertySymbols==='function'&&\n    Object.getOwnPropertySymbols(value).length!==0)return false;\n var names=Object.getOwnPropertyNames(value).sort();\n if(names.length!==keys.length)return false;\n for(var index=0;index<names.length;index+=1){\n  if(names[index]!==keys[index])return false;\n  var descriptor=Object.getOwnPropertyDescriptor(value,names[index]);\n  if(!descriptor||!Object.prototype.hasOwnProperty.call(descriptor,'value'))return false;\n }\n return true;\n}\nvar match=/^#(b1_[A-Za-z0-9_-]{22})$/.exec(location.hash);\nif(!match||match[1]!==EXPECTED_BOOTSTRAP_NONCE)return;\ntry{history.replaceState(null,'',location.pathname+location.search);}catch(_error){\n /* Fragment clearing has no authority over channel acceptance. */\n}\nvar frame=document.createElement('iframe');\nframe.setAttribute('title','Ad content');\nframe.setAttribute('aria-label','Advertisement');\nframe.setAttribute('scrolling','no');\nframe.setAttribute('frameborder','0');\nframe.setAttribute('marginheight','0');\nframe.setAttribute('marginwidth','0');\nframe.setAttribute('sandbox',PERMANENT_SANDBOX);\nframe.src=INNER_URL;\nvar source=null;\nfunction receive(event){\n if(consumed||!source||event.source!==source||event.origin!=='null'||\n    !event.ports||event.ports.length!==0||typeof event.data!=='string'||\n    utf8Length(event.data)>MAX_GLOBAL_MESSAGE_BYTES)return;\n var value;\n try{value=JSON.parse(event.data);}catch(_error){return;}\n if(!exact(value,['message','rendererNonce','version'])||\n    value.message!=='TS APS Inner Ready'||value.version!==1||\n    value.rendererNonce!==EXPECTED_RENDERER_NONCE||\n    event.data!==JSON.stringify({message:'TS APS Inner Ready',version:1,\n     rendererNonce:EXPECTED_RENDERER_NONCE}))return;\n consumed=true;\n removeEventListener('message',receive);\n var channel=new MessageChannel();\n try{\n  source.postMessage(JSON.stringify({message:'TS APS Inner Bind',version:1,\n   rendererNonce:EXPECTED_RENDERER_NONCE}),'*',[channel.port1]);\n  parent.postMessage(JSON.stringify({message:'TS APS Container Ready',version:1,\n   bootstrapNonce:EXPECTED_BOOTSTRAP_NONCE,\n   rendererNonce:EXPECTED_RENDERER_NONCE}),'*',[channel.port2]);\n }catch(_error){\n  try{channel.port1.close();}catch(_closeError){/* Continue closing the retained endpoint. */}\n  try{channel.port2.close();}catch(_closeError){/* Both endpoints are now inert to this owner. */}\n }\n}\naddEventListener('message',receive);\ndocument.body.appendChild(frame);\nsource=frame.contentWindow;\n})();\n<\/script>\n";
+var RENDERER_VALIDATOR="// @generated by scripts/generate-aps-renderer-contract.mjs\n// schema-sha256: 3f82e9c8d57719c29810a0ed181f4fe2779919c65605ae0cd7c61bd6d865b027\n// corpus-sha256: 3aea612e3316e6df4852e80cb3aa8882ca43d842455a22ba29e63fa88291c7b9\nvar DESCRIPTOR_KEYS = [\"aaxResponse\",\"accountId\",\"bidId\",\"creativeUrl\",\"height\",\"tagType\",\"type\",\"version\",\"width\"];\nvar DESCRIPTOR_KEYS_WITH_CREATIVE_ID = [\"aaxResponse\",\"accountId\",\"bidId\",\"creativeId\",\"creativeUrl\",\"height\",\"tagType\",\"type\",\"version\",\"width\"];\nvar ENVELOPE_ROOT_KEYS = [\"seatbid\"];\nvar ENVELOPE_SEAT_KEYS = [\"bid\"];\nvar ENVELOPE_BID_KEYS = [\"ext\",\"h\",\"id\",\"price\",\"w\"];\nvar ENVELOPE_EXT_KEYS = [\"creativeurl\",\"tagtype\"];\nvar MAX_ACCOUNT_ID_BYTES = 1024;\nvar MAX_BID_ID_BYTES = 64;\nvar MAX_CREATIVE_ID_BYTES = 1024;\nvar MAX_CREATIVE_URL_BYTES = 4096;\nvar MAX_RENDER_ENVELOPE_BYTES = 262144;\nvar MAX_RENDER_ENVELOPE_BASE64_BYTES = 349528;\nvar STANDARD_BASE64_PATTERN = \"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$\";\nvar RENDER_DIMENSION_MIN = 1;\nvar RENDER_DIMENSION_MAX = 4096;\nfunction apsExactRecord(value, expectedKeys) {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;\n  var prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) return false;\n  if (typeof Object.getOwnPropertySymbols === 'function' && Object.getOwnPropertySymbols(value).length !== 0) return false;\n  var actual = Object.getOwnPropertyNames(value).sort();\n  if (actual.length !== expectedKeys.length) return false;\n  for (var index = 0; index < actual.length; index += 1) {\n    var propertyName = actual[index];\n    if (propertyName === undefined || propertyName !== expectedKeys[index]) return false;\n    var property = Object.getOwnPropertyDescriptor(value, propertyName);\n    if (!property || !Object.prototype.hasOwnProperty.call(property, 'value')) return false;\n  }\n  return true;\n}\n\nfunction apsUtf8Length(value) {\n  return (new TextEncoder()).encode(value).length;\n}\n\nfunction apsHasAsciiControl(value) {\n  return /[\\x00-\\x1f\\x7f]/.test(value);\n}\n\nfunction apsDimensionResult(value) {\n  if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value || value <= 0) {\n    return 'invalid_dimensions';\n  }\n  if (value < RENDER_DIMENSION_MIN || value > RENDER_DIMENSION_MAX) {\n    return 'dimensions_out_of_range';\n  }\n  return 'accepted';\n}\n\nfunction apsValidCreativeUrl(value, publisherOrigin) {\n  try {\n    var url = new URL(value);\n    return url.protocol === 'https:' && url.hostname !== '' && url.username === '' &&\n      url.password === '' && url.origin !== publisherOrigin;\n  } catch (_error) {\n    return false;\n  }\n}\n\nfunction apsDecodeEnvelope(value) {\n  if (value.length === 0 || value.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||\n      value.length % 4 !== 0 || !(new RegExp(STANDARD_BASE64_PATTERN)).test(value)) {\n    return undefined;\n  }\n  try {\n    var binary = atob(value);\n    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;\n    var bytes = new Uint8Array(binary.length);\n    for (var index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);\n    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));\n  } catch (_error) {\n    return undefined;\n  }\n}\n\nfunction classifyApsRendererDescriptorV1(\n  value\n) {\n  var renderer = value;\n  if (!apsExactRecord(renderer, DESCRIPTOR_KEYS) &&\n      !apsExactRecord(renderer, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)) return 'descriptor_invalid';\n  if (renderer.type !== 'aps' || renderer.version !== 1 ||\n      typeof renderer.accountId !== 'string' || renderer.accountId.length === 0 ||\n      apsUtf8Length(renderer.accountId) > MAX_ACCOUNT_ID_BYTES ||\n      typeof renderer.bidId !== 'string' || renderer.bidId.length === 0 ||\n      apsUtf8Length(renderer.bidId) > MAX_BID_ID_BYTES ||\n      apsHasAsciiControl(renderer.bidId)) return 'descriptor_invalid';\n  if (Object.prototype.hasOwnProperty.call(renderer, 'creativeId') &&\n      (typeof renderer.creativeId !== 'string' || renderer.creativeId.length === 0 ||\n       apsUtf8Length(renderer.creativeId) > MAX_CREATIVE_ID_BYTES)) return 'descriptor_invalid';\n  if (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') return 'descriptor_invalid';\n\n  var widthResult = apsDimensionResult(renderer.width);\n  if (widthResult !== 'accepted') return widthResult;\n  var heightResult = apsDimensionResult(renderer.height);\n  if (heightResult !== 'accepted') return heightResult;\n\n  if (typeof renderer.creativeUrl !== 'string' ||\n      apsUtf8Length(renderer.creativeUrl) > MAX_CREATIVE_URL_BYTES ||\n      typeof renderer.aaxResponse !== 'string' ||\n      renderer.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES) return 'descriptor_invalid';\n  return 'accepted';\n}\n\nfunction classifyApsRendererV1(\n  value,\n  publisherOrigin\n) {\n  var renderer = value;\n  var descriptorResult =\n    classifyApsRendererDescriptorV1(renderer);\n  if (descriptorResult !== 'accepted') return descriptorResult;\n  if (!apsValidCreativeUrl(renderer.creativeUrl, publisherOrigin)) return 'descriptor_invalid';\n\n  var decoded = apsDecodeEnvelope(renderer.aaxResponse);\n  if (!apsExactRecord(decoded, ENVELOPE_ROOT_KEYS) || !Array.isArray(decoded.seatbid) ||\n      decoded.seatbid.length !== 1) return 'descriptor_invalid';\n  var seat = decoded.seatbid[0];\n  if (!apsExactRecord(seat, ENVELOPE_SEAT_KEYS) || !Array.isArray(seat.bid) ||\n      seat.bid.length !== 1) return 'descriptor_invalid';\n  var bid = seat.bid[0];\n  if (!apsExactRecord(bid, ENVELOPE_BID_KEYS) ||\n      !apsExactRecord(bid.ext, ENVELOPE_EXT_KEYS)) return 'descriptor_invalid';\n\n  var bidWidthResult = apsDimensionResult(bid.w);\n  if (bidWidthResult !== 'accepted') return bidWidthResult;\n  var bidHeightResult = apsDimensionResult(bid.h);\n  if (bidHeightResult !== 'accepted') return bidHeightResult;\n  if (bid.id !== renderer.bidId || bid.w !== renderer.width || bid.h !== renderer.height ||\n      bid.ext.creativeurl !== renderer.creativeUrl || bid.ext.tagtype !== renderer.tagType ||\n      typeof bid.price !== 'number' || !isFinite(bid.price) || bid.price < 0) {\n    return 'descriptor_invalid';\n  }\n  return 'accepted';\n}\n";
+var PERMANENT_SANDBOX='allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation';
+function utf8Length(value){return(new TextEncoder()).encode(value).length;}
+function validParentOrigin(value){
+ if(typeof value!=='string'||utf8Length(value)>2048||/[\x00-\x20\x7f'";]/.test(value))return false;
+ try{
+  var parsed=new URL(value);
+  if((parsed.protocol!=='https:'&&parsed.protocol!=='http:')||parsed.hostname===''||
+     parsed.username!==''||parsed.password!==''||parsed.origin==='null')return false;
+  return parsed.origin===value&&parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';
+ }catch(_error){return false;}
+}
+function exact(value,keys){
+ if(!value||typeof value!=='object'||Array.isArray(value)||
+    Object.getPrototypeOf(value)!==Object.prototype)return false;
+ if(typeof Object.getOwnPropertySymbols==='function'&&
+    Object.getOwnPropertySymbols(value).length!==0)return false;
+ var names=Object.getOwnPropertyNames(value).sort();
+ if(names.length!==keys.length)return false;
+ for(var index=0;index<names.length;index+=1){
+  if(names[index]!==keys[index])return false;
+  var descriptor=Object.getOwnPropertyDescriptor(value,names[index]);
+  if(!descriptor||!Object.prototype.hasOwnProperty.call(descriptor,'value'))return false;
+ }
+ return true;
+}
+function validCreativeOrigin(value,publisherOrigin){
+ if(typeof value!=='string'||utf8Length(value)>2048||/[\x00-\x20\x7f'";]/.test(value))return false;
+ try{
+  var parsed=new URL(value);
+  return parsed.protocol==='https:'&&parsed.hostname!==''&&parsed.username===''&&
+   parsed.password===''&&parsed.origin===value&&parsed.origin!==publisherOrigin&&
+   parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';
+ }catch(_error){return false;}
+}
+function scriptSources(origin,creativeOrigin,scriptCreative){
+ return scriptCreative?"'unsafe-inline' "+origin+' '+creativeOrigin:"'unsafe-inline' "+origin;
+}
+function csp(origin,creativeOrigin,scriptCreative,outer){
+ return "default-src 'none'; base-uri 'none'; object-src 'none'; script-src "+
+  scriptSources(origin,creativeOrigin,scriptCreative)+'; connect-src https: '+origin+
+  '; frame-src '+(outer?'data: ':'')+creativeOrigin+
+  "; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;";
+}
+function replaceOne(template,sentinel,replacement){
+ var first=template.indexOf(sentinel);
+ if(first<0||template.indexOf(sentinel,first+sentinel.length)>=0)return null;
+ return template.slice(0,first)+replacement+template.slice(first+sentinel.length);
+}
+function substitute(template,replacements){
+ var output=template;
+ for(var sentinel in replacements){
+  if(!Object.prototype.hasOwnProperty.call(replacements,sentinel))continue;
+  output=replaceOne(output,sentinel,replacements[sentinel]);
+  if(output===null)return null;
+ }
+ return /__TS_[A-Z0-9_]+__/.test(output)?null:output;
+}
+function dataUrl(source,nonce){return DATA_PREFIX+encodeURIComponent(source)+'#'+nonce;}
+function createContainer(configuration,origin){
+ var scriptCreative=configuration.tagType==='script';
+ var runnerUrl=origin+'/integrations/aps/runner.js';
+ var inner=substitute(INNER_TEMPLATE,{
+  __TS_INNER_CSP__:csp(origin,configuration.creativeOrigin,scriptCreative,false),
+  __TS_RENDERER_VALIDATOR__:RENDERER_VALIDATOR,
+  __TS_RENDERER_NONCE_JSON__:JSON.stringify(configuration.rendererNonce),
+  __TS_PUBLISHER_ORIGIN_JSON__:JSON.stringify(origin),
+  __TS_CREATIVE_ORIGIN_JSON__:JSON.stringify(configuration.creativeOrigin),
+  __TS_TAG_TYPE_JSON__:JSON.stringify(configuration.tagType),
+  __TS_RUNNER_URL_JSON__:JSON.stringify(runnerUrl)
+ });
+ if(!inner||utf8Length(inner)>65536)return null;
+ var innerUrl=dataUrl(inner,configuration.rendererNonce);
+ var outer=substitute(OUTER_TEMPLATE,{
+  __TS_OUTER_CSP__:csp(origin,configuration.creativeOrigin,scriptCreative,true),
+  __TS_BOOTSTRAP_NONCE_JSON__:JSON.stringify(configuration.bootstrapNonce),
+  __TS_RENDERER_NONCE_JSON__:JSON.stringify(configuration.rendererNonce),
+  __TS_INNER_URL_JSON__:JSON.stringify(innerUrl),
+  __TS_PERMANENT_SANDBOX_JSON__:JSON.stringify(PERMANENT_SANDBOX)
+ });
+ if(!outer||utf8Length(outer)>65536)return null;
+ var outerUrl=dataUrl(outer,configuration.bootstrapNonce);
+ return utf8Length(outerUrl)<=MAX_CONTAINER_URL_BYTES?outerUrl:null;
+}
+var match=/^#(b1_[A-Za-z0-9_-]{22})$/.exec(location.hash);
+var nonce=match&&match[1];
+if(!nonce)return;
+try{history.replaceState(null,'',location.pathname+location.search);}catch(_error){}
+var consumed=false;
+function receive(event){
+ if(consumed||event.source!==parent||!validParentOrigin(event.origin)||
+    !event.ports||event.ports.length!==0||typeof event.data!=='string'||
+    utf8Length(event.data)>MAX_CONFIGURATION_BYTES)return;
+ var origin=event.origin;
+ var value;
+ try{value=JSON.parse(event.data);}catch(_error){return;}
+ if(!exact(value,['bootstrapNonce','creativeOrigin','message','rendererNonce','tagType','version'])||
+    value.message!=='TS APS Bootstrap Configure'||value.version!==2||
+    value.bootstrapNonce!==nonce||
+    typeof value.rendererNonce!=='string'||!/^n1_[A-Za-z0-9_-]{22}$/.test(value.rendererNonce)||
+    !validCreativeOrigin(value.creativeOrigin,origin)||
+    (value.tagType!=='iframe'&&value.tagType!=='script')||
+    event.data!==JSON.stringify({message:'TS APS Bootstrap Configure',version:2,
+     bootstrapNonce:nonce,rendererNonce:value.rendererNonce,
+     creativeOrigin:value.creativeOrigin,tagType:value.tagType}))return;
+ var containerUrl=createContainer(value,origin);
+ if(!containerUrl)return;
+ consumed=true;
+ removeEventListener('message',receive);
+ location.replace(containerUrl);
+}
+addEventListener('message',receive);
+parent.postMessage(JSON.stringify({message:'TS APS Bootstrap Ready',version:1,
+ bootstrapNonce:nonce}),'*');
+})();
+</script>
diff --git a/crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js b/crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js
new file mode 100644
index 000000000..5c8a161f1
--- /dev/null
+++ b/crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js
@@ -0,0 +1,138 @@
+// @generated by scripts/generate-aps-renderer-contract.mjs
+// schema-sha256: 3f82e9c8d57719c29810a0ed181f4fe2779919c65605ae0cd7c61bd6d865b027
+// corpus-sha256: 3aea612e3316e6df4852e80cb3aa8882ca43d842455a22ba29e63fa88291c7b9
+var DESCRIPTOR_KEYS = ["aaxResponse","accountId","bidId","creativeUrl","height","tagType","type","version","width"];
+var DESCRIPTOR_KEYS_WITH_CREATIVE_ID = ["aaxResponse","accountId","bidId","creativeId","creativeUrl","height","tagType","type","version","width"];
+var ENVELOPE_ROOT_KEYS = ["seatbid"];
+var ENVELOPE_SEAT_KEYS = ["bid"];
+var ENVELOPE_BID_KEYS = ["ext","h","id","price","w"];
+var ENVELOPE_EXT_KEYS = ["creativeurl","tagtype"];
+var MAX_ACCOUNT_ID_BYTES = 1024;
+var MAX_BID_ID_BYTES = 64;
+var MAX_CREATIVE_ID_BYTES = 1024;
+var MAX_CREATIVE_URL_BYTES = 4096;
+var MAX_RENDER_ENVELOPE_BYTES = 262144;
+var MAX_RENDER_ENVELOPE_BASE64_BYTES = 349528;
+var STANDARD_BASE64_PATTERN = "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$";
+var RENDER_DIMENSION_MIN = 1;
+var RENDER_DIMENSION_MAX = 4096;
+function apsExactRecord(value, expectedKeys) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  var prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  if (typeof Object.getOwnPropertySymbols === 'function' && Object.getOwnPropertySymbols(value).length !== 0) return false;
+  var actual = Object.getOwnPropertyNames(value).sort();
+  if (actual.length !== expectedKeys.length) return false;
+  for (var index = 0; index < actual.length; index += 1) {
+    var propertyName = actual[index];
+    if (propertyName === undefined || propertyName !== expectedKeys[index]) return false;
+    var property = Object.getOwnPropertyDescriptor(value, propertyName);
+    if (!property || !Object.prototype.hasOwnProperty.call(property, 'value')) return false;
+  }
+  return true;
+}
+
+function apsUtf8Length(value) {
+  return (new TextEncoder()).encode(value).length;
+}
+
+function apsHasAsciiControl(value) {
+  return /[\x00-\x1f\x7f]/.test(value);
+}
+
+function apsDimensionResult(value) {
+  if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value || value <= 0) {
+    return 'invalid_dimensions';
+  }
+  if (value < RENDER_DIMENSION_MIN || value > RENDER_DIMENSION_MAX) {
+    return 'dimensions_out_of_range';
+  }
+  return 'accepted';
+}
+
+function apsValidCreativeUrl(value, publisherOrigin) {
+  try {
+    var url = new URL(value);
+    return url.protocol === 'https:' && url.hostname !== '' && url.username === '' &&
+      url.password === '' && url.origin !== publisherOrigin;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function apsDecodeEnvelope(value) {
+  if (value.length === 0 || value.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||
+      value.length % 4 !== 0 || !(new RegExp(STANDARD_BASE64_PATTERN)).test(value)) {
+    return undefined;
+  }
+  try {
+    var binary = atob(value);
+    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;
+    var bytes = new Uint8Array(binary.length);
+    for (var index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } catch (_error) {
+    return undefined;
+  }
+}
+
+function classifyApsRendererDescriptorV1(
+  value
+) {
+  var renderer = value;
+  if (!apsExactRecord(renderer, DESCRIPTOR_KEYS) &&
+      !apsExactRecord(renderer, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)) return 'descriptor_invalid';
+  if (renderer.type !== 'aps' || renderer.version !== 1 ||
+      typeof renderer.accountId !== 'string' || renderer.accountId.length === 0 ||
+      apsUtf8Length(renderer.accountId) > MAX_ACCOUNT_ID_BYTES ||
+      typeof renderer.bidId !== 'string' || renderer.bidId.length === 0 ||
+      apsUtf8Length(renderer.bidId) > MAX_BID_ID_BYTES ||
+      apsHasAsciiControl(renderer.bidId)) return 'descriptor_invalid';
+  if (Object.prototype.hasOwnProperty.call(renderer, 'creativeId') &&
+      (typeof renderer.creativeId !== 'string' || renderer.creativeId.length === 0 ||
+       apsUtf8Length(renderer.creativeId) > MAX_CREATIVE_ID_BYTES)) return 'descriptor_invalid';
+  if (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') return 'descriptor_invalid';
+
+  var widthResult = apsDimensionResult(renderer.width);
+  if (widthResult !== 'accepted') return widthResult;
+  var heightResult = apsDimensionResult(renderer.height);
+  if (heightResult !== 'accepted') return heightResult;
+
+  if (typeof renderer.creativeUrl !== 'string' ||
+      apsUtf8Length(renderer.creativeUrl) > MAX_CREATIVE_URL_BYTES ||
+      typeof renderer.aaxResponse !== 'string' ||
+      renderer.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES) return 'descriptor_invalid';
+  return 'accepted';
+}
+
+function classifyApsRendererV1(
+  value,
+  publisherOrigin
+) {
+  var renderer = value;
+  var descriptorResult =
+    classifyApsRendererDescriptorV1(renderer);
+  if (descriptorResult !== 'accepted') return descriptorResult;
+  if (!apsValidCreativeUrl(renderer.creativeUrl, publisherOrigin)) return 'descriptor_invalid';
+
+  var decoded = apsDecodeEnvelope(renderer.aaxResponse);
+  if (!apsExactRecord(decoded, ENVELOPE_ROOT_KEYS) || !Array.isArray(decoded.seatbid) ||
+      decoded.seatbid.length !== 1) return 'descriptor_invalid';
+  var seat = decoded.seatbid[0];
+  if (!apsExactRecord(seat, ENVELOPE_SEAT_KEYS) || !Array.isArray(seat.bid) ||
+      seat.bid.length !== 1) return 'descriptor_invalid';
+  var bid = seat.bid[0];
+  if (!apsExactRecord(bid, ENVELOPE_BID_KEYS) ||
+      !apsExactRecord(bid.ext, ENVELOPE_EXT_KEYS)) return 'descriptor_invalid';
+
+  var bidWidthResult = apsDimensionResult(bid.w);
+  if (bidWidthResult !== 'accepted') return bidWidthResult;
+  var bidHeightResult = apsDimensionResult(bid.h);
+  if (bidHeightResult !== 'accepted') return bidHeightResult;
+  if (bid.id !== renderer.bidId || bid.w !== renderer.width || bid.h !== renderer.height ||
+      bid.ext.creativeurl !== renderer.creativeUrl || bid.ext.tagtype !== renderer.tagType ||
+      typeof bid.price !== 'number' || !isFinite(bid.price) || bid.price < 0) {
+    return 'descriptor_invalid';
+  }
+  return 'accepted';
+}
diff --git a/crates/trusted-server-core/src/integrations/google_tag_manager.rs b/crates/trusted-server-core/src/integrations/google_tag_manager.rs
index 43eb1d9a4..594abfb9b 100644
--- a/crates/trusted-server-core/src/integrations/google_tag_manager.rs
+++ b/crates/trusted-server-core/src/integrations/google_tag_manager.rs
@@ -418,6 +418,7 @@ pub fn register(
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
             .with_script_rewriter(integration)
+            .with_empty_browser_config_v1()?
             .build(),
     ))
 }
diff --git a/crates/trusted-server-core/src/integrations/gpt.rs b/crates/trusted-server-core/src/integrations/gpt.rs
index 9a0905455..f87df6460 100644
--- a/crates/trusted-server-core/src/integrations/gpt.rs
+++ b/crates/trusted-server-core/src/integrations/gpt.rs
@@ -77,11 +77,6 @@ pub struct GptConfig {
     #[validate(url)]
     pub script_url: String,
 
-    /// Cache TTL for proxied GPT scripts in seconds (default: 3600 = 1 hour).
-    #[serde(default = "default_cache_ttl")]
-    #[validate(range(min = 60, max = 86400))]
-    pub cache_ttl_seconds: u32,
-
     /// Whether to rewrite GPT script URLs in publisher HTML.
     #[serde(default = "default_rewrite_script")]
     pub rewrite_script: bool,
@@ -145,6 +140,7 @@ impl GptIntegration {
     ) -> ProxyRequestConfig<'a> {
         let mut config = ProxyRequestConfig::new(target_url)
             .with_streaming()
+            .with_cache_bypass()
             .without_forward_headers();
         config.follow_redirects = false;
         config.forward_ec_id = false;
@@ -196,8 +192,6 @@ impl GptIntegration {
         let status = parts.status;
         let content_type = parts.headers.get(header::CONTENT_TYPE).cloned();
         let content_encoding = parts.headers.get(header::CONTENT_ENCODING).cloned();
-        let etag = parts.headers.get(header::ETAG).cloned();
-        let last_modified = parts.headers.get(header::LAST_MODIFIED).cloned();
         let upstream_vary = parts
             .headers
             .get(header::VARY)
@@ -216,16 +210,6 @@ impl GptIntegration {
                 .insert(header::CONTENT_TYPE, content_type);
         }
 
-        if let Some(etag) = etag {
-            finalized.headers_mut().insert(header::ETAG, etag);
-        }
-
-        if let Some(last_modified) = last_modified {
-            finalized
-                .headers_mut()
-                .insert(header::LAST_MODIFIED, last_modified);
-        }
-
         if let Some(content_encoding) = content_encoding {
             finalized
                 .headers_mut()
@@ -242,11 +226,7 @@ impl GptIntegration {
         if status.is_success() {
             finalized.headers_mut().insert(
                 header::CACHE_CONTROL,
-                http::HeaderValue::from_str(&format!(
-                    "public, max-age={}",
-                    self.config.cache_ttl_seconds
-                ))
-                .expect("should build GPT Cache-Control header"),
+                http::HeaderValue::from_static("private, no-store"),
             );
         }
 
@@ -390,11 +370,26 @@ pub fn register(
         return Ok(None);
     };
 
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct GptBrowserConfigV1 {
+        gam_attribution_enabled: bool,
+        page_bids_enabled: bool,
+    }
+    let browser_config = GptBrowserConfigV1 {
+        gam_attribution_enabled: integration.config.gam_attribution_enabled,
+        page_bids_enabled: settings
+            .creative_opportunities
+            .as_ref()
+            .is_some_and(|config| config.enabled),
+    };
+
     Ok(Some(
         IntegrationRegistration::builder(GPT_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
-            .with_head_injector(integration)
+            .with_head_injector(integration.clone())
+            .with_browser_config_v1(&browser_config)?
             .build(),
     ))
 }
@@ -473,72 +468,12 @@ impl IntegrationHeadInjector for GptIntegration {
         GPT_INTEGRATION_ID
     }
 
-    /// Injects the `tsjs.adInit` bootstrap script into `<head>`.
-    ///
-    /// ## Scroll / refresh handoff contract (Phase 1)
-    ///
-    /// `tsjs.adInit` handles **initial render only**: it wires server-side bid
-    /// targeting into GPT slots and refreshes them. Win/billing beacons fire
-    /// only from the TS render bridge in the JS bundle, where a matching
-    /// Prebid Universal Creative request proves the TS creative rendered.
-    /// It does **not** trigger refresh auctions or handle GPT slot refresh events.
-    ///
-    /// Post-`window.load`, slim-Prebid owns scroll and GPT refresh: it listens
-    /// for GPT refresh events, runs client-side auctions, and sets targeting for
-    /// subsequent impressions. SPA navigation is handled separately by
-    /// `installSpaAuctionHook()` in the GPT bundle, which re-runs the server-side
-    /// auction via `GET /_ts/page-bids` on pushState / replaceState / popstate
-    /// route changes (see `auction/endpoints.rs`).
-    /// The `POST /auction` endpoint is not involved in scroll or refresh flows.
+    /// GPT startup is owned entirely by the release-matched TS integration.
     fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        let gam_attribution_flag = if self.config.gam_attribution_enabled {
-            "window.__tsjs_gam_attribution_enabled=true;"
-        } else {
-            ""
-        };
-
-        let mut scripts = vec![
-            format!(
-                "<script>window.__tsjs_gpt_enabled=true;{gam_attribution_flag}\
-                 window.__tsjs_installGptShim&&window.__tsjs_installGptShim();</script>"
-            ),
-            format!("<script>{}</script>", GPT_BOOTSTRAP_JS),
-        ];
-
-        if let Some(ref url) = self.config.slim_prebid_url {
-            // JSON-encode the URL, then escape `</` so a configured value
-            // containing the literal `</script>` cannot close this inline tag and
-            // let trailing markup execute (standard JSON-in-HTML mitigation).
-            let encoded = serde_json::to_string(url)
-                .expect("should serialize string")
-                .replace("</", "<\\/");
-            scripts.push(format!(
-                "<script>window.__tsjs_slim_prebid_url={encoded};</script>"
-            ));
-        }
-
-        scripts
-    }
-
-    fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-        if self.config.gam_attribution_enabled {
-            vec![("data-ts-gam-attribution", "true")]
-        } else {
-            Vec::new()
-        }
+        Vec::new()
     }
 }
 
-/// Inline `window.tsjs.adInit` bootstrap injected at `<head>` so the bids
-/// script at `</body>` can call it before the TSJS bundle has loaded.
-///
-/// The bundle's idempotent implementation in
-/// `crates/trusted-server-js/lib/src/integrations/gpt/index.ts` later overwrites this stub.
-/// Both implementations guard the one-time-per-page setup with
-/// `window.tsjs.servicesEnabled` so neither double-enables services if the
-/// publisher's own init code also calls `googletag.enableServices()`.
-const GPT_BOOTSTRAP_JS: &str = include_str!("gpt_bootstrap.js");
-
 // Default value functions
 
 fn default_enabled() -> bool {
@@ -549,10 +484,6 @@ fn default_script_url() -> String {
     "https://securepubads.g.doubleclick.net/tag/js/gpt.js".to_string()
 }
 
-fn default_cache_ttl() -> u32 {
-    3600
-}
-
 fn default_rewrite_script() -> bool {
     true
 }
@@ -570,7 +501,6 @@ mod tests {
             enabled: true,
             gam_attribution_enabled: false,
             script_url: default_script_url(),
-            cache_ttl_seconds: 3600,
             rewrite_script: true,
             slim_prebid_url: None,
         }
@@ -616,6 +546,36 @@ mod tests {
         assert!(enabled.gam_attribution_enabled);
     }
 
+    #[test]
+    fn browser_config_projects_creative_opportunity_delivery_state() {
+        for enabled in [false, true] {
+            let mut settings = create_test_settings();
+            settings
+                .integrations
+                .insert_config("gpt", &serde_json::json!({ "enabled": true }))
+                .expect("should enable GPT");
+            settings.creative_opportunities = Some(
+                toml::from_str(&format!(
+                    "enabled = {enabled}\ngam_network_id = \"12345\"\n"
+                ))
+                .expect("should build creative opportunity config"),
+            );
+
+            let registration = register(&settings)
+                .expect("GPT registration should succeed")
+                .expect("GPT should be enabled");
+
+            assert_eq!(
+                registration.browser_config_v1,
+                Some(serde_json::json!({
+                    "gamAttributionEnabled": false,
+                    "pageBidsEnabled": enabled,
+                })),
+                "GPT browser config must carry the exact publisher delivery switch"
+            );
+        }
+    }
+
     // -- URL detection --
 
     #[test]
@@ -777,6 +737,10 @@ mod tests {
             !config.follow_redirects,
             "should keep GPT asset proxying on the original single-hop trust boundary"
         );
+        assert!(
+            config.bypass_cache,
+            "should always fetch live GPT bytes through the platform"
+        );
     }
 
     #[test]
@@ -926,21 +890,13 @@ mod tests {
             Some("application/javascript; charset=utf-8"),
             "should preserve upstream content type for GPT assets"
         );
-        assert_eq!(
-            response
-                .headers()
-                .get(header::ETAG)
-                .and_then(|value| value.to_str().ok()),
-            Some("\"gpt-etag\""),
-            "should preserve upstream ETag validators for GPT assets"
+        assert!(
+            response.headers().get(header::ETAG).is_none(),
+            "should strip upstream ETag validators from live GPT relays"
         );
-        assert_eq!(
-            response
-                .headers()
-                .get(header::LAST_MODIFIED)
-                .and_then(|value| value.to_str().ok()),
-            Some("Thu, 13 Mar 2025 08:00:00 GMT"),
-            "should preserve upstream Last-Modified validators for GPT assets"
+        assert!(
+            response.headers().get(header::LAST_MODIFIED).is_none(),
+            "should strip upstream Last-Modified validators from live GPT relays"
         );
         assert_eq!(
             response
@@ -963,8 +919,8 @@ mod tests {
                 .headers()
                 .get(header::CACHE_CONTROL)
                 .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=3600"),
-            "should add cache headers for successful GPT asset responses"
+            Some("private, no-store"),
+            "should make every live GPT relay response uncacheable"
         );
         assert!(
             response.headers().get(header::SET_COOKIE).is_none(),
@@ -1071,7 +1027,6 @@ mod tests {
                 &serde_json::json!({
                     "enabled": true,
                     "script_url": "https://securepubads.g.doubleclick.net/tag/js/gpt.js",
-                    "cache_ttl_seconds": 3600,
                     "rewrite_script": true
                 }),
             )
@@ -1171,293 +1126,20 @@ mod tests {
     // -- Head injector --
 
     #[test]
-    fn head_injector_emits_enable_flag() {
+    fn head_injector_is_empty_because_the_ts_module_owns_gpt_startup() {
         let integration = GptIntegration::new(test_config());
         let doc_state = IntegrationDocumentState::default();
         let ctx = IntegrationHtmlContext {
             request_host: "edge.example.com",
             request_scheme: "https",
             origin_host: "example.com",
+            csp_nonce: None,
             document_state: &doc_state,
         };
 
         let inserts = integration.head_inserts(&ctx);
 
-        assert_eq!(inserts.len(), 2, "should emit exactly two head inserts");
-        assert_eq!(
-            inserts[0],
-            "<script>window.__tsjs_gpt_enabled=true;window.__tsjs_installGptShim&&window.__tsjs_installGptShim();</script>",
-            "should set the enable flag and call the GPT shim activation function"
-        );
-        assert!(
-            integration.tsjs_script_tag_attributes().is_empty(),
-            "should not authorize GAM attribution metadata by default"
-        );
-    }
-
-    #[test]
-    fn gam_attribution_true_adds_both_activation_signals_without_a_new_insert() {
-        let integration = GptIntegration::new(GptConfig {
-            gam_attribution_enabled: true,
-            ..test_config()
-        });
-        let document_state = IntegrationDocumentState::default();
-        let context = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "origin.example.com",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&context);
-
-        assert_eq!(inserts.len(), 2, "should not add another head insert");
-        assert!(
-            inserts[0].contains("window.__tsjs_gam_attribution_enabled=true;"),
-            "should activate the early bootstrap marker"
-        );
-        assert_eq!(
-            integration.tsjs_script_tag_attributes(),
-            vec![("data-ts-gam-attribution", "true")],
-            "should authorize the bundle fallback on the publisher tag"
-        );
-    }
-
-    #[test]
-    fn head_inserts_includes_ts_ad_init_with_synchronous_bids_read() {
-        let config = test_config();
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let inserts = integration.head_inserts(&ctx);
-        let combined = inserts.join("");
-        assert!(combined.contains("ts.adInit"), "should define tsjs.adInit");
-        assert!(
-            combined.contains("ts.bids"),
-            "should read tsjs.bids synchronously"
-        );
-        assert!(
-            combined.contains("ts_initial"),
-            "should set ts_initial sentinel"
-        );
-        assert!(
-            combined.contains("addEventListener(\"slotRequested\""),
-            "should observe publisher GPT requests before delayed adInit"
-        );
-        assert!(
-            combined.contains("addEventListener(\"slotRenderEnded\""),
-            "should observe publisher GPT renders before delayed adInit"
-        );
-        assert!(
-            !combined.contains("sendBeacon"),
-            "inline bootstrap lifecycle ownership must not fire win/billing beacons"
-        );
-        assert!(
-            !combined.contains("getTargeting(\"hb_adid\")"),
-            "inline bootstrap must not treat GPT targeting as winner proof"
-        );
-        assert!(
-            !combined.contains("/ts-bids"),
-            "must NOT fetch /ts-bids — bids are inline on the page"
-        );
-        assert!(
-            !combined.contains("bidsPromise"),
-            "must NOT use bidsPromise — bids are synchronous"
-        );
-        assert!(
-            !combined.contains("__ts_request_id"),
-            "must NOT reference request_id — no longer used"
-        );
-    }
-
-    #[test]
-    fn head_inserts_bootstrap_installs_fallback_scheduler() {
-        // The `</body>` bids script hands its payload to
-        // `tsjs.scheduleInitialAdInit`. The bundle installs the real scheduler,
-        // but when the bundle fails to load this head bootstrap must provide
-        // the degradation path — otherwise a failed bundle request would leave
-        // initial server-side ads uninitialized. Executable coverage of the
-        // fallback lives in the Vitest suite (gpt_bootstrap.test.ts).
-        let config = test_config();
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let combined = integration.head_inserts(&ctx).join("");
-        assert!(
-            combined.contains("ts.scheduleInitialAdInit"),
-            "should install the fallback scheduler for bundle-load failures"
-        );
-        assert!(
-            combined.contains("navGeneration"),
-            "fallback scheduler should honor the navigation-generation guard"
-        );
-        assert!(
-            combined.contains("requestAnimationFrame"),
-            "fallback scheduler should defer past hydration frames"
-        );
-        assert!(
-            combined.contains("\"load\""),
-            "fallback scheduler should gate on window load"
-        );
-        // The no-retry-timer property is owned by the executable suite
-        // (gpt_bootstrap.test.ts asserts adInit runs exactly once); a
-        // `!contains("setTimeout")` over the whole joined head-insert output
-        // would misattribute any future unrelated timer to the scheduler.
-    }
-
-    #[test]
-    fn head_inserts_bootstrap_uses_css_safe_div_prefix_lookup() {
-        let config = test_config();
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let combined = integration.head_inserts(&ctx).join("");
-        assert!(
-            combined.contains("querySelectorAll(\"[id]\")"),
-            "bootstrap should scan ID-bearing elements instead of interpolating div_id into CSS"
-        );
-        assert!(
-            combined.contains("candidate.id.startsWith(divId)"),
-            "bootstrap should match metacharacter-containing div_id prefixes with startsWith"
-        );
-        assert!(
-            !combined.contains("[id^='\" + slot.div_id"),
-            "bootstrap must not build a CSS attribute selector from raw div_id"
-        );
-    }
-
-    #[test]
-    fn head_inserts_bootstrap_installs_inner_div_slot_handoff() {
-        let integration = GptIntegration::new(test_config());
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let combined = integration.head_inserts(&ctx).join("");
-        assert!(
-            combined.contains("gptSlotHandoffs"),
-            "bootstrap should keep late publisher slot handoff state on window.tsjs"
-        );
-        assert!(
-            combined.contains("__tsSlotHandoffPatched"),
-            "bootstrap should install idempotent GPT handoff wrappers"
-        );
-        assert!(
-            combined.contains("return googletag.defineSlot") && combined.contains("actualDivId"),
-            "bootstrap should define the TS fallback on the actual inner div"
-        );
-        assert!(
-            !combined.contains("actualDivId + \"-container\""),
-            "bootstrap must not define a competing outer-container GPT slot"
-        );
-    }
-
-    #[test]
-    fn head_inserts_bootstrap_guards_enable_services_with_idempotency_flag() {
-        let config = test_config();
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let combined = integration.head_inserts(&ctx).join("");
-        assert!(
-            combined.contains("ts.servicesEnabled"),
-            "should guard enableServices/enableSingleRequest with the tsjs.servicesEnabled flag"
-        );
-        assert!(combined.contains("ts.adInit"), "should install tsjs.adInit");
-        assert!(
-            !combined.contains("googletag.pubads().refresh()"),
-            "should never call unbounded refresh() — only refresh(newSlots)"
-        );
-    }
-
-    #[test]
-    fn head_inserts_bootstrap_refreshes_ts_slots_when_initial_load_disabled() {
-        // Mirrors the bundle: when the publisher disables initial load through
-        // setConfig() or the legacy disableInitialLoad() method, display() only
-        // registers a TS-defined slot, so the bootstrap must also refresh those
-        // slots or they render blank.
-        let config = test_config();
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-        let combined = integration.head_inserts(&ctx).join("");
-        assert!(
-            combined.contains("gpt.setConfig"),
-            "bootstrap should wrap googletag.setConfig() to detect the disabled state"
-        );
-        assert!(
-            combined.contains("gpt.getConfig"),
-            "bootstrap should read GPT's modern initial-load configuration"
-        );
-        assert!(
-            combined.contains("pubads.disableInitialLoad"),
-            "bootstrap should wrap legacy disableInitialLoad() calls"
-        );
-        assert!(
-            combined.contains("gptInitialLoadDisabled"),
-            "bootstrap should record the initial-load-disabled state on window.tsjs"
-        );
-        assert!(
-            combined.contains("slotsNeedingRefresh"),
-            "bootstrap should refresh TS-defined slots when initial load is disabled"
-        );
-    }
-
-    #[test]
-    fn head_inserts_queue_gam_attribution_before_guard_and_ad_requests() {
-        let targeting_index = GPT_BOOTSTRAP_JS
-            .find("gpt.setConfig({ targeting: { ts: \"true\" } })")
-            .expect("should apply the fixed page-level GAM targeting pair");
-        let guard_index = GPT_BOOTSTRAP_JS
-            .find("if (ts.adInit) return;")
-            .expect("should retain the preinstalled adInit guard");
-        let display_index = GPT_BOOTSTRAP_JS
-            .find("googletag.display(divId);")
-            .expect("should retain the executable GPT display call");
-        let refresh_index = GPT_BOOTSTRAP_JS
-            .find("googletag.pubads().refresh(slotsNeedingRefresh);")
-            .expect("should retain the bounded GPT refresh call");
-
-        assert!(
-            targeting_index < guard_index,
-            "should enqueue attribution before the preinstalled adInit guard"
-        );
-        assert!(
-            targeting_index < display_index,
-            "should enqueue attribution before the executable display call"
-        );
-        assert!(
-            targeting_index < refresh_index,
-            "should enqueue attribution before the executable refresh call"
-        );
+        assert!(inserts.is_empty(), "must not retain a second GPT bootstrap");
     }
 
     #[test]
@@ -1468,97 +1150,4 @@ mod tests {
             "gpt"
         );
     }
-
-    #[test]
-    fn head_inserts_emits_slim_prebid_url_when_configured() {
-        let config = GptConfig {
-            slim_prebid_url: Some("https://cdn.example.com/tsjs-prebid.min.js".to_string()),
-            ..test_config()
-        };
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-
-        assert_eq!(
-            inserts.len(),
-            3,
-            "should emit three head inserts when slim_prebid_url is set"
-        );
-        assert_eq!(
-            inserts[2],
-            r#"<script>window.__tsjs_slim_prebid_url="https://cdn.example.com/tsjs-prebid.min.js";</script>"#,
-            "should emit the slim-Prebid URL as a JSON-encoded string assignment"
-        );
-    }
-
-    #[test]
-    fn head_inserts_escapes_script_terminator_in_slim_prebid_url() {
-        // A configured URL containing `</script>` must not close the inline tag.
-        let config = GptConfig {
-            slim_prebid_url: Some("https://cdn.example.com/x</script><img src=x>".to_string()),
-            ..test_config()
-        };
-        let integration = GptIntegration::new(config);
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-
-        // The injected `</script><img ...>` must be neutralised: the only
-        // `</script>` left is the tag's own legitimate closer.
-        assert!(
-            !inserts[2].contains("</script><img"),
-            "should escape the injected </script> terminator, got: {}",
-            inserts[2]
-        );
-        assert_eq!(
-            inserts[2].matches("</script>").count(),
-            1,
-            "only the tag's own closing </script> should remain, got: {}",
-            inserts[2]
-        );
-        assert!(
-            inserts[2].contains("<\\/script>"),
-            "should emit the escaped terminator, got: {}",
-            inserts[2]
-        );
-    }
-
-    #[test]
-    fn head_inserts_omits_slim_prebid_url_when_not_configured() {
-        let integration = GptIntegration::new(test_config());
-        let doc_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "edge.example.com",
-            request_scheme: "https",
-            origin_host: "example.com",
-            document_state: &doc_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-
-        assert_eq!(
-            inserts.len(),
-            2,
-            "should emit exactly two head inserts when slim_prebid_url is absent"
-        );
-        assert!(
-            inserts
-                .iter()
-                .all(|s| !s.contains("__tsjs_slim_prebid_url")),
-            "should not emit slim-Prebid URL tag when not configured"
-        );
-    }
 }
diff --git a/crates/trusted-server-core/src/integrations/gpt_bootstrap.js b/crates/trusted-server-core/src/integrations/gpt_bootstrap.js
deleted file mode 100644
index c7cceaa80..000000000
--- a/crates/trusted-server-core/src/integrations/gpt_bootstrap.js
+++ /dev/null
@@ -1,894 +0,0 @@
-// Edge-injected GPT auction bootstrap.
-//
-// This is the minimal `window.tsjs.adInit` that runs on first page load
-// before the TSJS bundle has had a chance to install its richer
-// idempotent implementation. The bundle in
-// crates/trusted-server-js/lib/src/integrations/gpt/index.ts overwrites `tsjs.adInit`
-// once it loads.
-//
-// Contract with the bundle:
-//   - Both implementations must set `window.tsjs.servicesEnabled = true`
-//     after calling `enableSingleRequest()`/`enableServices()` so a
-//     subsequent call becomes a no-op.
-//   - `refresh()` is called only for the slots defined in this pass,
-//     never the global slot list.
-//
-// Only installed if `window.tsjs.adInit` isn't already defined.
-(function () {
-  if (typeof window === "undefined") return;
-  var ts = (window.tsjs = window.tsjs || {});
-  var tag;
-
-  if (window.__tsjs_gam_attribution_enabled === true) {
-    tag = window.googletag = window.googletag || { cmd: [] };
-    tag.cmd = tag.cmd || [];
-    tag.cmd.push(function () {
-      try {
-        var gpt = window.googletag;
-        if (gpt && typeof gpt.setConfig === "function") {
-          // "ts" is the fixed GAM key, not the local window.tsjs alias.
-          gpt.setConfig({ targeting: { ts: "true" } });
-        }
-      } catch (error) {
-        // Attribution must not interrupt the existing bootstrap queue.
-        ts.log &&
-          ts.log.warn &&
-          ts.log.warn("GAM attribution targeting failed", error);
-      }
-    });
-  }
-
-  if (ts.adInit) return;
-
-  // Track whether the publisher disabled GPT initial load. Read the effective
-  // googletag.getConfig() value when available, and wrap googletag.setConfig()
-  // and the legacy pubads().disableInitialLoad() method so changes are
-  // synchronized immediately and still detected when getConfig() is
-  // unavailable. With initial load disabled, display() only registers a slot
-  // and the ad request must come from a later refresh(); adInit() reads this to
-  // refresh its own freshly defined
-  // slots so they are not left blank. Pushed onto the command queue so it runs
-  // before the publisher's own GPT configuration.
-  function syncInitialLoadDisabled(gpt) {
-    if (typeof gpt.getConfig !== "function") return false;
-    var config = gpt.getConfig("disableInitialLoad");
-    if (!config || typeof config.disableInitialLoad === "undefined") {
-      return false;
-    }
-    ts.gptInitialLoadDisabled = config.disableInitialLoad === true;
-    return true;
-  }
-
-  tag = tag || (window.googletag = window.googletag || { cmd: [] });
-  tag.cmd = tag.cmd || [];
-  tag.cmd.push(function () {
-    var gpt = window.googletag;
-    syncInitialLoadDisabled(gpt);
-    if (
-      typeof gpt.setConfig === "function" &&
-      !gpt.__tsInitialLoadConfigHooked
-    ) {
-      var originalSetConfig = gpt.setConfig.bind(gpt);
-      gpt.setConfig = function (config) {
-        var result = originalSetConfig.apply(gpt, arguments);
-        if (
-          !syncInitialLoadDisabled(gpt) &&
-          config &&
-          "disableInitialLoad" in config
-        ) {
-          ts.gptInitialLoadDisabled = config.disableInitialLoad === true;
-        }
-        return result;
-      };
-      gpt.__tsInitialLoadConfigHooked = true;
-    }
-
-    var pubads = gpt.pubads && gpt.pubads();
-    if (
-      !pubads ||
-      typeof pubads.disableInitialLoad !== "function" ||
-      pubads.__tsInitialLoadHooked
-    ) {
-      return;
-    }
-    var originalDisableInitialLoad = pubads.disableInitialLoad.bind(pubads);
-    pubads.disableInitialLoad = function () {
-      var result = originalDisableInitialLoad.apply(pubads, arguments);
-      if (!syncInitialLoadDisabled(gpt)) {
-        ts.gptInitialLoadDisabled = true;
-      }
-      return result;
-    };
-    pubads.__tsInitialLoadHooked = true;
-  });
-
-  var FIRST_IMPRESSION_LEASE_MS = 5000;
-  var MAX_FIRST_IMPRESSION_SLOTS = 256;
-
-  function firstImpressionState(now) {
-    var generation = ts.navGeneration || 0;
-    if (
-      !ts.firstImpression ||
-      ts.firstImpression.generation !== generation
-    ) {
-      ts.firstImpression = {
-        generation: generation,
-        nextToken: 0,
-        slots: {},
-        fallbackSlots: {},
-      };
-    }
-    var state = ts.firstImpression;
-    state.slots = state.slots || {};
-    state.fallbackSlots = state.fallbackSlots || {};
-    Object.keys(state.slots).forEach(function (elementId) {
-      var claim = state.slots[elementId];
-      if (
-        claim.generation !== generation ||
-        claim.slotElementId !== elementId ||
-        claim.element.ownerDocument !== document ||
-        claim.element !== document.getElementById(elementId) ||
-        !claim.element.isConnected
-      ) {
-        delete state.slots[elementId];
-        return;
-      }
-      var hasReservedFallback =
-        claim.owner === "publisher" &&
-        (claim.phase === "auctioning" || claim.phase === "delivery_pending") &&
-        state.fallbackSlots[elementId] === claim.element;
-      Object.keys(claim.publisherAuctions || {}).forEach(function (token) {
-        var auction = claim.publisherAuctions[token];
-        if (
-          auction.expiresAt <= now &&
-          !hasReservedFallback &&
-          !(claim.owner === "trusted_server" && auction.suppressDelivery)
-        ) {
-          delete claim.publisherAuctions[token];
-        }
-      });
-      if (
-        claim.owner === "publisher" &&
-        (claim.phase === "auctioning" || claim.phase === "delivery_pending") &&
-        Object.keys(claim.publisherAuctions || {}).length === 0 &&
-        claim.expiresAt <= now &&
-        !hasReservedFallback
-      ) {
-        delete state.slots[elementId];
-      }
-    });
-    Object.keys(state.fallbackSlots).forEach(function (elementId) {
-      var element = state.fallbackSlots[elementId];
-      if (
-        !element.isConnected ||
-        element.id !== elementId ||
-        document.getElementById(elementId) !== element
-      ) {
-        delete state.fallbackSlots[elementId];
-      }
-    });
-    return state;
-  }
-
-  function firstImpressionClaim(element) {
-    return firstImpressionState(Date.now()).slots[element.id];
-  }
-
-  function storeFirstImpressionClaim(state, claim) {
-    if (
-      !state.slots[claim.slotElementId] &&
-      Object.keys(state.slots).length >= MAX_FIRST_IMPRESSION_SLOTS
-    ) {
-      return false;
-    }
-    state.slots[claim.slotElementId] = claim;
-    return true;
-  }
-
-  function claimFirstImpressionForTrustedServer(element) {
-    var now = Date.now();
-    var state = firstImpressionState(now);
-    var existing = state.slots[element.id];
-    if (existing) {
-      var canTransitionPublisherFallback =
-        existing.owner === "publisher" &&
-        existing.phase !== "requested" &&
-        existing.phase !== "rendered" &&
-        existing.expiresAt <= now &&
-        state.fallbackSlots[element.id] === element;
-      if (!canTransitionPublisherFallback) return null;
-      existing.owner = "trusted_server";
-      existing.phase = "delivery_pending";
-      existing.expiresAt = now + FIRST_IMPRESSION_LEASE_MS;
-      Object.keys(existing.publisherAuctions || {}).forEach(function (token) {
-        existing.publisherAuctions[token].suppressDelivery = true;
-      });
-      return existing;
-    }
-    var claim = {
-      generation: state.generation,
-      slotElementId: element.id,
-      element: element,
-      owner: "trusted_server",
-      phase: "delivery_pending",
-      expiresAt: now + FIRST_IMPRESSION_LEASE_MS,
-      publisherAuctions: {},
-    };
-    return storeFirstImpressionClaim(state, claim) ? claim : null;
-  }
-
-  function releaseTrustedServerFirstImpressionClaim(element, claim) {
-    var state = firstImpressionState(Date.now());
-    if (
-      state.slots[element.id] === claim &&
-      claim.owner === "trusted_server" &&
-      claim.phase === "delivery_pending"
-    ) {
-      delete state.slots[element.id];
-      if (state.fallbackSlots[element.id] === element) {
-        delete state.fallbackSlots[element.id];
-      }
-    }
-  }
-
-  function installFirstImpressionListeners() {
-    if (ts.firstImpressionListenersInstalled) return;
-    tag.cmd.push(function () {
-      if (ts.firstImpressionListenersInstalled) return;
-      var pubads = window.googletag.pubads();
-      if (!pubads || typeof pubads.addEventListener !== "function") return;
-      var observe = function (phase) {
-        return function (event) {
-          var elementId =
-            event.slot && event.slot.getSlotElementId
-              ? event.slot.getSlotElementId()
-              : "";
-          var element = elementId && document.getElementById(elementId);
-          if (!element) return;
-          var state = firstImpressionState(Date.now());
-          var claim = state.slots[elementId];
-          if (!claim) {
-            storeFirstImpressionClaim(state, {
-              generation: state.generation,
-              slotElementId: elementId,
-              element: element,
-              owner: "publisher",
-              phase: phase,
-              expiresAt: Number.POSITIVE_INFINITY,
-              publisherAuctions: {},
-            });
-            return;
-          }
-          claim.phase = phase;
-          if (claim.owner === "publisher") {
-            claim.expiresAt = Number.POSITIVE_INFINITY;
-          } else {
-            claim.publisherRegistrationClosed = true;
-          }
-        };
-      };
-      pubads.addEventListener("slotRequested", observe("requested"));
-      pubads.addEventListener("slotRenderEnded", observe("rendered"));
-      ts.firstImpressionListenersInstalled = true;
-    });
-  }
-
-  installFirstImpressionListeners();
-
-  // Minimal fallback for tsjs.scheduleInitialAdInit, mirroring the bundle's
-  // hydration-safe scheduler in
-  // crates/trusted-server-js/lib/src/integrations/gpt/index.ts: the </body>
-  // bids script hands the SSR bids payload to this scheduler, which applies
-  // it and runs adInit only while the page is still on navigation
-  // generation 0 (the SSR document), after window load plus a double
-  // requestAnimationFrame so the call lands outside React's hydration
-  // window. Keeps initial server-side ads working when the main TSJS bundle
-  // fails to load; the bundle overwrites this with the full implementation.
-  //
-  // Hidden documents: rAF is not serviced while the document is hidden, so a
-  // background-tab load holds the initial adInit until first view. Intended,
-  // and deliberately identical to the bundle scheduler — the impression is
-  // spent on a viewed tab, and the post-hydration guarantee holds whenever
-  // the request is actually issued.
-  ts.scheduleInitialAdInit = function (initialBids, initialSlots) {
-    // The bundle may replace this scheduler after the fallback claims the initial
-    // pass. Keep the latch on the shared document API so replacement cannot reset it.
-    if ((ts.navGeneration || 0) !== 0 || ts.initialAdInitScheduled) return;
-    ts.initialAdInitScheduled = true;
-    // Slots are generation-guarded for the same reason the bids are: the
-    // shared-template seam sends both, and an assignment made before this call
-    // would overwrite a committed SPA navigation's slots.
-    if (initialSlots !== undefined) ts.adSlots = initialSlots;
-    if (initialBids !== undefined) ts.bids = initialBids;
-    var fire = function () {
-      if ((ts.navGeneration || 0) !== 0) return;
-      if (typeof ts.adInit === "function") ts.adInit();
-    };
-    var afterFrames = function () {
-      window.requestAnimationFrame(function () {
-        window.requestAnimationFrame(fire);
-      });
-    };
-    if (document.readyState === "complete") afterFrames();
-    else window.addEventListener("load", afterFrames, { once: true });
-  };
-
-  function findSlotByElementId(pubads, elementId) {
-    var slots = pubads.getSlots ? pubads.getSlots() : [];
-    return (
-      slots.find(function (slot) {
-        return slot.getSlotElementId() === elementId;
-      }) || null
-    );
-  }
-
-  function normalizedGptFormats(formats) {
-    return formats.length === 2 &&
-      formats.every(function (format) {
-        return typeof format === "number";
-      })
-      ? [formats]
-      : formats;
-  }
-
-  function handoffFormatsMatch(handoff, formats) {
-    return (
-      JSON.stringify(handoff.formats) ===
-      JSON.stringify(normalizedGptFormats(formats))
-    );
-  }
-
-  function matchingHandoff(pubads, adUnitPath, formats, elementId) {
-    var exact = ts.gptSlotHandoffs && ts.gptSlotHandoffs[elementId];
-    if (exact) return exact.publisherClaimed ? null : exact;
-
-    var candidates = Object.values(ts.gptSlotHandoffs || {}).filter(
-      function (handoff, index, allHandoffs) {
-        return (
-          allHandoffs.indexOf(handoff) === index &&
-          !handoff.publisherClaimed &&
-          !document.getElementById(handoff.slotElementId) &&
-          elementId.startsWith(handoff.divIdPrefix) &&
-          handoff.gamUnitPath === adUnitPath &&
-          handoffFormatsMatch(handoff, formats) &&
-          findSlotByElementId(pubads, handoff.slotElementId)
-        );
-      },
-    );
-    return candidates.length === 1 ? candidates[0] : null;
-  }
-
-  function displayTargetElementId(target) {
-    if (typeof target === "string") return target;
-    if (target && typeof target.getSlotElementId === "function") {
-      return target.getSlotElementId();
-    }
-    return target && target.id ? target.id : null;
-  }
-
-  function isElementVisible(element) {
-    if (typeof element.checkVisibility === "function") {
-      return element.checkVisibility({
-        checkVisibilityCSS: true,
-        visibilityProperty: true,
-      });
-    }
-
-    for (var current = element; current; current = current.parentElement) {
-      var style = window.getComputedStyle(current);
-      if (
-        style.display === "none" ||
-        style.visibility === "hidden" ||
-        style.visibility === "collapse"
-      ) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  function slotElementHasLayout(element) {
-    if (!isElementVisible(element)) return false;
-    var elementRect = element.getBoundingClientRect();
-    if (elementRect.width > 0 && elementRect.height > 0) return true;
-
-    var container = document.getElementById(element.id + "-container");
-    if (!container || !isElementVisible(container)) return false;
-    var containerRect = container.getBoundingClientRect();
-    return containerRect.width > 0;
-  }
-
-  function resolveSlotElementByDivId(divId) {
-    if (!divId) {
-      return { element: null, prefixMatchCount: 0, activeMatchCount: 0 };
-    }
-    // Exact-id matches intentionally skip the visibility tiers below: a
-    // configured literal id is unambiguous, so a hidden match is still the
-    // right element. Prefix matches go through the tiers because a prefix can
-    // match several candidates and only visibility/layout disambiguates them —
-    // so a hidden exact-id match resolves while a hidden prefix match does not.
-    var exact = document.getElementById(divId);
-    if (exact) {
-      return { element: exact, prefixMatchCount: 1, activeMatchCount: 1 };
-    }
-
-    var idElements = document.querySelectorAll("[id]");
-    var prefixMatches = [];
-    for (var i = 0; i < idElements.length; i++) {
-      var candidate = idElements[i];
-      if (
-        candidate.id.startsWith(divId) &&
-        !candidate.id.endsWith("-container")
-      ) {
-        prefixMatches.push(candidate);
-      }
-    }
-    // A unique prefix match may be a lazy slot that has not been sized yet,
-    // but it must still be visible through its ancestor containers.
-    if (prefixMatches.length === 1 && isElementVisible(prefixMatches[0])) {
-      return {
-        element: prefixMatches[0],
-        prefixMatchCount: 1,
-        activeMatchCount: 1,
-      };
-    }
-
-    var visibleMatches = prefixMatches.filter(isElementVisible);
-    if (visibleMatches.length === 1) {
-      return {
-        element: visibleMatches[0],
-        prefixMatchCount: prefixMatches.length,
-        activeMatchCount: 1,
-      };
-    }
-
-    var activeMatches = visibleMatches.filter(slotElementHasLayout);
-    return {
-      element: activeMatches.length === 1 ? activeMatches[0] : null,
-      prefixMatchCount: prefixMatches.length,
-      activeMatchCount: activeMatches.length,
-    };
-  }
-
-  function runHandoffInternal(callback) {
-    var wasInternal = ts.gptSlotHandoffInternal;
-    ts.gptSlotHandoffInternal = true;
-    try {
-      return callback();
-    } finally {
-      ts.gptSlotHandoffInternal = wasInternal;
-    }
-  }
-
-  // TS cannot wait an arbitrary amount of time for a framework to define a
-  // slot: publishers that never define one would render blank. Instead, TS
-  // defines its fallback on the actual inner div and aliases only a later
-  // publisher defineSlot() for that exact div, or a hydration-renamed replacement
-  // after the original div is gone, to the same GPT slot.
-  function installSlotHandoff() {
-    window.googletag.cmd.push(function () {
-      var tag = window.googletag;
-      var pubads = tag.pubads && tag.pubads();
-      if (!tag.defineSlot || !tag.display || !pubads) return;
-
-      if (!tag.defineSlot.__tsSlotHandoffPatched) {
-        var originalDefineSlot = tag.defineSlot.bind(tag);
-        var patchedDefineSlot = function (adUnitPath, formats, elementId) {
-          if (!ts.gptSlotHandoffInternal && typeof elementId === "string") {
-            var handoff = matchingHandoff(
-              pubads,
-              adUnitPath,
-              formats,
-              elementId,
-            );
-            if (handoff) {
-              var existingSlot = findSlotByElementId(
-                pubads,
-                handoff.slotElementId,
-              );
-              if (existingSlot) {
-                ts.gptSlotHandoffs[elementId] = handoff;
-                handoff.publisherClaimed = true;
-                // The supported publisher lifecycle is defineSlot → addService → display.
-                // Intentionally wait for that display instead of applying a time heuristic.
-                handoff.suppressPublisherDisplay = true;
-                handoff.suppressPublisherRefresh =
-                  ts.gptInitialLoadDisabled === true;
-                ts.prevGptSlots = (ts.prevGptSlots || []).filter(
-                  function (ownedSlot) {
-                    return ownedSlot !== existingSlot;
-                  },
-                );
-                if (
-                  handoff.gamUnitPath !== adUnitPath ||
-                  !handoffFormatsMatch(handoff, formats)
-                ) {
-                  ts.log &&
-                    ts.log.warn &&
-                    ts.log.warn(
-                      "GPT slot handoff: publisher definition differs from TS configuration",
-                      elementId,
-                    );
-                }
-                return existingSlot;
-              }
-            }
-          }
-          return elementId === undefined
-            ? originalDefineSlot(adUnitPath, formats)
-            : originalDefineSlot(adUnitPath, formats, elementId);
-        };
-        patchedDefineSlot.__tsSlotHandoffPatched = true;
-        tag.defineSlot = patchedDefineSlot;
-      }
-
-      if (!tag.display.__tsSlotHandoffPatched) {
-        var originalDisplay = tag.display.bind(tag);
-        var patchedDisplay = function (target) {
-          var elementId = displayTargetElementId(target);
-          var handoff =
-            elementId && ts.gptSlotHandoffs && ts.gptSlotHandoffs[elementId];
-          if (
-            !ts.gptSlotHandoffInternal &&
-            handoff &&
-            handoff.suppressPublisherDisplay
-          ) {
-            handoff.suppressPublisherDisplay = false;
-            return;
-          }
-          originalDisplay(target);
-        };
-        patchedDisplay.__tsSlotHandoffPatched = true;
-        tag.display = patchedDisplay;
-      }
-
-      if (!pubads.refresh.__tsSlotHandoffPatched) {
-        var originalRefresh = pubads.refresh.bind(pubads);
-        var callRefresh = function (slots, options) {
-          if (options === undefined) {
-            originalRefresh(slots);
-          } else {
-            originalRefresh(slots, options);
-          }
-        };
-        var patchedRefresh = function (requestedSlots, options) {
-          if (ts.gptSlotHandoffInternal) {
-            callRefresh(requestedSlots, options);
-            return;
-          }
-          var slots =
-            requestedSlots || (pubads.getSlots ? pubads.getSlots() : null);
-          if (!slots) {
-            callRefresh(requestedSlots, options);
-            return;
-          }
-          var suppressed = false;
-          var remainingSlots = slots.filter(function (slot) {
-            var handoff =
-              ts.gptSlotHandoffs && ts.gptSlotHandoffs[slot.getSlotElementId()];
-            if (!handoff || !handoff.suppressPublisherRefresh) return true;
-            handoff.suppressPublisherRefresh = false;
-            suppressed = true;
-            return false;
-          });
-          if (!suppressed) {
-            callRefresh(requestedSlots, options);
-          } else if (remainingSlots.length > 0) {
-            callRefresh(remainingSlots, options);
-          }
-        };
-        patchedRefresh.__tsSlotHandoffPatched = true;
-        pubads.refresh = patchedRefresh;
-      }
-    });
-  }
-
-  installSlotHandoff();
-
-  function bootstrapTargeting(slot, bid) {
-    var targeting = Object.assign({}, slot.targeting || {});
-    ["hb_pb", "hb_bidder", "hb_adid", "hb_cache_host", "hb_cache_path"].forEach(
-      function (key) {
-        if (bid[key]) targeting[key] = String(bid[key]);
-      },
-    );
-    targeting.ts_initial = "1";
-    return targeting;
-  }
-
-  function scheduleFirstImpressionFallback(slot, bid, element, generation) {
-    var state = firstImpressionState(Date.now());
-    if (state.fallbackSlots[element.id]) return;
-    state.fallbackSlots[element.id] = element;
-
-    var retry = function () {
-      if (
-        (ts.navGeneration || 0) !== generation ||
-        !element.isConnected ||
-        document.getElementById(element.id) !== element
-      ) {
-        return;
-      }
-      var claim = firstImpressionClaim(element);
-      if (claim) {
-        if (
-          claim.owner !== "publisher" ||
-          claim.phase === "requested" ||
-          claim.phase === "rendered"
-        ) {
-          return;
-        }
-        var delay = Math.max(0, claim.expiresAt - Date.now());
-        if (delay > 0) {
-          window.setTimeout(retry, delay + 1);
-          return;
-        }
-      }
-
-      tag.cmd.push(function () {
-        if (
-          (ts.navGeneration || 0) !== generation ||
-          !element.isConnected ||
-          document.getElementById(element.id) !== element
-        ) {
-          return;
-        }
-        var fallbackClaim = claimFirstImpressionForTrustedServer(element);
-        if (!fallbackClaim) return;
-        var pubads = window.googletag.pubads();
-        var existingSlots = pubads.getSlots ? pubads.getSlots() : [];
-        var gptSlot =
-          existingSlots.find(function (candidate) {
-            return candidate.getSlotElementId() === element.id;
-          }) || null;
-        var tsOwned = false;
-        if (!gptSlot) {
-          gptSlot = runHandoffInternal(function () {
-            return window.googletag.defineSlot(
-              slot.gam_unit_path,
-              slot.formats,
-              element.id,
-            );
-          });
-          if (!gptSlot) {
-            releaseTrustedServerFirstImpressionClaim(element, fallbackClaim);
-            return;
-          }
-          gptSlot.addService(pubads);
-          tsOwned = true;
-          ts.gptSlotHandoffs = ts.gptSlotHandoffs || {};
-          ts.gptSlotHandoffs[element.id] = {
-            gamUnitPath: slot.gam_unit_path,
-            formats: slot.formats,
-            divIdPrefix: slot.div_id,
-            slotElementId: element.id,
-            publisherClaimed: false,
-            suppressPublisherDisplay: false,
-            suppressPublisherRefresh: false,
-          };
-        }
-
-        var targeting = bootstrapTargeting(slot, bid);
-        Object.entries(targeting).forEach(function (entry) {
-          gptSlot.setTargeting(entry[0], entry[1]);
-        });
-        fallbackClaim.targeting = targeting;
-        var slotElementId = gptSlot.getSlotElementId() || element.id;
-        ts.divToSlotId = ts.divToSlotId || {};
-        ts.divToSlotId[element.id] = slot.id;
-        ts.divToSlotId[slotElementId] = slot.id;
-        ts.prevSlotTargetingKeys = ts.prevSlotTargetingKeys || {};
-        var targetingKeys = Object.keys(slot.targeting || {});
-        ts.prevSlotTargetingKeys[element.id] = targetingKeys;
-        ts.prevSlotTargetingKeys[slotElementId] = targetingKeys;
-        if (tsOwned) {
-          ts.prevGptSlots = ts.prevGptSlots || [];
-          ts.prevGptSlots.push(gptSlot);
-        }
-        if (!ts.servicesEnabled) {
-          pubads.enableSingleRequest();
-          window.googletag.enableServices();
-          ts.servicesEnabled = true;
-        }
-        if (tsOwned) {
-          runHandoffInternal(function () {
-            window.googletag.display(slotElementId);
-          });
-        }
-        syncInitialLoadDisabled(window.googletag);
-        if (!tsOwned || ts.gptInitialLoadDisabled) {
-          ts.adInitRefreshInProgress = true;
-          try {
-            runHandoffInternal(function () {
-              pubads.refresh([gptSlot]);
-            });
-          } finally {
-            ts.adInitRefreshInProgress = false;
-          }
-        }
-      });
-    };
-
-    retry();
-  }
-
-  ts.adInit = function () {
-    var slots = ts.adSlots || [];
-    var bids = ts.bids || {};
-    var divToSlotId = {};
-    var nextSlotTargetingKeys = {};
-    // Generation this invocation belongs to. The slot work below is queued on
-    // googletag.cmd, which drains only when GPT loads; recheck first inside
-    // the queued callback so a navigation committed in the gap cancels the
-    // stale mutation — mirrors the bundle's adInit.
-    var generation = ts.navGeneration || 0;
-    var warnedResolutionFailures = Object.create(null);
-
-    googletag.cmd.push(function () {
-      if ((ts.navGeneration || 0) !== generation) return;
-      // Slots TS defined itself — tracked for SPA destroy. Publisher-owned
-      // slots are reused but never destroyed by TS on navigation.
-      var newSlots = [];
-      // Publisher-owned slots TS reused — refreshed to pick up server-side
-      // targeting. The publisher already display()ed these.
-      var slotsToRefresh = [];
-      // Element IDs of slots TS defined itself. GPT requires display() to
-      // register/render a freshly-defined slot; refresh() alone no-ops for a
-      // slot that was never displayed, so these are display()ed instead.
-      var slotsToDisplay = [];
-      slots.forEach(function (slot) {
-        // Resolve actual div ID: exact match first, then the visibility and
-        // geometry tiers for prefix matches. Responsive publishers may emit
-        // several mutually exclusive siblings for one stable prefix, so
-        // document order is not sufficient.
-        var resolution = resolveSlotElementByDivId(slot.div_id);
-        var el = resolution.element;
-        if (!el) {
-          if (!warnedResolutionFailures[slot.div_id]) {
-            if (resolution.prefixMatchCount > 1) {
-              warnedResolutionFailures[slot.div_id] = true;
-              if (ts.log && typeof ts.log.warn === "function") {
-                ts.log.warn(
-                  "GPT slot prefix did not resolve to one active element",
-                  {
-                    divId: slot.div_id,
-                    prefixMatchCount: resolution.prefixMatchCount,
-                    activeMatchCount: resolution.activeMatchCount,
-                  },
-                );
-              }
-            } else if (
-              resolution.prefixMatchCount === 1 &&
-              resolution.activeMatchCount === 0
-            ) {
-              // The common breakpoint-hidden config: the prefix matched one
-              // element but it is hidden, so the slot is skipped. Logged so a
-              // blank placement is diagnosable without stepping the resolver.
-              warnedResolutionFailures[slot.div_id] = true;
-              if (ts.log && typeof ts.log.debug === "function") {
-                ts.log.debug(
-                  "GPT slot prefix matched only a hidden element; skipping slot",
-                  { divId: slot.div_id },
-                );
-              }
-            }
-          }
-          return;
-        }
-        var actualDivId = el.id;
-        var b = bids[slot.id] || {};
-        var tsClaim = claimFirstImpressionForTrustedServer(el);
-        if (!tsClaim) {
-          var currentClaim = firstImpressionClaim(el);
-          if (currentClaim && currentClaim.owner === "publisher") {
-            scheduleFirstImpressionFallback(slot, b, el, generation);
-          }
-          return;
-        }
-
-        var existingSlots = googletag.pubads().getSlots();
-        var s =
-          existingSlots.find(function (gs) {
-            return gs.getSlotElementId() === actualDivId;
-          }) || null;
-        var tsOwned = false;
-        if (!s) {
-          // Define TS's fallback on the publisher's actual div. The scoped
-          // handoff wrapper returns this slot if the publisher defines it later.
-          s = runHandoffInternal(function () {
-            return googletag.defineSlot(
-              slot.gam_unit_path,
-              slot.formats,
-              actualDivId,
-            );
-          });
-          if (!s) {
-            releaseTrustedServerFirstImpressionClaim(el, tsClaim);
-            return;
-          }
-          s.addService(googletag.pubads());
-          tsOwned = true;
-          ts.gptSlotHandoffs = ts.gptSlotHandoffs || {};
-          ts.gptSlotHandoffs[actualDivId] = {
-            gamUnitPath: slot.gam_unit_path,
-            formats: slot.formats,
-            divIdPrefix: slot.div_id,
-            slotElementId: actualDivId,
-            publisherClaimed: false,
-            suppressPublisherDisplay: false,
-            suppressPublisherRefresh: false,
-          };
-        }
-
-        var targeting = bootstrapTargeting(slot, b);
-        Object.entries(targeting).forEach(function (entry) {
-          s.setTargeting(entry[0], entry[1]);
-        });
-        tsClaim.targeting = targeting;
-        // Map the resolved inner div to the slot ID. This bootstrap fires no
-        // beacons and registers no slotRenderEnded listener; the map is consumed
-        // by the bundle's render bridge (index.ts) once it loads.
-        divToSlotId[actualDivId] = slot.id;
-        var slotElementId = s.getSlotElementId();
-        var targetingKeys = Object.keys(slot.targeting || {});
-        nextSlotTargetingKeys[actualDivId] = targetingKeys;
-        if (slotElementId && slotElementId !== actualDivId) {
-          divToSlotId[slotElementId] = slot.id;
-          nextSlotTargetingKeys[slotElementId] = targetingKeys;
-        }
-        if (tsOwned) {
-          newSlots.push(s);
-          var displayId = s.getSlotElementId() || actualDivId;
-          slotsToDisplay.push(displayId);
-        } else {
-          slotsToRefresh.push(s);
-        }
-      });
-      ts.prevGptSlots = newSlots;
-      ts.divToSlotId = divToSlotId;
-      ts.prevSlotTargetingKeys = nextSlotTargetingKeys;
-      var hasRenderableWork =
-        slotsToDisplay.length > 0 || slotsToRefresh.length > 0;
-      if (!ts.servicesEnabled && hasRenderableWork) {
-        googletag.pubads().enableSingleRequest();
-        googletag.enableServices();
-        ts.servicesEnabled = true;
-      }
-      // Register and render TS-defined slots. GPT requires display() for a
-      // freshly-defined slot; without it the slot no-ops and misses its
-      // impression. Runs after enableServices(); on SPA navigation services are
-      // already enabled, so this runs unconditionally for new slots.
-      slotsToDisplay.forEach(function (divId) {
-        runHandoffInternal(function () {
-          googletag.display(divId);
-        });
-      });
-      syncInitialLoadDisabled(window.googletag);
-
-      // Reused publisher-owned slots always need a refresh to pick up the
-      // server-side targeting. TS-defined slots are fetched by display() above
-      // unless the publisher disabled initial load, in which case display() only
-      // registers them and refresh() must request the ad — otherwise they render
-      // blank. Only add them in that case to avoid double-requesting.
-      var slotsNeedingRefresh = ts.gptInitialLoadDisabled
-        ? slotsToRefresh.concat(newSlots)
-        : slotsToRefresh;
-
-      if (slotsNeedingRefresh.length > 0) {
-        // One-shot bypass: this internal refresh delivers the just-applied
-        // server-side targeting to GAM. If slim-Prebid has already wrapped
-        // refresh(), it must pass this call straight through — not clear the
-        // targeting and run a duplicate client-side auction. Mirrors the
-        // bundle's adInit() in crates/trusted-server-js/lib/src/integrations/gpt/index.ts.
-        ts.adInitRefreshInProgress = true;
-        try {
-          runHandoffInternal(function () {
-            googletag.pubads().refresh(slotsNeedingRefresh);
-          });
-        } finally {
-          ts.adInitRefreshInProgress = false;
-        }
-      }
-    });
-  };
-})();
diff --git a/crates/trusted-server-core/src/integrations/gpt_diagnostics.rs b/crates/trusted-server-core/src/integrations/gpt_diagnostics.rs
index 01b444ef9..98ac2b4c8 100644
--- a/crates/trusted-server-core/src/integrations/gpt_diagnostics.rs
+++ b/crates/trusted-server-core/src/integrations/gpt_diagnostics.rs
@@ -1,9 +1,9 @@
 //! Query-activated, browser-session GPT runtime diagnostics integration.
 //!
-//! Deployment configuration makes the standalone browser module available.
-//! Exact `ts_console` directives establish or clear a host-only session cookie;
-//! active documents load the module synchronously without adding diagnostics to
-//! the ordinary unified bundle.
+//! Exact `ts_console` directives establish or clear a host-only session cookie.
+//! Active documents select `gpt_diagnostics` as a takeover member of the unified
+//! TSJS manifest, whose runtime owns diagnostics fact capture and delivery. No
+//! standalone diagnostics browser module or script tag is emitted.
 
 use error_stack::{Report, ResultExt};
 use http::{HeaderValue, Method, Request, Response, Uri, header, uri::PathAndQuery};
@@ -16,7 +16,6 @@ use crate::error::TrustedServerError;
 use crate::http_util::is_navigation_request;
 use crate::response_privacy::enforce_synthesized_html_cache_privacy;
 use crate::settings::{IntegrationConfig, Settings};
-use crate::tsjs;
 
 use super::IntegrationRegistration;
 
@@ -26,7 +25,6 @@ pub const GPT_DIAGNOSTICS_INTEGRATION_ID: &str = "gpt_diagnostics";
 pub const GPT_DIAGNOSTICS_QUERY: &str = "ts_console";
 /// Host-only browser-session activation cookie.
 pub const GPT_DIAGNOSTICS_COOKIE: &str = "__Host-ts-console";
-
 const SET_CONSOLE_COOKIE: &str = "__Host-ts-console=1; Path=/; Secure; HttpOnly; SameSite=Lax";
 const CLEAR_CONSOLE_COOKIE: &str =
     "__Host-ts-console=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0";
@@ -35,7 +33,7 @@ const CLEAR_CONSOLE_COOKIE: &str =
 #[derive(Debug, Clone, Deserialize, Validate)]
 #[serde(deny_unknown_fields)]
 pub struct GptDiagnosticsConfig {
-    /// Whether the GPT diagnostics browser module is available.
+    /// Whether requests may activate the unified GPT diagnostics runtime.
     #[serde(default)]
     pub enabled: bool,
 }
@@ -62,6 +60,7 @@ pub enum GptDiagnosticsCookieAction {
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct GptDiagnosticsRequestDecision {
     active: bool,
+    reserved_directive: bool,
     clean_browser_path_and_query: Option<String>,
     cookie_action: GptDiagnosticsCookieAction,
 }
@@ -73,57 +72,46 @@ impl GptDiagnosticsRequestDecision {
         self.active
     }
 
+    /// Serialize the exact `DiagnosticsBootV1.gpt` value for the boot emitter.
+    #[must_use]
+    pub fn boot_config_json(&self) -> &'static str {
+        if self.active {
+            r#"{"active":true}"#
+        } else {
+            r#"{"active":false}"#
+        }
+    }
+
     /// Whether the response must be private and non-storeable.
     #[must_use]
     pub fn requires_private_no_store(&self) -> bool {
         self.active
             || self.cookie_action != GptDiagnosticsCookieAction::None
+            || self.reserved_directive
             || self.clean_browser_path_and_query.is_some()
     }
 
-    /// Build the early activation/URL-cleanup bootstrap for an HTML document.
+    /// Build the one-time inline URL-cleanup tag after reserved input was consumed.
     #[must_use]
-    pub fn bootstrap_script(&self) -> Option<String> {
-        if !self.active && self.clean_browser_path_and_query.is_none() {
-            return None;
-        }
-
-        let mut script = String::from("<script>");
-        if self.active {
-            script.push_str("window.__tsjs_gpt_diagnostics_active=true;");
-        }
-        if let Some(clean_path) = &self.clean_browser_path_and_query {
-            let encoded = serde_json::to_string(clean_path).ok()?;
-            script.push_str("history.replaceState(history.state,'',");
-            script.push_str(&encoded);
-            script.push_str("+location.hash);");
-        }
-        script.push_str("</script>");
-        Some(script)
-    }
-
-    /// Build the synchronous standalone diagnostics module tag.
-    #[must_use]
-    pub fn module_script_tag(&self) -> Option<String> {
-        self.active.then(|| {
-            format!(
-                "<script src=\"{}\"></script>",
-                tsjs::tsjs_single_module_script_src(GPT_DIAGNOSTICS_INTEGRATION_ID)
-            )
-        })
-    }
-    /// An active decision, for tests in other modules that need one.
-    ///
-    /// The fields are private and built by `prepare_request` from a cookie or query
-    /// parameter; there is no other way to obtain an active decision across a module
-    /// boundary.
-    #[cfg(test)]
-    pub(crate) fn active_for_tests() -> Self {
-        Self {
-            active: true,
-            clean_browser_path_and_query: None,
-            cookie_action: GptDiagnosticsCookieAction::None,
-        }
+    pub fn url_cleanup_script_tag(&self, csp_nonce: Option<&str>) -> Option<String> {
+        let clean_path = serde_json::to_string(self.clean_browser_path_and_query.as_ref()?).ok()?;
+        let nonce_attribute = match csp_nonce {
+            Some(nonce)
+                if !nonce.is_empty()
+                    && nonce.len() <= 256
+                    && nonce.bytes().all(|byte| {
+                        byte.is_ascii_alphanumeric()
+                            || matches!(byte, b'+' | b'/' | b'_' | b'-' | b'=')
+                    }) =>
+            {
+                format!(r#" nonce="{nonce}""#)
+            }
+            Some(_) => return None,
+            None => String::new(),
+        };
+        Some(format!(
+            "<script{nonce_attribute}>try{{history.replaceState(history.state,'',{clean_path}+location.hash)}}catch(_error){{}}</script>"
+        ))
     }
 }
 
@@ -141,11 +129,14 @@ mod head_seam_invariant_tests {
                     GptDiagnosticsCookieAction::SetSession,
                     GptDiagnosticsCookieAction::ClearSession,
                 ] {
-                    out.push(GptDiagnosticsRequestDecision {
-                        active,
-                        clean_browser_path_and_query: clean.clone(),
-                        cookie_action,
-                    });
+                    for reserved_directive in [false, true] {
+                        out.push(GptDiagnosticsRequestDecision {
+                            active,
+                            clean_browser_path_and_query: clean.clone(),
+                            cookie_action,
+                            reserved_directive,
+                        });
+                    }
                 }
             }
         }
@@ -163,8 +154,7 @@ mod head_seam_invariant_tests {
         // If a future change makes a script emit without also requiring the stamp,
         // this fails here rather than silently in a cached template.
         for decision in all_decisions() {
-            let injects =
-                decision.bootstrap_script().is_some() || decision.module_script_tag().is_some();
+            let injects = decision.url_cleanup_script_tag(None).is_some();
             if injects {
                 assert!(
                     decision.requires_private_no_store(),
@@ -178,16 +168,7 @@ mod head_seam_invariant_tests {
     #[test]
     fn a_default_decision_injects_nothing() {
         let decision = GptDiagnosticsRequestDecision::default();
-        assert_eq!(
-            decision.bootstrap_script(),
-            None,
-            "should not inject a bootstrap for an inert decision"
-        );
-        assert_eq!(
-            decision.module_script_tag(),
-            None,
-            "should not inject a module for an inert decision"
-        );
+        assert_eq!(decision.url_cleanup_script_tag(None), None);
         assert!(
             !decision.requires_private_no_store(),
             "an inert decision should not force the response private"
@@ -279,9 +260,13 @@ pub fn prepare_request(
         replace_path_and_query(request, &clean_path)?;
     }
 
-    let mut decision = GptDiagnosticsRequestDecision::default();
+    let mut decision = GptDiagnosticsRequestDecision {
+        reserved_directive: had_reserved_query,
+        clean_browser_path_and_query: (eligible_navigation && had_reserved_query)
+            .then_some(clean_path),
+        ..GptDiagnosticsRequestDecision::default()
+    };
     if integration_enabled && eligible_navigation && had_reserved_query {
-        decision.clean_browser_path_and_query = Some(clean_path);
         match directive {
             QueryDirective::Enable => {
                 decision.active = true;
@@ -320,6 +305,7 @@ pub fn finalize_response(
     decision: &GptDiagnosticsRequestDecision,
     response: &mut Response<EdgeBody>,
 ) {
+    sanitize_console_set_cookie(response);
     let cookie = match decision.cookie_action {
         GptDiagnosticsCookieAction::None => None,
         GptDiagnosticsCookieAction::SetSession => {
@@ -379,9 +365,9 @@ fn console_cookie_state(request: &Request<EdgeBody>) -> ConsoleCookieState {
         for cookie in value.split(';') {
             let cookie = cookie.trim();
             match cookie.split_once('=') {
-                Some((name, value)) if name.trim() == GPT_DIAGNOSTICS_COOKIE => {
+                Some((name, value)) if name == GPT_DIAGNOSTICS_COOKIE => {
                     state.occurrences += 1;
-                    state.canonical |= value.trim() == "1";
+                    state.canonical |= value == "1";
                 }
                 None if cookie == GPT_DIAGNOSTICS_COOKIE => state.occurrences += 1,
                 _ => {}
@@ -391,6 +377,33 @@ fn console_cookie_state(request: &Request<EdgeBody>) -> ConsoleCookieState {
     state
 }
 
+fn sanitize_console_set_cookie(response: &mut Response<EdgeBody>) {
+    let retained = response
+        .headers()
+        .get_all(header::SET_COOKIE)
+        .iter()
+        .filter(|value| {
+            let pair = value
+                .as_bytes()
+                .split(|byte| *byte == b';')
+                .next()
+                .unwrap_or_default();
+            let name = pair
+                .split(|byte| *byte == b'=')
+                .next()
+                .unwrap_or_default()
+                .trim_ascii();
+            name != GPT_DIAGNOSTICS_COOKIE.as_bytes()
+        })
+        .cloned()
+        .collect::<Vec<_>>();
+
+    response.headers_mut().remove(header::SET_COOKIE);
+    for value in retained {
+        response.headers_mut().append(header::SET_COOKIE, value);
+    }
+}
+
 fn sanitize_console_cookie(request: &mut Request<EdgeBody>) {
     let retained = request
         .headers()
@@ -466,13 +479,8 @@ mod tests {
     }
 
     #[test]
-    fn register_excludes_diagnostics_from_unified_and_deferred_bundles() {
-        let settings = settings(true);
-        let plan = std::sync::Arc::new(
-            crate::auction::compile_auction_plan(&settings).expect("should compile auction plan"),
-        );
-        let registry =
-            IntegrationRegistry::with_plan(&settings, plan).expect("should build registry");
+    fn ts_console_register_defers_browser_delivery_to_the_unified_takeover_catalog() {
+        let registry = IntegrationRegistry::new(&settings(true)).expect("should build registry");
 
         assert!(registry.integration_enabled(GPT_DIAGNOSTICS_INTEGRATION_ID));
         assert!(
@@ -488,7 +496,7 @@ mod tests {
     }
 
     #[test]
-    fn exact_directive_activates_cleans_and_strips_cookie() {
+    fn ts_console_exact_directive_activates_cleans_and_strips_cookie() {
         let mut request = navigation(
             "https://publisher.example/page?keep=%2F&ts_console=true#fragment",
             Some("other=value; __Host-ts-console=1"),
@@ -506,13 +514,28 @@ mod tests {
             "https://publisher.example/page?keep=%2F"
         );
         assert_eq!(request.headers()[header::COOKIE], "other=value");
-        let bootstrap = decision.bootstrap_script().expect("should bootstrap");
-        assert!(bootstrap.contains("__tsjs_gpt_diagnostics_active=true"));
-        assert!(bootstrap.contains("/page?keep=%2F"));
+        assert_eq!(decision.boot_config_json(), r#"{"active":true}"#);
+        let cleanup = decision
+            .url_cleanup_script_tag(None)
+            .expect("a server-consumed directive should authorize inline cleanup");
+        assert!(cleanup.starts_with("<script>"));
+        assert!(cleanup.ends_with("</script>"));
+        assert!(cleanup.contains("history.replaceState"));
+        assert!(!cleanup.contains(" src="));
+
+        let cleanup = decision
+            .url_cleanup_script_tag(Some("response-nonce_123="))
+            .expect("a valid response nonce should authorize inline cleanup");
+        assert!(cleanup.starts_with(r#"<script nonce="response-nonce_123=">"#));
+        assert_eq!(
+            decision.url_cleanup_script_tag(Some(r#"bad\" nonce"#)),
+            None,
+            "untrusted nonce text must never reach HTML"
+        );
     }
 
     #[test]
-    fn prefetch_directive_is_sanitized_without_activating_session() {
+    fn ts_console_prefetch_directive_is_sanitized_without_activating_session() {
         let mut request = navigation("https://publisher.example/page?ts_console=1&keep=1", None);
         request
             .headers_mut()
@@ -529,13 +552,14 @@ mod tests {
     }
 
     #[test]
-    fn active_cookie_enables_clean_navigation_but_duplicates_fail_closed() {
+    fn ts_console_active_cookie_enables_clean_navigation_but_duplicates_fail_closed() {
         let mut active = navigation(
             "https://publisher.example/page",
             Some("__Host-ts-console=1; other=value"),
         );
         let decision = prepare_request(&settings(true), &mut active).expect("should prepare");
         assert!(decision.active());
+        assert_eq!(decision.url_cleanup_script_tag(None), None);
         assert_eq!(active.headers()[header::COOKIE], "other=value");
 
         let mut duplicate = navigation(
@@ -545,10 +569,17 @@ mod tests {
         let decision = prepare_request(&settings(true), &mut duplicate).expect("should prepare");
         assert!(!decision.active());
         assert_eq!(duplicate.headers()[header::COOKIE], "other=value");
+
+        for noncanonical in ["__Host-ts-console =1", "__Host-ts-console= 1"] {
+            let mut request = navigation("https://publisher.example/page", Some(noncanonical));
+            let decision = prepare_request(&settings(true), &mut request).expect("should prepare");
+            assert!(!decision.active(), "{noncanonical} must fail closed");
+            assert!(!request.headers().contains_key(header::COOKIE));
+        }
     }
 
     #[test]
-    fn invalid_duplicate_and_disable_directives_fail_closed() {
+    fn ts_console_invalid_duplicate_and_disable_directives_fail_closed() {
         for query in [
             "ts_console=True",
             "ts_console=",
@@ -577,7 +608,47 @@ mod tests {
     }
 
     #[test]
-    fn finalization_sets_cookie_and_strips_shared_cache_headers() {
+    fn ts_console_invalid_directive_is_private_without_mutating_the_session() {
+        let mut request = navigation(
+            "https://publisher.example/page?keep=1&ts_console=True",
+            Some("__Host-ts-console=1"),
+        );
+        let decision = prepare_request(&settings(true), &mut request).expect("should prepare");
+        let mut response = Response::builder()
+            .header(header::CACHE_CONTROL, "public, max-age=60")
+            .body(EdgeBody::empty())
+            .expect("should build response");
+
+        finalize_response(&decision, &mut response);
+
+        assert!(!decision.active());
+        assert_eq!(request.uri().query(), Some("keep=1"));
+        assert!(!response.headers().contains_key(header::SET_COOKIE));
+        assert_eq!(
+            response.headers()[header::CACHE_CONTROL],
+            "private, no-store"
+        );
+    }
+
+    #[test]
+    fn ts_console_is_disabled_by_default_while_reserved_input_is_still_sanitized() {
+        let mut request = navigation(
+            "https://publisher.example/page?keep=1&ts_console=1",
+            Some("__Host-ts-console=1; other=value"),
+        );
+
+        let decision = prepare_request(&settings(false), &mut request).expect("should prepare");
+
+        assert!(!decision.active());
+        assert_eq!(decision.boot_config_json(), r#"{"active":false}"#);
+        assert_eq!(decision.cookie_action, GptDiagnosticsCookieAction::None);
+        assert_eq!(request.uri().query(), Some("keep=1"));
+        assert_eq!(request.headers()[header::COOKIE], "other=value");
+        assert!(decision.requires_private_no_store());
+    }
+
+    #[test]
+    fn ts_console_finalization_sets_cookie_and_strips_shared_cache_headers() {
         let mut request = navigation("https://publisher.example/?ts_console=1", None);
         let decision = prepare_request(&settings(true), &mut request).expect("should prepare");
         let mut response = Response::builder()
@@ -587,6 +658,11 @@ mod tests {
             .header("surrogate-control", "max-age=60")
             .header("fastly-surrogate-control", "max-age=60")
             .header("cloudflare-cdn-cache-control", "public, max-age=60")
+            .header(header::SET_COOKIE, "publisher=value; Path=/")
+            .header(
+                header::SET_COOKIE,
+                "__Host-ts-console=origin; Path=/; Secure",
+            )
             .body(EdgeBody::empty())
             .expect("should build response");
 
@@ -597,7 +673,13 @@ mod tests {
             "private, no-store",
             "should stamp diagnostics responses non-storable"
         );
-        assert_eq!(response.headers()[header::SET_COOKIE], SET_CONSOLE_COOKIE);
+        let cookies = response
+            .headers()
+            .get_all(header::SET_COOKIE)
+            .iter()
+            .map(|value| value.to_str().expect("should emit valid cookie text"))
+            .collect::<Vec<_>>();
+        assert_eq!(cookies, vec!["publisher=value; Path=/", SET_CONSOLE_COOKIE]);
         assert!(!response.headers().contains_key("surrogate-control"));
         assert!(!response.headers().contains_key("fastly-surrogate-control"));
         assert!(
@@ -676,7 +758,51 @@ mod tests {
     }
 
     #[test]
-    fn config_rejects_unknown_fields() {
+    fn ts_console_only_eligible_get_document_navigations_activate() {
+        for (method, destination) in [(Method::POST, "document"), (Method::GET, "script")] {
+            let mut request = Request::builder()
+                .method(method.clone())
+                .uri("https://publisher.example/page?keep=1&ts_console=1")
+                .header("sec-fetch-dest", destination)
+                .header(header::COOKIE, "__Host-ts-console=1; other=value")
+                .body(EdgeBody::empty())
+                .expect("should build ineligible request");
+
+            let decision = prepare_request(&settings(true), &mut request)
+                .expect("should sanitize ineligible request");
+
+            assert!(
+                !decision.active(),
+                "{method} {destination} must not activate"
+            );
+            assert_eq!(decision.cookie_action, GptDiagnosticsCookieAction::None);
+            assert_eq!(request.uri().query(), Some("keep=1"));
+            assert_eq!(request.headers()[header::COOKIE], "other=value");
+        }
+    }
+
+    #[test]
+    fn ts_console_disable_emits_the_exact_session_cookie_clear() {
+        let mut request = navigation(
+            "https://publisher.example/page?ts_console=0&keep=1",
+            Some("__Host-ts-console=1"),
+        );
+        let decision = prepare_request(&settings(true), &mut request).expect("should prepare");
+        let mut response = Response::new(EdgeBody::empty());
+
+        finalize_response(&decision, &mut response);
+
+        assert!(!decision.active());
+        assert_eq!(request.uri().query(), Some("keep=1"));
+        assert_eq!(response.headers()[header::SET_COOKIE], CLEAR_CONSOLE_COOKIE);
+        assert_eq!(
+            response.headers()[header::CACHE_CONTROL],
+            "private, no-store"
+        );
+    }
+
+    #[test]
+    fn ts_console_config_rejects_unknown_fields() {
         let mut settings = create_test_settings();
         settings
             .integrations
diff --git a/crates/trusted-server-core/src/integrations/gpt_diagnostics_bootstrap.js b/crates/trusted-server-core/src/integrations/gpt_diagnostics_bootstrap.js
new file mode 100644
index 000000000..3cbb36163
--- /dev/null
+++ b/crates/trusted-server-core/src/integrations/gpt_diagnostics_bootstrap.js
@@ -0,0 +1,36 @@
+// Request-scoped URL cleanup only. The server injects this asset exactly when
+// it has already consumed and stripped at least one reserved directive.
+(function () {
+    "use strict";
+
+    try {
+        var href = String(location.href);
+        var hashIndex = href.indexOf("#");
+        var hash = hashIndex < 0 ? "" : href.slice(hashIndex);
+        var beforeHash = hashIndex < 0 ? href : href.slice(0, hashIndex);
+        var queryIndex = beforeHash.indexOf("?");
+        if (queryIndex < 0) return;
+
+        var pairs = beforeHash.slice(queryIndex + 1).split("&");
+        var retained = [];
+        var removed = false;
+        for (var index = 0; index < pairs.length; index += 1) {
+            var pair = pairs[index];
+            var equalsIndex = pair.indexOf("=");
+            var name = equalsIndex < 0 ? pair : pair.slice(0, equalsIndex);
+            if (name === "ts_console") {
+                removed = true;
+            } else {
+                retained.push(pair);
+            }
+        }
+        if (!removed) return;
+
+        var cleanHref = beforeHash.slice(0, queryIndex);
+        var retainedQuery = retained.join("&");
+        if (retainedQuery !== "") cleanHref += "?" + retainedQuery;
+        history.replaceState(history.state, "", cleanHref + hash);
+    } catch (_) {
+        // Browser-visible cleanup cannot affect diagnostics or publisher code.
+    }
+})();
diff --git a/crates/trusted-server-core/src/integrations/lockr.rs b/crates/trusted-server-core/src/integrations/lockr.rs
index 1f4f04b73..998b83b3b 100644
--- a/crates/trusted-server-core/src/integrations/lockr.rs
+++ b/crates/trusted-server-core/src/integrations/lockr.rs
@@ -340,6 +340,7 @@ pub fn register(
         IntegrationRegistration::builder(LOCKR_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration)
+            .with_empty_browser_config_v1()?
             .build(),
     ))
 }
diff --git a/crates/trusted-server-core/src/integrations/mod.rs b/crates/trusted-server-core/src/integrations/mod.rs
index 742960970..8939dcb85 100644
--- a/crates/trusted-server-core/src/integrations/mod.rs
+++ b/crates/trusted-server-core/src/integrations/mod.rs
@@ -27,6 +27,7 @@ mod registry;
 pub mod sourcepoint;
 pub mod testlight;
 
+pub(crate) use registry::html_script_nonce_attribute;
 pub use registry::{
     AttributeRewriteAction, AttributeRewriteOutcome, HeaderMutation, HeaderMutationMode,
     IntegrationAttributeContext, IntegrationAttributeRewriter, IntegrationDocumentState,
@@ -35,7 +36,7 @@ pub use registry::{
     IntegrationRegistrationBuilder, IntegrationRegistry, IntegrationRequestFilter,
     IntegrationScriptContext, IntegrationScriptRewriter, ProxyDispatchInput, RequestFilterDecision,
     RequestFilterEffects, RequestFilterInput, RequestFilterRegistryInput,
-    RequestFilterRegistryOutcome, ScriptRewriteAction,
+    RequestFilterRegistryOutcome, ScriptRewriteAction, TsjsCatalogSelectionV1,
 };
 
 /// Registers or retrieves a platform backend for the given URL.
@@ -99,6 +100,31 @@ pub(crate) fn ensure_integration_backend_with_timeout(
         })
 }
 
+/// Registers or retrieves a platform backend with separate response-header and
+/// response-body gap timeouts.
+///
+/// # Errors
+///
+/// Returns an error when `url` cannot be parsed, is missing a host, or the
+/// backend registration fails.
+pub(crate) fn ensure_integration_backend_with_transport_timeouts(
+    services: &RuntimeServices,
+    url: &str,
+    integration: &'static str,
+    first_byte_timeout: Duration,
+    between_bytes_timeout: Duration,
+) -> Result<String, Report<TrustedServerError>> {
+    let mut spec = integration_backend_spec(url, integration, true, first_byte_timeout)?;
+    spec.between_bytes_timeout = between_bytes_timeout;
+    services
+        .backend()
+        .ensure(&spec)
+        .change_context(TrustedServerError::Integration {
+            integration: integration.to_string(),
+            message: "Failed to register backend".to_string(),
+        })
+}
+
 /// Compute the deterministic platform backend name for a URL without registering it.
 ///
 /// Parses `url`, builds a [`PlatformBackendSpec`], and delegates to
diff --git a/crates/trusted-server-core/src/integrations/osano.rs b/crates/trusted-server-core/src/integrations/osano.rs
index 9fc3aa66c..659df043e 100644
--- a/crates/trusted-server-core/src/integrations/osano.rs
+++ b/crates/trusted-server-core/src/integrations/osano.rs
@@ -45,7 +45,9 @@ pub fn register(
     };
 
     Ok(Some(
-        IntegrationRegistration::builder(OSANO_INTEGRATION_ID).build(),
+        IntegrationRegistration::builder(OSANO_INTEGRATION_ID)
+            .with_empty_browser_config_v1()?
+            .build(),
     ))
 }
 
diff --git a/crates/trusted-server-core/src/integrations/permutive.rs b/crates/trusted-server-core/src/integrations/permutive.rs
index aa684c620..b789b56e9 100644
--- a/crates/trusted-server-core/src/integrations/permutive.rs
+++ b/crates/trusted-server-core/src/integrations/permutive.rs
@@ -320,6 +320,7 @@ pub fn register(
         IntegrationRegistration::builder(PERMUTIVE_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration)
+            .with_empty_browser_config_v1()?
             .build(),
     ))
 }
diff --git a/crates/trusted-server-core/src/integrations/prebid.rs b/crates/trusted-server-core/src/integrations/prebid.rs
index 31b265cae..c09129e64 100644
--- a/crates/trusted-server-core/src/integrations/prebid.rs
+++ b/crates/trusted-server-core/src/integrations/prebid.rs
@@ -41,6 +41,7 @@ use crate::integrations::{
     AttributeRewriteAction, IntegrationAttributeContext, IntegrationAttributeRewriter,
     IntegrationEndpoint, IntegrationHeadInjector, IntegrationHtmlContext, IntegrationProxy,
     IntegrationRegistration, UPSTREAM_RTB_MAX_RESPONSE_BYTES, collect_response_bounded,
+    html_script_nonce_attribute,
 };
 #[cfg(test)]
 use crate::integrations::{
@@ -225,9 +226,8 @@ pub struct LegacyPrebidServerConfig {
     pub enabled: bool,
     #[validate(url)]
     pub server_url: String,
-    /// Prebid Server account ID, injected into the client-side bundle via
-    /// `window.__tsjs_prebid.accountId` so publishers don't need to configure
-    /// it in JavaScript.
+    /// Prebid Server account ID delivered through the release-bound immutable
+    /// integration configuration so publishers do not configure it in JavaScript.
     #[serde(default)]
     pub account_id: Option<String>,
     #[serde(default = "default_timeout_ms")]
@@ -463,6 +463,19 @@ impl From<&LegacyPrebidServerConfig> for PrebidIntegrationConfig {
     }
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PrebidBrowserConfigV1 {
+    account_id: String,
+    timeout: u32,
+    debug: bool,
+    bidders: Vec<String>,
+    #[serde(skip_serializing_if = "<[String]>::is_empty")]
+    client_side_bidders: Vec<String>,
+    #[serde(skip_serializing_if = "<[String]>::is_empty")]
+    excluded_gam_ad_unit_path_suffixes: Vec<String>,
+}
+
 #[cfg(test)]
 fn remove_aps_bidders(config: &mut LegacyPrebidServerConfig) {
     for (field, bidders) in [
@@ -826,7 +839,6 @@ fn validate_external_bundle_config(
 
 pub struct PrebidIntegration {
     config: PrebidIntegrationConfig,
-    planned_head_inserts: Option<Vec<String>>,
     #[cfg(test)]
     legacy_config: Option<LegacyPrebidServerConfig>,
     #[cfg(test)]
@@ -839,7 +851,6 @@ impl PrebidIntegration {
         let engine = Arc::new(BidParamOverrideEngine::try_from_config(&config)?);
         Ok(Arc::new(Self {
             config: PrebidIntegrationConfig::from(&config),
-            planned_head_inserts: None,
             legacy_config: Some(config),
             engine,
         }))
@@ -850,17 +861,28 @@ impl PrebidIntegration {
         Self::try_new(config).expect("should compile prebid bid param overrides")
     }
 
-    fn for_browser_plan(config: &PrebidIntegrationConfig, plan: &AuctionPlan) -> Arc<Self> {
-        let mut integration = Self {
+    fn for_browser_plan(config: &PrebidIntegrationConfig) -> Arc<Self> {
+        Arc::new(Self {
             config: config.clone(),
-            planned_head_inserts: None,
             #[cfg(test)]
             legacy_config: None,
             #[cfg(test)]
             engine: Arc::new(BidParamOverrideEngine::default()),
-        };
-        integration.planned_head_inserts = Some(integration.head_inserts_for_plan(config, plan));
-        Arc::new(integration)
+        })
+    }
+
+    fn browser_config_v1(&self, bidders: Vec<String>) -> PrebidBrowserConfigV1 {
+        PrebidBrowserConfigV1 {
+            account_id: self.config.account_id.clone().unwrap_or_default(),
+            timeout: self.config.timeout_ms,
+            debug: self.config.debug,
+            bidders,
+            client_side_bidders: self.config.client_side_bidders.clone(),
+            excluded_gam_ad_unit_path_suffixes: self
+                .config
+                .excluded_gam_ad_unit_path_suffixes
+                .clone(),
+        }
     }
 
     #[cfg(test)]
@@ -957,55 +979,14 @@ impl PrebidIntegration {
         Ok(response)
     }
 
-    fn external_bundle_script_tag(&self) -> String {
+    fn external_bundle_script_tag(&self, csp_nonce: Option<&str>) -> String {
         external_bundle_script_tag(
             self.config.external_bundle_sha256.as_deref(),
             self.config.external_bundle_sri.as_deref(),
+            csp_nonce,
         )
     }
 
-    /// Build the prepared browser injection from browser settings and validated routes.
-    pub(crate) fn head_inserts_for_plan(
-        &self,
-        browser_config: &PrebidIntegrationConfig,
-        plan: &AuctionPlan,
-    ) -> Vec<String> {
-        #[derive(Serialize)]
-        #[serde(rename_all = "camelCase")]
-        struct InjectedBrowserConfig<'a> {
-            account_id: &'a str,
-            timeout: u32,
-            debug: bool,
-            server_side_bidders: Vec<&'a str>,
-            #[serde(skip_serializing_if = "<[String]>::is_empty")]
-            client_side_bidders: &'a [String],
-            #[serde(skip_serializing_if = "<[String]>::is_empty")]
-            excluded_gam_ad_unit_path_suffixes: &'a [String],
-        }
-
-        let payload = InjectedBrowserConfig {
-            account_id: browser_config.account_id.as_deref().unwrap_or_default(),
-            timeout: browser_config.timeout_ms,
-            debug: browser_config.debug,
-            server_side_bidders: if plan.enabled() {
-                plan.browser_bidder_codes().collect()
-            } else {
-                Vec::new()
-            },
-            client_side_bidders: &browser_config.client_side_bidders,
-            excluded_gam_ad_unit_path_suffixes: &browser_config.excluded_gam_ad_unit_path_suffixes,
-        };
-        let config_json = serialize_injected_prebid_config(&payload);
-
-        vec![
-            injected_prebid_config_script(&config_json),
-            external_bundle_script_tag(
-                browser_config.external_bundle_sha256.as_deref(),
-                browser_config.external_bundle_sri.as_deref(),
-            ),
-        ]
-    }
-
     fn is_managed_external(&self) -> bool {
         self.config.external_bundle_url.is_some()
     }
@@ -1179,13 +1160,18 @@ fn external_bundle_script_src(sha256: Option<&str>) -> String {
     }
 }
 
-fn external_bundle_script_tag(sha256: Option<&str>, sri: Option<&str>) -> String {
+fn external_bundle_script_tag(
+    sha256: Option<&str>,
+    sri: Option<&str>,
+    csp_nonce: Option<&str>,
+) -> String {
     let src = external_bundle_script_src(sha256);
+    let nonce_attribute = html_script_nonce_attribute(csp_nonce).unwrap_or_default();
     let integrity = sri
         .map(|value| format!(" integrity=\"{}\"", escape_html_attr(value)))
         .unwrap_or_default();
 
-    format!("<script src=\"{src}\"{integrity} defer></script>")
+    format!("<script{nonce_attribute} src=\"{src}\"{integrity} defer></script>")
 }
 
 #[cfg(test)]
@@ -1238,13 +1224,19 @@ pub fn register_for_plan(
     config.excluded_gam_ad_unit_path_suffixes = canonical;
     validate_browser_config_for_startup(&config, &settings.proxy.allowed_domains)?;
     validate_browser_bidder_ownership(&config, plan)?;
-    let integration = PrebidIntegration::for_browser_plan(&config, plan);
+    let integration = PrebidIntegration::for_browser_plan(&config);
+    let browser_config = integration.browser_config_v1(if plan.enabled() {
+        plan.browser_bidder_codes().map(str::to_string).collect()
+    } else {
+        Vec::new()
+    });
     Ok(Some(
         IntegrationRegistration::builder(PREBID_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
             .with_head_injector(integration)
             .with_deferred_js()
+            .with_browser_config_v1(&browser_config)?
             .build(),
     ))
 }
@@ -1258,12 +1250,20 @@ pub fn register(
         return Ok(None);
     };
 
+    let legacy_config = integration.legacy_config.as_ref().ok_or_else(|| {
+        Report::new(TrustedServerError::Prebid {
+            message: "legacy test registration requires legacy config".to_string(),
+        })
+    })?;
+    let browser_config = integration.browser_config_v1(legacy_config.bidders.clone());
+
     Ok(Some(
         IntegrationRegistration::builder(PREBID_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
-            .with_head_injector(integration)
+            .with_head_injector(integration.clone())
             .with_deferred_js()
+            .with_browser_config_v1(&browser_config)?
             .build(),
     ))
 }
@@ -1340,70 +1340,13 @@ impl IntegrationAttributeRewriter for PrebidIntegration {
     }
 }
 
-fn serialize_injected_prebid_config(payload: &impl Serialize) -> String {
-    // Escape `</` to prevent breaking out of the script tag.
-    serde_json::to_string(payload)
-        .unwrap_or_else(|error| {
-            log::warn!("Prebid: failed to serialize client config: {error}");
-            "{}".to_string()
-        })
-        .replace("</", "<\\/")
-}
-
-fn injected_prebid_config_script(config_json: &str) -> String {
-    format!(
-        r#"<script>window.pbjs=window.pbjs||{{}};window.pbjs.que=window.pbjs.que||[];window.pbjs.cmd=window.pbjs.cmd||[];window.__tsjs_prebid={config_json};</script>"#
-    )
-}
-
 impl IntegrationHeadInjector for PrebidIntegration {
     fn integration_id(&self) -> &'static str {
         PREBID_INTEGRATION_ID
     }
 
-    fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        if let Some(inserts) = &self.planned_head_inserts {
-            return inserts.clone();
-        }
-        #[derive(Serialize)]
-        #[serde(rename_all = "camelCase")]
-        struct InjectedPrebidClientConfig<'a> {
-            account_id: &'a str,
-            timeout: u32,
-            debug: bool,
-            bidders: &'a [String],
-            #[serde(skip_serializing_if = "<[String]>::is_empty")]
-            client_side_bidders: &'a [String],
-            #[serde(skip_serializing_if = "<[String]>::is_empty")]
-            excluded_gam_ad_unit_path_suffixes: &'a [String],
-        }
-
-        let payload = InjectedPrebidClientConfig {
-            account_id: self.config.account_id.as_deref().unwrap_or_default(),
-            timeout: self.config.timeout_ms,
-            debug: self.config.debug,
-            bidders: {
-                #[cfg(test)]
-                {
-                    self.legacy_config
-                        .as_ref()
-                        .map_or(&[][..], |config| config.bidders.as_slice())
-                }
-                #[cfg(not(test))]
-                {
-                    &[]
-                }
-            },
-            client_side_bidders: &self.config.client_side_bidders,
-            excluded_gam_ad_unit_path_suffixes: &self.config.excluded_gam_ad_unit_path_suffixes,
-        };
-
-        let config_json = serialize_injected_prebid_config(&payload);
-        let mut inserts = vec![injected_prebid_config_script(&config_json)];
-
-        inserts.push(self.external_bundle_script_tag());
-
-        inserts
+    fn head_inserts(&self, ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
+        vec![self.external_bundle_script_tag(ctx.csp_nonce)]
     }
 }
 
@@ -2188,6 +2131,9 @@ fn parse_planned_prebid_bid(
 
     Ok(AuctionBid {
         slot_id,
+        candidate_id: None,
+        candidate_provider: None,
+        renderer_reservation_id: None,
         price: Some(price),
         currency: DEFAULT_CURRENCY.to_string(),
         creative,
@@ -3127,6 +3073,9 @@ impl PrebidAuctionProvider {
 
         Ok(AuctionBid {
             slot_id,
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(price), // Prebid provides decoded prices
             currency: DEFAULT_CURRENCY.to_string(),
             creative,
@@ -3420,7 +3369,7 @@ mod tests {
     };
     use crate::settings::Settings;
     use crate::streaming_processor::{Compression, PipelineConfig, StreamingPipeline};
-    use crate::test_support::tests::create_test_settings;
+    use crate::test_support::tests::{bootstrap_transport, create_test_settings};
     use base64::engine::general_purpose::STANDARD as TEST_BASE64_STANDARD;
     use bytes::Bytes;
     use http::Method;
@@ -3492,6 +3441,17 @@ mod tests {
         }
     }
 
+    fn browser_config_json(integration: &PrebidIntegration) -> String {
+        let bidders = integration
+            .legacy_config
+            .as_ref()
+            .expect("should retain legacy config for browser projection tests")
+            .bidders
+            .clone();
+        serde_json::to_string(&integration.browser_config_v1(bidders))
+            .expect("browser-safe Prebid config should serialize")
+    }
+
     struct PredictOnlyBackend;
 
     impl PlatformBackend for PredictOnlyBackend {
@@ -3847,24 +3807,14 @@ server_url = "https://prebid.example/openrtb2/auction"
             "should retain only the first declaration of each suffix"
         );
 
-        let integration = build(&settings)
-            .expect("should build Prebid integration")
-            .expect("should return enabled Prebid integration");
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-        let inserts = integration.head_inserts(&ctx);
+        let integration = PrebidIntegration::new(config);
+        let browser_config = browser_config_json(&integration);
 
         assert!(
-            inserts[0].contains(
+            browser_config.contains(
                 r#""excludedGamAdUnitPathSuffixes":["/trackingonly","/measurement-only"]"#
             ),
-            "should inject the canonical suffix list: {}",
-            inserts[0]
+            "should project the canonical suffix list: {browser_config}"
         );
     }
 
@@ -4035,15 +3985,25 @@ excluded_gam_ad_unit_path_suffixes = ["{suffix}"]
             !processed.contains("cdn.prebid.org/prebid.js"),
             "Prebid preload should be removed when auto-config is enabled"
         );
-        // Both scripts are `defer`, so they execute in document order. The
-        // bundle must run first: the shim disables the whole integration when
-        // it finds no Prebid.js API on window.pbjs.
+        // The external Prebid artifact remains distinct and precedes the one
+        // parser-time TSJS selected-runtime tag. Prebid's TS-owned adapter is included
+        // in that unified runtime artifact, never a standalone shim tag.
         let bundle_index = processed
             .find(PREBID_BUNDLE_ROUTE)
             .expect("should inject external prebid bundle route");
         let shim_index = processed
-            .find("tsjs-prebid.min.js")
-            .expect("should inject deferred tsjs prebid shim");
+            .find("id=\"trustedserver-js\"")
+            .expect("should inject one TSJS runtime tag");
+        let transport = bootstrap_transport(&processed);
+        let manifest_integrations = transport["boot"]["manifest"]["integrations"]
+            .as_array()
+            .expect("manifest integrations should be an array");
+        assert!(
+            manifest_integrations
+                .iter()
+                .any(|entry| { entry["id"] == "prebid" && entry["phase"] == "takeover" })
+        );
+        assert!(!processed.contains("tsjs-prebid.min.js"));
         assert!(
             bundle_index < shim_index,
             "external prebid bundle must execute before the deferred tsjs shim"
@@ -4757,55 +4717,36 @@ external_bundle_sri = "sha384-AAAA"
     }
 
     #[test]
-    fn head_injector_emits_config_script() {
+    fn registration_browser_projection_contains_only_client_fields() {
         let integration = PrebidIntegration::new(base_config());
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        assert_eq!(inserts.len(), 2, "should produce config and bundle inserts");
-
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            script.starts_with("<script>") && script.ends_with("</script>"),
-            "should be wrapped in script tags"
+            config.contains(r#""accountId":"test-account""#),
+            "should include accountId from config: {config}"
         );
         assert!(
-            script.contains(r#""accountId":"test-account""#),
-            "should include accountId from config: {}",
-            script
+            config.contains(r#""timeout":1000"#),
+            "should include timeout: {config}"
         );
         assert!(
-            script.contains(r#""timeout":1000"#),
-            "should include timeout: {}",
-            script
+            config.contains(r#""debug":false"#),
+            "should include debug flag: {config}"
         );
         assert!(
-            script.contains(r#""debug":false"#),
-            "should include debug flag: {}",
-            script
+            config.contains(r#""bidders":["exampleBidder"]"#),
+            "should include bidders array: {config}"
         );
         assert!(
-            script.contains(r#""bidders":["exampleBidder"]"#),
-            "should include bidders array: {}",
-            script
-        );
-        assert!(
-            !script.contains("excludedGamAdUnitPathSuffixes"),
-            "should omit empty refresh-auction exclusions: {}",
-            script
+            !config.contains("excludedGamAdUnitPathSuffixes"),
+            "should omit empty refresh-auction exclusions: {config}"
         );
+        assert!(!config.contains("server_url"));
+        assert!(!config.contains("external_bundle_url"));
     }
 
     #[test]
     #[allow(clippy::field_reassign_with_default)]
-    fn prepared_browser_injection_uses_only_plan_routes_and_browser_timeout_debug() {
-        let integration = PrebidIntegration::new(base_config());
+    fn browser_projection_uses_only_plan_routes_and_browser_timeout_debug() {
         let mut browser_config = PrebidIntegrationConfig::default();
         browser_config.account_id = Some("browser-account".to_string());
         browser_config.timeout_ms = 1750;
@@ -4859,25 +4800,38 @@ external_bundle_sri = "sha384-AAAA"
         })
         .expect("should compile plan while browser integration is not part of compilation");
 
-        let inserts = integration.head_inserts_for_plan(&browser_config, &plan);
-        let script = &inserts[0];
+        let integration = PrebidIntegration::for_browser_plan(&browser_config);
+        let product = serde_json::to_string(
+            &integration
+                .browser_config_v1(plan.browser_bidder_codes().map(str::to_string).collect()),
+        )
+        .expect("should serialize planned Prebid browser config");
 
-        assert!(script.contains(r#""timeout":1750,"debug":false"#));
+        assert!(product.contains(r#""timeout":1750,"debug":false"#));
         assert!(
-            script.contains(r#""serverSideBidders":["primaryRoute","secondaryRoute"]"#),
-            "should inject deterministic browser route codes: {script}"
+            product.contains(r#""bidders":["primaryRoute","secondaryRoute"]"#),
+            "should project deterministic browser route codes: {product}"
         );
-        assert!(!script.contains("pbs-primary"));
-        assert!(!script.contains("pbs-secondary"));
-        assert!(!script.contains("3000"));
-        assert!(!script.contains("4000"));
+        assert!(!product.contains("pbs-primary"));
+        assert!(!product.contains("pbs-secondary"));
+        assert!(!product.contains("3000"));
+        assert!(!product.contains("4000"));
 
         let disabled_plan = plan.clone().with_enabled(false);
-        let disabled_inserts = integration.head_inserts_for_plan(&browser_config, &disabled_plan);
+        let disabled_product =
+            serde_json::to_string(&integration.browser_config_v1(if disabled_plan.enabled() {
+                disabled_plan
+                    .browser_bidder_codes()
+                    .map(str::to_string)
+                    .collect()
+            } else {
+                Vec::new()
+            }))
+            .expect("should serialize disabled Prebid browser config");
         assert!(
-            disabled_inserts[0].contains(r#""serverSideBidders":[]"#),
+            disabled_product.contains(r#""bidders":[]"#),
             "auction kill switch should suppress browser server-side bidders: {}",
-            disabled_inserts[0]
+            disabled_product
         );
     }
 
@@ -4899,22 +4853,12 @@ external_bundle_sri = "sha384-AAAA"
         config.excluded_gam_ad_unit_path_suffixes =
             vec!["/trackingonly".to_string(), "/measurement-only".to_string()];
         let integration = PrebidIntegration::new(config);
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            script.contains(
+            config.contains(
                 r#""excludedGamAdUnitPathSuffixes":["/trackingonly","/measurement-only"]"#
             ),
-            "should inject refresh-auction exclusion suffixes: {}",
-            script
+            "should project refresh-auction exclusion suffixes: {config}"
         );
     }
 
@@ -4923,20 +4867,10 @@ external_bundle_sri = "sha384-AAAA"
         let mut config = base_config();
         config.account_id = None;
         let integration = PrebidIntegration::new(config);
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            script.contains(r#""accountId":"""#),
-            "should emit empty accountId when not configured: {}",
-            script
+            config.contains(r#""accountId":"""#),
+            "should emit empty accountId when not configured: {config}"
         );
     }
 
@@ -4954,26 +4888,36 @@ external_bundle_sri = "sha384-AAAA"
             request_host: "pub.example",
             request_scheme: "https",
             origin_host: "origin.example",
+            csp_nonce: Some("response-nonce_123="),
             document_state: &document_state,
         };
 
         let inserts = integration.head_inserts(&ctx);
 
-        assert_eq!(inserts.len(), 2, "should emit config and bundle scripts");
+        assert_eq!(
+            inserts.len(),
+            1,
+            "should emit only the vendor bundle script"
+        );
         assert!(
-            inserts[1].contains(&format!("src=\"{PREBID_BUNDLE_ROUTE}?v={sha256}\"")),
+            inserts[0].contains(&format!("src=\"{PREBID_BUNDLE_ROUTE}?v={sha256}\"")),
             "bundle script should use content-addressed first-party URL: {}",
-            inserts[1]
+            inserts[0]
         );
         assert!(
-            inserts[1].contains("integrity=\"sha384-"),
+            inserts[0].contains("integrity=\"sha384-"),
             "bundle script should include configured SRI: {}",
-            inserts[1]
+            inserts[0]
+        );
+        assert!(
+            inserts[0].contains("nonce=\"response-nonce_123=\""),
+            "bundle script should propagate the response CSP nonce: {}",
+            inserts[0]
         );
         assert!(
-            !inserts[1].contains("crossorigin"),
+            !inserts[0].contains("crossorigin"),
             "same-origin bundle script should not include crossorigin: {}",
-            inserts[1]
+            inserts[0]
         );
     }
 
@@ -4988,63 +4932,48 @@ external_bundle_sri = "sha384-AAAA"
             request_host: "pub.example",
             request_scheme: "https",
             origin_host: "origin.example",
+            csp_nonce: None,
             document_state: &document_state,
         };
 
         let inserts = integration.head_inserts(&ctx);
 
-        assert_eq!(inserts.len(), 2, "should emit config and bundle scripts");
+        assert_eq!(
+            inserts.len(),
+            1,
+            "should emit only the vendor bundle script"
+        );
         assert!(
-            inserts[1].contains(&format!("src=\"{PREBID_BUNDLE_ROUTE}\"")),
+            inserts[0].contains(&format!("src=\"{PREBID_BUNDLE_ROUTE}\"")),
             "bundle script should use first-party route without hash query: {}",
-            inserts[1]
+            inserts[0]
         );
         assert!(
-            !inserts[1].contains("?v="),
+            !inserts[0].contains("?v="),
             "unhashed bundle script should not include version query: {}",
-            inserts[1]
+            inserts[0]
         );
     }
 
     #[test]
-    fn head_injector_escapes_closing_script_tags_in_values() {
+    fn browser_projection_preserves_script_significant_values_for_boot_escaping() {
         let mut config = base_config();
         config.account_id = Some("</script><script>alert(1)</script>".to_string());
         let integration = PrebidIntegration::new(config);
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            script.contains(r#""accountId":"<\/script><script>alert(1)<\/script>""#),
-            "should escape closing script tags inside JSON values: {}",
-            script
+            config.contains(r#""accountId":"</script><script>alert(1)</script>""#),
+            "typed projection should preserve data before the central boot encoder: {config}"
         );
     }
 
     #[test]
     fn head_injector_omits_client_side_bidders_when_empty() {
         let integration = PrebidIntegration::new(base_config());
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            !script.contains("clientSideBidders"),
-            "should omit clientSideBidders when empty: {}",
-            script
+            !config.contains("clientSideBidders"),
+            "should omit clientSideBidders when empty: {config}"
         );
     }
 
@@ -5053,20 +4982,10 @@ external_bundle_sri = "sha384-AAAA"
         let mut config = base_config();
         config.client_side_bidders = vec!["rubicon".to_string(), "magnite".to_string()];
         let integration = PrebidIntegration::new(config);
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "pub.example",
-            request_scheme: "https",
-            origin_host: "origin.example",
-            document_state: &document_state,
-        };
-
-        let inserts = integration.head_inserts(&ctx);
-        let script = &inserts[0];
+        let config = browser_config_json(&integration);
         assert!(
-            script.contains(r#""clientSideBidders":["rubicon","magnite"]"#),
-            "should include clientSideBidders array: {}",
-            script
+            config.contains(r#""clientSideBidders":["rubicon","magnite"]"#),
+            "should include clientSideBidders array: {config}"
         );
     }
 
@@ -6629,6 +6548,11 @@ external_bundle_sri = "sha384-AAAA"
             provider_responses: vec![provider_response],
             mediator_response: None,
             winning_bids: HashMap::new(),
+            decision_set: crate::auction::types::AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "test-auction".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 42,
             metadata: HashMap::new(),
         };
diff --git a/crates/trusted-server-core/src/integrations/registry.rs b/crates/trusted-server-core/src/integrations/registry.rs
index 5b11b105e..a7367c25b 100644
--- a/crates/trusted-server-core/src/integrations/registry.rs
+++ b/crates/trusted-server-core/src/integrations/registry.rs
@@ -1,5 +1,5 @@
 use std::any::{Any, TypeId};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::sync::{Arc, Mutex};
 
 use async_trait::async_trait;
@@ -7,6 +7,7 @@ use edgezero_core::body::Body as EdgeBody;
 use error_stack::Report;
 use http::{Method, Request, Response};
 use matchit::Router;
+use serde::Serialize;
 
 use crate::auction::AuctionPlan;
 use crate::constants::HEADER_X_TS_EC;
@@ -545,9 +546,28 @@ pub struct IntegrationHtmlContext<'a> {
     pub request_host: &'a str,
     pub request_scheme: &'a str,
     pub origin_host: &'a str,
+    /// Response-authenticated CSP nonce for server-generated executable tags.
+    pub csp_nonce: Option<&'a str>,
     pub document_state: &'a IntegrationDocumentState,
 }
 
+/// Build a safe nonce attribute for a server-generated executable tag.
+pub(crate) fn html_script_nonce_attribute(csp_nonce: Option<&str>) -> Option<String> {
+    match csp_nonce {
+        Some(nonce)
+            if !nonce.is_empty()
+                && nonce.len() <= 256
+                && nonce.bytes().all(|byte| {
+                    byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'_' | b'-' | b'=')
+                }) =>
+        {
+            Some(format!(r#" nonce="{nonce}""#))
+        }
+        Some(_) => None,
+        None => Some(String::new()),
+    }
+}
+
 /// Trait for integration-provided HTML post-processors.
 /// These run after streaming HTML processing to handle cases that require
 /// access to the complete HTML (e.g., cross-script RSC T-chunks).
@@ -576,11 +596,6 @@ pub trait IntegrationHeadInjector: Send + Sync {
     fn integration_id(&self) -> &'static str;
     /// Return HTML snippets to insert at the start of `<head>`.
     fn head_inserts(&self, ctx: &IntegrationHtmlContext<'_>) -> Vec<String>;
-
-    /// Return attributes to add to the publisher TSJS bundle tag.
-    fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-        Vec::new()
-    }
 }
 
 /// Registration payload returned by integration builders.
@@ -594,6 +609,7 @@ pub struct IntegrationRegistration {
     pub html_post_processors: Vec<Arc<dyn IntegrationHtmlPostProcessor>>,
     pub head_injectors: Vec<Arc<dyn IntegrationHeadInjector>>,
     pub request_filters: Vec<Arc<dyn IntegrationRequestFilter>>,
+    pub(crate) browser_config_v1: Option<serde_json::Value>,
 }
 
 impl IntegrationRegistration {
@@ -620,6 +636,7 @@ impl IntegrationRegistrationBuilder {
                 html_post_processors: Vec::new(),
                 head_injectors: Vec::new(),
                 request_filters: Vec::new(),
+                browser_config_v1: None,
             },
         }
     }
@@ -666,6 +683,47 @@ impl IntegrationRegistrationBuilder {
         self
     }
 
+    /// Attach this product's explicit browser-safe version-1 projection.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when the typed projection cannot be represented as JSON.
+    pub(crate) fn with_browser_config_v1<T: Serialize>(
+        mut self,
+        config: &T,
+    ) -> Result<Self, Report<TrustedServerError>> {
+        self.registration.browser_config_v1 =
+            Some(serde_json::to_value(config).map_err(|error| {
+                Report::new(TrustedServerError::Configuration {
+                    message: format!(
+                        "Integration {} browser config serialization failed: {error}",
+                        self.registration.integration_id
+                    ),
+                })
+            })?);
+        Ok(self)
+    }
+
+    /// Attach an exact empty object for a product with no browser-selectable fields.
+    pub(crate) fn with_empty_browser_config_v1(
+        mut self,
+    ) -> Result<Self, Report<TrustedServerError>> {
+        #[derive(Serialize)]
+        struct EmptyBrowserConfigV1 {}
+
+        self.registration.browser_config_v1 = Some(
+            serde_json::to_value(EmptyBrowserConfigV1 {}).map_err(|error| {
+                Report::new(TrustedServerError::Configuration {
+                    message: format!(
+                        "Integration {} browser config serialization failed: {error}",
+                        self.registration.integration_id
+                    ),
+                })
+            })?,
+        );
+        Ok(self)
+    }
+
     /// Mark this integration's JS module for deferred loading via
     /// `<script defer>` instead of the main synchronous bundle.
     #[must_use]
@@ -699,6 +757,7 @@ struct IntegrationRegistryInner {
     patch_router: Router<RouteValue>,
     head_router: Router<RouteValue>,
     options_router: Router<RouteValue>,
+    reserved_proxies: Vec<(&'static str, Arc<dyn IntegrationProxy>)>,
 
     // Metadata for introspection
     routes: Vec<(IntegrationEndpoint, &'static str)>,
@@ -710,6 +769,8 @@ struct IntegrationRegistryInner {
     html_post_processors: Vec<Arc<dyn IntegrationHtmlPostProcessor>>,
     head_injectors: Vec<Arc<dyn IntegrationHeadInjector>>,
     request_filters: Vec<Arc<dyn IntegrationRequestFilter>>,
+    integration_configs_v1: crate::tsjs::IntegrationConfigsV1,
+    tsjs_static_transport: TsjsStaticTransportV1,
 }
 
 impl Default for IntegrationRegistryInner {
@@ -722,6 +783,7 @@ impl Default for IntegrationRegistryInner {
             patch_router: Router::new(),
             head_router: Router::new(),
             options_router: Router::new(),
+            reserved_proxies: Vec::new(),
             routes: Vec::new(),
             enabled_integration_ids: Vec::new(),
             deferred_js_ids: Vec::new(),
@@ -731,7 +793,79 @@ impl Default for IntegrationRegistryInner {
             html_post_processors: Vec::new(),
             head_injectors: Vec::new(),
             request_filters: Vec::new(),
+            integration_configs_v1: crate::tsjs::IntegrationConfigsV1::empty(),
+            tsjs_static_transport: TsjsStaticTransportV1::default(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct TsjsStaticTransportV1 {
+    artifacts_by_hash: HashMap<String, crate::tsjs::TsjsStaticArtifactV1>,
+    takeover_hash_by_selection: HashMap<TsjsCatalogSelectionV1, String>,
+    first_display_hash_by_mask: HashMap<u16, String>,
+    first_display_mask_by_hash: HashMap<String, u16>,
+}
+
+impl TsjsStaticTransportV1 {
+    fn new(
+        inner: &IntegrationRegistryInner,
+        creative_boot: crate::tsjs::CreativeBootConfigV1,
+    ) -> Self {
+        let mut transport = Self::default();
+        let creative_artifact = crate::tsjs::creative_tsjs_static_artifact_v1().clone();
+        transport
+            .artifacts_by_hash
+            .insert(creative_artifact.hash().to_owned(), creative_artifact);
+
+        for render_trace_overlay in [false, true] {
+            for selection in tsjs_static_transport_selections(inner, render_trace_overlay) {
+                let normalized_selection = normalize_tsjs_transport_selection(inner, selection);
+                let takeover_ids = tsjs_selected_catalog_metadata(inner, normalized_selection)
+                    .into_iter()
+                    .filter(|metadata| {
+                        metadata.phase == Some(trusted_server_js::TsjsModulePhase::Takeover)
+                    })
+                    .map(|metadata| metadata.id)
+                    .collect::<Vec<_>>();
+                let artifact = if takeover_ids.as_slice() == crate::tsjs::creative_tsjs_module_ids()
+                {
+                    crate::tsjs::creative_tsjs_static_artifact_v1().clone()
+                } else {
+                    crate::tsjs::TsjsStaticArtifactV1::new(&takeover_ids)
+                };
+                let hash = artifact.hash().to_owned();
+                transport
+                    .artifacts_by_hash
+                    .entry(hash.clone())
+                    .or_insert(artifact);
+                transport
+                    .takeover_hash_by_selection
+                    .insert(normalized_selection, hash);
+            }
         }
+
+        for (mask, slices) in first_display_static_transport_selections(inner, creative_boot) {
+            let artifact = crate::tsjs::TsjsStaticArtifactV1::new_first_display(mask, &slices)
+                .expect("catalog-derived first-display selection should compose");
+            let hash = artifact.hash().to_owned();
+            transport
+                .artifacts_by_hash
+                .entry(hash.clone())
+                .or_insert(artifact);
+            transport
+                .first_display_hash_by_mask
+                .insert(mask, hash.clone());
+            assert!(
+                transport
+                    .first_display_mask_by_hash
+                    .insert(hash, mask)
+                    .is_none(),
+                "distinct first-display masks should have distinct exact bytes"
+            );
+        }
+
+        transport
     }
 }
 
@@ -746,6 +880,173 @@ pub struct IntegrationMetadata {
     pub request_filters: usize,
 }
 
+/// Request/document-owned inputs for generated TSJS catalog predicates.
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
+pub struct TsjsCatalogSelectionV1 {
+    pub creative_enabled: bool,
+    pub creative_click_guard: bool,
+    pub creative_render_guard: bool,
+    pub gpt_diagnostics_active: bool,
+    pub render_trace_overlay: bool,
+}
+
+fn tsjs_static_transport_selections(
+    inner: &IntegrationRegistryInner,
+    render_trace_overlay: bool,
+) -> Vec<TsjsCatalogSelectionV1> {
+    let diagnostics_configured = inner.enabled_integration_ids.contains(&"gpt_diagnostics");
+    let diagnostics_values: &[bool] = if diagnostics_configured {
+        &[false, true]
+    } else {
+        &[false]
+    };
+    let mut selections = Vec::with_capacity(diagnostics_values.len() * 2);
+    for creative_enabled in [false, true] {
+        for gpt_diagnostics_active in diagnostics_values {
+            selections.push(TsjsCatalogSelectionV1 {
+                creative_enabled,
+                creative_click_guard: creative_enabled,
+                creative_render_guard: false,
+                gpt_diagnostics_active: *gpt_diagnostics_active,
+                render_trace_overlay,
+            });
+        }
+    }
+    selections
+}
+
+fn first_display_static_transport_selections(
+    inner: &IntegrationRegistryInner,
+    creative: crate::tsjs::CreativeBootConfigV1,
+) -> Vec<(u16, Vec<&'static str>)> {
+    if !inner.enabled_integration_ids.contains(&"gpt") {
+        return Vec::new();
+    }
+    let aps_values: &[bool] = if inner.enabled_integration_ids.contains(&"aps") {
+        &[false, true]
+    } else {
+        &[false]
+    };
+    let prebid_values: &[bool] = if inner.enabled_integration_ids.contains(&"prebid") {
+        &[false, true]
+    } else {
+        &[false]
+    };
+    let creative_guard = creative.enabled && (creative.click_guard || creative.render_guard);
+    let mut selections = Vec::new();
+    for gpt_participates in [false, true] {
+        for render_owner_participates in [false, true] {
+            if render_owner_participates && !gpt_participates {
+                continue;
+            }
+            for aps_participates in aps_values {
+                if *aps_participates && !render_owner_participates {
+                    continue;
+                }
+                for prebid_participates in prebid_values {
+                    if *prebid_participates && !gpt_participates {
+                        continue;
+                    }
+                    let mut mask = 0_u16;
+                    let mut slices = Vec::new();
+                    for (index, metadata) in trusted_server_js::all_first_display_metadata()
+                        .into_iter()
+                        .enumerate()
+                    {
+                        let selected = match metadata.include {
+                            Some("eligible_batch") => true,
+                            Some("render_owner_participates") => render_owner_participates,
+                            Some("gpt_initial") => gpt_participates,
+                            Some("aps_participates") => *aps_participates,
+                            Some("creative_guard") => creative_guard,
+                            Some("prebid_participates") => *prebid_participates,
+                            Some(predicate) => predicate
+                                .strip_prefix("integration:")
+                                .is_some_and(|id| inner.enabled_integration_ids.contains(&id)),
+                            None => false,
+                        };
+                        if selected {
+                            mask |= 1_u16 << index;
+                            slices.push(metadata.id);
+                        }
+                    }
+                    if slices.first() == Some(&"first_display")
+                        && trusted_server_js::first_display_mask_is_permitted(mask)
+                    {
+                        selections.push((mask, slices));
+                    }
+                }
+            }
+        }
+    }
+    selections
+}
+
+fn normalize_tsjs_transport_selection(
+    inner: &IntegrationRegistryInner,
+    selection: TsjsCatalogSelectionV1,
+) -> TsjsCatalogSelectionV1 {
+    let creative_guard = selection.creative_enabled
+        && (selection.creative_click_guard || selection.creative_render_guard);
+    TsjsCatalogSelectionV1 {
+        creative_enabled: creative_guard,
+        creative_click_guard: creative_guard,
+        creative_render_guard: false,
+        gpt_diagnostics_active: selection.gpt_diagnostics_active
+            && inner.enabled_integration_ids.contains(&"gpt_diagnostics"),
+        render_trace_overlay: selection.render_trace_overlay,
+    }
+}
+
+fn tsjs_catalog_module_enabled(
+    inner: &IntegrationRegistryInner,
+    predicate: Option<&str>,
+    selection: TsjsCatalogSelectionV1,
+) -> bool {
+    match predicate {
+        Some("always") => true,
+        Some("creative_guard") => {
+            selection.creative_enabled
+                && (selection.creative_click_guard || selection.creative_render_guard)
+        }
+        Some("gpt_diagnostics_active") => selection.gpt_diagnostics_active,
+        Some("diagnostics_presentation") => {
+            selection.render_trace_overlay || selection.gpt_diagnostics_active
+        }
+        Some("prebid_and_gpt") => {
+            inner.enabled_integration_ids.contains(&"prebid")
+                && inner.enabled_integration_ids.contains(&"gpt")
+        }
+        Some(predicate) => predicate
+            .strip_prefix("integration:")
+            .is_some_and(|integration_id| inner.enabled_integration_ids.contains(&integration_id)),
+        None => false,
+    }
+}
+
+fn tsjs_selected_catalog_metadata(
+    inner: &IntegrationRegistryInner,
+    selection: TsjsCatalogSelectionV1,
+) -> Vec<trusted_server_js::TsjsArtifactMetadata> {
+    let mut selected = Vec::new();
+    let mut provided = std::collections::HashSet::from(["runtime.v1"]);
+    for metadata in trusted_server_js::all_integration_metadata() {
+        if !tsjs_catalog_module_enabled(inner, metadata.include, selection) {
+            continue;
+        }
+        let requirements_available = metadata
+            .inputs
+            .iter()
+            .all(|declaration| declaration.contains('?') || provided.contains(declaration));
+        if !requirements_available {
+            continue;
+        }
+        provided.extend(metadata.outputs.iter().copied());
+        selected.push(metadata);
+    }
+    selected
+}
+
 impl IntegrationMetadata {
     fn new(id: &'static str) -> Self {
         Self {
@@ -775,12 +1076,26 @@ pub struct ProxyDispatchInput<'a> {
 }
 
 /// In-memory registry of integrations discovered from settings.
-#[derive(Clone, Default)]
+#[derive(Clone)]
 pub struct IntegrationRegistry {
     inner: Arc<IntegrationRegistryInner>,
+    creative_boot: crate::tsjs::CreativeBootConfigV1,
     plan: Option<Arc<AuctionPlan>>,
 }
 
+impl Default for IntegrationRegistry {
+    fn default() -> Self {
+        let mut inner = IntegrationRegistryInner::default();
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
+        Self {
+            inner: Arc::new(inner),
+            creative_boot,
+            plan: None,
+        }
+    }
+}
+
 impl IntegrationRegistry {
     /// Build a test registry from settings and a newly compiled auction plan.
     ///
@@ -808,6 +1123,14 @@ impl IntegrationRegistry {
     ) -> Result<Self, Report<TrustedServerError>> {
         let mut inner = IntegrationRegistryInner::default();
         let mut registrations = Vec::new();
+        let mut integration_configs_v1 = Vec::new();
+        let creative_boot = crate::tsjs::creative_boot_config_v1(settings)?;
+        let aps_proxy: Arc<dyn IntegrationProxy> =
+            Arc::new(super::aps::ApsV1Integration::from_plan(&plan));
+        inner
+            .reserved_proxies
+            .push(("/integrations/aps", aps_proxy));
+
         if let Some(registration) = crate::integrations::prebid::register_for_plan(settings, &plan)?
         {
             registrations.push(registration);
@@ -817,12 +1140,40 @@ impl IntegrationRegistry {
         }
         for builder in crate::integrations::builders() {
             if let Some(registration) = (builder.build)(settings)? {
-                debug_assert_eq!(registration.integration_id, builder.id);
+                debug_assert_eq!(
+                    registration.integration_id, builder.id,
+                    "integration builder ID should match registration ID"
+                );
                 registrations.push(registration);
             }
         }
 
         for registration in registrations {
+            match (
+                crate::tsjs::is_integration_config_product_v1(registration.integration_id),
+                registration.browser_config_v1.clone(),
+            ) {
+                (true, Some(config)) => {
+                    integration_configs_v1.push((registration.integration_id, config));
+                }
+                (true, None) => {
+                    return Err(Report::new(TrustedServerError::Configuration {
+                        message: format!(
+                            "Integration {} is missing its browser config projection",
+                            registration.integration_id
+                        ),
+                    }));
+                }
+                (false, Some(_)) => {
+                    return Err(Report::new(TrustedServerError::Configuration {
+                        message: format!(
+                            "Integration {} cannot emit a generic browser config",
+                            registration.integration_id
+                        ),
+                    }));
+                }
+                (false, None) => {}
+            }
             inner
                 .enabled_integration_ids
                 .push(registration.integration_id);
@@ -891,8 +1242,16 @@ impl IntegrationRegistry {
             }
         }
 
+        integration_configs_v1.sort_by_key(|(id, _)| {
+            crate::tsjs::integration_config_order_v1(id)
+                .expect("browser config product should have a canonical order")
+        });
+        inner.integration_configs_v1 =
+            crate::tsjs::IntegrationConfigsV1::new(integration_configs_v1)?;
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Ok(Self {
             inner: Arc::new(inner),
+            creative_boot,
             plan: Some(plan),
         })
     }
@@ -905,6 +1264,37 @@ impl IntegrationRegistry {
             .is_some_and(|owned| Arc::ptr_eq(owned, plan))
     }
 
+    fn reserved_proxy(&self, path: &str) -> Option<&Arc<dyn IntegrationProxy>> {
+        self.inner
+            .reserved_proxies
+            .iter()
+            .find(|(family, _)| {
+                path == *family
+                    || path
+                        .strip_prefix(*family)
+                        .is_some_and(|suffix| suffix.starts_with('/'))
+            })
+            .map(|(_, proxy)| proxy)
+    }
+
+    /// Return true when a hard-cutover family owns this path.
+    #[must_use]
+    pub fn has_reserved_path(&self, path: &str) -> bool {
+        self.reserved_proxy(path).is_some()
+    }
+
+    /// Dispatch a hard-cutover family before auth, EC, filters, and fallback.
+    #[must_use]
+    pub async fn handle_reserved_proxy(
+        &self,
+        settings: &Settings,
+        services: &RuntimeServices,
+        req: Request<EdgeBody>,
+    ) -> Option<Result<Response<EdgeBody>, Report<TrustedServerError>>> {
+        let proxy = self.reserved_proxy(req.uri().path())?;
+        Some(proxy.handle(settings, services, req).await)
+    }
+
     fn find_route(&self, method: &Method, path: &str) -> Option<&RouteValue> {
         let router = match *method {
             Method::GET => &self.inner.get_router,
@@ -1091,30 +1481,6 @@ impl IntegrationRegistry {
         inserts
     }
 
-    /// Collect static attributes for the publisher TSJS bundle tag.
-    #[must_use]
-    pub fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-        let mut attributes: Vec<(&'static str, &'static str)> = Vec::new();
-        for injector in &self.inner.head_injectors {
-            for attribute in injector.tsjs_script_tag_attributes() {
-                let existing = attributes
-                    .iter()
-                    .find(|(name, _)| *name == attribute.0)
-                    .copied();
-                match existing {
-                    None => attributes.push(attribute),
-                    Some((_, kept_value)) if kept_value != attribute.1 => log::warn!(
-                        "Integration `{}` emits conflicting value for publisher tag attribute `{}`; keeping the first",
-                        injector.integration_id(),
-                        attribute.0
-                    ),
-                    Some(_) => {}
-                }
-            }
-        }
-        attributes
-    }
-
     /// Provide a snapshot of registered integrations and their hooks.
     #[must_use]
     pub fn registered_integrations(&self) -> Vec<IntegrationMetadata> {
@@ -1172,6 +1538,12 @@ impl IntegrationRegistry {
         self.inner.enabled_integration_ids.contains(&integration_id)
     }
 
+    /// Return the exact server-owned creative browser boot policy.
+    #[must_use]
+    pub fn tsjs_creative_boot(&self) -> crate::tsjs::CreativeBootConfigV1 {
+        self.creative_boot
+    }
+
     /// Return JS module IDs that should be included in the tsjs bundle.
     ///
     /// Always includes JS-only modules with no Rust-side registration.
@@ -1220,11 +1592,139 @@ impl IntegrationRegistry {
             .collect()
     }
 
+    /// Return enabled TSJS catalog modules in the generated release order.
+    ///
+    /// This transport selector is deny-unknown and never accepts a phase or
+    /// ordering override from settings. Request-scoped diagnostics activation
+    /// may further filter the returned diagnostics rows when composing a manifest.
+    #[must_use]
+    pub fn tsjs_catalog_module_ids(&self, selection: TsjsCatalogSelectionV1) -> Vec<&'static str> {
+        tsjs_selected_catalog_metadata(&self.inner, selection)
+            .into_iter()
+            .map(|metadata| metadata.id)
+            .collect()
+    }
+
+    /// Return the exact browser-safe product configuration subset for one manifest.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when manifest product predicates and registered projections disagree.
+    pub(crate) fn tsjs_integration_configs_v1(
+        &self,
+        module_ids: &[&str],
+    ) -> Result<crate::tsjs::IntegrationConfigsV1, Report<TrustedServerError>> {
+        self.inner
+            .integration_configs_v1
+            .select_for_manifest(module_ids)
+    }
+
+    /// Return the enabled parser-blocking catalog slice in canonical order.
+    #[must_use]
+    pub fn tsjs_takeover_module_ids(&self, selection: TsjsCatalogSelectionV1) -> Vec<&'static str> {
+        tsjs_selected_catalog_metadata(&self.inner, selection)
+            .into_iter()
+            .filter(|metadata| metadata.phase == Some(trusted_server_js::TsjsModulePhase::Takeover))
+            .map(|metadata| metadata.id)
+            .collect()
+    }
+
+    /// Return the enabled post-paint catalog slice in canonical order.
+    #[must_use]
+    pub fn tsjs_deferred_module_ids(&self, selection: TsjsCatalogSelectionV1) -> Vec<&'static str> {
+        tsjs_selected_catalog_metadata(&self.inner, selection)
+            .into_iter()
+            .filter(|metadata| metadata.phase == Some(trusted_server_js::TsjsModulePhase::Deferred))
+            .map(|metadata| metadata.id)
+            .collect()
+    }
+
+    /// Return the bounded request-owned variants admitted by static transport.
+    ///
+    /// Integration predicates remain fixed by this registry. Creative guards and
+    /// diagnostics activity are document/session bits, so the content hash is
+    /// matched against only their configured, finite candidate combinations.
+    #[must_use]
+    pub fn tsjs_static_transport_selections(
+        &self,
+        render_trace_overlay: bool,
+    ) -> Vec<TsjsCatalogSelectionV1> {
+        tsjs_static_transport_selections(&self.inner, render_trace_overlay)
+    }
+
+    /// Return the precomputed takeover artifact for one document selection.
+    #[cfg(test)]
+    #[must_use]
+    pub(crate) fn tsjs_takeover_artifact(
+        &self,
+        selection: TsjsCatalogSelectionV1,
+    ) -> Option<&crate::tsjs::TsjsStaticArtifactV1> {
+        let normalized_selection = normalize_tsjs_transport_selection(&self.inner, selection);
+        let hash = self
+            .inner
+            .tsjs_static_transport
+            .takeover_hash_by_selection
+            .get(&normalized_selection)?;
+        self.tsjs_static_artifact(hash)
+    }
+
+    /// Resolve one admitted unified artifact by its exact content hash.
+    #[must_use]
+    pub(crate) fn tsjs_static_artifact(
+        &self,
+        hash: &str,
+    ) -> Option<&crate::tsjs::TsjsStaticArtifactV1> {
+        self.inner.tsjs_static_transport.artifacts_by_hash.get(hash)
+    }
+
+    /// Resolve one configuration-permitted first-display artifact by exact mask and hash.
+    #[must_use]
+    pub(crate) fn tsjs_first_display_artifact(
+        &self,
+        mask: u16,
+        hash: &str,
+    ) -> Option<&crate::tsjs::TsjsStaticArtifactV1> {
+        let indexed_hash = self
+            .inner
+            .tsjs_static_transport
+            .first_display_hash_by_mask
+            .get(&mask)?;
+        if indexed_hash != hash
+            || self
+                .inner
+                .tsjs_static_transport
+                .first_display_mask_by_hash
+                .get(hash)
+                != Some(&mask)
+        {
+            return None;
+        }
+        self.tsjs_static_artifact(hash)
+    }
+
+    /// Return the finite precomputed first-display masks admitted by this registry.
+    #[must_use]
+    pub fn tsjs_first_display_masks(&self) -> Vec<u16> {
+        let mut masks = self
+            .inner
+            .tsjs_static_transport
+            .first_display_hash_by_mask
+            .keys()
+            .copied()
+            .collect::<Vec<_>>();
+        masks.sort_unstable();
+        masks
+    }
+
     #[cfg(test)]
     #[must_use]
     pub fn empty_for_tests() -> Self {
+        let mut inner = IntegrationRegistryInner::default();
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Self {
-            inner: Arc::new(IntegrationRegistryInner::default()),
+            inner: Arc::new(inner),
+            creative_boot,
             plan: None,
         }
     }
@@ -1235,25 +1735,32 @@ impl IntegrationRegistry {
         attribute_rewriters: Vec<Arc<dyn IntegrationAttributeRewriter>>,
         script_rewriters: Vec<Arc<dyn IntegrationScriptRewriter>>,
     ) -> Self {
+        let mut inner = IntegrationRegistryInner {
+            get_router: Router::new(),
+            post_router: Router::new(),
+            put_router: Router::new(),
+            delete_router: Router::new(),
+            patch_router: Router::new(),
+            head_router: Router::new(),
+            options_router: Router::new(),
+            reserved_proxies: Vec::new(),
+            routes: Vec::new(),
+            enabled_integration_ids: Vec::new(),
+            html_rewriters: attribute_rewriters,
+            script_rewriters,
+            html_post_processors: Vec::new(),
+            head_injectors: Vec::new(),
+            request_filters: Vec::new(),
+            deferred_js_ids: Vec::new(),
+            disabled_js_ids: Vec::new(),
+            integration_configs_v1: crate::tsjs::IntegrationConfigsV1::empty(),
+            tsjs_static_transport: TsjsStaticTransportV1::default(),
+        };
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Self {
-            inner: Arc::new(IntegrationRegistryInner {
-                get_router: Router::new(),
-                post_router: Router::new(),
-                put_router: Router::new(),
-                delete_router: Router::new(),
-                patch_router: Router::new(),
-                head_router: Router::new(),
-                options_router: Router::new(),
-                routes: Vec::new(),
-                enabled_integration_ids: Vec::new(),
-                html_rewriters: attribute_rewriters,
-                script_rewriters,
-                html_post_processors: Vec::new(),
-                head_injectors: Vec::new(),
-                request_filters: Vec::new(),
-                deferred_js_ids: Vec::new(),
-                disabled_js_ids: Vec::new(),
-            }),
+            inner: Arc::new(inner),
+            creative_boot,
             plan: None,
         }
     }
@@ -1265,25 +1772,32 @@ impl IntegrationRegistry {
         script_rewriters: Vec<Arc<dyn IntegrationScriptRewriter>>,
         head_injectors: Vec<Arc<dyn IntegrationHeadInjector>>,
     ) -> Self {
+        let mut inner = IntegrationRegistryInner {
+            get_router: Router::new(),
+            post_router: Router::new(),
+            put_router: Router::new(),
+            delete_router: Router::new(),
+            patch_router: Router::new(),
+            head_router: Router::new(),
+            options_router: Router::new(),
+            reserved_proxies: Vec::new(),
+            routes: Vec::new(),
+            enabled_integration_ids: Vec::new(),
+            html_rewriters: attribute_rewriters,
+            script_rewriters,
+            html_post_processors: Vec::new(),
+            head_injectors,
+            request_filters: Vec::new(),
+            deferred_js_ids: Vec::new(),
+            disabled_js_ids: Vec::new(),
+            integration_configs_v1: crate::tsjs::IntegrationConfigsV1::empty(),
+            tsjs_static_transport: TsjsStaticTransportV1::default(),
+        };
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Self {
-            inner: Arc::new(IntegrationRegistryInner {
-                get_router: Router::new(),
-                post_router: Router::new(),
-                put_router: Router::new(),
-                delete_router: Router::new(),
-                patch_router: Router::new(),
-                head_router: Router::new(),
-                options_router: Router::new(),
-                routes: Vec::new(),
-                enabled_integration_ids: Vec::new(),
-                html_rewriters: attribute_rewriters,
-                script_rewriters,
-                html_post_processors: Vec::new(),
-                head_injectors,
-                request_filters: Vec::new(),
-                deferred_js_ids: Vec::new(),
-                disabled_js_ids: Vec::new(),
-            }),
+            inner: Arc::new(inner),
+            creative_boot,
             plan: None,
         }
     }
@@ -1291,25 +1805,32 @@ impl IntegrationRegistry {
     #[cfg(any(test, feature = "test-utils"))]
     #[must_use]
     pub fn from_request_filters(request_filters: Vec<Arc<dyn IntegrationRequestFilter>>) -> Self {
+        let mut inner = IntegrationRegistryInner {
+            get_router: Router::new(),
+            post_router: Router::new(),
+            put_router: Router::new(),
+            delete_router: Router::new(),
+            patch_router: Router::new(),
+            head_router: Router::new(),
+            options_router: Router::new(),
+            reserved_proxies: Vec::new(),
+            routes: Vec::new(),
+            enabled_integration_ids: Vec::new(),
+            html_rewriters: Vec::new(),
+            script_rewriters: Vec::new(),
+            html_post_processors: Vec::new(),
+            head_injectors: Vec::new(),
+            request_filters,
+            deferred_js_ids: Vec::new(),
+            disabled_js_ids: Vec::new(),
+            integration_configs_v1: crate::tsjs::IntegrationConfigsV1::empty(),
+            tsjs_static_transport: TsjsStaticTransportV1::default(),
+        };
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Self {
-            inner: Arc::new(IntegrationRegistryInner {
-                get_router: Router::new(),
-                post_router: Router::new(),
-                put_router: Router::new(),
-                delete_router: Router::new(),
-                patch_router: Router::new(),
-                head_router: Router::new(),
-                options_router: Router::new(),
-                routes: Vec::new(),
-                enabled_integration_ids: Vec::new(),
-                html_rewriters: Vec::new(),
-                script_rewriters: Vec::new(),
-                html_post_processors: Vec::new(),
-                head_injectors: Vec::new(),
-                request_filters,
-                deferred_js_ids: Vec::new(),
-                disabled_js_ids: Vec::new(),
-            }),
+            inner: Arc::new(inner),
+            creative_boot,
             plan: None,
         }
     }
@@ -1357,25 +1878,32 @@ impl IntegrationRegistry {
                 .expect("route registration should succeed");
         }
 
+        let mut inner = IntegrationRegistryInner {
+            get_router,
+            post_router,
+            put_router,
+            delete_router,
+            patch_router,
+            head_router,
+            options_router,
+            reserved_proxies: Vec::new(),
+            routes: Vec::new(),
+            enabled_integration_ids: Vec::new(),
+            html_rewriters: Vec::new(),
+            script_rewriters: Vec::new(),
+            html_post_processors: Vec::new(),
+            head_injectors: Vec::new(),
+            request_filters: Vec::new(),
+            deferred_js_ids: Vec::new(),
+            disabled_js_ids: Vec::new(),
+            integration_configs_v1: crate::tsjs::IntegrationConfigsV1::empty(),
+            tsjs_static_transport: TsjsStaticTransportV1::default(),
+        };
+        let creative_boot = crate::tsjs::CreativeBootConfigV1::default();
+        inner.tsjs_static_transport = TsjsStaticTransportV1::new(&inner, creative_boot);
         Self {
-            inner: Arc::new(IntegrationRegistryInner {
-                get_router,
-                post_router,
-                put_router,
-                delete_router,
-                patch_router,
-                head_router,
-                options_router,
-                routes: Vec::new(),
-                enabled_integration_ids: Vec::new(),
-                html_rewriters: Vec::new(),
-                script_rewriters: Vec::new(),
-                html_post_processors: Vec::new(),
-                head_injectors: Vec::new(),
-                request_filters: Vec::new(),
-                deferred_js_ids: Vec::new(),
-                disabled_js_ids: Vec::new(),
-            }),
+            inner: Arc::new(inner),
+            creative_boot,
             plan: None,
         }
     }
@@ -1388,79 +1916,6 @@ mod tests {
     use crate::platform::test_support::noop_services;
     use http::{HeaderValue, StatusCode, header};
 
-    struct DefaultMetadataHeadInjector;
-
-    impl IntegrationHeadInjector for DefaultMetadataHeadInjector {
-        fn integration_id(&self) -> &'static str {
-            "default-metadata"
-        }
-
-        fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-            Vec::new()
-        }
-    }
-
-    struct StaticMetadataHeadInjector;
-
-    impl IntegrationHeadInjector for StaticMetadataHeadInjector {
-        fn integration_id(&self) -> &'static str {
-            "static-metadata"
-        }
-
-        fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-            Vec::new()
-        }
-
-        fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-            vec![
-                ("data-ts-gam-attribution", "true"),
-                ("data-test-order", "second"),
-            ]
-        }
-    }
-
-    struct ConflictingMetadataHeadInjector;
-
-    impl IntegrationHeadInjector for ConflictingMetadataHeadInjector {
-        fn integration_id(&self) -> &'static str {
-            "conflicting-metadata"
-        }
-
-        fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-            Vec::new()
-        }
-
-        fn tsjs_script_tag_attributes(&self) -> Vec<(&'static str, &'static str)> {
-            vec![
-                ("data-ts-gam-attribution", "false"),
-                ("data-third-attribute", "third"),
-            ]
-        }
-    }
-
-    #[test]
-    fn tsjs_script_tag_attributes_preserve_registration_order_and_default_empty() {
-        let registry = IntegrationRegistry::from_rewriters_with_head_injectors(
-            Vec::new(),
-            Vec::new(),
-            vec![
-                Arc::new(DefaultMetadataHeadInjector),
-                Arc::new(StaticMetadataHeadInjector),
-                Arc::new(ConflictingMetadataHeadInjector),
-            ],
-        );
-
-        assert_eq!(
-            registry.tsjs_script_tag_attributes(),
-            vec![
-                ("data-ts-gam-attribution", "true"),
-                ("data-test-order", "second"),
-                ("data-third-attribute", "third"),
-            ],
-            "should keep the first value for duplicate names and preserve attribute order"
-        );
-    }
-
     // Mock integration proxy for testing
     struct MockProxy;
 
@@ -1584,6 +2039,7 @@ mod tests {
             request_host: "proxy.example.com",
             request_scheme: "https",
             origin_host: "origin.example.com",
+            csp_nonce: None,
             document_state: &document_state,
         };
 
@@ -1633,6 +2089,123 @@ mod tests {
         );
     }
 
+    #[test]
+    fn production_registry_always_reserves_the_aps_family() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("production registry should build");
+        assert!(registry.has_reserved_path("/integrations/aps"));
+        assert!(registry.has_reserved_path("/integrations/aps/runner.js"));
+        assert!(registry.has_reserved_path("/integrations/aps/malformed/path"));
+        assert!(!registry.has_reserved_path("/integrations/apsx/runner.js"));
+        assert!(!registry.has_reserved_path("/integrations/aps-legacy"));
+        assert!(
+            !registry
+                .registered_integrations()
+                .iter()
+                .any(|integration| integration.id == "aps"),
+            "a plan without an APS profile must not register APS"
+        );
+
+        for path in [
+            "/integrations/aps/renderer/v2",
+            "/integrations/aps/runner.js",
+        ] {
+            let request = Request::builder()
+                .method(Method::GET)
+                .uri(path)
+                .header(HEADER_X_TS_EC.clone(), "caller-controlled")
+                .body(EdgeBody::empty())
+                .expect("should build reserved APS request");
+            let response = futures::executor::block_on(registry.handle_reserved_proxy(
+                &settings,
+                &noop_services(),
+                request,
+            ))
+            .expect("reserved family should be handled")
+            .expect("disabled APS response should be local");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND);
+            assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+        }
+    }
+
+    #[test]
+    fn aps_profile_alone_registers_and_activates_reserved_routes() {
+        let settings = create_test_settings();
+        assert!(
+            settings
+                .integration_config::<crate::integrations::aps::ApsConfig>("aps")
+                .expect("APS browser config lookup should succeed")
+                .is_none(),
+            "the activation proof must not depend on integrations.aps"
+        );
+        let plan = crate::auction::AuctionPlan::compile(crate::auction::plan::AuctionPlanConfig {
+            timeout_ms: 1_000,
+            providers: BTreeMap::from([(
+                "aps-profile-only"
+                    .parse()
+                    .expect("should parse APS provider ID"),
+                crate::auction::plan::ProviderConfig {
+                    protocol: "openrtb-2.6".to_string(),
+                    profile: "aps".to_string(),
+                    endpoint: "https://aps.example/bid".to_string(),
+                    timeout_ms: None,
+                    routing: crate::auction::plan::RoutingMode::AllEligible,
+                    notifications: crate::auction::plan::NotificationConfig::default(),
+                    profile_config: serde_json::json!({
+                        "account_id": "example-account"
+                    }),
+                },
+            )]),
+            ..crate::auction::plan::AuctionPlanConfig::default()
+        })
+        .expect("APS-only plan should compile");
+        let registry = IntegrationRegistry::with_plan(&settings, Arc::new(plan))
+            .expect("APS-only registry should build");
+
+        assert!(
+            registry
+                .registered_integrations()
+                .iter()
+                .any(|integration| integration.id == "aps"),
+            "planned APS registration must be retained"
+        );
+
+        let renderer_request = Request::builder()
+            .method(Method::GET)
+            .uri("/integrations/aps/renderer/v2")
+            .body(EdgeBody::empty())
+            .expect("should build APS renderer request");
+        let renderer_response = futures::executor::block_on(registry.handle_reserved_proxy(
+            &settings,
+            &noop_services(),
+            renderer_request,
+        ))
+        .expect("reserved renderer should be handled")
+        .expect("profile-only APS renderer should respond locally");
+        assert_eq!(renderer_response.status(), StatusCode::OK);
+        assert_eq!(
+            renderer_response.headers()[header::CACHE_CONTROL],
+            "public, max-age=31536000, immutable"
+        );
+
+        let runner_request = Request::builder()
+            .method(Method::POST)
+            .uri("/integrations/aps/runner.js")
+            .body(EdgeBody::empty())
+            .expect("should build APS runner request");
+        let runner_response = futures::executor::block_on(registry.handle_reserved_proxy(
+            &settings,
+            &noop_services(),
+            runner_request,
+        ))
+        .expect("reserved runner should be handled")
+        .expect("enabled APS runner should reject invalid methods locally");
+        assert_eq!(runner_response.status(), StatusCode::METHOD_NOT_ALLOWED);
+        assert_eq!(runner_response.headers()[header::ALLOW], "GET");
+        assert_eq!(runner_response.headers()[header::CACHE_CONTROL], "no-store");
+    }
+
     #[test]
     fn filter_request_applies_request_headers_and_returns_response_headers() {
         let registry =
@@ -2184,6 +2757,197 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tsjs_catalog_selector_uses_generated_predicates_and_request_bits() {
+        let registry = IntegrationRegistry::empty_for_tests();
+
+        assert_eq!(
+            registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1::default()),
+            vec!["render_runtime"],
+            "always must select only the mandatory runtime without other inputs"
+        );
+        assert_eq!(
+            registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1 {
+                creative_enabled: true,
+                creative_click_guard: true,
+                ..TsjsCatalogSelectionV1::default()
+            }),
+            vec!["render_runtime", "creative"],
+            "creative requires enabled plus one guard"
+        );
+        assert_eq!(
+            registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1 {
+                creative_enabled: true,
+                ..TsjsCatalogSelectionV1::default()
+            }),
+            vec!["render_runtime"],
+            "creative enabled without a guard must remain absent"
+        );
+        assert_eq!(
+            registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1 {
+                gpt_diagnostics_active: true,
+                ..TsjsCatalogSelectionV1::default()
+            }),
+            vec!["render_runtime", "diagnostics_presentation"],
+            "diagnostics capture is omitted when its mandatory GPT provider is absent"
+        );
+        assert_eq!(
+            registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1 {
+                render_trace_overlay: true,
+                ..TsjsCatalogSelectionV1::default()
+            }),
+            vec!["render_runtime", "diagnostics_presentation"],
+            "overlay alone selects only presentation"
+        );
+    }
+
+    #[test]
+    fn tsjs_static_transport_precomputes_every_admitted_takeover_artifact() {
+        let mut settings = crate::test_support::tests::create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
+            .expect("should enable diagnostics");
+        let registry = IntegrationRegistry::new(&settings).expect("should create registry");
+
+        for render_trace_overlay in [false, true] {
+            for selection in registry.tsjs_static_transport_selections(render_trace_overlay) {
+                let module_ids = registry.tsjs_takeover_module_ids(selection);
+                let expected_body = trusted_server_js::concatenate_modules(&module_ids);
+                let expected_hash = trusted_server_js::concatenated_hash(&module_ids);
+                let artifact = registry
+                    .tsjs_takeover_artifact(selection)
+                    .expect("should precompute every admitted selection");
+
+                assert_eq!(artifact.hash(), expected_hash, "should preserve exact hash");
+                assert_eq!(
+                    artifact.body().as_ref(),
+                    expected_body.as_bytes(),
+                    "should preserve exact response bytes"
+                );
+                assert_eq!(
+                    artifact.src(),
+                    format!("/static/tsjs=tsjs-unified.min.js?v={expected_hash}"),
+                    "should precompute the exact takeover URL"
+                );
+                assert_eq!(
+                    registry
+                        .tsjs_static_artifact(&expected_hash)
+                        .expect("should index artifact by hash")
+                        .body()
+                        .as_ptr(),
+                    artifact.body().as_ptr(),
+                    "selection and transport lookups should share precomputed bytes"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn tsjs_static_transport_precomputes_every_size_admitted_first_display_mask() {
+        let mut settings = crate::test_support::tests::create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt", &serde_json::json!({}))
+            .expect("should enable GPT");
+        let plan = crate::auction::AuctionPlan::compile(crate::auction::plan::AuctionPlanConfig {
+            timeout_ms: 1_000,
+            providers: BTreeMap::from([(
+                "aps-mask".parse().expect("should parse APS provider ID"),
+                crate::auction::plan::ProviderConfig {
+                    protocol: "openrtb-2.6".to_string(),
+                    profile: "aps".to_string(),
+                    endpoint: "https://aps.example/bid".to_string(),
+                    timeout_ms: None,
+                    routing: crate::auction::plan::RoutingMode::AllEligible,
+                    notifications: crate::auction::plan::NotificationConfig::default(),
+                    profile_config: serde_json::json!({
+                        "account_id": "test-account"
+                    }),
+                },
+            )]),
+            ..crate::auction::plan::AuctionPlanConfig::default()
+        })
+        .expect("should compile APS mask plan");
+        let registry = IntegrationRegistry::with_plan(&settings, Arc::new(plan))
+            .expect("should create registry");
+        let masks = registry.tsjs_first_display_masks();
+
+        let catalog = trusted_server_js::all_first_display_ids();
+        let bit = |id: &str| {
+            1_u16
+                << catalog
+                    .iter()
+                    .position(|candidate| *candidate == id)
+                    .expect("catalog should contain slice")
+        };
+        let fixed = bit("first_display") | bit("creative_initial");
+        let owner = bit("render_owner_initial");
+        let gpt = bit("gpt_initial");
+        let aps = bit("aps_initial");
+        let prebid = bit("prebid_initial");
+        assert_eq!(
+            masks,
+            vec![
+                fixed,
+                fixed | gpt,
+                fixed | owner | gpt,
+                fixed | owner | aps | gpt,
+                fixed | gpt | prebid,
+                fixed | owner | gpt | prebid,
+                fixed | owner | aps | gpt | prebid,
+            ],
+            "registry should enumerate every configuration-reachable mask admitted by the fixed transfer ceiling"
+        );
+        for mask in masks {
+            let selected = trusted_server_js::all_first_display_ids()
+                .into_iter()
+                .enumerate()
+                .filter_map(|(index, id)| (mask & (1 << index) != 0).then_some(id))
+                .collect::<Vec<_>>();
+            let body = trusted_server_js::concatenate_first_display_slices(&selected[1..])
+                .expect("mask should select a closed composition");
+            let hash = trusted_server_js::concatenated_first_display_hash(&selected[1..])
+                .expect("mask should have a stable hash");
+            let artifact = registry
+                .tsjs_first_display_artifact(mask, &hash)
+                .expect("should resolve the precomputed mask/hash pair");
+
+            assert_eq!(artifact.body().as_ref(), body.as_bytes());
+            assert_eq!(
+                artifact.src(),
+                format!("/static/tsjs=tsjs-first-display.min.js?m={mask:04x}&v={hash}")
+            );
+            assert!(
+                registry
+                    .tsjs_first_display_artifact(mask ^ (1 << 1), &hash)
+                    .is_none(),
+                "hash-to-mask lookup must reject a mismatched selection"
+            );
+        }
+    }
+
+    #[test]
+    fn tsjs_static_transport_includes_creative_and_rejects_unknown_hash() {
+        let registry = IntegrationRegistry::empty_for_tests();
+        let creative_ids = crate::tsjs::creative_tsjs_module_ids();
+        let creative_hash = trusted_server_js::concatenated_hash(creative_ids);
+
+        assert_eq!(
+            registry
+                .tsjs_static_artifact(&creative_hash)
+                .expect("should precompute rewritten creative artifact")
+                .body()
+                .as_ref(),
+            trusted_server_js::concatenate_modules(creative_ids).as_bytes(),
+            "should admit the exact rewritten creative bundle"
+        );
+        assert!(
+            registry.tsjs_static_artifact(&"0".repeat(64)).is_none(),
+            "unknown hashes should be a lookup miss"
+        );
+    }
+
     #[test]
     fn js_module_ids_skip_enabled_integrations_without_generated_js_module() {
         let mut settings = crate::test_support::tests::create_test_settings();
@@ -2228,23 +2992,26 @@ mod tests {
             .insert_config("osano", &serde_json::json!({ "enabled": true }))
             .expect("should insert osano config");
 
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create registry");
-        let immediate = registry.js_module_ids_immediate();
+        let registry = IntegrationRegistry::new(&settings).expect("should create registry");
+        let selection = TsjsCatalogSelectionV1::default();
+        let takeover = registry.tsjs_takeover_module_ids(selection);
+        let deferred = registry.tsjs_deferred_module_ids(selection);
 
         assert!(
-            immediate.contains(&"sourcepoint"),
-            "should include Sourcepoint when explicitly enabled"
+            takeover.contains(&"sourcepoint_consent"),
+            "should include the Sourcepoint consent owner when explicitly enabled"
+        );
+        assert!(
+            takeover.contains(&"osano_consent"),
+            "should include the Osano consent owner when explicitly enabled"
+        );
+        assert!(
+            deferred.contains(&"sourcepoint_lifecycle"),
+            "should defer the Sourcepoint lifecycle owner"
         );
         assert!(
-            immediate.contains(&"osano"),
-            "should include Osano when explicitly enabled"
+            deferred.contains(&"osano_lifecycle"),
+            "should defer the Osano lifecycle owner"
         );
 
         let metadata = registry.registered_integrations();
@@ -2364,4 +3131,140 @@ mod tests {
             "should reconstruct full module list from immediate + deferred"
         );
     }
+
+    #[test]
+    fn registry_projects_every_enabled_product_once_without_private_server_fields() {
+        let mut settings = crate::test_support::tests::create_test_settings();
+        for (id, config) in [
+            (
+                "aps",
+                serde_json::json!({
+                    "enabled": true
+                }),
+            ),
+            (
+                "datadome",
+                serde_json::json!({
+                    "enabled": true,
+                    "server_side_key_secret_store": "private-datadome-store",
+                    "server_side_key_secret_name": "private-datadome-key"
+                }),
+            ),
+            ("didomi", serde_json::json!({ "enabled": true })),
+            (
+                "google_tag_manager",
+                serde_json::json!({
+                    "enabled": true,
+                    "container_id": "GTM-TEST"
+                }),
+            ),
+            (
+                "gpt",
+                serde_json::json!({
+                    "enabled": true,
+                    "gam_attribution_enabled": true,
+                    "script_url": "https://securepubads.g.doubleclick.net/tag/js/gpt.js",
+                    "slim_prebid_url": "https://private-prebid.example/slim.js"
+                }),
+            ),
+            (
+                "lockr",
+                serde_json::json!({ "enabled": true, "app_id": "private-lockr-app" }),
+            ),
+            ("osano", serde_json::json!({ "enabled": true })),
+            (
+                "permutive",
+                serde_json::json!({
+                    "enabled": true,
+                    "organization_id": "private-org",
+                    "workspace_id": "private-workspace"
+                }),
+            ),
+            (
+                "prebid",
+                serde_json::json!({
+                    "enabled": true,
+                    "account_id": "browser-account",
+                    "external_bundle_url": "https://assets.example/prebid/trusted-prebid.js"
+                }),
+            ),
+            (
+                "sourcepoint",
+                serde_json::json!({
+                    "enabled": true,
+                    "auth_cookie_name": "private_sourcepoint_cookie"
+                }),
+            ),
+            (
+                "testlight",
+                serde_json::json!({
+                    "enabled": true,
+                    "endpoint": "https://private-testlight.example/bid"
+                }),
+            ),
+        ] {
+            settings
+                .integrations
+                .insert_config(id, &config)
+                .expect("test integration config should insert");
+        }
+
+        let plan = crate::auction::AuctionPlan::compile(crate::auction::plan::AuctionPlanConfig {
+            timeout_ms: 1_000,
+            providers: BTreeMap::from([(
+                "aps-private".parse().expect("should parse APS provider ID"),
+                crate::auction::plan::ProviderConfig {
+                    protocol: "openrtb-2.6".to_string(),
+                    profile: "aps".to_string(),
+                    endpoint: "https://private-aps.example/bid".to_string(),
+                    timeout_ms: None,
+                    routing: crate::auction::plan::RoutingMode::AllEligible,
+                    notifications: crate::auction::plan::NotificationConfig::default(),
+                    profile_config: serde_json::json!({
+                        "account_id": "private-aps-account"
+                    }),
+                },
+            )]),
+            ..crate::auction::plan::AuctionPlanConfig::default()
+        })
+        .expect("should compile browser projection plan");
+        let registry = IntegrationRegistry::with_plan(&settings, Arc::new(plan))
+            .expect("registry should build");
+        let module_ids = registry.tsjs_catalog_module_ids(TsjsCatalogSelectionV1::default());
+        let carrier = registry
+            .tsjs_integration_configs_v1(&module_ids)
+            .expect("selected product configs should match the generated catalog");
+        let value = serde_json::to_value(carrier).expect("carrier should serialize");
+        let ids = value["entries"]
+            .as_array()
+            .expect("carrier entries should be an array")
+            .iter()
+            .map(|entry| entry["id"].as_str().expect("entry id should be a string"))
+            .collect::<Vec<_>>();
+
+        assert_eq!(ids, crate::tsjs::INTEGRATION_CONFIG_IDS_V1);
+        let serialized = value.to_string();
+        for private_value in [
+            "private-aps-account",
+            "private-aps.example",
+            "private-datadome-store",
+            "private-datadome-key",
+            "private-prebid.example",
+            "private-lockr-app",
+            "private-org",
+            "private-workspace",
+            "private_sourcepoint_cookie",
+            "private-testlight.example",
+        ] {
+            assert!(
+                !serialized.contains(private_value),
+                "private server field leaked into browser carrier: {private_value}"
+            );
+        }
+        assert_eq!(
+            value["entries"][0]["config"],
+            serde_json::json!({}),
+            "enabled APS must emit its required empty browser config"
+        );
+    }
 }
diff --git a/crates/trusted-server-core/src/integrations/sourcepoint.rs b/crates/trusted-server-core/src/integrations/sourcepoint.rs
index 7b2e49fb0..17fc4ba90 100644
--- a/crates/trusted-server-core/src/integrations/sourcepoint.rs
+++ b/crates/trusted-server-core/src/integrations/sourcepoint.rs
@@ -28,16 +28,15 @@ use error_stack::{Report, ResultExt};
 use http::header::{self, HeaderValue};
 use http::{Method, Request, Response, StatusCode};
 use regex::Regex;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use url::Url;
 use validator::{Validate, ValidationError};
 
 use crate::error::TrustedServerError;
 use crate::integrations::{
     AttributeRewriteAction, INTEGRATION_MAX_BODY_BYTES, IntegrationAttributeContext,
-    IntegrationAttributeRewriter, IntegrationEndpoint, IntegrationHeadInjector,
-    IntegrationHtmlContext, IntegrationProxy, IntegrationRegistration, collect_body_bounded,
-    collect_response_bounded, ensure_integration_backend,
+    IntegrationAttributeRewriter, IntegrationEndpoint, IntegrationProxy, IntegrationRegistration,
+    collect_body_bounded, collect_response_bounded, ensure_integration_backend,
 };
 use crate::platform::{PlatformHttpRequest, RuntimeServices};
 use crate::settings::{IntegrationConfig, Settings};
@@ -770,11 +769,20 @@ pub fn register(
         return Ok(None);
     };
 
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct SourcepointBrowserConfigV1 {
+        rewrite_sdk: bool,
+    }
+    let browser_config = SourcepointBrowserConfigV1 {
+        rewrite_sdk: integration.config.rewrite_sdk,
+    };
+
     Ok(Some(
         IntegrationRegistration::builder(SOURCEPOINT_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration.clone())
-            .with_head_injector(integration)
+            .with_browser_config_v1(&browser_config)?
             .build(),
     ))
 }
@@ -1013,79 +1021,10 @@ impl IntegrationAttributeRewriter for SourcepointIntegration {
     }
 }
 
-impl IntegrationHeadInjector for SourcepointIntegration {
-    fn integration_id(&self) -> &'static str {
-        SOURCEPOINT_INTEGRATION_ID
-    }
-
-    fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        let mut inserts = vec![format!(
-            "<script>window.__tsjs_sourcepoint={{\"rewriteSdk\":{}}};</script>",
-            self.config.rewrite_sdk
-        )];
-
-        if !self.config.rewrite_sdk {
-            return inserts;
-        }
-
-        // Install a property trap on `window._sp_` so that when the
-        // publisher's code (typically a Next.js hydration chunk) sets the
-        // Sourcepoint config object, we intercept it and rewrite any
-        // `cdn.privacy-mgmt.com` URLs to the first-party proxy prefix.
-        //
-        // The trap is transparent: the getter returns the (patched) value and
-        // the setter accepts any shape the SDK expects.  We also handle the
-        // case where `window._sp_` is already set before our script runs.
-        //
-        // Limitations:
-        // - Only intercepts top-level assignment (`window._sp_ = …`).  Nested
-        //   mutation like `window._sp_.config.baseEndpoint = "…"` after the
-        //   initial assignment is not caught.  The JS body regex rewriter
-        //   covers that case for string literals in bundled code.
-        // - `s.replace()` replaces only the first occurrence per call, which
-        //   is fine for the current set of scalar URL config fields.
-        inserts.push(format!(
-            concat!(
-                "<script>",
-                "(function(){{try{{",
-                "var C=\"{cdn_host}\";",
-                "var P=\"{cdn_prefix}\";",
-                "function r(s){{",
-                "if(typeof s!==\"string\")return s;",
-                "return s.replace(\"https://\"+C,P).replace(\"http://\"+C,P).replace(\"//\"+C,P)",
-                "}}",
-                "function p(o){{",
-                "if(!o||typeof o!==\"object\")return o;",
-                "if(o.config){{",
-                "if(typeof o.config.baseEndpoint===\"string\")o.config.baseEndpoint=r(o.config.baseEndpoint);",
-                "if(typeof o.config.mmsDomain===\"string\")o.config.mmsDomain=r(o.config.mmsDomain);",
-                "if(typeof o.config.wrapperAPIOrigin===\"string\")o.config.wrapperAPIOrigin=r(o.config.wrapperAPIOrigin);",
-                "if(typeof o.config.cmpOrigin===\"string\")o.config.cmpOrigin=r(o.config.cmpOrigin);",
-                "}}",
-                "if(typeof o.metricUrl===\"string\")o.metricUrl=r(o.metricUrl);",
-                "return o",
-                "}}",
-                "var v=window._sp_?p(window._sp_):undefined;",
-                "Object.defineProperty(window,\"_sp_\",{{",
-                "configurable:true,",
-                "get:function(){{return v}},",
-                "set:function(n){{v=p(n)}}",
-                "}});",
-                "}}catch(e){{if(window.console&&console.warn)console.warn(\"Sourcepoint: failed to install runtime config rewrite trap\",e)}}}})();",
-                "</script>",
-            ),
-            cdn_host = SOURCEPOINT_CDN_HOST,
-            cdn_prefix = SOURCEPOINT_CDN_PREFIX,
-        ));
-
-        inserts
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::integrations::{IntegrationDocumentState, IntegrationRegistry};
+    use crate::integrations::IntegrationRegistry;
     use crate::test_support::tests::create_test_settings;
     use serde_json::json;
 
@@ -1451,92 +1390,43 @@ mod tests {
     }
 
     #[test]
-    fn head_injector_emits_config_script_plus_trap_when_enabled() {
-        let integration = SourcepointIntegration::new(Arc::new(config(true)));
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "ts.example.com",
-            request_scheme: "https",
-            origin_host: "origin.example.com",
-            document_state: &document_state,
-        };
+    fn registration_projects_rewrite_enabled_without_a_config_script() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                SOURCEPOINT_INTEGRATION_ID,
+                &json!({ "enabled": true, "rewrite_sdk": true }),
+            )
+            .expect("should insert Sourcepoint config");
+        let registration = register(&settings)
+            .expect("config should parse")
+            .expect("Sourcepoint should register");
 
-        let inserts = integration.head_inserts(&ctx);
+        assert!(registration.head_injectors.is_empty());
         assert_eq!(
-            inserts.len(),
-            2,
-            "should emit config plus trap script when enabled"
-        );
-
-        let config_script = &inserts[0];
-        assert!(
-            config_script.contains("window.__tsjs_sourcepoint={\"rewriteSdk\":true}"),
-            "should emit rewrite SDK config script: {config_script}"
-        );
-
-        let trap_script = &inserts[1];
-        assert!(
-            trap_script.starts_with("<script>") && trap_script.ends_with("</script>"),
-            "should be wrapped in script tags: {trap_script}",
-        );
-        assert!(
-            trap_script.contains("cdn.privacy-mgmt.com"),
-            "should reference the CDN host to rewrite: {trap_script}",
-        );
-        assert!(
-            trap_script.contains("/integrations/sourcepoint/cdn"),
-            "should contain the first-party CDN prefix: {trap_script}",
-        );
-        assert!(
-            trap_script.contains("try{") && trap_script.contains("catch(e)"),
-            "should guard best-effort trap installation: {trap_script}",
-        );
-        assert!(
-            trap_script.contains("console.warn"),
-            "should log trap installation failures for observability: {trap_script}",
-        );
-        assert!(
-            trap_script.contains("Object.defineProperty"),
-            "should install a property trap on window._sp_: {trap_script}",
-        );
-        for config_field in ["baseEndpoint", "mmsDomain", "wrapperAPIOrigin", "cmpOrigin"] {
-            assert!(
-                trap_script.contains(&format!("o.config.{config_field}")),
-                "should patch config field {config_field}: {trap_script}",
-            );
-        }
-        assert!(
-            trap_script.contains("o.metricUrl"),
-            "should patch top-level metricUrl: {trap_script}",
+            registration.browser_config_v1,
+            Some(json!({ "rewriteSdk": true }))
         );
     }
 
     #[test]
-    fn head_injector_returns_config_when_rewrite_disabled() {
-        let mut cfg = config(true);
-        cfg.rewrite_sdk = false;
-        let integration = SourcepointIntegration::new(Arc::new(cfg));
-        let document_state = IntegrationDocumentState::default();
-        let ctx = IntegrationHtmlContext {
-            request_host: "ts.prospecta.com",
-            request_scheme: "https",
-            origin_host: "origin.prospecta.com",
-            document_state: &document_state,
-        };
+    fn registration_projects_rewrite_disabled() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                SOURCEPOINT_INTEGRATION_ID,
+                &json!({ "enabled": true, "rewrite_sdk": false }),
+            )
+            .expect("should insert Sourcepoint config");
+        let registration = register(&settings)
+            .expect("config should parse")
+            .expect("Sourcepoint should register");
 
-        let inserts = integration.head_inserts(&ctx);
         assert_eq!(
-            inserts.len(),
-            1,
-            "should emit only config script when rewrite_sdk is false"
-        );
-        assert!(
-            inserts[0].contains("window.__tsjs_sourcepoint={\"rewriteSdk\":false}"),
-            "should flag rewriteSdk false"
-        );
-        assert!(
-            !inserts[0].contains("Object.defineProperty"),
-            "should not emit runtime trap when rewrite_sdk is disabled"
+            registration.browser_config_v1,
+            Some(json!({ "rewriteSdk": false }))
         );
     }
 
diff --git a/crates/trusted-server-core/src/integrations/testlight.rs b/crates/trusted-server-core/src/integrations/testlight.rs
index 80b2c4dfa..c1760cb48 100644
--- a/crates/trusted-server-core/src/integrations/testlight.rs
+++ b/crates/trusted-server-core/src/integrations/testlight.rs
@@ -158,6 +158,7 @@ pub fn register(
         IntegrationRegistration::builder(TESTLIGHT_INTEGRATION_ID)
             .with_proxy(integration.clone())
             .with_attribute_rewriter(integration)
+            .with_empty_browser_config_v1()?
             .build(),
     ))
 }
diff --git a/crates/trusted-server-core/src/lib.rs b/crates/trusted-server-core/src/lib.rs
index 76621baf7..437056e30 100644
--- a/crates/trusted-server-core/src/lib.rs
+++ b/crates/trusted-server-core/src/lib.rs
@@ -72,6 +72,7 @@ pub mod streaming_processor;
 pub mod streaming_replacer;
 pub mod test_support;
 pub mod tester_cookie;
+pub mod trace_cookie;
 pub mod tsjs;
 
 #[cfg(test)]
diff --git a/crates/trusted-server-core/src/openrtb.rs b/crates/trusted-server-core/src/openrtb.rs
index 4aded7488..c27a5c988 100644
--- a/crates/trusted-server-core/src/openrtb.rs
+++ b/crates/trusted-server-core/src/openrtb.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::auction::types::{BidRenderer, OrchestratorExt};
+use crate::auction::types::{BidRenderSourceV1, OrchestratorExt};
 
 pub type OpenRtbRequest = trusted_server_openrtb::BidRequest;
 pub type OpenRtbResponse = trusted_server_openrtb::BidResponse;
@@ -180,7 +180,7 @@ impl ToExt for BidExt<'_> {}
 
 #[derive(Debug, Serialize)]
 pub struct BidTrustedServerExt<'a> {
-    pub renderer: &'a BidRenderer,
+    pub renderer: &'a BidRenderSourceV1,
 }
 
 #[derive(Debug, Serialize)]
diff --git a/crates/trusted-server-core/src/platform/http.rs b/crates/trusted-server-core/src/platform/http.rs
index 039df014c..730211526 100644
--- a/crates/trusted-server-core/src/platform/http.rs
+++ b/crates/trusted-server-core/src/platform/http.rs
@@ -1,5 +1,6 @@
 use std::any::Any;
 use std::fmt;
+use std::time::Duration;
 
 use edgezero_core::http::{Request as EdgeRequest, Response as EdgeResponse};
 use error_stack::Report;
@@ -7,6 +8,64 @@ use error_stack::Report;
 use super::PlatformError;
 use super::image_optimizer::PlatformImageOptimizerOptions;
 
+/// Raw evidence for one security-relevant upstream response header.
+///
+/// Values are never split or normalized. A runtime that preserves duplicate
+/// fields returns every occurrence; a runtime that visibly combines fields
+/// returns that exact combined byte string; erased evidence is unavailable.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ProxyHeaderEvidenceV1 {
+    /// Every raw header occurrence, including an empty vector for known absence.
+    Occurrences(Vec<Vec<u8>>),
+    /// One exact runtime-combined value. Core must not split it.
+    Combined(Vec<u8>),
+    /// The runtime erased or ambiguously transformed the evidence.
+    Unavailable,
+}
+
+impl ProxyHeaderEvidenceV1 {
+    /// Known absence of the header.
+    #[must_use]
+    pub fn absent() -> Self {
+        Self::Occurrences(Vec::new())
+    }
+
+    /// One preserved raw header occurrence.
+    #[must_use]
+    pub fn one(value: impl Into<Vec<u8>>) -> Self {
+        Self::Occurrences(vec![value.into()])
+    }
+}
+
+/// Status and raw security-header evidence captured before adapter normalization.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProxyResponseEvidenceV1 {
+    pub status: u16,
+    pub content_type: ProxyHeaderEvidenceV1,
+    pub content_encoding: ProxyHeaderEvidenceV1,
+    pub content_length: ProxyHeaderEvidenceV1,
+}
+
+/// Dedicated bounded raw-proxy transport policy.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RawProxyPolicyV1 {
+    /// Monotonic deadline covering dispatch through the final body byte.
+    pub total_timeout: Duration,
+    /// Maximum time the transport may wait for response headers.
+    pub first_byte_timeout: Duration,
+    /// Maximum duration of one blocking response-body read.
+    pub blocking_read_timeout: Duration,
+    /// Maximum accepted identity-body bytes.
+    pub max_response_bytes: usize,
+}
+
+/// Byte-preserving response produced by the dedicated raw-proxy transport.
+#[derive(Debug)]
+pub struct RawProxyResponseV1 {
+    pub evidence: ProxyResponseEvidenceV1,
+    pub body: Vec<u8>,
+}
+
 /// Outbound HTTP request paired with a pre-resolved backend name.
 ///
 /// Uses `EdgeZero`'s neutral [`EdgeRequest`] type so adapters share one
@@ -266,6 +325,21 @@ pub trait PlatformHttpClient: Send + Sync {
         request: PlatformHttpRequest,
     ) -> Result<PlatformResponse, Report<PlatformError>>;
 
+    /// Send one response-evidence-preserving, byte-bounded raw proxy request.
+    ///
+    /// Adapters must disable redirects and transformations, capture the three
+    /// evidence headers before generic normalization, enforce the total
+    /// monotonic deadline and byte cap, and cancel/drop in-flight resources on
+    /// failure. The default fails closed for platforms without that contract.
+    async fn send_raw_proxy_v1(
+        &self,
+        _request: PlatformHttpRequest,
+        _policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        Err(Report::new(PlatformError::Unsupported)
+            .attach("bounded raw-proxy transport is unavailable on this platform"))
+    }
+
     /// Start an upstream request without waiting for it to complete.
     ///
     /// # Errors
diff --git a/crates/trusted-server-core/src/platform/mod.rs b/crates/trusted-server-core/src/platform/mod.rs
index d09f9b549..59be9bc3f 100644
--- a/crates/trusted-server-core/src/platform/mod.rs
+++ b/crates/trusted-server-core/src/platform/mod.rs
@@ -54,7 +54,8 @@ pub use edgezero_core::key_value_store::{KvError, KvHandle, KvStore as PlatformK
 pub use error::PlatformError;
 pub use http::{
     PlatformHttpClient, PlatformHttpRequest, PlatformPendingRequest, PlatformResponse,
-    PlatformSelectResult, UnavailableHttpClient,
+    PlatformSelectResult, ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1,
+    RawProxyResponseV1, UnavailableHttpClient,
 };
 pub use image_optimizer::{
     PlatformImageOptimizerCrop, PlatformImageOptimizerCropMode, PlatformImageOptimizerOptions,
@@ -73,6 +74,7 @@ pub use template_cache::{
     VaryHeaderValues, VarySpec,
 };
 pub use traits::{PlatformBackend, PlatformConfigStore, PlatformGeo, PlatformSecretStore};
+pub use types::ExactResponseHeadersV1;
 pub use types::{
     ClientInfo, GeoInfo, PlatformBackendSpec, RuntimeServices, RuntimeServicesBuilder, StoreId,
     StoreName,
diff --git a/crates/trusted-server-core/src/platform/test_support.rs b/crates/trusted-server-core/src/platform/test_support.rs
index 856510c1d..eec394cc8 100644
--- a/crates/trusted-server-core/src/platform/test_support.rs
+++ b/crates/trusted-server-core/src/platform/test_support.rs
@@ -12,7 +12,8 @@ use super::{
     ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec, PlatformConfigStore, PlatformError,
     PlatformGeo, PlatformHttpClient, PlatformHttpRequest, PlatformImageOptimizerOptions,
     PlatformImageOptimizerParams, PlatformPendingRequest, PlatformResponse, PlatformSecretStore,
-    PlatformSelectResult, RuntimeServices, StoreId, StoreName,
+    PlatformSelectResult, RawProxyPolicyV1, RawProxyResponseV1, RuntimeServices, StoreId,
+    StoreName,
 };
 use crate::request_signing::{JWKS_STORE_NAME, SIGNING_STORE_NAME};
 
@@ -254,6 +255,8 @@ pub(crate) struct StubHttpClient {
     request_uris: Mutex<Vec<String>>,
     // Outgoing request bodies captured per send call, collected to bytes.
     request_bodies: Mutex<Vec<Vec<u8>>>,
+    raw_proxy_responses: Mutex<VecDeque<RawProxyResponseV1>>,
+    raw_proxy_policies: Mutex<Vec<RawProxyPolicyV1>>,
 }
 
 struct StubHttpResponse {
@@ -281,6 +284,8 @@ impl StubHttpClient {
             request_methods: Mutex::new(Vec::new()),
             request_uris: Mutex::new(Vec::new()),
             request_bodies: Mutex::new(Vec::new()),
+            raw_proxy_responses: Mutex::new(VecDeque::new()),
+            raw_proxy_policies: Mutex::new(Vec::new()),
         }
     }
 
@@ -328,6 +333,22 @@ impl StubHttpClient {
             });
     }
 
+    /// Queue one response for the dedicated raw-proxy transport boundary.
+    pub fn push_raw_proxy_response(&self, response: RawProxyResponseV1) {
+        self.raw_proxy_responses
+            .lock()
+            .expect("should lock raw proxy responses")
+            .push_back(response);
+    }
+
+    /// Return raw-proxy policies captured per dedicated send.
+    pub fn recorded_raw_proxy_policies(&self) -> Vec<RawProxyPolicyV1> {
+        self.raw_proxy_policies
+            .lock()
+            .expect("should lock raw proxy policies")
+            .clone()
+    }
+
     /// Inject a `select()` error: the next call to `select()` will return
     /// `ready: Err(...)` with the failed request's backend name in
     /// `failed_backend_name`. The corresponding queued response is consumed.
@@ -551,6 +572,77 @@ impl PlatformHttpClient for StubHttpClient {
         Ok(PlatformResponse::new(edge_response))
     }
 
+    async fn send_raw_proxy_v1(
+        &self,
+        request: PlatformHttpRequest,
+        policy: RawProxyPolicyV1,
+    ) -> Result<RawProxyResponseV1, Report<PlatformError>> {
+        if request.image_optimizer.is_some() || request.stream_response {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("unsupported option on StubHttpClient raw proxy request"));
+        }
+
+        self.calls
+            .lock()
+            .expect("should lock calls")
+            .push(request.backend_name.clone());
+        self.raw_proxy_policies
+            .lock()
+            .expect("should lock raw proxy policies")
+            .push(policy);
+        self.cache_bypass_flags
+            .lock()
+            .expect("should lock cache bypass flags")
+            .push(request.bypass_cache);
+        self.request_methods
+            .lock()
+            .expect("should lock request methods")
+            .push(request.request.method().to_string());
+        self.request_uris
+            .lock()
+            .expect("should lock request URIs")
+            .push(request.request.uri().to_string());
+        self.request_headers
+            .lock()
+            .expect("should lock request headers")
+            .push(
+                request
+                    .request
+                    .headers()
+                    .iter()
+                    .map(|(name, value)| {
+                        (
+                            name.as_str().to_string(),
+                            String::from_utf8_lossy(value.as_bytes()).into_owned(),
+                        )
+                    })
+                    .collect(),
+            );
+
+        let (_, body) = request.request.into_parts();
+        let body = body
+            .into_bytes_bounded(MAX_RECORDED_BODY_BYTES)
+            .await
+            .change_context(PlatformError::HttpClient)?
+            .to_vec();
+        self.request_bodies
+            .lock()
+            .expect("should lock request bodies")
+            .push(body);
+
+        let response = self
+            .raw_proxy_responses
+            .lock()
+            .expect("should lock raw proxy responses")
+            .pop_front()
+            .ok_or_else(|| Report::new(PlatformError::HttpClient))?;
+        if response.body.len() > policy.max_response_bytes {
+            return Err(Report::new(PlatformError::HttpClient)
+                .attach("stub raw proxy body exceeds configured cap"));
+        }
+        Ok(response)
+    }
+
     async fn send_async(
         &self,
         request: PlatformHttpRequest,
@@ -752,25 +844,6 @@ pub(crate) fn build_services_with_config_and_secret(
         .build()
 }
 
-pub(crate) fn build_services_with_config_and_secret_and_client_ip(
-    config_store: impl PlatformConfigStore + 'static,
-    secret_store: impl PlatformSecretStore + 'static,
-    client_ip: IpAddr,
-) -> RuntimeServices {
-    RuntimeServices::builder()
-        .config_store(Arc::new(config_store))
-        .secret_store(Arc::new(secret_store))
-        .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
-        .backend(Arc::new(NoopBackend))
-        .http_client(Arc::new(NoopHttpClient))
-        .geo(Arc::new(NoopGeo))
-        .client_info(ClientInfo {
-            client_ip: Some(client_ip),
-            ..ClientInfo::default()
-        })
-        .build()
-}
-
 pub(crate) fn build_request_signing_services() -> RuntimeServices {
     let signing_key = SigningKey::generate(&mut OsRng);
     let key_b64 = general_purpose::STANDARD.encode(signing_key.as_bytes());
@@ -805,6 +878,27 @@ pub(crate) fn build_services_with_config(
         .build()
 }
 
+/// Build test services with caller-supplied configuration and secrets plus an
+/// attested client IP.
+pub(crate) fn build_services_with_config_and_secret_and_client_ip(
+    config_store: impl PlatformConfigStore + 'static,
+    secret_store: impl PlatformSecretStore + 'static,
+    client_ip: IpAddr,
+) -> RuntimeServices {
+    RuntimeServices::builder()
+        .config_store(Arc::new(config_store))
+        .secret_store(Arc::new(secret_store))
+        .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
+        .backend(Arc::new(NoopBackend))
+        .http_client(Arc::new(NoopHttpClient))
+        .geo(Arc::new(NoopGeo))
+        .client_info(ClientInfo {
+            client_ip: Some(client_ip),
+            ..ClientInfo::default()
+        })
+        .build()
+}
+
 pub(crate) fn noop_services() -> RuntimeServices {
     build_services_with_config(NoopConfigStore)
 }
diff --git a/crates/trusted-server-core/src/platform/types.rs b/crates/trusted-server-core/src/platform/types.rs
index 7a3d09334..d7d25c1fa 100644
--- a/crates/trusted-server-core/src/platform/types.rs
+++ b/crates/trusted-server-core/src/platform/types.rs
@@ -10,6 +10,15 @@ use super::{
     PlatformSecretStore,
 };
 
+/// Response-extension marker for routes whose security contract owns the
+/// complete application-header set.
+///
+/// Adapter finalizers must not append geo, deployment, or operator-configured
+/// headers to a marked response. HTTP runtimes may still add transport framing
+/// such as `Content-Length`.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ExactResponseHeadersV1;
+
 /// Geographic information extracted from a request.
 ///
 /// Serde derives are required because `GeoInfo` is embedded in
diff --git a/crates/trusted-server-core/src/proxy.rs b/crates/trusted-server-core/src/proxy.rs
index 122e4c832..4b2aa5f76 100644
--- a/crates/trusted-server-core/src/proxy.rs
+++ b/crates/trusted-server-core/src/proxy.rs
@@ -341,6 +341,8 @@ pub struct ProxyRequestConfig<'a> {
     pub copy_request_headers: bool,
     /// When true, stream the origin response without HTML/CSS rewrites.
     pub stream_passthrough: bool,
+    /// Whether every outbound hop must bypass the platform response cache.
+    pub bypass_cache: bool,
     /// Domains allowed for the initial request and any redirects.
     ///
     /// **Open mode** (`&[]`): every host is permitted. Most integration proxies pass
@@ -369,6 +371,7 @@ impl<'a> ProxyRequestConfig<'a> {
             headers: Vec::new(),
             copy_request_headers: true,
             stream_passthrough: false,
+            bypass_cache: false,
             allowed_domains: &[],
             require_https: false,
         }
@@ -402,6 +405,13 @@ impl<'a> ProxyRequestConfig<'a> {
         self
     }
 
+    /// Bypass the platform response cache for the initial request and redirects.
+    #[must_use]
+    pub fn with_cache_bypass(mut self) -> Self {
+        self.bypass_cache = true;
+        self
+    }
+
     /// Disable EC ID query-param forwarding to the target URL.
     #[must_use]
     pub fn without_ec_id(mut self) -> Self {
@@ -733,6 +743,7 @@ struct ProxyRequestHeaders<'a> {
 struct ProxyRedirectPolicy<'a> {
     follow_redirects: bool,
     stream_passthrough: bool,
+    bypass_cache: bool,
     allowed_domains: &'a [String],
     require_https: bool,
 }
@@ -761,6 +772,7 @@ pub async fn proxy_request(
         headers,
         copy_request_headers,
         stream_passthrough,
+        bypass_cache,
         allowed_domains,
         require_https,
     } = config;
@@ -788,6 +800,7 @@ pub async fn proxy_request(
         ProxyRedirectPolicy {
             follow_redirects,
             stream_passthrough,
+            bypass_cache,
             allowed_domains,
             require_https,
         },
@@ -1329,10 +1342,14 @@ async fn proxy_with_redirects(
                     message: "failed to build proxy request".to_string(),
                 })?;
 
+        let mut platform_request = PlatformHttpRequest::new(edge_req, backend_name);
+        if redirect_policy.bypass_cache {
+            platform_request = platform_request.with_cache_bypass();
+        }
         let platform_resp = request_headers
             .services
             .http_client()
-            .send(PlatformHttpRequest::new(edge_req, backend_name))
+            .send(platform_request)
             .await
             .change_context(TrustedServerError::Proxy {
                 message: "Failed to proxy".to_string(),
@@ -1490,6 +1507,7 @@ pub async fn handle_first_party_proxy(
             headers: Vec::new(),
             copy_request_headers: true,
             stream_passthrough: false,
+            bypass_cache: false,
             allowed_domains: &settings.proxy.allowed_domains,
             require_https: false,
         },
@@ -3843,6 +3861,7 @@ mod tests {
                     headers: Vec::new(),
                     copy_request_headers: false,
                     stream_passthrough: false,
+                    bypass_cache: false,
                     allowed_domains: &[],
                     require_https: false,
                 },
@@ -3884,6 +3903,7 @@ mod tests {
                     headers: Vec::new(),
                     copy_request_headers: false,
                     stream_passthrough: false,
+                    bypass_cache: false,
                     allowed_domains: &[],
                     require_https: false,
                 },
@@ -3930,6 +3950,7 @@ mod tests {
                     headers: Vec::new(),
                     copy_request_headers: false,
                     stream_passthrough: false,
+                    bypass_cache: false,
                     allowed_domains: &[],
                     require_https: false,
                 },
@@ -3979,6 +4000,7 @@ mod tests {
                     headers: Vec::new(),
                     copy_request_headers: true,
                     stream_passthrough: false,
+                    bypass_cache: false,
                     allowed_domains: &[],
                     require_https: false,
                 },
@@ -4044,6 +4066,7 @@ mod tests {
                     headers: Vec::new(),
                     copy_request_headers: false,
                     stream_passthrough: false,
+                    bypass_cache: false,
                     allowed_domains: &[],
                     require_https: false,
                 },
diff --git a/crates/trusted-server-core/src/publisher.rs b/crates/trusted-server-core/src/publisher.rs
index 9525820ce..1f41faec7 100644
--- a/crates/trusted-server-core/src/publisher.rs
+++ b/crates/trusted-server-core/src/publisher.rs
@@ -10,6 +10,9 @@
 //! streaming processor treats unknown encodings as identity, so publisher code
 //! must gate them out before the body enters the rewrite pipeline.
 //!
+//! `BootManifestV1` serialization remains a pure helper in Task 8. This
+//! production pipeline does not emit it until the coordinated Task 19 switch.
+//!
 //! **Note on platform coupling:** The handler boundaries use portable HTTP
 //! types: [`handle_publisher_request`] and [`stream_publisher_body`] take and
 //! return `http::Request`/`http::Response` over `EdgeBody`, and platform I/O is
@@ -19,37 +22,39 @@
 //! the streaming route). It is not a content-rewriting concern.
 
 use std::borrow::Cow;
+use std::collections::{BTreeMap, HashSet};
 use std::io::Write;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant, SystemTime};
 
-use brotli::Decompressor;
-use brotli::enc::BrotliEncoderParams;
-use brotli::enc::writer::CompressorWriter;
 use cookie::CookieJar;
 use edgezero_core::body::Body as EdgeBody;
 use error_stack::{Report, ResultExt};
-use flate2::read::ZlibDecoder;
-use flate2::write::{GzEncoder, ZlibEncoder};
 use futures::StreamExt as _;
 use http::{HeaderValue, Method, Request, Response, StatusCode, Uri, header};
 
 use crate::auction::endpoints::{
     merge_auction_eids, resolve_auction_eids, resolve_client_auction_eids,
 };
-use crate::auction::formats::sanitize_publisher_page_url;
+use crate::auction::formats::{
+    coordinated_cutover_v1::CanonicalBrowserAuctionProjectionV1, sanitize_publisher_page_url,
+};
 use crate::auction::orchestrator::{
-    AuctionOrchestrator, DispatchAuctionOutcome, DispatchedAuction, ERROR_TYPE_ALL,
-    ERROR_TYPE_HTTP_STATUS, ERROR_TYPE_LAUNCH_FAILED, ERROR_TYPE_PARSE_RESPONSE,
-    ERROR_TYPE_TIMEOUT, ERROR_TYPE_TRANSPORT,
+    AuctionOrchestrator, DispatchedAuction, ERROR_TYPE_ALL, ERROR_TYPE_HTTP_STATUS,
+    ERROR_TYPE_LAUNCH_FAILED, ERROR_TYPE_PARSE_RESPONSE, ERROR_TYPE_TIMEOUT, ERROR_TYPE_TRANSPORT,
+    OrchestrationResult, ResolvedDispatchOutcome,
 };
 use crate::auction::telemetry::{
     AuctionObservationContext, AuctionSource, AuctionTerminalOutcome, build_auction_events,
     emit_auction_events_best_effort_lazy,
 };
 use crate::auction::types::{
-    AuctionContext, AuctionRequest, Bid, DeviceInfo, PublisherInfo, SiteInfo, UserInfo,
+    AdmRenderSourceV1, AuctionContext, AuctionDecisionSetV1, AuctionDropReasons,
+    AuctionIdentityGenerator, AuctionRequest, AuctionSlotFailureReason, BaselinePbsCacheSourceV1,
+    Bid, BidRenderSourceV1, BrowserAuctionBidV1, BrowserAuctionProjectionV1, BrowserAuctionSlotV1,
+    DeviceInfo, PublisherInfo, SiteInfo, SlotAuctionDecisionV1, SystemAuctionIdentityGenerator,
+    UserInfo, mint_response_unique_base64url_identity,
 };
 use crate::cache_policy::{
     CachePolicy, EdgeCacheHeader, cache_control_headers_are_private_or_no_store,
@@ -57,10 +62,7 @@ use crate::cache_policy::{
 use crate::consent::{consent_allows_server_side_auction, gate_eids_by_consent};
 use crate::constants::{COOKIE_TS_EIDS, HEADER_X_COMPRESS_HINT};
 use crate::cookies::handle_request_cookies;
-use crate::creative_opportunities::{
-    AdStackGateInput, AssemblyMode, CreativeOpportunitiesConfig, RuntimeAdStackExpected,
-    evaluate_ad_stack_gate,
-};
+use crate::creative_opportunities::{AssemblyMode, CreativeOpportunitiesConfig};
 use crate::ec::EcContext;
 use crate::ec::kv::KvIdentityGraph;
 use crate::ec::registry::PartnerRegistry;
@@ -83,8 +85,8 @@ use crate::settings::{
     AuctionDebugCommentFormat, AuctionDebugCommentOptions, AuctionDebugCommentVerbosity, Settings,
 };
 use crate::streaming_processor::{
-    BodyStreamDecoder, BodyStreamEncoder, Compression, GzipDecodeReader, PipelineConfig,
-    STREAM_CHUNK_SIZE, StreamProcessor, StreamingPipeline,
+    BodyStreamDecoder, BodyStreamEncoder, Compression, PipelineConfig, STREAM_CHUNK_SIZE,
+    StreamProcessor, StreamingPipeline,
 };
 use crate::streaming_replacer::create_url_replacer;
 
@@ -92,6 +94,30 @@ const SUPPORTED_ENCODING_VALUES: [&str; 3] = ["gzip", "deflate", "br"];
 const DEFAULT_PUBLISHER_FIRST_BYTE_TIMEOUT: Duration = Duration::from_secs(15);
 const HEADER_X_TS_TEMPLATE_CACHE: &str = "x-ts-template-cache";
 const HEADER_X_TS_ASSEMBLY: &str = "x-ts-assembly";
+const APS_PUBLISHER_FRAME_POLICY: &str = "frame-ancestors 'self'";
+
+fn append_aps_publisher_frame_policy(response: &mut Response<EdgeBody>, aps_enabled: bool) {
+    if aps_enabled {
+        response.headers_mut().append(
+            header::CONTENT_SECURITY_POLICY,
+            HeaderValue::from_static(APS_PUBLISHER_FRAME_POLICY),
+        );
+    }
+}
+
+fn ensure_aps_publisher_frame_policy(response: &mut Response<EdgeBody>, aps_enabled: bool) {
+    if !aps_enabled {
+        return;
+    }
+    let already_present = response
+        .headers()
+        .get_all(header::CONTENT_SECURITY_POLICY)
+        .iter()
+        .any(|value| value.as_bytes() == APS_PUBLISHER_FRAME_POLICY.as_bytes());
+    if !already_present {
+        append_aps_publisher_frame_policy(response, true);
+    }
+}
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum TemplateCacheResponseState {
@@ -281,6 +307,14 @@ fn not_found_response() -> Response<EdgeBody> {
     response
 }
 
+fn tsjs_not_found_response() -> Response<EdgeBody> {
+    let mut response = not_found_response();
+    response
+        .headers_mut()
+        .insert(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+    response
+}
+
 fn restrict_accept_encoding(req: &mut Request<EdgeBody>) {
     // If the client sent no Accept-Encoding, leave the request unchanged so the
     // origin responds without compression. Adding encodings here would cause the
@@ -374,10 +408,9 @@ fn parse_quality_value(value: &str) -> Option<f32> {
     let (whole, fraction) = value
         .split_once('.')
         .map_or((value, None), |(whole, fraction)| (whole, Some(fraction)));
-    let fraction_is_valid = fraction.is_none_or(|fraction| {
-        fraction.len() <= 3 && fraction.bytes().all(|byte| byte.is_ascii_digit())
-    });
-    if !fraction_is_valid {
+    if fraction.is_some_and(|fraction| {
+        fraction.len() > 3 || !fraction.bytes().all(|byte| byte.is_ascii_digit())
+    }) {
         return None;
     }
     match whole {
@@ -441,11 +474,8 @@ fn negotiate_reader_compression(
     };
     let wildcard = explicit("*");
     let quality_for = |name: &str| explicit(name).or(wildcard).unwrap_or(0.0);
-    // Identity is implicitly acceptable at q=1 unless explicitly excluded, or a
-    // wildcard q=0 excludes every unlisted coding.
     let identity_quality =
         explicit("identity").unwrap_or_else(|| if wildcard == Some(0.0) { 0.0 } else { 1.0 });
-
     let candidates = [
         (Compression::Brotli, quality_for("br")),
         (Compression::Gzip, quality_for("gzip")),
@@ -515,13 +545,7 @@ fn encode_complete_body(
     Ok(encoded)
 }
 
-/// Unified tsjs static serving: `/static/tsjs=<filename>`
-///
-/// Serves two types of bundles:
-/// - **Unified bundle** (`tsjs-unified.min.js`): core + immediate (non-deferred)
-///   integration modules.
-/// - **Deferred module** (`tsjs-{id}.min.js`): a single self-contained IIFE for
-///   modules loaded with `defer` (e.g., prebid).
+/// Exact content-addressed TSJS release transport.
 ///
 /// # Errors
 ///
@@ -532,74 +556,151 @@ pub fn handle_tsjs_dynamic(
     edge_header: EdgeCacheHeader,
 ) -> Result<Response<EdgeBody>, Report<TrustedServerError>> {
     const PREFIX: &str = "/static/tsjs=";
-    const UNIFIED_FILENAMES: &[&str] = &["tsjs-unified.js", "tsjs-unified.min.js"];
 
     let path = req.uri().path();
-    if !path.starts_with(PREFIX) {
-        return Ok(not_found_response());
+    if (req.method() != Method::GET && req.method() != Method::HEAD) || !path.starts_with(PREFIX) {
+        return Ok(tsjs_not_found_response());
     }
     let filename = &path[PREFIX.len()..];
 
-    if UNIFIED_FILENAMES.contains(&filename) {
-        // Serve core + immediate modules (excludes deferred like prebid).
-        let module_ids = integration_registry.js_module_ids_immediate();
-        let body = trusted_server_js::concatenate_modules(&module_ids);
-        let hash = trusted_server_js::concatenated_hash(&module_ids);
-        return Ok(serve_tsjs_static(req, &body, &hash, edge_header));
+    if filename == "tsjs-first-display.min.js" {
+        let Some((mask, requested_hash)) = req
+            .uri()
+            .query()
+            .and_then(parse_first_display_artifact_query)
+        else {
+            return Ok(tsjs_not_found_response());
+        };
+        let Some(artifact) = integration_registry.tsjs_first_display_artifact(mask, requested_hash)
+        else {
+            return Ok(tsjs_not_found_response());
+        };
+        let mut resp = serve_precomputed_tsjs_artifact(artifact, req, edge_header);
+        strip_tsjs_head_body(&mut resp, req.method());
+        apply_tsjs_success_headers(&mut resp);
+        return Ok(resp);
+    }
+
+    let Some(requested_hash) = req.uri().query().and_then(parse_tsjs_hash_query) else {
+        return Ok(tsjs_not_found_response());
+    };
+
+    if filename == "tsjs-unified.min.js" {
+        let Some(artifact) = integration_registry.tsjs_static_artifact(requested_hash) else {
+            return Ok(tsjs_not_found_response());
+        };
+        let mut resp = serve_precomputed_tsjs_artifact(artifact, req, edge_header);
+        strip_tsjs_head_body(&mut resp, req.method());
+        apply_tsjs_success_headers(&mut resp);
+        return Ok(resp);
     }
 
     if let Some(module_id) = parse_single_module_filename(filename) {
-        // Deferred modules and the conditionally injected diagnostics module
-        // are served as content-addressed standalone assets. Delivery remains
-        // cookie-independent so the static response can stay publicly cached.
-        let deferred_ids = integration_registry.js_module_ids_deferred();
-        let diagnostics_standalone = module_id
-            == crate::integrations::gpt_diagnostics::GPT_DIAGNOSTICS_INTEGRATION_ID
-            && integration_registry.integration_enabled(module_id);
-        if !deferred_ids.contains(&module_id) && !diagnostics_standalone {
-            return Ok(not_found_response());
-        }
-        if let (Some(content), Some(hash)) = (
-            trusted_server_js::module_bundle(module_id),
-            trusted_server_js::single_module_hash(module_id),
-        ) {
-            return Ok(serve_tsjs_static(req, content, hash, edge_header));
+        let render_trace_overlay = crate::trace_cookie::render_trace_overlay_active(req);
+        let module_enabled = integration_registry
+            .tsjs_static_transport_selections(render_trace_overlay)
+            .into_iter()
+            .any(|selection| {
+                integration_registry
+                    .tsjs_deferred_module_ids(selection)
+                    .contains(&module_id)
+            });
+        if module_enabled
+            && trusted_server_js::single_module_hash(module_id).as_deref() == Some(requested_hash)
+            && let Some(content) = trusted_server_js::module_bundle(module_id)
+        {
+            let mut resp = serve_static_with_etag(
+                content,
+                req,
+                "application/javascript; charset=utf-8",
+                edge_header,
+            );
+            strip_tsjs_head_body(&mut resp, req.method());
+            apply_tsjs_success_headers(&mut resp);
+            return Ok(resp);
         }
     }
 
-    Ok(not_found_response())
+    Ok(tsjs_not_found_response())
 }
 
-fn serve_tsjs_static(
-    req: &Request<EdgeBody>,
-    body: &str,
-    expected_hash: &str,
-    edge_header: EdgeCacheHeader,
-) -> Response<EdgeBody> {
-    let mut response = serve_static_with_etag(
-        body,
-        req,
-        "application/javascript; charset=utf-8",
-        edge_header,
-    );
-    if request_version_hash(req).is_some_and(|hash| hash == expected_hash) {
-        CachePolicy::public_immutable(Duration::from_secs(31_536_000))
-            .apply_to_headers(response.headers_mut(), edge_header);
+fn strip_tsjs_head_body(response: &mut Response<EdgeBody>, method: &Method) {
+    if method == Method::HEAD {
+        *response.body_mut() = EdgeBody::empty();
+    }
+}
+
+fn valid_lowercase_sha256(value: &str) -> bool {
+    value.len() == 64
+        && value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+}
+
+fn parse_tsjs_hash_query(query: &str) -> Option<&str> {
+    let hash = query.strip_prefix("v=")?;
+    valid_lowercase_sha256(hash).then_some(hash)
+}
+
+fn parse_first_display_artifact_query(query: &str) -> Option<(u16, &str)> {
+    let (mask, hash) = query.strip_prefix("m=")?.split_once("&v=")?;
+    if mask.len() != 4
+        || !mask
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+        || !valid_lowercase_sha256(hash)
+    {
+        return None;
     }
+    let mask = u16::from_str_radix(mask, 16).ok()?;
+    (mask & 1 == 1).then_some((mask, hash))
+}
+
+fn apply_tsjs_success_headers(response: &mut Response<EdgeBody>) {
     response
         .headers_mut()
         .insert(HEADER_X_COMPRESS_HINT, HeaderValue::from_static("on"));
-    response
+    response.headers_mut().insert(
+        header::X_CONTENT_TYPE_OPTIONS,
+        HeaderValue::from_static("nosniff"),
+    );
 }
 
-fn request_version_hash(req: &Request<EdgeBody>) -> Option<&str> {
-    req.uri().query()?.split('&').find_map(|pair| {
-        let (name, value) = pair.split_once('=')?;
-        (name == "v").then_some(value)
-    })
+fn serve_precomputed_tsjs_artifact(
+    artifact: &crate::tsjs::TsjsStaticArtifactV1,
+    req: &Request<EdgeBody>,
+    edge_header: EdgeCacheHeader,
+) -> Response<EdgeBody> {
+    let etag = format!("\"sha256-{}\"", artifact.hash());
+    let not_modified = req
+        .headers()
+        .get(header::IF_NONE_MATCH)
+        .and_then(|value| value.to_str().ok())
+        .is_some_and(|value| value == etag);
+    let builder = Response::builder()
+        .header(header::ETAG, etag)
+        .header(header::VARY, "Accept-Encoding");
+    let mut response = if not_modified {
+        builder
+            .status(StatusCode::NOT_MODIFIED)
+            .body(EdgeBody::empty())
+            .expect("should build 304 TSJS response")
+    } else {
+        builder
+            .status(StatusCode::OK)
+            .header(
+                header::CONTENT_TYPE,
+                "application/javascript; charset=utf-8",
+            )
+            .body(EdgeBody::from_bytes(artifact.body().clone()))
+            .expect("should build TSJS response")
+    };
+    CachePolicy::public_immutable(Duration::from_secs(31_536_000))
+        .apply_to_headers(response.headers_mut(), edge_header);
+    response
 }
 
-/// Extract a module ID from a deferred-module filename like `tsjs-sourcepoint.min.js`.
+/// Extract a catalogued deferred module ID from its only admitted filename.
 ///
 /// Returns `Some(&'static str)` if the filename matches a known JS module ID,
 /// `None` otherwise. The caller must additionally verify that the module is
@@ -608,11 +709,15 @@ fn request_version_hash(req: &Request<EdgeBody>) -> Option<&str> {
 fn parse_single_module_filename(filename: &str) -> Option<&'static str> {
     let stem = filename
         .strip_prefix("tsjs-")
-        .and_then(|s| s.strip_suffix(".min.js").or_else(|| s.strip_suffix(".js")))?;
+        .and_then(|s| s.strip_suffix(".min.js"))?;
 
-    trusted_server_js::all_module_ids()
+    trusted_server_js::all_integration_metadata()
         .into_iter()
-        .find(|&id| id == stem)
+        .find(|metadata| {
+            metadata.id == stem
+                && metadata.phase == Some(trusted_server_js::TsjsModulePhase::Deferred)
+        })
+        .map(|metadata| metadata.id)
 }
 
 /// Parameters for processing response streaming.
@@ -630,10 +735,10 @@ struct ProcessResponseParams<'a> {
     suppress_datadome_client_side_tag: bool,
     gpt_diagnostics:
         Option<&'a crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision>,
-    /// See [`HtmlStreamProcessorParams::shared_template_authorized`].
+    render_trace_overlay: bool,
     shared_template_authorized: bool,
-    /// See [`HtmlStreamProcessorParams::csp_nonce_observed`].
     csp_nonce_observed: Option<&'a Arc<AtomicBool>>,
+    csp_nonce: Option<&'a str>,
 }
 
 struct PublisherBodyProcessor {
@@ -660,8 +765,13 @@ impl PublisherBodyProcessor {
                 ad_bids_state: Arc::clone(params.ad_bids_state.script_cell()),
                 suppress_datadome_client_side_tag: params.suppress_datadome_client_side_tag,
                 gpt_diagnostics: params.gpt_diagnostics.clone(),
-                shared_template_authorized: params.template_cache_key.is_some(),
+                render_trace_overlay: params.render_trace_overlay,
+                assembly_mode: effective_assembly_mode(
+                    settings,
+                    params.template_cache_key.is_some(),
+                ),
                 csp_nonce_observed: params.csp_nonce_observed.clone(),
+                csp_nonce: response_csp_nonce(&params.policy_headers),
             })?)
         } else if is_rsc_flight {
             Box::new(RscFlightUrlRewriter::new(
@@ -741,8 +851,13 @@ fn process_response_streaming<W: Write>(
             ad_bids_state: params.ad_bids_state.clone(),
             suppress_datadome_client_side_tag: params.suppress_datadome_client_side_tag,
             gpt_diagnostics: params.gpt_diagnostics.cloned(),
-            shared_template_authorized: params.shared_template_authorized,
+            render_trace_overlay: params.render_trace_overlay,
+            assembly_mode: effective_assembly_mode(
+                params.settings,
+                params.shared_template_authorized,
+            ),
             csp_nonce_observed: params.csp_nonce_observed.cloned(),
+            csp_nonce: params.csp_nonce.map(str::to_owned),
         })?;
         StreamingPipeline::new(config, processor)
             .with_max_pending_decoded_bytes(max_pending_decoded_bytes)
@@ -968,251 +1083,44 @@ impl Drop for DispatchedAuctionGuard {
     }
 }
 
-/// Mutable auction-hold state threaded through the streaming hold pipeline.
-struct AuctionHoldState {
-    hold: Option<BodyCloseHoldBuffer>,
-    dispatched: DispatchedAuctionGuard,
-    telemetry: AuctionTelemetryCarry,
-}
-
-impl AuctionHoldState {
-    fn new(dispatched: DispatchedAuctionGuard, telemetry: AuctionTelemetryCarry) -> Self {
-        Self {
-            hold: Some(BodyCloseHoldBuffer::new()),
-            dispatched,
-            telemetry,
-        }
-    }
-}
-
-/// Abandon the in-flight auction (if still pending) with the given telemetry
-/// reason. No-op once the auction has been collected or already abandoned.
-async fn abandon_hold_auction(
-    state: &mut AuctionHoldState,
-    services: &RuntimeServices,
-    reason: &'static str,
-) {
-    if let Some(dispatched) = state.dispatched.take() {
-        emit_abandoned_auction(
-            services,
-            state.telemetry.observation.take(),
-            dispatched,
-            reason,
-        )
-        .await;
-        // Abandonment with telemetry is a terminal result, so the drop warning
-        // is no longer warranted. (A drop *during* the emit above still fires
-        // it, since the guard stays armed until here.)
-        state.dispatched.disarm();
-    }
-}
-
-/// Output of a single close-body hold step, split at the auction-collection
-/// barrier.
-///
-/// `ready` is the prefix the caller must emit *before* collecting the auction,
-/// so a small page whose `</body>` lands in the first source chunk still
-/// streams its document prefix immediately instead of stalling behind the
-/// auction. `close_found` signals that `</body` was seen: the caller emits
-/// `ready`, then awaits [`hold_collect_close_tail`] to collect the auction and
-/// emit the held closing tail.
-struct HoldStepSegments {
-    ready: Vec<bytes::Bytes>,
-    close_found: bool,
-}
+/// The single inert marker stored in a reader-neutral C2 template.
+pub const AD_ASSEMBLY_SEAM: &str = "<!--ts-ad-seam-->";
+/// Transform-owned placeholder replaced only after collision and nonce checks.
+pub(crate) const TEMPLATE_SEAM_PLACEHOLDER: &str = "<!--ts-seam-slot-->";
 
-/// Feed one decoded chunk through the close-body hold and processor.
-///
-/// Returns the ready prefix for the caller to emit — written to a client stream
-/// by [`body_close_hold_loop_stream`], yielded from the lazy body by
-/// [`publisher_response_into_streaming_response`]. Both async hold paths share
-/// this function so their behavior cannot drift apart.
-///
-/// This step never awaits auction collection: it processes only the bytes the
-/// hold buffer releases as ready and reports whether `</body` was seen. Holding
-/// the collection out of this step is what lets callers emit the prefix before
-/// the auction resolves. On processing failure the pending auction is abandoned
-/// before the error is returned.
-async fn hold_step_decoded_chunk<P: StreamProcessor>(
-    processor: &mut P,
-    encoder: &mut BodyStreamEncoder,
-    chunk: &[u8],
-    state: &mut AuctionHoldState,
-    collect_refs: &AuctionCollectDeps<'_>,
-) -> Result<HoldStepSegments, Report<TrustedServerError>> {
-    let mut ready = Vec::new();
-    let bytes: Cow<'_, [u8]> = match state.hold.as_mut() {
-        // Once the hold has been released the chunk streams straight through,
-        // borrowed rather than copied.
-        None => Cow::Borrowed(chunk),
-        Some(hold_buffer) => Cow::Owned(hold_buffer.push(chunk)),
-    };
-    match process_and_encode_chunk(processor, encoder, &bytes, false, "Failed to process chunk") {
-        Ok(Some(encoded)) => ready.push(encoded),
-        Ok(None) => {}
-        Err(err) => {
-            abandon_hold_auction(state, collect_refs.services, "stream_process_error").await;
-            return Err(err);
-        }
-    }
-    let close_found = state
-        .hold
+fn configured_assembly_mode(settings: &Settings) -> AssemblyMode {
+    settings
+        .creative_opportunities
         .as_ref()
-        .is_some_and(BodyCloseHoldBuffer::found_close);
-    Ok(HoldStepSegments { ready, close_found })
-}
-
-/// Collect the dispatched auction and process the held `</body>` tail.
-///
-/// Call only after [`hold_step_decoded_chunk`] (or
-/// [`hold_finish_ready_segments`]) reports `close_found` and the ready prefix
-/// has already been emitted:
-/// collecting here — after the prefix streams — is what keeps the auction
-/// riding alongside transfer instead of blocking it. Collection runs before the
-/// tail is processed so `lol_html` sees live bids at the injection point.
-async fn hold_collect_close_tail<P: StreamProcessor>(
-    processor: &mut P,
-    encoder: &mut BodyStreamEncoder,
-    state: &mut AuctionHoldState,
-    collect_refs: &AuctionCollectDeps<'_>,
-) -> Result<Vec<bytes::Bytes>, Report<TrustedServerError>> {
-    let mut segments = Vec::new();
-    let dispatched = state
-        .dispatched
-        .take()
-        .expect("should have dispatched auction to collect");
-    collect_stream_auction(dispatched, state.telemetry.take(), collect_refs).await;
-    // Collection reached a terminal result; disarm only now so a drop while the
-    // collect await above was still pending is reported.
-    state.dispatched.disarm();
-
-    let held = state
-        .hold
-        .take()
-        .expect("should have close-body hold buffer")
-        .finish();
-    if let Some(encoded) = process_and_encode_chunk(
-        processor,
-        encoder,
-        &held,
-        false,
-        "Failed to process held body close",
-    )? {
-        segments.push(encoded);
-    }
-    Ok(segments)
+        .filter(|config| config.enabled)
+        .map(CreativeOpportunitiesConfig::assembly_mode)
+        .unwrap_or_default()
 }
 
-/// Pull and decode the next chunk of the close-body hold pipeline, feeding it
-/// through [`hold_step_decoded_chunk`].
-///
-/// Returns `Ok(None)` when the source is exhausted; the caller must then emit
-/// [`hold_finish_ready_segments`] followed by [`hold_finish_tail_segments`]. On
-/// read or decode failure the pending auction is
-/// abandoned before the error is returned. Shared by the write-sink driver
-/// ([`body_close_hold_loop_stream`]) and the lazy publisher body stream so
-/// the two hold paths cannot drift apart.
-async fn hold_step_next_chunk<P: StreamProcessor>(
-    source: &mut BodyChunkSource,
-    decoder: &mut BodyStreamDecoder,
-    encoder: &mut BodyStreamEncoder,
-    processor: &mut P,
-    state: &mut AuctionHoldState,
-    collect_refs: &AuctionCollectDeps<'_>,
-) -> Result<Option<HoldStepSegments>, Report<TrustedServerError>> {
-    let raw_chunk = match source.next_chunk().await {
-        Ok(Some(chunk)) => chunk,
-        Ok(None) => return Ok(None),
-        Err(err) => {
-            abandon_hold_auction(state, collect_refs.services, "stream_read_error").await;
-            return Err(err);
-        }
-    };
-    let decoded = match decoder.decode_chunk(raw_chunk) {
-        Ok(decoded) => decoded,
-        Err(err) => {
-            abandon_hold_auction(state, collect_refs.services, "stream_decode_error").await;
-            return Err(err);
-        }
-    };
-    if decoded.is_empty() {
-        return Ok(Some(HoldStepSegments {
-            ready: Vec::new(),
-            close_found: false,
-        }));
+fn mode_emits_seam_marker(mode: AssemblyMode) -> bool {
+    match mode {
+        AssemblyMode::Inline => false,
+        AssemblyMode::Esi => true,
     }
-    hold_step_decoded_chunk(processor, encoder, &decoded, state, collect_refs)
-        .await
-        .map(Some)
 }
 
-/// Drain the decoder tail at end of the origin stream, returning the prefix the
-/// caller must emit before [`hold_finish_tail_segments`].
-///
-/// A codec can hold document bytes back until its own finalization — the gzip
-/// decoder releases the remainder of the final member at `finish()` — and that
-/// remainder may be the whole document for a small page. Returning it ahead of
-/// collection keeps the invariant the mid-stream path already has: only the
-/// closing `</body>` tail waits for the auction, never renderable content.
-///
-/// On decoder failure the pending auction is abandoned before the error is
-/// returned.
-async fn hold_finish_ready_segments<P: StreamProcessor>(
-    processor: &mut P,
-    decoder: &mut BodyStreamDecoder,
-    encoder: &mut BodyStreamEncoder,
-    state: &mut AuctionHoldState,
-    collect_refs: &AuctionCollectDeps<'_>,
-) -> Result<Vec<bytes::Bytes>, Report<TrustedServerError>> {
-    let decoded_tail = match decoder.finish() {
-        Ok(decoded_tail) => decoded_tail,
-        Err(err) => {
-            abandon_hold_auction(state, collect_refs.services, "stream_decode_error").await;
-            return Err(err);
-        }
-    };
-    if decoded_tail.is_empty() {
-        return Ok(Vec::new());
+fn effective_assembly_mode(settings: &Settings, shared_template_authorized: bool) -> AssemblyMode {
+    let configured = configured_assembly_mode(settings);
+    if matches!(configured, AssemblyMode::Inline) || shared_template_authorized {
+        configured
+    } else {
+        log::debug!(
+            "assembly mode {configured:?} is unavailable for this response; falling back to inline"
+        );
+        AssemblyMode::Inline
     }
-    let step =
-        hold_step_decoded_chunk(processor, encoder, &decoded_tail, state, collect_refs).await?;
-    Ok(step.ready)
 }
 
-/// Finalize the close-body hold pipeline after [`hold_finish_ready_segments`].
-///
-/// Collects the auction if the close-body tag never streamed, processes the held
-/// tail plus the processor's final chunk, and emits the encoder trailer. Returns
-/// the encoded segments for the caller to emit.
-async fn hold_finish_tail_segments<P: StreamProcessor>(
-    processor: &mut P,
-    encoder: &mut BodyStreamEncoder,
-    state: &mut AuctionHoldState,
-    collect_refs: &AuctionCollectDeps<'_>,
-) -> Result<Vec<bytes::Bytes>, Report<TrustedServerError>> {
-    let mut segments = Vec::new();
-
-    // If the hold is still armed the auction was never collected mid-stream:
-    // `</body>` arrived only in the decoder tail, or the document had none at
-    // all. Collect now and flush the held remainder before finalizing.
-    if state.hold.is_some() {
-        segments.extend(hold_collect_close_tail(processor, encoder, state, collect_refs).await?);
-    }
-
-    if let Some(encoded) = process_and_encode_chunk(
-        processor,
-        encoder,
-        &[],
-        true,
-        "Failed to finalize processor",
-    )? {
-        segments.push(encoded);
-    }
-    let trailer = encoder.finish()?;
-    if !trailer.is_empty() {
-        segments.push(bytes::Bytes::from(trailer));
+fn template_injection(mode: AssemblyMode) -> BodyCloseInjection {
+    match mode {
+        AssemblyMode::Inline => BodyCloseInjection::None,
+        AssemblyMode::Esi => BodyCloseInjection::Marker(TEMPLATE_SEAM_PLACEHOLDER.to_string()),
     }
-    Ok(segments)
 }
 
 /// Create a unified HTML stream processor.
@@ -1237,154 +1145,10 @@ struct HtmlStreamProcessorParams<'a> {
     ad_bids_state: Arc<Mutex<Option<String>>>,
     suppress_datadome_client_side_tag: bool,
     gpt_diagnostics: Option<crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision>,
-    /// Whether a shared template was authorized for this response.
-    ///
-    /// Carried rather than re-derived so both seams see the same answer. See
-    /// [`effective_assembly_mode`].
-    shared_template_authorized: bool,
-    /// Where the transform records a response-bound CSP nonce, when one matters.
+    render_trace_overlay: bool,
+    assembly_mode: AssemblyMode,
     csp_nonce_observed: Option<Arc<AtomicBool>>,
-}
-
-/// The diagnostics decision the template may carry.
-///
-/// Diagnostics is request-scoped — activated by a cookie or query parameter, and
-/// documented as an immutable per-request decision — so it must not reach a shared
-/// template.
-///
-/// It does not leak today even without this gate, but only by coincidence:
-/// `requires_private_no_store()` is a strict superset of the conditions under which
-/// a script is emitted, and that stamp lands before the template cache gate reads response
-/// headers, so the gate refuses. Two independent conditions that happen to align,
-/// with nothing enforcing the relationship. This makes the guarantee explicit;
-/// `requires_private_no_store_is_a_superset_of_injection` keeps the coincidence as a
-/// backstop if this gate is ever removed.
-pub(crate) fn template_gpt_diagnostics(
-    mode: AssemblyMode,
-    decision: Option<crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision>,
-) -> Option<crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision> {
-    match mode {
-        AssemblyMode::Inline => decision,
-        AssemblyMode::Esi => None,
-    }
-}
-
-/// The marker emitted at the `</body>` seam under [`AssemblyMode::Esi`], reserving the
-/// place this reader's slots and bids are spliced into.
-///
-/// An inert HTML comment, deliberately. Template schema v1 used an executable ESI include
-/// tag here, when the `esi` crate resolved it at the edge. That crate was removed from the
-/// render path because it truncates any element larger than its 16 KB chunk size, and
-/// nothing has parsed ESI since. What remained was a tag that *looked* executable, would
-/// have been executed by any ESI-enabled layer in front of us, and renders as text in a
-/// browser if assembly is ever skipped. A comment cannot do any of those things: an
-/// unassembled template degrades to a page with no ads rather than a page with a visible
-/// tag.
-///
-/// Carries no URL. Every byte here is a byte every reader of the shared template
-/// receives, so nothing request-scoped may appear, and keeping a URL out also removes
-/// any escaping question at the seam.
-pub const AD_ASSEMBLY_SEAM: &str = "<!--ts-ad-seam-->";
-
-/// Transform-owned stand-in for the seam, emitted at the document's structural body end.
-///
-/// Deliberately *not* [`AD_ASSEMBLY_SEAM`]. The payload that ends up in the seam is not
-/// known until the completed transform has been checked for publisher collisions, and the
-/// position is not knowable from the output bytes: a reverse search for `</body>` selects
-/// a string literal in `<script>const marker = "</body>";</script>` when the document has
-/// no real close, and prefers a `</body>` sequence in trailing comment data over the real
-/// closing tag. Only the parser knows which one is structural, so the parser marks the
-/// spot and the substitution below fills it in.
-///
-/// Keeping it distinct from [`AD_ASSEMBLY_SEAM`] is what lets a publisher document that
-/// contains the seam bytes still receive correctly positioned bids: that collision
-/// revokes the shared reservation without disturbing this placeholder.
-pub(crate) const TEMPLATE_SEAM_PLACEHOLDER: &str = "<!--ts-seam-slot-->";
-
-/// The mode the operator asked for, before availability is taken into account.
-///
-/// Spelled once, because the mode has to mean the same thing at the cache key, at the
-/// seam, and at both hit finalizers. Every one of those re-derived it from the same
-/// `Option` chain, and the finalizers had no way to ask at all — which is why they
-/// demanded a seam marker of a mode that emits none.
-fn configured_assembly_mode(settings: &Settings) -> AssemblyMode {
-    settings
-        .creative_opportunities
-        .as_ref()
-        .map(CreativeOpportunitiesConfig::assembly_mode)
-        .unwrap_or_default()
-}
-
-/// Whether this mode's completed template receives [`AD_ASSEMBLY_SEAM`].
-///
-/// The property that decides whether a template is *expected* to have a hole in it, and
-/// therefore whether the absence of one is a defect or the design. Only `Esi` splices per
-/// reader.
-///
-/// Matched exhaustively rather than compared against `Esi`, so a new mode has to state
-/// its answer here instead of silently inheriting one.
-fn mode_emits_seam_marker(mode: AssemblyMode) -> bool {
-    match mode {
-        AssemblyMode::Inline => false,
-        AssemblyMode::Esi => true,
-    }
-}
-
-/// The assembly mode this response will actually be delivered under.
-///
-/// The configured mode says what the operator wants; the cache key says whether it is
-/// available. A shared mode with no key means the gate refused this response — the
-/// origin set a cookie, declared a `Vary` the key does not cover, returned a non-200,
-/// and so on — so there is no shared template to build and nothing downstream will
-/// assemble one.
-///
-/// When that happens the request falls back to [`AssemblyMode::Inline`] **entirely**,
-/// at every seam. Falling back at one seam and not another is what produced the failure
-/// this function exists to prevent: the `</body>` seam emitted a legacy ESI tag because
-/// the mode was `Esi`, while assembly was skipped because there was no key, so the reader
-/// received a document with unresolved executable ESI markup in it and no bids at all.
-///
-/// Bypassing is the *normal* case against a real origin, not an edge case, so this path
-/// runs far more often than the shared one.
-fn effective_assembly_mode(settings: &Settings, shared_template_authorized: bool) -> AssemblyMode {
-    let configured = configured_assembly_mode(settings);
-    if matches!(configured, AssemblyMode::Inline) || shared_template_authorized {
-        return configured;
-    }
-    log::debug!(
-        "assembly mode {configured:?} is unavailable for this response (no shared template \
-         was authorized); falling back to inline"
-    );
-    AssemblyMode::Inline
-}
-
-/// What the streaming HTML processor should inject at `</body>`.
-///
-/// Explicit rather than inferred. The previous shape read
-/// `ad_slots_script.is_some()` inside the element handler, which silently coupled
-/// two independent decisions: once [`template_ad_slots_script`] stopped emitting a
-/// head script under a shared mode, body-close injection stopped with it.
-///
-/// `Esi` emits [`TEMPLATE_SEAM_PLACEHOLDER`], not the seam itself. What goes into the
-/// seam is still decided after the completed transform has been checked for publisher
-/// collisions and ESI directives — but *where* it goes has to be decided here, by the
-/// parser, because the output bytes cannot distinguish a structural `</body>` from one
-/// written inside a script string or a trailing comment.
-pub(crate) fn body_close_injection(
-    mode: AssemblyMode,
-    head_script_present: bool,
-) -> BodyCloseInjection {
-    match mode {
-        // Per-navigation and never shared, so gating on slot presence is correct.
-        AssemblyMode::Inline => {
-            if head_script_present {
-                BodyCloseInjection::InlineBids
-            } else {
-                BodyCloseInjection::None
-            }
-        }
-        AssemblyMode::Esi => BodyCloseInjection::Marker(TEMPLATE_SEAM_PLACEHOLDER.to_string()),
-    }
+    csp_nonce: Option<String>,
 }
 
 fn create_html_stream_processor(
@@ -1398,26 +1162,18 @@ fn create_html_stream_processor(
         params.origin_host,
         params.request_host,
         params.request_scheme,
-    );
-
-    let assembly_mode = effective_assembly_mode(params.settings, params.shared_template_authorized);
-    let body_close = body_close_injection(assembly_mode, params.ad_slots_script.is_some());
-
-    let gpt_diagnostics = template_gpt_diagnostics(assembly_mode, params.gpt_diagnostics);
-
-    // Only a response that can be stored has a consumer for the observation, so the
-    // handlers are not registered for ordinary inline traffic.
-    let csp_nonce_observed = params
-        .shared_template_authorized
-        .then_some(params.csp_nonce_observed)
-        .flatten();
-
-    let config = config
-        .with_ad_state(params.ad_slots_script, params.ad_bids_state)
-        .with_gpt_diagnostics(gpt_diagnostics)
-        .with_body_close(body_close)
-        .with_csp_nonce_observer(csp_nonce_observed)
-        .with_datadome_client_tag_suppression(params.suppress_datadome_client_side_tag);
+    )
+    .with_ad_state(params.ad_slots_script, params.ad_bids_state)
+    .with_gpt_diagnostics(params.gpt_diagnostics)
+    .with_body_close(template_injection(params.assembly_mode))
+    .with_render_trace_overlay(params.render_trace_overlay)
+    .with_csp_nonce_observer(
+        matches!(params.assembly_mode, AssemblyMode::Esi)
+            .then_some(params.csp_nonce_observed)
+            .flatten(),
+    )
+    .with_csp_nonce(params.csp_nonce)
+    .with_datadome_client_tag_suppression(params.suppress_datadome_client_side_tag);
 
     Ok(create_html_processor(config))
 }
@@ -1606,23 +1362,20 @@ pub struct OwnedProcessResponseParams {
     /// The streaming phase collects these and writes bids to `ad_bids_state`
     /// before processing the last body chunk, so `</body>` injection sees live bids.
     pub(crate) dispatched_auction: Option<DispatchedAuction>,
-    /// Price granularity used to bucket bids when building `tsjs.bids`.
+    /// Price granularity used to bucket bids in the browser auction projection.
     pub(crate) price_granularity: PriceGranularity,
     /// Whether to omit Trusted Server's automatic `DataDome` client-side tag.
     pub(crate) suppress_datadome_client_side_tag: bool,
     /// Request-scoped conditional diagnostics delivery decision.
     pub(crate) gpt_diagnostics:
         Option<crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision>,
-    /// Set by the transform when the document carries a response-bound CSP nonce.
-    ///
-    /// `None` wherever no transform runs. Recorded by the HTML parser rather than
-    /// rescanned from the output, which cannot tell a `nonce` attribute from the same
-    /// word inside a script.
+    /// Server-owned request-scoped render-trace overlay decision.
+    pub(crate) render_trace_overlay: bool,
+    /// Set by the transform when publisher markup carries a response-bound CSP nonce.
     pub(crate) csp_nonce_observed: Option<Arc<AtomicBool>>,
 }
 
-/// Response-authorized template cache insert inputs. The key is built before origin lookup; the
-/// lifetime is only known after the origin proves this representation is shareable.
+/// Response-authorized template cache insert inputs.
 pub(crate) struct AuthorizedTemplateStore {
     reservation: crate::platform::TemplateCacheReservation,
     expires_at: Instant,
@@ -1752,7 +1505,7 @@ pub async fn buffer_publisher_response_async(
                 let payload: Cow<'_, str> = if shared_response_authorized {
                     Cow::Borrowed(AD_ASSEMBLY_SEAM)
                 } else {
-                    Cow::Owned(seam_script_for(&params))
+                    Cow::Owned(seam_script_for(&params, settings, integration_registry))
                 };
                 match replace_seam_placeholder(bytes, payload.as_bytes()) {
                     Ok(bytes) => bytes,
@@ -1818,6 +1571,7 @@ pub async fn buffer_publisher_response_async(
                     shared_response_authorized,
                     shared_response_authorized,
                     settings,
+                    integration_registry,
                     &params,
                     services,
                     bytes,
@@ -1855,6 +1609,7 @@ pub async fn buffer_publisher_response_async(
                     &AuctionCollectDeps {
                         price_granularity: params.price_granularity,
                         ad_bids_state: &params.ad_bids_state,
+                        browser_slots_json: params.ad_slots_script.as_deref(),
                         orchestrator,
                         services,
                         settings,
@@ -1871,7 +1626,7 @@ pub async fn buffer_publisher_response_async(
                     message: "cached template has no usable seam marker".to_string(),
                 }
             })?;
-            let seam = seam_script_for(&params);
+            let seam = seam_script_for(&params, settings, integration_registry);
             let mut assembled = Vec::with_capacity(head.len() + seam.len() + tail.len());
             assembled.extend_from_slice(head);
             assembled.extend_from_slice(seam.as_bytes());
@@ -1907,6 +1662,7 @@ fn assemble_if_shared(
     was_authorized: bool,
     platform_assembly_allowed: bool,
     settings: &Settings,
+    integration_registry: &IntegrationRegistry,
     params: &OwnedProcessResponseParams,
     services: &RuntimeServices,
     bytes: Vec<u8>,
@@ -1920,7 +1676,7 @@ fn assemble_if_shared(
             message: "shared template has no usable seam marker".to_string(),
         }
     })?;
-    let seam = seam_script_for(params);
+    let seam = seam_script_for(params, settings, integration_registry);
 
     let platform_result = platform_assembly_allowed.then(|| {
         services
@@ -1992,23 +1748,102 @@ fn response_carries_a_seam_marker(was_authorized: bool, settings: &Settings) ->
     was_authorized && mode_emits_seam_marker(configured_assembly_mode(settings))
 }
 
-/// What this request splices into the seam marker: a `<script>`, or nothing at all.
-///
-/// `seam_ad_slots` is `None` exactly when the ad stack did not run — bot, prefetch,
-/// consent-denied, auction kill switch. Emitting a seam anyway, with `[]` slots, still
-/// calls `scheduleInitialAdInit`, which schedules `adInit` for precisely the traffic
-/// that opted out. Absent is not the same as empty here.
-///
-/// Shared by the miss path and by **both** hit finalizers. They previously each spelled
-/// the decision out, and the two hit paths spelled it `unwrap_or("[]")` — so the gate
-/// held on a cache miss and was ignored on every cache hit.
-fn seam_script_for(params: &OwnedProcessResponseParams) -> String {
-    params
-        .seam_ad_slots
-        .as_deref()
-        .map(|slots| params.ad_bids_state.build_seam_script(slots))
-        .unwrap_or_default()
-}
+/// Build the complete hard-cutover boot fragment inserted into a reader-neutral
+/// C2 template. The template contains neither request projection nor runtime
+/// bytes; both arrive atomically at this one per-reader seam.
+fn seam_script_for(
+    params: &OwnedProcessResponseParams,
+    settings: &Settings,
+    integration_registry: &IntegrationRegistry,
+) -> String {
+    let state = params
+        .ad_bids_state
+        .lock()
+        .expect("should lock C2 boot projection")
+        .clone();
+    let (debug_comment, projection_json) = match state.as_deref() {
+        Some(value) if value.starts_with("<!-- ts-debug:") => value.rsplit_once('\n').map_or(
+            (Some(value), crate::tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1),
+            |(debug, json)| (Some(debug), json),
+        ),
+        Some(value) => (None, value),
+        None => (None, crate::tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1),
+    };
+    let diagnostics_requested = params
+        .gpt_diagnostics
+        .as_ref()
+        .is_some_and(crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision::active);
+    let creative = integration_registry.tsjs_creative_boot();
+    let selection = crate::integrations::TsjsCatalogSelectionV1 {
+        creative_enabled: creative.enabled,
+        creative_click_guard: creative.click_guard,
+        creative_render_guard: creative.render_guard,
+        gpt_diagnostics_active: diagnostics_requested,
+        render_trace_overlay: params.render_trace_overlay,
+    };
+    let module_ids = integration_registry.tsjs_catalog_module_ids(selection);
+    let diagnostics_active = module_ids.contains(&"gpt_diagnostics");
+    let integration_configs = match integration_registry.tsjs_integration_configs_v1(&module_ids) {
+        Ok(configs) => configs,
+        Err(error) => {
+            log::error!("invalid C2 TSJS integration config projection: {error:?}");
+            return String::new();
+        }
+    };
+    let publisher_origin = request_origin(&params.request_scheme, &params.request_host);
+    let csp_nonce = response_csp_nonce(&params.policy_headers);
+    let mut interstitial = String::new();
+    if let Some(debug_comment) = debug_comment {
+        interstitial.push_str(debug_comment);
+        interstitial.push('\n');
+    }
+    let document_state = crate::integrations::IntegrationDocumentState::default();
+    let fallback_origin_host = settings.publisher.origin_host();
+    let context = crate::integrations::IntegrationHtmlContext {
+        request_host: &params.request_host,
+        request_scheme: &params.request_scheme,
+        origin_host: if params.origin_host.is_empty() {
+            &fallback_origin_host
+        } else {
+            &params.origin_host
+        },
+        csp_nonce: csp_nonce.as_deref(),
+        document_state: &document_state,
+    };
+    for insert in integration_registry.head_inserts(&context) {
+        interstitial.push_str(&insert);
+    }
+    crate::tsjs::tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(
+        crate::tsjs::TsjsBootScriptConfigV1 {
+            module_ids: &module_ids,
+            integration_configs: &integration_configs,
+            auction_projection_json: projection_json,
+            creative,
+            render_trace_overlay: params.render_trace_overlay,
+            gpt_diagnostics_active: diagnostics_active,
+        },
+        &publisher_origin,
+        csp_nonce.as_deref(),
+        &interstitial,
+    )
+    .or_else(|error| {
+        log::error!("invalid C2 TSJS boot projection: {error:?}");
+        crate::tsjs::tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(
+            crate::tsjs::TsjsBootScriptConfigV1 {
+                module_ids: &module_ids,
+                integration_configs: &integration_configs,
+                auction_projection_json: crate::tsjs::EMPTY_AUCTION_PROJECTION_JSON_V1,
+                creative,
+                render_trace_overlay: params.render_trace_overlay,
+                gpt_diagnostics_active: diagnostics_active,
+            },
+            &publisher_origin,
+            csp_nonce.as_deref(),
+            &interstitial,
+        )
+    })
+    .unwrap_or_default()
+}
 
 /// Builds the injection state a cached template needs on the way out.
 ///
@@ -2021,6 +1856,7 @@ fn build_template_assembly_params(
     request_scheme: &str,
     price_granularity: PriceGranularity,
     ad_bids_state: AdBidsState,
+    render_trace_overlay: bool,
 ) -> OwnedProcessResponseParams {
     OwnedProcessResponseParams {
         csp_nonce_observed: None,
@@ -2043,6 +1879,7 @@ fn build_template_assembly_params(
         price_granularity,
         gpt_diagnostics: None,
         suppress_datadome_client_side_tag: false,
+        render_trace_overlay,
     }
 }
 
@@ -2278,8 +2115,9 @@ async fn store_template_if_authorized(
 ///
 /// # Panics
 ///
-/// Panics if the `ad_bids_state` mutex is poisoned, which requires a prior panic while
-/// it was held. Every holder is a short, infallible read or write of an `Option<String>`.
+/// Panics if an internal streaming auction guard is missing after this helper
+/// has committed to collecting it. That state indicates a violated internal
+/// ownership invariant.
 pub async fn publisher_response_into_streaming_response(
     publisher_response: PublisherResponse,
     method: &Method,
@@ -2342,6 +2180,7 @@ pub async fn publisher_response_into_streaming_response(
             let services = services.clone();
             let settings = Arc::clone(&settings);
             let orchestrator = Arc::clone(&orchestrator);
+            let integration_registry = integration_registry.clone();
             let compression = response_compression(&response);
             // Arm the drop warning before constructing the lazy body. A reader can
             // disconnect after receiving the cached article prefix but before the seam
@@ -2378,6 +2217,7 @@ pub async fn publisher_response_into_streaming_response(
                         &AuctionCollectDeps {
                             price_granularity: params.price_granularity,
                             ad_bids_state: &params.ad_bids_state,
+                            browser_slots_json: params.ad_slots_script.as_deref(),
                             orchestrator: &orchestrator,
                             services: &services,
                             settings: &settings,
@@ -2391,7 +2231,7 @@ pub async fn publisher_response_into_streaming_response(
                     guard.disarm();
                 }
 
-                let seam = seam_script_for(&params);
+                let seam = seam_script_for(&params, &settings, &integration_registry);
                 if !seam.is_empty() {
                     let encoded_seam = encoder
                         .encode_chunk(seam.into_bytes())
@@ -2451,72 +2291,20 @@ pub async fn publisher_response_into_streaming_response(
 
             response.headers_mut().remove(header::CONTENT_LENGTH);
             let mut params = *params;
-            let mut processor =
-                match PublisherBodyProcessor::new(&params, &settings, integration_registry) {
-                    Ok(processor) => processor,
-                    Err(err) => {
-                        // Parity with the buffered finalizer: a processor
-                        // construction failure abandons the dispatched auction
-                        // with telemetry instead of dropping the in-flight SSP
-                        // responses silently.
-                        if let Some(dispatched) = params.dispatched_auction.take() {
-                            emit_abandoned_auction(
-                                &services,
-                                params.auction_observation.take(),
-                                dispatched,
-                                "processor_init_error",
-                            )
-                            .await;
-                        }
-                        return Err(err);
-                    }
-                };
-            // The guard is created before the lazy stream so an auction whose
-            // response body is dropped unpolled still logs the loss.
-            let dispatched_auction = params.dispatched_auction.take().map(|dispatched| {
+            if let Some(dispatched) = params.dispatched_auction.take() {
                 let telemetry = AuctionTelemetryCarry {
                     observation: params.auction_observation.take(),
                     auction_request: params.auction_request.take(),
                 };
-                (DispatchedAuctionGuard::new(dispatched), telemetry)
-            });
-            let stream = async_stream::try_stream! {
-                let compression = Compression::from_content_encoding(&params.content_encoding);
-                let max_body_bytes = settings.publisher.max_buffered_body_bytes;
-                let mut decoder = BodyStreamDecoder::new(compression, max_body_bytes);
-                let mut encoder = BodyStreamEncoder::new(compression);
-                let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE)
-                    .with_max_bytes(max_body_bytes);
-
-                // HTML rides the close-body hold so bids land before `</body>`;
-                // non-HTML has no injection point, so its auction is collected
-                // before any byte streams (matching the buffered finalizer).
-                let mut hold_auction = None;
-                if let Some((mut guard, telemetry)) = dispatched_auction {
-                    if is_html_content_type(&params.content_type) {
-                        hold_auction = Some((guard, telemetry));
-                    } else if let Some(dispatched) = guard.take() {
-                        collect_non_html_auction(
-                            dispatched,
-                            telemetry,
-                            &params,
-                            &orchestrator,
-                            &services,
-                            &settings,
-                        )
-                        .await;
-                        // Collection reached a terminal result; disarm only now
-                        // so a drop while the collect await above was still
-                        // pending is reported.
-                        guard.disarm();
-                    }
-                }
-
-                if let Some((guard, telemetry)) = hold_auction {
-                    let mut state = AuctionHoldState::new(guard, telemetry);
+                let mut guard = DispatchedAuctionGuard::new(dispatched);
+                let dispatched = guard
+                    .take()
+                    .expect("should have dispatched auction to collect before HTML");
+                if is_html_content_type(&params.content_type) {
                     let collect_refs = AuctionCollectDeps {
                         price_granularity: params.price_granularity,
                         ad_bids_state: &params.ad_bids_state,
+                        browser_slots_json: params.ad_slots_script.as_deref(),
                         orchestrator: &orchestrator,
                         services: &services,
                         settings: &settings,
@@ -2525,87 +2313,49 @@ pub async fn publisher_response_into_streaming_response(
                             &params.request_host,
                         ),
                     };
-
-                    while let Some(step) = hold_step_next_chunk(
-                        &mut source,
-                        &mut decoder,
-                        &mut encoder,
-                        &mut processor,
-                        &mut state,
-                        &collect_refs,
-                    )
-                    .await
-                    .map_err(publisher_stream_error)?
-                    {
-                        // Emit the ready prefix before collecting the auction so
-                        // the client receives the document up to `</body>` while
-                        // the auction rides alongside transfer.
-                        for encoded in step.ready {
-                            yield encoded;
-                        }
-                        if step.close_found {
-                            for encoded in hold_collect_close_tail(
-                                &mut processor,
-                                &mut encoder,
-                                &mut state,
-                                &collect_refs,
-                            )
-                            .await
-                            .map_err(publisher_stream_error)?
-                            {
-                                yield encoded;
-                            }
-                        }
-                    }
-
-                    // Whatever the decoder released at finalization is emitted
-                    // before collection, for the same reason as the mid-stream
-                    // prefix above: a small compressed page can surface its
-                    // whole document here.
-                    for encoded in hold_finish_ready_segments(
-                        &mut processor,
-                        &mut decoder,
-                        &mut encoder,
-                        &mut state,
-                        &collect_refs,
-                    )
-                    .await
-                    .map_err(publisher_stream_error)?
-                    {
-                        yield encoded;
-                    }
-                    for encoded in hold_finish_tail_segments(
-                        &mut processor,
-                        &mut encoder,
-                        &mut state,
-                        &collect_refs,
-                    )
-                    .await
-                    .map_err(publisher_stream_error)?
-                    {
-                        yield encoded;
-                    }
+                    collect_stream_auction(dispatched, telemetry, &collect_refs).await;
                 } else {
-                    while let Some(segments) = passthrough_step(
-                        &mut source,
-                        &mut decoder,
-                        &mut encoder,
-                        &mut processor,
+                    collect_non_html_auction(
+                        dispatched,
+                        telemetry,
+                        &params,
+                        &orchestrator,
+                        &services,
+                        &settings,
                     )
-                    .await
-                    .map_err(publisher_stream_error)?
-                    {
-                        for encoded in segments {
-                            yield encoded;
-                        }
-                    }
-                    for encoded in
-                        passthrough_finish_segments(&mut processor, &mut decoder, &mut encoder)
-                            .map_err(publisher_stream_error)?
-                    {
+                    .await;
+                }
+                guard.disarm();
+            }
+            let mut processor =
+                PublisherBodyProcessor::new(&params, &settings, integration_registry)?;
+            let stream = async_stream::try_stream! {
+                let compression = Compression::from_content_encoding(&params.content_encoding);
+                let max_body_bytes = settings.publisher.max_buffered_body_bytes;
+                let mut decoder = BodyStreamDecoder::new(compression, max_body_bytes);
+                let mut encoder = BodyStreamEncoder::new(compression);
+                let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE)
+                    .with_max_bytes(max_body_bytes);
+
+                while let Some(segments) = passthrough_step(
+                    &mut source,
+                    &mut decoder,
+                    &mut encoder,
+                    &mut processor,
+                )
+                .await
+                .map_err(publisher_stream_error)?
+                {
+                    for encoded in segments {
                         yield encoded;
                     }
                 }
+                for encoded in
+                    passthrough_finish_segments(&mut processor, &mut decoder, &mut encoder)
+                        .map_err(publisher_stream_error)?
+                {
+                    yield encoded;
+                }
             };
             *response.body_mut() = EdgeBody::from_stream::<_, std::io::Error>(stream);
             Ok(response)
@@ -2772,6 +2522,7 @@ pub fn stream_publisher_body<W: Write>(
     settings: &Settings,
     integration_registry: &IntegrationRegistry,
 ) -> Result<(), Report<TrustedServerError>> {
+    let csp_nonce = response_csp_nonce(&params.policy_headers);
     let borrowed = ProcessResponseParams {
         content_encoding: &params.content_encoding,
         origin_host: &params.origin_host,
@@ -2785,8 +2536,10 @@ pub fn stream_publisher_body<W: Write>(
         ad_bids_state: params.ad_bids_state.script_cell(),
         suppress_datadome_client_side_tag: params.suppress_datadome_client_side_tag,
         gpt_diagnostics: params.gpt_diagnostics.as_ref(),
+        render_trace_overlay: params.render_trace_overlay,
         shared_template_authorized: params.template_cache_key.is_some(),
         csp_nonce_observed: params.csp_nonce_observed.as_ref(),
+        csp_nonce: csp_nonce.as_deref(),
     };
     let input_compression = Compression::from_content_encoding(&params.content_encoding);
     let output_compression = if params.template_cache_key.is_some() {
@@ -2797,22 +2550,13 @@ pub fn stream_publisher_body<W: Write>(
     process_response_streaming(body, output, &borrowed, output_compression)
 }
 
-/// Stream publisher body with a `</body` tail hold for live bid injection.
-///
-/// Drives the origin body through the HTML pipeline one chunk at a time, using a
-/// small buffer that holds the first raw `</body` tail. When the origin body is
-/// exhausted (`read` returns `Ok(0)`):
-///
-/// 1. [`collect_dispatched_auction`](AuctionOrchestrator::collect_dispatched_auction)
-///    is awaited with the remaining deadline.
-/// 2. Winning bids are written to `ad_bids_state`.
-/// 3. The held tail is fed through the pipeline so `lol_html` fires its
-///    `</body>` handler with bids now in state.
+/// Stream a publisher body after collecting any dispatched auction.
 ///
-/// For non-HTML content types the auction is collected before any body bytes
-/// are written (no `</body>` to inject).  If `params.dispatched_auction` is
-/// `None` the function falls back to the synchronous
-/// [`stream_publisher_body`] path.
+/// HTML requires the exact initial auction projection before the first body
+/// byte reaches the processor because the immutable boot value is emitted at
+/// `<head>`. Non-HTML responses use the same collect-before-body ordering. If
+/// `params.dispatched_auction` is `None`, the function uses the ordinary
+/// streaming pipeline directly.
 ///
 /// # Errors
 ///
@@ -2847,11 +2591,18 @@ pub async fn stream_publisher_body_async<W: Write>(
         auction_request: params.auction_request.take(),
     };
 
-    let is_html = is_html_content_type(&params.content_type);
-
-    if !is_html {
-        // Non-HTML: collect auction first, then stream.  There is no </body>
-        // to hold, so delaying the entire body until collection is acceptable.
+    if is_html_content_type(&params.content_type) {
+        let collect_refs = AuctionCollectDeps {
+            price_granularity: params.price_granularity,
+            ad_bids_state: &params.ad_bids_state,
+            browser_slots_json: params.ad_slots_script.as_deref(),
+            orchestrator,
+            services,
+            settings,
+            request_origin: request_origin(&params.request_scheme, &params.request_host),
+        };
+        collect_stream_auction(dispatched, telemetry, &collect_refs).await;
+    } else {
         collect_non_html_auction(
             dispatched,
             telemetry,
@@ -2861,74 +2612,19 @@ pub async fn stream_publisher_body_async<W: Write>(
             settings,
         )
         .await;
-        if body.is_stream() {
-            return process_response_streaming_async(
-                body,
-                output,
-                params,
-                settings,
-                integration_registry,
-            )
-            .await;
-        }
-        return stream_publisher_body(body, output, params, settings, integration_registry);
     }
 
-    // HTML: build the processor once and drive it chunk by chunk.
-    // One-behind buffer: stream chunk N-1 immediately; hold chunk N until origin
-    // EOF, then await auction and process chunk N (which contains </body>).
-    let mut processor = match create_html_stream_processor(HtmlStreamProcessorParams {
-        origin_host: &params.origin_host,
-        request_host: &params.request_host,
-        request_scheme: &params.request_scheme,
-        settings,
-        integration_registry,
-        ad_slots_script: params.ad_slots_script.as_deref().map(str::to_string),
-        ad_bids_state: Arc::clone(params.ad_bids_state.script_cell()),
-        suppress_datadome_client_side_tag: params.suppress_datadome_client_side_tag,
-        gpt_diagnostics: params.gpt_diagnostics.clone(),
-        shared_template_authorized: params.template_cache_key.is_some(),
-        csp_nonce_observed: params.csp_nonce_observed.clone(),
-    }) {
-        Ok(processor) => processor,
-        Err(err) => {
-            emit_abandoned_auction(
-                services,
-                telemetry.observation,
-                dispatched,
-                "processor_init_error",
-            )
-            .await;
-            return Err(err);
-        }
-    };
-
-    let input_compression = Compression::from_content_encoding(&params.content_encoding);
-    let output_compression = if params.template_cache_key.is_some() {
-        Compression::None
-    } else {
-        input_compression
-    };
-    stream_html_with_auction_hold(
-        body,
-        output,
-        &mut processor,
-        input_compression,
-        output_compression,
-        AuctionCollectCtx {
-            dispatched,
-            telemetry,
-            deps: AuctionCollectDeps {
-                price_granularity: params.price_granularity,
-                ad_bids_state: &params.ad_bids_state,
-                orchestrator,
-                services,
-                settings,
-                request_origin: request_origin(&params.request_scheme, &params.request_host),
-            },
-        },
-    )
-    .await
+    if body.is_stream() {
+        return process_response_streaming_async(
+            body,
+            output,
+            params,
+            settings,
+            integration_registry,
+        )
+        .await;
+    }
+    stream_publisher_body(body, output, params, settings, integration_registry)
 }
 
 /// Builds the canonical mediator placeholder [`Request`] passed to the collect
@@ -3006,12 +2702,24 @@ pub(crate) fn is_prefetch_request(req: &Request<EdgeBody>) -> bool {
     header("sec-purpose") || header("purpose")
 }
 
-/// Returns whether request-scoped signals permit an ad-eligible navigation.
+/// Returns whether an `Authorization` header must bypass shared-template use.
 ///
-/// This is the request half of the shared ad-stack gate: the configuration
-/// halves (`matched_slots`, the kill switches) are deliberately absent, because
-/// the cache policy for a structurally inactive template must distinguish a
-/// page that no request could activate from one this particular request skipped.
+/// Only the exact single value already validated by Trusted Server's edge-auth
+/// middleware is reader-neutral. Missing markers, repeated values, and any
+/// post-auth replacement fail closed.
+fn request_authorization_disqualifies(req: &Request<EdgeBody>) -> bool {
+    match req.headers().get_all(header::AUTHORIZATION).iter().count() {
+        0 => false,
+        1 => req
+            .extensions()
+            .get::<crate::auth::EdgeTerminatedAuthorization>()
+            .is_none_or(|marker| !marker.matches(req.headers())),
+        _ => true,
+    }
+}
+
+/// Returns true only when the publisher request should run the full
+/// server-side ad stack: auction dispatch plus initial ad-slot injection.
 fn is_server_side_ad_eligible_navigation(
     is_get: bool,
     is_navigation: bool,
@@ -3022,6 +2730,24 @@ fn is_server_side_ad_eligible_navigation(
     is_get && is_navigation && !is_prefetch && !is_bot && consent_allows_auction
 }
 
+pub(crate) fn should_run_server_side_ad_stack(
+    is_get: bool,
+    is_navigation: bool,
+    is_prefetch: bool,
+    is_bot: bool,
+    has_active_matched_slots: bool,
+    consent_allows_auction: bool,
+    auction_enabled: bool,
+) -> bool {
+    is_server_side_ad_eligible_navigation(
+        is_get,
+        is_navigation,
+        is_prefetch,
+        is_bot,
+        consent_allows_auction,
+    ) && has_active_matched_slots
+        && auction_enabled
+}
 /// Write winning bids from an auction result into the shared `ad_bids_state` lock.
 /// Build the request origin (`scheme://host`, where `host` includes any port)
 /// used to emit absolute first-party URLs in inline creatives. Returns an empty
@@ -3035,135 +2761,172 @@ fn request_origin(scheme: &str, host: &str) -> String {
     }
 }
 
-/// This request's auction result, in both forms the seams need.
-///
-/// The inline `</body>` seam injects a rendered `<script>`; the shared-template seam
-/// splices the bids into a script it builds itself, and therefore needs them
-/// structured. [`write_bids_to_state`] derives both from one bid map under one call, so
-/// the two can never describe different auctions.
-///
-/// # Why the map is carried rather than recovered
-///
-/// An earlier revision stored only the script and reconstructed the map by un-escaping
-/// it. [`html_escape_for_script`] escapes `"` as `\"`, so the extracted text was invalid
-/// JSON for every non-empty map; `serde_json::from_str` failed and `unwrap_or_default()`
-/// turned the failure into `{}`. Shared modes therefore served **zero bids**, silently,
-/// on every request that had any. Every fixture had empty bids, so nothing caught it.
+/// Shared, single-writer initial browser projection for HTML processing and
+/// per-reader C2 assembly.
 #[derive(Clone, Default)]
 pub(crate) struct AdBidsState {
-    /// Rendered bids `<script>`. Shared with the HTML processor's `</body>` handler,
-    /// which is why this stays an `Option<String>` cell rather than moving inside the
-    /// same lock as the map.
-    script: Arc<Mutex<Option<String>>>,
-    /// The same bids, structured, for the shared-template seam.
-    bids: Arc<Mutex<serde_json::Map<String, serde_json::Value>>>,
-    /// Optional per-request diagnostics emitted before either bids-script shape.
-    debug_prefix: Arc<Mutex<String>>,
+    projection: Arc<Mutex<Option<String>>>,
+}
+
+impl core::ops::Deref for AdBidsState {
+    type Target = Mutex<Option<String>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.projection
+    }
 }
 
 #[cfg(test)]
 impl AdBidsState {
-    /// A state whose rendered script is already set, for tests that exercise the inline
-    /// `</body>` seam without running an auction.
-    fn with_script(script: &str) -> Self {
+    fn with_script(value: &str) -> Self {
         let state = Self::default();
-        *state.script.lock().expect("should lock bid script") = Some(script.to_string());
+        *state.lock().expect("should lock projection state") = Some(value.to_string());
         state
     }
 }
 
 impl AdBidsState {
-    /// The cell the HTML processor reads at the `</body>` seam.
     pub(crate) fn script_cell(&self) -> &Arc<Mutex<Option<String>>> {
-        &self.script
-    }
-
-    /// Record one auction result, rendering the script from the same map that is
-    /// stored, so the two representations cannot drift.
-    fn set(&self, bid_map: serde_json::Map<String, serde_json::Value>) {
-        let bids_script = build_bids_script(&bid_map);
-        *self.script.lock().expect("should lock bid script") = Some(bids_script);
-        *self.bids.lock().expect("should lock bid map") = bid_map;
-    }
-
-    /// The structured bids the shared-template seam splices into the marker.
-    ///
-    /// Empty when no auction has been collected, which is the same payload the inline
-    /// seam falls back to.
-    pub(crate) fn bids(&self) -> serde_json::Map<String, serde_json::Value> {
-        self.bids.lock().expect("should lock bid map").clone()
+        &self.projection
     }
 
-    /// Build the shared-template seam, retaining the same debug prefix as inline.
-    fn build_seam_script(&self, slots_json: &str) -> String {
-        let seam = build_seam_script(slots_json, &self.bids());
-        let prefix = self
-            .debug_prefix
-            .lock()
-            .expect("should lock bid debug prefix");
-        if prefix.is_empty() {
-            seam
-        } else {
-            format!("{prefix}\n{seam}")
-        }
-    }
-
-    /// Put `comment` immediately before the rendered bids script.
-    ///
-    /// Debug-only, and deliberately confined to the script: the structured map is what
-    /// the shared seam serializes, so prefixing an HTML comment onto it would be
-    /// meaningless there.
     fn prepend_to_script(&self, comment: &str) {
         let mut state = self
-            .script
             .lock()
-            .expect("should lock bid script for debug");
+            .expect("should lock projection state for debug prefix");
         match &mut *state {
-            Some(script) => {
-                *script = format!("{comment}\n{script}");
-            }
-            None => {
-                // invariant: write_bids_to_state is always called before this and
-                // always sets Some(_); this branch is unreachable in production.
-                *state = Some(comment.to_string());
-            }
-        }
-        let mut prefix = self
-            .debug_prefix
-            .lock()
-            .expect("should lock bid debug prefix");
-        if prefix.is_empty() {
-            *prefix = comment.to_string();
-        } else {
-            *prefix = format!("{comment}\n{prefix}");
+            Some(projection) => *projection = format!("{comment}\n{projection}"),
+            None => *state = Some(comment.to_string()),
         }
     }
 }
 
-pub(crate) fn write_bids_to_state(
-    winning_bids: &std::collections::HashMap<String, Bid>,
+fn mint_browser_auction_id(
+    identity_generator: &dyn AuctionIdentityGenerator,
+) -> Result<String, Report<TrustedServerError>> {
+    mint_response_unique_base64url_identity(identity_generator, &mut HashSet::new(), "a1_", 9, 8)
+        .ok_or_else(|| {
+            Report::new(TrustedServerError::Auction {
+                message: "Failed to mint browser auction identity".to_string(),
+            })
+        })
+}
+
+/// Write the one exact initial browser projection into the pre-core boot state.
+pub(crate) fn write_projection_to_state(
+    result: &OrchestrationResult,
     price_granularity: PriceGranularity,
     ad_bids_state: &AdBidsState,
     settings: &Settings,
     request_origin: &str,
-    include_debug_bid: bool,
-    auction_id: Option<&str>,
-) -> std::collections::HashSet<String> {
-    log::debug!(
-        "write_bids_to_state: {} winning bid(s): [{}]",
-        winning_bids.len(),
-        winning_bids.keys().cloned().collect::<Vec<_>>().join(", ")
-    );
-    let bid_map = build_bid_map_with_auction_id(
-        winning_bids,
+    browser_slots_json: Option<&str>,
+) -> HashSet<String> {
+    let browser_auction_id = match mint_browser_auction_id(&SystemAuctionIdentityGenerator) {
+        Ok(auction_id) => auction_id,
+        Err(error) => {
+            log::error!("initial browser auction identity failed closed: {error:?}");
+            *ad_bids_state.lock().expect("should lock projection state") = Some(
+                r#"{"version":1,"auction":{"version":1,"auctionId":"a1_unavailable","results":[]},"slots":[],"bids":[]}"#
+                    .to_string(),
+            );
+            return HashSet::new();
+        }
+    };
+    let fallback_slots = browser_slots_json
+        .and_then(|json| serde_json::from_str::<Vec<BrowserAuctionSlotV1>>(json).ok());
+    let projected = coordinated_cutover_v1::build_browser_auction_projection_v1(
+        result,
         price_granularity,
         settings,
         request_origin,
-        include_debug_bid,
-        auction_id,
-    );
-    let delivered_winner_slots = bid_map.keys().cloned().collect();
-    ad_bids_state.set(bid_map);
+        Some(&browser_auction_id),
+        &SystemAuctionIdentityGenerator,
+    )
+    .and_then(|projection| {
+        let slots = browser_slots_json.map_or_else(
+            || {
+                if projection.projection.auction.results.is_empty() {
+                    Ok(Vec::new())
+                } else {
+                    Err(Report::new(TrustedServerError::Auction {
+                        message: "Initial browser slot projection is unavailable".to_string(),
+                    }))
+                }
+            },
+            |json| {
+                serde_json::from_str::<Vec<BrowserAuctionSlotV1>>(json).map_err(|error| {
+                    Report::new(TrustedServerError::Auction {
+                        message: format!("Invalid browser slot projection: {error}"),
+                    })
+                })
+            },
+        )?;
+        coordinated_cutover_v1::attach_browser_slots_v1(projection, slots, request_origin)
+    });
+    let (json, delivered_winner_slots) = match projected {
+        Ok(CanonicalBrowserAuctionProjectionV1 {
+            projection, json, ..
+        }) => {
+            let delivered = projection
+                .auction
+                .results
+                .iter()
+                .filter_map(|decision| match decision {
+                    SlotAuctionDecisionV1::Winner { slot, .. } => Some(slot.clone()),
+                    _ => None,
+                })
+                .collect();
+            (
+                String::from_utf8(json).expect("should serialize projection as UTF-8"),
+                delivered,
+            )
+        }
+        Err(error) => {
+            log::error!("initial browser auction projection failed closed: {error:?}");
+            let mut fallback_results: Vec<SlotAuctionDecisionV1> = result
+                .decision_set
+                .results
+                .iter()
+                .map(|decision| match decision {
+                    SlotAuctionDecisionV1::Winner { slot, .. } => SlotAuctionDecisionV1::Failed {
+                        slot: slot.clone(),
+                        reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                    },
+                    decision => decision.clone(),
+                })
+                .collect();
+            let fallback_slots = fallback_slots
+                .filter(|slots| {
+                    slots.len() == fallback_results.len()
+                        && slots
+                            .iter()
+                            .zip(&fallback_results)
+                            .all(|(slot, decision)| slot.slot == decision.slot())
+                })
+                .unwrap_or_else(|| {
+                    // Without exact server-generated placement coverage, the
+                    // only valid browser-boot fallback is the empty projection.
+                    fallback_results.clear();
+                    Vec::new()
+                });
+            let projection = BrowserAuctionProjectionV1 {
+                version: 1,
+                auction: AuctionDecisionSetV1 {
+                    version: 1,
+                    auction_id: browser_auction_id,
+                    results: fallback_results,
+                },
+                slots: fallback_slots,
+                bids: Vec::new(),
+            };
+            (
+                serde_json::to_string(&projection)
+                    .expect("should serialize fail-closed projection as UTF-8"),
+                HashSet::new(),
+            )
+        }
+    };
+    *ad_bids_state.lock().expect("should lock projection state") = Some(json);
     delivered_winner_slots
 }
 
@@ -3212,6 +2975,20 @@ fn validated_http_status(
         .filter(|status| (100..=599).contains(status))
 }
 
+/// Return only the closed, typed local drop-reason map emitted by TS itself.
+/// Unknown names, non-integer counts, zero counts, and mixed-validity maps are
+/// rejected as a whole rather than copying provider-controlled JSON into HTML.
+fn validated_drop_reasons(
+    metadata: &std::collections::HashMap<String, serde_json::Value>,
+) -> Option<serde_json::Value> {
+    let reasons =
+        serde_json::from_value::<AuctionDropReasons>(metadata.get("drop_reasons")?.clone()).ok()?;
+    if reasons.is_empty() || reasons.values().any(|count| *count == 0) {
+        return None;
+    }
+    serde_json::to_value(reasons).ok()
+}
+
 /// Generate public diagnostic wording without copying provider-controlled text.
 ///
 /// Every [`ERROR_TYPE_ALL`] entry must map to wording here; the
@@ -3247,6 +3024,11 @@ fn redacted_metadata_for_dump(
     let http_status = validated_http_status(metadata);
     let mut safe = serde_json::Map::new();
 
+    if selected("drop_reasons")
+        && let Some(value) = validated_drop_reasons(metadata)
+    {
+        safe.insert("drop_reasons".to_string(), value);
+    }
     if selected("error_type")
         && let Some(value) = error_type
     {
@@ -3438,22 +3220,6 @@ struct AuctionTelemetryCarry {
     auction_request: Option<AuctionRequest>,
 }
 
-impl AuctionTelemetryCarry {
-    fn take(&mut self) -> Self {
-        Self {
-            observation: self.observation.take(),
-            auction_request: self.auction_request.take(),
-        }
-    }
-}
-
-/// Bundles the auction-collection state passed through the streaming helpers.
-struct AuctionCollectCtx<'a> {
-    dispatched: DispatchedAuction,
-    telemetry: AuctionTelemetryCarry,
-    deps: AuctionCollectDeps<'a>,
-}
-
 /// Borrowed dependencies of the auction collect step.
 ///
 /// Split from the per-auction state above because `dispatched` and `telemetry`
@@ -3462,6 +3228,7 @@ struct AuctionCollectCtx<'a> {
 struct AuctionCollectDeps<'a> {
     price_granularity: PriceGranularity,
     ad_bids_state: &'a AdBidsState,
+    browser_slots_json: Option<&'a str>,
     orchestrator: &'a AuctionOrchestrator,
     services: &'a RuntimeServices,
     settings: &'a Settings,
@@ -3469,356 +3236,6 @@ struct AuctionCollectDeps<'a> {
     request_origin: String,
 }
 
-/// Run the close-body hold loop for HTML bodies, collecting the auction before
-/// the raw `</body` tail is processed so `lol_html` sees live bids.
-async fn stream_html_with_auction_hold<W: Write, P: StreamProcessor>(
-    body: EdgeBody,
-    output: &mut W,
-    processor: &mut P,
-    input_compression: Compression,
-    output_compression: Compression,
-    ctx: AuctionCollectCtx<'_>,
-) -> Result<(), Report<TrustedServerError>> {
-    if body.is_stream() {
-        let max_body_bytes = ctx.deps.settings.publisher.max_buffered_body_bytes;
-        return body_close_hold_loop_stream(
-            body,
-            output,
-            processor,
-            input_compression,
-            output_compression,
-            ctx,
-            max_body_bytes,
-        )
-        .await;
-    }
-
-    // Bound the gzip decode budget to the same ceiling the buffered writer
-    // enforces, matching the streaming arm above and the no-hold buffered path.
-    let max_body_bytes = ctx.deps.settings.publisher.max_buffered_body_bytes;
-    let body = body_as_reader(body)?;
-    if output_compression == Compression::None {
-        return match input_compression {
-            Compression::None => body_close_hold_loop(body, output, processor, ctx).await,
-            Compression::Gzip => {
-                let decoder = GzipDecodeReader::new(body, max_body_bytes);
-                body_close_hold_loop(decoder, output, processor, ctx).await
-            }
-            Compression::Deflate => {
-                let decoder = ZlibDecoder::new(body);
-                body_close_hold_loop(decoder, output, processor, ctx).await
-            }
-            Compression::Brotli => {
-                let decoder = Decompressor::new(body, STREAM_CHUNK_SIZE);
-                body_close_hold_loop(decoder, output, processor, ctx).await
-            }
-        };
-    }
-
-    debug_assert_eq!(input_compression, output_compression);
-    match input_compression {
-        Compression::None => body_close_hold_loop(body, output, processor, ctx).await,
-        Compression::Gzip => {
-            // `GzipDecodeReader` decodes concatenated gzip members (RFC 1952)
-            // and bounds decoded output, unlike `flate2::read::GzDecoder`, which
-            // silently drops every member after the first — dropping trailing
-            // markup (potentially including `</body>`) on buffered adapters.
-            let decoder = GzipDecodeReader::new(body, max_body_bytes);
-            let mut encoder = GzEncoder::new(&mut *output, flate2::Compression::default());
-            body_close_hold_loop(decoder, &mut encoder, processor, ctx).await?;
-            encoder.finish().change_context(TrustedServerError::Proxy {
-                message: "Failed to finalize gzip encoder".to_string(),
-            })?;
-            Ok(())
-        }
-        Compression::Deflate => {
-            let decoder = ZlibDecoder::new(body);
-            let mut encoder = ZlibEncoder::new(&mut *output, flate2::Compression::default());
-            body_close_hold_loop(decoder, &mut encoder, processor, ctx).await?;
-            encoder.finish().change_context(TrustedServerError::Proxy {
-                message: "Failed to finalize deflate encoder".to_string(),
-            })?;
-            Ok(())
-        }
-        Compression::Brotli => {
-            let decoder = Decompressor::new(body, STREAM_CHUNK_SIZE);
-            let params = BrotliEncoderParams {
-                quality: 4,
-                lgwin: 22,
-                ..Default::default()
-            };
-            let mut encoder =
-                CompressorWriter::with_params(&mut *output, STREAM_CHUNK_SIZE, &params);
-            body_close_hold_loop(decoder, &mut encoder, processor, ctx).await?;
-            let _ = encoder.into_inner();
-            Ok(())
-        }
-    }
-}
-
-/// Async-pull variant of [`body_close_hold_loop`] for live origin streams.
-///
-/// Shares [`hold_step_next_chunk`] and the finish stages with the
-/// lazy streaming body built by [`publisher_response_into_streaming_response`],
-/// so the two async hold paths cannot drift apart.
-///
-/// No production caller reaches this today: it is only entered through
-/// [`buffer_publisher_response_async`], and the buffered adapters (Axum,
-/// Cloudflare, Spin) never produce `Body::Stream` because the publisher fetch
-/// is gated on `supports_streaming_responses()`. It is groundwork for those
-/// adapters' streaming cutover; Fastly uses the lazy stream instead.
-async fn body_close_hold_loop_stream<W: Write, P: StreamProcessor>(
-    body: EdgeBody,
-    writer: &mut W,
-    processor: &mut P,
-    input_compression: Compression,
-    output_compression: Compression,
-    ctx: AuctionCollectCtx<'_>,
-    max_body_bytes: usize,
-) -> Result<(), Report<TrustedServerError>> {
-    let AuctionCollectCtx {
-        dispatched,
-        telemetry,
-        deps: collect_refs,
-    } = ctx;
-    let mut decoder = BodyStreamDecoder::new(input_compression, max_body_bytes);
-    let mut encoder = BodyStreamEncoder::new(output_compression);
-    let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE).with_max_bytes(max_body_bytes);
-    let mut state = AuctionHoldState::new(DispatchedAuctionGuard::new(dispatched), telemetry);
-
-    while let Some(step) = hold_step_next_chunk(
-        &mut source,
-        &mut decoder,
-        &mut encoder,
-        processor,
-        &mut state,
-        &collect_refs,
-    )
-    .await?
-    {
-        // Write the ready prefix before collecting the auction, matching the
-        // lazy Fastly stream: only the held `</body>` tail waits on collection.
-        for encoded in step.ready {
-            write_encoded_segment(writer, &encoded)?;
-        }
-        if step.close_found {
-            for encoded in
-                hold_collect_close_tail(processor, &mut encoder, &mut state, &collect_refs).await?
-            {
-                write_encoded_segment(writer, &encoded)?;
-            }
-        }
-    }
-
-    // Write the decoder-finalized prefix before collection, matching the lazy
-    // Fastly stream: only the held `</body>` tail waits on the auction.
-    for encoded in hold_finish_ready_segments(
-        processor,
-        &mut decoder,
-        &mut encoder,
-        &mut state,
-        &collect_refs,
-    )
-    .await?
-    {
-        write_encoded_segment(writer, &encoded)?;
-    }
-    for encoded in
-        hold_finish_tail_segments(processor, &mut encoder, &mut state, &collect_refs).await?
-    {
-        write_encoded_segment(writer, &encoded)?;
-    }
-    writer.flush().change_context(TrustedServerError::Proxy {
-        message: "Failed to flush output".to_string(),
-    })?;
-    Ok(())
-}
-
-const BODY_CLOSE_PREFIX: &[u8] = b"</body";
-
-struct BodyCloseHoldBuffer {
-    buffered: Vec<u8>,
-    found_close: bool,
-}
-
-impl BodyCloseHoldBuffer {
-    fn new() -> Self {
-        Self {
-            buffered: Vec::new(),
-            found_close: false,
-        }
-    }
-
-    fn push(&mut self, chunk: &[u8]) -> Vec<u8> {
-        self.buffered.extend_from_slice(chunk);
-
-        if self.found_close {
-            return Vec::new();
-        }
-
-        if let Some(pos) = find_ascii_case_insensitive(&self.buffered, BODY_CLOSE_PREFIX) {
-            self.found_close = true;
-            return self.buffered.drain(..pos).collect();
-        }
-
-        let keep_len = BODY_CLOSE_PREFIX.len().saturating_sub(1);
-        if self.buffered.len() <= keep_len {
-            return Vec::new();
-        }
-
-        let split_at = self.buffered.len() - keep_len;
-        self.buffered.drain(..split_at).collect()
-    }
-
-    fn found_close(&self) -> bool {
-        self.found_close
-    }
-
-    fn finish(self) -> Vec<u8> {
-        self.buffered
-    }
-}
-
-fn find_ascii_case_insensitive(haystack: &[u8], needle: &[u8]) -> Option<usize> {
-    haystack.windows(needle.len()).position(|window| {
-        window
-            .iter()
-            .zip(needle)
-            .all(|(left, right)| left.eq_ignore_ascii_case(right))
-    })
-}
-
-/// Core close-body hold loop.
-///
-/// Streams processed output until the first case-insensitive `</body` prefix is
-/// seen, then collects the auction, writes bids, and processes the held tail
-/// before reading post-body chunks. If no close-body tag is found, collection
-/// happens at EOF before finalization.
-async fn body_close_hold_loop<R: std::io::Read, W: Write, P: StreamProcessor>(
-    mut reader: R,
-    writer: &mut W,
-    processor: &mut P,
-    ctx: AuctionCollectCtx<'_>,
-) -> Result<(), Report<TrustedServerError>> {
-    let AuctionCollectCtx {
-        dispatched,
-        mut telemetry,
-        deps,
-    } = ctx;
-    let mut buffer = vec![0u8; STREAM_CHUNK_SIZE];
-    let mut hold = Some(BodyCloseHoldBuffer::new());
-    let mut dispatched = Some(dispatched);
-
-    loop {
-        match reader.read(&mut buffer) {
-            Ok(0) => {
-                if let Some(hold) = hold.take() {
-                    let dispatched = dispatched
-                        .take()
-                        .expect("should have dispatched auction to collect");
-                    collect_stream_auction(dispatched, telemetry.take(), &deps).await;
-
-                    let held = hold.finish();
-                    write_processed_chunk(
-                        writer,
-                        processor,
-                        &held,
-                        false,
-                        "Failed to process held body close",
-                        "Failed to write held body close",
-                    )?;
-                }
-                // Signal EOF to lol_html (fires end() which flushes remaining state).
-                let final_out = processor.process_chunk(&[], true).change_context(
-                    TrustedServerError::Proxy {
-                        message: "Failed to finalize processor".to_string(),
-                    },
-                )?;
-                if !final_out.is_empty() {
-                    writer
-                        .write_all(&final_out)
-                        .change_context(TrustedServerError::Proxy {
-                            message: "Failed to write finalized output".to_string(),
-                        })?;
-                }
-                break;
-            }
-            Ok(n) => {
-                if let Some(hold_buffer) = hold.as_mut() {
-                    let ready = hold_buffer.push(&buffer[..n]);
-                    if let Err(err) = write_processed_chunk(
-                        writer,
-                        processor,
-                        &ready,
-                        false,
-                        "Failed to process chunk",
-                        "Failed to write chunk",
-                    ) {
-                        if let Some(dispatched) = dispatched.take() {
-                            emit_abandoned_auction(
-                                deps.services,
-                                telemetry.observation.take(),
-                                dispatched,
-                                "stream_process_error",
-                            )
-                            .await;
-                        }
-                        return Err(err);
-                    }
-
-                    if hold_buffer.found_close() {
-                        let dispatched = dispatched
-                            .take()
-                            .expect("should have dispatched auction to collect");
-                        collect_stream_auction(dispatched, telemetry.take(), &deps).await;
-
-                        let held = hold
-                            .take()
-                            .expect("should have close-body hold buffer")
-                            .finish();
-                        write_processed_chunk(
-                            writer,
-                            processor,
-                            &held,
-                            false,
-                            "Failed to process held body close",
-                            "Failed to write held body close",
-                        )?;
-                    }
-                } else {
-                    write_processed_chunk(
-                        writer,
-                        processor,
-                        &buffer[..n],
-                        false,
-                        "Failed to process chunk",
-                        "Failed to write chunk",
-                    )?;
-                }
-            }
-            Err(e) => {
-                if let Some(dispatched) = dispatched.take() {
-                    emit_abandoned_auction(
-                        deps.services,
-                        telemetry.observation.take(),
-                        dispatched,
-                        "stream_read_error",
-                    )
-                    .await;
-                }
-                return Err(Report::new(TrustedServerError::Proxy {
-                    message: format!("Failed to read origin body: {e}"),
-                }));
-            }
-        }
-    }
-
-    writer.flush().change_context(TrustedServerError::Proxy {
-        message: "Failed to flush output".to_string(),
-    })?;
-    Ok(())
-}
-
 async fn emit_abandoned_auction(
     services: &RuntimeServices,
     observation: Option<AuctionObservationContext>,
@@ -3855,10 +3272,6 @@ async fn collect_non_html_auction(
     services: &RuntimeServices,
     settings: &Settings,
 ) {
-    let auction_id = telemetry
-        .auction_request
-        .as_ref()
-        .and_then(|_| diagnostics_auction_id(settings));
     let placeholder = mediator_placeholder_request();
     let result = orchestrator
         .collect_dispatched_auction(
@@ -3867,14 +3280,13 @@ async fn collect_non_html_auction(
             &make_collect_context(settings, services, &placeholder),
         )
         .await;
-    let delivered_winner_slots = write_bids_to_state(
-        &result.winning_bids,
+    let delivered_winner_slots = write_projection_to_state(
+        &result,
         params.price_granularity,
         &params.ad_bids_state,
         settings,
         &request_origin(&params.request_scheme, &params.request_host),
-        settings.debug.inject_adm_for_testing,
-        auction_id.as_deref(),
+        params.ad_slots_script.as_deref(),
     );
     if let (Some(observation), Some(auction_request)) =
         (telemetry.observation, telemetry.auction_request.as_ref())
@@ -3893,7 +3305,7 @@ async fn collect_non_html_auction(
     }
 }
 
-// Private orchestration helper called only from `body_close_hold_loop`.
+// Private orchestration helper used by the streaming response paths.
 // `dispatched` and `telemetry` are moved per collect, so they stay by value
 // while the rest of the context is borrowed.
 async fn collect_stream_auction(
@@ -3904,33 +3316,29 @@ async fn collect_stream_auction(
     let AuctionCollectDeps {
         price_granularity,
         ad_bids_state,
+        browser_slots_json,
         orchestrator,
         services,
         settings,
         request_origin,
     } = deps;
-    let auction_id = telemetry
-        .auction_request
-        .as_ref()
-        .and_then(|_| diagnostics_auction_id(settings));
-    log::info!("body_close_hold_loop: collecting dispatched auction before held body tail");
+    log::info!("streaming response: collecting dispatched auction");
     let placeholder = mediator_placeholder_request();
     let collect_ctx = make_collect_context(settings, services, &placeholder);
     let result = orchestrator
         .collect_dispatched_auction(dispatched, services, &collect_ctx)
         .await;
     log::info!(
-        "body_close_hold_loop: collect complete - {} winning bid(s)",
+        "streaming response: collect complete - {} winning bid(s)",
         result.winning_bids.len()
     );
-    let delivered_winner_slots = write_bids_to_state(
-        &result.winning_bids,
+    let delivered_winner_slots = write_projection_to_state(
+        &result,
         *price_granularity,
         ad_bids_state,
         settings,
         request_origin,
-        settings.debug.inject_adm_for_testing,
-        auction_id.as_deref(),
+        *browser_slots_json,
     );
     if let (Some(observation), Some(auction_request)) =
         (telemetry.observation, telemetry.auction_request.as_ref())
@@ -3958,35 +3366,6 @@ async fn collect_stream_auction(
     }
 }
 
-fn write_processed_chunk<W: Write, P: StreamProcessor>(
-    writer: &mut W,
-    processor: &mut P,
-    chunk: &[u8],
-    is_last: bool,
-    process_error: &str,
-    write_error: &str,
-) -> Result<(), Report<TrustedServerError>> {
-    if chunk.is_empty() && !is_last {
-        return Ok(());
-    }
-
-    let out =
-        processor
-            .process_chunk(chunk, is_last)
-            .change_context(TrustedServerError::Proxy {
-                message: process_error.to_string(),
-            })?;
-    if !out.is_empty() {
-        writer
-            .write_all(&out)
-            .change_context(TrustedServerError::Proxy {
-                message: write_error.to_string(),
-            })?;
-    }
-
-    Ok(())
-}
-
 /// Auction dispatch context passed to [`handle_publisher_request`].
 pub struct AuctionDispatch<'a> {
     /// Orchestrator that dispatches and collects SSP bid requests.
@@ -4026,6 +3405,8 @@ pub async fn handle_publisher_request(
     // idempotent call as a direct-handler safety net and for focused tests.
     let gpt_diagnostics =
         crate::integrations::gpt_diagnostics::prepare_request(settings, &mut req)?;
+    let render_trace_overlay = crate::trace_cookie::render_trace_overlay_active(&req);
+    let aps_enabled = auction.orchestrator.is_enabled() && auction.orchestrator.has_profile("aps");
 
     // Prebid.js requests are not intercepted here anymore. The HTML processor removes
     // publisher-supplied Prebid scripts; the unified TSJS bundle includes Prebid.js when enabled.
@@ -4112,13 +3493,14 @@ pub async fn handle_publisher_request(
     let is_prefetch = is_prefetch_request(&req);
     let is_bot = is_bot_user_agent(&req);
 
-    let creative_opportunities = settings.creative_opportunities.as_ref();
-    let ad_templates_enabled = creative_opportunities.is_some_and(|co_config| co_config.enabled);
-    let ad_templates_disabled = creative_opportunities.is_some_and(|co_config| !co_config.enabled);
-    let matched_slots = if is_get && ad_templates_enabled {
-        creative_opportunities.map_or_else(Vec::new, |co_config| {
-            match_renderable_slots(auction.slots, co_config, &request_path)
-        })
+    let matched_slots = if is_get {
+        settings
+            .creative_opportunities
+            .as_ref()
+            .filter(|co_config| co_config.enabled)
+            .map_or_else(Vec::new, |co_config| {
+                match_renderable_slots(auction.slots, co_config, &request_path)
+            })
     } else {
         Vec::new()
     };
@@ -4128,34 +3510,29 @@ pub async fn handle_publisher_request(
     // (storage/access) before firing. Known non-GDPR jurisdictions are free.
     let consent_allows_auction = consent_allows_server_side_auction(&consent_context);
 
-    let should_run_ad_stack = evaluate_ad_stack_gate(AdStackGateInput {
-        method_get: is_get,
-        navigation: is_navigation,
-        prefetch: is_prefetch,
-        bot: is_bot,
-        matched_slots: !matched_slots.is_empty(),
-        consent_allows_auction: Some(consent_allows_auction),
-        auction_enabled: auction.orchestrator.is_enabled(),
-        ad_templates_enabled,
-    })
-    .expected
-        == RuntimeAdStackExpected::Yes;
+    let should_run_ad_stack = should_run_server_side_ad_stack(
+        is_get,
+        is_navigation,
+        is_prefetch,
+        is_bot,
+        !matched_slots.is_empty(),
+        consent_allows_auction,
+        auction.orchestrator.is_enabled(),
+    );
     let should_run_auction = should_run_ad_stack;
     // Diagnostic: shows which gate suppresses the server-side auction. Pair with
     // the `EC context: ... jurisdiction=...` line from EC-context construction
     // when `consent_allows_auction=false`.
     log::debug!(
         "server-side ad-stack gate: is_get={is_get} is_navigation={is_navigation} \
-         is_prefetch={is_prefetch} is_bot={is_bot} ad_templates_enabled={ad_templates_enabled} \
-         matched_slots={} consent_allows_auction={consent_allows_auction} \
+         is_prefetch={is_prefetch} is_bot={is_bot} matched_slots={} \
+         consent_allows_auction={consent_allows_auction} \
          orchestrator_enabled={} -> should_run_auction={should_run_auction}",
         matched_slots.len(),
         auction.orchestrator.is_enabled(),
     );
 
-    if ad_templates_disabled {
-        log::debug!("Server-side ad templates are disabled by configuration");
-    } else if matched_slots.is_empty() && settings.creative_opportunities.is_some() {
+    if matched_slots.is_empty() && settings.creative_opportunities.is_some() {
         log::debug!(
             "No creative opportunity slots matched path '{}' — skipping auction and injection",
             request_path
@@ -4175,6 +3552,14 @@ pub async fn handle_publisher_request(
         .as_ref()
         .map(|co| co.price_granularity)
         .unwrap_or_default();
+    let browser_slots_json = should_run_ad_stack
+        .then(|| {
+            settings
+                .creative_opportunities
+                .as_ref()
+                .map(|config| build_browser_slots_json(&matched_slots, config, &request_path))
+        })
+        .flatten();
 
     // Dispatch SSP bid requests while req still has the original client headers
     // (User-Agent, x-forwarded-for, cookies, etc.).  The borrow ends when
@@ -4236,66 +3621,82 @@ pub async fn handle_publisher_request(
                 provider_responses: None,
                 services,
             };
-            match auction
+            let dispatch_outcome = auction
                 .orchestrator
                 .dispatch_auction(&auction_request, &auction_context)
-                .await
+                .await;
+            match auction
+                .orchestrator
+                .resolve_dispatch_outcome(&auction_request, dispatch_outcome)
             {
-                DispatchAuctionOutcome::Dispatched(dispatched) => {
+                Ok(ResolvedDispatchOutcome::InFlight(dispatched)) => {
                     auction_request_for_telemetry = Some(auction_request);
                     auction_observation = Some(observation);
-                    Some(dispatched)
+                    Some(*dispatched)
                 }
-                DispatchAuctionOutcome::DispatchFailed {
-                    request,
-                    provider_responses,
-                    fatal_admission_error,
-                    metadata,
-                    elapsed_ms,
-                } => {
-                    if let Some(error) = fatal_admission_error {
-                        log::warn!(
-                            "Auction admission failed before publisher dispatch; continuing without bids: {error:?}"
-                        );
-                    }
-                    if !metadata.is_empty() {
-                        log::info!("Auction dispatch failure metadata: {metadata:?}");
-                    }
+                Ok(ResolvedDispatchOutcome::Complete(result)) => {
+                    let result = *result;
+                    let delivered_winner_slots = write_projection_to_state(
+                        &result,
+                        price_granularity,
+                        &ad_bids_state,
+                        settings,
+                        &request_origin(request_scheme, request_host),
+                        browser_slots_json.as_deref(),
+                    );
                     emit_auction_events_best_effort_lazy(services, || {
                         build_auction_events(
                             observation,
-                            AuctionTerminalOutcome::DispatchFailed {
-                                request: &request,
-                                provider_responses: &provider_responses,
-                                reason: "dispatch_failed",
-                                elapsed_ms,
+                            AuctionTerminalOutcome::Completed {
+                                request: &auction_request,
+                                result: &result,
+                                delivered_winner_slots: Some(&delivered_winner_slots),
                             },
                         )
                     })
                     .await;
+                    if settings.debug.auction_html_comment {
+                        prepend_auction_debug_comment(
+                            "dispatch",
+                            &result,
+                            &ad_bids_state,
+                            &settings.debug.auction_html_comment_options,
+                        );
+                    }
                     None
                 }
-                DispatchAuctionOutcome::NotStarted => {
+                Err(error) => {
+                    log::warn!("server-side auction dispatch failed: {error:?}");
                     let elapsed_ms = observation.elapsed_ms();
                     emit_auction_events_best_effort_lazy(services, || {
                         build_auction_events(
                             observation,
-                            AuctionTerminalOutcome::DispatchFailed {
-                                request: &auction_request,
+                            AuctionTerminalOutcome::ExecutionFailed {
+                                request: Some(&auction_request),
                                 provider_responses: &[],
-                                reason: "no_provider_dispatched",
+                                reason: "dispatch_failed",
                                 elapsed_ms,
                             },
                         )
                     })
                     .await;
+                    let result = OrchestrationResult::no_bid(
+                        &auction_request,
+                        AuctionSlotFailureReason::InternalError,
+                    );
+                    write_projection_to_state(
+                        &result,
+                        price_granularity,
+                        &ad_bids_state,
+                        settings,
+                        &request_origin(request_scheme, request_host),
+                        browser_slots_json.as_deref(),
+                    );
                     None
                 }
             }
         } else {
-            let skip_reason = if ad_templates_disabled {
-                "ad_templates_disabled"
-            } else if !auction.orchestrator.is_enabled() {
+            let skip_reason = if !auction.orchestrator.is_enabled() {
                 "auction_disabled"
             } else if !consent_allows_auction {
                 "consent_denied"
@@ -4332,15 +3733,7 @@ pub async fn handle_publisher_request(
     // Capture cache eligibility before the origin send consumes the request. One
     // unchanged marked Authorization value passed edge auth; unmarked, replaced,
     // or repeated values remain pass-through and bypass sharing.
-    let authorization_value_count = req.headers().get_all(header::AUTHORIZATION).iter().count();
-    let authorization_disqualifies = match authorization_value_count {
-        0 => false,
-        1 => req
-            .extensions()
-            .get::<crate::auth::EdgeTerminatedAuthorization>()
-            .is_none_or(|marker| !marker.matches(req.headers())),
-        _ => true,
-    };
+    let authorization_disqualifies = request_authorization_disqualifies(&req);
     let request_had_cookie = req.headers().contains_key(header::COOKIE);
     // Whether carrying a cookie is itself disqualifying. Computed once and used for both
     // the lookup and the store, so the two cannot drift apart.
@@ -4365,7 +3758,7 @@ pub async fn handle_publisher_request(
     let datadome_suppression_requires_origin = suppress_datadome_client_side_tag;
     let datadome_suppression_requires_full_body =
         suppress_datadome_client_side_tag && is_html_document_request(&req);
-    let request_requires_origin = request_bypasses_template_cache(req.headers())
+    let request_requires_origin = request_bypasses_c2(req.headers())
         || gpt_diagnostics.requires_private_no_store()
         || datadome_suppression_requires_origin;
     let reader_compression = negotiate_reader_compression(req.headers());
@@ -4454,15 +3847,9 @@ pub async fn handle_publisher_request(
         })?,
     );
 
-    // The slots the head seam deliberately withheld, routed to the `</body>` seam so they
-    // travel per request instead of into a template shared between readers.
-    let seam_ad_slots = seam_ad_slots_json(
-        assembly_mode,
-        should_run_ad_stack,
-        settings,
-        &matched_slots,
-        &request_path,
-    );
+    // Exact ordered placements are request state. Inline processing carries
+    // them in the head boot; C2 carries the same JSON in its per-reader seam.
+    let seam_ad_slots = browser_slots_json.clone();
 
     // Template-cache lookup happens before the origin fetch — the whole point is to skip it.
     //
@@ -4515,7 +3902,8 @@ pub async fn handle_publisher_request(
                     //
                     // Headers are constructed rather than replayed, so no origin header
                     // can reach a second reader through the cache.
-                    let response = build_cached_template_response(&entry, reader_compression)?;
+                    let mut response = build_cached_template_response(&entry, reader_compression)?;
+                    ensure_aps_publisher_frame_policy(&mut response, aps_enabled);
                     let mut params = build_template_assembly_params(
                         &entry,
                         settings,
@@ -4523,8 +3911,10 @@ pub async fn handle_publisher_request(
                         request_scheme,
                         price_granularity,
                         ad_bids_state.clone(),
+                        render_trace_overlay,
                     );
                     params.seam_ad_slots = seam_ad_slots.clone();
+                    params.ad_slots_script = browser_slots_json.clone();
                     params.dispatched_auction = dispatched_auction.take();
                     params.auction_observation = auction_observation.take();
                     params.auction_request = auction_request_for_telemetry.clone();
@@ -4618,11 +4008,19 @@ pub async fn handle_publisher_request(
             .change_context(TrustedServerError::Proxy {
                 message: "failed to build unexpected origin 304 response".to_string(),
             })?;
+        crate::integrations::gpt_diagnostics::finalize_response(&gpt_diagnostics, &mut response);
+        append_aps_publisher_frame_policy(&mut response, aps_enabled);
         enforce_terminal_private_cache_privacy(&mut response);
         return Ok(PublisherResponse::Buffered(response));
     }
 
-    let template_cache_policy = TemplateCachePolicy::from_settings(settings);
+    crate::integrations::gpt_diagnostics::finalize_response(&gpt_diagnostics, &mut response);
+    append_aps_publisher_frame_policy(&mut response, aps_enabled);
+
+    // A request key only authorizes lookup. The origin response must separately
+    // prove that the transformed representation is safe and fresh enough to
+    // store before the reservation becomes an authorized C2 write.
+    let c2_cache_policy = C2CachePolicy::from_settings(settings);
     let gate_content_type = response
         .headers()
         .get(header::CONTENT_TYPE)
@@ -4630,48 +4028,40 @@ pub async fn handle_publisher_request(
         .unwrap_or_default()
         .to_string();
     let mut template_cache_key = template_cache_reservation.and_then(|reservation| {
-        match template_cache_ttl(
+        match c2_cache_ttl(
             assembly_mode,
             authorization_disqualifies,
             cookie_disqualifies,
             response.status(),
             &gate_content_type,
             response.headers(),
-            &template_cache_policy,
+            &c2_cache_policy,
         ) {
             Err(reason) => {
-                log::debug!("template_cache bypass: {reason}");
+                log::debug!("c2_template_cache bypass: {reason}");
                 None
             }
-            Ok(ttl) => {
-                log::debug!("template_cache eligible for {}s", ttl.as_secs());
-                let Some(expires_at) = Instant::now().checked_add(ttl) else {
-                    log::warn!("template_cache bypass: origin freshness cannot be represented");
-                    return None;
-                };
-                Some(AuthorizedTemplateStore {
+            Ok(ttl) => Instant::now()
+                .checked_add(ttl)
+                .map(|expires_at| AuthorizedTemplateStore {
                     reservation,
                     expires_at,
-                })
-            }
+                }),
         }
     });
     let policy_headers = if template_cache_key.is_some() {
         match replayable_policy_headers(response.headers()) {
             Ok(headers) => headers,
             Err(reason) => {
-                // The eligibility gate checks this same input immediately above. Keep
-                // the second read fail-closed in case future code mutates the response
-                // between authorization and metadata capture.
                 log::warn!(
-                    "template_cache bypass: policy metadata changed after validation ({reason})"
+                    "c2_template_cache bypass: policy metadata changed after validation ({reason})"
                 );
                 template_cache_key = None;
                 Vec::new()
             }
         }
     } else {
-        Vec::new()
+        runtime_policy_headers(response.headers())
     };
     if template_cache_response_state == Some(TemplateCacheResponseState::MissReserved)
         && template_cache_key.is_none()
@@ -4686,15 +4076,7 @@ pub async fn handle_publisher_request(
     // from configuration. Deciding them independently is what produced a document with
     // unresolved executable ESI markup and no bids: the body seam saw `Esi` and emitted
     // a marker, the head seam emitted no `adSlots`, and nothing assembled either.
-    let assembly_mode = effective_assembly_mode(settings, template_cache_key.is_some());
-
-    let ad_slots_script = template_ad_slots_script(
-        assembly_mode,
-        should_run_ad_stack,
-        settings,
-        &matched_slots,
-        &request_path,
-    );
+    let ad_slots_script = browser_slots_json.clone();
 
     // §4.7: HTML with synthesized per-navigation auction state must not be
     // stored or validated as an origin representation. Strip both browser and
@@ -4717,10 +4099,11 @@ pub async fn handle_publisher_request(
     // stamp.
     // Gate on `should_run_ad_stack` rather than content-type alone: when no slot
     // matched, the feature is disabled, or this is not an ad-eligible navigation,
-    // no per-user `tsjs.adSlots`/`tsjs.bids` are injected. Applies regardless of
-    // the auction *outcome* (empty bids still inject per-user slot state). The
-    // separate EC-cookie cache net in the adapter's `finalize_response` keeps
-    // first-visit identity responses private.
+    // no per-navigation browser auction projection is injected, so forcing private
+    // here would needlessly strip shared cacheability from ordinary publisher
+    // HTML. Applies regardless of the auction *outcome* (empty bids still inject
+    // per-user slot state). The separate EC-cookie cache net in the adapter's
+    // `finalize_response` keeps first-visit identity responses private.
     let origin_content_type = response
         .headers()
         .get(header::CONTENT_TYPE)
@@ -4743,15 +4126,9 @@ pub async fn handle_publisher_request(
             is_bot,
             consent_allows_auction,
         ) && (response.status() == StatusCode::OK || is_not_modified)
+            && !cache_control_forbids_shared_storage(response.headers())
         {
-            // Issue #1007 caps browser caching for structurally inactive
-            // server-side ad templates. The cap also applies to 304 responses
-            // so revalidation cannot restore the origin freshness policy.
-            // Request-scoped skips retain the origin policy because the same URL
-            // can otherwise render templates.
-            if !cache_control_forbids_shared_storage(response.headers()) {
-                apply_inactive_ad_stack_browser_cache_policy(&mut response);
-            }
+            apply_inactive_ad_stack_browser_cache_policy(&mut response);
         }
     }
 
@@ -4888,12 +4265,13 @@ pub async fn handle_publisher_request(
                     content_type,
                     ad_slots_script: ad_slots_script.clone(),
                     ad_bids_state: ad_bids_state.clone(),
-                    suppress_datadome_client_side_tag,
                     auction_observation,
                     auction_request: auction_request_for_telemetry,
                     dispatched_auction,
                     price_granularity,
+                    suppress_datadome_client_side_tag,
                     gpt_diagnostics: Some(gpt_diagnostics),
+                    render_trace_overlay,
                 }),
             })
         }
@@ -5027,470 +4405,263 @@ pub(crate) fn build_auction_request(
     }
 }
 
-/// Mint the browser-visible auction correlation token for GPT diagnostics.
-///
-/// The token is freshly generated per auction and carries no user identity.
-/// [`AuctionRequest::id`] must never be used here: for a consented visitor it is
-/// `ts-{ec_id}`, so publishing it in `window.tsjs.bids` would hand the `HttpOnly`
-/// EC identifier to any script on the page, and — being stable per visitor — it
-/// could not distinguish one auction from the next either.
-///
-/// Returns `None` unless the GPT diagnostics integration is enabled, since
-/// nothing else consumes the value.
-fn diagnostics_auction_id(settings: &Settings) -> Option<String> {
-    crate::integrations::gpt_diagnostics::is_enabled(settings)
-        .then(|| format!("ts-auc-{}", uuid::Uuid::new_v4().simple()))
-}
+pub(crate) mod coordinated_cutover_v1 {
+    use super::*;
 
-/// Escape a JSON string so it is safe to embed inside a JS double-quoted string literal
-/// inside an HTML `<script>` block.
-///
-/// Escapes required:
-/// - `\` and `"` — prevent JS string termination / invalid escape sequences
-/// - `<`, `>`, `&` — prevent `</script>` injection breaking out of the script context
-/// - U+2028, U+2029 — line/paragraph separators that are valid JSON but terminate
-///   a JS string literal in some parsers
-///
-/// All substitutions use `\uXXXX` form, which is valid inside both JSON strings
-/// and JS string literals. The result is always safe to write as `JSON.parse("…")`.
-fn html_escape_for_script(s: &str) -> String {
-    let mut out = String::with_capacity(s.len());
-    for ch in s.chars() {
-        match ch {
-            '\\' => out.push_str("\\\\"),
-            '"' => out.push_str("\\\""),
-            '<' => out.push_str("\\u003C"),
-            '>' => out.push_str("\\u003E"),
-            '&' => out.push_str("\\u0026"),
-            '\u{2028}' => out.push_str("\\u2028"),
-            '\u{2029}' => out.push_str("\\u2029"),
-            _ => out.push(ch),
-        }
-    }
-    out
-}
+    const RENDERER_RESERVATION_BYTES: usize = 16;
+    const RENDERER_RESERVATION_COLLISION_RETRIES: usize = 8;
 
-/// Maximum length Google Ad Manager accepts for a key-value targeting value.
-/// Longer values are rejected by GAM, so the key never reaches the creative and
-/// the `hb_adid` render handshake cannot complete.
-const GAM_TARGETING_VALUE_MAX_LEN: usize = 40;
+    fn cache_source_from_legacy_bid(bid: &Bid) -> Option<BidRenderSourceV1> {
+        Some(BidRenderSourceV1::PbsCache(BaselinePbsCacheSourceV1 {
+            version: 1,
+            cache_id: bid
+                .cache_id
+                .as_deref()
+                .filter(|value| !value.is_empty())?
+                .to_string(),
+            cache_host: bid
+                .cache_host
+                .as_deref()
+                .filter(|value| !value.is_empty())?
+                .to_string(),
+            cache_path: bid
+                .cache_path
+                .as_deref()
+                .filter(|value| !value.is_empty())?
+                .to_string(),
+            width: bid.width,
+            height: bid.height,
+        }))
+    }
 
-/// Treat an empty identifier as absent.
-///
-/// `Option::or` considers `Some("")` present, which would let a blank
-/// `cacheId`/`adid` win the `hb_adid` precedence below and emit an empty
-/// targeting value — falsey on the page, so GPT skips the key and the render
-/// bridge has nothing to match, exactly the failure the fallback chain closes.
-fn non_empty(value: Option<&str>) -> Option<&str> {
-    value.filter(|value| !value.is_empty())
-}
+    fn project_render_source(
+        bid: &Bid,
+        settings: &Settings,
+        request_origin: &str,
+    ) -> Option<BidRenderSourceV1> {
+        match (&bid.renderer, &bid.creative, &bid.cache_id) {
+            (Some(source), None, None)
+                if bid.cache_host.is_none()
+                    && bid.cache_path.is_none()
+                    && !matches!(source, BidRenderSourceV1::PbsCache(_)) =>
+            {
+                Some(source.clone())
+            }
+            (None, Some(raw_creative), None)
+                if bid.cache_host.is_none() && bid.cache_path.is_none() =>
+            {
+                let priced = crate::creative::expand_auction_price_macro(
+                    raw_creative,
+                    bid.price
+                        .filter(|price| price.is_finite() && *price >= 0.0)?,
+                );
+                let adm = crate::creative::process_inline_auction_creative(
+                    settings,
+                    request_origin,
+                    &priced,
+                );
+                (!adm.is_empty()).then_some(BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+                    version: 1,
+                    adm,
+                    width: bid.width,
+                    height: bid.height,
+                }))
+            }
+            (None, None, Some(_)) => cache_source_from_legacy_bid(bid),
+            _ => None,
+        }
+    }
 
-/// Build a price-bucketed bid map from winning bids.
-///
-/// Returns a JSON object map of slot ID → bid metadata including the bucketed
-/// CPM (`hb_pb`), bidder (`hb_bidder`), and optional ad ID, nurl, and burl.
-#[cfg(test)]
-pub(crate) fn build_bid_map(
-    winning_bids: &std::collections::HashMap<String, Bid>,
-    granularity: crate::price_bucket::PriceGranularity,
-    settings: &Settings,
-    request_origin: &str,
-    include_debug_bid: bool,
-) -> serde_json::Map<String, serde_json::Value> {
-    build_bid_map_with_auction_id(
-        winning_bids,
-        granularity,
-        settings,
-        request_origin,
-        include_debug_bid,
-        None,
-    )
-}
+    fn project_targeting(
+        bid: &Bid,
+        cpm: f64,
+        granularity: PriceGranularity,
+    ) -> BTreeMap<String, String> {
+        BTreeMap::from([
+            ("hb_bidder".to_string(), bid.bidder.clone()),
+            ("hb_pb".to_string(), price_bucket(cpm, granularity)),
+        ])
+    }
 
-pub(crate) fn build_bid_map_with_auction_id(
-    winning_bids: &std::collections::HashMap<String, Bid>,
-    granularity: crate::price_bucket::PriceGranularity,
-    settings: &Settings,
-    request_origin: &str,
-    include_debug_bid: bool,
-    auction_id: Option<&str>,
-) -> serde_json::Map<String, serde_json::Value> {
-    // Inline creatives render in a foreign origin (PUC's srcdoc under GAM), so
-    // their proxy/click URLs must be absolute against the origin the visitor is
-    // actually on — scheme, host, and port. Fall back to the configured publisher
-    // domain only when the request origin is unknown (e.g. an empty host on a
-    // non-navigation path), where no inline render is expected anyway.
-    let base_origin = if request_origin.is_empty() {
-        format!("https://{}", settings.publisher.domain)
-    } else {
-        request_origin.to_owned()
-    };
-    winning_bids
-        .iter()
-        .filter_map(|(slot_id, bid)| {
-            bid.price.and_then(|cpm| {
-                let bucket = price_bucket(cpm, granularity);
-                let mut obj = serde_json::Map::new();
-                obj.insert("hb_pb".to_string(), serde_json::Value::String(bucket));
-                obj.insert(
-                    "hb_bidder".to_string(),
-                    serde_json::Value::String(bid.bidder.clone()),
-                );
-                if let Some(auction_id) = auction_id {
-                    obj.insert(
-                        "hb_auction_id".to_string(),
-                        serde_json::Value::String(auction_id.to_owned()),
-                    );
-                }
-                // Winning creative dimensions — the bridge sizes the inline
-                // render from these, falling back to the first configured slot
-                // format only when absent, which mis-sizes a multi-size slot.
-                // Omit a zero dimension (missing OpenRTB w/h parse to 0) so the
-                // bridge falls back rather than sizing the frame to 0.
-                if bid.width > 0 {
-                    obj.insert("w".to_string(), serde_json::Value::from(bid.width));
-                }
-                if bid.height > 0 {
-                    obj.insert("h".to_string(), serde_json::Value::from(bid.height));
-                }
-                // hb_adid: use the PBS Cache UUID when present — the Prebid
-                // Universal Creative uses this as the cache lookup key. Fall back
-                // to the selected typed-renderer bid ID, then `adid`, then the
-                // OpenRTB bid ID. The latter is the last resort: it is unique per
-                // bid instance rather than a creative, but GAM echoes it verbatim
-                // so the render bridge can find the exact winning bid.
-                let renderer_bid_id = bid.renderer.as_ref().and_then(|renderer| {
-                    renderer
-                        .as_aps()
-                        .map(|renderer| renderer.bid_id.as_str())
-                });
-                let hb_adid = non_empty(bid.cache_id.as_deref())
-                    .or_else(|| renderer_bid_id.and_then(|id| non_empty(Some(id))))
-                    .or_else(|| non_empty(bid.ad_id.as_deref()))
-                    .or_else(|| non_empty(bid.bid_id.as_deref()));
-                if let Some(id) = hb_adid {
-                    // GAM drops an over-long targeting value, so the creative
-                    // echoes nothing and the bridge's equality check never
-                    // matches. Log rather than truncate: a truncated ID is no
-                    // longer unique per bid.
-                    if id.len() > GAM_TARGETING_VALUE_MAX_LEN {
-                        log::warn!(
-                            "hb_adid for slot '{slot_id}' is {} characters, over GAM's \
-                             {GAM_TARGETING_VALUE_MAX_LEN}-character targeting value limit — \
-                             GAM may drop the key and the creative will not render",
-                            id.len()
-                        );
-                    }
-                    obj.insert(
-                        "hb_adid".to_string(),
-                        serde_json::Value::String(id.to_string()),
-                    );
-                }
-
-                // Win/billing notification URLs, fired verbatim by the bridge.
-                // Per OpenRTB these are the canonical carriers of
-                // `${AUCTION_PRICE}`, so expand it from the same winning CPM used
-                // for the creative below — an unexpanded macro would report an
-                // unresolved clearing price to the SSP, and some reject such
-                // notifications outright.
-                if let Some(ref nurl) = bid.nurl {
-                    let nurl = crate::creative::expand_auction_price_macro(nurl, cpm);
-                    obj.insert("nurl".to_string(), serde_json::Value::String(nurl));
-                }
-                if let Some(ref burl) = bid.burl {
-                    let burl = crate::creative::expand_auction_price_macro(burl, cpm);
-                    obj.insert("burl".to_string(), serde_json::Value::String(burl));
-                }
-                // Always include the winning creative so the pbRender bridge can
-                // render it locally when GAM serves the Prebid Universal Creative
-                // — no PBS Cache round trip.
-                //
-                // Optionally sanitize dangerous markup, then optionally rewrite
-                // URLs to first-party proxies — the same opt-in creative-processing
-                // policy as the `/auction` path (see `auction::formats`), except
-                // for the inline render context. This `adm` is rendered by the
-                // Prebid Universal Creative inside GAM's iframe (`f.srcdoc = d.ad`),
-                // a foreign origin where root-relative `/first-party/…` URLs resolve
-                // against GAM and 404. The inline rewriter therefore emits
-                // absolute first-party URLs and omits the tsjs bundle injection.
-                let has_renderer = if let Some(ref renderer) = bid.renderer {
-                    let renderer = match serde_json::to_value(renderer) {
-                        Ok(renderer) => renderer,
-                        Err(error) => {
-                            log::warn!(
-                                "Skipping winning bid for slot '{}' because its typed renderer could not be serialized: {error}",
-                                slot_id
-                            );
-                            return None;
-                        }
+    /// Build the exact immutable browser projection without publishing it.
+    pub(crate) fn build_browser_auction_projection_v1(
+        result: &OrchestrationResult,
+        granularity: PriceGranularity,
+        settings: &Settings,
+        request_origin: &str,
+        browser_auction_id: Option<&str>,
+        identity_generator: &dyn AuctionIdentityGenerator,
+    ) -> Result<CanonicalBrowserAuctionProjectionV1, Report<TrustedServerError>> {
+        let mut reservation_ids = HashSet::new();
+        let mut projected_results = Vec::with_capacity(result.decision_set.results.len());
+        let mut projected_bids = Vec::new();
+
+        for decision in &result.decision_set.results {
+            let SlotAuctionDecisionV1::Winner { slot, candidate_id } = decision else {
+                projected_results.push(decision.clone());
+                continue;
+            };
+            let Some(bid) = result.winning_bids.get(slot).filter(|bid| {
+                bid.slot_id == *slot && bid.candidate_id.as_deref() == Some(candidate_id.as_str())
+            }) else {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            };
+            let Some(cpm) = bid.price.filter(|price| price.is_finite() && *price >= 0.0) else {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            };
+            let Some(provider) = bid.candidate_provider.clone() else {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            };
+            let Some(upstream_bid_id) = bid.bid_id.clone() else {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            };
+            if upstream_bid_id.is_empty()
+                || upstream_bid_id.len() > 64
+                || upstream_bid_id
+                    .bytes()
+                    .any(|byte| byte <= 0x1f || byte == 0x7f)
+            {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            }
+            let Some(render_source) = project_render_source(bid, settings, request_origin) else {
+                projected_results.push(SlotAuctionDecisionV1::Failed {
+                    slot: slot.clone(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                });
+                continue;
+            };
+            let renderer_reservation_id = match &render_source {
+                BidRenderSourceV1::Aps(_) | BidRenderSourceV1::Adm(_) => {
+                    let Some(id) = mint_response_unique_base64url_identity(
+                        identity_generator,
+                        &mut reservation_ids,
+                        "r1_",
+                        RENDERER_RESERVATION_BYTES,
+                        RENDERER_RESERVATION_COLLISION_RETRIES,
+                    ) else {
+                        projected_results.push(SlotAuctionDecisionV1::Failed {
+                            slot: slot.clone(),
+                            reason: AuctionSlotFailureReason::IdentityGenerationFailed,
+                        });
+                        continue;
                     };
-                    obj.insert("renderer".to_string(), renderer);
-                    true
-                } else {
-                    false
-                };
-                // Every `Some(raw)` — including an explicit empty string, which
-                // PBS can return — counts as a supplied creative and goes
-                // through processing, so an empty `adm` cannot masquerade as
-                // "absent" and re-enable the raw cache fallback below.
-                // Processing may reject the creative outright (empty output):
-                // sanitization can strip everything, parsing can fail, or the
-                // size cap can trip.
-                if let Some(ref raw_creative) = bid.creative {
-                    // Resolve ${AUCTION_PRICE} from the exact winning CPM BEFORE
-                    // sanitizing, rewriting, and signing — URL rewriting would
-                    // otherwise encode the literal macro into the signed proxy/click
-                    // URL, and signing would lock that wrong value.
-                    let priced = crate::creative::expand_auction_price_macro(raw_creative, cpm);
-                    let adm = crate::creative::process_inline_auction_creative(
-                        settings,
-                        &base_origin,
-                        &priced,
-                    );
-                    if adm.trim().is_empty() {
-                        // Rejected. The PBS Cache coordinates are deliberately
-                        // NOT emitted as a fallback: the Universal Creative
-                        // fetches the cached bid's ORIGINAL adm, which would
-                        // hand the client an unprocessed copy of the very
-                        // markup processing just refused.
-                        if !has_renderer {
-                            log::warn!(
-                                "Skipping winning bid for slot '{}' because creative processing rejected its only render source",
-                                slot_id
-                            );
-                            return None;
-                        }
-                        log::warn!(
-                            "Creative for slot '{}' from '{}' rejected by processing; rendering through its typed renderer without a cache fallback",
-                            slot_id,
-                            bid.bidder
-                        );
-                    } else {
-                        obj.insert("adm".to_string(), serde_json::Value::String(adm));
-                    }
-                } else {
-                    // No creative of the bid's own, so the cache is the sole
-                    // render source and its coordinates are safe to emit. The
-                    // Prebid Universal Creative constructs:
-                    //   https://<hb_cache_host><hb_cache_path>?uuid=<hb_adid>
-                    //
-                    // Gated on a non-blank `cache_id`: PBS reports the cache
-                    // `url` and `cacheId` independently, and hb_adid falls back
-                    // to a non-cache identifier (`adid`, then the bid id).
-                    // Emitting the coordinates without a cache UUID would point
-                    // the Universal Creative at `?uuid=<non-cache-id>` — a
-                    // guaranteed cache miss. The gate matches the `non_empty`
-                    // chain used for hb_adid above so a blank `cacheId` cannot
-                    // pass here while losing the hb_adid precedence.
-                    if non_empty(bid.cache_id.as_deref()).is_some() {
-                        if let Some(ref host) = bid.cache_host {
-                            obj.insert(
-                                "hb_cache_host".to_string(),
-                                serde_json::Value::String(host.clone()),
-                            );
-                        }
-                        if let Some(ref path) = bid.cache_path {
-                            obj.insert(
-                                "hb_cache_path".to_string(),
-                                serde_json::Value::String(path.clone()),
-                            );
-                        }
-                    }
-                }
-                // Verbose per-bid debug blob only under the testing flag; also
-                // doubles as the client-side gate for the direct GAM-replace path.
-                // Deliberately mirrors the bidder-supplied `creative`/`nurl`/`burl`
-                // verbatim, macros unexpanded: this blob is diagnostic — nothing
-                // renders or fires from it — and showing what the bidder actually
-                // sent is the point.
-                if include_debug_bid {
-                    obj.insert(
-                        "debug_bid".to_string(),
-                        serde_json::json!({
-                            "slot_id": bid.slot_id,
-                            "price": bid.price,
-                            "currency": bid.currency,
-                            "creative": bid.creative,
-                            "adomain": bid.adomain,
-                            "bidder": bid.bidder,
-                            "width": bid.width,
-                            "height": bid.height,
-                            "nurl": bid.nurl,
-                            "burl": bid.burl,
-                            "ad_id": bid.ad_id,
-                            "cache_id": bid.cache_id,
-                            "cache_host": bid.cache_host,
-                            "cache_path": bid.cache_path,
-                            "metadata": bid.metadata,
-                        }),
-                    );
+                    Some(id)
                 }
-                Some((slot_id.clone(), serde_json::Value::Object(obj)))
-            })
-        })
-        .collect()
-}
+                BidRenderSourceV1::PbsCache(_) => None,
+            };
 
-/// Build the `tsjs.bids` `<script>` tag from a bucketed bid map.
-///
-/// The JSON is embedded via `JSON.parse(…)` so the browser parser never sees
-/// raw `</script>` sequences inside the string.
-pub(crate) fn build_bids_script(bid_map: &serde_json::Map<String, serde_json::Value>) -> String {
-    let json = serde_json::to_string(bid_map)
-        .expect("serde_json::to_string of Map<String,Value> should be infallible");
-    let escaped = html_escape_for_script(&json);
-    // adInit() defines GPT slots on the publisher's `-container` wrappers, which
-    // mutates those ad-slot subtrees. Calling it synchronously here (this script
-    // runs at body-parse time) lands those mutations inside React's hydration
-    // window and trips a #418 hydration mismatch. The deferral — gate on window
-    // `load`, then a double `requestAnimationFrame`, pinned to navigation
-    // generation 0 so a faster SPA navigation cancels it — lives in the GPT
-    // bundle module as `tsjs.scheduleInitialAdInit`
-    // (crates/trusted-server-js/lib/src/integrations/gpt/index.ts), where the
-    // lifecycle is executable under Vitest (schedule_initial_ad_init.test.ts)
-    // and the navigation-generation guard is shared with the SPA auction hook;
-    // gpt_bootstrap.js installs a minimal head-injected fallback so a failed
-    // bundle load still initializes initial ads.
-    //
-    // The deferral is deliberately unconditional — every publisher, every
-    // page — even though only hydrating React publishers exhibit the #418
-    // failure. Uniform behavior keeps one code path to reason about and
-    // avoids a framework-detection or config surface that must be kept
-    // truthful per publisher; the cost is that non-React pages also move the
-    // initial request from parse time to window load. The agreed follow-up
-    // (branch 958-adinit-hydration-chunk-gate, spec in docs/superpowers/
-    // specs/2026-07-24-adinit-hydration-gate-design.md) narrows the gate to
-    // the Next.js hydration chunks with `load` as the can't-hang fallback,
-    // which recovers most of that latency without a new config surface.
-    //
-    // The bids payload is handed to the scheduler instead of being assigned
-    // here: an SPA navigation that committed while this document was still
-    // streaming has already replaced `tsjs.bids`, and an unconditional
-    // assignment would clobber the live route's bids with the stale SSR
-    // payload. Only when no scheduler exists at all (GPT integration active
-    // without its head bootstrap — not an expected deployment) does the script
-    // fall back to a plain assignment, where no SPA hook exists to race with.
-    format!(
-        "<script>(function(){{\
-var t=window.tsjs=window.tsjs||{{}};\
-var b=JSON.parse(\"{}\");\
-var s=t.scheduleInitialAdInit;\
-if(typeof s===\"function\")s(b);\
-else t.bids=b;\
-}})();</script>",
-        escaped
-    )
-}
+            projected_results.push(decision.clone());
+            projected_bids.push(BrowserAuctionBidV1 {
+                candidate_id: candidate_id.clone(),
+                slot: slot.clone(),
+                provider,
+                upstream_bid_id,
+                cpm,
+                currency: bid.currency.clone(),
+                targeting: project_targeting(bid, cpm, granularity),
+                renderer_reservation_id,
+                render_source,
+            });
+        }
 
-/// Build the `</body>` seam script for a shared-template mode.
-///
-/// Carries **both** request-scoped pieces: the slot definitions and the bids. Under a
-/// shared mode the head seam emits no `tsjs.adSlots`, because slot *presence* is
-/// request-gated and baking it into a template shared between readers would decide for
-/// all of them. Sending only bids — which is what this did — left `tsjs.adSlots` at its
-/// `[]` default, so `adInit` defined no slots and the page rendered correctly with **no
-/// TS ads at all**. A review caught it; nothing here or in the harness would have.
-///
-/// Both are handed to the **scheduler**, not assigned here. `scheduleInitialAdInit`
-/// drops the whole payload once a SPA navigation has committed, and slots assigned on
-/// the line before the call would already have overwritten that navigation's slots by
-/// the time the guard ran — the guard covered the bids and `adInit`, and the assignment
-/// it was there to protect happened in front of it. The `else` arm keeps the direct
-/// assignment for the one case with no scheduler to race against: the GPT integration
-/// active without its head bootstrap, which is not an expected deployment.
-///
-/// Slots are applied before bids inside the scheduler, because the scheduler may fire
-/// `adInit` and `adInit` reads `ts.adSlots`.
-pub(crate) fn build_seam_script(
-    slots_json: &str,
-    bid_map: &serde_json::Map<String, serde_json::Value>,
-) -> String {
-    // The local test script probes the minified `var a=JSON.parse`,
-    // `var b=JSON.parse`, and `s(b,a)` literals below. Update the harness with any
-    // semantically equivalent rewrite so its black-box checks keep matching output.
-    let bids = serde_json::to_string(bid_map)
-        .expect("serde_json::to_string of Map<String,Value> should be infallible");
-    format!(
-        "<script>(function(){{\
-var t=window.tsjs=window.tsjs||{{}};\
-var a=JSON.parse(\"{}\");\
-var b=JSON.parse(\"{}\");\
-var s=t.scheduleInitialAdInit;\
-if(typeof s===\"function\")s(b,a);\
-else{{t.adSlots=a;t.bids=b;}}\
-}})();</script>",
-        html_escape_for_script(slots_json),
-        html_escape_for_script(&bids)
-    )
+        crate::auction::formats::coordinated_cutover_v1::canonicalize_browser_auction_projection_v1(
+            BrowserAuctionProjectionV1 {
+                version: 1,
+                auction: crate::auction::types::AuctionDecisionSetV1 {
+                    version: 1,
+                    auction_id: browser_auction_id
+                        .unwrap_or(&result.decision_set.auction_id)
+                        .to_string(),
+                    results: projected_results,
+                },
+                slots: Vec::new(),
+                bids: projected_bids,
+            },
+            request_origin,
+        )
+    }
+
+    /// Attach exact ordered GAM slot definitions to an already-canonical auction projection.
+    pub(crate) fn attach_browser_slots_v1(
+        mut canonical: CanonicalBrowserAuctionProjectionV1,
+        slots: Vec<BrowserAuctionSlotV1>,
+        request_origin: &str,
+    ) -> Result<CanonicalBrowserAuctionProjectionV1, Report<TrustedServerError>> {
+        if slots.len() != canonical.projection.auction.results.len() {
+            return Err(Report::new(TrustedServerError::Auction {
+                message: "Browser auction slots must cover every decision".to_string(),
+            }));
+        }
+        canonical.projection.slots = slots;
+        crate::auction::formats::coordinated_cutover_v1::canonicalize_browser_auction_projection_v1(
+            canonical.projection,
+            request_origin,
+        )
+    }
 }
 
-/// The slot definitions a shared-mode seam must carry, as JSON.
-///
-/// Mirrors [`template_ad_slots_script`]'s gating: same `should_run_ad_stack` condition,
-/// same slot set. The difference is only *where* it is delivered — the seam, per
-/// request, rather than the head, into a shared template.
-pub(crate) fn seam_ad_slots_json(
-    mode: AssemblyMode,
-    should_run_ad_stack: bool,
-    settings: &Settings,
+/// Build the exact ordered GAM placement records carried by the browser projection.
+pub(crate) fn build_browser_slots_v1(
     matched_slots: &[crate::creative_opportunities::CreativeOpportunitySlot],
+    co_config: &crate::creative_opportunities::CreativeOpportunitiesConfig,
     request_path: &str,
-) -> Option<String> {
-    if matches!(mode, AssemblyMode::Inline) || !should_run_ad_stack {
-        return None;
-    }
-    let co_config = settings.creative_opportunities.as_ref()?;
+) -> Vec<BrowserAuctionSlotV1> {
     let section = co_config.section_for_path(request_path);
-    let slots: Vec<serde_json::Value> = matched_slots
+    matched_slots
         .iter()
-        .filter_map(|slot| build_slot_json(slot, co_config, &section))
-        .collect();
-    Some(
-        serde_json::to_string(&slots)
-            .expect("serde_json::to_string of Vec<Value> should be infallible"),
-    )
-}
-
-/// Build the empty-bids `<script>` tag used when no bids were returned.
-///
-/// Shares the same shape as [`build_bids_script`] so any change to the script
-/// format stays in one place.
-pub(crate) fn build_empty_bids_script() -> String {
-    build_bids_script(&serde_json::Map::new())
+        .filter_map(|slot| {
+            let gam_unit_path = slot.render_gam_unit_path(&co_config.gam_network_id, &section)?;
+            Some(BrowserAuctionSlotV1 {
+                slot: slot.id.clone(),
+                gam_unit_path,
+                div_id: slot.resolved_div_id().to_string(),
+                formats: slot
+                    .formats
+                    .iter()
+                    .map(|format| [format.width, format.height])
+                    .collect(),
+                targeting: slot
+                    .targeting
+                    .iter()
+                    .map(|(key, value)| (key.clone(), value.clone()))
+                    .collect(),
+            })
+        })
+        .collect()
 }
 
-/// Builds the client-facing JSON wire shape for one creative-opportunity slot.
-///
-/// Shared verbatim by [`build_ad_slots_script`] (initial page render) and
-/// [`handle_page_bids`] (SPA navigation) so the slot wire shape has a single
-/// definition and the two paths cannot silently diverge. Property names match
-/// what the client-side TSJS bundle expects: `gam_unit_path`, `div_id`,
-/// `formats`, and `targeting`. Returns `None` when the slot's dynamic GAM unit
-/// path exceeds its rendering limit.
-pub(crate) fn build_slot_json(
-    slot: &crate::creative_opportunities::CreativeOpportunitySlot,
+/// Serialize the placement transport held until the initial auction projection is ready.
+pub(crate) fn build_browser_slots_json(
+    matched_slots: &[crate::creative_opportunities::CreativeOpportunitySlot],
     co_config: &crate::creative_opportunities::CreativeOpportunitiesConfig,
-    section: &str,
-) -> Option<serde_json::Value> {
-    let gam_path = slot.render_gam_unit_path(&co_config.gam_network_id, section)?;
-    let div_id = slot.resolved_div_id();
-    let formats: Vec<serde_json::Value> = slot
-        .formats
-        .iter()
-        .map(|f| serde_json::json!([f.width, f.height]))
-        .collect();
-    let targeting: serde_json::Map<String, serde_json::Value> = slot
-        .targeting
-        .iter()
-        .map(|(k, v)| (k.clone(), serde_json::Value::String(v.clone())))
-        .collect();
-    Some(serde_json::json!({
-        "id": slot.id,
-        "gam_unit_path": gam_path,
-        "div_id": div_id,
-        "formats": formats,
-        "targeting": targeting,
-    }))
+    request_path: &str,
+) -> String {
+    serde_json::to_string(&build_browser_slots_v1(
+        matched_slots,
+        co_config,
+        request_path,
+    ))
+    .expect("should serialize browser slot projection")
 }
 
 /// Match creative-opportunity slots and omit dynamic GAM paths that cannot be
@@ -5520,95 +4691,44 @@ fn match_renderable_slots(
         .collect()
 }
 
-/// Why a response must not enter the shared transformed-template cache (template cache).
-///
-/// `cache::core` is not an HTTP cache: it stores whatever bytes it is handed and
-/// rejects nothing on its own. Every safety condition is the caller's to enforce,
-/// so they are enumerated here rather than left implicit.
-///
-/// Spike-only, for the #1009 ESI validation.
+/// Why a response cannot enter the shared transformed-template cache.
 #[derive(Debug, Clone, PartialEq, Eq, derive_more::Display)]
-pub(crate) enum TemplateCacheBypassReason {
-    /// Not a shared-template mode; there is no template cache object to write.
+pub(crate) enum C2BypassReason {
     #[display("assembly mode is inline")]
     InlineMode,
-    /// The origin set a cookie. Caching this would replay one visitor's cookie
-    /// to the next — and the cookie-privacy net downgrades *our* response, which
-    /// happens after the cache has already stored the origin's.
     #[display("origin response carries Set-Cookie")]
     OriginSetCookie,
-    /// The origin declared the response non-shareable, or supplied CDN-specific
-    /// policy directives the template-cache path does not interpret and therefore cannot safely override.
-    #[display("origin cache policy is not eligible for template cache sharing")]
+    #[display("origin cache policy is not eligible for C2 sharing")]
     OriginNotShareable,
-    /// Cache directives or HTTP dates were malformed. Failing closed prevents a
-    /// parser disagreement from extending a representation's lifetime.
     #[display("origin cache policy is malformed")]
     MalformedCachePolicy,
-    /// Core Cache has no HTTP heuristic freshness. Template cache therefore requires an explicit,
-    /// still-positive origin lifetime rather than inventing one.
     #[display("origin response has no positive shared freshness")]
     NoPositiveFreshness,
-    /// The request was authenticated. #1009 describes a Basic-Auth-gated
-    /// deployment, so an authorized response entering a shared cache is a live
-    /// concern rather than a hypothetical one.
     #[display("request carried Authorization")]
     AuthorizedRequest,
-    /// Not a 200. This is also what covers a `DataDome` block, which replaces the
-    /// document with a `403` (`integrations/datadome/protection.rs:778`).
     #[display("status was not 200 OK")]
     NonOkStatus,
-    /// Not HTML, so there is no template to transform.
     #[display("content type is not text/html")]
     NotHtml,
-    /// A single-valued representation header was absent, repeated or malformed.
     #[display("origin representation headers are ambiguous or malformed")]
     MalformedRepresentationHeaders,
-    /// The body cannot be decoded by the transform. Authorizing it would rewrite
-    /// `Content-Encoding` while returning the untouched bytes on the fallback route.
     #[display("origin content encoding is not supported by the template transform")]
     UnsupportedContentEncoding,
-    /// The request carried a `Cookie`, which TS forwards to origin unchanged — there
-    /// is no `Cookie` strip on the publisher path. Cookie-personalized HTML is
-    /// therefore cross-servable unless the origin declares `Vary: Cookie` or marks
-    /// those responses private, and a response can be personalized without carrying
-    /// `Set-Cookie` itself when the session was established earlier. Named in §4 of
-    /// the design doc; disqualifying until the origin's `Vary` is verified to cover
-    /// it.
     #[display("request carried Cookie and the origin's Vary does not cover it")]
     CookieForwarded,
-    /// The origin varies on a header the cache key does not cover.
-    ///
-    /// The key is built *before* the fetch from a configured [`VarySpec`], because a
-    /// lookup cannot know what the origin varies on until it has responded. That makes
-    /// the configured list capable of going stale. This is the guard: once the origin's
-    /// `Vary` is finally known, a template whose key missed one of its headers must not
-    /// be stored, because a request differing only in that header would read it.
-    ///
-    /// Carries the uncovered header names rather than a bare flag, so a stale config is
-    /// identifiable from the log line instead of requiring a bisect.
     #[display("origin varies on {_0}, which the cache key does not cover")]
     VaryNotCovered(VaryGap),
-    /// `Vary: *` — the origin says no request key can select this representation.
-    ///
-    /// `VarySpec::uncovered_by` filters the wildcard out on the grounds that "the
-    /// eligibility gate handles it". It did not: nothing rejected it, so a `Vary: *`
-    /// response was shareable. A review found the gap between the comment and the code.
     #[display("origin sent Vary: *, so no request key can select this response")]
     VaryWildcard,
-    /// Cookie-selected HTML contradicts the reader-neutral-template contract even if
-    /// an operator accidentally lists `cookie` in the configured Vary key.
     #[display("origin sent Vary: Cookie, contradicting cookie independence")]
     VaryCookie,
-    /// A response-bound CSP nonce cannot safely be replayed with a shared document.
     #[display("origin CSP contains a response-bound nonce")]
     CspNonce,
-    /// A policy header selected for replay could not be represented losslessly.
     #[display("origin policy header is malformed")]
     MalformedPolicyHeader,
 }
 
-fn request_bypasses_template_cache(headers: &edgezero_core::http::HeaderMap) -> bool {
+fn request_bypasses_c2(headers: &edgezero_core::http::HeaderMap) -> bool {
     const CONDITIONAL_OR_PARTIAL: &[&str] = &[
         "range",
         "if-range",
@@ -5623,7 +4743,6 @@ fn request_bypasses_template_cache(headers: &edgezero_core::http::HeaderMap) ->
     {
         return true;
     }
-
     for value in headers.get_all(header::CACHE_CONTROL) {
         let Ok(value) = value.to_str() else {
             return true;
@@ -5634,14 +4753,8 @@ fn request_bypasses_template_cache(headers: &edgezero_core::http::HeaderMap) ->
                 .map_or((directive, None), |(name, argument)| (name, Some(argument)));
             match name.trim().to_ascii_lowercase().as_str() {
                 "no-cache" | "no-store" => return true,
-                // A browser reload's `max-age=0` requires a newly assembled response,
-                // not a second origin fetch for its reader-neutral template. The hit
-                // still runs this reader's auction and is stamped private/no-store.
-                // Positive or malformed constraints remain unprovable because template cache does
-                // not expose object age/remaining freshness at this layer.
                 "max-age"
-                    if argument.and_then(|argument| parse_delta_seconds(argument).ok())
-                        != Some(0) =>
+                    if argument.and_then(|value| parse_delta_seconds(value).ok()) != Some(0) =>
                 {
                     return true;
                 }
@@ -5650,7 +4763,6 @@ fn request_bypasses_template_cache(headers: &edgezero_core::http::HeaderMap) ->
             }
         }
     }
-
     headers.get_all(header::PRAGMA).iter().any(|value| {
         value.to_str().map_or(true, |value| {
             value.split(',').any(|directive| {
@@ -5664,11 +4776,6 @@ fn request_bypasses_template_cache(headers: &edgezero_core::http::HeaderMap) ->
     })
 }
 
-/// The header names an origin's `Vary` named that the cache key did not cover.
-///
-/// A newtype rather than a bare `Vec<String>` so [`TemplateCacheBypassReason`] stays `Display`-able
-/// as one line, and so the empty case is unrepresentable at the call site — an empty gap
-/// is not a bypass, it is a pass.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct VaryGap(Vec<String>);
 
@@ -5678,14 +4785,13 @@ impl core::fmt::Display for VaryGap {
     }
 }
 
-/// Operator policy applied after the origin authorizes shared freshness.
 #[derive(Debug, Clone)]
-struct TemplateCachePolicy {
+struct C2CachePolicy {
     key_vary: VarySpec,
     max_age: Duration,
 }
 
-impl TemplateCachePolicy {
+impl C2CachePolicy {
     fn from_settings(settings: &Settings) -> Self {
         settings.creative_opportunities.as_ref().map_or_else(
             || Self {
@@ -5708,17 +4814,8 @@ impl TemplateCachePolicy {
     }
 }
 
-/// Whether a response may be written to the shared transformed-template cache.
-///
-/// Returns [`None`] when it is safe to cache, or the first disqualifying reason.
-/// Leak vectors are checked before mere ineligibility so the reported reason is
-/// the most serious one that applies.
-///
-/// See `docs/superpowers/archive/2026-08-08-esi-cacheable-root-validation-design.md`
-/// §6.6 for why the C1 raw-origin/read-through cache, the reader-neutral template cache, and
-/// the forbidden C3 final assembled-response cache are distinct.
 #[cfg(test)]
-pub(crate) fn template_cache_bypass_reason(
+pub(crate) fn c2_bypass_reason(
     mode: AssemblyMode,
     authorization_disqualifies: bool,
     cookie_disqualifies: bool,
@@ -5726,16 +4823,15 @@ pub(crate) fn template_cache_bypass_reason(
     content_type: &str,
     response_headers: &edgezero_core::http::HeaderMap,
     key_vary: &VarySpec,
-) -> Option<TemplateCacheBypassReason> {
-    let policy = TemplateCachePolicy::for_test(key_vary, Duration::from_secs(60));
-    template_cache_ttl(
+) -> Option<C2BypassReason> {
+    c2_cache_ttl(
         mode,
         authorization_disqualifies,
         cookie_disqualifies,
         status,
         content_type,
         response_headers,
-        &policy,
+        &C2CachePolicy::for_test(key_vary, Duration::from_secs(60)),
     )
     .err()
 }
@@ -5743,126 +4839,110 @@ pub(crate) fn template_cache_bypass_reason(
 fn single_header_value(
     headers: &edgezero_core::http::HeaderMap,
     name: header::HeaderName,
-) -> Result<Option<&str>, TemplateCacheBypassReason> {
+) -> Result<Option<&str>, C2BypassReason> {
     let mut values = headers.get_all(name).iter();
     let Some(first) = values.next() else {
         return Ok(None);
     };
     if values.next().is_some() {
-        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+        return Err(C2BypassReason::MalformedCachePolicy);
     }
     first
         .to_str()
         .map(Some)
-        .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)
+        .map_err(|_| C2BypassReason::MalformedCachePolicy)
 }
 
 fn single_representation_header_value(
     headers: &edgezero_core::http::HeaderMap,
     name: header::HeaderName,
-) -> Result<Option<&str>, TemplateCacheBypassReason> {
+) -> Result<Option<&str>, C2BypassReason> {
     let mut values = headers.get_all(name).iter();
     let Some(first) = values.next() else {
         return Ok(None);
     };
     if values.next().is_some() {
-        return Err(TemplateCacheBypassReason::MalformedRepresentationHeaders);
+        return Err(C2BypassReason::MalformedRepresentationHeaders);
     }
     first
         .to_str()
         .map(Some)
-        .map_err(|_| TemplateCacheBypassReason::MalformedRepresentationHeaders)
+        .map_err(|_| C2BypassReason::MalformedRepresentationHeaders)
 }
 
-fn parse_delta_seconds(value: &str) -> Result<u64, TemplateCacheBypassReason> {
+fn parse_delta_seconds(value: &str) -> Result<u64, C2BypassReason> {
     let value = value.trim();
-    let quoted_at_start = value.starts_with('"');
-    let quoted_at_end = value.ends_with('"');
-    let digits = match (quoted_at_start, quoted_at_end) {
+    let digits = match (value.starts_with('"'), value.ends_with('"')) {
         (true, true) if value.len() >= 2 => &value[1..value.len() - 1],
         (false, false) => value,
-        _ => return Err(TemplateCacheBypassReason::MalformedCachePolicy),
+        _ => return Err(C2BypassReason::MalformedCachePolicy),
     };
     if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
-        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+        return Err(C2BypassReason::MalformedCachePolicy);
     }
     digits
         .parse::<u64>()
-        .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)
+        .map_err(|_| C2BypassReason::MalformedCachePolicy)
 }
 
-/// Parse the Fastly-specific freshness policy used by template cache's hosting platform.
-///
-/// Fastly documents `max-age`, `stale-while-revalidate`, and `stale-if-error` for
-/// `Surrogate-Control`. Template cache uses only `max-age` as fresh lifetime; the stale windows
-/// are validated so malformed policy cannot hide beside a valid max age, but Core
-/// Cache assembly does not serve stale templates under either extension.
-///
-/// Unknown directives fail closed rather than inheriting semantics from another CDN.
 fn surrogate_control_freshness(
     headers: &edgezero_core::http::HeaderMap,
-) -> Result<Option<Duration>, TemplateCacheBypassReason> {
+) -> Result<Option<Duration>, C2BypassReason> {
     let mut saw_header = false;
     let mut max_age = None;
     let mut stale_while_revalidate = None;
     let mut stale_if_error = None;
-
     for value in headers.get_all("surrogate-control") {
         saw_header = true;
         let value = value
             .to_str()
-            .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
+            .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
         if value.trim().is_empty() {
-            return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+            return Err(C2BypassReason::MalformedCachePolicy);
         }
         for directive in value.split(',') {
             let directive = directive.trim();
             if directive.is_empty() {
-                return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                return Err(C2BypassReason::MalformedCachePolicy);
             }
             let (name, value) = directive
                 .split_once('=')
                 .map_or((directive, None), |(name, value)| (name, Some(value)));
-            let name = name.trim().to_ascii_lowercase();
-            match name.as_str() {
+            match name.trim().to_ascii_lowercase().as_str() {
                 "private" | "no-store" | "no-cache" => {
-                    return Err(TemplateCacheBypassReason::OriginNotShareable);
+                    return Err(C2BypassReason::OriginNotShareable);
                 }
                 "max-age" => {
-                    let parsed = parse_delta_seconds(
-                        value.ok_or(TemplateCacheBypassReason::MalformedCachePolicy)?,
-                    )?;
+                    let parsed =
+                        parse_delta_seconds(value.ok_or(C2BypassReason::MalformedCachePolicy)?)?;
                     if max_age.replace(parsed).is_some() {
-                        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                        return Err(C2BypassReason::MalformedCachePolicy);
                     }
                 }
                 "stale-while-revalidate" => {
-                    let parsed = parse_delta_seconds(
-                        value.ok_or(TemplateCacheBypassReason::MalformedCachePolicy)?,
-                    )?;
+                    let parsed =
+                        parse_delta_seconds(value.ok_or(C2BypassReason::MalformedCachePolicy)?)?;
                     if stale_while_revalidate.replace(parsed).is_some() {
-                        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                        return Err(C2BypassReason::MalformedCachePolicy);
                     }
                 }
                 "stale-if-error" => {
-                    let parsed = parse_delta_seconds(
-                        value.ok_or(TemplateCacheBypassReason::MalformedCachePolicy)?,
-                    )?;
+                    let parsed =
+                        parse_delta_seconds(value.ok_or(C2BypassReason::MalformedCachePolicy)?)?;
                     if stale_if_error.replace(parsed).is_some() {
-                        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                        return Err(C2BypassReason::MalformedCachePolicy);
                     }
                 }
-                _ => return Err(TemplateCacheBypassReason::MalformedCachePolicy),
+                _ => return Err(C2BypassReason::MalformedCachePolicy),
             }
         }
     }
-
     if !saw_header {
         return Ok(None);
     }
-    let max_age = max_age.ok_or(TemplateCacheBypassReason::NoPositiveFreshness)?;
+    let max_age = max_age.ok_or(C2BypassReason::NoPositiveFreshness)?;
     if max_age == 0 {
-        return Err(TemplateCacheBypassReason::NoPositiveFreshness);
+        return Err(C2BypassReason::NoPositiveFreshness);
     }
     Ok(Some(Duration::from_secs(max_age)))
 }
@@ -5870,7 +4950,7 @@ fn surrogate_control_freshness(
 fn origin_shared_ttl(
     headers: &edgezero_core::http::HeaderMap,
     max_age: Duration,
-) -> Result<Duration, TemplateCacheBypassReason> {
+) -> Result<Duration, C2BypassReason> {
     origin_shared_ttl_at(headers, SystemTime::now(), max_age)
 }
 
@@ -5878,101 +4958,94 @@ fn origin_shared_ttl_at(
     headers: &edgezero_core::http::HeaderMap,
     now: SystemTime,
     template_cache_max_age: Duration,
-) -> Result<Duration, TemplateCacheBypassReason> {
+) -> Result<Duration, C2BypassReason> {
     let mut max_age = None;
     let mut shared_max_age = None;
-
     for value in headers.get_all(header::CACHE_CONTROL) {
         let value = value
             .to_str()
-            .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
-        for directive in value.split(',').map(str::trim).filter(|v| !v.is_empty()) {
+            .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
+        for directive in value
+            .split(',')
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+        {
             let (name, value) = directive
                 .split_once('=')
                 .map_or((directive, None), |(name, value)| (name, Some(value)));
             match name.trim().to_ascii_lowercase().as_str() {
                 "private" | "no-store" | "no-cache" => {
-                    return Err(TemplateCacheBypassReason::OriginNotShareable);
+                    return Err(C2BypassReason::OriginNotShareable);
                 }
                 "max-age" => {
-                    let parsed = parse_delta_seconds(
-                        value.ok_or(TemplateCacheBypassReason::MalformedCachePolicy)?,
-                    )?;
+                    let parsed =
+                        parse_delta_seconds(value.ok_or(C2BypassReason::MalformedCachePolicy)?)?;
                     if max_age.replace(parsed).is_some() {
-                        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                        return Err(C2BypassReason::MalformedCachePolicy);
                     }
                 }
                 "s-maxage" => {
-                    let parsed = parse_delta_seconds(
-                        value.ok_or(TemplateCacheBypassReason::MalformedCachePolicy)?,
-                    )?;
+                    let parsed =
+                        parse_delta_seconds(value.ok_or(C2BypassReason::MalformedCachePolicy)?)?;
                     if shared_max_age.replace(parsed).is_some() {
-                        return Err(TemplateCacheBypassReason::MalformedCachePolicy);
+                        return Err(C2BypassReason::MalformedCachePolicy);
                     }
                 }
                 _ => {}
             }
         }
     }
-
     let date = single_header_value(headers, header::DATE)?
         .map(httpdate::parse_http_date)
         .transpose()
-        .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
+        .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
     let standard_freshness = match shared_max_age.or(max_age) {
         Some(seconds) => Some(Duration::from_secs(seconds)),
         None => single_header_value(headers, header::EXPIRES)?
             .map(|value| {
                 let expires = httpdate::parse_http_date(value)
-                    .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
+                    .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
                 expires
                     .duration_since(date.unwrap_or(now))
-                    .map_err(|_| TemplateCacheBypassReason::NoPositiveFreshness)
+                    .map_err(|_| C2BypassReason::NoPositiveFreshness)
             })
             .transpose()?,
     };
-    // Fastly gives Surrogate-Control precedence for its edge cache. Standard
-    // restrictive directives were still parsed above and remain hard refusals.
     let freshness = surrogate_control_freshness(headers)?
         .or(standard_freshness)
-        .ok_or(TemplateCacheBypassReason::NoPositiveFreshness)?;
-
+        .ok_or(C2BypassReason::NoPositiveFreshness)?;
     let age = single_header_value(headers, header::AGE)?
         .map(parse_delta_seconds)
         .transpose()?
         .unwrap_or(0);
-    // `Age` may be absent even when an upstream cache emitted an old `Date`.
-    // RFC 9111's corrected age is at least the apparent age; ignoring it would
-    // grant an already-expired representation a new template cache lifetime.
     let apparent_age = date
         .and_then(|date| now.duration_since(date).ok())
         .unwrap_or_default();
-    let current_age = Duration::from_secs(age).max(apparent_age);
     let remaining = freshness
-        .checked_sub(current_age)
+        .checked_sub(Duration::from_secs(age).max(apparent_age))
         .filter(|duration| !duration.is_zero())
-        .ok_or(TemplateCacheBypassReason::NoPositiveFreshness)?;
+        .ok_or(C2BypassReason::NoPositiveFreshness)?;
     let capped = remaining.min(template_cache_max_age);
     if capped.is_zero() {
-        return Err(TemplateCacheBypassReason::NoPositiveFreshness);
+        return Err(C2BypassReason::NoPositiveFreshness);
     }
     Ok(capped)
 }
 
 fn replayable_policy_headers(
     headers: &edgezero_core::http::HeaderMap,
-) -> Result<Vec<(String, String)>, TemplateCacheBypassReason> {
+) -> Result<Vec<(String, String)>, C2BypassReason> {
     let mut captured = Vec::new();
     for name in crate::platform::REPLAYABLE_POLICY_HEADERS {
         for value in headers.get_all(*name) {
             let value = value
                 .to_str()
-                .map_err(|_| TemplateCacheBypassReason::MalformedPolicyHeader)?;
+                .map_err(|_| C2BypassReason::MalformedPolicyHeader)?;
             if (*name == "content-security-policy"
                 || *name == "content-security-policy-report-only")
                 && value.to_ascii_lowercase().contains("'nonce-")
             {
-                return Err(TemplateCacheBypassReason::CspNonce);
+                return Err(C2BypassReason::CspNonce);
             }
             captured.push(((*name).to_string(), value.to_string()));
         }
@@ -5980,76 +5053,140 @@ fn replayable_policy_headers(
     Ok(captured)
 }
 
-fn template_cache_ttl(
+fn runtime_policy_headers(headers: &edgezero_core::http::HeaderMap) -> Vec<(String, String)> {
+    let mut captured = Vec::new();
+    for name in crate::platform::REPLAYABLE_POLICY_HEADERS {
+        for value in headers.get_all(*name) {
+            let Ok(value) = value.to_str() else {
+                continue;
+            };
+            captured.push(((*name).to_string(), value.to_string()));
+        }
+    }
+    captured
+}
+
+fn valid_csp_nonce_value(value: &str) -> bool {
+    !value.is_empty()
+        && value.len() <= 256
+        && value.bytes().all(|byte| {
+            byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'_' | b'-' | b'=')
+        })
+}
+
+/// Select one nonce admitted by every nonce-bearing enforcing CSP policy.
+/// Ambiguous or disjoint policy sets fail closed by returning no nonce.
+fn response_csp_nonce(policy_headers: &[(String, String)]) -> Option<String> {
+    let mut admitted: Option<std::collections::BTreeSet<String>> = None;
+    for (name, policy) in policy_headers {
+        if !name.eq_ignore_ascii_case("content-security-policy") {
+            continue;
+        }
+        let mut script_src_elem: Option<&str> = None;
+        let mut script_src: Option<&str> = None;
+        let mut default_src: Option<&str> = None;
+        for directive in policy.split(';') {
+            let mut fields = directive.split_whitespace();
+            let Some(name) = fields.next() else {
+                continue;
+            };
+            let values = directive[name.len()..].trim();
+            match name.to_ascii_lowercase().as_str() {
+                "script-src-elem" if script_src_elem.is_none() => script_src_elem = Some(values),
+                "script-src" if script_src.is_none() => script_src = Some(values),
+                "default-src" if default_src.is_none() => default_src = Some(values),
+                _ => {}
+            }
+        }
+        let Some(effective) = script_src_elem.or(script_src).or(default_src) else {
+            continue;
+        };
+        let nonces = effective
+            .split_whitespace()
+            .filter_map(|token| {
+                let body = token.strip_prefix('\'')?.strip_suffix('\'')?;
+                let prefix = body.get(..6)?;
+                let value = body.get(6..)?;
+                (prefix.eq_ignore_ascii_case("nonce-") && valid_csp_nonce_value(value))
+                    .then(|| value.to_string())
+            })
+            .collect::<std::collections::BTreeSet<_>>();
+        if nonces.is_empty() {
+            continue;
+        }
+        admitted = Some(match admitted {
+            None => nonces,
+            Some(existing) => existing.intersection(&nonces).cloned().collect(),
+        });
+    }
+    let admitted = admitted?;
+    (admitted.len() == 1)
+        .then(|| admitted.into_iter().next())
+        .flatten()
+}
+
+fn c2_cache_ttl(
     mode: AssemblyMode,
     authorization_disqualifies: bool,
     cookie_disqualifies: bool,
     status: StatusCode,
     content_type: &str,
     response_headers: &edgezero_core::http::HeaderMap,
-    policy: &TemplateCachePolicy,
-) -> Result<Duration, TemplateCacheBypassReason> {
+    policy: &C2CachePolicy,
+) -> Result<Duration, C2BypassReason> {
     if matches!(mode, AssemblyMode::Inline) {
-        return Err(TemplateCacheBypassReason::InlineMode);
+        return Err(C2BypassReason::InlineMode);
     }
     if authorization_disqualifies {
-        return Err(TemplateCacheBypassReason::AuthorizedRequest);
+        return Err(C2BypassReason::AuthorizedRequest);
     }
     if cookie_disqualifies {
-        return Err(TemplateCacheBypassReason::CookieForwarded);
+        return Err(C2BypassReason::CookieForwarded);
     }
     if response_headers.contains_key(header::SET_COOKIE) {
-        return Err(TemplateCacheBypassReason::OriginSetCookie);
+        return Err(C2BypassReason::OriginSetCookie);
     }
-    // Core Cache has no HTTP semantics. Fastly's documented Surrogate-Control subset
-    // is parsed by `origin_shared_ttl`; every other vendor-specific policy remains a
-    // bypass rather than guessing that unrelated CDNs share its grammar or precedence.
     if crate::response_privacy::CDN_CACHE_HEADERS
         .iter()
         .filter(|name| **name != "surrogate-control")
         .any(|name| response_headers.contains_key(*name))
     {
-        return Err(TemplateCacheBypassReason::OriginNotShareable);
+        return Err(C2BypassReason::OriginNotShareable);
     }
-    // Checked here, among the leak vectors, because storing under a key that does not
-    // cover the origin's Vary is cross-serving rather than mere ineligibility: a request
-    // differing only in the uncovered header would read this template.
     let mut vary_values = Vec::new();
     for value in response_headers.get_all(header::VARY) {
         let value = value
             .to_str()
-            .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
+            .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
         for name in value
             .split(',')
             .map(str::trim)
             .filter(|name| !name.is_empty())
         {
             if name == "*" {
-                return Err(TemplateCacheBypassReason::VaryWildcard);
+                return Err(C2BypassReason::VaryWildcard);
             }
             if name.eq_ignore_ascii_case(header::COOKIE.as_str()) {
-                return Err(TemplateCacheBypassReason::VaryCookie);
+                return Err(C2BypassReason::VaryCookie);
             }
             header::HeaderName::from_bytes(name.as_bytes())
-                .map_err(|_| TemplateCacheBypassReason::MalformedCachePolicy)?;
+                .map_err(|_| C2BypassReason::MalformedCachePolicy)?;
         }
         vary_values.push(value);
     }
     let uncovered = policy.key_vary.uncovered_by(vary_values);
     if !uncovered.is_empty() {
-        return Err(TemplateCacheBypassReason::VaryNotCovered(VaryGap(
-            uncovered,
-        )));
+        return Err(C2BypassReason::VaryNotCovered(VaryGap(uncovered)));
     }
     if status != StatusCode::OK {
-        return Err(TemplateCacheBypassReason::NonOkStatus);
+        return Err(C2BypassReason::NonOkStatus);
     }
     let declared_content_type =
         single_representation_header_value(response_headers, header::CONTENT_TYPE)?;
     if declared_content_type.is_some_and(|declared| declared != content_type)
         || !is_html_content_type(content_type)
     {
-        return Err(TemplateCacheBypassReason::NotHtml);
+        return Err(C2BypassReason::NotHtml);
     }
     let content_encoding =
         single_representation_header_value(response_headers, header::CONTENT_ENCODING)?
@@ -6058,79 +5195,15 @@ fn template_cache_ttl(
                 |value| value.trim().to_ascii_lowercase(),
             );
     if content_encoding.is_empty() {
-        return Err(TemplateCacheBypassReason::MalformedRepresentationHeaders);
+        return Err(C2BypassReason::MalformedRepresentationHeaders);
     }
     if !is_supported_content_encoding(&content_encoding) {
-        return Err(TemplateCacheBypassReason::UnsupportedContentEncoding);
+        return Err(C2BypassReason::UnsupportedContentEncoding);
     }
     replayable_policy_headers(response_headers)?;
     origin_shared_ttl(response_headers, policy.max_age)
 }
 
-/// What the `<head>` seam injects, given the assembly mode.
-///
-/// Under [`AssemblyMode::Inline`] the response is per-navigation and not shared,
-/// so emitting `tsjs.adSlots` only when the ad stack runs is correct.
-///
-/// Under [`AssemblyMode::Esi`] the document is a
-/// **shared template**, and `should_run_ad_stack` is request-dependent — it folds
-/// in consent, bot classification, prefetch status and the auction kill switch.
-/// Emitting conditionally there would freeze the first-filling request's decision
-/// for every later reader of the cached object: a consent-denied fill would serve
-/// a no-ads template to consenting users, and a consenting fill would serve ad
-/// markup to someone who refused.
-///
-/// So ESI returns [`None`] **unconditionally**, and `adSlots` moves to the
-/// per-request body seam alongside the bids. The head is not a template hole.
-///
-/// See `docs/superpowers/archive/2026-08-08-esi-cacheable-root-validation-design.md`
-/// §6.7.
-pub(crate) fn template_ad_slots_script(
-    mode: AssemblyMode,
-    should_run_ad_stack: bool,
-    settings: &Settings,
-    matched_slots: &[crate::creative_opportunities::CreativeOpportunitySlot],
-    request_path: &str,
-) -> Option<String> {
-    match mode {
-        AssemblyMode::Esi => None,
-        AssemblyMode::Inline => {
-            if !should_run_ad_stack {
-                return None;
-            }
-            settings
-                .creative_opportunities
-                .as_ref()
-                .map(|co_config| build_ad_slots_script(matched_slots, co_config, request_path))
-        }
-    }
-}
-
-/// Build the `tsjs.adSlots` `<script>` tag from matched slots.
-///
-/// Property names match what the client-side TSJS bundle expects:
-/// `gam_unit_path`, `div_id`, `formats`, and `targeting`.
-pub(crate) fn build_ad_slots_script(
-    matched_slots: &[crate::creative_opportunities::CreativeOpportunitySlot],
-    co_config: &crate::creative_opportunities::CreativeOpportunitiesConfig,
-    request_path: &str,
-) -> String {
-    // `{section}` derives from the same raw path `page_patterns` matched
-    // against; derive it once for every slot on this request.
-    let section = co_config.section_for_path(request_path);
-    let slots: Vec<serde_json::Value> = matched_slots
-        .iter()
-        .filter_map(|slot| build_slot_json(slot, co_config, &section))
-        .collect();
-    let json = serde_json::to_string(&slots)
-        .expect("serde_json::to_string of Vec<Value> should be infallible");
-    let escaped = html_escape_for_script(&json);
-    format!(
-        "<script>(window.tsjs=window.tsjs||{{}}).adSlots=JSON.parse(\"{}\");</script>",
-        escaped
-    )
-}
-
 /// Whether the content type requires processing (URL rewriting, HTML injection).
 ///
 /// Text-based and JavaScript/JSON responses are processable; binary types
@@ -6165,37 +5238,6 @@ fn is_supported_content_encoding(encoding: &str) -> bool {
 /// Server route. Adapters register this path; the tsjs SPA hook fetches it.
 pub const PAGE_BIDS_PATH: &str = "/_ts/page-bids";
 
-/// Deprecated double-underscore alias of [`PAGE_BIDS_PATH`].
-///
-/// The endpoint originally shipped as `/__ts/page-bids`, the only internal path
-/// using a `__` prefix. Renaming it is atomic on the server, but a browser runs
-/// whichever tsjs bundle it was already served: pages loaded before the rename —
-/// and cached bundles — keep requesting this path, and on a SPA that path is what
-/// delivers ads for in-session navigations. Adapters route it to the same handler
-/// so those clients keep working.
-///
-/// The alias is bidirectional in practice: the current tsjs bundle requests
-/// [`PAGE_BIDS_PATH`] first and falls back here when that path does not serve
-/// page-bids on a deployment. That covers a server rolled back to before the
-/// rename, and an operator `[[handlers]]` auth regex broad enough to cover
-/// `/_ts` (which would answer the canonical path with `401`). Both are
-/// transitional — an affected operator must narrow the regex before the alias
-/// is removed.
-///
-/// Removal is tracked by IABTechLab/trusted-server#970: drop this const, its
-/// four adapter registrations, and the client fallback once access logs show no
-/// remaining traffic on the legacy path.
-pub const PAGE_BIDS_LEGACY_PATH: &str = "/__ts/page-bids";
-
-/// `X-TSJS-Page-Bids` value the current tsjs bundle sends when it retries
-/// [`PAGE_BIDS_LEGACY_PATH`] because [`PAGE_BIDS_PATH`] was unusable.
-///
-/// Separates the two populations on the deprecated alias: pre-rename bundles
-/// (which age out by themselves) from current bundles falling back (which do
-/// not, because the cause is deployment configuration). See the logging in
-/// [`handle_page_bids`].
-pub const PAGE_BIDS_FALLBACK_MARKER: &str = "fallback";
-
 /// Same-origin gate for `/_ts/page-bids`.
 ///
 /// The endpoint is a side-effecting GET: it dispatches real PBS/APS auctions
@@ -6235,8 +5277,7 @@ fn page_bids_request_allowed(req: &Request<EdgeBody>) -> bool {
 /// preflight; letting `OPTIONS` fall through to the publisher origin (which may
 /// return permissive CORS) would defeat that, allowing a cross-site page to
 /// trigger real PBS/APS auctions from a visitor's browser. Every adapter returns
-/// this same response for `OPTIONS /_ts/page-bids` and for its deprecated
-/// `/__ts/page-bids` alias.
+/// this same response for `OPTIONS /_ts/page-bids`.
 #[must_use]
 pub fn page_bids_preflight_denied() -> Response<EdgeBody> {
     let mut response = Response::new(EdgeBody::from("Forbidden"));
@@ -6245,46 +5286,11 @@ pub fn page_bids_preflight_denied() -> Response<EdgeBody> {
     response
 }
 
-/// Builds the `400 Bad Request` returned for an unrecognized `format`.
-///
-/// `private, no-store` like every other response from this endpoint, so an error
-/// cannot be cached and replayed.
-fn page_bids_unknown_format() -> Response<EdgeBody> {
-    let mut response = Response::new(EdgeBody::from("Unknown format"));
-    *response.status_mut() = StatusCode::BAD_REQUEST;
-    enforce_terminal_private_cache_privacy(&mut response);
-    response
-}
-
 /// Normalizes the client-supplied `path` query parameter before glob matching.
 ///
 /// The SPA hook sends `location.pathname`, but the parameter is
 /// client-controlled: strip any query string or fragment and force a leading
 /// `/` so slot `page_patterns` always match against a canonical path shape.
-/// How the page-bids endpoint serializes its answer.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
-pub(crate) enum PageBidsFormat {
-    /// `application/json`. What the SPA navigation hook consumes.
-    #[default]
-    Json,
-}
-
-impl PageBidsFormat {
-    /// Parse the `format` query parameter.
-    ///
-    /// # Errors
-    ///
-    /// Returns the offending value if it names no known format. Unknown values are
-    /// rejected rather than defaulting so callers cannot silently negotiate a response
-    /// representation the endpoint no longer supports.
-    fn parse(raw: Option<&str>) -> Result<Self, String> {
-        match raw {
-            None | Some("json") => Ok(Self::Json),
-            Some(other) => Err(other.to_string()),
-        }
-    }
-}
-
 fn normalize_page_bids_path(raw: &str) -> String {
     let path = raw.split(['?', '#']).next().unwrap_or("");
     if path.starts_with('/') {
@@ -6294,6 +5300,48 @@ fn normalize_page_bids_path(raw: &str) -> String {
     }
 }
 
+fn page_bids_terminal_projection_v1(
+    matched_slots: &[crate::creative_opportunities::CreativeOpportunitySlot],
+    browser_slots: Vec<BrowserAuctionSlotV1>,
+    reason: Option<AuctionSlotFailureReason>,
+    request_origin: &str,
+) -> Result<CanonicalBrowserAuctionProjectionV1, Report<TrustedServerError>> {
+    let auction_id = mint_response_unique_base64url_identity(
+        &SystemAuctionIdentityGenerator,
+        &mut HashSet::new(),
+        "a1_",
+        9,
+        8,
+    )
+    .ok_or_else(|| {
+        Report::new(TrustedServerError::Auction {
+            message: "Failed to mint page-bids auction identity".to_string(),
+        })
+    })?;
+    let results = reason.map_or_else(Vec::new, |reason| {
+        matched_slots
+            .iter()
+            .map(|slot| SlotAuctionDecisionV1::Failed {
+                slot: slot.id.clone(),
+                reason,
+            })
+            .collect()
+    });
+    crate::auction::formats::coordinated_cutover_v1::canonicalize_browser_auction_projection_v1(
+        BrowserAuctionProjectionV1 {
+            version: 1,
+            auction: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id,
+                results,
+            },
+            slots: browser_slots,
+            bids: Vec::new(),
+        },
+        request_origin,
+    )
+}
+
 /// Handle `GET /_ts/page-bids?path=<path>` — server-side auction for SPA navigation.
 ///
 /// Matches creative opportunity slots for the given path, runs a server-side
@@ -6330,51 +5378,9 @@ pub async fn handle_page_bids(
         return Ok(page_bids_preflight_denied());
     }
 
-    // Deprecation signal for the transition alias. Evaluated after the
-    // cross-site gate, so the count reflects genuine SPA clients still running a
-    // pre-rename tsjs bundle rather than anything a third-party page can
-    // inflate — and before the not-configured 404 below, so deployments with no
-    // creative opportunities still report their alias traffic instead of
-    // reading as zero. The log line and the response marker are the only in-app
-    // signals that `PAGE_BIDS_LEGACY_PATH` is still in use — the removal
-    // precondition in IABTechLab/trusted-server#970 is "no remaining traffic on
-    // the legacy path", which is otherwise only answerable from edge access
-    // logs.
-    //
-    // Two different clients land here, and they age out differently, so the log
-    // separates them by the `X-TSJS-Page-Bids` value. A pre-rename bundle sends
-    // `1` and disappears on its own as caches turn over. The current bundle
-    // sends `fallback` and does *not* — it only reaches the alias when the
-    // canonical path is unusable on this deployment (an operator `[[handlers]]`
-    // regex covering `/_ts`, or a server rolled back past the rename), which
-    // persists until that is fixed. Treating the two as one number would make
-    // #970 wait forever on a config problem. The value is client-supplied, so
-    // it is a diagnostic hint only; the gate above does not trust it.
-    let is_legacy_alias = req.uri().path() == PAGE_BIDS_LEGACY_PATH;
-    if is_legacy_alias {
-        let is_client_fallback = req
-            .headers()
-            .get("x-tsjs-page-bids")
-            .and_then(|value| value.to_str().ok())
-            == Some(PAGE_BIDS_FALLBACK_MARKER);
-        if is_client_fallback {
-            log::warn!(
-                "page-bids: served deprecated alias {PAGE_BIDS_LEGACY_PATH} to a current \
-                 tsjs bundle that could not use {PAGE_BIDS_PATH} — check `[[handlers]]` for \
-                 a pattern covering `/_ts`; see IABTechLab/trusted-server#970"
-            );
-        } else {
-            log::info!(
-                "page-bids: served deprecated alias {PAGE_BIDS_LEGACY_PATH} \
-                 (pre-rename tsjs bundle); see IABTechLab/trusted-server#970"
-            );
-        }
-    }
-
     let Some(co_config) = &settings.creative_opportunities else {
         let mut response = Response::new(EdgeBody::from("Creative opportunities not configured"));
         *response.status_mut() = StatusCode::NOT_FOUND;
-        mark_deprecated_alias(&mut response, is_legacy_alias);
         return Ok(response);
     };
 
@@ -6382,7 +5388,20 @@ pub async fn handle_page_bids(
     // origin the visitor is actually on (scheme, host, port), not the configured
     // publisher domain, which cannot carry a port and may differ by subdomain.
     let request_info = RequestInfo::from_request(&req, services.client_info());
-    let page_bids_request_origin = request_origin(&request_info.scheme, &request_info.host);
+    let request_scheme = if request_info.scheme.is_empty() {
+        req.uri().scheme_str().unwrap_or("https")
+    } else {
+        &request_info.scheme
+    };
+    let request_host = if request_info.host.is_empty() {
+        req.uri()
+            .authority()
+            .map(http::uri::Authority::as_str)
+            .unwrap_or(&settings.publisher.domain)
+    } else {
+        &request_info.host
+    };
+    let page_bids_request_origin = request_origin(request_scheme, request_host);
 
     let path_param = req
         .uri()
@@ -6394,28 +5413,13 @@ pub async fn handle_page_bids(
         })
         .unwrap_or_else(|| "/".to_string());
 
-    let format = match PageBidsFormat::parse(
-        req.uri()
-            .query()
-            .and_then(|query| {
-                url::form_urlencoded::parse(query.as_bytes())
-                    .find(|(k, _)| k == "format")
-                    .map(|(_, v)| v.into_owned())
-            })
-            .as_deref(),
-    ) {
-        Ok(format) => format,
-        Err(unknown) => {
-            log::warn!("page-bids: rejecting unknown format `{unknown}`");
-            return Ok(page_bids_unknown_format());
-        }
-    };
-
     let matched_slots = if co_config.enabled {
         match_renderable_slots(auction.slots, co_config, &path_param)
     } else {
         Vec::new()
     };
+    let browser_slots = build_browser_slots_v1(&matched_slots, co_config, &path_param);
+
     let request_info = crate::http_util::RequestInfo::from_request(&req, services.client_info());
     let ec_id = ec_context.ec_value().filter(|_| ec_context.ec_allowed());
     let consent_context = ec_context.consent();
@@ -6433,10 +5437,7 @@ pub async fn handle_page_bids(
     let is_bot = is_bot_user_agent(&req);
 
     let auction_enabled = auction.orchestrator.is_enabled();
-    let ad_templates_enabled = co_config.enabled;
-    if !ad_templates_enabled {
-        log::debug!("page-bids: [creative_opportunities].enabled is false — skipping templates");
-    } else if !auction_enabled {
+    if !auction_enabled {
         log::debug!("page-bids: [auction].enabled is false — skipping auction");
     } else if matched_slots.is_empty() {
         log::debug!(
@@ -6452,17 +5453,21 @@ pub async fn handle_page_bids(
         );
     }
 
-    // The dedicated template switch, [auction].enabled, and a consent denial
-    // disable the entire server-side ad stack. In those states the endpoint must
-    // return no slots, so the SPA hook does not assign `ts.adSlots` and call
-    // `adInit()` — otherwise the gate would stop SSP calls but still let the
-    // client create/refresh GPT slots client-side. Bot/prefetch requests, by
-    // contrast, keep their slot definitions (the placement structure is
-    // unchanged) but skip the live auction, matching the existing behavior.
-    let ad_stack_enabled = ad_templates_enabled && auction_enabled && consent_allows_auction;
+    // The [auction].enabled switch and a consent denial disable the
+    // entire server-side ad stack. In those states the endpoint returns no slots,
+    // so the coordinated runtime cannot create or refresh GPT placements.
+    // Bot/prefetch requests, by contrast,
+    // keep their slot definitions (the placement structure is unchanged) but
+    // skip the live auction, matching the existing bot/prefetch behaviour.
+    let ad_stack_enabled = auction_enabled && consent_allows_auction;
 
-    let (winning_bids, prebuilt_bid_map) = if matched_slots.is_empty() {
-        (std::collections::HashMap::new(), None)
+    let projection = if matched_slots.is_empty() {
+        page_bids_terminal_projection_v1(
+            &matched_slots,
+            browser_slots.clone(),
+            None,
+            &page_bids_request_origin,
+        )?
     } else {
         // Same publisher identity as the outbound bid request — see the
         // matching note on the initial-navigation observation above.
@@ -6518,17 +5523,31 @@ pub async fn handle_page_bids(
                 .await
             {
                 Ok(result) => {
-                    let winning_bids = result.winning_bids.clone();
-                    let auction_id = diagnostics_auction_id(settings);
-                    let bid_map = build_bid_map_with_auction_id(
-                        &winning_bids,
+                    let browser_auction_id =
+                        mint_browser_auction_id(&SystemAuctionIdentityGenerator)?;
+                    let projection = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                        &result,
                         co_config.price_granularity,
                         settings,
                         &page_bids_request_origin,
-                        settings.debug.inject_adm_for_testing,
-                        auction_id.as_deref(),
-                    );
-                    let delivered_winner_slots = bid_map.keys().cloned().collect();
+                        Some(&browser_auction_id),
+                        &SystemAuctionIdentityGenerator,
+                    )?;
+                    let projection = coordinated_cutover_v1::attach_browser_slots_v1(
+                        projection,
+                        browser_slots.clone(),
+                        &page_bids_request_origin,
+                    )?;
+                    let delivered_winner_slots = projection
+                        .projection
+                        .auction
+                        .results
+                        .iter()
+                        .filter_map(|decision| match decision {
+                            SlotAuctionDecisionV1::Winner { slot, .. } => Some(slot.clone()),
+                            _ => None,
+                        })
+                        .collect();
                     emit_auction_events_best_effort_lazy(services, || {
                         build_auction_events(
                             observation,
@@ -6540,7 +5559,7 @@ pub async fn handle_page_bids(
                         )
                     })
                     .await;
-                    (winning_bids, Some(bid_map))
+                    projection
                 }
                 Err(e) => {
                     log::warn!("page-bids auction failed: {e:?}");
@@ -6557,13 +5576,16 @@ pub async fn handle_page_bids(
                         )
                     })
                     .await;
-                    (std::collections::HashMap::new(), None)
+                    page_bids_terminal_projection_v1(
+                        &matched_slots,
+                        browser_slots.clone(),
+                        Some(AuctionSlotFailureReason::InternalError),
+                        &page_bids_request_origin,
+                    )?
                 }
             }
         } else {
-            let skip_reason = if !ad_templates_enabled {
-                "ad_templates_disabled"
-            } else if !auction_enabled {
+            let skip_reason = if !auction_enabled {
                 "auction_disabled"
             } else if !consent_allows_auction {
                 "consent_denied"
@@ -6585,82 +5607,38 @@ pub async fn handle_page_bids(
                 )
             })
             .await;
-            (std::collections::HashMap::new(), None)
+            let terminal_reason = if !auction_enabled {
+                AuctionSlotFailureReason::AuctionDisabled
+            } else if !consent_allows_auction {
+                AuctionSlotFailureReason::ConsentDenied
+            } else {
+                AuctionSlotFailureReason::SlotNotEligible
+            };
+            page_bids_terminal_projection_v1(
+                &matched_slots,
+                browser_slots,
+                Some(terminal_reason),
+                &page_bids_request_origin,
+            )?
         }
     };
 
-    let bid_map = prebuilt_bid_map.unwrap_or_else(|| {
-        build_bid_map_with_auction_id(
-            &winning_bids,
-            co_config.price_granularity,
-            settings,
-            &page_bids_request_origin,
-            settings.debug.inject_adm_for_testing,
-            None,
-        )
-    });
-
-    // Gate slots on the ad-stack kill switch / consent: when disabled, return no
-    // slots so the SPA hook does not call `adInit()` / create GPT slots.
-    let slots_json: Vec<serde_json::Value> = if ad_stack_enabled {
-        let section = co_config.section_for_path(&path_param);
-        matched_slots
-            .iter()
-            .filter_map(|slot| build_slot_json(slot, co_config, &section))
-            .collect()
-    } else {
-        Vec::new()
-    };
-
-    debug_assert_eq!(format, PageBidsFormat::Json);
-    let body = serde_json::json!({
-        "slots": slots_json,
-        "bids": bid_map,
-    });
-    let body = serde_json::to_string(&body).change_context(TrustedServerError::Proxy {
-        message: "Failed to serialize page-bids response".to_string(),
-    })?;
-
-    let mut response = Response::new(EdgeBody::from(body));
+    let mut response = Response::new(EdgeBody::from(projection.json));
     response.headers_mut().insert(
         header::CONTENT_TYPE,
         HeaderValue::from_static("application/json"),
     );
-    enforce_terminal_private_cache_privacy(&mut response);
-    mark_deprecated_alias(&mut response, is_legacy_alias);
-
-    Ok(response)
-}
-
-/// Marks a response served through [`PAGE_BIDS_LEGACY_PATH`] as deprecated.
-///
-/// Attaches the RFC 9745 `deprecation` link relation pointing at the removal
-/// issue, so CDN and edge log pipelines can measure remaining legacy traffic
-/// from any vantage point — the removal precondition in
-/// IABTechLab/trusted-server#970 is otherwise answerable only from application
-/// logs. RFC 9745's companion `Deprecation` field is deliberately omitted: it
-/// carries a date, and there is no source of truth here for when the alias was
-/// deprecated.
-///
-/// No-op for the canonical path.
-fn mark_deprecated_alias(response: &mut Response<EdgeBody>, is_legacy_alias: bool) {
-    if !is_legacy_alias {
-        return;
-    }
-
     response.headers_mut().insert(
-        header::LINK,
-        HeaderValue::from_static(
-            "<https://github.com/IABTechLab/trusted-server/issues/970>; rel=\"deprecation\"",
-        ),
+        header::CACHE_CONTROL,
+        HeaderValue::from_static("private, no-store"),
     );
+    Ok(response)
 }
 
 #[cfg(test)]
 mod tests {
     use std::future::Future as _;
     use std::io::{self, Read as _, Write as _};
-    use std::sync::atomic::{AtomicUsize, Ordering};
 
     use brotli::Decompressor;
     use brotli::enc::writer::CompressorWriter;
@@ -6669,22 +5647,85 @@ mod tests {
 
     use super::*;
     use crate::auction::orchestrator::OrchestrationResult;
-    use crate::auction::types::AuctionResponse;
     use crate::auction::types::{AdFormat, AdSlot, MediaType};
+    use crate::auction::types::{AuctionDecisionSetV1, AuctionDropReason, AuctionResponse};
+    use crate::auction_config_types::{NotificationConfig, ProviderConfig, RoutingMode};
     use crate::integrations::IntegrationRegistry;
     use crate::platform::test_support::{
         NoopSecretStore, StubHttpClient, build_services_with_http_client,
         build_services_with_secret_http_client_and_client_ip, noop_services,
         noop_services_with_telemetry_sink,
     };
-    use crate::test_support::tests::{crate_test_settings_str, create_test_settings};
+    use crate::test_support::tests::{
+        bootstrap_transport, crate_test_settings_str, create_test_settings,
+    };
     use edgezero_core::body::Body as EdgeBody;
     use http::{Method, Request as HttpRequest, StatusCode, header};
     use std::sync::Arc;
 
+    #[test]
+    fn enforcing_csp_selects_one_nonce_from_the_effective_script_directive() {
+        let headers = vec![(
+            "Content-Security-Policy".to_owned(),
+            "default-src 'nonce-default'; script-src 'nonce-script'; script-src-elem 'nonce-element' https:".to_owned(),
+        )];
+        assert_eq!(response_csp_nonce(&headers).as_deref(), Some("element"));
+    }
+
+    #[test]
+    fn enforcing_csp_nonce_selection_intersects_policies_and_fails_closed() {
+        let common = vec![
+            (
+                "content-security-policy".to_owned(),
+                "script-src 'nonce-shared' 'nonce-first'".to_owned(),
+            ),
+            (
+                "CONTENT-SECURITY-POLICY".to_owned(),
+                "script-src-elem 'nonce-shared' 'nonce-second'".to_owned(),
+            ),
+        ];
+        assert_eq!(response_csp_nonce(&common).as_deref(), Some("shared"));
+
+        let ambiguous = vec![(
+            "content-security-policy".to_owned(),
+            "script-src 'nonce-one' 'nonce-two'".to_owned(),
+        )];
+        assert_eq!(response_csp_nonce(&ambiguous), None);
+
+        let disjoint = vec![
+            (
+                "content-security-policy".to_owned(),
+                "script-src 'nonce-one'".to_owned(),
+            ),
+            (
+                "content-security-policy".to_owned(),
+                "script-src 'nonce-two'".to_owned(),
+            ),
+        ];
+        assert_eq!(response_csp_nonce(&disjoint), None);
+    }
+
+    #[test]
+    fn report_only_and_malformed_nonce_sources_do_not_authorize_emission() {
+        let headers = vec![
+            (
+                "content-security-policy-report-only".to_owned(),
+                "script-src 'nonce-report'".to_owned(),
+            ),
+            (
+                "content-security-policy".to_owned(),
+                "script-src 'nonce-bad\"value'".to_owned(),
+            ),
+        ];
+        assert_eq!(response_csp_nonce(&headers), None);
+    }
+
     fn make_test_bid_with_creative(creative: &str) -> Bid {
         Bid {
             slot_id: "slot".to_string(),
+            candidate_id: None,
+            candidate_provider: None,
+            renderer_reservation_id: None,
             price: Some(1.0),
             currency: "USD".to_string(),
             creative: Some(creative.to_string()),
@@ -6706,810 +5747,1430 @@ mod tests {
         }
     }
 
-    /// Build the ts-debug comment for a one-bid auction whose creative is
-    /// `creative`, so tests can assert on the rendered dump.
-    fn dump_comment_for_creative_with_options(
-        creative: &str,
-        options: &AuctionDebugCommentOptions,
-    ) -> String {
-        let mut bid = make_test_bid_with_creative(creative);
-        bid.slot_id = "ad-header-0".to_string();
-        let result = OrchestrationResult {
-            provider_responses: vec![
-                AuctionResponse::no_bid("prebid", 665),
-                AuctionResponse::success("aps", vec![bid], 42),
-            ],
-            mediator_response: None,
-            winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 665,
-            metadata: std::collections::HashMap::new(),
-        };
-        let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment("stream", &result, &state, options);
-        let comment = state
-            .script_cell()
-            .lock()
-            .expect("should lock state")
-            .clone()
-            .expect("should have comment");
-        drop(state);
-        comment
+    fn enable_aps_auction_plan(settings: &mut Settings) {
+        settings.auction.enabled = true;
+        settings.auction.providers = std::collections::BTreeMap::from([(
+            "aps-main".parse().expect("should parse APS provider ID"),
+            ProviderConfig {
+                protocol: "openrtb-2.6".to_string(),
+                profile: "aps".to_string(),
+                endpoint: "https://aps.example/e/pb/bid".to_string(),
+                timeout_ms: None,
+                routing: RoutingMode::AllEligible,
+                notifications: NotificationConfig::default(),
+                profile_config: serde_json::json!({"account_id":"test-account"}),
+            },
+        )]);
     }
 
-    fn dump_comment_for_creative(creative: &str) -> String {
-        dump_comment_for_creative_with_options(creative, &AuctionDebugCommentOptions::default())
+    fn boot_auction_id(html: &str) -> String {
+        bootstrap_transport(html)["boot"]["auctionProjection"]["auction"]["auctionId"]
+            .as_str()
+            .expect("sealed auction projection should carry an auction id")
+            .to_owned()
     }
 
-    fn dump_comment_for_metadata_with_options(
-        metadata: std::collections::HashMap<String, serde_json::Value>,
-        options: &AuctionDebugCommentOptions,
-    ) -> String {
-        let mut response = AuctionResponse::error("prebid", 12);
-        response.metadata = metadata;
-        let result = OrchestrationResult {
-            provider_responses: vec![response],
-            mediator_response: None,
-            winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 12,
-            metadata: std::collections::HashMap::new(),
-        };
-        let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment("stream", &result, &state, options);
-        let comment = state
-            .script_cell()
-            .lock()
-            .expect("should lock state")
-            .clone()
-            .expect("should have comment");
-        drop(state);
-        comment
+    fn boot_gpt_diagnostics_active(html: &str) -> bool {
+        bootstrap_transport(html)["boot"]["diagnostics"]["gpt"]["active"]
+            .as_bool()
+            .expect("sealed diagnostics should carry the GPT activation state")
     }
 
-    fn dump_from_comment(comment: &str) -> (&str, serde_json::Value) {
-        let (_, after_dump) = comment
-            .split_once("dump=")
-            .expect("should contain dump marker");
-        let (dump, _) = after_dump
-            .rsplit_once("\n-->")
-            .expect("should contain comment terminator");
-        let value: serde_json::Value =
-            serde_json::from_str(dump).expect("should contain valid untruncated JSON");
-        (dump, value)
-    }
+    mod coordinated_cutover_projection_tests {
+        use std::collections::{HashMap, VecDeque};
+        use std::sync::atomic::{AtomicUsize, Ordering};
 
-    fn response_metadata_from_comment(comment: &str) -> serde_json::Value {
-        let (_, dump) = dump_from_comment(comment);
-        dump["provider_responses"][0]["metadata"].clone()
-    }
+        use super::*;
+        use crate::auction::types::{
+            AdmRenderSourceV1, ApsRendererV1, ApsTagType, AuctionIdentityGenerator,
+            AuctionSlotFailureReason, BidRenderSourceV1, SlotAuctionDecisionV1,
+        };
+        use crate::price_bucket::PriceGranularity;
+        use base64::Engine as _;
 
-    #[test]
-    fn auction_debug_comment_dumps_provider_status() {
-        let comment = dump_comment_for_creative("<div>plain</div>");
-        // Compact (non-pretty) JSON: `"status":"nobid"` with no spaces.
-        assert!(
-            comment.contains("\"status\":\"nobid\""),
-            "should surface the no-bid provider status: {comment}"
-        );
-        assert!(
-            comment.contains("dump={\"provider_responses\":"),
-            "should dump the provider_responses payload: {comment}"
-        );
-        // No mediator ran, so it is omitted (mediator=none already says so).
-        assert!(
-            !comment.contains("mediator_response"),
-            "should omit mediator_response when no mediator ran: {comment}"
-        );
-    }
+        struct ScriptedIdentityGenerator {
+            draws: Mutex<VecDeque<Vec<u8>>>,
+            count: AtomicUsize,
+        }
 
-    #[test]
-    fn auction_debug_comment_reaches_the_shared_template_seam() {
-        let result = OrchestrationResult {
-            provider_responses: vec![AuctionResponse::no_bid("prebid", 12)],
-            mediator_response: None,
-            winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 12,
-            metadata: std::collections::HashMap::new(),
-        };
-        let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment(
-            "stream",
-            &result,
-            &state,
-            &AuctionDebugCommentOptions::default(),
-        );
+        impl ScriptedIdentityGenerator {
+            fn new(draws: impl IntoIterator<Item = Vec<u8>>) -> Self {
+                Self {
+                    draws: Mutex::new(draws.into_iter().collect()),
+                    count: AtomicUsize::new(0),
+                }
+            }
+        }
 
-        let seam = state.build_seam_script("[]");
+        impl AuctionIdentityGenerator for ScriptedIdentityGenerator {
+            fn fill(&self, destination: &mut [u8]) -> Result<(), ()> {
+                self.count.fetch_add(1, Ordering::SeqCst);
+                let draw = self
+                    .draws
+                    .lock()
+                    .expect("should lock scripted draws")
+                    .pop_front()
+                    .ok_or(())?;
+                if draw.len() != destination.len() {
+                    return Err(());
+                }
+                destination.copy_from_slice(&draw);
+                Ok(())
+            }
+        }
 
-        assert!(
-            seam.contains("<!-- ts-debug:"),
-            "debug state must reach ESI"
-        );
-        assert!(
-            seam.find("<!-- ts-debug:") < seam.find("<script>"),
-            "the diagnostic comment should precede the executable seam: {seam}"
-        );
-    }
+        fn tagged_adm_bid(slot: &str, candidate_id: &str, cpm: f64) -> Bid {
+            Bid {
+                slot_id: slot.to_string(),
+                candidate_id: Some(candidate_id.to_string()),
+                candidate_provider: Some("prebid".to_string()),
+                renderer_reservation_id: None,
+                price: Some(cpm),
+                currency: "USD".to_string(),
+                creative: None,
+                adomain: None,
+                bidder: "example_bidder".to_string(),
+                returned_seat: None,
+                width: 300,
+                height: 250,
+                nurl: None,
+                burl: None,
+                bid_id: Some(format!("upstream-{slot}")),
+                ad_id: None,
+                creative_id: None,
+                renderer: Some(BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+                    version: 1,
+                    adm: format!("<div>{slot}</div>"),
+                    width: 300,
+                    height: 250,
+                })),
+                cache_id: None,
+                cache_host: None,
+                cache_path: None,
+                metadata: HashMap::new(),
+            }
+        }
 
-    #[test]
-    fn auction_debug_comment_pretty_formats_outer_json_without_changing_value() {
-        let compact_comment = dump_comment_for_creative("<div>plain</div>");
-        let pretty_options = AuctionDebugCommentOptions {
-            format: AuctionDebugCommentFormat::Pretty,
-            ..AuctionDebugCommentOptions::default()
-        };
-        let pretty_comment =
-            dump_comment_for_creative_with_options("<div>plain</div>", &pretty_options);
+        fn tagged_aps_bid(slot: &str, candidate_id: &str, cpm: f64) -> Bid {
+            let envelope =
+                include_str!("../../trusted-server-js/lib/test/fixtures/aps-renderer-v1.json");
+            let mut bid = tagged_adm_bid(slot, candidate_id, cpm);
+            bid.candidate_provider = Some("aps".to_string());
+            bid.bidder = "aps".to_string();
+            bid.bid_id = Some("fictional-selected-bid-id".to_string());
+            bid.renderer = Some(BidRenderSourceV1::Aps(ApsRendererV1 {
+                version: 1,
+                account_id: "example-account-id".to_string(),
+                bid_id: "fictional-selected-bid-id".to_string(),
+                creative_id: None,
+                tag_type: ApsTagType::Iframe,
+                creative_url: "https://creative.example/render".to_string(),
+                aax_response: base64::engine::general_purpose::STANDARD.encode(envelope),
+                width: 300,
+                height: 250,
+            }));
+            bid
+        }
 
-        assert!(
-            compact_comment.contains("dump={\"provider_responses\":"),
-            "default output should remain compact: {compact_comment}"
-        );
-        assert!(
-            pretty_comment.contains("dump={\n  \"provider_responses\":"),
-            "pretty output should indent the outer dump: {pretty_comment}"
-        );
+        fn result_with_winners(bids: Vec<Bid>) -> OrchestrationResult {
+            let results = bids
+                .iter()
+                .map(|bid| SlotAuctionDecisionV1::Winner {
+                    slot: bid.slot_id.clone(),
+                    candidate_id: bid
+                        .candidate_id
+                        .clone()
+                        .expect("test winner should have candidate id"),
+                })
+                .collect();
+            OrchestrationResult {
+                provider_responses: Vec::new(),
+                mediator_response: None,
+                winning_bids: bids
+                    .into_iter()
+                    .map(|bid| (bid.slot_id.clone(), bid))
+                    .collect(),
+                decision_set: AuctionDecisionSetV1 {
+                    version: 1,
+                    auction_id: "auction-projection".to_string(),
+                    results,
+                },
+                total_time_ms: 1,
+                metadata: HashMap::new(),
+            }
+        }
 
-        let (_, compact_dump) = dump_from_comment(&compact_comment);
-        let (_, pretty_dump) = dump_from_comment(&pretty_comment);
-        assert_eq!(
-            pretty_dump, compact_dump,
-            "formatting should not change the dump value"
-        );
-    }
+        #[test]
+        fn projection_preserves_tagged_source_and_uses_one_reservation_on_both_wires() {
+            let source = BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+                version: 1,
+                adm: "<div>slot-1</div>".to_string(),
+                width: 300,
+                height: 250,
+            });
+            let result = result_with_winners(vec![tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.75)]);
+            let generator = ScriptedIdentityGenerator::new([vec![7; 16]]);
 
-    #[test]
-    fn auction_debug_comment_pretty_preserves_nested_json_as_string() {
-        let metadata = std::collections::HashMap::from([(
-            "debug".to_string(),
-            serde_json::json!({
-                "httpcalls": {
-                    "openx": [{ "requestbody": "{\"id\":\"request-1\"}" }]
-                }
-            }),
-        )]);
-        let options = AuctionDebugCommentOptions {
-            verbosity: AuctionDebugCommentVerbosity::Full,
-            format: AuctionDebugCommentFormat::Pretty,
-            ..AuctionDebugCommentOptions::default()
-        };
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &generator,
+            )
+            .expect("valid winner should project");
 
-        let comment = dump_comment_for_metadata_with_options(metadata, &options);
-        let response_metadata = response_metadata_from_comment(&comment);
-        let request_body = &response_metadata["debug"]["httpcalls"]["openx"][0]["requestbody"];
-        assert_eq!(request_body, "{\"id\":\"request-1\"}");
-        assert!(
-            request_body.is_string(),
-            "nested request body should remain a string"
-        );
-    }
+            let bid = &canonical.projection.bids[0];
+            assert_eq!(bid.candidate_id, "AAAAAAAAAAAA");
+            assert_eq!(bid.cpm, 2.75);
+            assert_eq!(bid.render_source, source);
+            assert_eq!(
+                bid.renderer_reservation_id.as_deref(),
+                Some("r1_BwcHBwcHBwcHBwcHBwcHBw")
+            );
+            assert!(
+                !serde_json::to_value(&bid.render_source)
+                    .expect("render source should serialize")
+                    .to_string()
+                    .contains("2.75"),
+                "selected CPM must not enter the render capability"
+            );
 
-    #[test]
-    fn auction_debug_comment_never_leaks_provider_debug_metadata() {
-        // A provider response whose `debug` metadata mirrors the shape prebid
-        // stores verbatim when `[integration.prebid].debug` is on: the resolved
-        // OpenRTB request carrying the visitor's identity graph. The dump must
-        // drop it — only allowlisted keys may reach the DOM.
-        let response = AuctionResponse::error("prebid", 12)
-            .with_metadata(
-                "debug",
-                serde_json::json!({
-                    "resolvedrequest": {
-                        "user": {
-                            "id": "EC-ID-abc123",
-                            "consent": "CPtc-TCSTRING-xyz",
-                            "ext": { "eids": [{ "source": "example.com",
-                                                "uids": [{ "id": "EID-USER-999" }] }] }
-                        },
-                        "device": { "ip": "203.0.113.77",
-                                    "geo": { "lat": 37.7749, "lon": -122.4194 } }
-                    }
-                }),
+            let direct: serde_json::Value = serde_json::from_slice(
+                &crate::auction::formats::coordinated_cutover_v1::serialize_trusted_server_auction_response_v1(
+                    &canonical,
+                )
+                .expect("direct wire should serialize"),
             )
-            // An allowlisted key must still survive.
-            .with_metadata("error_type", serde_json::json!("http_status"));
-        let result = OrchestrationResult {
-            provider_responses: vec![response],
-            mediator_response: None,
-            winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 12,
-            metadata: std::collections::HashMap::new(),
-        };
-        let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment(
-            "stream",
-            &result,
-            &state,
-            &AuctionDebugCommentOptions::default(),
-        );
-        let comment = state
-            .script_cell()
-            .lock()
-            .expect("should lock state")
-            .clone()
-            .expect("should have comment");
+            .expect("direct wire should be JSON");
+            assert_eq!(
+                direct["seatbid"][0]["bid"][0]["id"],
+                bid.renderer_reservation_id
+                    .as_deref()
+                    .expect("ADM bid should have reservation")
+            );
+        }
 
-        for needle in [
-            "EC-ID-abc123",
-            "EID-USER-999",
-            "CPtc-TCSTRING-xyz",
-            "203.0.113.77",
-            "37.7749",
-            "resolvedrequest",
-        ] {
+        #[test]
+        fn initial_html_state_uses_the_exact_projection_json_without_a_legacy_script() {
+            let result = result_with_winners(vec![tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.75)]);
+            let state = AdBidsState::default();
+            let slots = serde_json::to_string(&vec![BrowserAuctionSlotV1 {
+                slot: "slot-1".to_string(),
+                gam_unit_path: "/123/slot-1".to_string(),
+                div_id: "div-slot-1".to_string(),
+                formats: vec![[300, 250]],
+                targeting: BTreeMap::from([("pos".to_string(), "atf".to_string())]),
+            }])
+            .expect("slot projection should serialize");
+
+            let delivered = write_projection_to_state(
+                &result,
+                PriceGranularity::Dense,
+                &state,
+                &Settings::default(),
+                "https://publisher.example",
+                Some(&slots),
+            );
+
+            assert_eq!(delivered, HashSet::from(["slot-1".to_owned()]));
+            let stored = state
+                .lock()
+                .expect("should lock projection state")
+                .clone()
+                .expect("should store projection JSON");
+            let projection: serde_json::Value =
+                serde_json::from_str(&stored).expect("should store the exact projection shape");
+            let auction_id = projection["auction"]["auctionId"]
+                .as_str()
+                .expect("browser auction id should be a string");
             assert!(
-                !comment.contains(needle),
-                "identity/debug value {needle:?} must not reach the page HTML: {comment}"
+                auction_id.starts_with("a1_") && auction_id != result.decision_set.auction_id,
+                "initial HTML should use a fresh browser auction identity"
             );
+            assert_eq!(projection["slots"][0]["slot"], "slot-1");
+            assert_eq!(projection["slots"][0]["gamUnitPath"], "/123/slot-1");
+            assert_eq!(projection["bids"].as_array().map(Vec::len), Some(1));
+            assert!(!stored.contains("<script"));
+            assert!(!stored.contains(".bids"));
+            assert!(!stored.contains("adSlots"));
         }
-        assert!(
-            comment.contains("\"error_type\":\"http_status\""),
-            "allowlisted metadata must still surface: {comment}"
-        );
-    }
 
-    #[test]
-    fn default_options_apply_safe_response_metadata_schema() {
-        let metadata = std::collections::HashMap::from([
-            ("error_type".to_string(), serde_json::json!("http_status")),
-            ("http_status".to_string(), serde_json::json!(422)),
-            (
-                "message".to_string(),
-                serde_json::json!("raw-message-example-user-123"),
-            ),
-            (
-                "errors".to_string(),
-                serde_json::json!(["errors-example-user-123"]),
-            ),
-            (
-                "warnings".to_string(),
-                serde_json::json!(["warnings-example-user-123"]),
-            ),
-            (
-                "responsetimemillis".to_string(),
-                serde_json::json!({"timing-example-user-123": 12}),
-            ),
-            (
-                "bidstatus".to_string(),
-                serde_json::json!([{"bidder": "bidstatus-example-user-123"}]),
-            ),
-            (
-                "upstream_message".to_string(),
-                serde_json::json!("upstream-example-user-123"),
-            ),
-            (
-                "upstream_message_truncated".to_string(),
-                serde_json::json!("truncated-example-user-123"),
-            ),
-            (
-                "debug".to_string(),
-                serde_json::json!({"resolvedrequest": {"user": {"id": "debug-example-user-123"}}}),
-            ),
-        ]);
+        #[test]
+        fn browser_boot_attachment_requires_slots_for_every_decision() {
+            let result = result_with_winners(vec![tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.75)]);
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                Some("a1_AAAAAAAAAAAA"),
+                &SystemAuctionIdentityGenerator,
+            )
+            .expect("direct projection should be canonical before boot slots attach");
 
-        let comment = dump_comment_for_metadata_with_options(
-            metadata,
-            &AuctionDebugCommentOptions::default(),
-        );
+            let error = coordinated_cutover_v1::attach_browser_slots_v1(
+                canonical,
+                Vec::new(),
+                "https://publisher.example",
+            )
+            .expect_err("browser boot must never pair decisions with an empty slot list");
+            assert!(error.to_string().contains("cover every decision"));
+        }
 
-        assert_eq!(
-            response_metadata_from_comment(&comment),
-            serde_json::json!({
-                "error_type": "http_status",
-                "http_status": 422,
-                "message": "Provider returned HTTP 422",
-            })
-        );
-    }
+        #[test]
+        fn initial_projection_failure_preserves_exact_slot_coverage() {
+            let result = result_with_winners(vec![tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.75)]);
+            let state = AdBidsState::default();
+            let slots = serde_json::to_string(&vec![BrowserAuctionSlotV1 {
+                slot: "slot-1".to_string(),
+                gam_unit_path: "/123/slot-1".to_string(),
+                div_id: "div-slot-1".to_string(),
+                formats: vec![[300, 250]],
+                targeting: BTreeMap::new(),
+            }])
+            .expect("slot projection should serialize");
+
+            let delivered = write_projection_to_state(
+                &result,
+                PriceGranularity::Dense,
+                &state,
+                &Settings::default(),
+                "not-an-origin",
+                Some(&slots),
+            );
 
-    #[test]
-    fn configured_metadata_subset_only_includes_selected_safe_keys() {
-        let metadata = std::collections::HashMap::from([
-            ("error_type".to_string(), serde_json::json!("http_status")),
-            ("http_status".to_string(), serde_json::json!(418)),
-            (
-                "errors".to_string(),
-                serde_json::json!(["errors-example-user-123"]),
-            ),
-            (
-                "debug".to_string(),
-                serde_json::json!({"identity": "debug-example-user-123"}),
-            ),
-        ]);
-        let options = AuctionDebugCommentOptions {
-            metadata_keys: vec![
-                "http_status".to_string(),
-                "errors".to_string(),
-                "debug".to_string(),
-            ],
-            ..AuctionDebugCommentOptions::default()
-        };
+            assert!(delivered.is_empty());
+            let stored = state
+                .lock()
+                .expect("should lock projection state")
+                .clone()
+                .expect("should store fail-closed projection JSON");
+            let projection: BrowserAuctionProjectionV1 =
+                serde_json::from_str(&stored).expect("fallback should remain contract-shaped");
+            assert_eq!(projection.slots.len(), projection.auction.results.len());
+            assert_eq!(projection.slots[0].slot, "slot-1");
+            assert!(matches!(
+                projection.auction.results[0],
+                SlotAuctionDecisionV1::Failed {
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                    ..
+                }
+            ));
+        }
 
-        let comment = dump_comment_for_metadata_with_options(metadata, &options);
+        #[test]
+        fn reservation_collision_exhaustion_fails_only_the_affected_winner() {
+            let repeated = vec![9; 16];
+            let generator = ScriptedIdentityGenerator::new(
+                std::iter::once(repeated.clone()).chain(std::iter::repeat_n(repeated, 9)),
+            );
+            let result = result_with_winners(vec![
+                tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.0),
+                tagged_adm_bid("slot-2", "BBBBBBBBBBBB", 1.0),
+            ]);
 
-        assert_eq!(
-            response_metadata_from_comment(&comment),
-            serde_json::json!({"http_status": 418})
-        );
-    }
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &generator,
+            )
+            .expect("collision exhaustion should remain a per-slot decision");
 
-    #[test]
-    fn redacted_mode_rejects_wrong_types_and_unknown_error_classifications() {
-        let invalid_cases = [
-            std::collections::HashMap::from([(
-                "error_type".to_string(),
-                serde_json::json!({"identity": "example-user-123"}),
-            )]),
-            std::collections::HashMap::from([
-                (
-                    "error_type".to_string(),
-                    serde_json::json!("provider_supplied_unknown"),
-                ),
-                ("message".to_string(), serde_json::json!("example-user-123")),
-            ]),
-            std::collections::HashMap::from([(
-                "http_status".to_string(),
-                serde_json::json!("200 example-user-123"),
-            )]),
-            std::collections::HashMap::from([("http_status".to_string(), serde_json::json!(99))]),
-            std::collections::HashMap::from([("http_status".to_string(), serde_json::json!(600))]),
-            std::collections::HashMap::from([(
-                "http_status".to_string(),
-                serde_json::json!(200.5),
-            )]),
-            std::collections::HashMap::from([(
-                "message".to_string(),
-                serde_json::json!({"identity": "example-user-123"}),
-            )]),
-        ];
-        for metadata in invalid_cases {
-            let comment = dump_comment_for_metadata_with_options(
-                metadata,
-                &AuctionDebugCommentOptions::default(),
-            );
+            assert_eq!(generator.count.load(Ordering::SeqCst), 10);
+            assert_eq!(canonical.projection.bids.len(), 1);
+            assert!(matches!(
+                &canonical.projection.auction.results[0],
+                SlotAuctionDecisionV1::Winner { slot, .. } if slot == "slot-1"
+            ));
             assert_eq!(
-                response_metadata_from_comment(&comment),
-                serde_json::json!({})
+                canonical.projection.auction.results[1],
+                SlotAuctionDecisionV1::Failed {
+                    slot: "slot-2".to_string(),
+                    reason: AuctionSlotFailureReason::IdentityGenerationFailed,
+                }
             );
-            assert!(!comment.contains("example-user-123"));
-            assert!(!comment.contains("provider_supplied_unknown"));
         }
 
-        for status in [100_u64, 599] {
-            let metadata = std::collections::HashMap::from([(
-                "http_status".to_string(),
-                serde_json::json!(status),
-            )]);
-            let comment = dump_comment_for_metadata_with_options(
-                metadata,
-                &AuctionDebugCommentOptions::default(),
+        #[test]
+        fn aps_projection_preserves_the_validated_descriptor_without_cpm() {
+            let result = result_with_winners(vec![tagged_aps_bid("slot-1", "AAAAAAAAAAAA", 4.25)]);
+            let source = result.winning_bids["slot-1"]
+                .renderer
+                .clone()
+                .expect("APS source should exist");
+            let generator = ScriptedIdentityGenerator::new([vec![3; 16]]);
+
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &generator,
+            )
+            .expect("valid APS winner should project");
+
+            assert_eq!(canonical.projection.bids[0].render_source, source);
+            assert_eq!(canonical.projection.bids[0].cpm, 4.25);
+            assert!(
+                !serde_json::to_string(&canonical.projection.bids[0].render_source)
+                    .expect("APS source should serialize")
+                    .contains("4.25")
+            );
+        }
+
+        #[test]
+        fn cache_projection_preserves_native_coordinates_without_policy_or_reservation() {
+            let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+            bid.renderer = None;
+            bid.cache_id = Some("f47447a0-b759-4f2f-9887-af458b79b570".to_string());
+            bid.cache_host = Some("cache.example:8443".to_string());
+            bid.cache_path = Some("/pbc/v1/cache/opaque%2Fpath".to_string());
+            let result = result_with_winners(vec![bid]);
+            let generator = ScriptedIdentityGenerator::new([]);
+
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &generator,
+            )
+            .expect("valid cache winner should project");
+
+            assert_eq!(generator.count.load(Ordering::SeqCst), 0);
+            assert_eq!(
+                serde_json::to_value(&canonical.projection.bids[0])
+                    .expect("cache projection should serialize"),
+                serde_json::json!({
+                    "candidateId": "AAAAAAAAAAAA",
+                    "slot": "slot-1",
+                    "provider": "prebid",
+                    "upstreamBidId": "upstream-slot-1",
+                    "cpm": 1.5,
+                    "currency": "USD",
+                    "targeting": {"hb_bidder": "example_bidder", "hb_pb": "1.50"},
+                    "renderSource": {
+                        "type": "pbs_cache",
+                        "version": 1,
+                        "cacheId": "f47447a0-b759-4f2f-9887-af458b79b570",
+                        "cacheHost": "cache.example:8443",
+                        "cachePath": "/pbc/v1/cache/opaque%2Fpath",
+                        "width": 300,
+                        "height": 250
+                    }
+                })
             );
+
+            let direct: serde_json::Value = serde_json::from_slice(
+                &crate::auction::formats::coordinated_cutover_v1::serialize_trusted_server_auction_response_v1(
+                    &canonical,
+                )
+                .expect("direct wire should serialize"),
+            )
+            .expect("direct wire should be JSON");
             assert_eq!(
-                response_metadata_from_comment(&comment),
-                serde_json::json!({"http_status": status})
+                direct["seatbid"][0]["bid"][0]["id"],
+                "f47447a0-b759-4f2f-9887-af458b79b570"
             );
         }
-    }
 
-    #[test]
-    fn redacted_mode_generates_fixed_safe_messages() {
-        let cases = [
-            (
-                "parse_response",
-                None,
-                "Provider response could not be parsed",
-            ),
-            ("launch_failed", None, "Provider launch failed"),
-            ("transport", None, "Provider request failed"),
-            ("timeout", None, "Provider request timed out"),
-            ("http_status", Some(418_u64), "Provider returned HTTP 418"),
-            ("http_status", None, "Provider returned an HTTP error"),
-        ];
-        for (error_type, status, expected) in cases {
-            let mut metadata = std::collections::HashMap::from([
-                ("error_type".to_string(), serde_json::json!(error_type)),
-                (
-                    "message".to_string(),
-                    serde_json::json!("raw-example-user-123"),
-                ),
-            ]);
-            if let Some(status) = status {
-                metadata.insert("http_status".to_string(), serde_json::json!(status));
+        #[test]
+        fn projection_rejects_adm_with_any_coexisting_cache_coordinate() {
+            for extra in ["id", "host", "path"] {
+                let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+                bid.renderer = None;
+                bid.creative = Some("<div>creative</div>".to_string());
+                if extra == "id" {
+                    bid.cache_id = Some("f47447a0-b759-4f2f-9887-af458b79b570".to_string());
+                }
+                if extra == "host" {
+                    bid.cache_host = Some("cache.example".to_string());
+                }
+                if extra == "path" {
+                    bid.cache_path = Some("/pbc/v1/cache".to_string());
+                }
+                let generator = ScriptedIdentityGenerator::new([]);
+                let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                    &result_with_winners(vec![bid]),
+                    PriceGranularity::Dense,
+                    &Settings::default(),
+                    "https://publisher.example",
+                    None,
+                    &generator,
+                )
+                .expect("ambiguous ADM source should remain attributable");
+
+                assert!(canonical.projection.bids.is_empty(), "extra {extra}");
+                assert_eq!(generator.count.load(Ordering::SeqCst), 0, "extra {extra}");
+                assert_eq!(
+                    canonical.projection.auction.results[0],
+                    SlotAuctionDecisionV1::Failed {
+                        slot: "slot-1".to_string(),
+                        reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                    },
+                    "extra {extra}"
+                );
             }
-            let comment = dump_comment_for_metadata_with_options(
-                metadata,
-                &AuctionDebugCommentOptions::default(),
+        }
+
+        #[test]
+        fn rejected_adm_does_not_fall_through_to_coexisting_cache_coordinates() {
+            let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+            bid.renderer = None;
+            bid.creative = Some("x".repeat(1024 * 1024 + 1));
+            bid.cache_id = Some("cache-id".to_string());
+            bid.cache_host = Some("cache.example".to_string());
+            bid.cache_path = Some("/pbc/v1/cache".to_string());
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result_with_winners(vec![bid]),
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &ScriptedIdentityGenerator::new([]),
+            )
+            .expect("rejected ADM should remain an attributable slot failure");
+
+            assert!(canonical.projection.bids.is_empty());
+            assert_eq!(
+                canonical.projection.auction.results[0],
+                SlotAuctionDecisionV1::Failed {
+                    slot: "slot-1".to_string(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                }
             );
-            let rendered = response_metadata_from_comment(&comment);
-            assert_eq!(rendered["message"], serde_json::json!(expected));
-            assert!(!comment.contains("raw-example-user-123"));
         }
-    }
 
-    #[test]
-    fn redacted_metadata_covers_every_orchestrator_error_type() {
-        // Drift guard: adding a classification to ERROR_TYPE_ALL without wiring
-        // wording into safe_error_message would make it vanish from redacted
-        // dumps through the catch-all match arm.
-        for error_type in ERROR_TYPE_ALL {
-            let metadata = std::collections::HashMap::from([(
-                "error_type".to_string(),
-                serde_json::json!(error_type),
-            )]);
+        #[test]
+        fn cache_projection_requires_all_three_native_coordinates() {
+            for missing in ["id", "host", "path"] {
+                let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+                bid.renderer = None;
+                bid.creative = None;
+                bid.cache_id = (missing != "id").then(|| "cache-id".to_string());
+                bid.cache_host = (missing != "host").then(|| "cache.example".to_string());
+                bid.cache_path = (missing != "path").then(|| "/pbc/v1/cache".to_string());
+                let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                    &result_with_winners(vec![bid]),
+                    PriceGranularity::Dense,
+                    &Settings::default(),
+                    "https://publisher.example",
+                    None,
+                    &ScriptedIdentityGenerator::new([]),
+                )
+                .expect("incomplete cache coordinates should remain attributable");
+
+                assert!(canonical.projection.bids.is_empty(), "missing {missing}");
+                assert!(matches!(
+                    canonical.projection.auction.results[0],
+                    SlotAuctionDecisionV1::Failed {
+                        reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                        ..
+                    }
+                ));
+            }
+        }
+
+        #[test]
+        fn duplicate_cache_ids_remain_slot_scoped_and_never_enter_reservation_identity() {
+            let mut first = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 2.0);
+            first.renderer = None;
+            first.creative = None;
+            first.cache_id = Some("shared-cache-id".to_string());
+            first.cache_host = Some("Cache.EXAMPLE:443".to_string());
+            first.cache_path = Some("/opaque//path%2Fsegment".to_string());
+            let mut second = tagged_adm_bid("slot-2", "BBBBBBBBBBBB", 1.0);
+            second.renderer = None;
+            second.creative = None;
+            second.cache_id = first.cache_id.clone();
+            second.cache_host = Some("other-cache.example".to_string());
+            second.cache_path = Some("/another/path".to_string());
+
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result_with_winners(vec![first, second]),
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &ScriptedIdentityGenerator::new([]),
+            )
+            .expect("duplicate native cache ids should not collide as renderer reservations");
+
+            assert_eq!(canonical.projection.bids.len(), 2);
+            assert!(
+                canonical
+                    .projection
+                    .bids
+                    .iter()
+                    .all(|bid| bid.renderer_reservation_id.is_none())
+            );
+            let encoded = serde_json::to_value(&canonical.projection)
+                .expect("cache projection should serialize");
             assert_eq!(
-                validated_error_type(&metadata),
-                Some(*error_type),
-                "{error_type} should be a recognized classification"
+                encoded["bids"][0]["renderSource"]["cacheHost"],
+                "Cache.EXAMPLE:443"
+            );
+            assert_eq!(
+                encoded["bids"][0]["renderSource"]["cachePath"],
+                "/opaque//path%2Fsegment"
+            );
+
+            let direct: serde_json::Value = serde_json::from_slice(
+                &crate::auction::formats::coordinated_cutover_v1::serialize_trusted_server_auction_response_v1(
+                    &canonical,
+                )
+                .expect("direct wire should serialize"),
+            )
+            .expect("direct wire should be JSON");
+            let direct_bids = direct["seatbid"]
+                .as_array()
+                .expect("direct response should contain seats")
+                .iter()
+                .flat_map(|seat| {
+                    seat["bid"]
+                        .as_array()
+                        .expect("each direct seat should contain bids")
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(direct_bids.len(), 2);
+            assert!(direct_bids.iter().all(|bid| bid["id"] == "shared-cache-id"));
+        }
+
+        #[test]
+        fn invalid_targeting_is_rejected_without_truncation() {
+            let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+            bid.bidder = "x".repeat(41);
+            let result = result_with_winners(vec![bid]);
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &ScriptedIdentityGenerator::new([vec![5; 16]]),
+            )
+            .expect("invalid winner targeting should remain an explicit slot result");
+
+            assert!(canonical.projection.bids.is_empty());
+            assert_eq!(
+                canonical.projection.auction.results[0],
+                SlotAuctionDecisionV1::Failed {
+                    slot: "slot-1".to_string(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                }
             );
             assert!(
-                safe_error_message(error_type, None).is_some(),
-                "{error_type} should map to safe diagnostic wording"
+                !String::from_utf8(canonical.json)
+                    .expect("canonical projection should be UTF-8")
+                    .contains(&"x".repeat(40))
             );
         }
-    }
 
-    #[test]
-    fn metadata_keys_empty_yields_empty_safe_metadata_in_redacted() {
-        let options = AuctionDebugCommentOptions {
-            metadata_keys: vec![],
-            ..AuctionDebugCommentOptions::default()
-        };
-        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
-        assert!(
-            comment.contains("\"metadata\":{}"),
-            "empty metadata_keys should yield an empty metadata object: {comment}"
-        );
+        #[test]
+        fn blank_upstream_bid_id_fails_only_the_affected_winner() {
+            let mut bid = tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5);
+            bid.bid_id = Some(String::new());
+            let result = result_with_winners(vec![bid]);
+
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &ScriptedIdentityGenerator::new([]),
+            )
+            .expect("blank upstream identity should remain an explicit slot failure");
+
+            assert!(canonical.projection.bids.is_empty());
+            assert_eq!(
+                canonical.projection.auction.results[0],
+                SlotAuctionDecisionV1::Failed {
+                    slot: "slot-1".to_string(),
+                    reason: AuctionSlotFailureReason::WinnerNotRenderable,
+                }
+            );
+        }
+
+        #[test]
+        fn unavailable_reservation_randomness_is_identity_generation_failed() {
+            let result = result_with_winners(vec![tagged_adm_bid("slot-1", "AAAAAAAAAAAA", 1.5)]);
+            let canonical = coordinated_cutover_v1::build_browser_auction_projection_v1(
+                &result,
+                PriceGranularity::Dense,
+                &Settings::default(),
+                "https://publisher.example",
+                None,
+                &ScriptedIdentityGenerator::new([]),
+            )
+            .expect("CSPRNG failure should remain a per-slot decision");
+
+            assert!(canonical.projection.bids.is_empty());
+            assert_eq!(
+                canonical.projection.auction.results[0],
+                SlotAuctionDecisionV1::Failed {
+                    slot: "slot-1".to_string(),
+                    reason: AuctionSlotFailureReason::IdentityGenerationFailed,
+                }
+            );
+        }
     }
 
-    #[test]
-    fn metadata_keys_attack_vector_debug_key_never_surfaces_in_redacted_mode() {
-        // Configuring "debug" in metadata_keys must have zero effect in Redacted
-        // mode — the allowlist intersection is the actual security boundary, not
-        // the config value. This is the load-bearing test for this whole design.
-        let response = AuctionResponse::error("prebid", 12).with_metadata(
-            "debug",
-            serde_json::json!({"resolvedrequest": {"user": {"id": "EC-ID-abc123"}}}),
-        );
+    /// Build the ts-debug comment for a one-bid auction whose creative is
+    /// `creative`, so tests can assert on the rendered dump.
+    fn dump_comment_for_creative_with_options(
+        creative: &str,
+        options: &AuctionDebugCommentOptions,
+    ) -> String {
+        let mut bid = make_test_bid_with_creative(creative);
+        bid.slot_id = "ad-header-0".to_string();
         let result = OrchestrationResult {
-            provider_responses: vec![response],
+            provider_responses: vec![
+                AuctionResponse::no_bid("prebid", 665),
+                AuctionResponse::success("aps", vec![bid], 42),
+            ],
             mediator_response: None,
             winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 12,
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 665,
             metadata: std::collections::HashMap::new(),
         };
-        let options = AuctionDebugCommentOptions {
-            metadata_keys: vec!["debug".to_string()],
-            ..AuctionDebugCommentOptions::default()
-        };
         let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment("stream", &result, &state, &options);
+        prepend_auction_debug_comment("stream", &result, &state, options);
         let comment = state
             .script_cell()
             .lock()
             .expect("should lock state")
             .clone()
             .expect("should have comment");
-        assert!(
-            !comment.contains("EC-ID-abc123"),
-            "debug key must never surface in Redacted mode even if configured: {comment}"
-        );
-    }
-
-    #[test]
-    fn upstream_mode_includes_provider_diagnostics_but_not_debug_subtree() {
-        let metadata = std::collections::HashMap::from([
-            ("error_type".to_string(), serde_json::json!("timeout")),
-            (
-                "errors".to_string(),
-                serde_json::json!(["errors-example-user-123"]),
-            ),
-            (
-                "warnings".to_string(),
-                serde_json::json!(["warnings-example-user-123"]),
-            ),
-            (
-                "responsetimemillis".to_string(),
-                serde_json::json!({"example-bidder": 12}),
-            ),
-            (
-                "bidstatus".to_string(),
-                serde_json::json!([{"bidder": "example-bidder", "status": "timeout"}]),
-            ),
-            (
-                "upstream_message".to_string(),
-                serde_json::json!("upstream-example-user-123"),
-            ),
-            (
-                "upstream_message_truncated".to_string(),
-                serde_json::json!(true),
-            ),
-            (
-                "debug".to_string(),
-                serde_json::json!({"resolvedrequest": {"user": {"id": "debug-example-user-123"}}}),
-            ),
-        ]);
-        let options = AuctionDebugCommentOptions {
-            verbosity: AuctionDebugCommentVerbosity::Upstream,
-            metadata_keys: vec!["error_type".to_string()],
-            ..AuctionDebugCommentOptions::default()
-        };
-
-        let comment = dump_comment_for_metadata_with_options(metadata, &options);
-        let rendered = response_metadata_from_comment(&comment);
-
-        for key in [
-            "error_type",
-            "errors",
-            "warnings",
-            "responsetimemillis",
-            "bidstatus",
-            "upstream_message",
-            "upstream_message_truncated",
-        ] {
-            assert!(
-                rendered.get(key).is_some(),
-                "should include {key}: {comment}"
-            );
-        }
-        assert!(rendered.get("debug").is_none());
-        assert!(!comment.contains("debug-example-user-123"));
+        drop(state);
+        comment
     }
 
-    #[test]
-    fn verbosity_upstream_still_truncates_creative() {
-        let big_creative = "u".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 2);
-        let options = AuctionDebugCommentOptions {
-            verbosity: AuctionDebugCommentVerbosity::Upstream,
-            ..AuctionDebugCommentOptions::default()
-        };
-
-        let comment = dump_comment_for_creative_with_options(&big_creative, &options);
-
-        assert!(comment.contains("(truncated"));
-        assert!(!comment.contains(&big_creative));
+    fn dump_comment_for_creative(creative: &str) -> String {
+        dump_comment_for_creative_with_options(creative, &AuctionDebugCommentOptions::default())
     }
 
-    #[test]
-    fn verbosity_full_includes_raw_debug_subtree_when_present() {
-        let response = AuctionResponse::error("prebid", 12).with_metadata(
-            "debug",
-            serde_json::json!({"httpcalls": {"aps": [{"status": 200}]}}),
-        );
+    fn dump_comment_for_metadata_with_options(
+        metadata: std::collections::HashMap<String, serde_json::Value>,
+        options: &AuctionDebugCommentOptions,
+    ) -> String {
+        let mut response = AuctionResponse::error("prebid", 12);
+        response.metadata = metadata;
         let result = OrchestrationResult {
             provider_responses: vec![response],
             mediator_response: None,
             winning_bids: std::collections::HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
             total_time_ms: 12,
             metadata: std::collections::HashMap::new(),
         };
-        let options = AuctionDebugCommentOptions {
-            verbosity: AuctionDebugCommentVerbosity::Full,
-            ..AuctionDebugCommentOptions::default()
-        };
         let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment("stream", &result, &state, &options);
+        prepend_auction_debug_comment("stream", &result, &state, options);
         let comment = state
             .script_cell()
             .lock()
             .expect("should lock state")
             .clone()
             .expect("should have comment");
-        assert!(
-            comment.contains("httpcalls"),
-            "Full verbosity should surface the raw debug subtree: {comment}"
-        );
+        drop(state);
+        comment
     }
 
-    #[test]
-    fn verbosity_full_skips_creative_truncation() {
-        let big_creative = "y".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 2);
-        let options = AuctionDebugCommentOptions {
-            verbosity: AuctionDebugCommentVerbosity::Full,
-            ..AuctionDebugCommentOptions::default()
-        };
-        let comment = dump_comment_for_creative_with_options(&big_creative, &options);
-        assert!(
-            comment.contains(&big_creative),
-            "Full verbosity should not truncate the creative preview"
-        );
+    fn dump_from_comment(comment: &str) -> (&str, serde_json::Value) {
+        let (_, after_dump) = comment
+            .split_once("dump=")
+            .expect("should contain dump marker");
+        let (dump, _) = after_dump
+            .rsplit_once("\n-->")
+            .expect("should contain comment terminator");
+        let value: serde_json::Value =
+            serde_json::from_str(dump).expect("should contain valid untruncated JSON");
+        (dump, value)
+    }
+
+    fn response_metadata_from_comment(comment: &str) -> serde_json::Value {
+        let (_, dump) = dump_from_comment(comment);
+        dump["provider_responses"][0]["metadata"].clone()
     }
 
     #[test]
-    fn verbosity_full_still_hits_overall_byte_cap() {
-        let huge_creative = "z".repeat(MAX_AUCTION_DEBUG_DUMP_BYTES * 2);
-        for format in [
-            AuctionDebugCommentFormat::Compact,
-            AuctionDebugCommentFormat::Pretty,
-        ] {
-            let options = AuctionDebugCommentOptions {
-                verbosity: AuctionDebugCommentVerbosity::Full,
-                format,
-                ..AuctionDebugCommentOptions::default()
-            };
-            let comment = dump_comment_for_creative_with_options(&huge_creative, &options);
-            assert!(
-                comment.contains("(truncated"),
-                "even Full verbosity must respect the total dump byte cap for {format:?}: {}",
-                &comment[..comment.len().min(200)]
-            );
-        }
+    fn auction_debug_comment_dumps_provider_status() {
+        let comment = dump_comment_for_creative("<div>plain</div>");
+        // Compact (non-pretty) JSON: `"status":"nobid"` with no spaces.
+        assert!(
+            comment.contains("\"status\":\"nobid\""),
+            "should surface the no-bid provider status: {comment}"
+        );
+        assert!(
+            comment.contains("dump={\"provider_responses\":"),
+            "should dump the provider_responses payload: {comment}"
+        );
+        // No mediator ran, so it is omitted (mediator=none already says so).
+        assert!(
+            !comment.contains("mediator_response"),
+            "should omit mediator_response when no mediator ran: {comment}"
+        );
     }
 
     #[test]
-    fn include_provider_responses_false_omits_section_entirely() {
-        let options = AuctionDebugCommentOptions {
-            include_provider_responses: false,
-            ..AuctionDebugCommentOptions::default()
+    fn auction_debug_comment_projects_typed_drop_reasons() {
+        let response = AuctionResponse::no_bid("aps", 12)
+            .with_drop_reason(AuctionDropReason::DuplicateUpstreamBidId);
+        let result = OrchestrationResult {
+            provider_responses: vec![response],
+            mediator_response: None,
+            winning_bids: std::collections::HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 12,
+            metadata: std::collections::HashMap::new(),
         };
-        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
-        assert!(!comment.contains("provider_responses"));
+        let state = AdBidsState::with_script("BIDS_SCRIPT");
+
+        prepend_auction_debug_comment(
+            "stream",
+            &result,
+            &state,
+            &AuctionDebugCommentOptions::default(),
+        );
+
+        let comment = state
+            .script_cell()
+            .lock()
+            .expect("should lock state")
+            .clone()
+            .expect("should have comment");
+        assert!(
+            comment.contains("\"drop_reasons\":{\"duplicate_upstream_bid_id\":1}"),
+            "typed fixed reason/count metadata should remain visible: {comment}"
+        );
     }
 
     #[test]
-    fn include_mediator_response_false_omits_even_when_mediator_ran() {
-        let response = AuctionResponse::success("aps", vec![], 10);
-        let mediator = AuctionResponse::success("mediator", vec![], 5);
+    fn auction_debug_comment_never_leaks_provider_debug_metadata() {
+        // A provider response whose `debug` metadata mirrors the shape prebid
+        // stores verbatim when `[integration.prebid].debug` is on: the resolved
+        // OpenRTB request carrying the visitor's identity graph. The dump must
+        // drop it — only allowlisted keys may reach the DOM.
+        let response = AuctionResponse::error("prebid", 12)
+            .with_metadata(
+                "debug",
+                serde_json::json!({
+                    "resolvedrequest": {
+                        "user": {
+                            "id": "EC-ID-abc123",
+                            "consent": "CPtc-TCSTRING-xyz",
+                            "ext": { "eids": [{ "source": "example.com",
+                                                "uids": [{ "id": "EID-USER-999" }] }] }
+                        },
+                        "device": { "ip": "203.0.113.77",
+                                    "geo": { "lat": 37.7749, "lon": -122.4194 } }
+                    }
+                }),
+            )
+            // An allowlisted key must still survive.
+            .with_metadata("error_type", serde_json::json!("http_status"));
         let result = OrchestrationResult {
             provider_responses: vec![response],
-            mediator_response: Some(mediator),
+            mediator_response: None,
             winning_bids: std::collections::HashMap::new(),
-            total_time_ms: 10,
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 12,
             metadata: std::collections::HashMap::new(),
         };
-        let options = AuctionDebugCommentOptions {
-            include_mediator_response: false,
-            ..AuctionDebugCommentOptions::default()
-        };
         let state = AdBidsState::with_script("BIDS_SCRIPT");
-        prepend_auction_debug_comment("stream", &result, &state, &options);
+        prepend_auction_debug_comment(
+            "stream",
+            &result,
+            &state,
+            &AuctionDebugCommentOptions::default(),
+        );
         let comment = state
             .script_cell()
             .lock()
             .expect("should lock state")
             .clone()
             .expect("should have comment");
-        assert!(!comment.contains("mediator_response"));
+
+        for needle in [
+            "EC-ID-abc123",
+            "EID-USER-999",
+            "CPtc-TCSTRING-xyz",
+            "203.0.113.77",
+            "37.7749",
+            "resolvedrequest",
+        ] {
+            assert!(
+                !comment.contains(needle),
+                "identity/debug value {needle:?} must not reach the page HTML: {comment}"
+            );
+        }
+        assert!(
+            comment.contains("\"error_type\":\"http_status\""),
+            "allowlisted metadata must still surface: {comment}"
+        );
     }
 
     #[test]
-    fn include_bids_false_yields_empty_bids_array_not_omitted_response() {
+    fn default_options_apply_safe_response_metadata_schema() {
+        let metadata = std::collections::HashMap::from([
+            ("error_type".to_string(), serde_json::json!("http_status")),
+            ("http_status".to_string(), serde_json::json!(422)),
+            (
+                "message".to_string(),
+                serde_json::json!("raw-message-example-user-123"),
+            ),
+            (
+                "errors".to_string(),
+                serde_json::json!(["errors-example-user-123"]),
+            ),
+            (
+                "warnings".to_string(),
+                serde_json::json!(["warnings-example-user-123"]),
+            ),
+            (
+                "responsetimemillis".to_string(),
+                serde_json::json!({"timing-example-user-123": 12}),
+            ),
+            (
+                "bidstatus".to_string(),
+                serde_json::json!([{"bidder": "bidstatus-example-user-123"}]),
+            ),
+            (
+                "upstream_message".to_string(),
+                serde_json::json!("upstream-example-user-123"),
+            ),
+            (
+                "upstream_message_truncated".to_string(),
+                serde_json::json!("truncated-example-user-123"),
+            ),
+            (
+                "debug".to_string(),
+                serde_json::json!({"resolvedrequest": {"user": {"id": "debug-example-user-123"}}}),
+            ),
+        ]);
+
+        let comment = dump_comment_for_metadata_with_options(
+            metadata,
+            &AuctionDebugCommentOptions::default(),
+        );
+
+        assert_eq!(
+            response_metadata_from_comment(&comment),
+            serde_json::json!({
+                "error_type": "http_status",
+                "http_status": 422,
+                "message": "Provider returned HTTP 422",
+            })
+        );
+    }
+
+    #[test]
+    fn configured_metadata_subset_only_includes_selected_safe_keys() {
+        let metadata = std::collections::HashMap::from([
+            ("error_type".to_string(), serde_json::json!("http_status")),
+            ("http_status".to_string(), serde_json::json!(418)),
+            (
+                "errors".to_string(),
+                serde_json::json!(["errors-example-user-123"]),
+            ),
+            (
+                "debug".to_string(),
+                serde_json::json!({"identity": "debug-example-user-123"}),
+            ),
+        ]);
         let options = AuctionDebugCommentOptions {
-            include_bids: false,
+            metadata_keys: vec![
+                "http_status".to_string(),
+                "errors".to_string(),
+                "debug".to_string(),
+            ],
             ..AuctionDebugCommentOptions::default()
         };
-        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
-        assert!(comment.contains("\"bids\":[]"));
-        // The provider entry itself (status/provider name) must still be present.
-        assert!(comment.contains("\"provider\":\"aps\""));
-    }
 
-    #[test]
-    fn auction_debug_comment_truncates_oversized_creative() {
-        // A creative larger than the per-bid preview cap must be truncated with a
-        // marker rather than copied verbatim into the page.
-        let oversized = "x".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 4);
-        let comment = dump_comment_for_creative(&oversized);
-        assert!(
-            comment.contains("(truncated"),
-            "oversized creative should carry a truncation marker: {}",
-            &comment[..comment.len().min(200)]
-        );
-        assert!(
-            !comment.contains(&oversized),
-            "the full oversized creative must not appear in the comment"
+        let comment = dump_comment_for_metadata_with_options(metadata, &options);
+
+        assert_eq!(
+            response_metadata_from_comment(&comment),
+            serde_json::json!({"http_status": 418})
         );
     }
 
     #[test]
-    fn auction_debug_comment_neutralises_every_comment_terminator_vector() {
-        // Each vector reaches HTML5 comment-end state via a distinct tokenizer
-        // path. A single `replace("--", …)` would re-form a terminator on the
-        // odd-dash-run cases; the targeted two-replace must leave the comment's
-        // own trailing `-->` as the only surviving terminator and drop `--!>`.
-        for verbosity in [
-            AuctionDebugCommentVerbosity::Redacted,
-            AuctionDebugCommentVerbosity::Full,
-        ] {
-            for format in [
-                AuctionDebugCommentFormat::Compact,
-                AuctionDebugCommentFormat::Pretty,
-            ] {
-                let options = AuctionDebugCommentOptions {
-                    verbosity,
-                    format,
-                    ..AuctionDebugCommentOptions::default()
-                };
-                for creative in [
-                    "<div>evil-->break</div>",
-                    "--!><img src=x onerror=alert(1)>",
-                    "<!--><img src=x onerror=alert(1)>",
-                    "<!--!><img src=x onerror=alert(1)>",
-                    "----!><img src=x onerror=alert(1)>",
-                ] {
-                    let comment = dump_comment_for_creative_with_options(creative, &options);
-                    assert_eq!(
-                        comment.matches("-->").count(),
-                        1,
-                        "exactly one terminator must survive for {verbosity:?}, {format:?}, {creative:?}: {comment}"
-                    );
-                    assert!(
-                        !comment.contains("--!>"),
-                        "nested terminator must not survive for {verbosity:?}, {format:?}, {creative:?}: {comment}"
-                    );
-                }
-            }
+    fn redacted_mode_rejects_wrong_types_and_unknown_error_classifications() {
+        let invalid_cases = [
+            std::collections::HashMap::from([(
+                "error_type".to_string(),
+                serde_json::json!({"identity": "example-user-123"}),
+            )]),
+            std::collections::HashMap::from([
+                (
+                    "error_type".to_string(),
+                    serde_json::json!("provider_supplied_unknown"),
+                ),
+                ("message".to_string(), serde_json::json!("example-user-123")),
+            ]),
+            std::collections::HashMap::from([(
+                "http_status".to_string(),
+                serde_json::json!("200 example-user-123"),
+            )]),
+            std::collections::HashMap::from([("http_status".to_string(), serde_json::json!(99))]),
+            std::collections::HashMap::from([("http_status".to_string(), serde_json::json!(600))]),
+            std::collections::HashMap::from([(
+                "http_status".to_string(),
+                serde_json::json!(200.5),
+            )]),
+            std::collections::HashMap::from([(
+                "message".to_string(),
+                serde_json::json!({"identity": "example-user-123"}),
+            )]),
+        ];
+        for metadata in invalid_cases {
+            let comment = dump_comment_for_metadata_with_options(
+                metadata,
+                &AuctionDebugCommentOptions::default(),
+            );
+            assert_eq!(
+                response_metadata_from_comment(&comment),
+                serde_json::json!({})
+            );
+            assert!(!comment.contains("example-user-123"));
+            assert!(!comment.contains("provider_supplied_unknown"));
         }
-    }
 
-    struct ChunkedReader {
-        chunks: std::collections::VecDeque<Vec<u8>>,
-        read_count: Arc<AtomicUsize>,
+        for status in [100_u64, 599] {
+            let metadata = std::collections::HashMap::from([(
+                "http_status".to_string(),
+                serde_json::json!(status),
+            )]);
+            let comment = dump_comment_for_metadata_with_options(
+                metadata,
+                &AuctionDebugCommentOptions::default(),
+            );
+            assert_eq!(
+                response_metadata_from_comment(&comment),
+                serde_json::json!({"http_status": status})
+            );
+        }
     }
 
-    impl ChunkedReader {
-        fn new(chunks: &[&[u8]], read_count: Arc<AtomicUsize>) -> Self {
-            Self {
-                chunks: chunks.iter().map(|chunk| chunk.to_vec()).collect(),
-                read_count,
+    #[test]
+    fn redacted_mode_generates_fixed_safe_messages() {
+        let cases = [
+            (
+                "parse_response",
+                None,
+                "Provider response could not be parsed",
+            ),
+            ("launch_failed", None, "Provider launch failed"),
+            ("transport", None, "Provider request failed"),
+            ("timeout", None, "Provider request timed out"),
+            ("http_status", Some(418_u64), "Provider returned HTTP 418"),
+            ("http_status", None, "Provider returned an HTTP error"),
+        ];
+        for (error_type, status, expected) in cases {
+            let mut metadata = std::collections::HashMap::from([
+                ("error_type".to_string(), serde_json::json!(error_type)),
+                (
+                    "message".to_string(),
+                    serde_json::json!("raw-example-user-123"),
+                ),
+            ]);
+            if let Some(status) = status {
+                metadata.insert("http_status".to_string(), serde_json::json!(status));
             }
+            let comment = dump_comment_for_metadata_with_options(
+                metadata,
+                &AuctionDebugCommentOptions::default(),
+            );
+            let rendered = response_metadata_from_comment(&comment);
+            assert_eq!(rendered["message"], serde_json::json!(expected));
+            assert!(!comment.contains("raw-example-user-123"));
         }
     }
 
-    impl io::Read for ChunkedReader {
-        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-            let Some(chunk) = self.chunks.pop_front() else {
-                return Ok(0);
-            };
-            self.read_count.fetch_add(1, Ordering::SeqCst);
-            let len = chunk.len().min(buf.len());
-            buf[..len].copy_from_slice(&chunk[..len]);
-            Ok(len)
+    #[test]
+    fn redacted_metadata_covers_every_orchestrator_error_type() {
+        // Drift guard: adding a classification to ERROR_TYPE_ALL without wiring
+        // wording into safe_error_message would make it vanish from redacted
+        // dumps through the catch-all match arm.
+        for error_type in ERROR_TYPE_ALL {
+            let metadata = std::collections::HashMap::from([(
+                "error_type".to_string(),
+                serde_json::json!(error_type),
+            )]);
+            assert_eq!(
+                validated_error_type(&metadata),
+                Some(*error_type),
+                "{error_type} should be a recognized classification"
+            );
+            assert!(
+                safe_error_message(error_type, None).is_some(),
+                "{error_type} should map to safe diagnostic wording"
+            );
         }
     }
 
-    struct RecordingProcessor {
-        read_count: Arc<AtomicUsize>,
-        body_close_processed_at: Arc<AtomicUsize>,
-    }
-
-    impl StreamProcessor for RecordingProcessor {
-        fn process_chunk(&mut self, chunk: &[u8], _is_last: bool) -> Result<Vec<u8>, io::Error> {
-            if find_ascii_case_insensitive(chunk, BODY_CLOSE_PREFIX).is_some() {
-                self.body_close_processed_at
-                    .store(self.read_count.load(Ordering::SeqCst), Ordering::SeqCst);
-            }
-            Ok(chunk.to_vec())
-        }
+    #[test]
+    fn metadata_keys_empty_yields_empty_safe_metadata_in_redacted() {
+        let options = AuctionDebugCommentOptions {
+            metadata_keys: vec![],
+            ..AuctionDebugCommentOptions::default()
+        };
+        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
+        assert!(
+            comment.contains("\"metadata\":{}"),
+            "empty metadata_keys should yield an empty metadata object: {comment}"
+        );
     }
 
-    fn gzip_encode(input: &[u8]) -> Vec<u8> {
-        let mut encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
-        encoder
-            .write_all(input)
-            .expect("should write gzip test input");
-        encoder.finish().expect("should finish gzip encoding")
+    #[test]
+    fn metadata_keys_attack_vector_debug_key_never_surfaces_in_redacted_mode() {
+        // Configuring "debug" in metadata_keys must have zero effect in Redacted
+        // mode — the allowlist intersection is the actual security boundary, not
+        // the config value. This is the load-bearing test for this whole design.
+        let response = AuctionResponse::error("prebid", 12).with_metadata(
+            "debug",
+            serde_json::json!({"resolvedrequest": {"user": {"id": "EC-ID-abc123"}}}),
+        );
+        let result = OrchestrationResult {
+            provider_responses: vec![response],
+            mediator_response: None,
+            winning_bids: std::collections::HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 12,
+            metadata: std::collections::HashMap::new(),
+        };
+        let options = AuctionDebugCommentOptions {
+            metadata_keys: vec!["debug".to_string()],
+            ..AuctionDebugCommentOptions::default()
+        };
+        let state = AdBidsState::with_script("BIDS_SCRIPT");
+        prepend_auction_debug_comment("stream", &result, &state, &options);
+        let comment = state
+            .script_cell()
+            .lock()
+            .expect("should lock state")
+            .clone()
+            .expect("should have comment");
+        assert!(
+            !comment.contains("EC-ID-abc123"),
+            "debug key must never surface in Redacted mode even if configured: {comment}"
+        );
     }
 
-    fn gzip_decode(input: &[u8]) -> Vec<u8> {
-        let mut decoder = GzDecoder::new(input);
-        let mut output = Vec::new();
-        decoder
-            .read_to_end(&mut output)
-            .expect("should decode gzip test output");
-        output
-    }
+    #[test]
+    fn upstream_mode_includes_provider_diagnostics_but_not_debug_subtree() {
+        let metadata = std::collections::HashMap::from([
+            ("error_type".to_string(), serde_json::json!("timeout")),
+            (
+                "errors".to_string(),
+                serde_json::json!(["errors-example-user-123"]),
+            ),
+            (
+                "warnings".to_string(),
+                serde_json::json!(["warnings-example-user-123"]),
+            ),
+            (
+                "responsetimemillis".to_string(),
+                serde_json::json!({"example-bidder": 12}),
+            ),
+            (
+                "bidstatus".to_string(),
+                serde_json::json!([{"bidder": "example-bidder", "status": "timeout"}]),
+            ),
+            (
+                "upstream_message".to_string(),
+                serde_json::json!("upstream-example-user-123"),
+            ),
+            (
+                "upstream_message_truncated".to_string(),
+                serde_json::json!(true),
+            ),
+            (
+                "debug".to_string(),
+                serde_json::json!({"resolvedrequest": {"user": {"id": "debug-example-user-123"}}}),
+            ),
+        ]);
+        let options = AuctionDebugCommentOptions {
+            verbosity: AuctionDebugCommentVerbosity::Upstream,
+            metadata_keys: vec!["error_type".to_string()],
+            ..AuctionDebugCommentOptions::default()
+        };
 
-    fn deflate_encode(input: &[u8]) -> Vec<u8> {
-        let mut encoder =
-            flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
-        encoder
-            .write_all(input)
-            .expect("should write deflate test input");
-        encoder.finish().expect("should finish deflate encoding")
-    }
+        let comment = dump_comment_for_metadata_with_options(metadata, &options);
+        let rendered = response_metadata_from_comment(&comment);
 
-    fn deflate_decode(input: &[u8]) -> Vec<u8> {
-        let mut decoder = flate2::read::ZlibDecoder::new(input);
-        let mut output = Vec::new();
+        for key in [
+            "error_type",
+            "errors",
+            "warnings",
+            "responsetimemillis",
+            "bidstatus",
+            "upstream_message",
+            "upstream_message_truncated",
+        ] {
+            assert!(
+                rendered.get(key).is_some(),
+                "should include {key}: {comment}"
+            );
+        }
+        assert!(rendered.get("debug").is_none());
+        assert!(!comment.contains("debug-example-user-123"));
+    }
+
+    #[test]
+    fn verbosity_upstream_still_truncates_creative() {
+        let big_creative = "u".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 2);
+        let options = AuctionDebugCommentOptions {
+            verbosity: AuctionDebugCommentVerbosity::Upstream,
+            ..AuctionDebugCommentOptions::default()
+        };
+
+        let comment = dump_comment_for_creative_with_options(&big_creative, &options);
+
+        assert!(comment.contains("(truncated"));
+        assert!(!comment.contains(&big_creative));
+    }
+
+    #[test]
+    fn verbosity_full_includes_raw_debug_subtree_when_present() {
+        let response = AuctionResponse::error("prebid", 12).with_metadata(
+            "debug",
+            serde_json::json!({"httpcalls": {"aps": [{"status": 200}]}}),
+        );
+        let result = OrchestrationResult {
+            provider_responses: vec![response],
+            mediator_response: None,
+            winning_bids: std::collections::HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 12,
+            metadata: std::collections::HashMap::new(),
+        };
+        let options = AuctionDebugCommentOptions {
+            verbosity: AuctionDebugCommentVerbosity::Full,
+            ..AuctionDebugCommentOptions::default()
+        };
+        let state = AdBidsState::with_script("BIDS_SCRIPT");
+        prepend_auction_debug_comment("stream", &result, &state, &options);
+        let comment = state
+            .script_cell()
+            .lock()
+            .expect("should lock state")
+            .clone()
+            .expect("should have comment");
+        assert!(
+            comment.contains("httpcalls"),
+            "Full verbosity should surface the raw debug subtree: {comment}"
+        );
+    }
+
+    #[test]
+    fn verbosity_full_skips_creative_truncation() {
+        let big_creative = "y".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 2);
+        let options = AuctionDebugCommentOptions {
+            verbosity: AuctionDebugCommentVerbosity::Full,
+            ..AuctionDebugCommentOptions::default()
+        };
+        let comment = dump_comment_for_creative_with_options(&big_creative, &options);
+        assert!(
+            comment.contains(&big_creative),
+            "Full verbosity should not truncate the creative preview"
+        );
+    }
+
+    #[test]
+    fn verbosity_full_still_hits_overall_byte_cap() {
+        let huge_creative = "z".repeat(MAX_AUCTION_DEBUG_DUMP_BYTES * 2);
+        for format in [
+            AuctionDebugCommentFormat::Compact,
+            AuctionDebugCommentFormat::Pretty,
+        ] {
+            let options = AuctionDebugCommentOptions {
+                verbosity: AuctionDebugCommentVerbosity::Full,
+                format,
+                ..AuctionDebugCommentOptions::default()
+            };
+            let comment = dump_comment_for_creative_with_options(&huge_creative, &options);
+            assert!(
+                comment.contains("(truncated"),
+                "even Full verbosity must respect the total dump byte cap for {format:?}: {}",
+                &comment[..comment.len().min(200)]
+            );
+        }
+    }
+
+    #[test]
+    fn include_provider_responses_false_omits_section_entirely() {
+        let options = AuctionDebugCommentOptions {
+            include_provider_responses: false,
+            ..AuctionDebugCommentOptions::default()
+        };
+        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
+        assert!(!comment.contains("provider_responses"));
+    }
+
+    #[test]
+    fn include_mediator_response_false_omits_even_when_mediator_ran() {
+        let response = AuctionResponse::success("aps", vec![], 10);
+        let mediator = AuctionResponse::success("mediator", vec![], 5);
+        let result = OrchestrationResult {
+            provider_responses: vec![response],
+            mediator_response: Some(mediator),
+            winning_bids: std::collections::HashMap::new(),
+            decision_set: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "debug-auction".to_string(),
+                results: Vec::new(),
+            },
+            total_time_ms: 10,
+            metadata: std::collections::HashMap::new(),
+        };
+        let options = AuctionDebugCommentOptions {
+            include_mediator_response: false,
+            ..AuctionDebugCommentOptions::default()
+        };
+        let state = AdBidsState::with_script("BIDS_SCRIPT");
+        prepend_auction_debug_comment("stream", &result, &state, &options);
+        let comment = state
+            .script_cell()
+            .lock()
+            .expect("should lock state")
+            .clone()
+            .expect("should have comment");
+        assert!(!comment.contains("mediator_response"));
+    }
+
+    #[test]
+    fn include_bids_false_yields_empty_bids_array_not_omitted_response() {
+        let options = AuctionDebugCommentOptions {
+            include_bids: false,
+            ..AuctionDebugCommentOptions::default()
+        };
+        let comment = dump_comment_for_creative_with_options("<div>x</div>", &options);
+        assert!(comment.contains("\"bids\":[]"));
+        // The provider entry itself (status/provider name) must still be present.
+        assert!(comment.contains("\"provider\":\"aps\""));
+    }
+
+    #[test]
+    fn auction_debug_comment_truncates_oversized_creative() {
+        // A creative larger than the per-bid preview cap must be truncated with a
+        // marker rather than copied verbatim into the page.
+        let oversized = "x".repeat(MAX_BID_CREATIVE_DUMP_BYTES * 4);
+        let comment = dump_comment_for_creative(&oversized);
+        assert!(
+            comment.contains("(truncated"),
+            "oversized creative should carry a truncation marker: {}",
+            &comment[..comment.len().min(200)]
+        );
+        assert!(
+            !comment.contains(&oversized),
+            "the full oversized creative must not appear in the comment"
+        );
+    }
+
+    #[test]
+    fn auction_debug_comment_neutralises_every_comment_terminator_vector() {
+        // Each vector reaches HTML5 comment-end state via a distinct tokenizer
+        // path. A single `replace("--", …)` would re-form a terminator on the
+        // odd-dash-run cases; the targeted two-replace must leave the comment's
+        // own trailing `-->` as the only surviving terminator and drop `--!>`.
+        for verbosity in [
+            AuctionDebugCommentVerbosity::Redacted,
+            AuctionDebugCommentVerbosity::Full,
+        ] {
+            for format in [
+                AuctionDebugCommentFormat::Compact,
+                AuctionDebugCommentFormat::Pretty,
+            ] {
+                let options = AuctionDebugCommentOptions {
+                    verbosity,
+                    format,
+                    ..AuctionDebugCommentOptions::default()
+                };
+                for creative in [
+                    "<div>evil-->break</div>",
+                    "--!><img src=x onerror=alert(1)>",
+                    "<!--><img src=x onerror=alert(1)>",
+                    "<!--!><img src=x onerror=alert(1)>",
+                    "----!><img src=x onerror=alert(1)>",
+                ] {
+                    let comment = dump_comment_for_creative_with_options(creative, &options);
+                    assert_eq!(
+                        comment.matches("-->").count(),
+                        1,
+                        "exactly one terminator must survive for {verbosity:?}, {format:?}, {creative:?}: {comment}"
+                    );
+                    assert!(
+                        !comment.contains("--!>"),
+                        "nested terminator must not survive for {verbosity:?}, {format:?}, {creative:?}: {comment}"
+                    );
+                }
+            }
+        }
+    }
+
+    fn gzip_encode(input: &[u8]) -> Vec<u8> {
+        let mut encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder
+            .write_all(input)
+            .expect("should write gzip test input");
+        encoder.finish().expect("should finish gzip encoding")
+    }
+
+    fn gzip_decode(input: &[u8]) -> Vec<u8> {
+        let mut decoder = GzDecoder::new(input);
+        let mut output = Vec::new();
+        decoder
+            .read_to_end(&mut output)
+            .expect("should decode gzip test output");
+        output
+    }
+
+    fn deflate_encode(input: &[u8]) -> Vec<u8> {
+        let mut encoder =
+            flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder
+            .write_all(input)
+            .expect("should write deflate test input");
+        encoder.finish().expect("should finish deflate encoding")
+    }
+
+    fn deflate_decode(input: &[u8]) -> Vec<u8> {
+        let mut decoder = flate2::read::ZlibDecoder::new(input);
+        let mut output = Vec::new();
         decoder
             .read_to_end(&mut output)
             .expect("should decode deflate test output");
@@ -7556,9 +7217,45 @@ mod tests {
             price_granularity: Default::default(),
             gpt_diagnostics: None,
             suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
         }
     }
 
+    #[test]
+    fn c2_reader_seam_inserts_one_complete_hard_cutover_boot() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let projection = r#"{"version":1,"auction":{"version":1,"auctionId":"auction-c2-reader","results":[]},"slots":[],"bids":[]}"#;
+        let mut params = make_stream_params(&settings, "");
+        params.content_type = "text/html; charset=utf-8".to_string();
+        params.ad_bids_state = AdBidsState::with_script(projection);
+
+        let seam = seam_script_for(&params, &settings, &registry);
+        let boot = seam
+            .find("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+            .expect("should emit one immutable sealed boot transport");
+        let runtime = seam
+            .find("id=\"trustedserver-js\"")
+            .expect("should emit the selected parser-time runtime");
+
+        assert!(boot < runtime, "boot input must precede runtime execution");
+        assert_eq!(
+            seam.matches("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+                .count(),
+            1,
+            "reader seam must carry exactly one complete boot"
+        );
+        assert_eq!(
+            bootstrap_transport(&seam)["boot"]["auctionProjection"]["auction"]["auctionId"],
+            "auction-c2-reader"
+        );
+        assert!(seam.contains(r#"performance.mark("tsjs:bids-script")"#));
+        assert!(!seam.contains(AD_ASSEMBLY_SEAM));
+        assert!(!seam.contains(".adSlots"));
+        assert!(!seam.contains(".bids="));
+    }
+
     fn test_auction_request() -> AuctionRequest {
         AuctionRequest {
             id: "test-auction".to_string(),
@@ -7597,20 +7294,18 @@ mod tests {
     }
 
     #[test]
-    fn stream_publisher_body_injects_active_diagnostics_for_materialized_html() {
+    fn ts_console_stream_publisher_body_injects_active_diagnostics_for_materialized_html() {
         let mut settings = create_test_settings();
         settings
             .integrations
             .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
             .expect("should enable diagnostics");
-        let integration_registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
+        settings
+            .integrations
+            .insert_config("gpt", &serde_json::json!({}))
+            .expect("should enable the GPT event provider");
+        let integration_registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
         let mut request = HttpRequest::builder()
             .method(Method::GET)
             .uri("https://publisher.example/article?ts_console=1")
@@ -7636,13 +7331,16 @@ mod tests {
 
         let html = String::from_utf8(output).expect("should produce UTF-8 HTML");
         assert!(
-            html.contains("__tsjs_gpt_diagnostics_active"),
-            "should inject the activation flag"
+            !html.contains("__tsjs_gpt_diagnostics_active"),
+            "should not inject the removed activation flag"
         );
         assert!(
-            html.contains("tsjs-gpt_diagnostics.min.js"),
-            "should inject the standalone diagnostics module"
+            boot_gpt_diagnostics_active(&html),
+            "should activate diagnostics through immutable boot data"
         );
+        assert!(html.contains("tsjs-unified.min.js?v="));
+        assert!(!html.contains("tsjs-gpt_diagnostics.min.js"));
+        assert_eq!(html.matches("history.replaceState").count(), 1);
     }
 
     #[test]
@@ -7759,7 +7457,11 @@ mod tests {
         services: &RuntimeServices,
         req: Request<EdgeBody>,
     ) -> PublisherResponse {
-        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+        let plan = Arc::new(
+            crate::auction::compile_auction_plan(settings)
+                .expect("should compile the publisher test auction plan"),
+        );
+        let orchestrator = AuctionOrchestrator::from_plan(plan, None);
         let mut ec_context =
             EcContext::read_from_request(settings, &req, services).expect("should read EC context");
         handle_publisher_request(
@@ -7779,8852 +7481,4058 @@ mod tests {
         .expect("should proxy publisher request")
     }
 
-    mod rendered_template_identity_tests {
-        //! The gate the plan's Task 3 Step 2 actually asks for.
-        //!
-        //! Every other test in this area exercises the decision functions with
-        //! hand-built inputs. That is how three HIGH review findings sat in covered,
-        //! passing code: the decisions were right and nothing checked what the
-        //! composition of them *renders*.
-        //!
-        //! These tests render whole documents through `create_html_processor`,
-        //! composing the same three decisions `create_html_stream_processor` uses,
-        //! and compare bytes. A future request-dependent injection added at either
-        //! seam fails here even if every decision function is left untouched.
-
-        use super::template_neutrality_tests::{settings_with_slots, slot};
-        use super::*;
-        use crate::creative_opportunities::AssemblyMode;
-        use crate::html_processor::{HtmlProcessorConfig, create_html_processor};
-        use crate::integrations::IntegrationRegistry;
-        use crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision;
-
-        const DOCUMENT: &[u8] =
-            b"<html><head><title>t</title></head><body><p>content</p></body></html>";
-
-        /// One request's worth of variation. Everything here is request-scoped and
-        /// must not reach a shared template.
-        #[derive(Debug, Clone, Copy)]
-        struct RequestShape {
-            /// Folds in consent, bot classification, prefetch and the kill switch.
-            ad_stack_ran: bool,
-            /// Cookie- or query-activated.
-            diagnostics_active: bool,
-            /// A resolved auction, present only when one was dispatched.
-            bids_available: bool,
-        }
-
-        /// Build the config exactly as `create_html_stream_processor` does, so a
-        /// drift between a decision and its use is caught rather than hidden.
-        fn render(mode: AssemblyMode, shape: RequestShape) -> String {
-            let settings = settings_with_slots();
-            let slots = [slot()];
-
-            let ad_slots_script =
-                template_ad_slots_script(mode, shape.ad_stack_ran, &settings, &slots, "/");
-            let body_close = body_close_injection(mode, ad_slots_script.is_some());
-            let gpt_diagnostics = template_gpt_diagnostics(
-                mode,
-                shape
-                    .diagnostics_active
-                    .then(GptDiagnosticsRequestDecision::active_for_tests),
-            );
-
-            let ad_bids_state =
-                std::sync::Arc::new(std::sync::Mutex::new(shape.bids_available.then(|| {
-                    r#"<script>(window.tsjs=window.tsjs||{}).bids={"atf":1};</script>"#.to_string()
-                })));
-
-            let config = HtmlProcessorConfig {
-                csp_nonce_observed: None,
-                origin_host: "origin.example.com".to_string(),
-                request_host: "example.com".to_string(),
-                request_scheme: "https".to_string(),
-                integrations: IntegrationRegistry::empty_for_tests(),
-                ad_slots_script,
-                ad_bids_state,
-                max_buffered_body_bytes: 16 * 1024 * 1024,
-                gpt_diagnostics,
-                body_close,
-                suppress_datadome_client_side_tag: false,
-            };
-
-            let mut processor = create_html_processor(config);
-            let out = processor
-                .process_chunk(DOCUMENT, true)
-                .expect("should process the document");
-            String::from_utf8(out).expect("output should be utf8")
-        }
-
-        fn every_shape() -> Vec<RequestShape> {
-            let mut shapes = Vec::new();
-            for ad_stack_ran in [false, true] {
-                for diagnostics_active in [false, true] {
-                    for bids_available in [false, true] {
-                        shapes.push(RequestShape {
-                            ad_stack_ran,
-                            diagnostics_active,
-                            bids_available,
-                        });
-                    }
-                }
-            }
-            shapes
+    struct TsConsolePipelineResult {
+        response: Response<EdgeBody>,
+        origin_uri: String,
+        outbound_cookie: Option<String>,
+    }
+
+    async fn run_ts_console_pipeline(
+        method: Method,
+        destination: &str,
+        uri: &str,
+        cookie: Option<&str>,
+    ) -> TsConsolePipelineResult {
+        run_ts_console_pipeline_with_origin_policies(method, destination, uri, cookie, &[]).await
+    }
+
+    async fn run_ts_console_pipeline_with_origin_policies(
+        method: Method,
+        destination: &str,
+        uri: &str,
+        cookie: Option<&str>,
+        enforcing_policies: &[&str],
+    ) -> TsConsolePipelineResult {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
+            .expect("should enable diagnostics");
+        settings
+            .integrations
+            .insert_config("gpt", &serde_json::json!({}))
+            .expect("should enable the GPT event provider");
+        let stub = Arc::new(StubHttpClient::new());
+        let mut origin_headers = vec![(
+            "content-type".to_owned(),
+            "text/html; charset=utf-8".to_owned(),
+        )];
+        origin_headers.extend(
+            enforcing_policies
+                .iter()
+                .map(|policy| ("content-security-policy".to_owned(), (*policy).to_owned())),
+        );
+        stub.push_response_with_headers(
+            200,
+            b"<html><head><script>publisher()</script></head><body>origin</body></html>".to_vec(),
+            origin_headers,
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let mut request = Request::builder()
+            .method(method.clone())
+            .uri(uri)
+            .header(header::HOST, "publisher.example")
+            .header("sec-fetch-dest", destination);
+        if let Some(cookie) = cookie {
+            request = request.header(header::COOKIE, cookie);
         }
-
-        #[test]
-        fn shared_template_ad_seam_is_readable_and_versioned() {
-            assert_eq!(
-                (crate::platform::TEMPLATE_SCHEMA_VERSION, AD_ASSEMBLY_SEAM,),
-                (4, "<!--ts-ad-seam-->"),
-                "the readable seam and its cache schema must move together"
-            );
-            assert_eq!(
-                body_close_injection(AssemblyMode::Esi, false),
-                BodyCloseInjection::Marker(TEMPLATE_SEAM_PLACEHOLDER.to_string()),
-                "the seam's position must come from the parser, never from a byte search"
-            );
-            assert_ne!(
-                TEMPLATE_SEAM_PLACEHOLDER, AD_ASSEMBLY_SEAM,
-                "a publisher document carrying the seam bytes must still receive \
-                 correctly positioned bids, which a shared marker would make impossible"
-            );
+        let request = request
+            .body(EdgeBody::empty())
+            .expect("should build diagnostics pipeline request");
+        let publisher_response = run_publisher_proxy(&settings, &services, request).await;
+        let registry = IntegrationRegistry::new(&settings).expect("should build registry");
+        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+        let response = buffer_publisher_response_async(
+            publisher_response,
+            &method,
+            &settings,
+            &registry,
+            &orchestrator,
+            &services,
+        )
+        .await
+        .expect("should buffer diagnostics pipeline response");
+        let outbound_cookie = stub.recorded_request_headers().first().and_then(|headers| {
+            headers
+                .iter()
+                .find(|(name, _)| name.eq_ignore_ascii_case(header::COOKIE.as_str()))
+                .map(|(_, value)| value.clone())
+        });
+        TsConsolePipelineResult {
+            response,
+            origin_uri: stub
+                .recorded_request_uris()
+                .into_iter()
+                .next()
+                .expect("should forward one origin request"),
+            outbound_cookie,
         }
+    }
 
-        #[test]
-        fn shared_modes_render_byte_identical_documents_for_every_request_shape() {
-            let mode = AssemblyMode::Esi;
-            let shapes = every_shape();
-            let baseline = render(mode, shapes[0]);
-
-            for shape in &shapes[1..] {
-                let rendered = render(mode, *shape);
-                assert_eq!(
-                    rendered, baseline,
-                    "{mode:?}: rendered template differs for {shape:?}. A shared \
-                     template that varies by request freezes the first-filling \
-                     request's decision for every later reader."
-                );
-            }
-        }
+    #[tokio::test]
+    async fn response_csp_nonce_flows_through_the_real_publisher_html_pipeline() {
+        let nonce = "response-nonce_123=";
+        let result = run_ts_console_pipeline_with_origin_policies(
+            Method::GET,
+            "document",
+            "https://publisher.example/article?ts_console=1",
+            None,
+            &["default-src 'none'; script-src 'nonce-response-nonce_123='"],
+        )
+        .await;
+        let html = response_body_string(result.response);
 
-        #[test]
-        fn shared_mode_templates_contain_no_request_scoped_markers() {
-            // Byte-identity alone would be satisfied by rendering the same wrong
-            // thing every time, so also assert the specific things that must be
-            // absent.
-            let mode = AssemblyMode::Esi;
-            let rendered = render(
-                mode,
-                RequestShape {
-                    ad_stack_ran: true,
-                    diagnostics_active: true,
-                    bids_available: true,
-                },
-            );
-            for forbidden in [
-                ".adSlots",
-                ".bids=",
-                "__tsjs_gpt_diagnostics_active",
-                "history.replaceState",
-            ] {
-                assert!(
-                    !rendered.contains(forbidden),
-                    "{mode:?}: template contains request-scoped `{forbidden}`:\n{rendered}"
-                );
-            }
-        }
+        assert!(
+            html.contains(&format!(
+                r#"<script nonce="{nonce}">try{{history.replaceState"#
+            )),
+            "request-scoped diagnostics cleanup must carry the response nonce"
+        );
+        assert!(
+            html.contains(&format!(
+                r#"<script nonce="{nonce}">const __TSJS_SERVER_BOOT_TRANSPORT_V1__="#
+            )),
+            "the inline TSJS controller must carry the response nonce"
+        );
+        assert!(
+            html.contains(&format!(
+                r#"<script nonce="{nonce}" src="/static/tsjs=tsjs-first-display.min.js"#
+            )) || html.contains(&format!(
+                r#"<script nonce="{nonce}" src="/static/tsjs=tsjs-unified.min.js"#
+            )),
+            "the selected TSJS artifact must carry the response nonce"
+        );
+        assert!(
+            html.contains(&format!(
+                r#"<script nonce="{nonce}" src="/integrations/prebid/bundle.js"#
+            )),
+            "the live Prebid head insert must carry the response nonce"
+        );
+        assert_eq!(
+            html.matches(&format!(r#"nonce="{nonce}""#)).count(),
+            4,
+            "only the four Trusted Server executable tags should receive the nonce"
+        );
+    }
 
-        #[test]
-        fn inline_still_varies_by_request_as_it_must() {
-            // The shared-mode assertions would also pass if rendering were broken
-            // everywhere. Inline responses are per-navigation and never shared, so
-            // they *should* differ — this proves the test can tell the difference.
-            let with_ads = render(
-                AssemblyMode::Inline,
-                RequestShape {
-                    ad_stack_ran: true,
-                    diagnostics_active: false,
-                    bids_available: true,
-                },
-            );
-            let without = render(
-                AssemblyMode::Inline,
-                RequestShape {
-                    ad_stack_ran: false,
-                    diagnostics_active: false,
-                    bids_available: false,
-                },
-            );
-            assert_ne!(
-                with_ads, without,
-                "inline must still vary by request; if it does not, this harness is \
-                 not rendering what it claims to"
-            );
+    #[tokio::test]
+    async fn ambiguous_or_disjoint_response_csp_nonces_emit_no_nonce() {
+        for policies in [
+            vec!["script-src 'nonce-one' 'nonce-two'"],
+            vec!["script-src 'nonce-one'", "script-src 'nonce-two'"],
+        ] {
+            let result = run_ts_console_pipeline_with_origin_policies(
+                Method::GET,
+                "document",
+                "https://publisher.example/article?ts_console=1",
+                None,
+                &policies,
+            )
+            .await;
+            let html = response_body_string(result.response);
+            assert!(html.contains("const __TSJS_SERVER_BOOT_TRANSPORT_V1__="));
+            assert!(html.contains("history.replaceState"));
             assert!(
-                with_ads.contains(".adSlots"),
-                "inline with a matched slot should carry adSlots"
+                !html.contains(" nonce="),
+                "ambiguous/disjoint policies must not choose an arbitrary nonce: {policies:?}"
             );
         }
     }
 
-    mod template_fingerprint_tests {
-        use super::*;
+    #[test]
+    fn shared_template_authorization_requires_one_unchanged_edge_validated_value() {
+        let no_authorization = HttpRequest::builder()
+            .uri("https://publisher.example/article")
+            .body(EdgeBody::empty())
+            .expect("should build request without authorization");
+        assert!(!request_authorization_disqualifies(&no_authorization));
 
-        /// Base settings with one integration's config replaced.
-        ///
-        /// Edits the parsed `[integrations]` map rather than appending TOML, so the two
-        /// fixtures differ in exactly the field under test — the base settings already
-        /// declare `[integrations.prebid]`, and a second table would not parse.
-        fn settings_with_prebid(enabled: bool, timeout_ms: u32) -> Settings {
-            let mut settings = create_test_settings();
-            settings.integrations.insert(
-                "prebid".to_string(),
-                serde_json::json!({
-                    "enabled": enabled,
-                    "external_bundle_url": "https://assets.example.com/prebid/bundle.js",
-                    "timeout_ms": timeout_ms,
-                }),
-            );
-            settings
-        }
+        let pass_through = HttpRequest::builder()
+            .uri("https://publisher.example/article")
+            .header(header::AUTHORIZATION, "Basic dXNlcjpwYXNz")
+            .body(EdgeBody::empty())
+            .expect("should build pass-through authorization request");
+        assert!(request_authorization_disqualifies(&pass_through));
 
-        #[test]
-        fn disabling_an_integration_changes_the_fingerprint() {
-            // The fingerprint was `concatenated_hash(all_module_ids())` — every module
-            // compiled into the binary, so a constant for that binary. Turning an
-            // integration off changed the injected `<script>` set and left the cache key
-            // untouched, and every reader kept getting the template built while it was on.
-            assert_ne!(
-                template_fingerprint(&settings_with_prebid(true, 1000)),
-                template_fingerprint(&settings_with_prebid(false, 1000)),
-                "the enabled integration set must select a different template"
-            );
-        }
+        let mut edge_validated = HttpRequest::builder()
+            .uri("https://publisher.example/article")
+            .header(header::AUTHORIZATION, "Basic dXNlcjpwYXNz")
+            .body(EdgeBody::empty())
+            .expect("should build edge-validated authorization request");
+        edge_validated
+            .extensions_mut()
+            .insert(crate::auth::EdgeTerminatedAuthorization::for_test(
+                "Basic dXNlcjpwYXNz",
+            ));
+        assert!(!request_authorization_disqualifies(&edge_validated));
 
-        #[test]
-        fn reconfiguring_an_integration_changes_the_fingerprint() {
-            // Config reaches the template directly: the prebid head insert carries the
-            // account ID, timeout and bidder list into bytes shared between readers.
-            assert_ne!(
-                template_fingerprint(&settings_with_prebid(true, 1000)),
-                template_fingerprint(&settings_with_prebid(true, 2500)),
-                "an integration's configuration must select a different template"
-            );
-        }
+        edge_validated.headers_mut().insert(
+            header::AUTHORIZATION,
+            http::HeaderValue::from_static("Bearer publisher-origin-credential"),
+        );
+        assert!(request_authorization_disqualifies(&edge_validated));
 
-        #[test]
-        fn the_fingerprint_is_stable_across_calls_for_one_configuration() {
-            // `IntegrationSettings` derefs to a `HashMap`, whose iteration order varies.
-            // An unsorted digest would differ between two requests to the same binary and
-            // the cache would never hit — a fix that quietly disables the feature.
-            let settings = settings_with_prebid(true, 1000);
-            let first = template_fingerprint(&settings);
-
-            for _ in 0..16 {
-                assert_eq!(
-                    template_fingerprint(&settings),
-                    first,
-                    "the same configuration must always fingerprint identically"
-                );
-            }
-            // A second, independently parsed `Settings` builds a fresh `HashMap` with a
-            // different iteration order, which is what actually exercises the sort.
-            assert_eq!(
-                template_fingerprint(&settings_with_prebid(true, 1000)),
-                first,
-                "two equal configurations must fingerprint identically"
-            );
-        }
+        let mut repeated = HttpRequest::builder()
+            .uri("https://publisher.example/article")
+            .header(header::AUTHORIZATION, "Basic dXNlcjpwYXNz")
+            .body(EdgeBody::empty())
+            .expect("should build repeated authorization request");
+        repeated.headers_mut().append(
+            header::AUTHORIZATION,
+            http::HeaderValue::from_static("Bearer publisher-origin-credential"),
+        );
+        repeated
+            .extensions_mut()
+            .insert(crate::auth::EdgeTerminatedAuthorization::for_test(
+                "Basic dXNlcjpwYXNz",
+            ));
+        assert!(request_authorization_disqualifies(&repeated));
+    }
 
-        #[test]
-        fn creative_and_origin_configuration_change_the_fingerprint() {
-            let base = super::template_neutrality_tests::settings_with_slots();
+    mod c2_gate_tests {
+        //! `cache::core` stores whatever it is handed and rejects nothing, so every
+        //! one of these conditions is the caller's to enforce. Each is a leak vector
+        //! or an eligibility rule, not a preference.
 
-            let mut creative = base.clone();
-            creative
-                .creative_opportunities
-                .as_mut()
-                .expect("fixture should configure creative opportunities")
-                .gam_network_id = "different-network".to_string();
-            assert_ne!(template_fingerprint(&base), template_fingerprint(&creative));
+        use super::*;
+        use crate::creative_opportunities::AssemblyMode;
+        use edgezero_core::http::HeaderName;
 
-            let mut origin = base.clone();
-            origin.publisher.origin_host_header_override = Some("tenant.example.com".to_string());
-            assert_ne!(template_fingerprint(&base), template_fingerprint(&origin));
+        fn headers(pairs: &[(HeaderName, &str)]) -> edgezero_core::http::HeaderMap {
+            let mut map = edgezero_core::http::HeaderMap::new();
+            for (name, value) in pairs {
+                map.insert(
+                    name.clone(),
+                    HeaderValue::from_str(value).expect("should build header value"),
+                );
+            }
+            map
         }
-    }
 
-    mod seam_script_tests {
-        use super::*;
+        fn shareable() -> edgezero_core::http::HeaderMap {
+            headers(&[(header::CACHE_CONTROL, "max-age=60")])
+        }
 
-        fn seam() -> String {
-            build_seam_script(
-                r#"[{"id":"atf","div_id":"atf"}]"#,
-                &serde_json::Map::from_iter([(
-                    "atf".to_string(),
-                    serde_json::json!({"hb_pb": "1.50"}),
-                )]),
-            )
+        /// The shipped default: no operator has stated what the origin varies on, so the
+        /// key covers nothing. Responses without a `Vary` are unaffected; any `Vary` at
+        /// all disqualifies.
+        fn nothing_covered() -> VarySpec {
+            VarySpec::new([])
         }
 
         #[test]
-        fn no_slot_assignment_precedes_the_navigation_generation_guard() {
-            // `scheduleInitialAdInit` drops the whole SSR payload once a navigation has
-            // committed. The seam used to assign `t.adSlots` on the line *before* calling
-            // it, which is outside that guard — so a committed SPA navigation kept its own
-            // bids and silently lost its slots to the stale SSR document's.
-            let script = seam();
-            let guard = script
-                .find("t.scheduleInitialAdInit")
-                .expect("the seam should consult the scheduler");
+        fn an_unconfigured_deployment_never_caches_a_varying_response() {
+            // The fail-closed default. An operator who has not stated the origin's Vary
+            // must not acquire a shared cache by omission — and a real origin varies on
+            // something, so this is the common path, not an edge case.
+            // Deliberately not `Accept-Encoding`: the shared path normalizes supported
+            // content codings to one identity template, so that header is covered
+            // whatever the operator configured. Using it here would test the
+            // structural-coverage carve-out rather than the drift guard.
+            let mut varying = shareable();
+            varying.insert(header::VARY, HeaderValue::from_static("rsc"));
 
-            assert!(
-                !script[..guard].contains("t.adSlots="),
-                "no slot assignment may run ahead of the navigation-generation guard: \
-                 {script}"
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::VaryNotCovered(VaryGap(vec![
+                    "rsc".to_string()
+                ]))),
+                "an unstated Vary must disqualify rather than silently under-key"
             );
         }
 
         #[test]
-        fn the_slots_are_handed_to_the_scheduler_so_the_guard_can_apply_them() {
-            // Removing the unguarded assignment is only half the fix: the slots still have
-            // to arrive, or a shared-mode page defines no slots at all.
-            let script = seam();
+        fn an_origin_that_varies_on_cookie_is_refused_even_when_declared_independent() {
+            // The backstop that makes `origin_is_cookie_independent` safe to offer. The
+            // operator asserts their origin ignores cookies; if the origin then says
+            // otherwise, the assertion loses. Without this, a wrong assertion would
+            // silently cross-serve personalized HTML.
+            let mut varying = shareable();
+            varying.insert(header::VARY, HeaderValue::from_static("Cookie"));
 
-            assert!(
-                script.contains("s(b,a)"),
-                "the scheduler should receive bids and slots together: {script}"
-            );
-            assert!(
-                script.contains("atf"),
-                "the slot definitions should reach the page: {script}"
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    // The operator's assertion has already been applied here: this is
+                    // `false` precisely because they declared independence.
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &VarySpec::new(["cookie".to_string()]),
+                ),
+                Some(C2BypassReason::VaryCookie),
+                "the origin's declaration must override both cookie independence and an \
+                 accidentally configured per-cookie key"
             );
         }
 
         #[test]
-        fn a_page_with_no_scheduler_still_gets_its_slots() {
-            // The GPT integration active without its head bootstrap. There is no SPA hook
-            // to race with there, so the direct assignment is the correct fallback — and
-            // dropping it while moving the assignment would have served no ads at all.
-            let script = seam();
-            let fallback = script
-                .find("else")
-                .expect("the seam should carry a no-scheduler fallback");
-
-            assert!(
-                script[fallback..].contains("t.adSlots=a"),
-                "the fallback should still assign slots: {script}"
+        fn a_private_directive_on_a_second_cache_control_line_is_refused() {
+            // `HeaderMap::get` returns the first value only. An origin that sends
+            // `Cache-Control: public, max-age=300` and then `Cache-Control: private` on a
+            // separate line means exactly what one comma-joined line would mean, but the
+            // second line was invisible — so a response the origin marked private was
+            // written to a cache shared between readers. The `Vary` reads a few lines up
+            // already use `get_all` for the same reason.
+            let mut split = edgezero_core::http::HeaderMap::new();
+            split.append(
+                header::CACHE_CONTROL,
+                HeaderValue::from_static("public, max-age=300"),
             );
-            assert!(
-                script[fallback..].contains("t.bids=b"),
-                "the fallback should still assign bids: {script}"
+            split.append(header::CACHE_CONTROL, HeaderValue::from_static("private"));
+
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &split,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::OriginNotShareable),
+                "a directive on any Cache-Control line must disqualify the response"
             );
         }
-    }
-
-    mod page_bids_format_tests {
-        //! Page-bids is a JSON API. The old executable fragment was part of the removed
-        //! parser-based spike and must not remain as an accidental public surface.
-
-        use super::*;
 
         #[test]
-        fn an_unknown_format_response_is_not_storable() {
-            // Every response from this endpoint is per-user. An error is no exception:
-            // a cached 400 would be replayed to clients asking correctly.
-            let response = page_bids_unknown_format();
-            assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-            assert_eq!(
-                response
-                    .headers()
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|v| v.to_str().ok()),
-                Some("private, no-store")
+        fn a_no_store_directive_on_a_second_cache_control_line_is_refused() {
+            // Same defect, the other directive that matters — `no-store` is the one an
+            // origin uses for a response that must not be written down anywhere.
+            let mut split = edgezero_core::http::HeaderMap::new();
+            split.append(
+                header::CACHE_CONTROL,
+                HeaderValue::from_static("max-age=60"),
             );
-            assert!(
-                response
-                    .extensions()
-                    .get::<crate::response_privacy::TerminalPrivateResponse>()
-                    .is_some(),
-                "page-bids errors should remain terminal-private after late response effects"
+            split.append(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &split,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::OriginNotShareable)
             );
         }
 
         #[test]
-        fn a_preflight_denial_is_terminal_private() {
-            let response = page_bids_preflight_denied();
+        fn cdn_specific_cache_policy_cannot_be_overridden_by_public_cache_control() {
+            for name in crate::response_privacy::CDN_CACHE_HEADERS {
+                let mut split = shareable();
+                split.insert(
+                    header::HeaderName::from_static(name),
+                    HeaderValue::from_static("no-store"),
+                );
 
-            assert!(
-                response
-                    .extensions()
-                    .get::<crate::response_privacy::TerminalPrivateResponse>()
-                    .is_some(),
-                "page-bids preflight denial should remain private after late response effects"
-            );
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &split,
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::OriginNotShareable),
+                    "C2 must fail closed on the CDN-specific policy header {name}"
+                );
+            }
         }
-    }
-
-    mod template_cache_store_authorization_tests {
-        //! The store is authorized by the key's presence and nothing else. These cover
-        //! the two ways that could silently break: storing without authorization, and
-        //! storing twice for one request.
-
-        use super::*;
 
-        /// Records what was stored, so the assertions are about behaviour rather than
-        /// about a call not returning an error.
-        #[derive(Default)]
-        struct RecordingCache {
-            stored: Arc<Mutex<Vec<(String, usize)>>>,
-        }
+        #[test]
+        fn unsupported_vendor_freshness_does_not_authorize_c2() {
+            for name in crate::response_privacy::CDN_CACHE_HEADERS
+                .iter()
+                .filter(|name| **name != "surrogate-control")
+            {
+                let mut split = shareable();
+                split.insert(
+                    header::HeaderName::from_static(name),
+                    HeaderValue::from_static("max-age=60"),
+                );
 
-        struct RecordingReservation {
-            stored: Arc<Mutex<Vec<(String, usize)>>>,
-            url: String,
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &split,
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::OriginNotShareable),
+                    "the Fastly exception must not authorize the vendor policy {name}"
+                );
+            }
         }
 
-        impl crate::platform::PlatformTemplateCacheReservation for RecordingReservation {
-            fn insert(
-                self: Box<Self>,
-                _metadata: &crate::platform::TemplateMetadata,
-                body: Vec<u8>,
-                _max_age: Duration,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                self.stored
-                    .lock()
-                    .expect("should lock recorded stores")
-                    .push((self.url, body.len()));
-                Ok(())
-            }
+        #[test]
+        fn observed_fastly_surrogate_policy_uses_edge_freshness_capped_by_configuration() {
+            let publisher_headers = headers(&[
+                (header::CACHE_CONTROL, "public, max-age=60"),
+                (
+                    header::HeaderName::from_static("surrogate-control"),
+                    "max-age=1200, stale-while-revalidate=21600, stale-if-error=604800",
+                ),
+            ]);
 
-            fn cancel(self: Box<Self>) -> Result<(), crate::platform::TemplateCacheError> {
-                Ok(())
-            }
+            assert_eq!(
+                c2_cache_ttl(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &publisher_headers,
+                    &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(300),),
+                ),
+                Ok(Duration::from_secs(300)),
+                "Fastly's edge freshness should take precedence over the shorter browser \
+                 lifetime, while the configured safety ceiling remains authoritative"
+            );
         }
 
-        #[async_trait::async_trait(?Send)]
-        impl crate::platform::PlatformTemplateCache for RecordingCache {
-            async fn get(
-                &self,
-                _key: &crate::platform::TemplateCacheKey,
-            ) -> Result<crate::platform::TemplateEntry, crate::platform::TemplateCacheMiss>
-            {
-                Err(crate::platform::TemplateCacheMiss::NotFound)
-            }
+        #[test]
+        fn fastly_surrogate_freshness_takes_precedence_over_standard_freshness() {
+            for (cache_control, surrogate_control, expected) in [
+                ("public, max-age=300", "max-age=30", 30),
+                ("public, max-age=30", "max-age=300", 300),
+            ] {
+                let publisher_headers = headers(&[
+                    (header::CACHE_CONTROL, cache_control),
+                    (
+                        header::HeaderName::from_static("surrogate-control"),
+                        surrogate_control,
+                    ),
+                ]);
 
-            async fn put(
-                &self,
-                key: &crate::platform::TemplateCacheKey,
-                _metadata: &crate::platform::TemplateMetadata,
-                body: Vec<u8>,
-                _max_age: Duration,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                self.stored
-                    .lock()
-                    .expect("should lock recorded stores")
-                    .push((key.url.clone(), body.len()));
-                Ok(())
+                assert_eq!(
+                    c2_cache_ttl(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &publisher_headers,
+                        &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(600),),
+                    ),
+                    Ok(Duration::from_secs(expected))
+                );
             }
+        }
 
-            async fn purge_url(
-                &self,
-                _key: &crate::platform::TemplateCacheKey,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                Ok(())
-            }
+        #[test]
+        fn surrogate_stale_windows_do_not_extend_fresh_reuse() {
+            let publisher_headers = headers(&[
+                (header::CACHE_CONTROL, "public, max-age=300"),
+                (
+                    header::HeaderName::from_static("surrogate-control"),
+                    "max-age=20, stale-while-revalidate=600, stale-if-error=1200",
+                ),
+                (header::AGE, "10"),
+            ]);
 
-            async fn purge_all(&self) -> Result<(), crate::platform::TemplateCacheError> {
-                Ok(())
-            }
+            assert_eq!(
+                c2_cache_ttl(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &publisher_headers,
+                    &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(600),),
+                ),
+                Ok(Duration::from_secs(10)),
+                "stale windows are validated metadata, not fresh C2 lifetime"
+            );
         }
 
-        impl RecordingCache {
-            fn recorded(&self) -> Vec<(String, usize)> {
-                self.stored
-                    .lock()
-                    .expect("should lock recorded stores")
-                    .clone()
-            }
-        }
+        #[test]
+        fn ambiguous_or_unsupported_surrogate_policy_fails_closed() {
+            for (policy, expected) in [
+                ("max-age", C2BypassReason::MalformedCachePolicy),
+                (
+                    "max-age=30, max-age=60",
+                    C2BypassReason::MalformedCachePolicy,
+                ),
+                ("max-age=tomorrow", C2BypassReason::MalformedCachePolicy),
+                ("max-age=30, public", C2BypassReason::MalformedCachePolicy),
+                ("stale-if-error=60", C2BypassReason::NoPositiveFreshness),
+                ("max-age=0", C2BypassReason::NoPositiveFreshness),
+                ("max-age=30,", C2BypassReason::MalformedCachePolicy),
+            ] {
+                let mut publisher_headers = shareable();
+                publisher_headers.insert(
+                    header::HeaderName::from_static("surrogate-control"),
+                    HeaderValue::from_str(policy).expect("should build Surrogate-Control"),
+                );
 
-        fn key() -> crate::platform::TemplateCacheKey {
-            crate::platform::TemplateCacheKey {
-                url: "https://example.com/page".to_string(),
-                request_host: "example.com".to_string(),
-                request_scheme: "https".to_string(),
-                origin_identity: "https://origin.example.com\0origin.example.com".to_string(),
-                assembly_mode: AssemblyMode::Esi,
-                vary_values: vec![],
-                template_fingerprint: "fp".to_string(),
-                schema_version: crate::platform::TEMPLATE_SCHEMA_VERSION,
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &publisher_headers,
+                        &nothing_covered(),
+                    ),
+                    Some(expected),
+                    "`{policy}` must fail closed"
+                );
             }
         }
 
-        fn authorization(cache: &RecordingCache) -> AuthorizedTemplateStore {
-            AuthorizedTemplateStore {
-                reservation: crate::platform::TemplateCacheReservation::new(Box::new(
-                    RecordingReservation {
-                        stored: Arc::clone(&cache.stored),
-                        url: key().url,
-                    },
-                )),
-                expires_at: Instant::now() + Duration::from_secs(30),
+        #[test]
+        fn restrictive_surrogate_policy_is_never_overridden_by_standard_freshness() {
+            for directive in ["private", "no-store", "no-cache"] {
+                let mut publisher_headers = shareable();
+                publisher_headers.insert(
+                    header::HeaderName::from_static("surrogate-control"),
+                    HeaderValue::from_str(directive).expect("should build Surrogate-Control"),
+                );
+
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &publisher_headers,
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::OriginNotShareable),
+                    "`{directive}` must remain authoritative"
+                );
             }
         }
 
-        #[tokio::test]
-        async fn an_unauthorized_response_stores_nothing() {
-            // `None` is what the gate leaves behind on every bypass, and it is also the
-            // default for Inline. If this ever stored, every bypass reason would be
-            // decorative.
-            let cache = Arc::new(RecordingCache::default());
-            let settings = create_test_settings();
-            let mut params = make_stream_params(&settings, "identity");
-            params.template_cache_key = None;
-
-            let _ = store_template_if_authorized(&mut params, b"body").await;
+        #[test]
+        fn restrictive_standard_policy_is_never_overridden_by_surrogate_freshness() {
+            for directive in ["private", "no-store", "no-cache"] {
+                let publisher_headers = headers(&[
+                    (
+                        header::CACHE_CONTROL,
+                        &format!("public, max-age=60, {directive}"),
+                    ),
+                    (
+                        header::HeaderName::from_static("surrogate-control"),
+                        "max-age=1200",
+                    ),
+                ]);
 
-            assert!(
-                cache.recorded().is_empty(),
-                "a response the gate rejected must not reach the cache"
-            );
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &publisher_headers,
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::OriginNotShareable),
+                    "standard `{directive}` must refuse C2 even with positive edge freshness"
+                );
+            }
         }
 
-        #[tokio::test]
-        async fn an_authorized_response_stores_the_transformed_bytes() {
-            let cache = Arc::new(RecordingCache::default());
-            let settings = create_test_settings();
-            let mut params = make_stream_params(&settings, "identity");
-            params.template_cache_key = Some(authorization(&cache));
-
-            let _ = store_template_if_authorized(&mut params, b"<html>transformed</html>").await;
+        #[test]
+        fn surrogate_control_can_authorize_fastly_edge_freshness_without_browser_freshness() {
+            let publisher_headers = headers(&[(
+                header::HeaderName::from_static("surrogate-control"),
+                "max-age=1200",
+            )]);
 
             assert_eq!(
-                cache.recorded(),
-                vec![("https://example.com/page".to_string(), 24)],
-                "the authorized response should store its transformed bytes"
+                c2_cache_ttl(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &publisher_headers,
+                    &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(300),),
+                ),
+                Ok(Duration::from_secs(300)),
+                "Fastly edge freshness should not require browser freshness"
             );
         }
 
-        #[tokio::test]
-        async fn authorization_is_consumed_so_one_request_stores_once() {
-            // The finalizers are layered, and a future change could plausibly call this
-            // from both. Taking the key makes a double store impossible rather than
-            // merely unlikely.
-            let cache = Arc::new(RecordingCache::default());
-            let settings = create_test_settings();
-            let mut params = make_stream_params(&settings, "identity");
-            params.template_cache_key = Some(authorization(&cache));
-            let _ = store_template_if_authorized(&mut params, b"first").await;
-            let _ = store_template_if_authorized(&mut params, b"second").await;
+        #[test]
+        fn repeated_cache_control_lines_without_a_disqualifier_still_cache() {
+            // The other direction: reading every value must not turn an ordinary
+            // multi-line `Cache-Control` into a bypass, or the fix would disable the
+            // cache instead of tightening it.
+            let mut split = edgezero_core::http::HeaderMap::new();
+            split.append(header::CACHE_CONTROL, HeaderValue::from_static("public"));
+            split.append(
+                header::CACHE_CONTROL,
+                HeaderValue::from_static("max-age=60"),
+            );
 
             assert_eq!(
-                cache.recorded().len(),
-                1,
-                "authorization must be single-use"
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &split,
+                    &nothing_covered(),
+                ),
+                None
             );
         }
 
-        #[tokio::test]
-        async fn origin_freshness_keeps_ticking_while_the_template_is_built() {
-            let cache = Arc::new(RecordingCache::default());
-            let settings = create_test_settings();
-            let mut params = make_stream_params(&settings, "identity");
-            let mut expired = authorization(&cache);
-            expired.expires_at = Instant::now();
-            params.template_cache_key = Some(expired);
-
-            let outcome = store_template_if_authorized(&mut params, b"body").await;
-
-            assert_eq!(outcome, Some(TemplateStoreOutcome::Expired));
-            assert!(
-                cache.recorded().is_empty(),
-                "template cache must not invent a new TTL after origin freshness elapsed"
+        #[test]
+        fn origin_freshness_is_positive_age_adjusted_and_capped() {
+            let fresh_headers = headers(&[(header::CACHE_CONTROL, "public, max-age=300")]);
+            assert_eq!(
+                c2_cache_ttl(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &fresh_headers,
+                    &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(60),),
+                ),
+                Ok(Duration::from_secs(60))
             );
-        }
-    }
-
-    mod template_cache_end_to_end_tests {
-        //! The chain, end to end: a second request for the same URL must be served from
-        //! the cache without touching the origin. Everything else in this file tests a
-        //! link; this tests that they connect.
 
-        use super::*;
-        use crate::platform::ClientInfo;
-        use crate::platform::test_support::{
-            NoopConfigStore, NoopGeo, NoopSecretStore, StubBackend, StubHttpClient,
-        };
-        use crate::test_support::tests::crate_test_settings_str;
-        use std::collections::HashMap;
-        use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+            let aged = headers(&[
+                (header::CACHE_CONTROL, "s-maxage=50, max-age=300"),
+                (header::AGE, "35"),
+            ]);
+            assert_eq!(
+                c2_cache_ttl(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &aged,
+                    &C2CachePolicy::for_test(&nothing_covered(), Duration::from_secs(60),),
+                ),
+                Ok(Duration::from_secs(15))
+            );
 
-        /// A working cache, unlike the recorder above — this one has to actually return
-        /// what it stored, or a hit proves nothing.
-        #[derive(Default)]
-        struct MemoryTemplateCache {
-            entries: Arc<Mutex<HashMap<String, crate::platform::TemplateEntry>>>,
-            /// Set only after a reservation has committed its reader-neutral bytes.
-            insert_completed: Arc<AtomicBool>,
-            /// Every key `get` was called with, so a test can assert what was *asked
-            /// for* rather than only what came back. A lookup that names a schema
-            /// version this binary cannot assemble is the bug; whether the entry
-            /// happened to survive the later marker check is not the same question.
-            lookups: Arc<Mutex<Vec<crate::platform::TemplateCacheKey>>>,
-            /// Every key `put` was called with, so a test can re-key an entry exactly
-            /// instead of reconstructing what the request derived.
-            stored_keys: Arc<Mutex<Vec<crate::platform::TemplateCacheKey>>>,
-            /// Per-entry freshness handed from publisher policy to the platform cache.
-            stored_max_ages: Arc<Mutex<Vec<Duration>>>,
-            /// Force the lookup transaction to fail, for the fail-open + telemetry
-            /// contract. A backend outage must never become a publisher outage.
-            fail_lookup: AtomicBool,
+            let old_date_without_age = headers(&[
+                (header::CACHE_CONTROL, "public, max-age=60"),
+                (header::DATE, "Wed, 12 Aug 2026 08:00:00 GMT"),
+            ]);
+            let one_minute_later = httpdate::parse_http_date("Wed, 12 Aug 2026 08:01:00 GMT")
+                .expect("should parse fixture time");
+            assert_eq!(
+                origin_shared_ttl_at(
+                    &old_date_without_age,
+                    one_minute_later,
+                    Duration::from_secs(60),
+                ),
+                Err(C2BypassReason::NoPositiveFreshness),
+                "an old Date is apparent age even when an upstream omitted Age"
+            );
         }
 
-        struct MemoryTemplateReservation {
-            entries: Arc<Mutex<HashMap<String, crate::platform::TemplateEntry>>>,
-            insert_completed: Arc<AtomicBool>,
-            stored_keys: Arc<Mutex<Vec<crate::platform::TemplateCacheKey>>>,
-            stored_max_ages: Arc<Mutex<Vec<Duration>>>,
-            key: crate::platform::TemplateCacheKey,
+        #[test]
+        fn zero_exhausted_missing_and_malformed_freshness_are_refused() {
+            for (map, expected) in [
+                (
+                    headers(&[(header::CACHE_CONTROL, "max-age=0")]),
+                    C2BypassReason::NoPositiveFreshness,
+                ),
+                (
+                    headers(&[(header::CACHE_CONTROL, "max-age=60"), (header::AGE, "60")]),
+                    C2BypassReason::NoPositiveFreshness,
+                ),
+                (
+                    headers(&[(header::CACHE_CONTROL, "public")]),
+                    C2BypassReason::NoPositiveFreshness,
+                ),
+                (
+                    headers(&[(header::CACHE_CONTROL, "max-age=tomorrow")]),
+                    C2BypassReason::MalformedCachePolicy,
+                ),
+                (
+                    headers(&[(header::CACHE_CONTROL, "max-age=\"60")]),
+                    C2BypassReason::MalformedCachePolicy,
+                ),
+                (
+                    headers(&[(header::CACHE_CONTROL, "max-age=+60")]),
+                    C2BypassReason::MalformedCachePolicy,
+                ),
+            ] {
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &map,
+                        &nothing_covered(),
+                    ),
+                    Some(expected)
+                );
+            }
         }
 
-        #[derive(Default)]
-        struct RecordingTemplateAssembler {
-            calls: AtomicUsize,
-            fail: AtomicBool,
-            expected_store_completion: Mutex<Option<Arc<AtomicBool>>>,
-        }
+        #[test]
+        fn expires_can_authorize_but_never_extend_an_expired_response() {
+            let now = httpdate::parse_http_date("Wed, 12 Aug 2026 08:00:00 GMT")
+                .expect("should parse fixture time");
+            let fresh = headers(&[
+                (header::DATE, "Wed, 12 Aug 2026 08:00:00 GMT"),
+                (header::EXPIRES, "Wed, 12 Aug 2026 08:00:30 GMT"),
+            ]);
+            assert_eq!(
+                origin_shared_ttl_at(&fresh, now, Duration::from_secs(60)),
+                Ok(Duration::from_secs(30))
+            );
 
-        impl RecordingTemplateAssembler {
-            fn require_store_before_call(&self, completed: Arc<AtomicBool>) {
-                *self
-                    .expected_store_completion
-                    .lock()
-                    .expect("should lock expected store completion") = Some(completed);
-            }
+            let expired = headers(&[
+                (header::DATE, "Wed, 12 Aug 2026 08:01:00 GMT"),
+                (header::EXPIRES, "Wed, 12 Aug 2026 08:00:30 GMT"),
+            ]);
+            assert_eq!(
+                origin_shared_ttl_at(&expired, now, Duration::from_secs(60)),
+                Err(C2BypassReason::NoPositiveFreshness)
+            );
         }
 
-        impl crate::platform::PlatformTemplateAssembler for RecordingTemplateAssembler {
-            fn assemble(
-                &self,
-                template: &[u8],
-                fragment: &[u8],
-            ) -> Result<Vec<u8>, crate::platform::TemplateAssemblyError> {
-                self.calls.fetch_add(1, Ordering::Relaxed);
-                if self
-                    .expected_store_completion
-                    .lock()
-                    .expect("should lock expected store completion")
-                    .as_ref()
-                    .is_some_and(|completed| !completed.load(Ordering::Relaxed))
-                {
-                    return Err(crate::platform::TemplateAssemblyError::Failed {
-                        message: "assembler ran before cache insertion completed".to_string(),
-                    });
-                }
-                if self.fail.load(Ordering::Relaxed) {
-                    return Err(crate::platform::TemplateAssemblyError::Failed {
-                        message: "injected assembly failure".to_string(),
-                    });
-                }
-                let (head, tail) = split_template_at_seam(template).map_err(|error| {
-                    crate::platform::TemplateAssemblyError::Failed {
-                        message: error.to_string(),
-                    }
-                })?;
-                let mut assembled = Vec::with_capacity(head.len() + fragment.len() + tail.len());
-                assembled.extend_from_slice(head);
-                assembled.extend_from_slice(fragment);
-                assembled.extend_from_slice(tail);
-                Ok(assembled)
+        #[test]
+        fn request_semantics_bypass_c2_except_for_a_max_age_zero_reload() {
+            for (name, value) in [
+                (header::CACHE_CONTROL, "no-cache"),
+                (header::CACHE_CONTROL, "max-age=30"),
+                (header::CACHE_CONTROL, "max-age=\"0"),
+                (header::CACHE_CONTROL, "min-fresh=10"),
+                (header::CACHE_CONTROL, "no-store"),
+                (header::PRAGMA, "no-cache"),
+                (header::PRAGMA, "legacy-extension, no-cache"),
+                (header::RANGE, "bytes=0-99"),
+                (header::IF_NONE_MATCH, "\"etag\""),
+                (header::IF_MODIFIED_SINCE, "Wed, 12 Aug 2026 08:00:00 GMT"),
+            ] {
+                let map = headers(&[(name.clone(), value)]);
+                assert!(request_bypasses_c2(&map), "{name}: {value} must bypass");
             }
+            assert!(
+                !request_bypasses_c2(&headers(&[(header::CACHE_CONTROL, "max-age=0")])),
+                "a browser reload may reuse C2 because the assembled response and auction \
+                 are still rebuilt for this reader"
+            );
+            assert!(!request_bypasses_c2(&headers(&[(
+                header::CACHE_CONTROL,
+                "public"
+            )])));
         }
 
-        impl crate::platform::PlatformTemplateCacheReservation for MemoryTemplateReservation {
-            fn insert(
-                self: Box<Self>,
-                metadata: &crate::platform::TemplateMetadata,
-                body: Vec<u8>,
-                max_age: Duration,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                self.stored_keys
-                    .lock()
-                    .expect("should lock stored keys")
-                    .push(self.key.clone());
-                self.stored_max_ages
-                    .lock()
-                    .expect("should lock stored max ages")
-                    .push(max_age);
-                self.entries.lock().expect("should lock entries").insert(
-                    self.key.to_cache_key(),
-                    crate::platform::TemplateEntry {
-                        metadata: metadata.clone(),
-                        body,
-                    },
-                );
-                self.insert_completed.store(true, Ordering::Relaxed);
-                Ok(())
-            }
+        #[test]
+        fn a_wildcard_vary_is_refused() {
+            // `VarySpec::uncovered_by` filters `*` out, with a comment saying the
+            // eligibility gate handles it. It did not — nothing rejected the wildcard, so
+            // a response the origin said no key can select was shareable.
+            let mut varying = shareable();
+            varying.insert(header::VARY, HeaderValue::from_static("*"));
 
-            fn cancel(self: Box<Self>) -> Result<(), crate::platform::TemplateCacheError> {
-                Ok(())
-            }
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::VaryWildcard)
+            );
         }
 
-        #[async_trait::async_trait(?Send)]
-        impl crate::platform::PlatformTemplateCache for MemoryTemplateCache {
-            async fn lookup_or_reserve(
-                &self,
-                key: &crate::platform::TemplateCacheKey,
-            ) -> Result<crate::platform::TemplateCacheLookup, crate::platform::TemplateCacheError>
-            {
-                self.lookups
-                    .lock()
-                    .expect("should lock lookups")
-                    .push(key.clone());
-                if self.fail_lookup.load(Ordering::Relaxed) {
-                    return Err(crate::platform::TemplateCacheError::Backend {
-                        message: "injected lookup failure".to_string(),
-                    });
-                }
-                if let Some(entry) = self
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .get(&key.to_cache_key())
-                    .cloned()
-                {
-                    return Ok(crate::platform::TemplateCacheLookup::Hit(entry));
-                }
-                Ok(crate::platform::TemplateCacheLookup::Reserved(
-                    crate::platform::TemplateCacheReservation::new(Box::new(
-                        MemoryTemplateReservation {
-                            entries: Arc::clone(&self.entries),
-                            insert_completed: Arc::clone(&self.insert_completed),
-                            stored_keys: Arc::clone(&self.stored_keys),
-                            stored_max_ages: Arc::clone(&self.stored_max_ages),
-                            key: key.clone(),
-                        },
-                    )),
-                ))
-            }
-
-            async fn get(
-                &self,
-                key: &crate::platform::TemplateCacheKey,
-            ) -> Result<crate::platform::TemplateEntry, crate::platform::TemplateCacheMiss>
-            {
-                self.lookups
-                    .lock()
-                    .expect("should lock lookups")
-                    .push(key.clone());
-                self.entries
-                    .lock()
-                    .expect("should lock entries")
-                    .get(&key.to_cache_key())
-                    .cloned()
-                    .ok_or(crate::platform::TemplateCacheMiss::NotFound)
-            }
-
-            async fn put(
-                &self,
-                key: &crate::platform::TemplateCacheKey,
-                metadata: &crate::platform::TemplateMetadata,
-                body: Vec<u8>,
-                max_age: Duration,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                self.stored_keys
-                    .lock()
-                    .expect("should lock stored keys")
-                    .push(key.clone());
-                self.stored_max_ages
-                    .lock()
-                    .expect("should lock stored max ages")
-                    .push(max_age);
-                self.entries.lock().expect("should lock entries").insert(
-                    key.to_cache_key(),
-                    crate::platform::TemplateEntry {
-                        metadata: metadata.clone(),
-                        body,
-                    },
-                );
-                self.insert_completed.store(true, Ordering::Relaxed);
-                Ok(())
-            }
-
-            async fn purge_url(
-                &self,
-                key: &crate::platform::TemplateCacheKey,
-            ) -> Result<(), crate::platform::TemplateCacheError> {
-                self.entries
-                    .lock()
-                    .expect("should lock entries")
-                    .remove(&key.to_cache_key());
-                Ok(())
-            }
+        #[test]
+        fn a_fully_covered_vary_is_cacheable() {
+            let mut varying = shareable();
+            varying.insert(
+                header::VARY,
+                HeaderValue::from_static("rsc, Accept-Encoding"),
+            );
 
-            async fn purge_all(&self) -> Result<(), crate::platform::TemplateCacheError> {
-                self.entries.lock().expect("should lock entries").clear();
-                Ok(())
-            }
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &VarySpec::new(["rsc".to_string(), "accept-encoding".to_string()]),
+                ),
+                None,
+                "a key covering everything the origin varies on is safe to store"
+            );
         }
 
-        /// Settings with the ad stack **live**, not merely configured.
-        ///
-        /// `[auction] enabled = true` and a slot matching the request path are both
-        /// required, because `should_run_ad_stack` folds them together and half this
-        /// path only executes when it is true. An earlier version of this helper left
-        /// the auction disabled, which made every test here exercise the branch where
-        /// TS never stamps its own `private, no-store` — and so missed that the template cache gate
-        /// was reading that stamp and refusing to cache every page that runs ads.
-        fn settings_with_mode(mode: &str) -> Settings {
-            let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n\
-                 [creative_opportunities]\ngam_network_id = \"99999\"\n\
-                 assembly_mode = \"{mode}\"\n\n\
-                 [[creative_opportunities.slot]]\n\
-                 id = \"test-slot\"\n\
-                 page_patterns = [\"/article\"]\n\
-                 formats = [{{ width = 728, height = 90 }}]\n",
-                crate_test_settings_str()
+        #[test]
+        fn config_drift_names_the_missing_header() {
+            // The failure this guards: the origin adds a header to its Vary, nobody
+            // updates config, and requests differing only in that header start sharing a
+            // template. The reason must name it, or diagnosing means a bisect.
+            let mut varying = shareable();
+            varying.insert(
+                header::VARY,
+                HeaderValue::from_static("rsc, next-router-prefetch"),
             );
-            let mut settings =
-                Settings::from_toml(&toml).expect("should parse settings with an assembly mode");
-            // Mirrors `create_test_settings`; the integration registry refuses to build
-            // without it.
-            settings.proxy.allowed_domains =
-                vec!["*.example".to_string(), "*.example.com".to_string()];
-            settings
-        }
 
-        fn settings_with_mode_and_template_cache_max_age(mode: &str, seconds: u32) -> Settings {
-            let mut settings = settings_with_mode(mode);
-            settings
-                .creative_opportunities
-                .as_mut()
-                .expect("should configure creative opportunities")
-                .template_cache_max_age_seconds = Some(seconds);
-            settings
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &VarySpec::new(["rsc".to_string()]),
+                ),
+                Some(C2BypassReason::VaryNotCovered(VaryGap(vec![
+                    "next-router-prefetch".to_string()
+                ]))),
+                "the uncovered header must be named"
+            );
         }
 
-        fn services(
-            http_client: Arc<StubHttpClient>,
-            cache: Arc<MemoryTemplateCache>,
-        ) -> RuntimeServices {
-            RuntimeServices::builder()
-                .config_store(Arc::new(NoopConfigStore))
-                .secret_store(Arc::new(NoopSecretStore))
-                .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
-                .backend(Arc::new(StubBackend))
-                .http_client(http_client)
-                .geo(Arc::new(NoopGeo))
-                .client_info(ClientInfo::default())
-                .template_cache(cache)
-                .build()
-        }
+        #[test]
+        fn a_vary_split_across_repeated_headers_is_still_checked() {
+            // Vary is a list header, so an origin may send it once or many times. Reading
+            // only the first would let the rest through unkeyed.
+            let mut varying = shareable();
+            varying.append(header::VARY, HeaderValue::from_static("rsc"));
+            varying.append(header::VARY, HeaderValue::from_static("cookie"));
 
-        fn services_with_assembler(
-            http_client: Arc<StubHttpClient>,
-            cache: Arc<MemoryTemplateCache>,
-            assembler: Arc<RecordingTemplateAssembler>,
-        ) -> RuntimeServices {
-            services(http_client, cache).with_template_assembler(assembler)
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &varying,
+                    &VarySpec::new(["rsc".to_string()]),
+                ),
+                Some(C2BypassReason::VaryCookie),
+                "a repeated Vary header must not hide names behind the first value"
+            );
         }
 
-        /// Shareable HTML: no `Set-Cookie`, no `Vary`, a public `Cache-Control`. Every
-        /// condition the gate checks is satisfied, so a bypass here would be a bug in
-        /// the wiring rather than in the fixture.
-        fn queue_shareable_html(stub: &StubHttpClient) {
-            stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                ],
+        #[test]
+        fn a_plain_shareable_html_200_is_cacheable() {
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &shareable(),
+                    &nothing_covered(),
+                ),
+                None,
+                "ESI shareable HTML 200 should be eligible"
             );
         }
 
-        fn navigation_request() -> Request<EdgeBody> {
-            HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .header("sec-fetch-mode", "navigate")
-                .body(EdgeBody::empty())
-                .expect("should build navigation request")
+        #[test]
+        fn inline_mode_never_writes_a_template() {
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Inline,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &shareable(),
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::InlineMode),
+                "inline has no shared template to write"
+            );
         }
 
-        /// A navigation that opts out of the server-side ad stack.
-        ///
-        /// A prefetch is the cheapest of the four opt-outs to build (the others are bot
-        /// classification, denied consent, and the auction kill switch); all four reach
-        /// the seam the same way, as `seam_ad_slots == None`.
-        fn prefetch_navigation_request() -> Request<EdgeBody> {
-            let mut request = navigation_request();
-            request.headers_mut().insert(
-                "sec-purpose",
-                HeaderValue::from_static("prefetch;prerender"),
+        #[test]
+        fn an_authorized_request_is_never_cached() {
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    true,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &shareable(),
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::AuthorizedRequest),
+                "an authenticated response must not enter a shared cache"
             );
-            request
         }
 
-        /// A navigation carrying an **active** diagnostics decision, the way the real one
-        /// arrives: in the request extensions, set from a per-reader cookie or query
-        /// parameter.
-        fn diagnostics_navigation_request() -> Request<EdgeBody> {
-            let mut request = navigation_request();
-            request.extensions_mut().insert(
-                crate::integrations::gpt_diagnostics::GptDiagnosticsRequestDecision::active_for_tests(),
+        #[test]
+        fn a_forwarded_request_cookie_disqualifies_even_without_set_cookie() {
+            // The dangerous case: session established on an earlier request, so this
+            // response carries no Set-Cookie, has no Cache-Control at all, is a 200,
+            // and is HTML — yet is personalized because TS forwarded the Cookie to
+            // origin unchanged. Every other condition reports it cacheable.
+            let no_cache_control = edgezero_core::http::HeaderMap::new();
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    true,
+                    StatusCode::OK,
+                    "text/html",
+                    &no_cache_control,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::CookieForwarded),
+                "cookie-personalized HTML must not become a shared template"
             );
-            request
         }
 
-        /// A slot matching `/article`.
-        ///
-        /// Passed through `AuctionDispatch`, not read from settings — and that is the
-        /// distinction that matters. `should_run_ad_stack` requires a *matched* slot, so
-        /// a config slot with no dispatch slot leaves the ad stack off and skips every
-        /// branch that only runs when it is on.
-        fn article_slot() -> crate::creative_opportunities::CreativeOpportunitySlot {
-            crate::creative_opportunities::CreativeOpportunitySlot {
-                id: "test-slot".to_string(),
-                gam_unit_path: None,
-                div_id: Some("test-slot".to_string()),
-                page_patterns: vec!["/article".to_string()],
-                formats: vec![crate::creative_opportunities::CreativeOpportunityFormat {
-                    width: 728,
-                    height: 90,
-                    media_type: MediaType::Banner,
-                }],
-                floor_price: None,
-                targeting: Default::default(),
-                providers: Default::default(),
-                compiled_patterns: Vec::new(),
-                compiled_unit: None,
-            }
+        #[test]
+        fn an_origin_set_cookie_is_never_cached() {
+            let with_cookie = headers(&[
+                (header::CACHE_CONTROL, "max-age=60"),
+                (header::SET_COOKIE, "sid=abc; Path=/"),
+            ]);
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &with_cookie,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::OriginSetCookie),
+                "caching this would replay one visitor's cookie to the next"
+            );
         }
 
-        /// Name of the bidding test double, matched by `[auction].providers`.
-        const STUB_BIDDER: &str = "stub-bidder";
-
-        /// The CPM the stub bids. Chosen so its price bucket (`"3.50"`) is a distinctive
-        /// string that cannot appear in the fixture page by accident.
-        const STUB_BID_CPM: f64 = 3.5;
-
-        /// An auction provider that returns one genuine winning bid.
-        ///
-        /// Every other fixture in this file leaves the orchestrator with no providers, so
-        /// every auction resolves to an empty bid map. That is exactly why a defect that
-        /// discarded *non-empty* maps survived: no test ever produced one.
-        struct WinningBidProvider;
-
-        #[async_trait::async_trait(?Send)]
-        impl crate::auction::provider::AuctionProvider for WinningBidProvider {
-            fn provider_name(&self) -> &'static str {
-                STUB_BIDDER
-            }
-
-            async fn request_bids(
-                &self,
-                _request: &AuctionRequest,
-                context: &crate::auction::types::AuctionContext<'_>,
-            ) -> Result<crate::auction::provider::ProviderRequestOutcome, Report<TrustedServerError>>
-            {
-                let request = PlatformHttpRequest::new(
-                    HttpRequest::builder()
-                        .method(Method::POST)
-                        .uri("https://bidder.example.com/openrtb2/auction")
-                        .body(EdgeBody::empty())
-                        .expect("should build stub bid request"),
-                    "stub-bidder-backend",
+        #[test]
+        fn non_shareable_cache_control_is_refused_case_insensitively() {
+            for directive in [
+                "private",
+                "no-store",
+                "no-cache",
+                "Private, max-age=60",
+                "NO-STORE",
+                "public, No-Cache",
+            ] {
+                let map = headers(&[(header::CACHE_CONTROL, directive)]);
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        "text/html",
+                        &map,
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::OriginNotShareable),
+                    "`{directive}` should disqualify the response"
                 );
-                context
-                    .services
-                    .http_client()
-                    .send_async(request)
-                    .await
-                    .change_context(TrustedServerError::Auction {
-                        message: "stub bid launch failed".to_string(),
-                    })
-                    .map(crate::auction::provider::ProviderRequestOutcome::pending)
-            }
-
-            async fn parse_response(
-                &self,
-                _response: crate::platform::PlatformResponse,
-                response_time_ms: u64,
-            ) -> Result<crate::auction::types::AuctionResponse, Report<TrustedServerError>>
-            {
-                Ok(crate::auction::types::AuctionResponse::success(
-                    STUB_BIDDER,
-                    vec![Bid {
-                        slot_id: "test-slot".to_string(),
-                        price: Some(STUB_BID_CPM),
-                        currency: "USD".to_string(),
-                        creative: None,
-                        adomain: None,
-                        bidder: STUB_BIDDER.to_string(),
-                        returned_seat: None,
-                        width: 728,
-                        height: 90,
-                        nurl: None,
-                        burl: None,
-                        bid_id: None,
-                        creative_id: None,
-                        renderer: None,
-                        ad_id: Some("stub-creative-1".to_string()),
-                        cache_id: None,
-                        cache_host: None,
-                        cache_path: None,
-                        metadata: Default::default(),
-                    }],
-                    response_time_ms,
-                ))
-            }
-
-            fn timeout_ms(&self) -> u32 {
-                2000
-            }
-
-            fn backend_name(
-                &self,
-                _services: &RuntimeServices,
-                _timeout_ms: u32,
-            ) -> Option<String> {
-                Some("stub-bidder-backend".to_string())
             }
         }
 
-        /// [`settings_with_mode`], with an auction provider that actually bids.
-        fn settings_with_bidder(mode: &str) -> Settings {
-            let mut settings = settings_with_mode(mode);
-            settings.auction.providers =
-                crate::auction::AuctionConfig::legacy_provider_map(&[STUB_BIDDER]);
-            settings
-        }
-
-        /// Queue the bidder's canned response.
-        ///
-        /// Must be pushed **before** the origin HTML: the stub client serves one shared
-        /// FIFO queue, and the auction is dispatched before the origin fetch.
-        fn queue_bid_response(stub: &StubHttpClient) {
-            stub.push_response(200, b"{}".to_vec());
+        #[test]
+        fn a_datadome_block_is_refused_by_the_status_check() {
+            // DataDome replaces the document with a 403
+            // (`integrations/datadome/protection.rs:778`). There is no separate
+            // marker to detect, and none is needed.
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::FORBIDDEN,
+                    "text/html",
+                    &shareable(),
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::NonOkStatus),
+                "a blocked document must not become the shared template"
+            );
         }
 
-        /// Which finalizer a request is driven through.
-        ///
-        /// Both exist and both own an `AssembleTemplate` arm with its own seam call, so a
-        /// test that exercised one of them proves nothing about the other.
-        #[derive(Clone, Copy)]
-        enum Finalizer {
-            /// Fastly's path: headers commit first and the seam is spliced inside the
-            /// body stream.
-            Streaming,
-            /// Every buffered adapter's path: the seam is spliced eagerly.
-            Buffered,
+        #[test]
+        fn non_html_is_refused() {
+            for content_type in ["text/x-component", "application/json", ""] {
+                assert_eq!(
+                    c2_bypass_reason(
+                        AssemblyMode::Esi,
+                        false,
+                        false,
+                        StatusCode::OK,
+                        content_type,
+                        &shareable(),
+                        &nothing_covered(),
+                    ),
+                    Some(C2BypassReason::NotHtml),
+                    "`{content_type}` has no HTML template to transform"
+                );
+            }
         }
 
-        /// Runs the full request, **including the finalizer**.
-        ///
-        /// The finalizer is not optional here: the store happens once the transform has
-        /// produced every byte, so a test that stopped at `handle_publisher_request`
-        /// would never populate the cache and a hit could not be proven.
-        async fn run(
-            settings: &Arc<Settings>,
-            services: &RuntimeServices,
-            request: Request<EdgeBody>,
-        ) -> Response<EdgeBody> {
-            run_with_orchestrator(
-                settings,
-                services,
-                request,
-                AuctionOrchestrator::new(settings.auction.clone()),
-                Finalizer::Streaming,
-            )
-            .await
-        }
+        #[test]
+        fn unsupported_content_encoding_is_refused_before_representation_headers_change() {
+            let map = headers(&[
+                (header::CACHE_CONTROL, "public, max-age=60"),
+                (header::CONTENT_ENCODING, "zstd"),
+            ]);
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &map,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::UnsupportedContentEncoding)
+            );
 
-        /// [`run`], through the chosen finalizer.
-        async fn run_via(
-            settings: &Arc<Settings>,
-            services: &RuntimeServices,
-            request: Request<EdgeBody>,
-            finalizer: Finalizer,
-        ) -> Response<EdgeBody> {
-            run_with_orchestrator(
-                settings,
-                services,
-                request,
-                AuctionOrchestrator::new(settings.auction.clone()),
-                finalizer,
-            )
-            .await
+            let mut repeated = headers(&[(header::CACHE_CONTROL, "public, max-age=60")]);
+            repeated.append(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));
+            repeated.append(
+                header::CONTENT_TYPE,
+                HeaderValue::from_static("application/json"),
+            );
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    false,
+                    false,
+                    StatusCode::OK,
+                    "text/html",
+                    &repeated,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::MalformedRepresentationHeaders)
+            );
         }
 
-        /// [`run`], with a provider registered so the auction returns a real bid.
-        async fn run_bidding(
-            settings: &Arc<Settings>,
-            services: &RuntimeServices,
-            request: Request<EdgeBody>,
-        ) -> Response<EdgeBody> {
-            let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            orchestrator.register_provider(Arc::new(WinningBidProvider));
-            run_with_orchestrator(
-                settings,
-                services,
-                request,
-                orchestrator,
-                Finalizer::Streaming,
-            )
-            .await
+        #[test]
+        fn leak_vectors_are_reported_before_mere_ineligibility() {
+            // A response that fails several conditions should name the most serious
+            // one, so an operator reading the log sees the security reason rather
+            // than a content-type quibble.
+            let map = headers(&[
+                (header::CACHE_CONTROL, "private"),
+                (header::SET_COOKIE, "sid=abc"),
+            ]);
+            assert_eq!(
+                c2_bypass_reason(
+                    AssemblyMode::Esi,
+                    true,
+                    false,
+                    StatusCode::FORBIDDEN,
+                    "application/json",
+                    &map,
+                    &nothing_covered(),
+                ),
+                Some(C2BypassReason::AuthorizedRequest),
+                "authorization is the most serious disqualifier and should win"
+            );
         }
+    }
 
-        async fn run_with_orchestrator(
-            settings: &Arc<Settings>,
-            services: &RuntimeServices,
-            request: Request<EdgeBody>,
-            orchestrator: AuctionOrchestrator,
-            finalizer: Finalizer,
-        ) -> Response<EdgeBody> {
-            let orchestrator = Arc::new(orchestrator);
-            let registry =
-                IntegrationRegistry::new(settings).expect("should create integration registry");
-            let consent = crate::consent::ConsentContext {
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                ..Default::default()
-            };
-            let mut ec_context = EcContext::new_for_test(None, consent);
-            let publisher_response = handle_publisher_request(
-                settings,
-                services,
-                None,
-                &mut ec_context,
-                AuctionDispatch {
-                    orchestrator: &orchestrator,
-                    slots: &[article_slot()],
-                    registry: None,
-                },
-                request,
-                EdgeCacheHeader::SMaxageFallback,
-            )
-            .await
-            .expect("should proxy publisher request");
+    mod ssat_cache_policy_tests {
+        use super::*;
+        use crate::auction::provider::{AuctionProvider, ProviderRequestOutcome};
+        use crate::auction::telemetry::{AuctionEventBatch, AuctionTelemetrySink};
+        use crate::creative_opportunities::{CreativeOpportunityFormat, CreativeOpportunitySlot};
+        use crate::platform::test_support::{
+            NoopConfigStore, NoopGeo, NoopSecretStore, StubBackend, StubHttpClient,
+        };
+        use crate::platform::{
+            ClientInfo, PlatformError, PlatformHttpClient, PlatformPendingRequest,
+            PlatformResponse, PlatformSelectResult,
+        };
+        use crate::test_support::tests::crate_test_settings_str;
 
-            match finalizer {
-                Finalizer::Streaming => publisher_response_into_streaming_response(
-                    publisher_response,
-                    &Method::GET,
-                    Arc::clone(settings),
-                    &registry,
-                    orchestrator,
-                    services.clone(),
-                )
-                .await
-                .expect("should finalize publisher response"),
-                Finalizer::Buffered => buffer_publisher_response_async(
-                    publisher_response,
-                    &Method::GET,
-                    settings,
-                    &registry,
-                    &orchestrator,
-                    services,
-                )
-                .await
-                .expect("should finalize publisher response"),
+        const ORIGIN_ETAG: &str = "\"origin-tag\"";
+        const ORIGIN_LAST_MODIFIED: &str = "Wed, 21 Oct 2015 07:28:00 GMT";
+        const UNEXPECTED_304_PROVIDER: &str = "example-navigation-bidder";
+        const UNEXPECTED_304_BACKEND: &str = "example-navigation-bidder-backend";
+
+        struct DispatchingTestProvider;
+
+        struct RangeAwareHttpClient {
+            stub: StubHttpClient,
+        }
+
+        impl RangeAwareHttpClient {
+            fn new() -> Self {
+                Self {
+                    stub: StubHttpClient::new(),
+                }
             }
         }
 
-        /// Collects a response body whether it was buffered or streamed.
-        ///
-        /// Both occur here by design: a response the gate authorized is buffered so it
-        /// can be stored, and one it refused keeps streaming exactly like `inline`. A
-        /// helper that assumed either would silently only ever test one of them.
-        async fn body_of(response: Response<EdgeBody>) -> Vec<u8> {
-            match response.into_body() {
-                EdgeBody::Stream(mut stream) => {
-                    let mut out = Vec::new();
-                    while let Some(chunk) = stream.next().await {
-                        out.extend_from_slice(&chunk.expect("stream chunk should read"));
-                    }
-                    out
+        #[async_trait::async_trait(?Send)]
+        impl PlatformHttpClient for RangeAwareHttpClient {
+            async fn send(
+                &self,
+                request: PlatformHttpRequest,
+            ) -> Result<PlatformResponse, Report<PlatformError>> {
+                if request.request.headers().contains_key(header::RANGE) {
+                    self.stub.push_response_with_headers(
+                        206,
+                        b"<html><body>partial".to_vec(),
+                        vec![
+                            ("content-type", "text/html; charset=utf-8"),
+                            ("content-range", "bytes 0-18/39"),
+                        ],
+                    );
+                } else {
+                    self.stub.push_response_with_headers(
+                        200,
+                        b"<html><body>origin</body></html>".to_vec(),
+                        vec![("content-type", "text/html; charset=utf-8")],
+                    );
                 }
-                other => other
-                    .into_bytes()
-                    .expect("a non-stream body has its bytes in hand")
-                    .to_vec(),
+                self.stub.send(request).await
+            }
+
+            async fn send_async(
+                &self,
+                request: PlatformHttpRequest,
+            ) -> Result<PlatformPendingRequest, Report<PlatformError>> {
+                self.stub.send_async(request).await
+            }
+
+            async fn select(
+                &self,
+                pending_requests: Vec<PlatformPendingRequest>,
+            ) -> Result<PlatformSelectResult, Report<PlatformError>> {
+                self.stub.select(pending_requests).await
             }
         }
 
-        #[tokio::test]
-        async fn a_second_request_is_served_from_the_cache_without_touching_the_origin() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
+        #[async_trait::async_trait(?Send)]
+        impl AuctionProvider for DispatchingTestProvider {
+            fn provider_name(&self) -> &str {
+                UNEXPECTED_304_PROVIDER
+            }
 
-            // Only one origin response is queued. If the second request reached the
-            // origin it would find the queue empty, so this fixture is itself part of
-            // the assertion.
-            queue_shareable_html(&stub);
+            async fn request_bids(
+                &self,
+                _request: &AuctionRequest,
+                context: &AuctionContext<'_>,
+            ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
+                let request = PlatformHttpRequest::new(
+                    HttpRequest::builder()
+                        .method(Method::POST)
+                        .uri("https://bidder.example.com/navigation-bids")
+                        .body(EdgeBody::empty())
+                        .expect("should build test provider request"),
+                    UNEXPECTED_304_BACKEND,
+                );
+                context
+                    .services
+                    .http_client()
+                    .send_async(request)
+                    .await
+                    .change_context(TrustedServerError::Auction {
+                        message: "test provider launch failed".to_string(),
+                    })
+                    .map(ProviderRequestOutcome::pending)
+            }
 
-            let cold = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                cold.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("miss-stored"),
-                "a successful cold fill must be distinguishable from a bypass"
-            );
-            assert!(
-                cold.headers()
-                    .get(header::HeaderName::from_static("x-ts-c2-cache"))
-                    .is_none(),
-                "the retired template cache diagnostic must be absent from cold responses"
-            );
-            let first = body_of(cold).await;
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the cold request must fetch the origin"
-            );
+            async fn parse_response(
+                &self,
+                _response: PlatformResponse,
+                _response_time_ms: u64,
+            ) -> Result<AuctionResponse, Report<TrustedServerError>> {
+                panic!("parse_response must not run for an unexpected origin 304");
+            }
 
-            let warm = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                warm.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("hit")
-            );
-            assert!(
-                warm.headers()
-                    .get(header::HeaderName::from_static("x-ts-c2-cache"))
-                    .is_none(),
-                "the retired template cache diagnostic must be absent from warm responses"
-            );
-            let second = body_of(warm).await;
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the warm request must not fetch the origin — that saving is the point"
-            );
-            assert_eq!(
-                second, first,
-                "the cached template must be byte-identical to what was stored"
-            );
-        }
+            fn timeout_ms(&self) -> u32 {
+                100
+            }
 
-        #[tokio::test]
-        async fn a_pass_through_authorization_never_reaches_the_shared_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let mut request = navigation_request();
-            request.headers_mut().insert(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Basic dXNlcjpwYXNz"),
-            );
+            fn backend_name(
+                &self,
+                _services: &RuntimeServices,
+                _timeout_ms: u32,
+            ) -> Option<String> {
+                Some(UNEXPECTED_304_BACKEND.to_string())
+            }
+        }
 
-            let response = run(&settings, &services, request).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request"),
-                "a credential TS did not terminate is bound for the origin, so its response must never be shared"
-            );
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                0,
-                "an unterminated authorization must bypass before the lookup, not after it"
-            );
+        #[derive(Default)]
+        struct RecordingTelemetrySink {
+            batches: Mutex<Vec<AuctionEventBatch>>,
         }
 
-        #[tokio::test]
-        async fn repeated_authorization_never_reaches_the_shared_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let mut request = navigation_request();
-            request.headers_mut().insert(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Basic dXNlcjpwYXNz"),
-            );
-            request.headers_mut().append(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Bearer publisher-origin-credential"),
-            );
-            request
-                .extensions_mut()
-                .insert(crate::auth::EdgeTerminatedAuthorization::for_test(
-                    "Basic dXNlcjpwYXNz",
-                ));
+        #[async_trait::async_trait(?Send)]
+        impl AuctionTelemetrySink for RecordingTelemetrySink {
+            async fn emit_auction_events(
+                &self,
+                _services: &RuntimeServices,
+                batch: AuctionEventBatch,
+            ) -> Result<(), Report<TrustedServerError>> {
+                self.batches
+                    .lock()
+                    .expect("should lock telemetry batches")
+                    .push(batch);
+                Ok(())
+            }
+        }
 
-            let response = run(&settings, &services, request).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request"),
-                "an ambiguous authorization must remain bound for the origin even if a marker is present"
-            );
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                0,
-                "repeated authorization must bypass before the shared template lookup"
+        fn settings_with_enabled_auction_and_creative_opportunities() -> Settings {
+            let toml = format!(
+                "{}\n[auction]\nenabled = true\n\n\
+                 [creative_opportunities]\nenabled = true\ngam_network_id = \"12345\"\n",
+                crate_test_settings_str()
             );
+            Settings::from_toml(&toml)
+                .expect("should parse settings with auction and creative opportunities enabled")
         }
 
-        #[tokio::test]
-        async fn a_replaced_edge_terminated_authorization_bypasses_the_shared_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut settings = settings_with_mode("esi");
-            settings.handlers[0] = toml::from_str(
-                r#"
-                    path = "^/article"
-                    username = "user"
-                    password = "pass"
-                "#,
-            )
-            .expect("should parse article auth handler");
-            let settings = Arc::new(settings);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let mut request = navigation_request();
-            request.headers_mut().insert(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Basic dXNlcjpwYXNz"),
-            );
-            assert!(
-                crate::auth::enforce_basic_auth(&settings, &mut request)
-                    .expect("should evaluate auth")
-                    .is_none(),
-                "the original credential should pass edge auth"
-            );
-            request.headers_mut().insert(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Bearer publisher-origin-credential"),
+        fn settings_with_disabled_creative_opportunities() -> Settings {
+            let toml = format!(
+                "{}\n[auction]\nenabled = true\n\n\
+                 [creative_opportunities]\nenabled = false\ngam_network_id = \"12345\"\nassembly_mode = \"esi\"\n",
+                crate_test_settings_str()
             );
+            Settings::from_toml(&toml)
+                .expect("should parse settings with creative opportunities disabled")
+        }
 
-            let response = run(&settings, &services, request).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request"),
-                "a replacement credential was not validated at the edge and must bypass sharing"
-            );
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                0,
-                "a replaced authorization must bypass before the shared template lookup"
+        fn settings_with_dispatching_provider() -> Settings {
+            let toml = format!(
+                "{}\n[auction]\nenabled = true\n\n\
+                 [auction.providers.{UNEXPECTED_304_PROVIDER}]\nprotocol = \"openrtb-2.6\"\nprofile = \"standard\"\nendpoint = \"https://bidder.example/bid\"\nrouting = \"all_eligible\"\n\n\
+                 [creative_opportunities]\nenabled = true\ngam_network_id = \"12345\"\n",
+                crate_test_settings_str()
             );
+            Settings::from_toml(&toml)
+                .expect("should parse settings with the dispatching test provider")
         }
 
-        #[tokio::test]
-        async fn an_edge_terminated_authorization_still_shares_its_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-
-            // One origin response for two requests: the warm read is asserted by the
-            // fixture running dry, exactly as in the unauthenticated case.
-            queue_shareable_html(&stub);
-
-            let authorized_navigation = || {
-                let mut request = navigation_request();
-                request.headers_mut().insert(
-                    header::AUTHORIZATION,
-                    HeaderValue::from_static("Basic dXNlcjpwYXNz"),
-                );
-                request.extensions_mut().insert(
-                    crate::auth::EdgeTerminatedAuthorization::for_test("Basic dXNlcjpwYXNz"),
-                );
-                request
-            };
-
-            let cold = run(&settings, &services, authorized_navigation()).await;
-            assert_eq!(
-                cold.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("miss-stored"),
-                "a credential this edge terminated must be allowed to fill the shared template"
-            );
-            let first = body_of(cold).await;
+        fn services_with_telemetry(
+            http_client: Arc<dyn crate::platform::PlatformHttpClient>,
+            telemetry_sink: Arc<RecordingTelemetrySink>,
+        ) -> RuntimeServices {
+            let telemetry_sink: Arc<dyn AuctionTelemetrySink> = telemetry_sink;
+            RuntimeServices::builder()
+                .config_store(Arc::new(NoopConfigStore))
+                .secret_store(Arc::new(NoopSecretStore))
+                .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
+                .backend(Arc::new(StubBackend))
+                .http_client(http_client)
+                .geo(Arc::new(NoopGeo))
+                .auction_telemetry_sink(telemetry_sink)
+                .client_info(ClientInfo::default())
+                .build()
+        }
 
-            let warm = run(&settings, &services, authorized_navigation()).await;
-            assert_eq!(
-                warm.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("hit"),
-                "the second gated request must read the template the first one stored"
-            );
-            let second = body_of(warm).await;
+        fn article_slot() -> CreativeOpportunitySlot {
+            CreativeOpportunitySlot {
+                id: "article-slot".to_string(),
+                gam_unit_path: None,
+                div_id: None,
+                page_patterns: vec!["/article".to_string()],
+                formats: vec![CreativeOpportunityFormat {
+                    width: 300,
+                    height: 250,
+                    media_type: MediaType::Banner,
+                }],
+                floor_price: None,
+                targeting: Default::default(),
+                providers: Default::default(),
+                compiled_patterns: Vec::new(),
+                compiled_unit: None,
+            }
+        }
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the warm gated request must not fetch the origin"
-            );
-            assert_eq!(
-                second, first,
-                "the gated warm response must be byte-identical to the stored template"
-            );
+        fn conditional_navigation_request() -> Request<EdgeBody> {
+            HttpRequest::builder()
+                .method(Method::GET)
+                .uri("https://ts.example.com/article")
+                .header(header::HOST, "ts.example.com")
+                .header("sec-fetch-dest", "document")
+                .header(header::IF_NONE_MATCH, ORIGIN_ETAG)
+                .header(header::IF_MODIFIED_SINCE, ORIGIN_LAST_MODIFIED)
+                .body(EdgeBody::empty())
+                .expect("should build conditional navigation request")
         }
 
-        #[tokio::test]
-        async fn only_the_cold_miss_uses_the_platform_assembler() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let assembler = Arc::new(RecordingTemplateAssembler::default());
-            assembler.require_store_before_call(Arc::clone(&cache.insert_completed));
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services_with_assembler(
-                Arc::clone(&stub),
-                Arc::clone(&cache),
-                Arc::clone(&assembler),
-            );
-            queue_shareable_html(&stub);
+        fn queue_cacheable_html_response(stub: &StubHttpClient) {
+            queue_html_response_with_cache_control(stub, "public, max-age=300");
+        }
 
-            let cold = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                header_of(&cold, header::HeaderName::from_static("x-ts-assembly")),
-                Some("esi-parser")
-            );
-            let cold_body = body_of(cold).await;
-            assert_eq!(assembler.calls.load(Ordering::Relaxed), 1);
+        fn queue_html_response_with_cache_control(
+            stub: &StubHttpClient,
+            cache_control: &'static str,
+        ) {
+            queue_html_response_with_status_and_cache_control(stub, 200, cache_control);
+        }
 
-            let warm = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                header_of(&warm, header::HeaderName::from_static("x-ts-assembly")),
-                Some("byte-seam")
+        fn queue_html_response_with_status_and_cache_control(
+            stub: &StubHttpClient,
+            status: u16,
+            cache_control: &'static str,
+        ) {
+            stub.push_response_with_headers(
+                status,
+                b"<html><body>origin</body></html>".to_vec(),
+                vec![
+                    ("content-type", "text/html; charset=utf-8"),
+                    ("cache-control", cache_control),
+                    ("etag", ORIGIN_ETAG),
+                    ("last-modified", ORIGIN_LAST_MODIFIED),
+                    ("surrogate-control", "max-age=300"),
+                    ("fastly-surrogate-control", "max-age=300"),
+                    ("cdn-cache-control", "max-age=300"),
+                    ("cloudflare-cdn-cache-control", "max-age=300"),
+                ],
             );
-            let warm_body = body_of(warm).await;
+        }
 
-            assert_eq!(
-                assembler.calls.load(Ordering::Relaxed),
-                1,
-                "a warm hit must preserve the streaming byte-seam path"
-            );
-            assert_eq!(cold_body, warm_body);
+        fn non_regulated_consent() -> crate::consent::ConsentContext {
+            crate::consent::ConsentContext {
+                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
+                ..Default::default()
+            }
         }
 
-        #[tokio::test]
-        async fn a_platform_assembly_failure_falls_back_to_a_complete_byte_seam() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let assembler = Arc::new(RecordingTemplateAssembler::default());
-            assembler.fail.store(true, Ordering::Relaxed);
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services_with_assembler(
-                Arc::clone(&stub),
-                Arc::clone(&cache),
-                Arc::clone(&assembler),
-            );
-            queue_shareable_html(&stub);
+        async fn run_with_slots(
+            settings: &Settings,
+            services: &RuntimeServices,
+            slots: &[CreativeOpportunitySlot],
+            req: Request<EdgeBody>,
+        ) -> PublisherResponse {
+            run_with_slots_and_consent(settings, services, slots, req, non_regulated_consent())
+                .await
+        }
 
-            let response = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                header_of(&response, header::HeaderName::from_static("x-ts-assembly")),
-                Some("byte-seam-fallback")
-            );
-            let document = String::from_utf8(body_of(response).await)
-                .expect("served document should be UTF-8");
+        async fn run_with_slots_and_consent(
+            settings: &Settings,
+            services: &RuntimeServices,
+            slots: &[CreativeOpportunitySlot],
+            req: Request<EdgeBody>,
+            consent: crate::consent::ConsentContext,
+        ) -> PublisherResponse {
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            run_with_orchestrator_and_consent(
+                settings,
+                services,
+                &orchestrator,
+                slots,
+                req,
+                consent,
+            )
+            .await
+        }
 
-            assert!(document.contains("origin"));
-            assert!(document.contains("scheduleInitialAdInit"));
-            assert!(!document.contains(AD_ASSEMBLY_SEAM));
-            assert_eq!(assembler.calls.load(Ordering::Relaxed), 1);
+        async fn run_with_orchestrator(
+            settings: &Settings,
+            services: &RuntimeServices,
+            orchestrator: &AuctionOrchestrator,
+            slots: &[CreativeOpportunitySlot],
+            req: Request<EdgeBody>,
+        ) -> PublisherResponse {
+            run_with_orchestrator_and_consent(
+                settings,
+                services,
+                orchestrator,
+                slots,
+                req,
+                non_regulated_consent(),
+            )
+            .await
         }
 
-        #[tokio::test]
-        async fn publisher_esi_directives_are_never_stored_or_executed() {
-            for (source, expected_directive) in [
-                ("<!--ESI publisher-->", "<!--esi publisher-->"),
-                (
-                    "<ESI:remove>publisher</ESI:remove>",
-                    "<esi:remove>publisher</esi:remove>",
-                ),
-            ] {
-                let stub = Arc::new(StubHttpClient::new());
-                let cache = Arc::new(MemoryTemplateCache::default());
-                let assembler = Arc::new(RecordingTemplateAssembler::default());
-                let settings = Arc::new(settings_with_mode("esi"));
-                let services = services_with_assembler(
-                    Arc::clone(&stub),
-                    Arc::clone(&cache),
-                    Arc::clone(&assembler),
-                );
-                stub.push_response_with_headers(
-                    200,
-                    format!("<html><head></head><body>{source}</body></html>").into_bytes(),
-                    vec![
-                        ("content-type", "text/html; charset=utf-8"),
-                        ("cache-control", "public, max-age=300"),
-                    ],
-                );
+        async fn run_with_orchestrator_and_consent(
+            settings: &Settings,
+            services: &RuntimeServices,
+            orchestrator: &AuctionOrchestrator,
+            slots: &[CreativeOpportunitySlot],
+            req: Request<EdgeBody>,
+            consent: crate::consent::ConsentContext,
+        ) -> PublisherResponse {
+            let mut ec_context = EcContext::new_for_test(None, consent);
 
-                let response = run(&settings, &services, navigation_request()).await;
-                assert_eq!(
-                    header_of(
-                        &response,
-                        header::HeaderName::from_static(HEADER_X_TS_TEMPLATE_CACHE),
-                    ),
-                    Some("bypass-response")
-                );
-                assert_eq!(
-                    header_of(&response, header::HeaderName::from_static("x-ts-assembly")),
-                    Some("byte-seam-fallback")
-                );
-                let document = String::from_utf8(body_of(response).await)
-                    .expect("served document should be UTF-8");
+            handle_publisher_request(
+                settings,
+                services,
+                None,
+                &mut ec_context,
+                AuctionDispatch {
+                    orchestrator,
+                    slots,
+                    registry: None,
+                },
+                req,
+                EdgeCacheHeader::SMaxageFallback,
+            )
+            .await
+            .expect("should proxy publisher request")
+        }
 
-                assert!(document.to_ascii_lowercase().contains(expected_directive));
-                assert!(document.contains("scheduleInitialAdInit"));
-                assert!(
-                    cache
-                        .entries
-                        .lock()
-                        .expect("should lock entries")
-                        .is_empty(),
-                    "publisher-authored ESI must never enter the shared template cache"
-                );
-                assert_eq!(
-                    assembler.calls.load(Ordering::Relaxed),
-                    0,
-                    "publisher-authored ESI must never reach the platform parser"
-                );
+        fn response_head(response: PublisherResponse) -> http::response::Parts {
+            match response {
+                PublisherResponse::Buffered(response)
+                | PublisherResponse::Stream { response, .. }
+                | PublisherResponse::AssembleTemplate { response, .. }
+                | PublisherResponse::PassThrough { response, .. } => response.into_parts().0,
             }
         }
 
-        #[tokio::test]
-        async fn ineligible_requests_and_responses_never_use_the_platform_assembler() {
-            let inline_stub = Arc::new(StubHttpClient::new());
-            let inline_cache = Arc::new(MemoryTemplateCache::default());
-            let inline_assembler = Arc::new(RecordingTemplateAssembler::default());
-            let inline_settings = Arc::new(settings_with_mode("inline"));
-            let inline_services = services_with_assembler(
-                Arc::clone(&inline_stub),
-                Arc::clone(&inline_cache),
-                Arc::clone(&inline_assembler),
-            );
-            queue_shareable_html(&inline_stub);
-
-            let _ =
-                body_of(run(&inline_settings, &inline_services, navigation_request()).await).await;
-            assert_eq!(inline_assembler.calls.load(Ordering::Relaxed), 0);
-
-            let private_stub = Arc::new(StubHttpClient::new());
-            let private_cache = Arc::new(MemoryTemplateCache::default());
-            let private_assembler = Arc::new(RecordingTemplateAssembler::default());
-            let esi_settings = Arc::new(settings_with_mode("esi"));
-            let private_services = services_with_assembler(
-                Arc::clone(&private_stub),
-                Arc::clone(&private_cache),
-                Arc::clone(&private_assembler),
-            );
-            private_stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>private origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                    ("set-cookie", "reader=personalized; Path=/"),
-                ],
-            );
-
-            let _ =
-                body_of(run(&esi_settings, &private_services, navigation_request()).await).await;
-            assert_eq!(private_assembler.calls.load(Ordering::Relaxed), 0);
-
-            let authenticated_stub = Arc::new(StubHttpClient::new());
-            let authenticated_cache = Arc::new(MemoryTemplateCache::default());
-            let authenticated_assembler = Arc::new(RecordingTemplateAssembler::default());
-            let authenticated_services = services_with_assembler(
-                Arc::clone(&authenticated_stub),
-                Arc::clone(&authenticated_cache),
-                Arc::clone(&authenticated_assembler),
-            );
-            queue_shareable_html(&authenticated_stub);
-            let mut authenticated_request = navigation_request();
-            authenticated_request.headers_mut().insert(
-                header::AUTHORIZATION,
-                HeaderValue::from_static("Bearer example-token"),
-            );
-
-            let _ = body_of(
-                run(
-                    &esi_settings,
-                    &authenticated_services,
-                    authenticated_request,
-                )
-                .await,
-            )
-            .await;
-            assert_eq!(authenticated_assembler.calls.load(Ordering::Relaxed), 0);
-
-            let failed_cache_stub = Arc::new(StubHttpClient::new());
-            let failed_cache = Arc::new(MemoryTemplateCache::default());
-            failed_cache.fail_lookup.store(true, Ordering::Relaxed);
-            let failed_cache_assembler = Arc::new(RecordingTemplateAssembler::default());
-            let failed_cache_services = services_with_assembler(
-                Arc::clone(&failed_cache_stub),
-                Arc::clone(&failed_cache),
-                Arc::clone(&failed_cache_assembler),
-            );
-            queue_shareable_html(&failed_cache_stub);
-
-            let _ = body_of(run(&esi_settings, &failed_cache_services, navigation_request()).await)
-                .await;
-            assert_eq!(failed_cache_assembler.calls.load(Ordering::Relaxed), 0);
+        fn recorded_header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
+            headers
+                .iter()
+                .find(|(header_name, _)| header_name.eq_ignore_ascii_case(name))
+                .map(|(_, value)| value.as_str())
         }
 
         #[tokio::test]
-        async fn fastly_surrogate_control_still_allows_a_cold_fill_and_warm_hit() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode_and_template_cache_max_age("esi", 1_200));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-
-            // This is the policy observed on the publisher that exposed the bug. Fastly
-            // gives the surrogate lifetime edge precedence; the configured safety
-            // ceiling allows the origin's twenty-minute edge freshness.
-            stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=60"),
-                    (
-                        "surrogate-control",
-                        "max-age=1200, stale-while-revalidate=21600, \
-                         stale-if-error=604800",
-                    ),
-                ],
+        async fn signer_admission_failure_continues_publisher_origin_without_provider_io() {
+            let mut settings = settings_with_dispatching_provider();
+            settings
+                .request_signing
+                .as_mut()
+                .expect("should configure request signing stores")
+                .enabled = true;
+            let plan = Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile signed navigation auction"),
+            );
+            let orchestrator = crate::auction::build_orchestrator_with_plan(plan, &settings)
+                .expect("should build signed plan-backed orchestrator");
+            let stub = Arc::new(StubHttpClient::new());
+            queue_cacheable_html_response(&stub);
+            let services = services_with_telemetry(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
+                Arc::new(RecordingTelemetrySink::default()),
             );
+            let slots = [article_slot()];
+
+            let response = run_with_orchestrator(
+                &settings,
+                &services,
+                &orchestrator,
+                &slots,
+                conditional_navigation_request(),
+            )
+            .await;
 
-            let cold = run(&settings, &services, navigation_request()).await;
+            assert_eq!(response_head(response).status, StatusCode::OK);
             assert_eq!(
-                cold.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("miss-stored")
+                stub.recorded_backend_names(),
+                vec!["stub-backend".to_string()],
+                "signer admission failure should skip provider I/O and still fetch the publisher origin"
             );
-            let _ = body_of(cold).await;
-            let stored_max_age = cache
-                .stored_max_ages
-                .lock()
-                .expect("should lock stored max ages")[0];
-            assert!(
-                stored_max_age <= Duration::from_secs(1_200)
-                    && stored_max_age > Duration::from_secs(1_195),
-                "the real store path should receive the configured twenty-minute ceiling, got {stored_max_age:?}"
+        }
+
+        #[tokio::test]
+        async fn eligible_navigation_bypasses_cache_and_returns_non_storable_html() {
+            // Arrange
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
+            let stub = Arc::new(StubHttpClient::new());
+            queue_cacheable_html_response(&stub);
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
+            let slots = [article_slot()];
+            let req = conditional_navigation_request();
+
+            // Act
+            let response = run_with_slots(&settings, &services, &slots, req).await;
+            let response_head = response_head(response);
 
-            let warm = run(&settings, &services, navigation_request()).await;
+            // Assert
             assert_eq!(
-                warm.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("hit")
+                stub.recorded_cache_bypass_flags(),
+                vec![true],
+                "eligible publisher navigation should bypass the platform cache"
             );
-            let _ = body_of(warm).await;
+            let recorded_requests = stub.recorded_request_headers();
+            let outbound_headers = recorded_requests
+                .first()
+                .expect("should record the outbound publisher request");
             assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the warm request must reuse the template authorized by Surrogate-Control"
+                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
+                None,
+                "eligible publisher request should not forward If-None-Match"
+            );
+            assert_eq!(
+                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
+                None,
+                "eligible publisher request should not forward If-Modified-Since"
+            );
+            assert_eq!(
+                response_head
+                    .headers
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("private, no-store"),
+                "eligible HTML response should be private and non-storable"
             );
+            for header_name in [
+                header::ETAG,
+                header::LAST_MODIFIED,
+                header::HeaderName::from_static("surrogate-control"),
+                header::HeaderName::from_static("fastly-surrogate-control"),
+                header::HeaderName::from_static("cdn-cache-control"),
+                header::HeaderName::from_static("cloudflare-cdn-cache-control"),
+            ] {
+                assert!(
+                    !response_head.headers.contains_key(&header_name),
+                    "eligible HTML response should remove {header_name}"
+                );
+            }
         }
 
         #[tokio::test]
-        async fn one_identity_template_is_negotiated_per_reader_on_miss_and_hit() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            stub.push_response_with_headers(
-                200,
-                gzip_encode(b"<html><head></head><body>origin</body></html>"),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("content-encoding", "gzip"),
-                    ("cache-control", "public, max-age=300"),
-                    ("vary", "accept-encoding"),
-                ],
+        async fn eligible_range_navigation_fetches_complete_html() {
+            // Arrange
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
+            let http_client = Arc::new(RangeAwareHttpClient::new());
+            let services = build_services_with_http_client(
+                Arc::clone(&http_client) as Arc<dyn crate::platform::PlatformHttpClient>
             );
+            let slots = [article_slot()];
+            let mut req = conditional_navigation_request();
+            req.headers_mut()
+                .insert(header::RANGE, HeaderValue::from_static("bytes=0-18"));
+            req.headers_mut()
+                .insert(header::IF_RANGE, HeaderValue::from_static(ORIGIN_ETAG));
 
-            let mut gzip_request = navigation_request();
-            gzip_request
-                .headers_mut()
-                .insert(header::ACCEPT_ENCODING, HeaderValue::from_static("gzip"));
-            let cold = run(&settings, &services, gzip_request).await;
+            // Act
+            let response = run_with_slots(&settings, &services, &slots, req).await;
+            let response_head = response_head(response);
+
+            // Assert
             assert_eq!(
-                cold.headers()
-                    .get(header::CONTENT_ENCODING)
-                    .and_then(|value| value.to_str().ok()),
-                Some("gzip")
-            );
-            assert!(
-                cold.headers().get_all(header::VARY).iter().any(|value| {
-                    value.to_str().is_ok_and(|value| {
-                        value
-                            .split(',')
-                            .any(|name| name.trim().eq_ignore_ascii_case("accept-encoding"))
-                    })
-                }),
-                "the encoded cold response must declare reader negotiation"
+                response_head.status,
+                StatusCode::OK,
+                "eligible range navigation should fetch the complete origin document"
             );
-            let cold_decoded = gzip_decode(&body_of(cold).await);
+            let recorded_requests = http_client.stub.recorded_request_headers();
+            let outbound_headers = recorded_requests
+                .first()
+                .expect("should record the outbound publisher request");
+            for header_name in [header::RANGE, header::IF_RANGE] {
+                assert_eq!(
+                    recorded_header(outbound_headers, header_name.as_str()),
+                    None,
+                    "eligible publisher request should not forward {header_name}"
+                );
+            }
+        }
 
-            let warm_identity = run(&settings, &services, navigation_request()).await;
-            assert!(
-                warm_identity
-                    .headers()
-                    .get(header::CONTENT_ENCODING)
-                    .is_none(),
-                "a reader that did not advertise compression must receive identity"
+        #[tokio::test]
+        async fn navigation_without_matched_slots_preserves_origin_cache_policy() {
+            // Arrange
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
+            let stub = Arc::new(StubHttpClient::new());
+            queue_cacheable_html_response(&stub);
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
-            let warm_identity_body = body_of(warm_identity).await;
+            let mut req = conditional_navigation_request();
+            req.headers_mut()
+                .insert(header::RANGE, HeaderValue::from_static("bytes=0-18"));
+            req.headers_mut()
+                .insert(header::IF_RANGE, HeaderValue::from_static(ORIGIN_ETAG));
 
-            let mut warm_gzip_request = navigation_request();
-            warm_gzip_request
-                .headers_mut()
-                .insert(header::ACCEPT_ENCODING, HeaderValue::from_static("gzip"));
-            let warm_gzip = run(&settings, &services, warm_gzip_request).await;
+            // Act
+            let response = run_with_slots(&settings, &services, &[], req).await;
+            let response_head = response_head(response);
+
+            // Assert
             assert_eq!(
-                warm_gzip
-                    .headers()
-                    .get(header::CONTENT_ENCODING)
-                    .and_then(|value| value.to_str().ok()),
-                Some("gzip")
+                stub.recorded_cache_bypass_flags(),
+                vec![false],
+                "publisher navigation without matched slots should use the default cache mode"
             );
+            let recorded_requests = stub.recorded_request_headers();
+            let outbound_headers = recorded_requests
+                .first()
+                .expect("should record the outbound publisher request");
             assert_eq!(
-                warm_gzip
-                    .headers()
-                    .get(header::VARY)
-                    .and_then(|value| value.to_str().ok()),
-                Some("Accept-Encoding")
+                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
+                Some(ORIGIN_ETAG),
+                "publisher request without matched slots should preserve If-None-Match"
             );
-            let warm_gzip_decoded = gzip_decode(&body_of(warm_gzip).await);
-
-            let mut warm_brotli_request = navigation_request();
-            warm_brotli_request.headers_mut().insert(
-                header::ACCEPT_ENCODING,
-                HeaderValue::from_static("br, gzip;q=0.5"),
+            assert_eq!(
+                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
+                Some(ORIGIN_LAST_MODIFIED),
+                "publisher request without matched slots should preserve If-Modified-Since"
             );
-            let warm_brotli = run(&settings, &services, warm_brotli_request).await;
             assert_eq!(
-                warm_brotli
-                    .headers()
-                    .get(header::CONTENT_ENCODING)
-                    .and_then(|value| value.to_str().ok()),
-                Some("br")
+                recorded_header(outbound_headers, header::RANGE.as_str()),
+                Some("bytes=0-18"),
+                "publisher request without matched slots should preserve Range"
+            );
+            assert_eq!(
+                recorded_header(outbound_headers, header::IF_RANGE.as_str()),
+                Some(ORIGIN_ETAG),
+                "publisher request without matched slots should preserve If-Range"
             );
-            let warm_brotli_decoded = brotli_decode(&body_of(warm_brotli).await);
 
-            assert_eq!(stub.recorded_request_uris().len(), 1);
-            assert_eq!(cold_decoded, warm_identity_body);
-            assert_eq!(warm_gzip_decoded, warm_identity_body);
-            assert_eq!(warm_brotli_decoded, warm_identity_body);
+            for (header_name, expected) in [
+                (header::CACHE_CONTROL, "private, max-age=60"),
+                (header::ETAG, ORIGIN_ETAG),
+                (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
+                (
+                    header::HeaderName::from_static("surrogate-control"),
+                    "max-age=300",
+                ),
+                (
+                    header::HeaderName::from_static("fastly-surrogate-control"),
+                    "max-age=300",
+                ),
+                (
+                    header::HeaderName::from_static("cdn-cache-control"),
+                    "max-age=300",
+                ),
+                (
+                    header::HeaderName::from_static("cloudflare-cdn-cache-control"),
+                    "max-age=300",
+                ),
+            ] {
+                assert_eq!(
+                    response_head
+                        .headers
+                        .get(&header_name)
+                        .and_then(|value| value.to_str().ok()),
+                    Some(expected),
+                    "publisher response without matched slots should preserve {header_name}"
+                );
+            }
         }
 
         #[tokio::test]
-        async fn esi_unsupported_reader_encoding_still_injects_tsjs() {
+        async fn disabled_creative_opportunities_keep_matching_navigation_inactive() {
+            let settings = settings_with_disabled_creative_opportunities();
+            assert_eq!(
+                configured_assembly_mode(&settings),
+                AssemblyMode::Inline,
+                "disabled template delivery must not activate configured assembly machinery"
+            );
             let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            let mut request = navigation_request();
-            request.headers_mut().insert(
-                header::ACCEPT_ENCODING,
-                HeaderValue::from_static("zstd, gzip;q=0, deflate;q=0, br;q=0, identity;q=0"),
+            queue_cacheable_html_response(&stub);
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
+            let slots = [article_slot()];
 
-            let body = String::from_utf8(body_of(run(&settings, &services, request).await).await)
-                .expect("should return UTF-8 HTML");
+            let response = run_with_slots(
+                &settings,
+                &services,
+                &slots,
+                conditional_navigation_request(),
+            )
+            .await;
+            let response_head = response_head(response);
 
-            let forwarded = stub.recorded_request_headers();
-            assert!(
-                forwarded[0].iter().any(|(name, value)| {
-                    name.eq_ignore_ascii_case("accept-encoding") && value == "identity"
-                }),
-                "should force an identity origin representation when no reader encoding is \
-                 available for assembly"
+            assert_eq!(
+                stub.recorded_cache_bypass_flags(),
+                vec![false],
+                "disabled template delivery must not bypass the publisher cache"
             );
-            assert!(
-                body.contains("window.tsjs"),
-                "should preserve TSJS injection while bypassing shared assembly"
+            assert_eq!(
+                response_head
+                    .headers
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("private, max-age=60"),
+                "disabled template delivery should preserve a private origin policy"
             );
-            assert!(
-                cache
-                    .lookups
-                    .lock()
-                    .expect("should lock lookups")
-                    .is_empty(),
-                "should bypass template cache when the reader accepts no supported representation"
+            assert_eq!(
+                response_head.headers.get(header::ETAG),
+                Some(&HeaderValue::from_static(ORIGIN_ETAG)),
+                "disabled template delivery must preserve the origin validator"
             );
         }
 
         #[tokio::test]
-        async fn an_unsupported_origin_encoding_bypasses_template_cache_without_relabeling_the_body()
-         {
+        async fn inactive_html_failure_preserves_origin_cache_policy() {
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
             let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            let wire_body = b"opaque-zstd-wire-bytes".to_vec();
             stub.push_response_with_headers(
-                200,
-                wire_body.clone(),
+                500,
+                b"<html><body>origin failure</body></html>".to_vec(),
                 vec![
                     ("content-type", "text/html; charset=utf-8"),
-                    ("content-encoding", "zstd"),
                     ("cache-control", "public, max-age=300"),
+                    ("etag", ORIGIN_ETAG),
                 ],
             );
-
-            let response = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(header::CONTENT_ENCODING)
-                    .and_then(|value| value.to_str().ok()),
-                Some("zstd"),
-                "the pass-through bytes must keep the origin's representation label"
-            );
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-response")
-            );
-            assert_eq!(body_of(response).await, wire_body);
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty()
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
-        }
-
-        #[tokio::test]
-        async fn revalidation_partial_and_conditional_requests_bypass_a_warm_template() {
-            for (name, value) in [
-                (header::CACHE_CONTROL, "no-cache"),
-                (header::PRAGMA, "no-cache"),
-                (header::RANGE, "bytes=0-31"),
-                (header::IF_NONE_MATCH, "\"reader-validator\""),
-            ] {
-                let stub = Arc::new(StubHttpClient::new());
-                let cache = Arc::new(MemoryTemplateCache::default());
-                let settings = Arc::new(settings_with_mode("esi"));
-                let services = services(Arc::clone(&stub), Arc::clone(&cache));
-                queue_shareable_html(&stub);
-                queue_shareable_html(&stub);
-
-                let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-                let mut revalidating = navigation_request();
-                revalidating
-                    .headers_mut()
-                    .insert(name.clone(), HeaderValue::from_static(value));
-                let _ = body_of(run(&settings, &services, revalidating).await).await;
-
-                assert_eq!(
-                    stub.recorded_request_uris().len(),
-                    2,
-                    "{name}: {value} must reach the origin even when template cache is warm"
-                );
-            }
-        }
-
-        fn header_of(response: &Response<EdgeBody>, name: header::HeaderName) -> Option<&str> {
-            response.headers().get(name).and_then(|v| v.to_str().ok())
-        }
-
-        /// The bid payload the seam actually embedded, decoded from the served page.
-        ///
-        /// Deliberately **not** written as the inverse of [`html_escape_for_script`]: the
-        /// escaper emits `\"`, `\\` and `\uXXXX`, which are all JSON string escapes, so
-        /// re-quoting the payload and handing it to `serde_json`'s own string parser
-        /// decodes it without this test agreeing with the encoder about anything.
-        ///
-        /// Panics rather than returning an error, because a served page with no decodable
-        /// bid payload is the failure under test and its diagnostics belong at the
-        /// assertion.
-        fn seam_bids(document: &str) -> serde_json::Map<String, serde_json::Value> {
-            const OPEN: &str = "var b=JSON.parse(\"";
-            // The seam's fixed shape. A bare `")` could occur inside the payload; this
-            // nine-byte terminator cannot.
-            const CLOSE: &str = "\");var s=";
-            let start = document
-                .find(OPEN)
-                .unwrap_or_else(|| panic!("the seam must carry a bids payload: {document}"));
-            let rest = &document[start + OPEN.len()..];
-            let end = rest
-                .find(CLOSE)
-                .unwrap_or_else(|| panic!("the bids payload must terminate: {document}"));
-            let unescaped: String = serde_json::from_str(&format!("\"{}\"", &rest[..end]))
-                .expect("the embedded payload should be a valid JSON string literal");
-            serde_json::from_str(&unescaped).expect("the embedded payload should be a JSON object")
-        }
-
-        #[test]
-        fn the_seam_payload_replaces_the_transform_owned_placeholder() {
-            let document =
-                format!(r#"<p>article</p>{TEMPLATE_SEAM_PLACEHOLDER}</body>"#).into_bytes();
 
-            let replaced = replace_seam_placeholder(document, b"<script>seam</script>")
-                .expect("should substitute the placeholder the transform emitted");
+            let response =
+                run_with_slots(&settings, &services, &[], conditional_navigation_request()).await;
+            let response_head = response_head(response);
 
+            assert_eq!(response_head.status, StatusCode::INTERNAL_SERVER_ERROR);
             assert_eq!(
-                replaced, br#"<p>article</p><script>seam</script></body>"#,
-                "should splice the payload exactly where the parser marked the body end"
+                response_head
+                    .headers
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("public, max-age=300"),
+                "failed publisher HTML must retain the origin cache policy"
             );
-        }
-
-        #[test]
-        fn a_body_close_written_in_script_data_does_not_attract_the_seam() {
-            // The reverse byte search this replaced picked the string literal, spliced a
-            // `<script>` payload into it, and the emitted `</script>` terminated the
-            // publisher's script — in the served page and in the stored template alike.
-            let document = format!(
-                r#"<script>const marker = "</body>";</script><p>article</p>{TEMPLATE_SEAM_PLACEHOLDER}"#
-            )
-            .into_bytes();
-
-            let replaced = replace_seam_placeholder(document, b"<script>seam</script>")
-                .expect("should substitute the placeholder the transform emitted");
-
             assert_eq!(
-                replaced,
-                br#"<script>const marker = "</body>";</script><p>article</p><script>seam</script>"#,
-                "should leave a body-close sequence inside script data untouched"
+                response_head.headers.get(header::ETAG),
+                Some(&HeaderValue::from_static(ORIGIN_ETAG)),
+                "failed publisher HTML must retain origin validators"
             );
         }
 
-        #[test]
-        fn a_publisher_copy_of_the_placeholder_refuses_substitution() {
-            let document = format!(
-                "<p>{TEMPLATE_SEAM_PLACEHOLDER}</p><body>article{TEMPLATE_SEAM_PLACEHOLDER}</body>"
-            )
-            .into_bytes();
-
-            let (returned, error) =
-                replace_seam_placeholder(document.clone(), b"<script>x</script>")
-                    .expect_err("should refuse a document that collides with the placeholder");
-
-            assert!(
-                matches!(error, SeamError::Repeated),
-                "should name the collision rather than guess an occurrence"
-            );
-            assert_eq!(
-                returned, document,
-                "should hand back the publisher document byte for byte"
+        #[tokio::test]
+        async fn inactive_html_post_preserves_origin_cache_policy() {
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
+            let stub = Arc::new(StubHttpClient::new());
+            queue_cacheable_html_response(&stub);
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
-        }
-
-        #[test]
-        fn a_document_without_the_placeholder_refuses_substitution() {
-            let document = b"<p>article</p></body>".to_vec();
+            let req = HttpRequest::builder()
+                .method(Method::POST)
+                .uri("https://ts.example.com/article")
+                .header(header::HOST, "ts.example.com")
+                .body(EdgeBody::empty())
+                .expect("should build publisher POST request");
 
-            let (returned, error) =
-                replace_seam_placeholder(document.clone(), b"<script>x</script>")
-                    .expect_err("should refuse a document the transform did not mark");
+            let response = run_with_slots(&settings, &services, &[], req).await;
+            let response_head = response_head(response);
 
-            assert!(
-                matches!(error, SeamError::Missing),
-                "should name the absent placeholder rather than append blindly"
-            );
+            assert_eq!(response_head.status, StatusCode::OK);
             assert_eq!(
-                returned, document,
-                "should hand back the document unchanged"
+                response_head
+                    .headers
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("public, max-age=300"),
+                "non-GET publisher HTML must retain the origin cache policy"
             );
         }
 
-        #[test]
-        fn parser_validation_does_not_change_the_cached_schema() {
-            assert_eq!(crate::platform::TEMPLATE_SCHEMA_VERSION, 4);
-            assert_eq!(AD_ASSEMBLY_SEAM, "<!--ts-ad-seam-->");
-            assert!(!contains_publisher_esi_directive(
-                AD_ASSEMBLY_SEAM.as_bytes()
-            ));
-        }
+        #[tokio::test]
+        async fn inactive_html_preserves_case_insensitive_private_origin_policy() {
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
 
-        /// Shareable HTML that already contains the seam marker.
-        ///
-        /// The marker is reserved, but publisher content can still contain it. The
-        /// transform adds its own terminal placeholder; repeated markers then make the
-        /// response bypass the template cache rather than requiring normalization.
-        fn queue_html_that_collides_with_the_marker(stub: &StubHttpClient) {
-            stub.push_response_with_headers(
-                200,
-                format!(
-                    "<html><head></head><body><script>window.publisherMarker=\
-                     \"{AD_ASSEMBLY_SEAM}\";</script><p>origin</p></body></html>"
-                )
-                .into_bytes(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                ],
-            );
-        }
+            for origin_policy in ["PuBlIc, PrIvAtE, max-age=300", "public, NO-STORE"] {
+                let stub = Arc::new(StubHttpClient::new());
+                stub.push_response_with_headers(
+                    200,
+                    b"<html><body>origin</body></html>".to_vec(),
+                    vec![
+                        ("content-type", "text/html; charset=utf-8"),
+                        ("cache-control", origin_policy),
+                    ],
+                );
+                let services = build_services_with_http_client(
+                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+                );
 
-        #[tokio::test]
-        async fn origin_marker_collision_bypasses_template_cache_without_mutating_publisher_bytes()
-        {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_html_that_collides_with_the_marker(&stub);
-            queue_html_that_collides_with_the_marker(&stub);
-
-            let cold = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("cold document should be UTF-8");
-            let warm = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("warm document should be UTF-8");
+                let response =
+                    run_with_slots(&settings, &services, &[], conditional_navigation_request())
+                        .await;
+                let response_head = response_head(response);
 
-            assert!(
-                cold.contains("origin") && cold.contains("window.tsjs"),
-                "a reserved-comment collision must not turn a valid origin 200 into a 500"
-            );
-            for document in [&cold, &warm] {
-                assert!(
-                    document.contains(&format!("window.publisherMarker=\"{AD_ASSEMBLY_SEAM}\"")),
-                    "should preserve a publisher marker inside script data: {document}"
+                assert_eq!(
+                    response_head
+                        .headers
+                        .get(header::CACHE_CONTROL)
+                        .and_then(|value| value.to_str().ok()),
+                    Some(origin_policy),
+                    "inactive HTML must preserve origin private/no-store directives"
                 );
             }
-            assert_eq!(stub.recorded_request_uris().len(), 2);
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "should not store a template with a publisher marker collision"
-            );
         }
 
         #[tokio::test]
-        async fn html_without_an_explicit_body_gets_a_terminal_seam_instead_of_a_500() {
+        async fn inactive_html_preserves_private_policy_on_a_repeated_header_line() {
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
             let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
             stub.push_response_with_headers(
                 200,
-                b"<div>origin fragment</div>".to_vec(),
+                b"<html><body>origin</body></html>".to_vec(),
                 vec![
                     ("content-type", "text/html; charset=utf-8"),
                     ("cache-control", "public, max-age=300"),
+                    ("cache-control", "PrIvAtE"),
                 ],
             );
-
-            let cold = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("cold fragment should be UTF-8");
-            let warm = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("warm fragment should be UTF-8");
-
-            for document in [&cold, &warm] {
-                assert!(document.contains("origin fragment"));
-                assert!(!document.contains(AD_ASSEMBLY_SEAM));
-            }
-            assert_eq!(stub.recorded_request_uris().len(), 1);
-            assert!(
-                !cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "the recovered template should remain cacheable"
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
-        }
-
-        #[tokio::test]
-        async fn an_unsplittable_cached_template_is_a_miss_before_any_header_commits() {
-            // The hit path used to check only that a marker existed *somewhere* and
-            // leave the exactly-one check to the finalizer. By then the 200 and its
-            // headers were committed and, on the streaming adapter, the document head
-            // was already on the wire — so the only available failure was a truncated
-            // response. Falling back to the origin is a slower correct page.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            // Fill the cache legitimately, then corrupt the stored body in place so the
-            // entry is found under exactly the key the next request derives.
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            {
-                let stored_key = cache
-                    .stored_keys
-                    .lock()
-                    .expect("should lock stored keys")
-                    .first()
-                    .cloned()
-                    .expect("the cold request should have stored a template");
-                let mut entries = cache.entries.lock().expect("should lock entries");
-                let entry = entries
-                    .get_mut(&stored_key.to_cache_key())
-                    .expect("the stored template should be readable");
-                entry.body = format!(
-                    "<html><head></head><body>origin{AD_ASSEMBLY_SEAM}\
-                     {AD_ASSEMBLY_SEAM}</body></html>"
-                )
-                .into_bytes();
-            }
 
-            // The fall-back must be able to reach the origin.
-            queue_shareable_html(&stub);
-            let response = run(&settings, &services, navigation_request()).await;
-            let status = response.status();
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("invalid"),
-                "an invalid-object recovery must be observable without exposing its key"
-            );
-            let served = String::from_utf8(body_of(response).await)
-                .expect("served document should be UTF-8");
+            let response =
+                run_with_slots(&settings, &services, &[], conditional_navigation_request()).await;
+            let response_head = response_head(response);
+            let policies = response_head
+                .headers
+                .get_all(header::CACHE_CONTROL)
+                .iter()
+                .map(|value| value.to_str().expect("cache policy should be ASCII"))
+                .collect::<Vec<_>>();
 
             assert_eq!(
-                status,
-                StatusCode::OK,
-                "the reader should get a complete page, not a committed-then-broken one"
-            );
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "an unusable entry must be treated as a miss and refetched"
-            );
-            assert!(
-                !served.contains(AD_ASSEMBLY_SEAM),
-                "no marker may survive into the served page: {served}"
-            );
-            assert!(
-                served.contains("window.tsjs"),
-                "and the fallback must still deliver the seam: {served}"
-            );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "an unusable fresh object must be purged instead of forcing inline fallback \
-                 until its TTL expires"
-            );
-        }
-
-        /// The schema version whose templates carried an executable ESI tag at the seam.
-        ///
-        /// Pinned as a literal rather than derived from [`TEMPLATE_SCHEMA_VERSION`]: the
-        /// point is that the current version is *not* this one, and a derived value
-        /// would move with it and assert nothing.
-        const ESI_INCLUDE_SCHEMA_VERSION: u32 = 1;
-
-        /// The exact schema-v1 marker retained only as a cache-compatibility fixture.
-        const LEGACY_ESI_INCLUDE: &str = "<esi:include src=\"/_ts/page-bids?format=fragment\"/>";
-
-        #[tokio::test]
-        async fn a_template_written_under_the_previous_schema_version_is_never_read() {
-            // v1 put an executable ESI include at the seam. v2 puts an inert comment
-            // there and hands slots to the scheduler, so a v1 entry has no marker this
-            // binary can find. `schema_version` is the only thing keeping the two apart
-            // — nothing purges template cache on deploy.
-            assert_ne!(
-                crate::platform::TEMPLATE_SCHEMA_VERSION,
-                ESI_INCLUDE_SCHEMA_VERSION,
-                "the seam marker changed shape, so the schema version must have moved \
-                 off the value under which the old marker was stored"
-            );
-
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            // Fill the cache the ordinary way, then plant a predecessor's entry
-            // alongside it: same request, previous schema version, previous marker.
-            // Re-keyed from the key the store actually used, so the fixture cannot
-            // drift from what the request derives.
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            {
-                let stored_key = cache
-                    .stored_keys
-                    .lock()
-                    .expect("should lock stored keys")
-                    .first()
-                    .cloned()
-                    .expect("the cold request should have stored a template");
-                let mut entries = cache.entries.lock().expect("should lock entries");
-                let mut predecessor = entries
-                    .get(&stored_key.to_cache_key())
-                    .cloned()
-                    .expect("the stored template should be readable");
-                predecessor.body =
-                    format!("<html><head></head><body>origin{LEGACY_ESI_INCLUDE}</body></html>")
-                        .into_bytes();
-                predecessor.metadata.schema_version = ESI_INCLUDE_SCHEMA_VERSION;
-                let mut old_key = stored_key;
-                old_key.schema_version = ESI_INCLUDE_SCHEMA_VERSION;
-                entries.insert(old_key.to_cache_key(), predecessor);
-            }
-
-            let served = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("served document should be UTF-8");
-
-            assert!(
-                cache
-                    .lookups
-                    .lock()
-                    .expect("should lock lookups")
-                    .iter()
-                    .all(|key| key.schema_version != ESI_INCLUDE_SCHEMA_VERSION),
-                "no lookup may name a schema version whose templates this binary cannot \
-                 assemble"
-            );
-            assert!(
-                !served.contains("<esi:"),
-                "a predecessor's template must never reach a reader: {served}"
+                policies,
+                ["public, max-age=300", "PrIvAtE"],
+                "a private directive on any origin header line must prevent the inactive rewrite"
             );
         }
 
         #[tokio::test]
-        async fn a_hit_for_opted_out_traffic_emits_no_seam_on_either_finalizer() {
-            // The miss path already honours this: `assemble_if_shared` emits nothing when
-            // the ad stack did not run. Both hit finalizers used `unwrap_or("[]")`
-            // instead, so a prefetch, a bot, a consent-denied reader, or every request
-            // under a disabled auction received a seam that still called
-            // `scheduleInitialAdInit` — scheduling `adInit` for exactly the traffic that
-            // opted out — as long as the template was already cached.
-            for finalizer in [Finalizer::Streaming, Finalizer::Buffered] {
+        async fn eligible_navigation_rejects_unexpected_origin_304() {
+            for content_type in [None, Some("text/html; charset=utf-8")] {
+                // Arrange
+                let settings = settings_with_dispatching_provider();
+                let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+                orchestrator.register_provider(Arc::new(DispatchingTestProvider));
+                let telemetry_sink = Arc::new(RecordingTelemetrySink::default());
                 let stub = Arc::new(StubHttpClient::new());
-                let cache = Arc::new(MemoryTemplateCache::default());
-                let settings = Arc::new(settings_with_mode("esi"));
-                let services = services(Arc::clone(&stub), Arc::clone(&cache));
-                queue_shareable_html(&stub);
-
-                // A normal navigation fills the cache; only then is a hit available for
-                // the opted-out request, which is the whole point — the gate held on the
-                // miss and was ignored on the hit.
-                let cold = String::from_utf8(
-                    body_of(run_via(&settings, &services, navigation_request(), finalizer).await)
-                        .await,
-                )
-                .expect("cold document should be UTF-8");
-                assert!(
-                    cold.contains("scheduleInitialAdInit"),
-                    "the fixture must produce a seam for ordinary traffic, or this test \
-                     passes for the wrong reason: {cold}"
+
+                // `send_async` consumes the first response before the publisher
+                // origin request consumes the second response.
+                stub.push_response(200, b"unused provider response".to_vec());
+                let mut origin_headers = vec![
+                    ("cache-control", "public, max-age=300"),
+                    ("etag", ORIGIN_ETAG),
+                    ("last-modified", ORIGIN_LAST_MODIFIED),
+                    ("surrogate-control", "max-age=300"),
+                    ("fastly-surrogate-control", "max-age=300"),
+                ];
+                if let Some(content_type) = content_type {
+                    origin_headers.push(("content-type", content_type));
+                }
+                stub.push_response_with_headers(304, Vec::new(), origin_headers);
+                let services = services_with_telemetry(
+                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
+                    Arc::clone(&telemetry_sink),
                 );
+                let slots = [article_slot()];
 
-                let served = String::from_utf8(
-                    body_of(
-                        run_via(
-                            &settings,
-                            &services,
-                            prefetch_navigation_request(),
-                            finalizer,
-                        )
-                        .await,
-                    )
-                    .await,
+                // Act
+                let response = run_with_orchestrator(
+                    &settings,
+                    &services,
+                    &orchestrator,
+                    &slots,
+                    conditional_navigation_request(),
                 )
-                .expect("served document should be UTF-8");
+                .await;
 
+                // Assert
+                let response = match response {
+                    PublisherResponse::Buffered(response) => response,
+                    PublisherResponse::PassThrough { .. }
+                    | PublisherResponse::Stream { .. }
+                    | PublisherResponse::AssembleTemplate { .. } => {
+                        panic!("unexpected origin 304 should return a buffered response")
+                    }
+                };
                 assert_eq!(
-                    stub.recorded_request_uris().len(),
-                    1,
-                    "the opted-out request must be a cache hit, or the hit finalizer is \
-                     never reached"
-                );
-                assert!(
-                    !served.contains("scheduleInitialAdInit"),
-                    "a reader whose ad stack did not run must not have `adInit` \
-                     scheduled: {served}"
-                );
-                assert!(
-                    !served.contains("t.adSlots="),
-                    "no slot assignment may reach opted-out traffic: {served}"
+                    response.status(),
+                    StatusCode::BAD_GATEWAY,
+                    "eligible origin 304 should fail closed with or without Content-Type"
                 );
-                assert!(
-                    !served.contains(AD_ASSEMBLY_SEAM),
-                    "the marker must still be consumed even when nothing replaces it: \
-                     {served}"
+                assert_eq!(
+                    response
+                        .headers()
+                        .get(header::CACHE_CONTROL)
+                        .and_then(|value| value.to_str().ok()),
+                    Some("private, no-store"),
+                    "eligible origin 304 should return an explicitly non-storable response"
                 );
                 assert!(
-                    served.contains("origin"),
-                    "the page itself must still be served: {served}"
+                    response
+                        .extensions()
+                        .get::<crate::response_privacy::TerminalPrivateResponse>()
+                        .is_some(),
+                    "invalid origin 304 response should remain private after late response effects"
                 );
-            }
-        }
-
-        #[tokio::test]
-        async fn a_winning_bid_reaches_the_page_on_both_the_miss_and_the_hit_path() {
-            // The fixture every other test here lacks. With no registered provider the
-            // auction always resolves to `{}`, so a seam that discarded every non-empty
-            // bid map looked identical to one that worked — which is precisely how the
-            // shared modes shipped serving zero bids.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_bidder("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-
-            // Bid first, page second: one FIFO queue, and the auction is dispatched
-            // before the origin fetch.
-            queue_bid_response(&stub);
-            queue_shareable_html(&stub);
-
-            let cold = String::from_utf8(
-                body_of(run_bidding(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("cold document should be UTF-8");
-            let cold_bids = seam_bids(&cold);
-            assert_eq!(
-                cold_bids
-                    .get("test-slot")
-                    .and_then(|bid| bid.get("hb_pb"))
-                    .and_then(serde_json::Value::as_str),
-                Some("3.50"),
-                "the miss path must deliver the winning bid's bucketed price, not an \
-                 empty map: {cold}"
-            );
-            assert_eq!(
-                cold_bids
-                    .get("test-slot")
-                    .and_then(|bid| bid.get("hb_bidder"))
-                    .and_then(serde_json::Value::as_str),
-                Some(STUB_BIDDER),
-                "the miss path must name the winning bidder: {cold}"
-            );
+                for header_name in [
+                    header::ETAG,
+                    header::LAST_MODIFIED,
+                    header::HeaderName::from_static("surrogate-control"),
+                    header::HeaderName::from_static("fastly-surrogate-control"),
+                ] {
+                    assert!(
+                        !response.headers().contains_key(&header_name),
+                        "eligible origin 304 should not forward {header_name}"
+                    );
+                }
 
-            // The warm request needs only the bid response: a hit skips the origin
-            // entirely, so an unused page fixture here would mask a fetch.
-            queue_bid_response(&stub);
-            let warm = String::from_utf8(
-                body_of(run_bidding(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("warm document should be UTF-8");
-            assert_eq!(
-                stub.recorded_request_uris()
+                let batches = telemetry_sink
+                    .batches
+                    .lock()
+                    .expect("should lock telemetry batches");
+                let summary_rows: Vec<_> = batches
                     .iter()
-                    .filter(|uri| uri.contains("/article"))
-                    .count(),
-                1,
-                "the warm request must be served from the template cache"
-            );
-            let warm_bids = seam_bids(&warm);
-            assert_eq!(
-                warm_bids
-                    .get("test-slot")
-                    .and_then(|bid| bid.get("hb_pb"))
-                    .and_then(serde_json::Value::as_str),
-                Some("3.50"),
-                "the hit path must deliver this reader's winning bid, not an empty \
-                 map: {warm}"
-            );
-            assert_eq!(
-                warm_bids, cold_bids,
-                "both paths must splice the same bids for the same auction"
-            );
+                    .flat_map(AuctionEventBatch::rows)
+                    .filter(|row| row.event_kind == "summary")
+                    .collect();
+                assert_eq!(
+                    summary_rows.len(),
+                    1,
+                    "unexpected origin 304 should emit exactly one summary row"
+                );
+                assert_eq!(
+                    summary_rows[0].terminal_status.as_deref(),
+                    Some("abandoned"),
+                    "unexpected origin 304 should abandon the dispatched auction"
+                );
+                assert_eq!(
+                    summary_rows[0].terminal_reason.as_deref(),
+                    Some("unexpected_origin_304"),
+                    "unexpected origin 304 should use the bounded telemetry reason"
+                );
+            }
         }
 
         #[tokio::test]
-        async fn max_age_zero_reload_reuses_a_warm_template_and_runs_a_fresh_auction() {
+        async fn ts_console_finalizes_session_on_replaced_origin_304_response() {
+            let mut settings = settings_with_enabled_auction_and_creative_opportunities();
+            settings
+                .integrations
+                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
+                .expect("should enable diagnostics");
             let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_bidder("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-
-            queue_bid_response(&stub);
-            queue_shareable_html(&stub);
-            let cold = run_bidding(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                cold.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("miss-stored")
-            );
-            let _ = body_of(cold).await;
-
-            // Keep an origin response available so the old bypass behavior completes
-            // normally and fails on the observable cache state rather than a fixture
-            // underflow. A correct warm reload leaves this response untouched.
-            queue_bid_response(&stub);
-            queue_shareable_html(&stub);
-            let mut reload = navigation_request();
-            reload
-                .headers_mut()
-                .insert(header::CACHE_CONTROL, HeaderValue::from_static("max-age=0"));
-            let warm = run_bidding(&settings, &services, reload).await;
-            assert_eq!(
-                warm.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("hit"),
-                "a browser reload must re-run per-reader assembly without refetching the \
-                 reader-neutral template"
+            stub.push_response_with_headers(
+                304,
+                Vec::new(),
+                vec![
+                    ("cache-control", "public, max-age=300"),
+                    ("etag", ORIGIN_ETAG),
+                ],
             );
-            assert_eq!(
-                warm.headers()
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, no-store"),
-                "reusing template cache must not make the assembled response browser-cacheable"
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
             );
-            let warm = String::from_utf8(body_of(warm).await)
-                .expect("warm reload document should be UTF-8");
+            let slots = [article_slot()];
+            let mut req = conditional_navigation_request();
+            *req.uri_mut() = "https://ts.example.com/article?keep=1&ts_console=1"
+                .parse()
+                .expect("should parse activation URI");
+
+            let response = run_with_slots(&settings, &services, &slots, req).await;
+            let response = match response {
+                PublisherResponse::Buffered(response) => response,
+                PublisherResponse::PassThrough { .. }
+                | PublisherResponse::Stream { .. }
+                | PublisherResponse::AssembleTemplate { .. } => {
+                    panic!("unexpected origin 304 should return a buffered response")
+                }
+            };
 
-            let requests = stub.recorded_request_uris();
+            assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
             assert_eq!(
-                requests
-                    .iter()
-                    .filter(|uri| uri.contains("/article"))
-                    .count(),
-                1,
-                "the reload must reuse the warm article template"
+                response.headers()[header::SET_COOKIE],
+                "__Host-ts-console=1; Path=/; Secure; HttpOnly; SameSite=Lax"
             );
             assert_eq!(
-                stub.recorded_backend_names()
-                    .iter()
-                    .filter(|backend| backend.as_str() == "stub-bidder-backend")
-                    .count(),
-                2,
-                "each navigation must dispatch its own auction even when template cache hits"
+                response.headers()[header::CACHE_CONTROL],
+                "private, no-store"
             );
             assert_eq!(
-                seam_bids(&warm)
-                    .get("test-slot")
-                    .and_then(|bid| bid.get("hb_pb"))
-                    .and_then(serde_json::Value::as_str),
-                Some("3.50"),
-                "the reload's auction result must reach the assembled seam"
+                stub.recorded_request_uris(),
+                vec!["https://origin.test-publisher.com/article?keep=1"]
             );
         }
 
         #[tokio::test]
-        async fn the_marker_never_reaches_the_browser_on_either_path() {
-            // The user-visible failure this whole chain exists to avoid: a page that
-            // returns 200, parses fine, renders no ads, and reports no error, because
-            // the legacy executable ESI tag was served literally.
-            //
-            // Both paths are checked. The miss path assembles after the transform; the
-            // hit path assembles after reading the cache. They are separate call sites
-            // and only one of them running would still look like success on the other.
+        async fn noneligible_origin_304_preserves_conditional_response_metadata() {
+            // Arrange
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
             let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
+            stub.push_response_with_headers(
+                304,
+                Vec::new(),
+                vec![
+                    ("cache-control", "public, max-age=300"),
+                    ("etag", ORIGIN_ETAG),
+                    ("last-modified", ORIGIN_LAST_MODIFIED),
+                    ("surrogate-control", "max-age=300"),
+                    ("fastly-surrogate-control", "max-age=300"),
+                ],
+            );
+            let services = build_services_with_http_client(
+                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+            );
 
-            let cold = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("cold response should be utf-8");
-            let warm = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("warm response should be utf-8");
+            // Act
+            let response =
+                run_with_slots(&settings, &services, &[], conditional_navigation_request()).await;
 
+            // Assert
+            let response = match response {
+                PublisherResponse::Buffered(response) => response,
+                PublisherResponse::PassThrough { .. }
+                | PublisherResponse::Stream { .. }
+                | PublisherResponse::AssembleTemplate { .. } => {
+                    panic!("noneligible origin 304 should remain buffered")
+                }
+            };
             assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the second request must be a hit, or this only tests one path"
+                response.status(),
+                StatusCode::NOT_MODIFIED,
+                "inactive server-side ad templates should preserve the 304 status"
             );
-            for (label, document) in [("miss", &cold), ("hit", &warm)] {
-                assert!(
-                    !document.contains(AD_ASSEMBLY_SEAM),
-                    "{label}: an unresolved marker reached the browser: {document}"
-                );
-                assert!(
-                    document.contains("window.tsjs"),
-                    "{label}: assembly must leave a bids script behind: {document}"
+            assert_eq!(
+                response
+                    .headers()
+                    .get(header::CACHE_CONTROL)
+                    .and_then(|value| value.to_str().ok()),
+                Some("private, max-age=60"),
+                "inactive server-side ad templates should apply the browser policy on revalidation"
+            );
+            for (header_name, expected) in [
+                (header::ETAG, ORIGIN_ETAG),
+                (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
+                (
+                    header::HeaderName::from_static("surrogate-control"),
+                    "max-age=300",
+                ),
+                (
+                    header::HeaderName::from_static("fastly-surrogate-control"),
+                    "max-age=300",
+                ),
+            ] {
+                assert_eq!(
+                    response
+                        .headers()
+                        .get(&header_name)
+                        .and_then(|value| value.to_str().ok()),
+                    Some(expected),
+                    "inactive server-side ad templates should preserve {header_name} on revalidation"
                 );
             }
-        }
-
-        #[tokio::test]
-        async fn the_cached_template_holds_the_marker_and_never_the_bids() {
-            // Store the reader-neutral template before assembling the final per-user
-            // response, which must never enter the forbidden C3 cache. If
-            // these were swapped, the cache would hold one visitor's bids and serve them
-            // to the next — and every test above would still pass, because the served
-            // page would look correct.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let _ = run(&settings, &services, navigation_request()).await;
-
-            let entries = cache.entries.lock().expect("should lock entries");
-            let stored = entries
-                .values()
-                .next()
-                .expect("a template should be stored");
-            let template = core::str::from_utf8(&stored.body).expect("template should be utf-8");
-
-            assert!(
-                template.contains(AD_ASSEMBLY_SEAM),
-                "the cached template must still carry the unresolved marker: {template}"
-            );
-            assert!(
-                !template.contains("window.tsjs"),
-                "the cached template must not carry a bids script: {template}"
+            assert_eq!(
+                stub.recorded_cache_bypass_flags(),
+                vec![false],
+                "noneligible publisher navigation should use the default cache mode"
             );
-        }
-
-        #[tokio::test]
-        async fn a_transform_that_overruns_its_buffer_stores_nothing() {
-            // The 16 MB cap in production, shrunk here. A partial template in template cache is the
-            // worst outcome available: it would be served to every subsequent visitor as
-            // a truncated document, indefinitely, with no error after the first request.
-            //
-            // Safe by construction — the cap error propagates before the store runs — but
-            // "by construction" is exactly the kind of claim that stops being true after
-            // an unrelated refactor moves one line.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut raw = settings_with_mode("esi");
-            raw.publisher.max_buffered_body_bytes = 8;
-            let settings = Arc::new(raw);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-            let registry =
-                IntegrationRegistry::new(&settings).expect("should create integration registry");
-            let consent = crate::consent::ConsentContext {
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                ..Default::default()
-            };
-            let mut ec_context = EcContext::new_for_test(None, consent);
-            let publisher_response = handle_publisher_request(
-                &settings,
-                &services,
-                None,
-                &mut ec_context,
-                AuctionDispatch {
-                    orchestrator: &orchestrator,
-                    slots: &[article_slot()],
-                    registry: None,
-                },
-                navigation_request(),
-                EdgeCacheHeader::SMaxageFallback,
-            )
-            .await
-            .expect("the request itself should succeed; the cap trips during streaming");
-
-            let result = publisher_response_into_streaming_response(
-                publisher_response,
-                &Method::GET,
-                Arc::clone(&settings),
-                &registry,
-                orchestrator,
-                services.clone(),
-            )
-            .await;
-
-            assert!(
-                result.is_err(),
-                "overrunning the buffer must fail rather than truncate"
+            let recorded_requests = stub.recorded_request_headers();
+            let outbound_headers = recorded_requests
+                .first()
+                .expect("should record the outbound publisher request");
+            assert_eq!(
+                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
+                Some(ORIGIN_ETAG),
+                "noneligible publisher request should preserve If-None-Match"
             );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "a failed transform must leave nothing in the shared cache"
+            assert_eq!(
+                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
+                Some(ORIGIN_LAST_MODIFIED),
+                "noneligible publisher request should preserve If-Modified-Since"
             );
         }
 
         #[tokio::test]
-        async fn a_cache_hit_is_never_shared_cacheable() {
-            // Asserted positively, because the obvious negative check does not work.
-            // Forbidding `public`, `s-maxage` and `Surrogate-Control` passes trivially
-            // on a response that carries no `Cache-Control` at all — and *that* is the
-            // real failure mode here, since a template cache hit returns before the point where the
-            // publisher path stamps the response private. HTML with no `Cache-Control`
-            // is heuristically cacheable, so "nothing to forbid" is not safety.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
+        async fn inactive_ad_stack_304_preserves_private_origin_cache_policy() {
+            let settings = settings_with_enabled_auction_and_creative_opportunities();
 
-            let _cold = run(&settings, &services, navigation_request()).await;
-            let warm = run(&settings, &services, navigation_request()).await;
+            for cache_control in ["private, max-age=0", "No-Store"] {
+                // Arrange
+                let stub = Arc::new(StubHttpClient::new());
+                stub.push_response_with_headers(
+                    304,
+                    Vec::new(),
+                    vec![("cache-control", cache_control), ("etag", ORIGIN_ETAG)],
+                );
+                let services = build_services_with_http_client(
+                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+                );
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the second request must be a hit, or this asserts nothing"
-            );
-            assert_eq!(
-                header_of(&warm, header::CACHE_CONTROL),
-                Some("private, no-store"),
-                "an assembled response is per-user even when its template is not"
-            );
+                // Act
+                let response =
+                    run_with_slots(&settings, &services, &[], conditional_navigation_request())
+                        .await;
+                let response_head = response_head(response);
 
-            // Validators would let a client revalidate into a shared copy, and the CDN
-            // directives would instruct an intermediary to store one outright. The
-            // origin fixture sends a `public, max-age=300` that must not survive.
-            for stripped in [header::ETAG, header::LAST_MODIFIED, header::EXPIRES] {
+                // Assert
                 assert_eq!(
-                    header_of(&warm, stripped.clone()),
-                    None,
-                    "{stripped} must not survive onto an assembled response"
+                    response_head
+                        .headers
+                        .get(header::CACHE_CONTROL)
+                        .and_then(|value| value.to_str().ok()),
+                    Some(cache_control),
+                    "inactive server-side ad templates should preserve origin {cache_control} policy on revalidation"
                 );
             }
         }
+    }
 
-        #[tokio::test]
-        async fn a_returning_visitor_gets_the_same_privacy_headers() {
-            // The case with no backstop. A first-visit response sets an EC cookie, so
-            // the adapter's cookie-privacy net force-privatizes it regardless of what
-            // this path does. A returning visitor sets no cookie, so that net never
-            // fires and this path is the only thing standing between an assembled
-            // per-user document and a shared cache.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let _cold = run(&settings, &services, navigation_request()).await;
-            let warm = run(&settings, &services, navigation_request()).await;
-
-            assert!(
-                header_of(&warm, header::SET_COOKIE).is_none(),
-                "no cookie here means no privacy net, which is the point of this test"
-            );
-            assert_eq!(
-                header_of(&warm, header::CACHE_CONTROL),
-                Some("private, no-store")
-            );
-        }
-
-        /// Geo that reports a fixed, recognizable location.
-        ///
-        /// A distinct value per synthetic user, so a geo leak into the template shows up
-        /// as a substring rather than requiring inference.
-        struct StubGeo(&'static str);
+    #[tokio::test]
+    async fn publisher_asset_cache_policy_applies_to_non_html_response() {
+        let settings = Settings::from_toml(&format!(
+            r#"{}
 
-        impl crate::platform::PlatformGeo for StubGeo {
-            fn lookup(
-                &self,
-                _client_ip: Option<std::net::IpAddr>,
-            ) -> Result<Option<GeoInfo>, Report<crate::platform::PlatformError>> {
-                Ok(Some(GeoInfo {
-                    city: self.0.to_string(),
-                    country: self.0.to_string(),
-                    continent: self.0.to_string(),
-                    latitude: 1.0,
-                    longitude: 2.0,
-                    metro_code: 3,
-                    region: Some(self.0.to_string()),
-                    asn: Some(4),
-                }))
-            }
-        }
-
-        /// One synthetic user: an identity, a consent posture, and a location.
-        struct SyntheticUser {
-            ec_id: &'static str,
-            jurisdiction: crate::consent::jurisdiction::Jurisdiction,
-            geo_marker: &'static str,
-        }
+            [[cache.asset_rules]]
+            id = "publisher-fingerprinted-assets"
+            enabled = true
+            path_globs = ["/assets/**/*.png"]
+            fingerprint_style = "hex"
+            visibility = "public"
+            browser_ttl_seconds = 31536000
+            edge_ttl_seconds = 31536000
+            immutable = true
+        "#,
+            crate_test_settings_str()
+        ))
+        .expect("should parse settings with cache rule");
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"png".to_vec(),
+            vec![
+                (header::CONTENT_TYPE.as_str(), "image/png"),
+                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/assets/logo.0123abcd.png")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-        /// Runs one synthetic user against a fresh cache and returns the stored template.
-        ///
-        /// Fresh cache per user deliberately: the point is to compare what each *would*
-        /// store, so sharing a cache would let the first user's entry answer for the
-        /// second and the comparison would prove nothing.
-        async fn stored_template_for(user: &SyntheticUser) -> Vec<u8> {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = RuntimeServices::builder()
-                .config_store(Arc::new(NoopConfigStore))
-                .secret_store(Arc::new(NoopSecretStore))
-                .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
-                .backend(Arc::new(StubBackend))
-                .http_client(Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>)
-                .geo(Arc::new(StubGeo(user.geo_marker)))
-                .client_info(ClientInfo::default())
-                .template_cache(
-                    Arc::clone(&cache) as Arc<dyn crate::platform::PlatformTemplateCache>
-                )
-                .build();
-            queue_shareable_html(&stub);
+        let response = run_publisher_proxy(&settings, &services, request).await;
+        let PublisherResponse::PassThrough { response, .. } = response else {
+            panic!("should pass through non-HTML asset response");
+        };
 
-            let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-            let registry =
-                IntegrationRegistry::new(&settings).expect("should create integration registry");
-            let consent = crate::consent::ConsentContext {
-                jurisdiction: user.jurisdiction.clone(),
-                ..Default::default()
-            };
-            let mut ec_context = EcContext::new_for_test(Some(user.ec_id.to_string()), consent);
-            let publisher_response = handle_publisher_request(
-                &settings,
-                &services,
-                None,
-                &mut ec_context,
-                AuctionDispatch {
-                    orchestrator: &orchestrator,
-                    slots: &[article_slot()],
-                    registry: None,
-                },
-                navigation_request(),
-                EdgeCacheHeader::SMaxageFallback,
-            )
-            .await
-            .expect("should proxy publisher request");
-            let _ = publisher_response_into_streaming_response(
-                publisher_response,
-                &Method::GET,
-                Arc::clone(&settings),
-                &registry,
-                orchestrator,
-                services.clone(),
-            )
-            .await
-            .expect("should finalize publisher response");
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CACHE_CONTROL)
+                .and_then(|value| value.to_str().ok()),
+            Some("public, max-age=31536000, s-maxage=31536000, immutable"),
+            "matched publisher asset should receive immutable browser and edge policy"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get("surrogate-control")
+                .and_then(|value| value.to_str().ok()),
+            None,
+            "S-maxage fallback should keep the edge TTL in Cache-Control"
+        );
+    }
 
-            let entries = cache.entries.lock().expect("should lock entries");
-            entries
-                .values()
-                .next()
-                .expect("a template should have been stored")
-                .body
-                .clone()
-        }
+    #[tokio::test]
+    async fn publisher_asset_policy_response_with_cookie_is_private_after_finalization() {
+        let settings = Settings::from_toml(&format!(
+            r#"{}
 
-        #[tokio::test]
-        async fn two_users_differing_in_identity_consent_and_geo_store_the_same_template() {
-            // The gate the whole design rests on. The template is shared between
-            // visitors, so anything request-scoped that reaches it is one visitor's data
-            // served to the next. Byte-identity is the assertion because it does not
-            // depend on guessing which field might leak.
-            let alice = SyntheticUser {
-                ec_id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.alice1",
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                geo_marker: "AliceCity",
-            };
-            let bob = SyntheticUser {
-                ec_id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.bobbb1",
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::Gdpr,
-                geo_marker: "BobCity",
-            };
+            [[cache.asset_rules]]
+            id = "publisher-fingerprinted-assets"
+            enabled = true
+            path_globs = ["/assets/**/*.png"]
+            fingerprint_style = "hex"
+            visibility = "public"
+            browser_ttl_seconds = 31536000
+            edge_ttl_seconds = 31536000
+            immutable = true
+        "#,
+            crate_test_settings_str()
+        ))
+        .expect("should parse settings with cache rule");
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"png".to_vec(),
+            vec![
+                (header::CONTENT_TYPE.as_str(), "image/png"),
+                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
+                (header::SET_COOKIE.as_str(), "viewer=example; Path=/"),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/assets/logo.0123abcd.png")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-            let alice_template = stored_template_for(&alice).await;
-            let bob_template = stored_template_for(&bob).await;
+        let response = run_publisher_proxy(&settings, &services, request).await;
+        let PublisherResponse::PassThrough { mut response, .. } = response else {
+            panic!("should pass through non-HTML asset response");
+        };
+        crate::response_privacy::apply_response_headers_with_cache_privacy(
+            &settings,
+            &mut response,
+        );
 
-            assert_eq!(
-                alice_template, bob_template,
-                "two users differing in identity, consent and geo must produce the same \
-                 shared template"
-            );
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CACHE_CONTROL)
+                .and_then(|value| value.to_str().ok()),
+            Some("private, max-age=0"),
+            "publisher asset with Set-Cookie must become private after finalization"
+        );
+        assert!(
+            response.headers().get("surrogate-control").is_none(),
+            "publisher asset with Set-Cookie must not retain a shared-cache header"
+        );
+    }
 
-            // Belt and braces: byte-identity would also hold if *both* templates leaked
-            // the same wrong thing, so name the values that must be absent.
-            let template = String::from_utf8(alice_template).expect("template should be utf-8");
-            for forbidden in [
-                alice.ec_id,
-                bob.ec_id,
-                alice.geo_marker,
-                bob.geo_marker,
-                "adSlots",
-                "window.tsjs",
-            ] {
-                assert!(
-                    !template.contains(forbidden),
-                    "`{forbidden}` must not appear in a shared template: {template}"
-                );
-            }
-        }
+    #[tokio::test]
+    async fn publisher_asset_cache_policy_skips_html_response() {
+        let settings = Settings::from_toml(&format!(
+            r#"{}
 
-        #[tokio::test]
-        async fn inline_mode_never_reads_or_writes_the_cache() {
-            // The shipped path. If this ever cached, per-user ad state would be shared
-            // between visitors — the exact failure the whole design exists to avoid.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("inline"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+            [[cache.asset_rules]]
+            id = "broad-publisher-path"
+            enabled = true
+            path_glob = "/news/*.html"
+            visibility = "public"
+            browser_ttl_seconds = 31536000
+            edge_ttl_seconds = 31536000
+            immutable = true
+            fingerprint_style = "hex"
+        "#,
+            crate_test_settings_str()
+        ))
+        .expect("should parse settings with cache rule");
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><body>news</body></html>".to_vec(),
+            vec![
+                (header::CONTENT_TYPE.as_str(), "text/html; charset=utf-8"),
+                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/news/story.0123abcd.html")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-            let _ = run(&settings, &services, navigation_request()).await;
-            let _ = run(&settings, &services, navigation_request()).await;
+        let response = run_publisher_proxy(&settings, &services, request).await;
+        let response = match response {
+            PublisherResponse::Stream { response, .. } | PublisherResponse::Buffered(response) => {
+                response
+            }
+            PublisherResponse::PassThrough { .. } | PublisherResponse::AssembleTemplate { .. } => {
+                panic!("should classify HTML response for processing")
+            }
+        };
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "inline must fetch the origin every time"
-            );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "inline must never write a shared template"
-            );
-        }
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CACHE_CONTROL)
+                .and_then(|value| value.to_str().ok()),
+            Some("public, max-age=60"),
+            "asset policy must not apply shared asset caching to publisher HTML"
+        );
+        assert!(
+            response.headers().get("surrogate-control").is_none(),
+            "HTML response must not receive a shared-cache header"
+        );
+    }
 
-        /// [`settings_with_mode`], with one integration configured a stated way.
-        ///
-        /// Edits the parsed `[integrations]` map rather than appending TOML, so two
-        /// fixtures differ in exactly the field under test.
-        fn settings_with_prebid_timeout(mode: &str, timeout_ms: u32) -> Settings {
-            let mut settings = settings_with_mode(mode);
-            settings.integrations.insert(
-                "prebid".to_string(),
-                serde_json::json!({
-                    "enabled": true,
-                    "external_bundle_url": "https://assets.example.com/prebid/bundle.js",
-                    "timeout_ms": timeout_ms,
-                }),
-            );
-            settings
-        }
+    #[tokio::test]
+    async fn publisher_request_uses_platform_http_client_with_http_types() {
+        let settings = create_test_settings();
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response(200, b"origin response".to_vec());
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/page")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-        /// Every key the cache was asked to store, rendered.
-        fn stored_cache_keys(cache: &MemoryTemplateCache) -> Vec<String> {
-            cache
-                .stored_keys
-                .lock()
-                .expect("should lock stored keys")
-                .iter()
-                .map(crate::platform::TemplateCacheKey::to_cache_key)
-                .collect()
-        }
+        let response = match run_publisher_proxy(&settings, &services, req).await {
+            PublisherResponse::Buffered(r) => r,
+            PublisherResponse::PassThrough { mut response, body } => {
+                *response.body_mut() = body;
+                response
+            }
+            PublisherResponse::Stream { response, .. }
+            | PublisherResponse::AssembleTemplate { response, .. } => response,
+        };
 
-        /// Every key the cache was asked to read, rendered.
-        fn looked_up_cache_keys(cache: &MemoryTemplateCache) -> Vec<String> {
-            cache
-                .lookups
-                .lock()
-                .expect("should lock lookups")
-                .iter()
-                .map(crate::platform::TemplateCacheKey::to_cache_key)
-                .collect()
-        }
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(response_body_string(response), "origin response");
+        assert_eq!(
+            stub.recorded_backend_names(),
+            vec!["stub-backend".to_string()],
+            "should proxy through the platform http client"
+        );
+    }
 
-        #[tokio::test]
-        async fn two_integration_configurations_never_share_a_template() {
-            // `template_fingerprint` folds the complete typed config, and its own
-            // tests call it directly — so reverting the *call site* back to the
-            // bundle-only hash, a constant for a given binary, left the entire suite
-            // green while every configuration silently shared one template.
-            //
-            // This drives the real request path and asserts on the keys the cache was
-            // actually handed, which is the only place that mutation is visible.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            let first = Arc::new(settings_with_prebid_timeout("esi", 1000));
-            let second = Arc::new(settings_with_prebid_timeout("esi", 2500));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+    #[tokio::test]
+    async fn aps_enabled_publisher_response_appends_an_independent_frame_policy() {
+        let mut settings = create_test_settings();
+        enable_aps_auction_plan(&mut settings);
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><head></head><body>origin</body></html>".to_vec(),
+            vec![
+                ("content-type", "text/html; charset=utf-8"),
+                (
+                    "content-security-policy",
+                    "default-src 'self'; frame-ancestors https://operator.example",
+                ),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/article")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build publisher request");
+
+        let response = run_publisher_proxy(&settings, &services, request).await;
+        let headers = match response {
+            PublisherResponse::Buffered(response)
+            | PublisherResponse::PassThrough { response, .. }
+            | PublisherResponse::Stream { response, .. }
+            | PublisherResponse::AssembleTemplate { response, .. } => {
+                response.into_parts().0.headers
+            }
+        };
+        let policies = headers
+            .get_all(header::CONTENT_SECURITY_POLICY)
+            .iter()
+            .map(|value| value.to_str().expect("policy should be ASCII"))
+            .collect::<Vec<_>>();
 
-            let _ = run(&first, &services, navigation_request()).await;
-            let _ = run(&second, &services, navigation_request()).await;
+        assert_eq!(
+            policies,
+            [
+                "default-src 'self'; frame-ancestors https://operator.example",
+                "frame-ancestors 'self'",
+            ],
+            "APS framing policy should append after and intersect operator policy"
+        );
+    }
 
-            let stored = stored_cache_keys(&cache);
-            assert_eq!(
-                stored.len(),
-                2,
-                "each configuration must store its own template, got {stored:?}"
-            );
-            assert_ne!(
-                stored[0], stored[1],
-                "two `[integrations]` configurations must key different templates; one key \
-                 serves the first configuration's injected markup to the second"
-            );
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "the second configuration must have missed and fetched the origin rather \
-                 than reading the first's template"
-            );
-        }
+    #[tokio::test]
+    async fn aps_disabled_publisher_response_does_not_add_a_frame_policy() {
+        let mut settings = create_test_settings();
+        enable_aps_auction_plan(&mut settings);
+        settings.auction.enabled = false;
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><head></head><body>origin</body></html>".to_vec(),
+            vec![
+                ("content-type", "text/html; charset=utf-8"),
+                ("content-security-policy", "default-src 'self'"),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let request = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/article")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build publisher request");
 
-        #[tokio::test]
-        async fn one_integration_configuration_keys_one_template() {
-            // The converse, and the failure mode a fingerprint fix can introduce:
-            // over-invalidating is as total as under-invalidating. A fingerprint that
-            // moves between two equal configurations is a cache that never hits, which
-            // the spike would report as "no measurable benefit" rather than as a bug.
-            //
-            // The two `Settings` are parsed independently, so their `[integrations]`
-            // maps iterate in different orders — which is what exercises the sort.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            let first = Arc::new(settings_with_prebid_timeout("esi", 1000));
-            let second = Arc::new(settings_with_prebid_timeout("esi", 1000));
-            queue_shareable_html(&stub);
+        let response = run_publisher_proxy(&settings, &services, request).await;
+        let headers = match response {
+            PublisherResponse::Buffered(response)
+            | PublisherResponse::PassThrough { response, .. }
+            | PublisherResponse::Stream { response, .. }
+            | PublisherResponse::AssembleTemplate { response, .. } => {
+                response.into_parts().0.headers
+            }
+        };
+        let policies = headers
+            .get_all(header::CONTENT_SECURITY_POLICY)
+            .iter()
+            .map(|value| value.to_str().expect("policy should be ASCII"))
+            .collect::<Vec<_>>();
 
-            let _ = run(&first, &services, navigation_request()).await;
-            let _ = run(&second, &services, navigation_request()).await;
+        assert_eq!(policies, ["default-src 'self'"]);
+    }
 
-            let looked_up = looked_up_cache_keys(&cache);
-            assert_eq!(
-                looked_up.len(),
-                2,
-                "both requests must consult the cache, got {looked_up:?}"
-            );
-            assert_eq!(
-                looked_up[0], looked_up[1],
-                "equal configurations must name one key, or the cache never hits"
-            );
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the second request must be served from the first's template"
-            );
-        }
+    #[tokio::test]
+    async fn ts_console_publisher_pipeline_strips_reserved_input_and_finalizes_session() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
+            .expect("should enable diagnostics");
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><head></head><body>origin</body></html>".to_vec(),
+            vec![
+                ("content-type", "text/html; charset=utf-8"),
+                ("cache-control", "public, max-age=300"),
+                ("surrogate-control", "max-age=300"),
+            ],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/article?keep=%2F&ts_console=true")
+            .header(header::HOST, "publisher.example")
+            .header("sec-fetch-dest", "document")
+            .header(
+                header::COOKIE,
+                "other=value; __Host-ts-console=1; second=two",
+            )
+            .body(EdgeBody::empty())
+            .expect("should build diagnostics navigation");
 
-        fn cookie_navigation_request() -> Request<EdgeBody> {
-            HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .header("sec-fetch-mode", "navigate")
-                .header(header::COOKIE, "ts-ec=abc123")
-                .body(EdgeBody::empty())
-                .expect("should build cookie-bearing request")
-        }
+        let response = run_publisher_proxy(&settings, &services, req).await;
+        let headers = match response {
+            PublisherResponse::Buffered(response)
+            | PublisherResponse::PassThrough { response, .. }
+            | PublisherResponse::Stream { response, .. }
+            | PublisherResponse::AssembleTemplate { response, .. } => {
+                response.into_parts().0.headers
+            }
+        };
 
-        #[tokio::test]
-        async fn by_default_a_cookie_bearing_request_uses_no_shared_cache() {
-            // The shipped default, and the reason the cache is nearly inert on real
-            // traffic: TS sets its own identity cookie, so essentially every repeat
-            // visitor arrives carrying one and is excluded in both directions.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+        let origin_uri = stub
+            .recorded_request_uris()
+            .into_iter()
+            .next()
+            .expect("should forward one publisher request");
+        assert!(origin_uri.contains("keep=%2F"));
+        assert!(!origin_uri.contains("ts_console"));
+        let outbound_headers = stub.recorded_request_headers();
+        let outbound_cookies = outbound_headers
+            .first()
+            .expect("should record publisher request headers")
+            .iter()
+            .filter(|(name, _)| name.eq_ignore_ascii_case(header::COOKIE.as_str()))
+            .map(|(_, value)| value.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(outbound_cookies, vec!["other=value; second=two"]);
+        assert_eq!(
+            headers[header::SET_COOKIE],
+            "__Host-ts-console=1; Path=/; Secure; HttpOnly; SameSite=Lax"
+        );
+        assert_eq!(headers[header::CACHE_CONTROL], "private, no-store");
+        assert!(!headers.contains_key("surrogate-control"));
+    }
 
-            let _ = run(&settings, &services, cookie_navigation_request()).await;
-            let _ = run(&settings, &services, cookie_navigation_request()).await;
+    #[tokio::test]
+    async fn ts_console_publisher_pipeline_duplicate_and_invalid_fail_closed_but_clean_url() {
+        for uri in [
+            "https://publisher.example/article?keep=a%2Fb&ts_console=1&ts_console=true",
+            "https://publisher.example/article?ts_console=True&keep=a%2Fb",
+        ] {
+            let result = run_ts_console_pipeline(
+                Method::GET,
+                "document",
+                uri,
+                Some("__Host-ts-console=1; publisher=value"),
+            )
+            .await;
+            let body = response_body_string(result.response);
 
             assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "both requests must reach the origin"
-            );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "and neither may store a template"
+                result.origin_uri,
+                "https://origin.test-publisher.com/article?keep=a%2Fb"
             );
+            assert_eq!(result.outbound_cookie.as_deref(), Some("publisher=value"));
+            assert!(!boot_gpt_diagnostics_active(&body));
+            assert!(!body.contains("tsjs-gpt_diagnostics.min.js"));
+            assert!(!body.contains("tsjs-gpt_diagnostics-bootstrap.min.js"));
+            assert_eq!(body.matches("history.replaceState").count(), 1);
         }
+    }
 
-        #[tokio::test]
-        async fn a_declared_cookie_independent_origin_lets_repeat_visitors_share() {
-            // The opt-in. Without it the spike can only ever measure first-ever page
-            // views, which is not the population the issue cares about.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut raw = settings_with_mode("esi");
-            raw.creative_opportunities
-                .as_mut()
-                .expect("fixture configures creative opportunities")
-                .origin_is_cookie_independent = Some(true);
-            let settings = Arc::new(raw);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+    #[tokio::test]
+    async fn ts_console_publisher_pipeline_cookie_session_and_disable_are_exact() {
+        let active = run_ts_console_pipeline(
+            Method::GET,
+            "document",
+            "https://publisher.example/article?keep=%2F",
+            Some("publisher=value; __Host-ts-console=1"),
+        )
+        .await;
+        let active_body = response_body_string(active.response);
+        assert_eq!(active.outbound_cookie.as_deref(), Some("publisher=value"));
+        assert!(boot_gpt_diagnostics_active(&active_body));
+        assert!(active_body.contains("tsjs-unified.min.js?v="));
+        assert!(!active_body.contains("tsjs-gpt_diagnostics.min.js"));
+        assert!(!active_body.contains("tsjs-gpt_diagnostics-bootstrap.min.js"));
+        assert!(!active_body.contains("history.replaceState"));
+
+        let disabled = run_ts_console_pipeline(
+            Method::GET,
+            "document",
+            "https://publisher.example/article?ts_console=false&keep=%2F",
+            Some("publisher=value; __Host-ts-console=1"),
+        )
+        .await;
+        assert_eq!(
+            disabled.response.headers()[header::SET_COOKIE],
+            "__Host-ts-console=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0"
+        );
+        assert_eq!(
+            disabled.origin_uri,
+            "https://origin.test-publisher.com/article?keep=%2F"
+        );
+        let disabled_body = response_body_string(disabled.response);
+        assert!(!boot_gpt_diagnostics_active(&disabled_body));
+        assert!(!disabled_body.contains("tsjs-gpt_diagnostics.min.js"));
+        assert!(!disabled_body.contains("tsjs-gpt_diagnostics-bootstrap.min.js"));
+        assert_eq!(disabled_body.matches("history.replaceState").count(), 1);
+    }
+
+    #[tokio::test]
+    async fn render_trace_cookie_populates_the_immutable_html_boot() {
+        let result = run_ts_console_pipeline(
+            Method::GET,
+            "document",
+            "https://publisher.example/article",
+            Some("publisher=value; ts-trace=1"),
+        )
+        .await;
+        let body = response_body_string(result.response);
+        let transport = bootstrap_transport(&body);
+        let diagnostics = &transport["boot"]["diagnostics"];
 
-            let _ = run(&settings, &services, cookie_navigation_request()).await;
-            let _ = run(&settings, &services, cookie_navigation_request()).await;
+        assert!(
+            diagnostics["renderTraceOverlay"] == true,
+            "the exact server-owned trace cookie must populate DiagnosticsBootV1: {body}"
+        );
+        assert_eq!(
+            body.matches("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+                .count(),
+            1,
+            "the immutable server boot must carry one active diagnostics object"
+        );
+    }
 
+    #[tokio::test]
+    async fn ts_console_publisher_pipeline_method_and_document_ineligibility_stay_inert() {
+        for (method, destination) in [(Method::POST, "document"), (Method::GET, "script")] {
+            let result = run_ts_console_pipeline(
+                method,
+                destination,
+                "https://publisher.example/article?keep=%2F&ts_console=1",
+                Some("publisher=value; __Host-ts-console=1"),
+            )
+            .await;
             assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the second cookie-bearing request should be served from the cache"
+                result.origin_uri,
+                "https://origin.test-publisher.com/article?keep=%2F"
             );
+            assert_eq!(result.outbound_cookie.as_deref(), Some("publisher=value"));
+            assert!(!result.response.headers().contains_key(header::SET_COOKIE));
+            let body = response_body_string(result.response);
+            assert!(!boot_gpt_diagnostics_active(&body));
+            assert!(!body.contains("tsjs-gpt_diagnostics.min.js"));
+            assert!(!body.contains("tsjs-gpt_diagnostics-bootstrap.min.js"));
+            assert!(!body.contains("history.replaceState"));
         }
+    }
 
-        #[tokio::test]
-        async fn an_active_diagnostics_request_never_stores_a_template() {
-            // An independent review reintroduced a diagnostics leak scoped to
-            // A request-private diagnostics mutation could otherwise leak through a
-            // shared template. `requires_private_no_store()` is a
-            // strict superset of the condition under which diagnostics markup is
-            // emitted, and that stamp lands *before* the template cache gate reads response headers,
-            // so such a request never stores a template at all.
-            //
-            // That is a coincidence between two independent conditions, and the whole
-            // protection rests on it. This pins the consequence directly, so the
-            // relationship is checked rather than merely reasoned about.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let _ = run(&settings, &services, diagnostics_navigation_request()).await;
+    #[tokio::test]
+    async fn publisher_origin_fetch_leaves_stream_response_disabled_when_unsupported() {
+        let settings = create_test_settings();
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><body>origin</body></html>".to_vec(),
+            vec![("content-type", "text/html; charset=utf-8")],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/page")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "a reader running diagnostics must not contribute to a shared cache"
-            );
-        }
+        let _ = run_publisher_proxy(&settings, &services, req).await;
 
-        #[tokio::test]
-        async fn active_diagnostics_bypass_an_already_warm_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+        assert_eq!(
+            stub.recorded_stream_response_flags(),
+            vec![false],
+            "publisher origin fetch must not request streams when the platform does not support them"
+        );
+    }
 
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            let response = run(&settings, &services, diagnostics_navigation_request()).await;
-            let document = String::from_utf8(body_of(response).await)
-                .expect("diagnostics document should be UTF-8");
+    #[tokio::test]
+    async fn publisher_origin_fetch_sets_stream_response_when_supported() {
+        let settings = create_test_settings();
+        let stub = Arc::new(StubHttpClient::new());
+        stub.set_streaming_responses_supported(true);
+        stub.push_response_with_headers(
+            200,
+            b"<html><body>origin</body></html>".to_vec(),
+            vec![("content-type", "text/html; charset=utf-8")],
+        );
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/page")
+            .header(header::HOST, "publisher.example")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "request-private diagnostics must reach the origin even when an ordinary \
-                 shared template is warm"
-            );
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                1,
-                "the diagnostics request must not consult template cache at all"
-            );
-            assert!(
-                document.contains("__tsjs_gpt_diagnostics_active"),
-                "origin fallback must retain the request-private diagnostics bootstrap"
-            );
-        }
+        let _ = run_publisher_proxy(&settings, &services, req).await;
 
-        #[tokio::test]
-        async fn datadome_suppressed_request_bypasses_a_warm_shared_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut raw = settings_with_mode("esi");
-            raw.integrations
-                .insert_config(
-                    "datadome",
-                    &serde_json::json!({
-                        "enabled": true,
-                        "client_side_key": "test-client-key",
-                    }),
-                )
-                .expect("should configure DataDome integration");
-            let settings = Arc::new(raw);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
-
-            let ordinary = run(&settings, &services, navigation_request()).await;
-            let ordinary_document = String::from_utf8(body_of(ordinary).await)
-                .expect("ordinary document should be UTF-8");
-            assert!(
-                ordinary_document.contains("/integrations/datadome/tags.js"),
-                "the warm template fixture must contain the ordinary DataDome tag"
-            );
+        assert_eq!(
+            stub.recorded_stream_response_flags(),
+            vec![true],
+            "publisher origin fetch should request streams when the platform supports them"
+        );
+    }
 
-            let mut suppressed_request = navigation_request();
-            suppressed_request
-                .headers_mut()
-                .insert("sec-fetch-dest", HeaderValue::from_static("script"));
-            suppressed_request
-                .extensions_mut()
-                .insert(crate::integrations::datadome::DataDomeClientTagSuppressed);
-            let suppressed = run(&settings, &services, suppressed_request).await;
-            assert_eq!(
-                suppressed
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request"),
-                "request-scoped tag suppression must not read a shared template"
-            );
-            let suppressed_document = String::from_utf8(body_of(suppressed).await)
-                .expect("suppressed document should be UTF-8");
+    #[tokio::test]
+    async fn handle_publisher_request_does_not_self_generate_ec() {
+        // EC generation is the adapter's real-browser-gated responsibility. This
+        // handler must never mint an EC ID on its own: for a navigation from a
+        // client the adapter did not pre-generate for (e.g. a non-real browser),
+        // `ec_value` must stay `None` so no IP-derived identifier reaches the
+        // auction. Consent allows EC creation and a client IP is present here —
+        // exactly the conditions under which the old inline call would have
+        // generated one.
+        let settings = create_test_settings();
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response(200, b"<html><body>ok</body></html>".to_vec());
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
+        );
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "the suppressed navigation must reach the origin even when template cache is warm"
-            );
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                1,
-                "the suppressed request must bypass template cache before lookup"
-            );
-            assert!(
-                !suppressed_document.contains("/integrations/datadome/tags.js"),
-                "the request-scoped suppression decision must survive origin processing"
-            );
-        }
-
-        #[tokio::test]
-        async fn real_diagnostics_query_bypasses_template_cache_and_keeps_its_private_bootstrap() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut raw = settings_with_mode("esi");
-            raw.integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should configure diagnostics");
-            let settings = Arc::new(raw);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let mut request = navigation_request();
-            *request.uri_mut() = "https://ts.example.com/article?ts_console=1"
-                .parse()
-                .expect("should parse diagnostics URI");
-            let response = run(&settings, &services, request).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request")
-            );
-            assert_eq!(
-                response
-                    .headers()
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, no-store")
-            );
-            assert!(response.headers().contains_key(header::SET_COOKIE));
-            let document = String::from_utf8(body_of(response).await)
-                .expect("diagnostics document should be UTF-8");
-            assert!(document.contains("__tsjs_gpt_diagnostics_active"));
-            assert!(document.contains("tsjs-gpt_diagnostics.min.js"));
-            assert!(
-                cache
-                    .lookups
-                    .lock()
-                    .expect("should lock lookups")
-                    .is_empty(),
-                "the real query activation must bypass lookup before origin work"
-            );
-        }
-
-        #[tokio::test]
-        async fn real_diagnostics_cookie_bypasses_a_warm_cookie_independent_template() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let mut raw = settings_with_mode("esi");
-            raw.creative_opportunities
-                .as_mut()
-                .expect("fixture configures creative opportunities")
-                .origin_is_cookie_independent = Some(true);
-            raw.integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should configure diagnostics");
-            let settings = Arc::new(raw);
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
-
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            let mut diagnostics = navigation_request();
-            diagnostics.headers_mut().insert(
-                header::COOKIE,
-                HeaderValue::from_static("__Host-ts-console=1"),
-            );
-            let response = run(&settings, &services, diagnostics).await;
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-request")
-            );
-            let document = String::from_utf8(body_of(response).await)
-                .expect("diagnostics document should be UTF-8");
-
-            assert_eq!(stub.recorded_request_uris().len(), 2);
-            assert_eq!(
-                cache.lookups.lock().expect("should lock lookups").len(),
-                1,
-                "the diagnostics cookie must bypass the otherwise-eligible warm lookup"
-            );
-            assert!(document.contains("__tsjs_gpt_diagnostics_active"));
-        }
+        let consent = crate::consent::ConsentContext {
+            jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
+            ..Default::default()
+        };
+        let mut ec_context =
+            EcContext::new_for_test_with_ip(None, consent, Some("203.0.113.7".to_string()));
+        assert!(
+            ec_context.ec_allowed(),
+            "test precondition: consent must allow EC creation"
+        );
 
-        #[tokio::test]
-        async fn a_cache_backend_failure_falls_back_to_origin_and_is_observable() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            cache.fail_lookup.store(true, Ordering::Relaxed);
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let response = run(&settings, &services, navigation_request()).await;
-            assert_eq!(response.status(), StatusCode::OK);
-            assert_eq!(
-                response
-                    .headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("backend-error")
-            );
-            let document = String::from_utf8(body_of(response).await)
-                .expect("fallback document should be UTF-8");
-            assert!(document.contains("origin"));
-            assert_eq!(stub.recorded_request_uris().len(), 1);
-        }
+        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/article")
+            .header(header::HOST, "publisher.example")
+            .header("sec-fetch-dest", "document")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-        #[tokio::test]
-        async fn a_cache_hit_streams_rather_than_buffering() {
-            // The property that makes the cache worth having, and the one that regressed
-            // silently. Buffered assembly held the first byte until the auction resolved
-            // — measured at ~100x worse TTFB than shipping nothing at all, because the
-            // inline path already streams and waits only at `</body>`.
-            //
-            // Asserted on the body *shape* rather than on timing: a timing test would be
-            // flaky, and `EdgeBody::Stream` is the structural fact that produces the
-            // timing.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
+        let _ = handle_publisher_request(
+            &settings,
+            &services,
+            None,
+            &mut ec_context,
+            AuctionDispatch {
+                orchestrator: &orchestrator,
+                slots: &[],
+                registry: None,
+            },
+            req,
+            EdgeCacheHeader::SMaxageFallback,
+        )
+        .await
+        .expect("should proxy publisher request");
 
-            // Warm the cache, then take the hit.
-            let _ = run(&settings, &services, navigation_request()).await;
-            let warm = run(&settings, &services, navigation_request()).await;
+        assert_eq!(
+            ec_context.ec_value(),
+            None,
+            "handler must not self-generate an EC ID; generation is the adapter's real-browser-gated responsibility",
+        );
+    }
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the second request must be a hit, or this asserts nothing"
-            );
-            assert!(
-                warm.headers().get(header::CONTENT_LENGTH).is_none(),
-                "a streamed assembly has no length until bids resolve, and headers \
-                 commit before the first byte"
-            );
+    #[tokio::test]
+    async fn datadome_filter_marker_survives_into_publisher_html_pipeline() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "datadome",
+                &serde_json::json!({
+                    "enabled": true,
+                    "enable_protection": true,
+                    "server_side_key_secret_name": "server-side-key",
+                    "protection_excluded_ip_cidrs": ["192.0.2.0/24"],
+                    "client_side_key": "test-client-key",
+                }),
+            )
+            .expect("should configure DataDome integration");
+        let registry = IntegrationRegistry::new(&settings)
+            .expect("should create integration registry with DataDome");
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response_with_headers(
+            200,
+            b"<html><head></head><body>content</body></html>".to_vec(),
+            vec![("content-type", "text/html; charset=utf-8")],
+        );
+        let services = build_services_with_secret_http_client_and_client_ip(
+            NoopSecretStore,
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
+            Some("192.0.2.10".parse().expect("should parse client IP")),
+        );
+        let mut req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/page")
+            .header(header::HOST, "publisher.example")
+            .header("sec-fetch-dest", "document")
+            .body(EdgeBody::empty())
+            .expect("should build request");
 
-            // The invariant that actually matters, and the one a body-shape assertion
-            // misses: a stream that awaited the auction before its first yield would
-            // still be an `EdgeBody::Stream` and would still hold the first byte.
-            //
-            // So pull exactly one chunk and prove the auction has not been collected
-            // yet — `ad_bids_state` is only written by the collector. No timing
-            // involved, so nothing to be flaky about.
-            let EdgeBody::Stream(mut stream) = warm.into_body() else {
-                panic!("a cache hit must stream, not buffer");
-            };
-            let first = stream
-                .next()
-                .await
-                .expect("the stream should yield a first chunk")
-                .expect("the first chunk should read");
+        let filter_outcome = registry
+            .filter_request(crate::integrations::RequestFilterRegistryInput {
+                settings: &settings,
+                services: &services,
+                req: &mut req,
+                geo_info: None,
+            })
+            .await
+            .expect("should run DataDome filter");
+        assert!(matches!(
+            filter_outcome,
+            crate::integrations::RequestFilterRegistryOutcome::Continue(_)
+        ));
+        let publisher_response = run_publisher_proxy(&settings, &services, req).await;
+        let response = buffer_publisher_response_async(
+            publisher_response,
+            &Method::GET,
+            &settings,
+            &registry,
+            &AuctionOrchestrator::new(settings.auction.clone()),
+            &services,
+        )
+        .await
+        .expect("should buffer publisher response");
+        let html = response_body_string(response);
 
-            assert!(
-                first.starts_with(b"<!doctype html>") || first.starts_with(b"<html"),
-                "the first chunk must be the document head, not the bids: {:?}",
-                String::from_utf8_lossy(&first[..first.len().min(60)])
-            );
-            assert!(
-                !first.windows(11).any(|w| w == b"window.tsjs"),
-                "the first chunk must precede the bids script"
-            );
-        }
+        assert!(!html.contains("window.ddjskey"));
+        assert!(!html.contains("/integrations/datadome/tags.js"));
+        assert_eq!(
+            stub.recorded_backend_names().len(),
+            1,
+            "only the publisher origin should be called"
+        );
+    }
 
-        #[tokio::test]
-        async fn a_bypassed_response_falls_back_to_inline_at_every_seam() {
-            // Observed against a real origin: a page arrived with a raw
-            // executable ESI markup in it and no bids at all. The `</body>` seam emitted
-            // the marker because the mode was `Esi`, while assembly was skipped because
-            // the gate had refused a key — a fallback at one seam and not the other.
-            //
-            // Bypassing is the *normal* case against a real origin, so this path runs
-            // far more often than the shared one. It has to produce a working page.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
+    #[test]
+    fn response_carries_body_preserves_bodiless_metadata() {
+        // A processable GET 200 buffers a body and recomputes Content-Length.
+        assert!(
+            super::response_carries_body(&Method::GET, StatusCode::OK),
+            "a GET 200 publisher response should carry a buffered body"
+        );
+        // HEAD carries no body; recomputing Content-Length to 0 would mislead
+        // clients/caches about the GET representation length.
+        assert!(
+            !super::response_carries_body(&Method::HEAD, StatusCode::OK),
+            "HEAD publisher responses must not get a recomputed Content-Length"
+        );
+        // Bodiless statuses keep their metadata regardless of method.
+        assert!(
+            !super::response_carries_body(&Method::GET, StatusCode::NO_CONTENT),
+            "204 responses must not get a recomputed Content-Length"
+        );
+        assert!(
+            !super::response_carries_body(&Method::GET, StatusCode::RESET_CONTENT),
+            "205 responses must not get a recomputed Content-Length"
+        );
+        assert!(
+            !super::response_carries_body(&Method::GET, StatusCode::NOT_MODIFIED),
+            "304 responses must not get a recomputed Content-Length"
+        );
+    }
 
-            // A `Set-Cookie` from the origin disqualifies the response, exactly as a
-            // real origin does.
-            stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                    ("set-cookie", "sess=1"),
-                ],
-            );
+    #[test]
+    fn dispatched_auction_guard_stays_armed_until_collection_completes() {
+        // `take()` hands the dispatched auction to the async collector, but the
+        // guard must stay armed across the collection await so a drop while
+        // collection is still pending (a client disconnect at the await point)
+        // still logs the loss. Only `disarm()` — called once collection reaches
+        // a terminal result — clears the warning.
+        let mut guard = DispatchedAuctionGuard::new(DispatchedAuction::empty_for_test(
+            test_auction_request(),
+            10,
+        ));
+        assert!(guard.armed, "a freshly dispatched guard should be armed");
 
-            let document = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("response should be utf-8");
+        let _dispatched = guard
+            .take()
+            .expect("guard should yield the dispatched auction for collection");
+        assert!(
+            guard.armed,
+            "guard must stay armed across the collection await so a drop mid-collection is reported"
+        );
 
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "the gate refused, so nothing may be stored"
-            );
-            assert!(
-                !document.contains(AD_ASSEMBLY_SEAM),
-                "a marker must never be emitted when nothing will resolve it: {document}"
-            );
-            assert!(
-                document.contains("window.tsjs"),
-                "and the reader must still get their bids: {document}"
-            );
-        }
+        guard.disarm();
+        assert!(
+            !guard.armed,
+            "guard must disarm once collection reaches a terminal result"
+        );
+    }
 
-        #[tokio::test]
-        async fn the_seam_carries_slot_definitions_or_the_page_serves_no_ads() {
-            // Shared modes suppress the head slot script, so the seam is the only place
-            // `tsjs.adSlots` can come from. Sending only bids left it at its `[]` default,
-            // `adInit` defined nothing, and the page rendered perfectly with zero TS ads —
-            // green tests, healthy-looking page, no revenue.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
+    fn response_body_string(response: http::Response<EdgeBody>) -> String {
+        String::from_utf8(
+            response
+                .into_body()
+                .into_bytes()
+                .unwrap_or_default()
+                .to_vec(),
+        )
+        .expect("response body should be valid UTF-8")
+    }
 
-            let miss = body_of(run(&settings, &services, navigation_request()).await).await;
-            let hit = body_of(run(&settings, &services, navigation_request()).await).await;
-
-            for (label, body) in [("miss", miss), ("hit", hit)] {
-                let text = String::from_utf8(body).expect("utf-8");
-                assert!(
-                    text.contains("var a=JSON.parse(") && text.contains("s(b,a)"),
-                    "{label}: the seam must carry slot definitions and hand them to the \
-                     scheduler: {text}"
-                );
-                assert!(
-                    text.contains("test-slot"),
-                    "{label}: the slot definitions must be populated, not `[]`"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn an_assembled_response_is_private_even_when_the_ad_stack_is_off() {
-            // The private stamp was gated on `should_run_ad_stack`. A bot, prefetch,
-            // kill-switched or consent-denied request can still assemble an empty-bids
-            // document, and would have kept the origin's public caching directives — so a
-            // downstream cache could serve that to a later eligible reader.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-
-            let bot = HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .header("sec-fetch-mode", "navigate")
-                .header(
-                    header::USER_AGENT,
-                    "Googlebot/2.1 (+http://www.google.com/bot.html)",
-                )
-                .body(EdgeBody::empty())
-                .expect("should build bot request");
-            let response = run(&settings, &services, bot).await;
+    #[test]
+    fn test_content_type_detection() {
+        let test_cases = vec![
+            ("text/html", true),
+            ("text/html; charset=utf-8", true),
+            ("Text/HTML; Charset=utf-8", true),
+            ("text/css", true),
+            ("Text/CSS", true),
+            ("text/javascript", true),
+            ("application/javascript", true),
+            ("Application/JavaScript", true),
+            ("application/json", true),
+            ("application/json; charset=utf-8", true),
+            ("Application/JSON; Charset=UTF-8", true),
+            ("image/jpeg", false),
+            ("image/png", false),
+            ("application/pdf", false),
+            ("video/mp4", false),
+            ("application/octet-stream", false),
+        ];
 
+        for (content_type, expected) in test_cases {
             assert_eq!(
-                response
-                    .headers()
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|v| v.to_str().ok()),
-                Some("private, no-store"),
-                "an assembled response must be private whatever the ad stack decided"
+                is_processable_content_type(content_type),
+                expected,
+                "Content-Type '{content_type}' should_process: expected {expected}",
             );
         }
+    }
 
-        #[tokio::test]
-        async fn a_cache_hit_keeps_the_origin_security_headers() {
-            // Reconstructing headers keeps origin `Set-Cookie` and caching directives out
-            // of a shared cache, and also silently dropped Content-Security-Policy —
-            // a weaker page, served faster. Policy headers are per-URL, so they belong
-            // with the template.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                    ("content-security-policy", "default-src 'self'"),
-                    ("x-frame-options", "SAMEORIGIN"),
-                ],
-            );
-
-            let _ = run(&settings, &services, navigation_request()).await;
-            let warm = run(&settings, &services, navigation_request()).await;
-
-            assert_eq!(
-                warm.headers()
-                    .get(header::CONTENT_SECURITY_POLICY)
-                    .and_then(|v| v.to_str().ok()),
-                Some("default-src 'self'"),
-                "a hit must not drop the origin's CSP"
-            );
-            assert_eq!(
-                warm.headers()
-                    .get("x-frame-options")
-                    .and_then(|v| v.to_str().ok()),
-                Some("SAMEORIGIN")
-            );
-        }
+    #[test]
+    fn supported_content_encoding_accepts_known_values() {
+        assert!(is_supported_content_encoding(""), "should accept empty");
+        assert!(
+            is_supported_content_encoding("identity"),
+            "should accept identity"
+        );
+        assert!(is_supported_content_encoding("gzip"), "should accept gzip");
+        assert!(
+            is_supported_content_encoding("deflate"),
+            "should accept deflate"
+        );
+        assert!(is_supported_content_encoding("br"), "should accept br");
+    }
 
-        #[tokio::test]
-        async fn a_cache_hit_preserves_every_repeated_policy_header_in_order() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            stub.push_response_with_headers(
-                200,
-                b"<html><head></head><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                    ("content-security-policy", "default-src 'self'"),
-                    ("content-security-policy", "script-src 'self'"),
-                    ("link", "</one.js>; rel=preload; as=script"),
-                    ("link", "</two.css>; rel=preload; as=style"),
-                    ("cross-origin-opener-policy", "same-origin"),
-                    ("cross-origin-embedder-policy", "require-corp"),
-                ],
-            );
+    #[test]
+    fn supported_content_encoding_rejects_unknown_values() {
+        assert!(!is_supported_content_encoding("zstd"), "should reject zstd");
+        assert!(
+            !is_supported_content_encoding("compress"),
+            "should reject compress"
+        );
+        assert!(
+            !is_supported_content_encoding("snappy"),
+            "should reject snappy"
+        );
+    }
 
-            let _ = run(&settings, &services, navigation_request()).await;
-            let warm = run(&settings, &services, navigation_request()).await;
+    #[test]
+    fn server_side_ad_stack_runs_only_when_all_auction_gates_pass() {
+        assert!(
+            should_run_server_side_ad_stack(true, true, false, false, true, true, true),
+            "GET, real navigation, matched slots, and consent should run TS ad stack"
+        );
 
-            let values = |name: &'static str| {
-                warm.headers()
-                    .get_all(name)
-                    .iter()
-                    .map(|value| value.to_str().expect("policy header should be text"))
-                    .collect::<Vec<_>>()
-            };
-            assert_eq!(
-                values("content-security-policy"),
-                ["default-src 'self'", "script-src 'self'"]
-            );
-            assert_eq!(
-                values("link"),
-                [
-                    "</one.js>; rel=preload; as=script",
-                    "</two.css>; rel=preload; as=style"
-                ]
-            );
-            assert_eq!(values("cross-origin-opener-policy"), ["same-origin"]);
-            assert_eq!(values("cross-origin-embedder-policy"), ["require-corp"]);
-        }
+        assert!(
+            !should_run_server_side_ad_stack(false, true, false, false, true, true, true),
+            "non-GET requests should skip TS ad stack"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, false, false, false, true, true, true),
+            "non-document requests should skip TS ad stack"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, true, true, false, true, true, true),
+            "prefetch requests should skip TS ad stack and injection"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, true, false, true, true, true, true),
+            "bot requests should skip TS ad stack and injection"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, true, false, false, false, true, true),
+            "requests with no matching slots should skip TS ad stack"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, true, false, false, true, false, true),
+            "requests without required consent should skip TS ad stack and injection"
+        );
+        assert!(
+            !should_run_server_side_ad_stack(true, true, false, false, true, true, false),
+            "disabled [auction].enabled kill switch should skip TS ad stack and injection"
+        );
+    }
 
-        #[tokio::test]
-        async fn nonce_bearing_csp_bypasses_the_shared_template_cache() {
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            for _ in 0..2 {
-                stub.push_response_with_headers(
-                    200,
-                    b"<html><head><script nonce=reader-nonce></script></head><body>origin</body></html>"
-                        .to_vec(),
-                    vec![
-                        ("content-type", "text/html; charset=utf-8"),
-                        ("cache-control", "public, max-age=300"),
-                        (
-                            "content-security-policy",
-                            "default-src 'self'; script-src 'nonce-reader-nonce'",
-                        ),
-                    ],
-                );
-            }
+    #[test]
+    fn unsupported_encoding_response_is_returned_unmodified() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::OK,
+                "text/html; charset=utf-8",
+                "zstd",
+                "example.com"
+            ),
+            ResponseRoute::BufferedUnmodified,
+        );
+    }
 
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
+    #[test]
+    fn test_publisher_origin_host_extraction() {
+        let settings = create_test_settings();
+        let origin_host = settings.publisher.origin_host();
+        assert_eq!(origin_host, "origin.test-publisher.com");
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "a response-bound CSP nonce and its HTML must never be reused from template cache"
-            );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty()
-            );
-        }
+        let mut settings_with_port = create_test_settings();
+        settings_with_port.publisher.origin_url = "origin.test-publisher.com:8080".to_string();
+        assert_eq!(
+            settings_with_port.publisher.origin_host(),
+            "origin.test-publisher.com:8080"
+        );
+    }
 
-        #[tokio::test]
-        async fn a_meta_delivered_nonce_policy_bypasses_the_shared_template_cache() {
-            // The response-header gate cannot see this policy at all. Storing the document
-            // would replay one response's nonce to every later reader — the exact thing the
-            // header check exists to prevent.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            for _ in 0..2 {
-                stub.push_response_with_headers(
-                    200,
-                    br#"<html><head><meta http-equiv="Content-Security-Policy" content="script-src 'nonce-reader-nonce'"><script nonce="reader-nonce"></script></head><body>origin</body></html>"#
-                        .to_vec(),
-                    vec![
-                        ("content-type", "text/html; charset=utf-8"),
-                        ("cache-control", "public, max-age=300"),
-                    ],
-                );
-            }
+    #[test]
+    fn test_invalid_utf8_handling() {
+        let invalid_utf8_bytes = vec![0xFF, 0xFE, 0xFD];
+        assert!(String::from_utf8(invalid_utf8_bytes.clone()).is_err());
+    }
 
-            let cold = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                cold.headers()
-                    .get(HEADER_X_TS_TEMPLATE_CACHE)
-                    .and_then(|value| value.to_str().ok()),
-                Some("bypass-response"),
-                "the cold response must refuse to store a nonce-bearing document"
-            );
-            let _ = body_of(cold).await;
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
+    #[test]
+    fn test_utf8_conversion_edge_cases() {
+        let test_cases = vec![
+            (vec![0xE2, 0x98, 0x83], true),
+            (vec![0xF0, 0x9F, 0x98, 0x80], true),
+            (vec![0xFF, 0xFE], false),
+            (vec![0xC0, 0x80], false),
+            (vec![0xED, 0xA0, 0x80], false),
+        ];
 
+        for (bytes, should_be_valid) in test_cases {
+            let result = String::from_utf8(bytes.clone());
             assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "the warm request must reach the origin, not a replayed nonce"
-            );
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty(),
-                "nothing nonce-bearing may reach the shared cache"
+                result.is_ok(),
+                should_be_valid,
+                "UTF-8 validation failed for bytes: {:?}",
+                bytes
             );
         }
+    }
 
-        #[tokio::test]
-        async fn a_nonce_attribute_without_a_policy_bypasses_the_shared_template_cache() {
-            // Fail closed: the attributes say the document was written for a per-response
-            // policy, whether or not the policy itself survived to this scan.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            for _ in 0..2 {
-                stub.push_response_with_headers(
-                    200,
-                    br#"<html><head><script nonce="reader-nonce"></script></head><body>origin</body></html>"#
-                        .to_vec(),
-                    vec![
-                        ("content-type", "text/html; charset=utf-8"),
-                        ("cache-control", "public, max-age=300"),
-                    ],
-                );
-            }
+    #[test]
+    fn route_streams_2xx_html_without_post_processors() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::OK,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+        );
+    }
 
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
-            let _ = body_of(run(&settings, &services, navigation_request()).await).await;
+    #[test]
+    fn route_streams_mixed_case_html_content_type() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::OK,
+                "Text/HTML; Charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+            "HTML MIME type matching must be case-insensitive",
+        );
+    }
 
-            assert_eq!(stub.recorded_request_uris().len(), 2);
-            assert!(
-                cache
-                    .entries
-                    .lock()
-                    .expect("should lock entries")
-                    .is_empty()
-            );
-        }
+    #[test]
+    fn route_streams_html_with_post_processors() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::OK,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+        );
+    }
 
-        #[tokio::test]
-        async fn a_body_close_in_script_data_corrupts_neither_the_cold_nor_the_warm_document() {
-            // No structural `</body>` anywhere: a reverse byte search takes the string
-            // literal, and the payload's `</script>` then terminates the publisher's script
-            // — in the response served cold and in the template every warm reader gets.
-            const PUBLISHER_SCRIPT: &str = r#"<script>const marker = "</body>";</script>"#;
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            stub.push_response_with_headers(
-                200,
-                format!("<html><head></head>{PUBLISHER_SCRIPT}<p>article</p></html>").into_bytes(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                ],
-            );
-
-            let cold = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("the cold document should be UTF-8");
-            let warm = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("the warm document should be UTF-8");
-
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                1,
-                "the document is otherwise shareable and must still be stored and reused"
-            );
-            for (label, document) in [("cold", &cold), ("warm", &warm)] {
-                assert!(
-                    document.contains(PUBLISHER_SCRIPT),
-                    "the {label} document must carry the publisher's script byte for byte: {document}"
-                );
-                assert!(
-                    !document.contains(AD_ASSEMBLY_SEAM),
-                    "the {label} document must not ship an unresolved seam: {document}"
-                );
-            }
-        }
+    #[test]
+    fn route_streams_non_html_even_with_post_processors_registered() {
+        assert_eq!(
+            classify_response_route(StatusCode::OK, "application/json", "gzip", "example.com"),
+            ResponseRoute::Stream,
+        );
+    }
 
-        #[tokio::test]
-        async fn a_body_close_in_trailing_comment_data_does_not_attract_the_seam() {
-            // The reverse search took the *last* `</body>` sequence, so the seam landed
-            // inside this comment and the assembled bids never executed.
-            const TRAILING_COMMENT: &str = "<!-- </body> -->";
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            stub.push_response_with_headers(
-                200,
-                format!("<html><head></head><body><p>article</p></body>{TRAILING_COMMENT}</html>")
-                    .into_bytes(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", "public, max-age=300"),
-                ],
-            );
+    #[test]
+    fn route_buffers_unmodified_on_unsupported_encoding() {
+        assert_eq!(
+            classify_response_route(StatusCode::OK, "text/html", "zstd", "example.com"),
+            ResponseRoute::BufferedUnmodified,
+        );
+    }
 
-            let cold = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("the cold document should be UTF-8");
-            let warm = String::from_utf8(
-                body_of(run(&settings, &services, navigation_request()).await).await,
-            )
-            .expect("the warm document should be UTF-8");
+    #[test]
+    fn route_passes_through_non_processable_2xx() {
+        assert_eq!(
+            classify_response_route(StatusCode::OK, "image/png", "", "example.com"),
+            ResponseRoute::PassThrough,
+        );
+    }
 
-            assert_eq!(stub.recorded_request_uris().len(), 1);
-            for (label, document) in [("cold", &cold), ("warm", &warm)] {
-                assert!(
-                    document.contains(TRAILING_COMMENT),
-                    "the {label} document must leave the publisher comment intact: {document}"
-                );
-                assert!(
-                    !document.contains(AD_ASSEMBLY_SEAM),
-                    "the {label} document must not ship an unresolved seam: {document}"
-                );
-                assert!(
-                    !document.contains(TEMPLATE_SEAM_PLACEHOLDER),
-                    "the transform-owned placeholder must never reach a reader: {document}"
-                );
-            }
-        }
+    #[test]
+    fn route_buffers_non_processable_error_responses() {
+        assert_eq!(
+            classify_response_route(StatusCode::NOT_FOUND, "image/png", "", "example.com"),
+            ResponseRoute::BufferedUnmodified,
+        );
+    }
 
-        #[tokio::test]
-        async fn a_post_is_never_answered_from_a_cached_get() {
-            // `handle_publisher_request` is the `*`-method fallback route, so a publisher
-            // path that renders a page on GET and accepts a form or webhook on POST reaches
-            // here for both. Serving the cached GET to the POST swallows the mutating
-            // request entirely: the origin never sees it, the caller gets 200 and a page,
-            // and nothing anywhere reports a problem.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+    #[test]
+    fn route_excludes_204_from_pass_through() {
+        assert_eq!(
+            classify_response_route(StatusCode::NO_CONTENT, "image/png", "", "example.com"),
+            ResponseRoute::BufferedUnmodified,
+        );
+    }
 
-            // Warm the cache with a GET.
-            let _ = run(&settings, &services, navigation_request()).await;
-            assert_eq!(stub.recorded_request_uris().len(), 1);
+    #[test]
+    fn route_excludes_205_from_pass_through() {
+        assert_eq!(
+            classify_response_route(StatusCode::RESET_CONTENT, "image/png", "", "example.com"),
+            ResponseRoute::BufferedUnmodified,
+        );
+    }
 
-            let post = HttpRequest::builder()
-                .method(Method::POST)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .body(EdgeBody::from("field=value"))
-                .expect("should build post request");
-            let _ = run(&settings, &services, post).await;
+    #[test]
+    fn route_excludes_204_for_processable_content_types() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::NO_CONTENT,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::BufferedUnmodified,
+            "204 + HTML must not route to Stream",
+        );
+        assert_eq!(
+            classify_response_route(
+                StatusCode::NO_CONTENT,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::BufferedUnmodified,
+            "204 + HTML + post-processors must not route to Stream",
+        );
+    }
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "the POST must reach the origin rather than being answered from the \
-                 cached GET"
-            );
-            assert_eq!(
-                cache.entries.lock().expect("should lock entries").len(),
-                1,
-                "and it must not store a template of its own"
-            );
-        }
+    #[test]
+    fn route_excludes_205_for_processable_content_types() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::RESET_CONTENT,
+                "application/json",
+                "",
+                "example.com"
+            ),
+            ResponseRoute::BufferedUnmodified,
+            "205 + JSON must not route to Stream",
+        );
+    }
 
-        #[tokio::test]
-        async fn an_authenticated_request_is_not_served_a_shared_template() {
-            // The stored template is perfectly cacheable; this request is not entitled
-            // to it. The store gate cannot express that, because it is a property of
-            // the reader rather than of the bytes — which is why the lookup re-checks.
-            let stub = Arc::new(StubHttpClient::new());
-            let cache = Arc::new(MemoryTemplateCache::default());
-            let settings = Arc::new(settings_with_mode("esi"));
-            let services = services(Arc::clone(&stub), Arc::clone(&cache));
-            queue_shareable_html(&stub);
-            queue_shareable_html(&stub);
+    #[test]
+    fn route_streams_non_2xx_processable_content() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::NOT_FOUND,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+        );
+        assert_eq!(
+            classify_response_route(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "application/json",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+        );
+    }
 
-            let _ = run(&settings, &services, navigation_request()).await;
-            assert_eq!(
-                cache.entries.lock().expect("should lock entries").len(),
-                1,
-                "the cold request should have populated the cache"
-            );
+    #[test]
+    fn route_streams_non_2xx_html_with_post_processors() {
+        assert_eq!(
+            classify_response_route(
+                StatusCode::NOT_FOUND,
+                "text/html; charset=utf-8",
+                "gzip",
+                "example.com"
+            ),
+            ResponseRoute::Stream,
+        );
+    }
 
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let consent = crate::consent::ConsentContext {
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                ..Default::default()
-            };
-            let mut ec_context = EcContext::new_for_test(None, consent);
-            let authenticated = HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .header(header::AUTHORIZATION, "Basic dXNlcjpwYXNz")
-                .body(EdgeBody::empty())
-                .expect("should build authenticated request");
-            let _ = handle_publisher_request(
-                &settings,
-                &services,
-                None,
-                &mut ec_context,
-                AuctionDispatch {
-                    orchestrator: &orchestrator,
-                    slots: &[article_slot()],
-                    registry: None,
-                },
-                authenticated,
-                EdgeCacheHeader::SMaxageFallback,
-            )
-            .await
-            .expect("should proxy publisher request");
+    #[test]
+    fn route_passes_through_non_processable_even_with_empty_request_host() {
+        assert_eq!(
+            classify_response_route(StatusCode::OK, "image/png", "", ""),
+            ResponseRoute::PassThrough,
+        );
+    }
 
-            assert_eq!(
-                stub.recorded_request_uris().len(),
-                2,
-                "an authenticated request must reach the origin rather than read a \
-                 shared template"
-            );
-        }
+    #[test]
+    fn route_buffers_processable_content_with_empty_request_host() {
+        assert_eq!(
+            classify_response_route(StatusCode::OK, "text/html", "gzip", ""),
+            ResponseRoute::BufferedUnmodified,
+        );
     }
 
-    mod template_cache_gate_tests {
-        //! `cache::core` stores whatever it is handed and rejects nothing, so every
-        //! one of these conditions is the caller's to enforce. Each is a leak vector
-        //! or an eligibility rule, not a preference.
+    #[test]
+    fn pass_through_preserves_body_and_content_length() {
+        let image_bytes: Vec<u8> = (0..=255).cycle().take(4096).collect();
 
-        use super::*;
-        use crate::creative_opportunities::AssemblyMode;
-        use edgezero_core::http::HeaderName;
+        let mut response = Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "image/png")
+            .header(header::CONTENT_LENGTH, image_bytes.len() as u64)
+            .body(EdgeBody::from(image_bytes.clone()))
+            .expect("should build test response");
 
-        fn headers(pairs: &[(HeaderName, &str)]) -> edgezero_core::http::HeaderMap {
-            let mut map = edgezero_core::http::HeaderMap::new();
-            for (name, value) in pairs {
-                map.insert(
-                    name.clone(),
-                    HeaderValue::from_str(value).expect("should build header value"),
-                );
-            }
-            map
-        }
+        // Simulate PassThrough: take body then reattach
+        let body = std::mem::replace(response.body_mut(), EdgeBody::empty());
+        // Body is unmodified — Content-Length stays correct
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CONTENT_LENGTH)
+                .and_then(|v| v.to_str().ok())
+                .expect("should have content-length"),
+            "4096",
+            "Content-Length should be preserved for pass-through"
+        );
 
-        fn shareable() -> edgezero_core::http::HeaderMap {
-            headers(&[(header::CACHE_CONTROL, "max-age=60")])
-        }
+        // Reattach and verify body content
+        *response.body_mut() = body;
+        let (_, final_body) = response.into_parts();
+        let output = final_body.into_bytes().unwrap_or_default();
+        assert_eq!(
+            output, image_bytes,
+            "pass-through should preserve body byte-for-byte"
+        );
+    }
 
-        /// The shipped default: no operator has stated what the origin varies on, so the
-        /// key covers nothing. Responses without a `Vary` are unaffected; any `Vary` at
-        /// all disqualifies.
-        fn nothing_covered() -> VarySpec {
-            VarySpec::new([])
-        }
-
-        #[test]
-        fn an_unconfigured_deployment_never_caches_a_varying_response() {
-            // The fail-closed default. An operator who has not stated the origin's Vary
-            // must not acquire a shared cache by omission — and a real origin varies on
-            // something, so this is the common path, not an edge case.
-            // Deliberately not `Accept-Encoding`: the shared path normalizes supported
-            // content codings to one identity template, so that header is covered
-            // whatever the operator configured. Using it here would test the
-            // structural-coverage carve-out rather than the drift guard.
-            let mut varying = shareable();
-            varying.insert(header::VARY, HeaderValue::from_static("rsc"));
+    #[test]
+    fn test_content_encoding_detection() {
+        let test_encodings = vec!["gzip", "deflate", "br", "identity", ""];
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::VaryNotCovered(VaryGap(vec![
-                    "rsc".to_string()
-                ]))),
-                "an unstated Vary must disqualify rather than silently under-key"
+        for encoding in test_encodings {
+            let mut req = build_request(Method::GET, "https://test.example.com/page");
+            req.headers_mut().insert(
+                header::ACCEPT_ENCODING,
+                http::HeaderValue::from_static("gzip, deflate, br"),
             );
-        }
 
-        #[test]
-        fn an_origin_that_varies_on_cookie_is_refused_even_when_declared_independent() {
-            // The backstop that makes `origin_is_cookie_independent` safe to offer. The
-            // operator asserts their origin ignores cookies; if the origin then says
-            // otherwise, the assertion loses. Without this, a wrong assertion would
-            // silently cross-serve personalized HTML.
-            let mut varying = shareable();
-            varying.insert(header::VARY, HeaderValue::from_static("Cookie"));
+            if !encoding.is_empty() {
+                req.headers_mut().insert(
+                    header::CONTENT_ENCODING,
+                    http::HeaderValue::from_str(encoding)
+                        .expect("content encoding should be valid"),
+                );
+            }
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    // The operator's assertion has already been applied here: this is
-                    // `false` precisely because they declared independence.
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &VarySpec::new(["cookie".to_string()]),
-                ),
-                Some(TemplateCacheBypassReason::VaryCookie),
-                "the origin's declaration must override both cookie independence and an \
-                 accidentally configured per-cookie key"
-            );
+            let content_encoding = req
+                .headers()
+                .get(header::CONTENT_ENCODING)
+                .map(|h| h.to_str().unwrap_or_default())
+                .unwrap_or_default();
+
+            assert_eq!(content_encoding, encoding);
         }
+    }
 
-        #[test]
-        fn a_private_directive_on_a_second_cache_control_line_is_refused() {
-            // `HeaderMap::get` returns the first value only. An origin that sends
-            // `Cache-Control: public, max-age=300` and then `Cache-Control: private` on a
-            // separate line means exactly what one comma-joined line would mean, but the
-            // second line was invisible — so a response the origin marked private was
-            // written to a cache shared between readers. The `Vary` reads a few lines up
-            // already use `get_all` for the same reason.
-            let mut split = edgezero_core::http::HeaderMap::new();
-            split.append(
-                header::CACHE_CONTROL,
-                HeaderValue::from_static("public, max-age=300"),
-            );
-            split.append(header::CACHE_CONTROL, HeaderValue::from_static("private"));
+    #[test]
+    fn publisher_proxy_does_not_add_accept_encoding_when_absent() {
+        let mut req = build_request(Method::GET, "https://test.example.com/page");
+        // No Accept-Encoding header set by the client.
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &split,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::OriginNotShareable),
-                "a directive on any Cache-Control line must disqualify the response"
-            );
-        }
+        restrict_accept_encoding(&mut req);
 
-        #[test]
-        fn a_no_store_directive_on_a_second_cache_control_line_is_refused() {
-            // Same defect, the other directive that matters — `no-store` is the one an
-            // origin uses for a response that must not be written down anywhere.
-            let mut split = edgezero_core::http::HeaderMap::new();
-            split.append(
-                header::CACHE_CONTROL,
-                HeaderValue::from_static("max-age=60"),
-            );
-            split.append(header::CACHE_CONTROL, HeaderValue::from_static("no-store"));
+        assert_eq!(
+            req.headers().get(header::ACCEPT_ENCODING),
+            None,
+            "publisher proxy should not inject Accept-Encoding when the client sent none"
+        );
+    }
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &split,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::OriginNotShareable)
-            );
-        }
+    #[test]
+    fn publisher_proxy_limits_accept_encoding_to_supported_values() {
+        let mut req = build_request(Method::GET, "https://test.example.com/page");
+        req.headers_mut().insert(
+            header::ACCEPT_ENCODING,
+            http::HeaderValue::from_static("gzip, deflate, br, zstd"),
+        );
 
-        #[test]
-        fn cdn_specific_cache_policy_cannot_be_overridden_by_public_cache_control() {
-            for name in crate::response_privacy::CDN_CACHE_HEADERS {
-                let mut split = shareable();
-                split.insert(
-                    header::HeaderName::from_static(name),
-                    HeaderValue::from_static("no-store"),
-                );
+        restrict_accept_encoding(&mut req);
 
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &split,
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::OriginNotShareable),
-                    "template cache must fail closed on the CDN-specific policy header {name}"
-                );
-            }
-        }
+        assert_eq!(
+            req.headers()
+                .get(header::ACCEPT_ENCODING)
+                .and_then(|value| value.to_str().ok()),
+            Some("gzip, deflate, br"),
+            "publisher fallback should only advertise encodings the rewrite pipeline supports"
+        );
+    }
 
-        #[test]
-        fn unsupported_vendor_freshness_does_not_authorize_template_cache() {
-            for name in crate::response_privacy::CDN_CACHE_HEADERS
-                .iter()
-                .filter(|name| **name != "surrogate-control")
-            {
-                let mut split = shareable();
-                split.insert(
-                    header::HeaderName::from_static(name),
-                    HeaderValue::from_static("max-age=60"),
-                );
+    #[test]
+    fn publisher_proxy_preserves_identity_only_accept_encoding() {
+        let mut req = build_request(Method::GET, "https://test.example.com/page");
+        req.headers_mut().insert(
+            header::ACCEPT_ENCODING,
+            http::HeaderValue::from_static("identity"),
+        );
 
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &split,
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::OriginNotShareable),
-                    "the Fastly exception must not authorize the vendor policy {name}"
-                );
-            }
-        }
+        restrict_accept_encoding(&mut req);
 
-        #[test]
-        fn observed_fastly_surrogate_policy_uses_edge_freshness_capped_by_configuration() {
-            let publisher_headers = headers(&[
-                (header::CACHE_CONTROL, "public, max-age=60"),
-                (
-                    header::HeaderName::from_static("surrogate-control"),
-                    "max-age=1200, stale-while-revalidate=21600, stale-if-error=604800",
-                ),
-            ]);
+        assert_eq!(
+            req.headers()
+                .get(header::ACCEPT_ENCODING)
+                .and_then(|value| value.to_str().ok()),
+            Some("identity"),
+            "publisher fallback should preserve identity-only clients"
+        );
+    }
 
-            assert_eq!(
-                template_cache_ttl(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &publisher_headers,
-                    &TemplateCachePolicy::for_test(&nothing_covered(), Duration::from_secs(300),),
-                ),
-                Ok(Duration::from_secs(300)),
-                "Fastly's edge freshness should take precedence over the shorter browser \
-                 lifetime, while the configured safety ceiling remains authoritative"
-            );
-        }
+    #[test]
+    fn publisher_proxy_respects_supported_client_subset() {
+        let mut req = build_request(Method::GET, "https://test.example.com/page");
+        req.headers_mut().insert(
+            header::ACCEPT_ENCODING,
+            http::HeaderValue::from_static("br, gzip;q=0, zstd"),
+        );
 
-        #[test]
-        fn fastly_surrogate_freshness_takes_precedence_over_standard_freshness() {
-            for (cache_control, surrogate_control, expected) in [
-                ("public, max-age=300", "max-age=30", 30),
-                ("public, max-age=30", "max-age=300", 300),
-            ] {
-                let publisher_headers = headers(&[
-                    (header::CACHE_CONTROL, cache_control),
-                    (
-                        header::HeaderName::from_static("surrogate-control"),
-                        surrogate_control,
-                    ),
-                ]);
+        restrict_accept_encoding(&mut req);
 
-                assert_eq!(
-                    template_cache_ttl(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &publisher_headers,
-                        &TemplateCachePolicy::for_test(
-                            &nothing_covered(),
-                            Duration::from_secs(600),
-                        ),
-                    ),
-                    Ok(Duration::from_secs(expected))
-                );
-            }
-        }
+        assert_eq!(
+            req.headers()
+                .get(header::ACCEPT_ENCODING)
+                .and_then(|value| value.to_str().ok()),
+            Some("br"),
+            "publisher fallback should only advertise the supported encodings the client accepts"
+        );
+    }
 
-        #[test]
-        fn surrogate_stale_windows_do_not_extend_fresh_reuse() {
-            let publisher_headers = headers(&[
-                (header::CACHE_CONTROL, "public, max-age=300"),
-                (
-                    header::HeaderName::from_static("surrogate-control"),
-                    "max-age=20, stale-while-revalidate=600, stale-if-error=1200",
-                ),
-                (header::AGE, "10"),
-            ]);
+    #[test]
+    fn publisher_proxy_falls_back_to_identity_for_unsupported_client_encodings() {
+        let mut req = build_request(Method::GET, "https://test.example.com/page");
+        req.headers_mut().insert(
+            header::ACCEPT_ENCODING,
+            http::HeaderValue::from_static("zstd"),
+        );
 
-            assert_eq!(
-                template_cache_ttl(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &publisher_headers,
-                    &TemplateCachePolicy::for_test(&nothing_covered(), Duration::from_secs(600),),
-                ),
-                Ok(Duration::from_secs(10)),
-                "stale windows are validated metadata, not fresh template cache lifetime"
-            );
-        }
+        restrict_accept_encoding(&mut req);
 
-        #[test]
-        fn ambiguous_or_unsupported_surrogate_policy_fails_closed() {
-            for (policy, expected) in [
-                ("max-age", TemplateCacheBypassReason::MalformedCachePolicy),
-                (
-                    "max-age=30, max-age=60",
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-                (
-                    "max-age=tomorrow",
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-                (
-                    "max-age=30, public",
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-                (
-                    "stale-if-error=60",
-                    TemplateCacheBypassReason::NoPositiveFreshness,
-                ),
-                ("max-age=0", TemplateCacheBypassReason::NoPositiveFreshness),
-                (
-                    "max-age=30,",
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-            ] {
-                let mut publisher_headers = shareable();
-                publisher_headers.insert(
-                    header::HeaderName::from_static("surrogate-control"),
-                    HeaderValue::from_str(policy).expect("should build Surrogate-Control"),
-                );
+        assert_eq!(
+            req.headers()
+                .get(header::ACCEPT_ENCODING)
+                .and_then(|value| value.to_str().ok()),
+            Some("identity"),
+            "publisher fallback should request identity when the client only accepts unsupported encodings"
+        );
+    }
 
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &publisher_headers,
-                        &nothing_covered(),
-                    ),
-                    Some(expected),
-                    "`{policy}` must fail closed"
+    #[test]
+    fn esi_reader_encoding_negotiation_honours_quality_identity_and_repeated_fields() {
+        let headers = |values: &[&str]| {
+            let mut headers = edgezero_core::http::HeaderMap::new();
+            for value in values {
+                headers.append(
+                    header::ACCEPT_ENCODING,
+                    HeaderValue::from_str(value).expect("should build accept-encoding"),
                 );
             }
+            headers
+        };
+
+        assert_eq!(
+            negotiate_reader_compression(&headers(&[])),
+            Ok(Compression::None)
+        );
+        assert_eq!(
+            negotiate_reader_compression(&headers(&["gzip;q=0.8", "br;q=0.4, identity;q=0.1"])),
+            Ok(Compression::Gzip)
+        );
+        assert_eq!(
+            negotiate_reader_compression(&headers(&["gzip, br"])),
+            Ok(Compression::Brotli),
+            "server preference breaks an equal-quality tie"
+        );
+        assert_eq!(
+            negotiate_reader_compression(&headers(&["gzip;q=0.5"])),
+            Ok(Compression::None),
+            "implicit identity has q=1"
+        );
+        assert_eq!(
+            negotiate_reader_compression(&headers(&["zstd, identity;q=0"])),
+            Err(ReaderEncodingError::NoAcceptableEncoding)
+        );
+        assert_eq!(
+            negotiate_reader_compression(&headers(&["gzip;q=invalid"])),
+            Err(ReaderEncodingError::Malformed)
+        );
+        for malformed in [
+            "gzip;q=1e-1",
+            "gzip;q=0.1234",
+            "gzip;q=1.001",
+            "not a coding;q=1",
+        ] {
+            assert_eq!(
+                negotiate_reader_compression(&headers(&[malformed])),
+                Err(ReaderEncodingError::Malformed),
+                "{malformed} is not valid Accept-Encoding syntax"
+            );
         }
+    }
 
-        #[test]
-        fn restrictive_surrogate_policy_is_never_overridden_by_standard_freshness() {
-            for directive in ["private", "no-store", "no-cache"] {
-                let mut publisher_headers = shareable();
-                publisher_headers.insert(
-                    header::HeaderName::from_static("surrogate-control"),
-                    HeaderValue::from_str(directive).expect("should build Surrogate-Control"),
-                );
+    #[test]
+    fn tsjs_dynamic_returns_not_found_for_unknown_filename() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let req = build_request(
+            Method::GET,
+            "https://publisher.example/static/tsjs=unknown.js",
+        );
 
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &publisher_headers,
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::OriginNotShareable),
-                    "`{directive}` must remain authoritative"
-                );
-            }
-        }
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    }
 
-        #[test]
-        fn restrictive_standard_policy_is_never_overridden_by_surrogate_freshness() {
-            for directive in ["private", "no-store", "no-cache"] {
-                let publisher_headers = headers(&[
-                    (
-                        header::CACHE_CONTROL,
-                        &format!("public, max-age=60, {directive}"),
-                    ),
-                    (
-                        header::HeaderName::from_static("surrogate-control"),
-                        "max-age=1200",
-                    ),
-                ]);
+    #[test]
+    fn tsjs_dynamic_serves_unified_bundle_for_known_filename() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let src = registry
+            .tsjs_takeover_artifact(selection)
+            .expect("should precompute selected takeover artifact")
+            .src();
+        let req = build_request(Method::GET, &format!("https://publisher.example{src}"));
 
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &publisher_headers,
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::OriginNotShareable),
-                    "standard `{directive}` must refuse template cache even with positive edge freshness"
-                );
-            }
-        }
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers().get(header::CONTENT_TYPE),
+            Some(&HeaderValue::from_static(
+                "application/javascript; charset=utf-8"
+            ))
+        );
+        assert_eq!(
+            response.headers().get(header::X_CONTENT_TYPE_OPTIONS),
+            Some(&HeaderValue::from_static("nosniff"))
+        );
+        assert!(response.headers().contains_key(header::ETAG));
+    }
 
-        #[test]
-        fn surrogate_control_can_authorize_fastly_edge_freshness_without_browser_freshness() {
-            let publisher_headers = headers(&[(
-                header::HeaderName::from_static("surrogate-control"),
-                "max-age=1200",
-            )]);
+    #[test]
+    fn tsjs_dynamic_head_matches_get_metadata_without_a_body() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let src = registry
+            .tsjs_takeover_artifact(selection)
+            .expect("should precompute selected takeover artifact")
+            .src();
+        let get = build_request(Method::GET, &format!("https://publisher.example{src}"));
+        let head = build_request(Method::HEAD, &format!("https://publisher.example{src}"));
+
+        let get_response = handle_tsjs_dynamic(&get, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should serve GET metadata");
+        let head_response = handle_tsjs_dynamic(&head, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should serve HEAD metadata");
+
+        assert_eq!(head_response.status(), get_response.status());
+        assert_eq!(head_response.headers(), get_response.headers());
+        assert!(
+            matches!(head_response.body(), EdgeBody::Once(bytes) if bytes.is_empty()),
+            "HEAD must not return embedded TSJS bytes"
+        );
+    }
 
-            assert_eq!(
-                template_cache_ttl(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &publisher_headers,
-                    &TemplateCachePolicy::for_test(&nothing_covered(), Duration::from_secs(300),),
-                ),
-                Ok(Duration::from_secs(300)),
-                "Fastly edge freshness should not require browser freshness"
-            );
-        }
+    #[test]
+    fn tsjs_dynamic_serves_the_exact_rewritten_creative_bundle() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let creative_hash = trusted_server_js::concatenated_hash(&["render_runtime", "creative"]);
+        let src = registry
+            .tsjs_static_artifact(&creative_hash)
+            .expect("should precompute rewritten creative artifact")
+            .src();
+        let req = build_request(Method::GET, &format!("https://publisher.example{src}"));
 
-        #[test]
-        fn repeated_cache_control_lines_without_a_disqualifier_still_cache() {
-            // The other direction: reading every value must not turn an ordinary
-            // multi-line `Cache-Control` into a bypass, or the fix would disable the
-            // cache instead of tightening it.
-            let mut split = edgezero_core::http::HeaderMap::new();
-            split.append(header::CACHE_CONTROL, HeaderValue::from_static("public"));
-            split.append(
-                header::CACHE_CONTROL,
-                HeaderValue::from_static("max-age=60"),
-            );
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &split,
-                    &nothing_covered(),
-                ),
-                None
-            );
-        }
+        assert_eq!(
+            response.status(),
+            StatusCode::OK,
+            "rewritten creative HTML must reference a transport-admitted artifact"
+        );
+    }
 
-        #[test]
-        fn origin_freshness_is_positive_age_adjusted_and_capped() {
-            let fresh_headers = headers(&[(header::CACHE_CONTROL, "public, max-age=300")]);
-            assert_eq!(
-                template_cache_ttl(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &fresh_headers,
-                    &TemplateCachePolicy::for_test(&nothing_covered(), Duration::from_secs(60),),
-                ),
-                Ok(Duration::from_secs(60))
-            );
+    #[test]
+    fn tsjs_dynamic_preserves_strong_etag_conditional_304() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let ids = registry.tsjs_takeover_module_ids(selection);
+        let src = crate::tsjs::tsjs_script_src(&ids);
+        let first = build_request(Method::GET, &format!("https://publisher.example{src}"));
+        let first_response =
+            handle_tsjs_dynamic(&first, &registry, EdgeCacheHeader::SMaxageFallback)
+                .expect("should serve current release");
+        let etag = first_response
+            .headers()
+            .get(header::ETAG)
+            .cloned()
+            .expect("should emit an ETag");
+        let mut conditional =
+            build_request(Method::GET, &format!("https://publisher.example{src}"));
+        conditional
+            .headers_mut()
+            .insert(header::IF_NONE_MATCH, etag.clone());
 
-            let aged = headers(&[
-                (header::CACHE_CONTROL, "s-maxage=50, max-age=300"),
-                (header::AGE, "35"),
-            ]);
-            assert_eq!(
-                template_cache_ttl(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &aged,
-                    &TemplateCachePolicy::for_test(&nothing_covered(), Duration::from_secs(60),),
-                ),
-                Ok(Duration::from_secs(15))
-            );
+        let response =
+            handle_tsjs_dynamic(&conditional, &registry, EdgeCacheHeader::SMaxageFallback)
+                .expect("should handle conditional request");
 
-            let old_date_without_age = headers(&[
-                (header::CACHE_CONTROL, "public, max-age=60"),
-                (header::DATE, "Wed, 12 Aug 2026 08:00:00 GMT"),
-            ]);
-            let one_minute_later = httpdate::parse_http_date("Wed, 12 Aug 2026 08:01:00 GMT")
-                .expect("should parse fixture time");
+        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
+        assert_eq!(response.headers().get(header::ETAG), Some(&etag));
+        assert_eq!(
+            response.headers().get(header::X_CONTENT_TYPE_OPTIONS),
+            Some(&HeaderValue::from_static("nosniff"))
+        );
+    }
+
+    #[test]
+    fn tsjs_dynamic_serves_only_the_exact_precomputed_first_display_mask_and_hash() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "creative",
+                &serde_json::json!({
+                    "enabled": false,
+                    "click_guard": false,
+                    "render_guard": false
+                }),
+            )
+            .expect("should disable the creative guard");
+        settings
+            .integrations
+            .insert_config("gpt", &serde_json::json!({}))
+            .expect("should enable GPT");
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let mask = 0x0083;
+        assert!(
+            registry.tsjs_first_display_masks().contains(&mask),
+            "GPT must precompute the ADM render-owner mask"
+        );
+        let selected = trusted_server_js::all_first_display_ids()
+            .into_iter()
+            .enumerate()
+            .filter_map(|(index, id)| (mask & (1 << index) != 0).then_some(id))
+            .collect::<Vec<_>>();
+        let hash = trusted_server_js::concatenated_first_display_hash(&selected[1..])
+            .expect("selected slices should hash");
+        let src = format!("/static/tsjs=tsjs-first-display.min.js?m={mask:04x}&v={hash}");
+
+        let request = build_request(Method::GET, &format!("https://publisher.example{src}"));
+        let response = handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should serve artifact");
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response.headers().get(header::CONTENT_TYPE),
+            Some(&HeaderValue::from_static(
+                "application/javascript; charset=utf-8"
+            ))
+        );
+        assert_eq!(
+            response
+                .into_body()
+                .into_bytes()
+                .unwrap_or_default()
+                .as_ref(),
+            trusted_server_js::concatenate_first_display_slices(&selected[1..])
+                .expect("should compose selected slices")
+                .as_bytes()
+        );
+
+        let head = build_request(Method::HEAD, &format!("https://publisher.example{src}"));
+        let response = handle_tsjs_dynamic(&head, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should serve HEAD metadata");
+        assert_eq!(response.status(), StatusCode::OK);
+        assert!(
+            response
+                .into_body()
+                .into_bytes()
+                .unwrap_or_default()
+                .is_empty()
+        );
+
+        for suffix in [
+            format!("tsjs-first-display.min.js?v={hash}&m={mask:04x}"),
+            format!("tsjs-first-display.min.js?m={mask:04x}&v={hash}&x=1"),
+            format!(
+                "tsjs-first-display.min.js?m={:04x}&v={hash}",
+                mask ^ (1 << 1)
+            ),
+            format!(
+                "tsjs-first-display.min.js?m={mask:04x}&v={}",
+                "0".repeat(64)
+            ),
+            format!("tsjs-first_display.min.js?m={mask:04x}&v={hash}"),
+        ] {
+            let request = build_request(
+                Method::GET,
+                &format!("https://publisher.example/static/tsjs={suffix}"),
+            );
+            let response =
+                handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SMaxageFallback)
+                    .expect("should reject locally");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND, "case {suffix}");
             assert_eq!(
-                origin_shared_ttl_at(
-                    &old_date_without_age,
-                    one_minute_later,
-                    Duration::from_secs(60),
-                ),
-                Err(TemplateCacheBypassReason::NoPositiveFreshness),
-                "an old Date is apparent age even when an upstream omitted Age"
+                response.headers().get(header::CACHE_CONTROL),
+                Some(&HeaderValue::from_static("no-store")),
+                "case {suffix}"
             );
         }
 
-        #[test]
-        fn zero_exhausted_missing_and_malformed_freshness_are_refused() {
-            for (map, expected) in [
-                (
-                    headers(&[(header::CACHE_CONTROL, "max-age=0")]),
-                    TemplateCacheBypassReason::NoPositiveFreshness,
-                ),
-                (
-                    headers(&[(header::CACHE_CONTROL, "max-age=60"), (header::AGE, "60")]),
-                    TemplateCacheBypassReason::NoPositiveFreshness,
-                ),
-                (
-                    headers(&[(header::CACHE_CONTROL, "public")]),
-                    TemplateCacheBypassReason::NoPositiveFreshness,
-                ),
-                (
-                    headers(&[(header::CACHE_CONTROL, "max-age=tomorrow")]),
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-                (
-                    headers(&[(header::CACHE_CONTROL, "max-age=\"60")]),
-                    TemplateCacheBypassReason::MalformedCachePolicy,
-                ),
-                (
-                    headers(&[(header::CACHE_CONTROL, "max-age=+60")]),
-                    TemplateCacheBypassReason::MalformedCachePolicy,
+        let owner_hash =
+            trusted_server_js::concatenated_first_display_hash(&["render_owner_initial"])
+                .expect("render owner should have one generated component hash");
+        let owner_request = build_request(
+            Method::GET,
+            &format!(
+                "https://publisher.example/static/tsjs=tsjs-render_owner_initial.min.js?v={owner_hash}"
+            ),
+        );
+        let owner_response =
+            handle_tsjs_dynamic(&owner_request, &registry, EdgeCacheHeader::SMaxageFallback)
+                .expect("standalone owner route should reject locally");
+        assert_eq!(owner_response.status(), StatusCode::NOT_FOUND);
+        assert_eq!(
+            owner_response.headers().get(header::CACHE_CONTROL),
+            Some(&HeaderValue::from_static("no-store"))
+        );
+        assert!(!owner_response.headers().contains_key(header::LOCATION));
+    }
+
+    #[test]
+    fn tsjs_dynamic_rejects_noncanonical_transport_locally_without_fallthrough() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let ids = registry.tsjs_takeover_module_ids(selection);
+        let hash = trusted_server_js::concatenated_hash(&ids);
+        let cases = [
+            (Method::OPTIONS, format!("tsjs-unified.min.js?v={hash}")),
+            (Method::POST, format!("tsjs-unified.min.js?v={hash}")),
+            (Method::GET, "tsjs-unified.min.js".to_owned()),
+            (Method::GET, format!("tsjs-unified.js?v={hash}")),
+            (Method::GET, format!("tsjs-unified.min.js?v={hash}&x=1")),
+            (Method::GET, format!("tsjs-unified.min.js?x=1&v={hash}")),
+            (Method::GET, "tsjs-unified.min.js?v=stale".to_owned()),
+            (
+                Method::GET,
+                format!("tsjs-unified.min.js?v={}", "0".repeat(64)),
+            ),
+            (
+                Method::GET,
+                format!("tsjs-unified.min.js?v={}", hash.to_uppercase()),
+            ),
+            (
+                Method::GET,
+                format!("tsjs-unknown.min.js?v={}", "0".repeat(64)),
+            ),
+            (
+                Method::GET,
+                format!(
+                    "tsjs-creative.min.js?v={}",
+                    trusted_server_js::single_module_hash("creative")
+                        .expect("should hash the creative runtime")
                 ),
-            ] {
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &map,
-                        &nothing_covered(),
-                    ),
-                    Some(expected)
-                );
-            }
-        }
+            ),
+        ];
 
-        #[test]
-        fn expires_can_authorize_but_never_extend_an_expired_response() {
-            let now = httpdate::parse_http_date("Wed, 12 Aug 2026 08:00:00 GMT")
-                .expect("should parse fixture time");
-            let fresh = headers(&[
-                (header::DATE, "Wed, 12 Aug 2026 08:00:00 GMT"),
-                (header::EXPIRES, "Wed, 12 Aug 2026 08:00:30 GMT"),
-            ]);
-            assert_eq!(
-                origin_shared_ttl_at(&fresh, now, Duration::from_secs(60)),
-                Ok(Duration::from_secs(30))
+        for (method, suffix) in cases {
+            let req = build_request(
+                method,
+                &format!("https://publisher.example/static/tsjs={suffix}"),
             );
-
-            let expired = headers(&[
-                (header::DATE, "Wed, 12 Aug 2026 08:01:00 GMT"),
-                (header::EXPIRES, "Wed, 12 Aug 2026 08:00:30 GMT"),
-            ]);
+            let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+                .expect("should reject locally");
+            assert_eq!(response.status(), StatusCode::NOT_FOUND, "case {suffix}");
             assert_eq!(
-                origin_shared_ttl_at(&expired, now, Duration::from_secs(60)),
-                Err(TemplateCacheBypassReason::NoPositiveFreshness)
+                response.headers().get(header::CACHE_CONTROL),
+                Some(&HeaderValue::from_static("no-store")),
+                "case {suffix}"
             );
-        }
-
-        #[test]
-        fn request_semantics_bypass_template_cache_except_for_a_max_age_zero_reload() {
-            for (name, value) in [
-                (header::CACHE_CONTROL, "no-cache"),
-                (header::CACHE_CONTROL, "max-age=30"),
-                (header::CACHE_CONTROL, "max-age=\"0"),
-                (header::CACHE_CONTROL, "min-fresh=10"),
-                (header::CACHE_CONTROL, "no-store"),
-                (header::PRAGMA, "no-cache"),
-                (header::PRAGMA, "legacy-extension, no-cache"),
-                (header::RANGE, "bytes=0-99"),
-                (header::IF_NONE_MATCH, "\"etag\""),
-                (header::IF_MODIFIED_SINCE, "Wed, 12 Aug 2026 08:00:00 GMT"),
-            ] {
-                let map = headers(&[(name.clone(), value)]);
-                assert!(
-                    request_bypasses_template_cache(&map),
-                    "{name}: {value} must bypass"
-                );
-            }
             assert!(
-                !request_bypasses_template_cache(&headers(&[(header::CACHE_CONTROL, "max-age=0")])),
-                "a browser reload may reuse template cache because the assembled response and auction \
-                 are still rebuilt for this reader"
+                !response.headers().contains_key(header::LOCATION),
+                "case {suffix}"
             );
-            assert!(!request_bypasses_template_cache(&headers(&[(
-                header::CACHE_CONTROL,
-                "public"
-            )])));
         }
+    }
 
-        #[test]
-        fn a_wildcard_vary_is_refused() {
-            // `VarySpec::uncovered_by` filters `*` out, with a comment saying the
-            // eligibility gate handles it. It did not — nothing rejected the wildcard, so
-            // a response the origin said no key can select was shareable.
-            let mut varying = shareable();
-            varying.insert(header::VARY, HeaderValue::from_static("*"));
+    #[test]
+    fn tsjs_dynamic_rejects_takeover_diagnostics_as_a_standalone_alias() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
+            .expect("should enable diagnostics");
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let mut req = build_request(
+            Method::GET,
+            &format!(
+                "https://publisher.example/static/tsjs=tsjs-gpt_diagnostics.min.js?v={}",
+                trusted_server_js::single_module_hash("gpt_diagnostics")
+                    .expect("should hash diagnostics")
+            ),
+        );
+        req.headers_mut().insert(
+            header::COOKIE,
+            HeaderValue::from_static("__Host-ts-console=1"),
+        );
 
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::VaryWildcard)
-            );
-        }
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
 
-        #[test]
-        fn a_fully_covered_vary_is_cacheable() {
-            let mut varying = shareable();
-            varying.insert(
-                header::VARY,
-                HeaderValue::from_static("rsc, Accept-Encoding"),
-            );
-
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &VarySpec::new(["rsc".to_string(), "accept-encoding".to_string()]),
-                ),
-                None,
-                "a key covering everything the origin varies on is safe to store"
-            );
-        }
-
-        #[test]
-        fn config_drift_names_the_missing_header() {
-            // The failure this guards: the origin adds a header to its Vary, nobody
-            // updates config, and requests differing only in that header start sharing a
-            // template. The reason must name it, or diagnosing means a bisect.
-            let mut varying = shareable();
-            varying.insert(
-                header::VARY,
-                HeaderValue::from_static("rsc, next-router-prefetch"),
-            );
-
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &VarySpec::new(["rsc".to_string()]),
-                ),
-                Some(TemplateCacheBypassReason::VaryNotCovered(VaryGap(vec![
-                    "next-router-prefetch".to_string()
-                ]))),
-                "the uncovered header must be named"
-            );
-        }
-
-        #[test]
-        fn a_vary_split_across_repeated_headers_is_still_checked() {
-            // Vary is a list header, so an origin may send it once or many times. Reading
-            // only the first would let the rest through unkeyed.
-            let mut varying = shareable();
-            varying.append(header::VARY, HeaderValue::from_static("rsc"));
-            varying.append(header::VARY, HeaderValue::from_static("cookie"));
-
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &varying,
-                    &VarySpec::new(["rsc".to_string()]),
-                ),
-                Some(TemplateCacheBypassReason::VaryCookie),
-                "a repeated Vary header must not hide names behind the first value"
-            );
-        }
-
-        #[test]
-        fn a_plain_shareable_html_200_is_cacheable() {
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &shareable(),
-                    &nothing_covered(),
-                ),
-                None,
-                "ESI shareable HTML 200 should be eligible"
-            );
-        }
-
-        #[test]
-        fn inline_mode_never_writes_a_template() {
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Inline,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &shareable(),
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::InlineMode),
-                "inline has no shared template to write"
-            );
-        }
-
-        #[test]
-        fn an_authorized_request_is_never_cached() {
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    true,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &shareable(),
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::AuthorizedRequest),
-                "an authenticated response must not enter a shared cache"
-            );
-        }
-
-        #[test]
-        fn a_forwarded_request_cookie_disqualifies_even_without_set_cookie() {
-            // The dangerous case: session established on an earlier request, so this
-            // response carries no Set-Cookie, has no Cache-Control at all, is a 200,
-            // and is HTML — yet is personalized because TS forwarded the Cookie to
-            // origin unchanged. Every other condition reports it cacheable.
-            let no_cache_control = edgezero_core::http::HeaderMap::new();
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    true,
-                    StatusCode::OK,
-                    "text/html",
-                    &no_cache_control,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::CookieForwarded),
-                "cookie-personalized HTML must not become a shared template"
-            );
-        }
-
-        #[test]
-        fn an_origin_set_cookie_is_never_cached() {
-            let with_cookie = headers(&[
-                (header::CACHE_CONTROL, "max-age=60"),
-                (header::SET_COOKIE, "sid=abc; Path=/"),
-            ]);
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &with_cookie,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::OriginSetCookie),
-                "caching this would replay one visitor's cookie to the next"
-            );
-        }
-
-        #[test]
-        fn non_shareable_cache_control_is_refused_case_insensitively() {
-            for directive in [
-                "private",
-                "no-store",
-                "no-cache",
-                "Private, max-age=60",
-                "NO-STORE",
-                "public, No-Cache",
-            ] {
-                let map = headers(&[(header::CACHE_CONTROL, directive)]);
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        "text/html",
-                        &map,
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::OriginNotShareable),
-                    "`{directive}` should disqualify the response"
-                );
-            }
-        }
-
-        #[test]
-        fn a_datadome_block_is_refused_by_the_status_check() {
-            // DataDome replaces the document with a 403
-            // (`integrations/datadome/protection.rs:778`). There is no separate
-            // marker to detect, and none is needed.
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::FORBIDDEN,
-                    "text/html",
-                    &shareable(),
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::NonOkStatus),
-                "a blocked document must not become the shared template"
-            );
-        }
-
-        #[test]
-        fn non_html_is_refused() {
-            for content_type in ["text/x-component", "application/json", ""] {
-                assert_eq!(
-                    template_cache_bypass_reason(
-                        AssemblyMode::Esi,
-                        false,
-                        false,
-                        StatusCode::OK,
-                        content_type,
-                        &shareable(),
-                        &nothing_covered(),
-                    ),
-                    Some(TemplateCacheBypassReason::NotHtml),
-                    "`{content_type}` has no HTML template to transform"
-                );
-            }
-        }
-
-        #[test]
-        fn unsupported_content_encoding_is_refused_before_representation_headers_change() {
-            let map = headers(&[
-                (header::CACHE_CONTROL, "public, max-age=60"),
-                (header::CONTENT_ENCODING, "zstd"),
-            ]);
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &map,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::UnsupportedContentEncoding)
-            );
-
-            let mut repeated = headers(&[(header::CACHE_CONTROL, "public, max-age=60")]);
-            repeated.append(header::CONTENT_TYPE, HeaderValue::from_static("text/html"));
-            repeated.append(
-                header::CONTENT_TYPE,
-                HeaderValue::from_static("application/json"),
-            );
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    false,
-                    false,
-                    StatusCode::OK,
-                    "text/html",
-                    &repeated,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::MalformedRepresentationHeaders)
-            );
-        }
-
-        #[test]
-        fn leak_vectors_are_reported_before_mere_ineligibility() {
-            // A response that fails several conditions should name the most serious
-            // one, so an operator reading the log sees the security reason rather
-            // than a content-type quibble.
-            let map = headers(&[
-                (header::CACHE_CONTROL, "private"),
-                (header::SET_COOKIE, "sid=abc"),
-            ]);
-            assert_eq!(
-                template_cache_bypass_reason(
-                    AssemblyMode::Esi,
-                    true,
-                    false,
-                    StatusCode::FORBIDDEN,
-                    "application/json",
-                    &map,
-                    &nothing_covered(),
-                ),
-                Some(TemplateCacheBypassReason::AuthorizedRequest),
-                "authorization is the most serious disqualifier and should win"
-            );
-        }
-    }
-
-    mod template_neutrality_tests {
-        //! The gate for #1009's shared-template design.
-        //!
-        //! An "absence of per-user values" scan is not sufficient here: the bug
-        //! that nearly shipped was a *conditionally present* element whose own
-        //! content was per-URL. These tests assert byte-identity across requests
-        //! that differ only in the gating decision.
-
-        use super::*;
-        use crate::creative_opportunities::{
-            AssemblyMode, CreativeOpportunityFormat, CreativeOpportunitySlot,
-        };
-
-        pub(super) fn slot() -> CreativeOpportunitySlot {
-            CreativeOpportunitySlot {
-                id: "atf".to_string(),
-                gam_unit_path: Some("/99999/example/home".to_string()),
-                div_id: Some("ad-atf".to_string()),
-                page_patterns: vec!["/**".to_string()],
-                formats: vec![CreativeOpportunityFormat {
-                    width: 300,
-                    height: 250,
-                    media_type: MediaType::Banner,
-                }],
-                floor_price: None,
-                targeting: Default::default(),
-                providers: Default::default(),
-                compiled_patterns: Vec::new(),
-                compiled_unit: None,
-            }
-        }
-
-        pub(super) fn settings_with_slots() -> Settings {
-            let mut settings = crate::test_support::tests::create_test_settings();
-            // Construct the section rather than mutating it if present: the shared
-            // fixture does not carry `[creative_opportunities]`, and an `if let
-            // Some(..)` here would silently no-op and make the inline assertion
-            // below vacuous.
-            settings.creative_opportunities = Some(CreativeOpportunitiesConfig {
-                enabled: true,
-                gam_network_id: "99999".to_string(),
-                auction_timeout_ms: Some(500),
-                price_granularity: Default::default(),
-                section_root: None,
-                assembly_mode: None,
-                template_cache_vary: None,
-                template_cache_max_age_seconds: None,
-                origin_is_cookie_independent: None,
-                section_segment: None,
-                slot: vec![slot()],
-            });
-            settings
-        }
-
-        #[test]
-        fn shared_modes_emit_no_head_script_regardless_of_the_gating_decision() {
-            let settings = settings_with_slots();
-            let slots = [slot()];
-            let mode = AssemblyMode::Esi;
-            let ran = template_ad_slots_script(mode, true, &settings, &slots, "/");
-            let did_not_run = template_ad_slots_script(mode, false, &settings, &slots, "/");
-
-            assert_eq!(
-                ran, did_not_run,
-                "{mode:?}: the template must be byte-identical whether or not the ad \
-                 stack ran; a cached object cannot carry one request's consent, bot, \
-                 prefetch or kill-switch decision"
-            );
-            assert_eq!(
-                ran, None,
-                "{mode:?}: adSlots belongs in the per-request seam, not the template"
-            );
-        }
-
-        #[test]
-        fn inline_mode_keeps_its_request_dependent_behaviour() {
-            // Inline responses are per-navigation and never shared, so gating is
-            // correct there. This guards against "fixing" the shared-mode bug by
-            // breaking the shipped path.
-            let settings = settings_with_slots();
-            let slots = [slot()];
-
-            assert!(
-                template_ad_slots_script(AssemblyMode::Inline, true, &settings, &slots, "/")
-                    .is_some(),
-                "inline should emit adSlots when the ad stack runs"
-            );
-            assert_eq!(
-                template_ad_slots_script(AssemblyMode::Inline, false, &settings, &slots, "/"),
-                None,
-                "inline should emit nothing when the ad stack does not run"
-            );
-        }
-
-        #[test]
-        fn shared_modes_are_neutral_across_differing_slot_matches() {
-            // Slot matching folds in the request path. Under a shared mode even
-            // that must not reach the template.
-            let settings = settings_with_slots();
-
-            let matched = template_ad_slots_script(
-                AssemblyMode::Esi,
-                true,
-                &settings,
-                &[slot()],
-                "/news/article",
-            );
-            let unmatched =
-                template_ad_slots_script(AssemblyMode::Esi, true, &settings, &[], "/other");
-
-            assert_eq!(
-                matched, unmatched,
-                "the template must not vary with slot matching under a shared mode"
-            );
-        }
-    }
-
-    mod ssat_cache_policy_tests {
-        use super::*;
-        use crate::auction::provider::{AuctionProvider, ProviderRequestOutcome};
-        use crate::auction::telemetry::{AuctionEventBatch, AuctionTelemetrySink};
-        use crate::creative_opportunities::{CreativeOpportunityFormat, CreativeOpportunitySlot};
-        use crate::platform::test_support::{
-            NoopConfigStore, NoopGeo, NoopSecretStore, StubBackend,
-        };
-        use crate::platform::{
-            ClientInfo, PlatformError, PlatformHttpClient, PlatformPendingRequest,
-            PlatformResponse, PlatformSelectResult,
-        };
-        use crate::test_support::tests::crate_test_settings_str;
-
-        const ORIGIN_ETAG: &str = "\"origin-tag\"";
-        const ORIGIN_LAST_MODIFIED: &str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        const UNEXPECTED_304_PROVIDER: &str = "example-navigation-bidder";
-        const UNEXPECTED_304_BACKEND: &str = "example-navigation-bidder-backend";
-
-        struct DispatchingTestProvider;
-
-        struct RangeAwareHttpClient {
-            stub: StubHttpClient,
-        }
-
-        impl RangeAwareHttpClient {
-            fn new() -> Self {
-                Self {
-                    stub: StubHttpClient::new(),
-                }
-            }
-        }
-
-        #[async_trait::async_trait(?Send)]
-        impl PlatformHttpClient for RangeAwareHttpClient {
-            async fn send(
-                &self,
-                request: PlatformHttpRequest,
-            ) -> Result<PlatformResponse, Report<PlatformError>> {
-                if request.request.headers().contains_key(header::RANGE) {
-                    self.stub.push_response_with_headers(
-                        206,
-                        b"<html><body>partial".to_vec(),
-                        vec![
-                            ("content-type", "text/html; charset=utf-8"),
-                            ("content-range", "bytes 0-18/39"),
-                        ],
-                    );
-                } else {
-                    self.stub.push_response_with_headers(
-                        200,
-                        b"<html><body>origin</body></html>".to_vec(),
-                        vec![("content-type", "text/html; charset=utf-8")],
-                    );
-                }
-                self.stub.send(request).await
-            }
-
-            async fn send_async(
-                &self,
-                request: PlatformHttpRequest,
-            ) -> Result<PlatformPendingRequest, Report<PlatformError>> {
-                self.stub.send_async(request).await
-            }
-
-            async fn select(
-                &self,
-                pending_requests: Vec<PlatformPendingRequest>,
-            ) -> Result<PlatformSelectResult, Report<PlatformError>> {
-                self.stub.select(pending_requests).await
-            }
-        }
-
-        #[async_trait::async_trait(?Send)]
-        impl AuctionProvider for DispatchingTestProvider {
-            fn provider_name(&self) -> &str {
-                UNEXPECTED_304_PROVIDER
-            }
-
-            async fn request_bids(
-                &self,
-                _request: &AuctionRequest,
-                context: &AuctionContext<'_>,
-            ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
-                let request = PlatformHttpRequest::new(
-                    HttpRequest::builder()
-                        .method(Method::POST)
-                        .uri("https://bidder.example.com/navigation-bids")
-                        .body(EdgeBody::empty())
-                        .expect("should build test provider request"),
-                    UNEXPECTED_304_BACKEND,
-                );
-                context
-                    .services
-                    .http_client()
-                    .send_async(request)
-                    .await
-                    .change_context(TrustedServerError::Auction {
-                        message: "test provider launch failed".to_string(),
-                    })
-                    .map(ProviderRequestOutcome::pending)
-            }
-
-            async fn parse_response(
-                &self,
-                _response: PlatformResponse,
-                _response_time_ms: u64,
-            ) -> Result<AuctionResponse, Report<TrustedServerError>> {
-                panic!("parse_response must not run for an unexpected origin 304");
-            }
-
-            fn timeout_ms(&self) -> u32 {
-                100
-            }
-
-            fn backend_name(
-                &self,
-                _services: &RuntimeServices,
-                _timeout_ms: u32,
-            ) -> Option<String> {
-                Some(UNEXPECTED_304_BACKEND.to_string())
-            }
-        }
-
-        #[derive(Default)]
-        struct RecordingTelemetrySink {
-            batches: Mutex<Vec<AuctionEventBatch>>,
-        }
-
-        #[async_trait::async_trait(?Send)]
-        impl AuctionTelemetrySink for RecordingTelemetrySink {
-            async fn emit_auction_events(
-                &self,
-                _services: &RuntimeServices,
-                batch: AuctionEventBatch,
-            ) -> Result<(), Report<TrustedServerError>> {
-                self.batches
-                    .lock()
-                    .expect("should lock telemetry batches")
-                    .push(batch);
-                Ok(())
-            }
-        }
-
-        fn settings_with_enabled_auction_and_creative_opportunities() -> Settings {
-            let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n\
-                 [creative_opportunities]\ngam_network_id = \"12345\"\n",
-                crate_test_settings_str()
-            );
-            Settings::from_toml(&toml)
-                .expect("should parse settings with auction and creative opportunities enabled")
-        }
-
-        fn settings_with_disabled_ad_templates() -> Settings {
-            let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n\
-                 [creative_opportunities]\nenabled = false\ngam_network_id = \"12345\"\n",
-                crate_test_settings_str()
-            );
-            Settings::from_toml(&toml).expect("should parse settings with disabled ad templates")
-        }
-
-        fn settings_with_disabled_auction() -> Settings {
-            let toml = format!(
-                "{}\n[auction]\nenabled = false\n\n\
-                 [creative_opportunities]\ngam_network_id = \"12345\"\n",
-                crate_test_settings_str()
-            );
-            Settings::from_toml(&toml).expect("should parse settings with disabled auction")
-        }
-
-        fn settings_without_creative_opportunities() -> Settings {
-            Settings::from_toml(&crate_test_settings_str())
-                .expect("should parse settings without creative opportunities")
-        }
-        fn settings_with_dispatching_provider() -> Settings {
-            let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n[auction.providers.{UNEXPECTED_304_PROVIDER}]\nprotocol = \"openrtb-2.6\"\nendpoint = \"https://unexpected.example/openrtb2/auction\"\nrouting = \"all_eligible\"\n\n\
-                 [creative_opportunities]\ngam_network_id = \"12345\"\n",
-                crate_test_settings_str()
-            );
-            Settings::from_toml(&toml)
-                .expect("should parse settings with the dispatching test provider")
-        }
-
-        fn services_with_telemetry(
-            http_client: Arc<dyn crate::platform::PlatformHttpClient>,
-            telemetry_sink: Arc<RecordingTelemetrySink>,
-        ) -> RuntimeServices {
-            let telemetry_sink: Arc<dyn AuctionTelemetrySink> = telemetry_sink;
-            RuntimeServices::builder()
-                .config_store(Arc::new(NoopConfigStore))
-                .secret_store(Arc::new(NoopSecretStore))
-                .kv_store(Arc::new(edgezero_core::key_value_store::NoopKvStore))
-                .backend(Arc::new(StubBackend))
-                .http_client(http_client)
-                .geo(Arc::new(NoopGeo))
-                .auction_telemetry_sink(telemetry_sink)
-                .client_info(ClientInfo::default())
-                .build()
-        }
-
-        fn article_slot() -> CreativeOpportunitySlot {
-            CreativeOpportunitySlot {
-                id: "article-slot".to_string(),
-                gam_unit_path: None,
-                div_id: None,
-                page_patterns: vec!["/article".to_string()],
-                formats: vec![CreativeOpportunityFormat {
-                    width: 300,
-                    height: 250,
-                    media_type: MediaType::Banner,
-                }],
-                floor_price: None,
-                targeting: Default::default(),
-                providers: Default::default(),
-                compiled_patterns: Vec::new(),
-                compiled_unit: None,
-            }
-        }
-
-        fn conditional_navigation_request() -> Request<EdgeBody> {
-            HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .header(header::IF_NONE_MATCH, ORIGIN_ETAG)
-                .header(header::IF_MODIFIED_SINCE, ORIGIN_LAST_MODIFIED)
-                .body(EdgeBody::empty())
-                .expect("should build conditional navigation request")
-        }
-
-        fn queue_cacheable_html_response(stub: &StubHttpClient) {
-            queue_html_response_with_cache_control(stub, "public, max-age=300");
-        }
-
-        fn queue_html_response_with_cache_control(
-            stub: &StubHttpClient,
-            cache_control: &'static str,
-        ) {
-            queue_html_response_with_status_and_cache_control(stub, 200, cache_control);
-        }
-
-        fn queue_html_response_with_status_and_cache_control(
-            stub: &StubHttpClient,
-            status: u16,
-            cache_control: &'static str,
-        ) {
-            stub.push_response_with_headers(
-                status,
-                b"<html><body>origin</body></html>".to_vec(),
-                vec![
-                    ("content-type", "text/html; charset=utf-8"),
-                    ("cache-control", cache_control),
-                    ("etag", ORIGIN_ETAG),
-                    ("last-modified", ORIGIN_LAST_MODIFIED),
-                    ("surrogate-control", "max-age=300"),
-                    ("fastly-surrogate-control", "max-age=300"),
-                    ("cdn-cache-control", "max-age=300"),
-                    ("cloudflare-cdn-cache-control", "max-age=300"),
-                ],
-            );
-        }
-
-        fn non_regulated_consent() -> crate::consent::ConsentContext {
-            crate::consent::ConsentContext {
-                jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                ..Default::default()
-            }
-        }
-
-        async fn run_with_slots(
-            settings: &Settings,
-            services: &RuntimeServices,
-            slots: &[CreativeOpportunitySlot],
-            req: Request<EdgeBody>,
-        ) -> PublisherResponse {
-            run_with_slots_and_consent(settings, services, slots, req, non_regulated_consent())
-                .await
-        }
-
-        async fn run_with_slots_and_consent(
-            settings: &Settings,
-            services: &RuntimeServices,
-            slots: &[CreativeOpportunitySlot],
-            req: Request<EdgeBody>,
-            consent: crate::consent::ConsentContext,
-        ) -> PublisherResponse {
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            run_with_orchestrator_and_consent(
-                settings,
-                services,
-                &orchestrator,
-                slots,
-                req,
-                consent,
-            )
-            .await
-        }
-
-        async fn run_with_orchestrator(
-            settings: &Settings,
-            services: &RuntimeServices,
-            orchestrator: &AuctionOrchestrator,
-            slots: &[CreativeOpportunitySlot],
-            req: Request<EdgeBody>,
-        ) -> PublisherResponse {
-            run_with_orchestrator_and_consent(
-                settings,
-                services,
-                orchestrator,
-                slots,
-                req,
-                non_regulated_consent(),
-            )
-            .await
-        }
-
-        async fn run_with_orchestrator_and_consent(
-            settings: &Settings,
-            services: &RuntimeServices,
-            orchestrator: &AuctionOrchestrator,
-            slots: &[CreativeOpportunitySlot],
-            req: Request<EdgeBody>,
-            consent: crate::consent::ConsentContext,
-        ) -> PublisherResponse {
-            let mut ec_context = EcContext::new_for_test(None, consent);
-
-            handle_publisher_request(
-                settings,
-                services,
-                None,
-                &mut ec_context,
-                AuctionDispatch {
-                    orchestrator,
-                    slots,
-                    registry: None,
-                },
-                req,
-                EdgeCacheHeader::SMaxageFallback,
-            )
-            .await
-            .expect("should proxy publisher request")
-        }
-
-        fn response_head(response: PublisherResponse) -> http::response::Parts {
-            match response {
-                PublisherResponse::Buffered(response)
-                | PublisherResponse::Stream { response, .. }
-                | PublisherResponse::AssembleTemplate { response, .. }
-                | PublisherResponse::PassThrough { response, .. } => response.into_parts().0,
-            }
-        }
-
-        fn recorded_header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
-            headers
-                .iter()
-                .find(|(header_name, _)| header_name.eq_ignore_ascii_case(name))
-                .map(|(_, value)| value.as_str())
-        }
-
-        #[tokio::test]
-        async fn signer_admission_failure_continues_publisher_origin_without_provider_io() {
-            let mut settings = settings_with_dispatching_provider();
-            settings
-                .request_signing
-                .as_mut()
-                .expect("should configure request signing stores")
-                .enabled = true;
-            let plan = Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile signed navigation auction"),
-            );
-            let orchestrator = crate::auction::build_orchestrator_with_plan(plan, &settings)
-                .expect("should build signed plan-backed orchestrator");
-            let stub = Arc::new(StubHttpClient::new());
-            queue_cacheable_html_response(&stub);
-            let services = services_with_telemetry(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
-                Arc::new(RecordingTelemetrySink::default()),
-            );
-            let slots = [article_slot()];
-
-            let response = run_with_orchestrator(
-                &settings,
-                &services,
-                &orchestrator,
-                &slots,
-                conditional_navigation_request(),
-            )
-            .await;
-
-            assert_eq!(response_head(response).status, StatusCode::OK);
-            assert_eq!(
-                stub.recorded_backend_names(),
-                vec!["stub-backend".to_string()],
-                "signer admission failure should skip provider I/O and still fetch the publisher origin"
-            );
-        }
-
-        #[tokio::test]
-        async fn eligible_navigation_bypasses_cache_and_returns_non_storable_html() {
-            // Arrange
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-            let stub = Arc::new(StubHttpClient::new());
-            queue_cacheable_html_response(&stub);
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let slots = [article_slot()];
-            let req = conditional_navigation_request();
-
-            // Act
-            let response = run_with_slots(&settings, &services, &slots, req).await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                stub.recorded_cache_bypass_flags(),
-                vec![true],
-                "eligible publisher navigation should bypass the platform cache"
-            );
-            let recorded_requests = stub.recorded_request_headers();
-            let outbound_headers = recorded_requests
-                .first()
-                .expect("should record the outbound publisher request");
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
-                None,
-                "eligible publisher request should not forward If-None-Match"
-            );
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
-                None,
-                "eligible publisher request should not forward If-Modified-Since"
-            );
-            assert_eq!(
-                response_head
-                    .headers
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, no-store"),
-                "eligible HTML response should be private and non-storable"
-            );
-            for header_name in [
-                header::ETAG,
-                header::LAST_MODIFIED,
-                header::HeaderName::from_static("surrogate-control"),
-                header::HeaderName::from_static("fastly-surrogate-control"),
-                header::HeaderName::from_static("cdn-cache-control"),
-                header::HeaderName::from_static("cloudflare-cdn-cache-control"),
-            ] {
-                assert!(
-                    !response_head.headers.contains_key(&header_name),
-                    "eligible HTML response should remove {header_name}"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn eligible_range_navigation_fetches_complete_html() {
-            // Arrange
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-            let http_client = Arc::new(RangeAwareHttpClient::new());
-            let services = build_services_with_http_client(
-                Arc::clone(&http_client) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let slots = [article_slot()];
-            let mut req = conditional_navigation_request();
-            req.headers_mut()
-                .insert(header::RANGE, HeaderValue::from_static("bytes=0-18"));
-            req.headers_mut()
-                .insert(header::IF_RANGE, HeaderValue::from_static(ORIGIN_ETAG));
-
-            // Act
-            let response = run_with_slots(&settings, &services, &slots, req).await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                response_head.status,
-                StatusCode::OK,
-                "eligible range navigation should fetch the complete origin document"
-            );
-            let recorded_requests = http_client.stub.recorded_request_headers();
-            let outbound_headers = recorded_requests
-                .first()
-                .expect("should record the outbound publisher request");
-            for header_name in [header::RANGE, header::IF_RANGE] {
-                assert_eq!(
-                    recorded_header(outbound_headers, header_name.as_str()),
-                    None,
-                    "eligible publisher request should not forward {header_name}"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn navigation_without_matched_slots_preserves_origin_cache_policy() {
-            // Arrange
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-            let stub = Arc::new(StubHttpClient::new());
-            queue_cacheable_html_response(&stub);
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let mut req = conditional_navigation_request();
-            req.headers_mut()
-                .insert(header::RANGE, HeaderValue::from_static("bytes=0-18"));
-            req.headers_mut()
-                .insert(header::IF_RANGE, HeaderValue::from_static(ORIGIN_ETAG));
-
-            // Act
-            let response = run_with_slots(&settings, &services, &[], req).await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                stub.recorded_cache_bypass_flags(),
-                vec![false],
-                "publisher navigation without matched slots should use the default cache mode"
-            );
-            let recorded_requests = stub.recorded_request_headers();
-            let outbound_headers = recorded_requests
-                .first()
-                .expect("should record the outbound publisher request");
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
-                Some(ORIGIN_ETAG),
-                "publisher request without matched slots should preserve If-None-Match"
-            );
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
-                Some(ORIGIN_LAST_MODIFIED),
-                "publisher request without matched slots should preserve If-Modified-Since"
-            );
-            assert_eq!(
-                recorded_header(outbound_headers, header::RANGE.as_str()),
-                Some("bytes=0-18"),
-                "publisher request without matched slots should preserve Range"
-            );
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_RANGE.as_str()),
-                Some(ORIGIN_ETAG),
-                "publisher request without matched slots should preserve If-Range"
-            );
-
-            for (header_name, expected) in [
-                (header::CACHE_CONTROL, "private, max-age=60"),
-                (header::ETAG, ORIGIN_ETAG),
-                (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
-                (
-                    header::HeaderName::from_static("surrogate-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("fastly-surrogate-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("cdn-cache-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("cloudflare-cdn-cache-control"),
-                    "max-age=300",
-                ),
-            ] {
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(&header_name)
-                        .and_then(|value| value.to_str().ok()),
-                    Some(expected),
-                    "publisher response without matched slots should preserve {header_name}"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn disabled_ad_templates_use_short_browser_cache_policy() {
-            // Arrange
-            let mut settings = settings_with_disabled_ad_templates();
-            settings.proxy.allowed_domains =
-                vec!["*.example".to_string(), "*.example.com".to_string()];
-            let stub = Arc::new(StubHttpClient::new());
-            queue_html_response_with_cache_control(&stub, "public, max-age=300");
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let slots = [article_slot()];
-
-            // Act
-            let response = run_with_slots(
-                &settings,
-                &services,
-                &slots,
-                conditional_navigation_request(),
-            )
-            .await;
-            let registry =
-                IntegrationRegistry::new(&settings).expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let response = buffer_publisher_response_async(
-                response,
-                &Method::GET,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("should buffer disabled-template response");
-            let (response_head, body) = response.into_parts();
-            let body = String::from_utf8(
-                body.into_bytes()
-                    .expect("should return an in-memory publisher body")
-                    .to_vec(),
-            )
-            .expect("should return UTF-8 publisher HTML");
-
-            // Assert
-            assert_eq!(
-                stub.recorded_cache_bypass_flags(),
-                vec![false],
-                "disabled server-side ad templates should not bypass the origin cache"
-            );
-            assert_eq!(
-                response_head
-                    .headers
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, max-age=60"),
-                "disabled server-side ad templates should use the private browser cache policy"
-            );
-            assert!(
-                !body.contains(".adSlots=JSON.parse"),
-                "disabled server-side ad templates should not inject ad-slot state"
-            );
-            for (header_name, expected) in [
-                (header::ETAG, ORIGIN_ETAG),
-                (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
-                (
-                    header::HeaderName::from_static("surrogate-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("fastly-surrogate-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("cdn-cache-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("cloudflare-cdn-cache-control"),
-                    "max-age=300",
-                ),
-            ] {
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(&header_name)
-                        .and_then(|value| value.to_str().ok()),
-                    Some(expected),
-                    "disabled server-side ad templates should preserve {header_name}"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn disabled_auction_uses_private_browser_cache_policy() {
-            // Arrange
-            let settings = settings_with_disabled_auction();
-            let stub = Arc::new(StubHttpClient::new());
-            queue_html_response_with_cache_control(&stub, "no-cache");
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-
-            // Act
-            let response = run_with_slots(
-                &settings,
-                &services,
-                &[article_slot()],
-                conditional_navigation_request(),
-            )
-            .await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                response_head
-                    .headers
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, max-age=60"),
-                "disabled auction should use the private browser cache policy"
-            );
-        }
-
-        #[tokio::test]
-        async fn navigation_without_matched_slots_replaces_origin_cache_policy() {
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-
-            for cache_control in ["no-cache", "max-age=0", "must-revalidate", "s-maxage=0"] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                queue_html_response_with_cache_control(&stub, cache_control);
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response =
-                    run_with_slots(&settings, &services, &[], conditional_navigation_request())
-                        .await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some("private, max-age=60"),
-                    "inactive server-side ad templates should replace origin {cache_control} policy"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn navigation_without_matched_slots_preserves_private_origin_cache_policy() {
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-
-            for cache_control in ["private, max-age=0", "No-Store"] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                queue_html_response_with_cache_control(&stub, cache_control);
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response =
-                    run_with_slots(&settings, &services, &[], conditional_navigation_request())
-                        .await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some(cache_control),
-                    "inactive server-side ad templates should preserve private origin {cache_control} policy"
-                );
-                for (header_name, expected) in [
-                    (header::ETAG, ORIGIN_ETAG),
-                    (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
-                    (
-                        header::HeaderName::from_static("surrogate-control"),
-                        "max-age=300",
-                    ),
-                    (
-                        header::HeaderName::from_static("fastly-surrogate-control"),
-                        "max-age=300",
-                    ),
-                    (
-                        header::HeaderName::from_static("cdn-cache-control"),
-                        "max-age=300",
-                    ),
-                    (
-                        header::HeaderName::from_static("cloudflare-cdn-cache-control"),
-                        "max-age=300",
-                    ),
-                ] {
-                    assert_eq!(
-                        response_head
-                            .headers
-                            .get(&header_name)
-                            .and_then(|value| value.to_str().ok()),
-                        Some(expected),
-                        "inactive server-side ad templates should preserve {header_name}"
-                    );
-                }
-            }
-        }
-
-        #[tokio::test]
-        async fn request_scoped_ad_stack_suppression_preserves_origin_cache_policy() {
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-            let slots = [article_slot()];
-            let mut bot_request = conditional_navigation_request();
-            bot_request.headers_mut().insert(
-                "user-agent",
-                HeaderValue::from_static("Mozilla/5.0 (compatible; Googlebot/2.1)"),
-            );
-            let mut prefetch_request = conditional_navigation_request();
-            prefetch_request
-                .headers_mut()
-                .insert("sec-purpose", HeaderValue::from_static("prefetch"));
-
-            for (skip_reason, request, consent) in [
-                ("bot", bot_request, non_regulated_consent()),
-                ("prefetch", prefetch_request, non_regulated_consent()),
-                (
-                    "consent denied",
-                    conditional_navigation_request(),
-                    crate::consent::ConsentContext {
-                        jurisdiction: crate::consent::jurisdiction::Jurisdiction::Gdpr,
-                        ..Default::default()
-                    },
-                ),
-            ] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                queue_html_response_with_cache_control(&stub, "no-cache");
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response =
-                    run_with_slots_and_consent(&settings, &services, &slots, request, consent)
-                        .await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some("no-cache"),
-                    "{skip_reason} should retain the origin cache policy"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn absent_creative_opportunities_use_short_browser_cache_policy() {
-            // Arrange
-            let settings = settings_without_creative_opportunities();
-            let stub = Arc::new(StubHttpClient::new());
-            queue_html_response_with_cache_control(&stub, "no-cache");
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-
-            // Act
-            let response =
-                run_with_slots(&settings, &services, &[], conditional_navigation_request()).await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                response_head
-                    .headers
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, max-age=60"),
-                "absent creative opportunities should use the private inactive-stack cache policy"
-            );
-        }
-
-        #[tokio::test]
-        async fn inactive_ad_stack_preserves_non_ok_response_cache_policy() {
-            let settings = settings_with_disabled_ad_templates();
-
-            for status in [206, 404, 500, 503] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                queue_html_response_with_status_and_cache_control(&stub, status, "no-cache");
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response = run_with_slots(
-                    &settings,
-                    &services,
-                    &[article_slot()],
-                    conditional_navigation_request(),
-                )
-                .await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some("no-cache"),
-                    "inactive server-side ad templates should preserve origin policy on {status}"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn inactive_ad_stack_preserves_gpt_diagnostics_cache_privacy() {
-            // Arrange
-            let mut settings = settings_with_disabled_ad_templates();
-            settings
-                .integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should enable GPT diagnostics");
-            let stub = Arc::new(StubHttpClient::new());
-            queue_html_response_with_cache_control(&stub, "no-cache");
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let request = HttpRequest::builder()
-                .method(Method::GET)
-                .uri("https://ts.example.com/article?ts_console=1")
-                .header(header::HOST, "ts.example.com")
-                .header("sec-fetch-dest", "document")
-                .body(EdgeBody::empty())
-                .expect("should build GPT diagnostics request");
-
-            // Act
-            let response = run_with_slots(&settings, &services, &[article_slot()], request).await;
-            let response_head = response_head(response);
-
-            // Assert
-            assert_eq!(
-                response_head
-                    .headers
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, no-store"),
-                "active GPT diagnostics should retain cache privacy when server-side ad templates are inactive"
-            );
-        }
-
-        #[tokio::test]
-        async fn inactive_ad_stack_preserves_non_get_and_non_document_cache_policy() {
-            let settings = settings_with_disabled_ad_templates();
-
-            for request in [
-                HttpRequest::builder()
-                    .method(Method::POST)
-                    .uri("https://ts.example.com/article")
-                    .header(header::HOST, "ts.example.com")
-                    .header("sec-fetch-dest", "document")
-                    .body(EdgeBody::empty())
-                    .expect("should build non-GET document request"),
-                HttpRequest::builder()
-                    .method(Method::GET)
-                    .uri("https://ts.example.com/article")
-                    .header(header::HOST, "ts.example.com")
-                    .header("sec-fetch-dest", "empty")
-                    .body(EdgeBody::empty())
-                    .expect("should build non-document request"),
-            ] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                queue_html_response_with_cache_control(&stub, "no-cache");
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response =
-                    run_with_slots(&settings, &services, &[article_slot()], request).await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some("no-cache"),
-                    "inactive server-side ad templates should preserve non-document request policy"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn eligible_navigation_rejects_unexpected_origin_304() {
-            for content_type in [None, Some("text/html; charset=utf-8")] {
-                // Arrange
-                let settings = settings_with_dispatching_provider();
-                let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-                orchestrator.register_provider(Arc::new(DispatchingTestProvider));
-                let telemetry_sink = Arc::new(RecordingTelemetrySink::default());
-                let stub = Arc::new(StubHttpClient::new());
-
-                // `send_async` consumes the first response before the publisher
-                // origin request consumes the second response.
-                stub.push_response(200, b"unused provider response".to_vec());
-                let mut origin_headers = vec![
-                    ("cache-control", "public, max-age=300"),
-                    ("etag", ORIGIN_ETAG),
-                    ("last-modified", ORIGIN_LAST_MODIFIED),
-                    ("surrogate-control", "max-age=300"),
-                    ("fastly-surrogate-control", "max-age=300"),
-                ];
-                if let Some(content_type) = content_type {
-                    origin_headers.push(("content-type", content_type));
-                }
-                stub.push_response_with_headers(304, Vec::new(), origin_headers);
-                let services = services_with_telemetry(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
-                    Arc::clone(&telemetry_sink),
-                );
-                let slots = [article_slot()];
-
-                // Act
-                let response = run_with_orchestrator(
-                    &settings,
-                    &services,
-                    &orchestrator,
-                    &slots,
-                    conditional_navigation_request(),
-                )
-                .await;
-
-                // Assert
-                let response = match response {
-                    PublisherResponse::Buffered(response) => response,
-                    PublisherResponse::PassThrough { .. }
-                    | PublisherResponse::Stream { .. }
-                    | PublisherResponse::AssembleTemplate { .. } => {
-                        panic!("unexpected origin 304 should return a buffered response")
-                    }
-                };
-                assert_eq!(
-                    response.status(),
-                    StatusCode::BAD_GATEWAY,
-                    "eligible origin 304 should fail closed with or without Content-Type"
-                );
-                assert_eq!(
-                    response
-                        .headers()
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some("private, no-store"),
-                    "eligible origin 304 should return an explicitly non-storable response"
-                );
-                assert!(
-                    response
-                        .extensions()
-                        .get::<crate::response_privacy::TerminalPrivateResponse>()
-                        .is_some(),
-                    "invalid origin 304 response should remain private after late response effects"
-                );
-                for header_name in [
-                    header::ETAG,
-                    header::LAST_MODIFIED,
-                    header::HeaderName::from_static("surrogate-control"),
-                    header::HeaderName::from_static("fastly-surrogate-control"),
-                ] {
-                    assert!(
-                        !response.headers().contains_key(&header_name),
-                        "eligible origin 304 should not forward {header_name}"
-                    );
-                }
-
-                let batches = telemetry_sink
-                    .batches
-                    .lock()
-                    .expect("should lock telemetry batches");
-                let summary_rows: Vec<_> = batches
-                    .iter()
-                    .flat_map(AuctionEventBatch::rows)
-                    .filter(|row| row.event_kind == "summary")
-                    .collect();
-                assert_eq!(
-                    summary_rows.len(),
-                    1,
-                    "unexpected origin 304 should emit exactly one summary row"
-                );
-                assert_eq!(
-                    summary_rows[0].terminal_status.as_deref(),
-                    Some("abandoned"),
-                    "unexpected origin 304 should abandon the dispatched auction"
-                );
-                assert_eq!(
-                    summary_rows[0].terminal_reason.as_deref(),
-                    Some("unexpected_origin_304"),
-                    "unexpected origin 304 should use the bounded telemetry reason"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn inactive_ad_stack_304_uses_short_browser_cache_policy() {
-            // Arrange
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-            let stub = Arc::new(StubHttpClient::new());
-            stub.push_response_with_headers(
-                304,
-                Vec::new(),
-                vec![
-                    ("cache-control", "public, max-age=300"),
-                    ("etag", ORIGIN_ETAG),
-                    ("last-modified", ORIGIN_LAST_MODIFIED),
-                    ("surrogate-control", "max-age=300"),
-                    ("fastly-surrogate-control", "max-age=300"),
-                ],
-            );
-            let services = build_services_with_http_client(
-                Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-
-            // Act
-            let response =
-                run_with_slots(&settings, &services, &[], conditional_navigation_request()).await;
-
-            // Assert
-            let response = match response {
-                PublisherResponse::Buffered(response) => response,
-                PublisherResponse::PassThrough { .. }
-                | PublisherResponse::Stream { .. }
-                | PublisherResponse::AssembleTemplate { .. } => {
-                    panic!("noneligible origin 304 should remain buffered")
-                }
-            };
-            assert_eq!(
-                response.status(),
-                StatusCode::NOT_MODIFIED,
-                "inactive server-side ad templates should preserve the 304 status"
-            );
-            assert_eq!(
-                response
-                    .headers()
-                    .get(header::CACHE_CONTROL)
-                    .and_then(|value| value.to_str().ok()),
-                Some("private, max-age=60"),
-                "inactive server-side ad templates should apply the browser policy on revalidation"
-            );
-            for (header_name, expected) in [
-                (header::ETAG, ORIGIN_ETAG),
-                (header::LAST_MODIFIED, ORIGIN_LAST_MODIFIED),
-                (
-                    header::HeaderName::from_static("surrogate-control"),
-                    "max-age=300",
-                ),
-                (
-                    header::HeaderName::from_static("fastly-surrogate-control"),
-                    "max-age=300",
-                ),
-            ] {
-                assert_eq!(
-                    response
-                        .headers()
-                        .get(&header_name)
-                        .and_then(|value| value.to_str().ok()),
-                    Some(expected),
-                    "inactive server-side ad templates should preserve {header_name} on revalidation"
-                );
-            }
-            assert_eq!(
-                stub.recorded_cache_bypass_flags(),
-                vec![false],
-                "noneligible publisher navigation should use the default cache mode"
-            );
-            let recorded_requests = stub.recorded_request_headers();
-            let outbound_headers = recorded_requests
-                .first()
-                .expect("should record the outbound publisher request");
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_NONE_MATCH.as_str()),
-                Some(ORIGIN_ETAG),
-                "noneligible publisher request should preserve If-None-Match"
-            );
-            assert_eq!(
-                recorded_header(outbound_headers, header::IF_MODIFIED_SINCE.as_str()),
-                Some(ORIGIN_LAST_MODIFIED),
-                "noneligible publisher request should preserve If-Modified-Since"
-            );
-        }
-
-        #[tokio::test]
-        async fn inactive_ad_stack_304_preserves_private_origin_cache_policy() {
-            let settings = settings_with_enabled_auction_and_creative_opportunities();
-
-            for cache_control in ["private, max-age=0", "No-Store"] {
-                // Arrange
-                let stub = Arc::new(StubHttpClient::new());
-                stub.push_response_with_headers(
-                    304,
-                    Vec::new(),
-                    vec![("cache-control", cache_control), ("etag", ORIGIN_ETAG)],
-                );
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-
-                // Act
-                let response =
-                    run_with_slots(&settings, &services, &[], conditional_navigation_request())
-                        .await;
-                let response_head = response_head(response);
-
-                // Assert
-                assert_eq!(
-                    response_head
-                        .headers
-                        .get(header::CACHE_CONTROL)
-                        .and_then(|value| value.to_str().ok()),
-                    Some(cache_control),
-                    "inactive server-side ad templates should preserve origin {cache_control} policy on revalidation"
-                );
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn publisher_asset_cache_policy_applies_to_non_html_response() {
-        let settings = Settings::from_toml(&format!(
-            r#"{}
-
-            [[cache.asset_rules]]
-            id = "publisher-fingerprinted-assets"
-            enabled = true
-            path_globs = ["/assets/**/*.png"]
-            fingerprint_style = "hex"
-            visibility = "public"
-            browser_ttl_seconds = 31536000
-            edge_ttl_seconds = 31536000
-            immutable = true
-        "#,
-            crate_test_settings_str()
-        ))
-        .expect("should parse settings with cache rule");
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"png".to_vec(),
-            vec![
-                (header::CONTENT_TYPE.as_str(), "image/png"),
-                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
-            ],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let request = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/assets/logo.0123abcd.png")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let response = run_publisher_proxy(&settings, &services, request).await;
-        let PublisherResponse::PassThrough { response, .. } = response else {
-            panic!("should pass through non-HTML asset response");
-        };
-
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=31536000, s-maxage=31536000, immutable"),
-            "matched publisher asset should receive immutable browser and edge policy"
-        );
-        assert_eq!(
-            response
-                .headers()
-                .get("surrogate-control")
-                .and_then(|value| value.to_str().ok()),
-            None,
-            "S-maxage fallback should keep the edge TTL in Cache-Control"
-        );
-    }
-
-    #[tokio::test]
-    async fn publisher_asset_policy_response_with_cookie_is_private_after_finalization() {
-        let settings = Settings::from_toml(&format!(
-            r#"{}
-
-            [[cache.asset_rules]]
-            id = "publisher-fingerprinted-assets"
-            enabled = true
-            path_globs = ["/assets/**/*.png"]
-            fingerprint_style = "hex"
-            visibility = "public"
-            browser_ttl_seconds = 31536000
-            edge_ttl_seconds = 31536000
-            immutable = true
-        "#,
-            crate_test_settings_str()
-        ))
-        .expect("should parse settings with cache rule");
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"png".to_vec(),
-            vec![
-                (header::CONTENT_TYPE.as_str(), "image/png"),
-                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
-                (header::SET_COOKIE.as_str(), "viewer=example; Path=/"),
-            ],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let request = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/assets/logo.0123abcd.png")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let response = run_publisher_proxy(&settings, &services, request).await;
-        let PublisherResponse::PassThrough { mut response, .. } = response else {
-            panic!("should pass through non-HTML asset response");
-        };
-        crate::response_privacy::apply_response_headers_with_cache_privacy(
-            &settings,
-            &mut response,
-        );
-
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("private, max-age=0"),
-            "publisher asset with Set-Cookie must become private after finalization"
-        );
-        assert!(
-            response.headers().get("surrogate-control").is_none(),
-            "publisher asset with Set-Cookie must not retain a shared-cache header"
-        );
-    }
-
-    #[tokio::test]
-    async fn publisher_asset_cache_policy_skips_html_response() {
-        let settings = Settings::from_toml(&format!(
-            r#"{}
-
-            [[cache.asset_rules]]
-            id = "broad-publisher-path"
-            enabled = true
-            path_glob = "/news/*.html"
-            visibility = "public"
-            browser_ttl_seconds = 31536000
-            edge_ttl_seconds = 31536000
-            immutable = true
-            fingerprint_style = "hex"
-        "#,
-            crate_test_settings_str()
-        ))
-        .expect("should parse settings with cache rule");
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"<html><body>news</body></html>".to_vec(),
-            vec![
-                (header::CONTENT_TYPE.as_str(), "text/html; charset=utf-8"),
-                (header::CACHE_CONTROL.as_str(), "public, max-age=60"),
-            ],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let request = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/news/story.0123abcd.html")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let response = run_publisher_proxy(&settings, &services, request).await;
-        let response = match response {
-            PublisherResponse::Stream { response, .. } | PublisherResponse::Buffered(response) => {
-                response
-            }
-            PublisherResponse::PassThrough { .. } | PublisherResponse::AssembleTemplate { .. } => {
-                panic!("should classify HTML response for processing")
-            }
-        };
-
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=60"),
-            "asset policy must not apply shared asset caching to publisher HTML"
-        );
-        assert!(
-            response.headers().get("surrogate-control").is_none(),
-            "HTML response must not receive a shared-cache header"
-        );
-    }
-
-    #[tokio::test]
-    async fn publisher_request_uses_platform_http_client_with_http_types() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response(200, b"origin response".to_vec());
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let response = match run_publisher_proxy(&settings, &services, req).await {
-            PublisherResponse::Buffered(r) => r,
-            PublisherResponse::PassThrough { mut response, body } => {
-                *response.body_mut() = body;
-                response
-            }
-            PublisherResponse::Stream { response, .. }
-            | PublisherResponse::AssembleTemplate { response, .. } => response,
-        };
-
-        assert_eq!(response.status(), StatusCode::OK);
-        assert_eq!(response_body_string(response), "origin response");
-        assert_eq!(
-            stub.recorded_backend_names(),
-            vec!["stub-backend".to_string()],
-            "should proxy through the platform http client"
-        );
-    }
-
-    #[tokio::test]
-    async fn suppressed_navigation_removes_conditional_and_range_headers() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"<html><body>origin</body></html>".to_vec(),
-            vec![("content-type", "text/html; charset=utf-8")],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let mut req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .header("sec-fetch-dest", "document")
-            .header(header::IF_NONE_MATCH, "\"cached-page\"")
-            .header(header::IF_MODIFIED_SINCE, "Wed, 21 Oct 2015 07:28:00 GMT")
-            .header(header::RANGE, "bytes=0-18")
-            .header(header::IF_RANGE, "\"cached-page\"")
-            .body(EdgeBody::empty())
-            .expect("should build conditional request");
-        req.extensions_mut()
-            .insert(crate::integrations::datadome::DataDomeClientTagSuppressed);
-
-        let _response = run_publisher_proxy(&settings, &services, req).await;
-
-        let headers = stub
-            .recorded_request_headers()
-            .into_iter()
-            .next()
-            .expect("should record one outbound request");
-        for header_name in [
-            header::IF_NONE_MATCH,
-            header::IF_MODIFIED_SINCE,
-            header::RANGE,
-            header::IF_RANGE,
-        ] {
-            assert!(
-                headers
-                    .iter()
-                    .all(|(name, _)| !name.eq_ignore_ascii_case(header_name.as_str())),
-                "suppressed navigations must not forward {header_name}"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn suppressed_iframe_removes_conditional_and_range_headers() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"<html><body>frame</body></html>".to_vec(),
-            vec![("content-type", "text/html; charset=utf-8")],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let mut req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/frame")
-            .header(header::HOST, "publisher.example")
-            .header("sec-fetch-dest", "iframe")
-            .header(header::IF_NONE_MATCH, "\"cached-frame\"")
-            .header(header::IF_MODIFIED_SINCE, "Wed, 21 Oct 2015 07:28:00 GMT")
-            .header(header::RANGE, "bytes=0-18")
-            .header(header::IF_RANGE, "\"cached-frame\"")
-            .body(EdgeBody::empty())
-            .expect("should build conditional iframe request");
-        req.extensions_mut()
-            .insert(crate::integrations::datadome::DataDomeClientTagSuppressed);
-
-        let _response = run_publisher_proxy(&settings, &services, req).await;
-
-        let headers = stub
-            .recorded_request_headers()
-            .into_iter()
-            .next()
-            .expect("should record one outbound request");
-        for header_name in [
-            header::IF_NONE_MATCH,
-            header::IF_MODIFIED_SINCE,
-            header::RANGE,
-            header::IF_RANGE,
-        ] {
-            assert!(
-                headers
-                    .iter()
-                    .all(|(name, _)| !name.eq_ignore_ascii_case(header_name.as_str())),
-                "suppressed iframe documents must not forward {header_name}"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn suppressed_subresource_preserves_conditional_and_range_headers() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"video".to_vec(),
-            vec![("content-type", "video/mp4")],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let mut req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/video.mp4")
-            .header(header::HOST, "publisher.example")
-            .header("sec-fetch-dest", "video")
-            .header(header::IF_NONE_MATCH, "\"cached-video\"")
-            .header(header::IF_MODIFIED_SINCE, "Wed, 21 Oct 2015 07:28:00 GMT")
-            .header(header::RANGE, "bytes=0-18")
-            .header(header::IF_RANGE, "\"cached-video\"")
-            .body(EdgeBody::empty())
-            .expect("should build conditional subresource request");
-        req.extensions_mut()
-            .insert(crate::integrations::datadome::DataDomeClientTagSuppressed);
-
-        let _response = run_publisher_proxy(&settings, &services, req).await;
-
-        let headers = stub
-            .recorded_request_headers()
-            .into_iter()
-            .next()
-            .expect("should record one outbound request");
-        for (header_name, expected) in [
-            (header::IF_NONE_MATCH, "\"cached-video\""),
-            (header::IF_MODIFIED_SINCE, "Wed, 21 Oct 2015 07:28:00 GMT"),
-            (header::RANGE, "bytes=0-18"),
-            (header::IF_RANGE, "\"cached-video\""),
-        ] {
-            assert_eq!(
-                headers
-                    .iter()
-                    .find(|(name, _)| name.eq_ignore_ascii_case(header_name.as_str()))
-                    .map(|(_, value)| value.as_str()),
-                Some(expected),
-                "suppressed subresources should preserve {header_name}"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn publisher_origin_fetch_leaves_stream_response_disabled_when_unsupported() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"<html><body>origin</body></html>".to_vec(),
-            vec![("content-type", "text/html; charset=utf-8")],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let _ = run_publisher_proxy(&settings, &services, req).await;
-
-        assert_eq!(
-            stub.recorded_stream_response_flags(),
-            vec![false],
-            "publisher origin fetch must not request streams when the platform does not support them"
-        );
-    }
-
-    #[tokio::test]
-    async fn publisher_origin_fetch_sets_stream_response_when_supported() {
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.set_streaming_responses_supported(true);
-        stub.push_response_with_headers(
-            200,
-            b"<html><body>origin</body></html>".to_vec(),
-            vec![("content-type", "text/html; charset=utf-8")],
-        );
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let _ = run_publisher_proxy(&settings, &services, req).await;
-
-        assert_eq!(
-            stub.recorded_stream_response_flags(),
-            vec![true],
-            "publisher origin fetch should request streams when the platform supports them"
-        );
-    }
-
-    #[tokio::test]
-    async fn handle_publisher_request_does_not_self_generate_ec() {
-        // EC generation is the adapter's real-browser-gated responsibility. This
-        // handler must never mint an EC ID on its own: for a navigation from a
-        // client the adapter did not pre-generate for (e.g. a non-real browser),
-        // `ec_value` must stay `None` so no IP-derived identifier reaches the
-        // auction. Consent allows EC creation and a client IP is present here —
-        // exactly the conditions under which the old inline call would have
-        // generated one.
-        let settings = create_test_settings();
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response(200, b"<html><body>ok</body></html>".to_vec());
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-
-        let consent = crate::consent::ConsentContext {
-            jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-            ..Default::default()
-        };
-        let mut ec_context =
-            EcContext::new_for_test_with_ip(None, consent, Some("203.0.113.7".to_string()));
-        assert!(
-            ec_context.ec_allowed(),
-            "test precondition: consent must allow EC creation"
-        );
-
-        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-        let req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/article")
-            .header(header::HOST, "publisher.example")
-            .header("sec-fetch-dest", "document")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let _ = handle_publisher_request(
-            &settings,
-            &services,
-            None,
-            &mut ec_context,
-            AuctionDispatch {
-                orchestrator: &orchestrator,
-                slots: &[],
-                registry: None,
-            },
-            req,
-            EdgeCacheHeader::SMaxageFallback,
-        )
-        .await
-        .expect("should proxy publisher request");
-
-        assert_eq!(
-            ec_context.ec_value(),
-            None,
-            "handler must not self-generate an EC ID; generation is the adapter's real-browser-gated responsibility",
-        );
-    }
-
-    #[tokio::test]
-    async fn datadome_filter_marker_survives_into_publisher_html_pipeline() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "datadome",
-                &serde_json::json!({
-                    "enabled": true,
-                    "enable_protection": true,
-                    "server_side_key_secret_name": "server-side-key",
-                    "protection_excluded_ip_cidrs": ["192.0.2.0/24"],
-                    "client_side_key": "test-client-key",
-                }),
-            )
-            .expect("should configure DataDome integration");
-        let registry = IntegrationRegistry::new(&settings)
-            .expect("should create integration registry with DataDome");
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response_with_headers(
-            200,
-            b"<html><head></head><body>content</body></html>".to_vec(),
-            vec![("content-type", "text/html; charset=utf-8")],
-        );
-        let services = build_services_with_secret_http_client_and_client_ip(
-            NoopSecretStore,
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>,
-            Some("192.0.2.10".parse().expect("should parse client IP")),
-        );
-        let mut req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .header("sec-fetch-dest", "document")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let filter_outcome = registry
-            .filter_request(crate::integrations::RequestFilterRegistryInput {
-                settings: &settings,
-                services: &services,
-                req: &mut req,
-                geo_info: None,
-            })
-            .await
-            .expect("should run DataDome filter");
-        assert!(matches!(
-            filter_outcome,
-            crate::integrations::RequestFilterRegistryOutcome::Continue(_)
-        ));
-        let publisher_response = run_publisher_proxy(&settings, &services, req).await;
-        let response = buffer_publisher_response_async(
-            publisher_response,
-            &Method::GET,
-            &settings,
-            &registry,
-            &AuctionOrchestrator::new(settings.auction.clone()),
-            &services,
-        )
-        .await
-        .expect("should buffer publisher response");
-        let html = response_body_string(response);
-
-        assert!(!html.contains("window.ddjskey"));
-        assert!(!html.contains("/integrations/datadome/tags.js"));
-        assert_eq!(
-            stub.recorded_backend_names().len(),
-            1,
-            "only the publisher origin should be called"
-        );
-    }
-
-    #[test]
-    fn suppressed_datadome_tag_reaches_publisher_html_pipeline() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "datadome",
-                &serde_json::json!({
-                    "enabled": true,
-                    "client_side_key": "test-client-key",
-                }),
-            )
-            .expect("should configure DataDome integration");
-        let registry = IntegrationRegistry::new(&settings)
-            .expect("should create integration registry with DataDome");
-        let mut params = make_stream_params(&settings, "identity");
-        params.content_type = "text/html; charset=utf-8".to_string();
-        params.suppress_datadome_client_side_tag = true;
-        let mut output = Vec::new();
-
-        stream_publisher_body(
-            EdgeBody::from(b"<html><head></head><body>content</body></html>".to_vec()),
-            &mut output,
-            &params,
-            &settings,
-            &registry,
-        )
-        .expect("should process suppressed HTML");
-
-        let html = String::from_utf8(output).expect("should produce UTF-8 HTML");
-        assert!(
-            !html.contains("window.ddjskey"),
-            "publisher processing should omit the DataDome client configuration"
-        );
-        assert!(
-            !html.contains("/integrations/datadome/tags.js"),
-            "publisher processing should omit the DataDome client tag URL"
-        );
-    }
-
-    #[test]
-    fn suppressed_datadome_html_is_private_and_not_shared_cached() {
-        let mut response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CACHE_CONTROL, "public, max-age=600")
-            .header("surrogate-control", "max-age=600")
-            .header("fastly-surrogate-control", "max-age=600")
-            .header("cloudflare-cdn-cache-control", "max-age=600")
-            .header("cdn-cache-control", "max-age=600")
-            .header(header::ETAG, "\"origin-tag\"")
-            .header(header::LAST_MODIFIED, "Wed, 21 Oct 2015 07:28:00 GMT")
-            .body(EdgeBody::empty())
-            .expect("should build cacheable HTML response");
-
-        super::apply_datadome_client_tag_cache_privacy(
-            &mut response,
-            &Method::GET,
-            true,
-            "text/html; charset=utf-8",
-        );
-
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("private, no-store"),
-            "suppressed HTML should be private and non-storable"
-        );
-        assert!(
-            response.headers().get("surrogate-control").is_none(),
-            "suppressed HTML should not retain Surrogate-Control"
-        );
-        assert!(
-            response.headers().get("fastly-surrogate-control").is_none(),
-            "suppressed HTML should not retain Fastly-Surrogate-Control"
-        );
-        assert!(
-            response
-                .headers()
-                .get("cloudflare-cdn-cache-control")
-                .is_none(),
-            "suppressed HTML should not retain Cloudflare-CDN-Cache-Control"
-        );
-        assert!(
-            response.headers().get("cdn-cache-control").is_none(),
-            "suppressed HTML should not retain CDN-Cache-Control"
-        );
-        for header_name in [header::ETAG, header::LAST_MODIFIED] {
-            assert!(
-                !response.headers().contains_key(&header_name),
-                "suppressed HTML should not retain {header_name}"
-            );
-        }
-
-        let mut no_store_response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CACHE_CONTROL, "no-store")
-            .body(EdgeBody::empty())
-            .expect("should build no-store HTML response");
-        super::apply_datadome_client_tag_cache_privacy(
-            &mut no_store_response,
-            &Method::GET,
-            true,
-            "text/html; charset=utf-8",
-        );
-        assert_eq!(
-            no_store_response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("private, no-store"),
-            "suppressed HTML should use the exact synthesized-HTML policy"
-        );
-    }
-
-    #[test]
-    fn datadome_cache_privacy_does_not_change_non_html_or_unsuppressed_responses() {
-        let mut response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CACHE_CONTROL, "public, max-age=600")
-            .header("surrogate-control", "max-age=600")
-            .body(EdgeBody::empty())
-            .expect("should build cacheable response");
-
-        super::apply_datadome_client_tag_cache_privacy(
-            &mut response,
-            &Method::GET,
-            false,
-            "text/html; charset=utf-8",
-        );
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=600"),
-            "unsuppressed HTML should retain its existing cache policy"
-        );
-
-        super::apply_datadome_client_tag_cache_privacy(
-            &mut response,
-            &Method::GET,
-            true,
-            "text/css",
-        );
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=600"),
-            "non-HTML should retain its existing cache policy"
-        );
-    }
-
-    #[test]
-    fn response_carries_body_preserves_bodiless_metadata() {
-        // A processable GET 200 buffers a body and recomputes Content-Length.
-        assert!(
-            super::response_carries_body(&Method::GET, StatusCode::OK),
-            "a GET 200 publisher response should carry a buffered body"
-        );
-        // HEAD carries no body; recomputing Content-Length to 0 would mislead
-        // clients/caches about the GET representation length.
-        assert!(
-            !super::response_carries_body(&Method::HEAD, StatusCode::OK),
-            "HEAD publisher responses must not get a recomputed Content-Length"
-        );
-        // Bodiless statuses keep their metadata regardless of method.
-        assert!(
-            !super::response_carries_body(&Method::GET, StatusCode::NO_CONTENT),
-            "204 responses must not get a recomputed Content-Length"
-        );
-        assert!(
-            !super::response_carries_body(&Method::GET, StatusCode::RESET_CONTENT),
-            "205 responses must not get a recomputed Content-Length"
-        );
-        assert!(
-            !super::response_carries_body(&Method::GET, StatusCode::NOT_MODIFIED),
-            "304 responses must not get a recomputed Content-Length"
-        );
-    }
-
-    #[test]
-    fn dispatched_auction_guard_stays_armed_until_collection_completes() {
-        // `take()` hands the dispatched auction to the async collector, but the
-        // guard must stay armed across the collection await so a drop while
-        // collection is still pending (a client disconnect at the await point)
-        // still logs the loss. Only `disarm()` — called once collection reaches
-        // a terminal result — clears the warning.
-        let mut guard = DispatchedAuctionGuard::new(DispatchedAuction::empty_for_test(
-            test_auction_request(),
-            10,
-        ));
-        assert!(guard.armed, "a freshly dispatched guard should be armed");
-
-        let _dispatched = guard
-            .take()
-            .expect("guard should yield the dispatched auction for collection");
-        assert!(
-            guard.armed,
-            "guard must stay armed across the collection await so a drop mid-collection is reported"
-        );
-
-        guard.disarm();
-        assert!(
-            !guard.armed,
-            "guard must disarm once collection reaches a terminal result"
-        );
-    }
-
-    fn response_body_string(response: http::Response<EdgeBody>) -> String {
-        String::from_utf8(
-            response
-                .into_body()
-                .into_bytes()
-                .unwrap_or_default()
-                .to_vec(),
-        )
-        .expect("response body should be valid UTF-8")
-    }
-
-    #[test]
-    fn test_content_type_detection() {
-        let test_cases = vec![
-            ("text/html", true),
-            ("text/html; charset=utf-8", true),
-            ("Text/HTML; Charset=utf-8", true),
-            ("text/css", true),
-            ("Text/CSS", true),
-            ("text/javascript", true),
-            ("application/javascript", true),
-            ("Application/JavaScript", true),
-            ("application/json", true),
-            ("application/json; charset=utf-8", true),
-            ("Application/JSON; Charset=UTF-8", true),
-            ("image/jpeg", false),
-            ("image/png", false),
-            ("application/pdf", false),
-            ("video/mp4", false),
-            ("application/octet-stream", false),
-        ];
-
-        for (content_type, expected) in test_cases {
-            assert_eq!(
-                is_processable_content_type(content_type),
-                expected,
-                "Content-Type '{content_type}' should_process: expected {expected}",
-            );
-        }
-    }
-
-    #[test]
-    fn supported_content_encoding_accepts_known_values() {
-        assert!(is_supported_content_encoding(""), "should accept empty");
-        assert!(
-            is_supported_content_encoding("identity"),
-            "should accept identity"
-        );
-        assert!(is_supported_content_encoding("gzip"), "should accept gzip");
-        assert!(
-            is_supported_content_encoding("deflate"),
-            "should accept deflate"
-        );
-        assert!(is_supported_content_encoding("br"), "should accept br");
-    }
-
-    #[test]
-    fn supported_content_encoding_rejects_unknown_values() {
-        assert!(!is_supported_content_encoding("zstd"), "should reject zstd");
-        assert!(
-            !is_supported_content_encoding("compress"),
-            "should reject compress"
-        );
-        assert!(
-            !is_supported_content_encoding("snappy"),
-            "should reject snappy"
-        );
-    }
-
-    #[tokio::test]
-    async fn body_close_hold_loop_processes_close_tail_before_reading_post_body_chunks() {
-        let settings = create_test_settings();
-        let services = noop_services();
-        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-        let dispatched = DispatchedAuction::empty_for_test(test_auction_request(), 500);
-        let read_count = Arc::new(AtomicUsize::new(0));
-        let body_close_processed_at = Arc::new(AtomicUsize::new(0));
-        let reader = ChunkedReader::new(
-            &[
-                b"<html><body>painted</body>",
-                b"<script>late()</script>",
-                b"</html>",
-            ],
-            Arc::clone(&read_count),
-        );
-        let mut processor = RecordingProcessor {
-            read_count: Arc::clone(&read_count),
-            body_close_processed_at: Arc::clone(&body_close_processed_at),
-        };
-        let ad_bids_state = AdBidsState::default();
-        let ctx = AuctionCollectCtx {
-            dispatched,
-            telemetry: AuctionTelemetryCarry {
-                observation: None,
-                auction_request: None,
-            },
-            deps: AuctionCollectDeps {
-                price_granularity: PriceGranularity::default(),
-                ad_bids_state: &ad_bids_state,
-                orchestrator: &orchestrator,
-                services: &services,
-                settings: &settings,
-                request_origin: String::new(),
-            },
-        };
-        let mut output = Vec::new();
-
-        body_close_hold_loop(reader, &mut output, &mut processor, ctx)
-            .await
-            .expect("should stream body with auction hold");
-
-        assert_eq!(
-            body_close_processed_at.load(Ordering::SeqCst),
-            1,
-            "close-body tail should be processed as soon as it is found, before later chunks are read"
-        );
-        assert_eq!(
-            std::str::from_utf8(&output).expect("should be utf8"),
-            "<html><body>painted</body><script>late()</script></html>",
-            "post-body chunks should still stream in order"
-        );
-    }
-
-    #[tokio::test]
-    async fn hold_step_yields_ready_prefix_before_collecting_auction() {
-        // A small page whose `</body>` lands in the first source chunk must
-        // still stream its document prefix immediately. `hold_step_decoded_chunk`
-        // reports the ready prefix and `close_found` without collecting; only
-        // `hold_collect_close_tail` awaits collection. Regression guard for the
-        // #849 FCP objective: the prefix must become ready while collection
-        // remains pending.
-        let settings = create_test_settings();
-        let services = noop_services();
-        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-        let ad_bids_state = AdBidsState::default();
-        let mut state = AuctionHoldState::new(
-            DispatchedAuctionGuard::new(DispatchedAuction::empty_for_test(
-                test_auction_request(),
-                500,
-            )),
-            AuctionTelemetryCarry {
-                observation: None,
-                auction_request: None,
-            },
-        );
-        let collect_refs = AuctionCollectDeps {
-            price_granularity: PriceGranularity::default(),
-            ad_bids_state: &ad_bids_state,
-            orchestrator: &orchestrator,
-            services: &services,
-            settings: &settings,
-            request_origin: String::new(),
-        };
-        // Passthrough processor: the ordering contract is about collection, not
-        // HTML rewriting, so keep the emitted bytes verbatim.
-        let mut processor = RecordingProcessor {
-            read_count: Arc::new(AtomicUsize::new(0)),
-            body_close_processed_at: Arc::new(AtomicUsize::new(0)),
-        };
-        let mut encoder = BodyStreamEncoder::new(Compression::None);
-
-        let step = hold_step_decoded_chunk(
-            &mut processor,
-            &mut encoder,
-            b"<html><body>painted</body></html>",
-            &mut state,
-            &collect_refs,
-        )
-        .await
-        .expect("hold step should succeed");
-
-        assert!(
-            step.close_found,
-            "</body> in the first chunk must be detected"
-        );
-        let ready: Vec<u8> = step.ready.iter().flat_map(|b| b.to_vec()).collect();
-        assert_eq!(
-            std::str::from_utf8(&ready).expect("ready prefix should be utf8"),
-            "<html><body>painted",
-            "the prefix up to </body> must be ready before collection"
-        );
-        assert!(
-            ad_bids_state
-                .script_cell()
-                .lock()
-                .expect("should lock bid state")
-                .is_none(),
-            "auction must not be collected while the ready prefix is emitted"
-        );
-
-        let tail = hold_collect_close_tail(&mut processor, &mut encoder, &mut state, &collect_refs)
-            .await
-            .expect("collect should succeed");
-        let tail_bytes: Vec<u8> = tail.iter().flat_map(|b| b.to_vec()).collect();
-        assert_eq!(
-            std::str::from_utf8(&tail_bytes).expect("held tail should be utf8"),
-            "</body></html>",
-            "the held close tail must be emitted after collection"
-        );
-        assert!(
-            ad_bids_state
-                .script_cell()
-                .lock()
-                .expect("should lock bid state")
-                .is_some(),
-            "collection must run when the held tail is emitted"
-        );
-    }
-
-    #[test]
-    fn body_close_hold_buffer_holds_close_body_tail_in_single_chunk() {
-        let mut hold = BodyCloseHoldBuffer::new();
-
-        let ready = hold.push(b"<html><body>painted</body></html>");
-        let held = hold.finish();
-
-        assert_eq!(
-            std::str::from_utf8(&ready).expect("should be utf8"),
-            "<html><body>painted",
-            "content before </body> should stream before auction collection"
-        );
-        assert_eq!(
-            std::str::from_utf8(&held).expect("should be utf8"),
-            "</body></html>",
-            "the close-body tag and trailing bytes should be held"
-        );
-    }
-
-    #[test]
-    fn body_close_hold_buffer_holds_close_body_tail_across_chunks() {
-        let mut hold = BodyCloseHoldBuffer::new();
-
-        let first = hold.push(b"<html><body>painted</bo");
-        let second = hold.push(b"dy></html>");
-        let held = hold.finish();
-
-        let streamed = [first, second].concat();
-        assert_eq!(
-            std::str::from_utf8(&streamed).expect("should be utf8"),
-            "<html><body>painted",
-            "split </body> bytes must not leak before auction collection"
-        );
-        assert_eq!(
-            std::str::from_utf8(&held).expect("should be utf8"),
-            "</body></html>",
-            "split close-body tag should be held intact"
-        );
-    }
-
-    #[test]
-    fn unsupported_encoding_response_is_returned_unmodified() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::OK,
-                "text/html; charset=utf-8",
-                "zstd",
-                "example.com"
-            ),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn test_publisher_origin_host_extraction() {
-        let settings = create_test_settings();
-        let origin_host = settings.publisher.origin_host();
-        assert_eq!(origin_host, "origin.test-publisher.com");
-
-        let mut settings_with_port = create_test_settings();
-        settings_with_port.publisher.origin_url = "origin.test-publisher.com:8080".to_string();
-        assert_eq!(
-            settings_with_port.publisher.origin_host(),
-            "origin.test-publisher.com:8080"
-        );
-    }
-
-    #[test]
-    fn test_invalid_utf8_handling() {
-        let invalid_utf8_bytes = vec![0xFF, 0xFE, 0xFD];
-        assert!(String::from_utf8(invalid_utf8_bytes.clone()).is_err());
-    }
-
-    #[test]
-    fn test_utf8_conversion_edge_cases() {
-        let test_cases = vec![
-            (vec![0xE2, 0x98, 0x83], true),
-            (vec![0xF0, 0x9F, 0x98, 0x80], true),
-            (vec![0xFF, 0xFE], false),
-            (vec![0xC0, 0x80], false),
-            (vec![0xED, 0xA0, 0x80], false),
-        ];
-
-        for (bytes, should_be_valid) in test_cases {
-            let result = String::from_utf8(bytes.clone());
-            assert_eq!(
-                result.is_ok(),
-                should_be_valid,
-                "UTF-8 validation failed for bytes: {:?}",
-                bytes
-            );
-        }
-    }
-
-    #[test]
-    fn route_streams_2xx_html_without_post_processors() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::OK,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-        );
-    }
-
-    #[test]
-    fn route_streams_mixed_case_html_content_type() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::OK,
-                "Text/HTML; Charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-            "HTML MIME type matching must be case-insensitive",
-        );
-    }
-
-    #[test]
-    fn route_streams_html_with_post_processors() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::OK,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-        );
-    }
-
-    #[test]
-    fn route_streams_non_html_even_with_post_processors_registered() {
-        assert_eq!(
-            classify_response_route(StatusCode::OK, "application/json", "gzip", "example.com"),
-            ResponseRoute::Stream,
-        );
-    }
-
-    #[test]
-    fn route_buffers_unmodified_on_unsupported_encoding() {
-        assert_eq!(
-            classify_response_route(StatusCode::OK, "text/html", "zstd", "example.com"),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn route_passes_through_non_processable_2xx() {
-        assert_eq!(
-            classify_response_route(StatusCode::OK, "image/png", "", "example.com"),
-            ResponseRoute::PassThrough,
-        );
-    }
-
-    #[test]
-    fn route_buffers_non_processable_error_responses() {
-        assert_eq!(
-            classify_response_route(StatusCode::NOT_FOUND, "image/png", "", "example.com"),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn route_excludes_204_from_pass_through() {
-        assert_eq!(
-            classify_response_route(StatusCode::NO_CONTENT, "image/png", "", "example.com"),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn route_excludes_205_from_pass_through() {
-        assert_eq!(
-            classify_response_route(StatusCode::RESET_CONTENT, "image/png", "", "example.com"),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn route_excludes_204_for_processable_content_types() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::NO_CONTENT,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::BufferedUnmodified,
-            "204 + HTML must not route to Stream",
-        );
-        assert_eq!(
-            classify_response_route(
-                StatusCode::NO_CONTENT,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::BufferedUnmodified,
-            "204 + HTML + post-processors must not route to Stream",
-        );
-    }
-
-    #[test]
-    fn route_excludes_205_for_processable_content_types() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::RESET_CONTENT,
-                "application/json",
-                "",
-                "example.com"
-            ),
-            ResponseRoute::BufferedUnmodified,
-            "205 + JSON must not route to Stream",
-        );
-    }
-
-    #[test]
-    fn route_streams_non_2xx_processable_content() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::NOT_FOUND,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-        );
-        assert_eq!(
-            classify_response_route(
-                StatusCode::INTERNAL_SERVER_ERROR,
-                "application/json",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-        );
-    }
-
-    #[test]
-    fn route_streams_non_2xx_html_with_post_processors() {
-        assert_eq!(
-            classify_response_route(
-                StatusCode::NOT_FOUND,
-                "text/html; charset=utf-8",
-                "gzip",
-                "example.com"
-            ),
-            ResponseRoute::Stream,
-        );
-    }
-
-    #[test]
-    fn route_passes_through_non_processable_even_with_empty_request_host() {
-        assert_eq!(
-            classify_response_route(StatusCode::OK, "image/png", "", ""),
-            ResponseRoute::PassThrough,
-        );
-    }
-
-    #[test]
-    fn route_buffers_processable_content_with_empty_request_host() {
-        assert_eq!(
-            classify_response_route(StatusCode::OK, "text/html", "gzip", ""),
-            ResponseRoute::BufferedUnmodified,
-        );
-    }
-
-    #[test]
-    fn pass_through_preserves_body_and_content_length() {
-        let image_bytes: Vec<u8> = (0..=255).cycle().take(4096).collect();
-
-        let mut response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "image/png")
-            .header(header::CONTENT_LENGTH, image_bytes.len() as u64)
-            .body(EdgeBody::from(image_bytes.clone()))
-            .expect("should build test response");
-
-        // Simulate PassThrough: take body then reattach
-        let body = std::mem::replace(response.body_mut(), EdgeBody::empty());
-        // Body is unmodified — Content-Length stays correct
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CONTENT_LENGTH)
-                .and_then(|v| v.to_str().ok())
-                .expect("should have content-length"),
-            "4096",
-            "Content-Length should be preserved for pass-through"
-        );
-
-        // Reattach and verify body content
-        *response.body_mut() = body;
-        let (_, final_body) = response.into_parts();
-        let output = final_body.into_bytes().unwrap_or_default();
-        assert_eq!(
-            output, image_bytes,
-            "pass-through should preserve body byte-for-byte"
-        );
-    }
-
-    #[test]
-    fn test_content_encoding_detection() {
-        let test_encodings = vec!["gzip", "deflate", "br", "identity", ""];
-
-        for encoding in test_encodings {
-            let mut req = build_request(Method::GET, "https://test.example.com/page");
-            req.headers_mut().insert(
-                header::ACCEPT_ENCODING,
-                http::HeaderValue::from_static("gzip, deflate, br"),
-            );
-
-            if !encoding.is_empty() {
-                req.headers_mut().insert(
-                    header::CONTENT_ENCODING,
-                    http::HeaderValue::from_str(encoding)
-                        .expect("content encoding should be valid"),
-                );
-            }
-
-            let content_encoding = req
-                .headers()
-                .get(header::CONTENT_ENCODING)
-                .map(|h| h.to_str().unwrap_or_default())
-                .unwrap_or_default();
-
-            assert_eq!(content_encoding, encoding);
-        }
-    }
-
-    #[test]
-    fn publisher_proxy_does_not_add_accept_encoding_when_absent() {
-        let mut req = build_request(Method::GET, "https://test.example.com/page");
-        // No Accept-Encoding header set by the client.
-
-        restrict_accept_encoding(&mut req);
-
-        assert_eq!(
-            req.headers().get(header::ACCEPT_ENCODING),
-            None,
-            "publisher proxy should not inject Accept-Encoding when the client sent none"
-        );
-    }
-
-    #[test]
-    fn publisher_proxy_limits_accept_encoding_to_supported_values() {
-        let mut req = build_request(Method::GET, "https://test.example.com/page");
-        req.headers_mut().insert(
-            header::ACCEPT_ENCODING,
-            http::HeaderValue::from_static("gzip, deflate, br, zstd"),
-        );
-
-        restrict_accept_encoding(&mut req);
-
-        assert_eq!(
-            req.headers()
-                .get(header::ACCEPT_ENCODING)
-                .and_then(|value| value.to_str().ok()),
-            Some("gzip, deflate, br"),
-            "publisher fallback should only advertise encodings the rewrite pipeline supports"
-        );
-    }
-
-    #[test]
-    fn publisher_proxy_preserves_identity_only_accept_encoding() {
-        let mut req = build_request(Method::GET, "https://test.example.com/page");
-        req.headers_mut().insert(
-            header::ACCEPT_ENCODING,
-            http::HeaderValue::from_static("identity"),
-        );
-
-        restrict_accept_encoding(&mut req);
-
-        assert_eq!(
-            req.headers()
-                .get(header::ACCEPT_ENCODING)
-                .and_then(|value| value.to_str().ok()),
-            Some("identity"),
-            "publisher fallback should preserve identity-only clients"
-        );
-    }
-
-    #[test]
-    fn publisher_proxy_respects_supported_client_subset() {
-        let mut req = build_request(Method::GET, "https://test.example.com/page");
-        req.headers_mut().insert(
-            header::ACCEPT_ENCODING,
-            http::HeaderValue::from_static("br, gzip;q=0, zstd"),
-        );
-
-        restrict_accept_encoding(&mut req);
-
-        assert_eq!(
-            req.headers()
-                .get(header::ACCEPT_ENCODING)
-                .and_then(|value| value.to_str().ok()),
-            Some("br"),
-            "publisher fallback should only advertise the supported encodings the client accepts"
-        );
-    }
-
-    #[test]
-    fn publisher_proxy_falls_back_to_identity_for_unsupported_client_encodings() {
-        let mut req = build_request(Method::GET, "https://test.example.com/page");
-        req.headers_mut().insert(
-            header::ACCEPT_ENCODING,
-            http::HeaderValue::from_static("zstd"),
-        );
-
-        restrict_accept_encoding(&mut req);
-
-        assert_eq!(
-            req.headers()
-                .get(header::ACCEPT_ENCODING)
-                .and_then(|value| value.to_str().ok()),
-            Some("identity"),
-            "publisher fallback should request identity when the client only accepts unsupported encodings"
-        );
-    }
-
-    #[test]
-    fn esi_reader_encoding_negotiation_honours_quality_identity_and_repeated_fields() {
-        let headers = |values: &[&str]| {
-            let mut headers = edgezero_core::http::HeaderMap::new();
-            for value in values {
-                headers.append(
-                    header::ACCEPT_ENCODING,
-                    HeaderValue::from_str(value).expect("should build accept-encoding"),
-                );
-            }
-            headers
-        };
-
-        assert_eq!(
-            negotiate_reader_compression(&headers(&[])),
-            Ok(Compression::None)
-        );
-        assert_eq!(
-            negotiate_reader_compression(&headers(&["gzip;q=0.8", "br;q=0.4, identity;q=0.1"])),
-            Ok(Compression::Gzip)
-        );
-        assert_eq!(
-            negotiate_reader_compression(&headers(&["gzip, br"])),
-            Ok(Compression::Brotli),
-            "server preference breaks an equal-quality tie"
-        );
-        assert_eq!(
-            negotiate_reader_compression(&headers(&["gzip;q=0.5"])),
-            Ok(Compression::None),
-            "implicit identity has q=1"
-        );
-        assert_eq!(
-            negotiate_reader_compression(&headers(&["zstd, identity;q=0"])),
-            Err(ReaderEncodingError::NoAcceptableEncoding)
-        );
-        assert_eq!(
-            negotiate_reader_compression(&headers(&["gzip;q=invalid"])),
-            Err(ReaderEncodingError::Malformed)
-        );
-        for malformed in [
-            "gzip;q=1e-1",
-            "gzip;q=0.1234",
-            "gzip;q=1.001",
-            "not a coding;q=1",
-        ] {
-            assert_eq!(
-                negotiate_reader_compression(&headers(&[malformed])),
-                Err(ReaderEncodingError::Malformed),
-                "{malformed} is not valid Accept-Encoding syntax"
-            );
-        }
-    }
-
-    #[test]
-    fn tsjs_dynamic_returns_not_found_for_unknown_filename() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=unknown.js",
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-        assert_eq!(response.status(), StatusCode::NOT_FOUND);
-    }
-
-    #[test]
-    fn tsjs_dynamic_serves_unified_bundle_for_known_filename() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-unified.min.js",
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-        assert_eq!(response.status(), StatusCode::OK);
-    }
-
-    #[test]
-    fn tsjs_dynamic_serves_diagnostics_standalone_without_cookie_variance() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-            .expect("should enable diagnostics");
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let mut req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-gpt_diagnostics.min.js",
-        );
-        req.headers_mut().insert(
-            header::COOKIE,
-            HeaderValue::from_static("__Host-ts-console=1"),
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-
-        assert_eq!(response.status(), StatusCode::OK);
-        assert!(!response.headers().contains_key(header::SET_COOKIE));
-        assert!(
-            !response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok())
-                .is_some_and(|value| value.contains("private") || value.contains("no-store")),
-            "standalone module should remain cookie-independent and publicly cacheable"
-        );
-    }
-
-    #[test]
-    fn parse_single_module_filename_extracts_known_id() {
-        assert_eq!(
-            parse_single_module_filename("tsjs-sourcepoint.min.js"),
-            Some("sourcepoint"),
-            "should extract sourcepoint from minified filename"
-        );
-        assert_eq!(
-            parse_single_module_filename("tsjs-sourcepoint.js"),
-            Some("sourcepoint"),
-            "should extract sourcepoint from unminified filename"
-        );
-    }
-
-    #[test]
-    fn parse_single_module_filename_rejects_unknown_ids() {
-        assert_eq!(
-            parse_single_module_filename("tsjs-evil.min.js"),
-            None,
-            "should reject unknown module names"
-        );
-        assert_eq!(
-            parse_single_module_filename("tsjs-core.min.js"),
-            Some("core"),
-            "should accept any known module ID (deferred check happens in caller)"
-        );
-        assert_eq!(
-            parse_single_module_filename("prebid.min.js"),
-            None,
-            "should reject without tsjs- prefix"
-        );
-        assert_eq!(
-            parse_single_module_filename("tsjs-sourcepoint.txt"),
-            None,
-            "should reject non-js extension"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_serves_prebid_shim_when_enabled() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-prebid.min.js",
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-        assert_eq!(
-            response.status(),
-            StatusCode::OK,
-            "should serve the deferred prebid shim module when prebid is enabled"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_returns_not_found_for_disabled_deferred_module() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "prebid",
-                &serde_json::json!({
-                    "enabled": false,
-                    "external_bundle_url": "https://assets.example/prebid/trusted-prebid.js",
-                }),
-            )
-            .expect("should update prebid config");
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-prebid.min.js",
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-        assert_eq!(
-            response.status(),
-            StatusCode::NOT_FOUND,
-            "should return 404 for disabled deferred module"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_returns_not_found_for_arbitrary_module_name() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let req = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-evil.min.js",
-        );
-
-        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
-            .expect("should handle tsjs request");
-        assert_eq!(
-            response.status(),
-            StatusCode::NOT_FOUND,
-            "should reject unknown module names"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_uses_immutable_cache_for_matching_hash() {
-        let settings = create_test_settings();
-        let registry =
-            IntegrationRegistry::new(&settings).expect("should create integration registry");
-        let module_ids = registry.js_module_ids_immediate();
-        let hash = trusted_server_js::concatenated_hash(&module_ids);
-        let request = build_request(
-            Method::GET,
-            &format!("https://publisher.example/static/tsjs=tsjs-unified.min.js?v={hash}"),
-        );
-
-        let response = handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SurrogateControl)
-            .expect("should handle tsjs request");
-
-        assert_eq!(response.status(), StatusCode::OK);
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CACHE_CONTROL)
-                .and_then(|value| value.to_str().ok()),
-            Some("public, max-age=31536000, immutable"),
-            "matching content-versioned bundle should be immutable"
-        );
-        assert_eq!(
-            response
-                .headers()
-                .get("surrogate-control")
-                .and_then(|value| value.to_str().ok()),
-            Some("max-age=31536000"),
-            "matching content-versioned bundle should set the Fastly edge TTL"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_uses_cloudflare_edge_header_when_selected() {
-        let settings = create_test_settings();
-        let registry =
-            IntegrationRegistry::new(&settings).expect("should create integration registry");
-        let module_ids = registry.js_module_ids_immediate();
-        let hash = trusted_server_js::concatenated_hash(&module_ids);
-        let request = build_request(
-            Method::GET,
-            &format!("https://publisher.example/static/tsjs=tsjs-unified.min.js?v={hash}"),
-        );
-
-        let response = handle_tsjs_dynamic(
-            &request,
-            &registry,
-            EdgeCacheHeader::CloudflareCdnCacheControl,
-        )
-        .expect("should handle tsjs request");
-
-        assert_eq!(
-            response
-                .headers()
-                .get("cloudflare-cdn-cache-control")
-                .and_then(|value| value.to_str().ok()),
-            Some("max-age=31536000"),
-            "Cloudflare requests should use its edge cache header"
-        );
-        assert!(
-            response.headers().get("surrogate-control").is_none(),
-            "Cloudflare requests should not emit Fastly's edge cache header"
-        );
-    }
-
-    #[test]
-    fn tsjs_dynamic_keeps_short_cache_for_mismatched_hash() {
-        let settings = create_test_settings();
-        let registry =
-            IntegrationRegistry::new(&settings).expect("should create integration registry");
-        let request = build_request(
-            Method::GET,
-            "https://publisher.example/static/tsjs=tsjs-unified.min.js?v=not-the-hash",
-        );
-
-        let response = handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SurrogateControl)
-            .expect("should handle tsjs request");
-        let cache_control = response
-            .headers()
-            .get(header::CACHE_CONTROL)
-            .and_then(|value| value.to_str().ok())
-            .expect("should set cache-control");
-
-        assert_eq!(response.status(), StatusCode::OK);
-        assert!(
-            cache_control.contains("max-age=300") && !cache_control.contains("immutable"),
-            "mismatched hash should retain the short, mutable cache policy"
-        );
-        assert_eq!(
-            response
-                .headers()
-                .get("surrogate-control")
-                .and_then(|value| value.to_str().ok()),
-            Some("max-age=300, stale-while-revalidate=60, stale-if-error=86400"),
-            "mismatched hash should retain the short Fastly edge TTL"
-        );
-    }
-
-    #[tokio::test]
-    async fn publisher_request_sends_configured_host_header_override() {
-        let mut settings = create_test_settings();
-        settings.publisher.origin_host_header_override = Some("www.example.com".to_string());
-        let stub = Arc::new(StubHttpClient::new());
-        stub.push_response(200, b"origin response".to_vec());
-        let services = build_services_with_http_client(
-            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-        );
-        let req = HttpRequest::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example/page")
-            .header(header::HOST, "publisher.example")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        let _ = run_publisher_proxy(&settings, &services, req).await;
-
-        let recorded_headers = stub.recorded_request_headers();
-        let outbound_headers = recorded_headers
-            .first()
-            .expect("should record one outbound request");
-        let outbound_host = outbound_headers
-            .iter()
-            .find(|(name, _)| name.eq_ignore_ascii_case("host"))
-            .map(|(_, value)| value.as_str());
-
-        assert_eq!(
-            outbound_host,
-            Some("www.example.com"),
-            "should send configured host override to outbound request"
-        );
-    }
-
-    #[test]
-    fn stream_publisher_body_preserves_gzip_round_trip() {
-        use flate2::write::GzEncoder;
-        use std::io::Write;
-
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-
-        // Compress CSS containing an origin URL that should be rewritten.
-        // CSS uses the text URL replacer (not lol_html), so inline URLs are rewritten.
-        let html = b"body { background: url('https://origin.example.com/page'); }";
-        let mut compressed = Vec::new();
-        {
-            let mut encoder = GzEncoder::new(&mut compressed, flate2::Compression::default());
-            encoder.write_all(html).expect("should compress");
-            encoder.finish().expect("should finish compression");
-        }
-
-        let body = EdgeBody::from(compressed);
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: "gzip".to_string(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/css".to_string(),
-            ad_slots_script: None,
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-
-        let mut output = Vec::new();
-        stream_publisher_body(body, &mut output, &params, &settings, &registry)
-            .expect("should process gzip CSS");
-
-        // Decompress output
-        use flate2::read::GzDecoder;
-        use std::io::Read;
-        let mut decoder = GzDecoder::new(&output[..]);
-        let mut decompressed = String::new();
-        decoder
-            .read_to_string(&mut decompressed)
-            .expect("should decompress output");
-
-        assert!(
-            decompressed.contains("proxy.example.com"),
-            "should rewrite origin to proxy. Got: {decompressed}"
-        );
-        assert!(
-            !decompressed.contains("origin.example.com"),
-            "should not contain original host. Got: {decompressed}"
-        );
-    }
-
-    /// Empty origin body on the streaming route must produce no output
-    /// without erroring. Exercises the `Ok(0)` branch of `process_chunks`
-    /// plus the processor's `is_last=true, chunk=[]` terminal call.
-    #[test]
-    fn stream_publisher_body_handles_empty_body() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: String::new(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/html; charset=utf-8".to_string(),
-            ad_slots_script: None,
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-
-        let mut output = Vec::new();
-        stream_publisher_body(
-            EdgeBody::empty(),
-            &mut output,
-            &params,
-            &settings,
-            &registry,
-        )
-        .expect("should succeed on empty body");
-
-        assert!(
-            output.is_empty(),
-            "empty origin body should produce empty streaming output. Got: {output:?}"
-        );
-    }
-
-    #[test]
-    fn stream_publisher_body_rejects_stream_body_in_sync_path() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: String::new(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/html; charset=utf-8".to_string(),
-            ad_slots_script: None,
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-        let body = EdgeBody::from_stream(futures::stream::iter(vec![Ok::<_, io::Error>(
-            bytes::Bytes::from_static(b"<html><body>live</body></html>"),
-        )]));
-        let mut output = Vec::new();
-
-        let err = stream_publisher_body(body, &mut output, &params, &settings, &registry)
-            .expect_err("should reject stream body in sync path");
-
-        assert!(
-            format!("{err:?}").contains("streaming body"),
-            "should explain that Body::Stream is not supported by the sync path: {err:?}"
-        );
-    }
-
-    #[test]
-    fn body_chunk_source_yields_once_body_in_chunks() {
-        futures::executor::block_on(async {
-            let body = EdgeBody::from_bytes(bytes::Bytes::from_static(b"abcdef"));
-            let mut source = BodyChunkSource::new(body, 3).with_max_bytes(16);
-
-            assert_eq!(
-                source.next_chunk().await.expect("should read").as_deref(),
-                Some(&b"abc"[..]),
-                "should yield the first chunk"
-            );
-            assert_eq!(
-                source.next_chunk().await.expect("should read").as_deref(),
-                Some(&b"def"[..]),
-                "should yield the second chunk"
-            );
-            assert!(
-                source.next_chunk().await.expect("should read").is_none(),
-                "should end after buffered bytes are exhausted"
-            );
-        });
-    }
-
-    #[test]
-    fn body_chunk_source_preserves_stream_chunks() {
-        futures::executor::block_on(async {
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::from_static(b"first"),
-                bytes::Bytes::from_static(b"second"),
-            ]));
-            let mut source = BodyChunkSource::new(body, 3).with_max_bytes(16);
-
-            assert_eq!(
-                source.next_chunk().await.expect("should read").as_deref(),
-                Some(&b"first"[..]),
-                "stream chunks should pass through without re-chunking"
-            );
-            assert_eq!(
-                source.next_chunk().await.expect("should read").as_deref(),
-                Some(&b"second"[..]),
-                "stream chunks should preserve upstream boundaries"
-            );
-            assert!(
-                source.next_chunk().await.expect("should read").is_none(),
-                "should end after stream is exhausted"
-            );
-        });
-    }
-
-    #[test]
-    fn body_chunk_source_enforces_cumulative_raw_cap() {
-        futures::executor::block_on(async {
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::from_static(b"1234"),
-                bytes::Bytes::from_static(b"5678"),
-            ]));
-            let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE).with_max_bytes(6);
-
-            assert!(
-                source
-                    .next_chunk()
-                    .await
-                    .expect("first chunk should pass")
-                    .is_some(),
-                "first chunk should stay under cap"
-            );
-            let err = source
-                .next_chunk()
-                .await
-                .expect_err("second chunk should exceed cap");
-
-            assert!(
-                format!("{err:?}").contains("publisher origin body exceeded"),
-                "should report cumulative cap: {err:?}"
-            );
-        });
-    }
-
-    #[test]
-    fn stream_publisher_body_async_processes_stream_without_auction() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: String::new(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: None,
-                dispatched_auction: None,
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::from_static(b"body{background:url('https://origin.example.com/"),
-                bytes::Bytes::from_static(b"asset.png')}"),
-            ]));
-            let mut output = Vec::new();
-
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("stream body should process on async path");
-
-            let css = String::from_utf8(output).expect("should be valid UTF-8");
-            assert!(
-                css.contains("proxy.example.com"),
-                "should rewrite origin host while streaming. Got: {css}"
-            );
-            assert!(
-                !css.contains("origin.example.com"),
-                "should not leave origin host after rewrite. Got: {css}"
-            );
-        });
-    }
-
-    #[test]
-    fn stream_publisher_body_async_processes_gzip_stream_without_auction() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: "gzip".to_string(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: None,
-                dispatched_auction: None,
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let compressed =
-                gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            let split_at = compressed.len() / 2;
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ]));
-            let mut output = Vec::new();
-
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("gzip stream body should process on async path");
-
-            let css = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
-            assert!(
-                css.contains("proxy.example.com"),
-                "should rewrite origin host while streaming gzip. Got: {css}"
-            );
-            assert!(
-                !css.contains("origin.example.com"),
-                "should not leave origin host after gzip rewrite. Got: {css}"
-            );
-        });
-    }
-
-    #[test]
-    fn stream_publisher_body_async_processes_deflate_stream_without_auction() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: "deflate".to_string(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: None,
-                dispatched_auction: None,
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let compressed =
-                deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            let split_at = compressed.len() / 2;
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ]));
-            let mut output = Vec::new();
-
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("deflate stream body should process on async path");
-
-            let css = String::from_utf8(deflate_decode(&output)).expect("should be valid UTF-8");
-            assert!(
-                css.contains("proxy.example.com"),
-                "should rewrite origin host while streaming deflate. Got: {css}"
-            );
-            assert!(
-                !css.contains("origin.example.com"),
-                "should not leave origin host after deflate rewrite. Got: {css}"
-            );
-        });
-    }
-
-    #[test]
-    fn stream_publisher_body_async_processes_brotli_stream_without_auction() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: "br".to_string(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: None,
-                dispatched_auction: None,
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let compressed =
-                brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            let split_at = compressed.len() / 2;
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ]));
-            let mut output = Vec::new();
-
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("brotli stream body should process on async path");
-
-            let css = String::from_utf8(brotli_decode(&output)).expect("should be valid UTF-8");
-            assert!(
-                css.contains("proxy.example.com"),
-                "should rewrite origin host while streaming brotli. Got: {css}"
-            );
-            assert!(
-                !css.contains("origin.example.com"),
-                "should not leave origin host after brotli rewrite. Got: {css}"
-            );
-        });
-    }
-
-    #[test]
-    fn stream_publisher_body_async_rejects_truncated_brotli_stream() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: "br".to_string(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: None,
-                dispatched_auction: None,
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let compressed =
-                brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            let truncated = &compressed[..compressed.len() - 3];
-            let body =
-                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
-                    truncated,
-                )]));
-            let mut output = Vec::new();
-
-            let err = stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect_err("truncated brotli stream must fail instead of truncating silently");
-
-            assert!(
-                format!("{err:?}").contains("brotli"),
-                "should surface the brotli finalization failure: {err:?}"
-            );
-        });
-    }
-
-    fn non_html_stream_params(content_encoding: &str) -> OwnedProcessResponseParams {
-        OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: content_encoding.to_string(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/css".to_string(),
-            ad_slots_script: None,
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        }
-    }
-
-    #[test]
-    fn stream_publisher_body_async_rejects_truncated_gzip_stream() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = non_html_stream_params("gzip");
-            let compressed =
-                gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            let truncated = &compressed[..compressed.len() - 3];
-            let body =
-                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
-                    truncated,
-                )]));
-            let mut output = Vec::new();
-
-            let err = stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect_err("truncated gzip stream must fail instead of truncating silently");
-
-            assert!(
-                format!("{err:?}").contains("gzip"),
-                "should surface the gzip finalization failure: {err:?}"
-            );
-        });
-    }
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        assert!(!response.headers().contains_key(header::SET_COOKIE));
+        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+    }
 
     #[test]
-    fn stream_publisher_body_async_rejects_truncated_deflate_stream() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = non_html_stream_params("deflate");
-            let compressed =
-                deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-            // Cut into the deflate data itself, not just the adler32 trailer.
-            let truncated = &compressed[..compressed.len() / 2];
-            let body =
-                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
-                    truncated,
-                )]));
-            let mut output = Vec::new();
+    fn ts_console_legacy_cleanup_asset_is_not_a_tsjs_release_route() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::new(&settings).expect("should build registry");
+        let req = Request::builder()
+            .uri("https://publisher.example/static/tsjs=tsjs-gpt_diagnostics-bootstrap.min.js")
+            .body(EdgeBody::empty())
+            .expect("should build cleanup asset request");
 
-            let err = stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect_err("truncated deflate stream must fail instead of truncating silently");
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should serve cleanup asset");
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        assert_eq!(response.headers()[header::CACHE_CONTROL], "no-store");
+    }
 
-            assert!(
-                format!("{err:?}").contains("deflate"),
-                "should surface the deflate finalization failure: {err:?}"
-            );
-        });
+    #[test]
+    fn parse_single_module_filename_extracts_known_id() {
+        assert_eq!(
+            parse_single_module_filename("tsjs-sourcepoint_lifecycle.min.js"),
+            Some("sourcepoint_lifecycle"),
+            "should extract a catalogued deferred module from the exact filename"
+        );
+        assert_eq!(
+            parse_single_module_filename("tsjs-sourcepoint_lifecycle.js"),
+            None,
+            "should reject unminified aliases"
+        );
     }
 
     #[test]
-    fn stream_publisher_body_async_enforces_decoded_byte_cap() {
-        futures::executor::block_on(async {
-            let mut settings = create_test_settings();
-            // Raw compressed input stays tiny (well under the cap); only the
-            // decoded expansion exceeds it — the decompression-bomb case the
-            // raw-byte cap alone cannot catch.
-            settings.publisher.max_buffered_body_bytes = 1024;
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = non_html_stream_params("gzip");
-            let compressed = gzip_encode(&vec![b'a'; 64 * 1024]);
-            assert!(
-                compressed.len() < 1024,
-                "test precondition: compressed input must stay under the raw cap"
-            );
-            let body =
-                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from(compressed)]));
-            let mut output = Vec::new();
+    fn parse_single_module_filename_rejects_unknown_ids() {
+        assert_eq!(
+            parse_single_module_filename("tsjs-evil.min.js"),
+            None,
+            "should reject unknown module names"
+        );
+        assert_eq!(
+            parse_single_module_filename("tsjs-core.min.js"),
+            None,
+            "should reject reserved core as a standalone module"
+        );
+        assert_eq!(
+            parse_single_module_filename("prebid.min.js"),
+            None,
+            "should reject without tsjs- prefix"
+        );
+        assert_eq!(
+            parse_single_module_filename("tsjs-sourcepoint.txt"),
+            None,
+            "should reject non-js extension"
+        );
+    }
 
-            let err = stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect_err("decoded expansion past the cap must fail");
+    #[test]
+    fn tsjs_dynamic_serves_one_enabled_deferred_module_with_exact_hash() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config("osano", &serde_json::json!({ "enabled": true }))
+            .expect("should enable Osano lifecycle");
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let deferred = registry.tsjs_deferred_module_ids(selection);
+        let module_id = deferred
+            .iter()
+            .find(|module_id| **module_id != "diagnostics_presentation")
+            .expect("should enable one non-diagnostics deferred module");
+        let src = crate::tsjs::tsjs_single_module_script_src(module_id)
+            .expect("should name an enabled deferred module");
+        let req = build_request(Method::GET, &format!("https://publisher.example{src}"));
 
-            assert!(
-                format!("{err:?}").contains("decoded size exceeded"),
-                "should report the cumulative decoded cap: {err:?}"
-            );
-        });
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
+        assert_eq!(
+            response.status(),
+            StatusCode::OK,
+            "should serve an enabled deferred catalog module"
+        );
     }
 
     #[test]
-    fn body_chunk_source_resumes_after_cancelled_poll() {
-        futures::executor::block_on(async {
-            let mut pending_once = true;
-            let mut yielded = false;
-            let stream = futures::stream::poll_fn(move |cx| {
-                if pending_once {
-                    pending_once = false;
-                    cx.waker().wake_by_ref();
-                    return std::task::Poll::Pending;
-                }
-                if yielded {
-                    return std::task::Poll::Ready(None);
-                }
-                yielded = true;
-                std::task::Poll::Ready(Some(Ok::<_, io::Error>(bytes::Bytes::from_static(
-                    b"chunk",
-                ))))
-            });
-            let body = EdgeBody::from_stream(stream);
-            let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE);
-
-            {
-                // Poll the pull future once (Pending), then drop it —
-                // simulating a cancelled await (select/timeout wrapper).
-                let mut pull = Box::pin(source.next_chunk());
-                let waker = futures::task::noop_waker();
-                let mut context = std::task::Context::from_waker(&waker);
-                assert!(
-                    pull.as_mut().poll(&mut context).is_pending(),
-                    "first poll should be pending"
-                );
-            }
+    fn tsjs_dynamic_returns_not_found_for_disabled_deferred_module() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "prebid",
+                &serde_json::json!({
+                    "enabled": false,
+                    "external_bundle_url": "https://assets.example/prebid/trusted-prebid.js",
+                }),
+            )
+            .expect("should update prebid config");
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let req = build_request(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-prebid.min.js",
+        );
 
-            let chunk = source
-                .next_chunk()
-                .await
-                .expect("should read after cancelled poll");
-            assert_eq!(
-                chunk.as_deref(),
-                Some(&b"chunk"[..]),
-                "cancelled pull must not lose the origin stream"
-            );
-        });
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
+        assert_eq!(
+            response.status(),
+            StatusCode::NOT_FOUND,
+            "should return 404 for disabled deferred module"
+        );
     }
 
     #[test]
-    fn stream_publisher_body_async_processes_stream_with_auction_hold() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let state = AdBidsState::default();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: String::new(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/html; charset=utf-8".to_string(),
-                ad_slots_script: Some(
-                    r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
-                        .to_string(),
-                ),
-                ad_bids_state: state,
-                auction_observation: None,
-                auction_request: Some(test_auction_request()),
-                dispatched_auction: Some(DispatchedAuction::empty_for_test(
-                    test_auction_request(),
-                    10,
-                )),
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let body = EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::from_static(b"<html><head></head><body>hello"),
-                bytes::Bytes::from_static(b"</body></html>"),
-            ]));
-            let mut output = Vec::new();
+    fn tsjs_dynamic_returns_not_found_for_arbitrary_module_name() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let req = build_request(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-evil.min.js",
+        );
 
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("stream body with auction should process on async path");
+        let response = handle_tsjs_dynamic(&req, &registry, EdgeCacheHeader::SMaxageFallback)
+            .expect("should handle tsjs request");
+        assert_eq!(
+            response.status(),
+            StatusCode::NOT_FOUND,
+            "should reject unknown module names"
+        );
+    }
 
-            let html = String::from_utf8(output).expect("should be valid UTF-8");
-            assert!(
-                html.contains("hello"),
-                "should preserve streamed HTML content. Got: {html}"
-            );
-            assert!(
-                html.contains(".adSlots=JSON.parse"),
-                "should still inject ad slots. Got: {html}"
-            );
-            assert!(
-                html.contains("var b=JSON.parse("),
-                "should collect auction and inject bids before body close. Got: {html}"
-            );
-        });
+    #[test]
+    fn tsjs_dynamic_uses_immutable_cache_for_matching_hash() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let src = registry
+            .tsjs_takeover_artifact(selection)
+            .expect("should precompute selected takeover artifact")
+            .src();
+        let request = build_request(Method::GET, &format!("https://publisher.example{src}"));
+
+        let response = handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SurrogateControl)
+            .expect("should handle tsjs request");
+
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CACHE_CONTROL)
+                .and_then(|value| value.to_str().ok()),
+            Some("public, max-age=31536000, immutable"),
+            "matching content-versioned bundle should be immutable"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get("surrogate-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("max-age=31536000"),
+            "matching content-versioned bundle should set the Fastly edge TTL"
+        );
     }
 
     #[test]
-    fn stream_publisher_body_async_auction_hold_decodes_multi_member_gzip_buffered() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let state = AdBidsState::default();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: "gzip".to_string(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/html; charset=utf-8".to_string(),
-                ad_slots_script: Some(
-                    r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
-                        .to_string(),
-                ),
-                ad_bids_state: state,
-                auction_observation: None,
-                auction_request: Some(test_auction_request()),
-                dispatched_auction: Some(DispatchedAuction::empty_for_test(
-                    test_auction_request(),
-                    10,
-                )),
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            // The `</body>` that triggers bid injection lives in the SECOND gzip
-            // member. `flate2::read::GzDecoder` decodes only the first member, so
-            // this buffered `Body::Once` body (the non-stream auction arm) proves
-            // the multi-member decoder now reads every member.
-            let mut compressed = gzip_encode(b"<html><head></head><body>hello");
-            compressed.extend(gzip_encode(b"</body></html>"));
-            let body = EdgeBody::from(compressed);
-            let mut output = Vec::new();
+    fn tsjs_dynamic_uses_cloudflare_edge_header_when_selected() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let selection = registry
+            .tsjs_static_transport_selections(false)
+            .pop()
+            .expect("should expose one transport selection");
+        let src = registry
+            .tsjs_takeover_artifact(selection)
+            .expect("should precompute selected takeover artifact")
+            .src();
+        let request = build_request(Method::GET, &format!("https://publisher.example{src}"));
 
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("buffered multi-member gzip auction body should process");
+        let response = handle_tsjs_dynamic(
+            &request,
+            &registry,
+            EdgeCacheHeader::CloudflareCdnCacheControl,
+        )
+        .expect("should handle tsjs request");
 
-            let html = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
-            assert!(
-                html.contains("hello"),
-                "should decode the first gzip member. Got: {html}"
-            );
-            assert!(
-                html.contains("</body></html>"),
-                "should decode the second gzip member that a single-member decoder drops. Got: {html}"
-            );
-            assert!(
-                html.contains("var b=JSON.parse("),
-                "should inject bids before the </body> carried in the second member. Got: {html}"
-            );
-        });
+        assert_eq!(
+            response
+                .headers()
+                .get("cloudflare-cdn-cache-control")
+                .and_then(|value| value.to_str().ok()),
+            Some("max-age=31536000"),
+            "Cloudflare requests should use its edge cache header"
+        );
+        assert!(
+            response.headers().get("surrogate-control").is_none(),
+            "Cloudflare requests should not emit Fastly's edge cache header"
+        );
     }
 
     #[test]
-    fn stream_publisher_body_async_processes_non_html_stream_after_auction_collect() {
-        futures::executor::block_on(async {
-            let settings = create_test_settings();
-            let registry = IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry");
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let services = noop_services();
-            let mut params = OwnedProcessResponseParams {
-                csp_nonce_observed: None,
-                template_cache_key: None,
-                seam_ad_slots: None,
-                policy_headers: Vec::new(),
-                content_encoding: String::new(),
-                origin_host: "origin.example.com".to_string(),
-                origin_url: "https://origin.example.com".to_string(),
-                request_host: "proxy.example.com".to_string(),
-                request_scheme: "https".to_string(),
-                content_type: "text/css".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: None,
-                auction_request: Some(test_auction_request()),
-                dispatched_auction: Some(DispatchedAuction::empty_for_test(
-                    test_auction_request(),
-                    10,
-                )),
-                price_granularity: crate::price_bucket::PriceGranularity::default(),
-                gpt_diagnostics: None,
-                suppress_datadome_client_side_tag: false,
-            };
-            let body = EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
-                b"body{background:url('https://origin.example.com/asset.png')}",
-            )]));
-            let mut output = Vec::new();
-
-            stream_publisher_body_async(
-                body,
-                &mut output,
-                &mut params,
-                &settings,
-                &registry,
-                &orchestrator,
-                &services,
-            )
-            .await
-            .expect("non-html stream body should process after auction collection");
+    fn tsjs_dynamic_rejects_mismatched_hash_without_caching() {
+        let settings = create_test_settings();
+        let registry =
+            IntegrationRegistry::new(&settings).expect("should create integration registry");
+        let request = build_request(
+            Method::GET,
+            "https://publisher.example/static/tsjs=tsjs-unified.min.js?v=not-the-hash",
+        );
 
-            let css = String::from_utf8(output).expect("should be valid UTF-8");
-            assert!(
-                css.contains("proxy.example.com"),
-                "should rewrite non-html stream after auction collection. Got: {css}"
-            );
-            assert!(
-                !css.contains("origin.example.com"),
-                "should not leave origin host after rewrite. Got: {css}"
-            );
-        });
+        let response = handle_tsjs_dynamic(&request, &registry, EdgeCacheHeader::SurrogateControl)
+            .expect("should handle tsjs request");
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+        assert_eq!(
+            response.headers().get(header::CACHE_CONTROL),
+            Some(&HeaderValue::from_static("no-store")),
+            "a mismatched content address must fail closed without caching"
+        );
+        assert!(!response.headers().contains_key("surrogate-control"));
     }
 
-    fn drain_streaming_finalize_body(content_encoding: &str, body: EdgeBody) -> Vec<u8> {
-        let settings = Arc::new(create_test_settings());
-        let registry = Arc::new(
-            IntegrationRegistry::with_plan(
-                &settings,
-                Arc::new(
-                    crate::auction::compile_auction_plan(&settings)
-                        .expect("should compile auction plan"),
-                ),
-            )
-            .expect("should create integration registry"),
+    #[tokio::test]
+    async fn publisher_request_sends_configured_host_header_override() {
+        let mut settings = create_test_settings();
+        settings.publisher.origin_host_header_override = Some("www.example.com".to_string());
+        let stub = Arc::new(StubHttpClient::new());
+        stub.push_response(200, b"origin response".to_vec());
+        let services = build_services_with_http_client(
+            Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
         );
-        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-        let services = noop_services();
-        let response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "text/css")
+        let req = HttpRequest::builder()
+            .method(Method::GET)
+            .uri("https://publisher.example/page")
+            .header(header::HOST, "publisher.example")
             .body(EdgeBody::empty())
-            .expect("should build response");
+            .expect("should build request");
+
+        let _ = run_publisher_proxy(&settings, &services, req).await;
+
+        let recorded_headers = stub.recorded_request_headers();
+        let outbound_headers = recorded_headers
+            .first()
+            .expect("should record one outbound request");
+        let outbound_host = outbound_headers
+            .iter()
+            .find(|(name, _)| name.eq_ignore_ascii_case("host"))
+            .map(|(_, value)| value.as_str());
+
+        assert_eq!(
+            outbound_host,
+            Some("www.example.com"),
+            "should send configured host override to outbound request"
+        );
+    }
+
+    #[test]
+    fn stream_publisher_body_preserves_gzip_round_trip() {
+        use flate2::write::GzEncoder;
+        use std::io::Write;
+
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+
+        // Compress CSS containing an origin URL that should be rewritten.
+        // CSS uses the text URL replacer (not lol_html), so inline URLs are rewritten.
+        let html = b"body { background: url('https://origin.example.com/page'); }";
+        let mut compressed = Vec::new();
+        {
+            let mut encoder = GzEncoder::new(&mut compressed, flate2::Compression::default());
+            encoder.write_all(html).expect("should compress");
+            encoder.finish().expect("should finish compression");
+        }
+
+        let body = EdgeBody::from(compressed);
         let params = OwnedProcessResponseParams {
             csp_nonce_observed: None,
             template_cache_key: None,
             seam_ad_slots: None,
             policy_headers: Vec::new(),
-            content_encoding: content_encoding.to_string(),
+            content_encoding: "gzip".to_string(),
             origin_host: "origin.example.com".to_string(),
             origin_url: "https://origin.example.com".to_string(),
             request_host: "proxy.example.com".to_string(),
@@ -16638,544 +11546,762 @@ mod tests {
             price_granularity: crate::price_bucket::PriceGranularity::default(),
             gpt_diagnostics: None,
             suppress_datadome_client_side_tag: false,
-        };
-        let publisher_response = PublisherResponse::Stream {
-            response,
-            body,
-            params: Box::new(params),
+            render_trace_overlay: false,
         };
 
-        let response = futures::executor::block_on(publisher_response_into_streaming_response(
-            publisher_response,
-            &Method::GET,
-            Arc::clone(&settings),
-            registry.as_ref(),
-            orchestrator,
-            services,
-        ))
-        .expect("should build streaming response");
+        let mut output = Vec::new();
+        stream_publisher_body(body, &mut output, &params, &settings, &registry)
+            .expect("should process gzip CSS");
+
+        // Decompress output
+        use flate2::read::GzDecoder;
+        use std::io::Read;
+        let mut decoder = GzDecoder::new(&output[..]);
+        let mut decompressed = String::new();
+        decoder
+            .read_to_string(&mut decompressed)
+            .expect("should decompress output");
 
         assert!(
-            matches!(response.body(), EdgeBody::Stream(_)),
-            "streaming finalize should keep a lazy Body::Stream"
+            decompressed.contains("proxy.example.com"),
+            "should rewrite origin to proxy. Got: {decompressed}"
+        );
+        assert!(
+            !decompressed.contains("origin.example.com"),
+            "should not contain original host. Got: {decompressed}"
         );
-
-        futures::executor::block_on(
-            response
-                .into_body()
-                .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
-        )
-        .expect("streaming body should drain")
-        .to_vec()
     }
 
+    /// Empty origin body on the streaming route must produce no output
+    /// without erroring. Exercises the `Ok(0)` branch of `process_chunks`
+    /// plus the processor's `is_last=true, chunk=[]` terminal call.
     #[test]
-    fn publisher_response_streaming_finalize_keeps_stream_body_lazy() {
-        let body_bytes = drain_streaming_finalize_body(
-            "",
-            EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
-                b"body{background:url('https://origin.example.com/asset.png')}",
-            )])),
-        );
-        let css = String::from_utf8(body_bytes).expect("should be valid UTF-8");
+    fn stream_publisher_body_handles_empty_body() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: String::new(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html; charset=utf-8".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+
+        let mut output = Vec::new();
+        stream_publisher_body(
+            EdgeBody::empty(),
+            &mut output,
+            &params,
+            &settings,
+            &registry,
+        )
+        .expect("should succeed on empty body");
+
         assert!(
-            css.contains("proxy.example.com"),
-            "streaming response body should still run publisher rewriting. Got: {css}"
+            output.is_empty(),
+            "empty origin body should produce empty streaming output. Got: {output:?}"
         );
+    }
+
+    #[test]
+    fn stream_publisher_body_rejects_stream_body_in_sync_path() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: String::new(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html; charset=utf-8".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+        let body = EdgeBody::from_stream(futures::stream::iter(vec![Ok::<_, io::Error>(
+            bytes::Bytes::from_static(b"<html><body>live</body></html>"),
+        )]));
+        let mut output = Vec::new();
+
+        let err = stream_publisher_body(body, &mut output, &params, &settings, &registry)
+            .expect_err("should reject stream body in sync path");
+
         assert!(
-            !css.contains("origin.example.com"),
-            "streaming response body should not leave origin URLs unrewritten. Got: {css}"
+            format!("{err:?}").contains("streaming body"),
+            "should explain that Body::Stream is not supported by the sync path: {err:?}"
         );
     }
 
-    /// An origin body stream that yields `chunk` once and then stays `Pending`
-    /// forever without ever signalling EOF — modelling an origin that has sent
-    /// the document head but not yet finished the response.
-    fn origin_chunk_then_pending(chunk: bytes::Bytes) -> EdgeBody {
-        let mut sent = false;
-        EdgeBody::from_stream(futures::stream::poll_fn(move |_cx| {
-            if sent {
-                return std::task::Poll::Pending;
-            }
-            sent = true;
-            std::task::Poll::Ready(Some(Ok::<_, io::Error>(chunk.clone())))
-        }))
-    }
+    #[test]
+    fn body_chunk_source_yields_once_body_in_chunks() {
+        futures::executor::block_on(async {
+            let body = EdgeBody::from_bytes(bytes::Bytes::from_static(b"abcdef"));
+            let mut source = BodyChunkSource::new(body, 3).with_max_bytes(16);
 
-    /// Poll a lazy `Body::Stream` exactly once and return the first emitted
-    /// chunk. Panics if the first poll is `Pending` (nothing emitted before the
-    /// origin would need its next chunk) or the stream ends.
-    fn first_lazy_body_chunk(body: EdgeBody) -> bytes::Bytes {
-        let mut stream = body
-            .into_stream()
-            .expect("streaming finalize should keep a lazy Body::Stream");
-        let waker = futures::task::noop_waker();
-        let mut cx = std::task::Context::from_waker(&waker);
-        let next = futures::StreamExt::next(&mut stream);
-        let mut next = std::pin::pin!(next);
-        match std::future::Future::poll(next.as_mut(), &mut cx) {
-            std::task::Poll::Ready(Some(Ok(bytes))) => bytes,
-            std::task::Poll::Ready(other) => {
-                panic!("first poll must emit a chunk, got Ready({other:?})")
-            }
-            std::task::Poll::Pending => {
-                panic!("first poll must emit rewritten content before origin EOF, got Pending")
-            }
-        }
+            assert_eq!(
+                source.next_chunk().await.expect("should read").as_deref(),
+                Some(&b"abc"[..]),
+                "should yield the first chunk"
+            );
+            assert_eq!(
+                source.next_chunk().await.expect("should read").as_deref(),
+                Some(&b"def"[..]),
+                "should yield the second chunk"
+            );
+            assert!(
+                source.next_chunk().await.expect("should read").is_none(),
+                "should end after buffered bytes are exhausted"
+            );
+        });
     }
 
-    fn streaming_finalize_response(params: OwnedProcessResponseParams, body: EdgeBody) -> EdgeBody {
-        streaming_finalize_response_with_settings(params, body, create_test_settings())
+    #[test]
+    fn body_chunk_source_preserves_stream_chunks() {
+        futures::executor::block_on(async {
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::from_static(b"first"),
+                bytes::Bytes::from_static(b"second"),
+            ]));
+            let mut source = BodyChunkSource::new(body, 3).with_max_bytes(16);
+
+            assert_eq!(
+                source.next_chunk().await.expect("should read").as_deref(),
+                Some(&b"first"[..]),
+                "stream chunks should pass through without re-chunking"
+            );
+            assert_eq!(
+                source.next_chunk().await.expect("should read").as_deref(),
+                Some(&b"second"[..]),
+                "stream chunks should preserve upstream boundaries"
+            );
+            assert!(
+                source.next_chunk().await.expect("should read").is_none(),
+                "should end after stream is exhausted"
+            );
+        });
     }
 
-    fn streaming_finalize_response_with_settings(
-        params: OwnedProcessResponseParams,
-        body: EdgeBody,
-        settings: Settings,
-    ) -> EdgeBody {
-        let settings = Arc::new(settings);
-        let registry = Arc::new(
-            IntegrationRegistry::with_plan(
+    #[test]
+    fn body_chunk_source_enforces_cumulative_raw_cap() {
+        futures::executor::block_on(async {
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::from_static(b"1234"),
+                bytes::Bytes::from_static(b"5678"),
+            ]));
+            let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE).with_max_bytes(6);
+
+            assert!(
+                source
+                    .next_chunk()
+                    .await
+                    .expect("first chunk should pass")
+                    .is_some(),
+                "first chunk should stay under cap"
+            );
+            let err = source
+                .next_chunk()
+                .await
+                .expect_err("second chunk should exceed cap");
+
+            assert!(
+                format!("{err:?}").contains("publisher origin body exceeded"),
+                "should report cumulative cap: {err:?}"
+            );
+        });
+    }
+
+    #[test]
+    fn stream_publisher_body_async_processes_stream_without_auction() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
                 &settings,
                 Arc::new(
                     crate::auction::compile_auction_plan(&settings)
                         .expect("should compile auction plan"),
                 ),
             )
-            .expect("should create integration registry"),
-        );
-        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-        let services = noop_services();
-        let response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, &params.content_type)
-            .body(EdgeBody::empty())
-            .expect("should build response");
-        let publisher_response = PublisherResponse::Stream {
-            response,
-            body,
-            params: Box::new(params),
-        };
-        futures::executor::block_on(publisher_response_into_streaming_response(
-            publisher_response,
-            &Method::GET,
-            Arc::clone(&settings),
-            registry.as_ref(),
-            orchestrator,
-            services,
-        ))
-        .expect("should build streaming response")
-        .into_body()
-    }
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: String::new(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: None,
+                dispatched_auction: None,
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::from_static(b"body{background:url('https://origin.example.com/"),
+                bytes::Bytes::from_static(b"asset.png')}"),
+            ]));
+            let mut output = Vec::new();
 
-    fn html_stream_params(
-        content_encoding: &str,
-        dispatched_auction: Option<DispatchedAuction>,
-    ) -> OwnedProcessResponseParams {
-        OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: content_encoding.to_string(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/html; charset=utf-8".to_string(),
-            ad_slots_script: Some(
-                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
-                    .to_string(),
-            ),
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: dispatched_auction.as_ref().map(|_| test_auction_request()),
-            dispatched_auction,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        }
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("stream body should process on async path");
+
+            let css = String::from_utf8(output).expect("should be valid UTF-8");
+            assert!(
+                css.contains("proxy.example.com"),
+                "should rewrite origin host while streaming. Got: {css}"
+            );
+            assert!(
+                !css.contains("origin.example.com"),
+                "should not leave origin host after rewrite. Got: {css}"
+            );
+        });
     }
 
     #[test]
-    fn streaming_finalize_emits_gam_attribution_head_before_origin_eof() {
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "gpt",
-                &serde_json::json!({
-                    "enabled": true,
-                    "gam_attribution_enabled": true
-                }),
+    fn stream_publisher_body_async_processes_gzip_stream_without_auction() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
             )
-            .expect("should insert GPT config");
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: "gzip".to_string(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: None,
+                dispatched_auction: None,
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let compressed =
+                gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            let split_at = compressed.len() / 2;
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ]));
+            let mut output = Vec::new();
 
-        let body = streaming_finalize_response_with_settings(
-            html_stream_params("", None),
-            origin_chunk_then_pending(bytes::Bytes::from_static(
-                b"<html><head></head><body><p>origin remains pending</p>",
-            )),
-            settings,
-        );
-        let html = String::from_utf8(first_lazy_body_chunk(body).to_vec())
-            .expect("should emit UTF-8 HTML");
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("gzip stream body should process on async path");
 
-        assert!(
-            html.contains("__tsjs_gam_attribution_enabled=true"),
-            "first rewritten head chunk should carry the primary activation flag: {html}"
-        );
-        assert!(
-            html.contains("data-ts-gam-attribution=\"true\""),
-            "first rewritten head chunk should authorize the bundle fallback: {html}"
-        );
+            let css = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
+            assert!(
+                css.contains("proxy.example.com"),
+                "should rewrite origin host while streaming gzip. Got: {css}"
+            );
+            assert!(
+                !css.contains("origin.example.com"),
+                "should not leave origin host after gzip rewrite. Got: {css}"
+            );
+        });
     }
 
     #[test]
-    fn streaming_finalize_emits_compressed_html_before_origin_eof() {
-        // The FCP regression from #849: the lazy body must emit its first
-        // rewritten, browser-decodable chunk as soon as the origin delivers one
-        // block — not buffer the whole (compressed) response until EOF. The
-        // origin here sends one gzip member and then stays Pending; the first
-        // poll must still yield gzip bytes that decode to the streamed content.
-        // The page exceeds the deflate decoder's internal output buffer so the
-        // first decoded block flushes downstream before the (never-arriving)
-        // EOF, exactly as a real page does.
-        let mut page = b"<html><head></head><body>".to_vec();
-        for i in 0..4000 {
-            page.extend(format!("<p>hello world paragraph {i}</p>").bytes());
-        }
-        let params = html_stream_params("gzip", None);
-        let body = streaming_finalize_response(
-            params,
-            origin_chunk_then_pending(bytes::Bytes::from(gzip_encode(&page))),
-        );
-
-        let first = first_lazy_body_chunk(body);
-        assert!(
-            !first.is_empty(),
-            "first emitted gzip chunk must not be empty"
-        );
-
-        // Decode the flushed (not finished) gzip prefix the way a browser would
-        // decode bytes received so far while the response is still open.
-        let mut decoder = flate2::write::MultiGzDecoder::new(Vec::new());
-        decoder
-            .write_all(&first)
-            .expect("first chunk must be valid gzip");
-        decoder.flush().expect("should flush gzip decoder");
-        let decoded = String::from_utf8(decoder.get_ref().clone()).expect("should be valid UTF-8");
-        assert!(
-            decoded.contains("hello world"),
-            "first poll must emit decodable streamed content before EOF. Got: {decoded}"
-        );
-    }
+    fn stream_publisher_body_async_processes_deflate_stream_without_auction() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: "deflate".to_string(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: None,
+                dispatched_auction: None,
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let compressed =
+                deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            let split_at = compressed.len() / 2;
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ]));
+            let mut output = Vec::new();
 
-    #[test]
-    fn streaming_finalize_auction_hold_emits_prefix_before_origin_eof() {
-        // The auction-hold path must stream the document prefix (up to the held
-        // `</body>` tail) before the origin finishes and before the auction is
-        // collected — otherwise the hold reintroduces the FCP regression. The
-        // origin sends the head/body prefix (no `</body>`) then stays Pending.
-        let page = b"<html><head></head><body><p>hello</p><p>more streamed content here</p>";
-        let params = html_stream_params(
-            "",
-            Some(DispatchedAuction::empty_for_test(
-                test_auction_request(),
-                10,
-            )),
-        );
-        let body = streaming_finalize_response(
-            params,
-            origin_chunk_then_pending(bytes::Bytes::from(&page[..])),
-        );
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("deflate stream body should process on async path");
 
-        let first = first_lazy_body_chunk(body);
-        let html = String::from_utf8(first.to_vec()).expect("should be valid UTF-8");
-        assert!(
-            html.contains("hello"),
-            "auction-hold path must stream the prefix before EOF. Got: {html}"
-        );
-        assert!(
-            html.contains(".adSlots=JSON.parse"),
-            "prefix must carry the injected (rewritten) head before EOF. Got: {html}"
-        );
-        assert!(
-            !html.contains("var b=JSON.parse("),
-            "bids inject only at </body> after collection, which the first poll must not wait for. Got: {html}"
-        );
+            let css = String::from_utf8(deflate_decode(&output)).expect("should be valid UTF-8");
+            assert!(
+                css.contains("proxy.example.com"),
+                "should rewrite origin host while streaming deflate. Got: {css}"
+            );
+            assert!(
+                !css.contains("origin.example.com"),
+                "should not leave origin host after deflate rewrite. Got: {css}"
+            );
+        });
     }
 
     #[test]
-    fn streaming_finalize_auction_hold_emits_small_compressed_page_before_collection() {
-        // A small gzip page arrives as one origin chunk whose whole expansion
-        // fits inside `flate2`'s internal decode buffer, and its `</body>` lands
-        // in that same chunk. Both stages that could withhold it must not: the
-        // decoder sync-flushes per source chunk instead of holding output until
-        // its own finalization, and the finish path emits the decoder tail
-        // before awaiting collection. Otherwise the client holds committed
-        // headers and an empty body until the auction resolves.
-        let page = b"<html><head></head><body><p>small compressed page</p></body></html>";
-        let params = html_stream_params(
-            "gzip",
-            Some(DispatchedAuction::empty_for_test(
-                test_auction_request(),
-                500,
-            )),
-        );
-        let body = streaming_finalize_response(
-            params,
-            origin_chunk_then_pending(bytes::Bytes::from(gzip_encode(page))),
-        );
+    fn stream_publisher_body_async_processes_brotli_stream_without_auction() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: "br".to_string(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: None,
+                dispatched_auction: None,
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let compressed =
+                brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            let split_at = compressed.len() / 2;
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ]));
+            let mut output = Vec::new();
 
-        let first = first_lazy_body_chunk(body);
-        // Decode the flushed (not finished) prefix the way a browser decodes the
-        // bytes received while the response is still open.
-        let mut decoder = flate2::write::MultiGzDecoder::new(Vec::new());
-        decoder
-            .write_all(&first)
-            .expect("first chunk must be valid gzip");
-        decoder.flush().expect("should flush gzip decoder");
-        let decoded = String::from_utf8(decoder.get_ref().clone()).expect("should be valid UTF-8");
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("brotli stream body should process on async path");
 
-        assert!(
-            decoded.contains("small compressed page"),
-            "first poll must emit the decoded document prefix of a small gzip page. Got: {decoded}"
-        );
-        assert!(
-            !decoded.contains("var b=JSON.parse("),
-            "bids inject only at </body> after collection, which the first poll must not wait for. Got: {decoded}"
-        );
+            let css = String::from_utf8(brotli_decode(&output)).expect("should be valid UTF-8");
+            assert!(
+                css.contains("proxy.example.com"),
+                "should rewrite origin host while streaming brotli. Got: {css}"
+            );
+            assert!(
+                !css.contains("origin.example.com"),
+                "should not leave origin host after brotli rewrite. Got: {css}"
+            );
+        });
     }
 
-    // (method, status, expected Content-Length, expected Transfer-Encoding)
-    // after bodiless normalization. 204 forbids Content-Length (removed); 205
-    // must advertise a zero-length body; HEAD and 304 legitimately advertise the
-    // GET representation length. Chunked framing is stripped from 204 (forbidden
-    // by RFC 9112 §6.1) and 205 (would conflict with the inserted
-    // `Content-Length: 0`), but preserved for HEAD and 304, whose message length
-    // is fixed by the header section regardless of framing fields
-    // (RFC 9112 §6.3, rule 1).
-    const BODILESS_FRAMING_CASES: [(Method, StatusCode, Option<&str>, Option<&str>); 4] = [
-        (Method::HEAD, StatusCode::OK, Some("42"), Some("chunked")),
-        (Method::GET, StatusCode::NO_CONTENT, None, None),
-        (Method::GET, StatusCode::RESET_CONTENT, Some("0"), None),
-        (
-            Method::GET,
-            StatusCode::NOT_MODIFIED,
-            Some("42"),
-            Some("chunked"),
-        ),
-    ];
+    #[test]
+    fn stream_publisher_body_async_rejects_truncated_brotli_stream() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: "br".to_string(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: None,
+                dispatched_auction: None,
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let compressed =
+                brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            let truncated = &compressed[..compressed.len() - 3];
+            let body =
+                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
+                    truncated,
+                )]));
+            let mut output = Vec::new();
 
-    /// Assert the framing fields left on a normalized bodiless response.
-    fn assert_bodiless_framing(
-        response: &Response<EdgeBody>,
-        method: &Method,
-        status: StatusCode,
-        expected_length: Option<&str>,
-        expected_transfer_encoding: Option<&str>,
-    ) {
-        let header_value = |name: header::HeaderName| {
-            response
-                .headers()
-                .get(name)
-                .and_then(|value| value.to_str().ok())
-                .map(str::to_owned)
-        };
-        assert_eq!(
-            header_value(header::CONTENT_LENGTH).as_deref(),
-            expected_length,
-            "bodiless {method} {status} must carry the corrected Content-Length"
-        );
-        assert_eq!(
-            header_value(header::TRANSFER_ENCODING).as_deref(),
-            expected_transfer_encoding,
-            "bodiless {method} {status} must carry the corrected Transfer-Encoding"
-        );
-        assert_eq!(
-            header_value(header::TRAILER).as_deref(),
-            // `Trailer` only describes fields a chunked body can carry, so it
-            // survives exactly where chunked framing does.
-            expected_transfer_encoding.map(|_| "expires"),
-            "bodiless {method} {status} must drop Trailer with its chunked framing"
-        );
+            let err = stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect_err("truncated brotli stream must fail instead of truncating silently");
+
+            assert!(
+                format!("{err:?}").contains("brotli"),
+                "should surface the brotli finalization failure: {err:?}"
+            );
+        });
+    }
+
+    fn non_html_stream_params(content_encoding: &str) -> OwnedProcessResponseParams {
+        OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: content_encoding.to_string(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/css".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        }
     }
 
     #[test]
-    fn publisher_response_streaming_finalize_normalizes_bodiless_framing() {
-        // Fastly requests the origin body as a stream before classification, so
-        // a buffered-unmodified response can hold an `EdgeBody::Stream`. The
-        // adapter streams any `EdgeBody::Stream` to the client, so bodiless
-        // responses must carry no body and correct framing per status.
-        let settings = Arc::new(create_test_settings());
-        let registry = Arc::new(
-            IntegrationRegistry::with_plan(
+    fn stream_publisher_body_async_rejects_truncated_gzip_stream() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
                 &settings,
                 Arc::new(
                     crate::auction::compile_auction_plan(&settings)
                         .expect("should compile auction plan"),
                 ),
             )
-            .expect("should create integration registry"),
-        );
-        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-
-        for (method, status, expected_length, expected_transfer_encoding) in BODILESS_FRAMING_CASES
-        {
-            let response = Response::builder()
-                .status(status)
-                .header(header::CONTENT_LENGTH, "42")
-                .header(header::TRANSFER_ENCODING, "chunked")
-                .header(header::TRAILER, "expires")
-                .body(EdgeBody::stream(futures::stream::iter(vec![
-                    bytes::Bytes::from_static(b"origin body bytes that must not reach the client"),
-                ])))
-                .expect("should build response");
-            let publisher_response = PublisherResponse::Buffered(response);
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = non_html_stream_params("gzip");
+            let compressed =
+                gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            let truncated = &compressed[..compressed.len() - 3];
+            let body =
+                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
+                    truncated,
+                )]));
+            let mut output = Vec::new();
 
-            let response = futures::executor::block_on(publisher_response_into_streaming_response(
-                publisher_response,
-                &method,
-                Arc::clone(&settings),
-                registry.as_ref(),
-                Arc::clone(&orchestrator),
-                noop_services(),
-            ))
-            .expect("should finalize buffered response");
+            let err = stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect_err("truncated gzip stream must fail instead of truncating silently");
 
             assert!(
-                !matches!(response.body(), EdgeBody::Stream(_)),
-                "bodiless {method} {status} must not carry a streaming body"
-            );
-            assert_bodiless_framing(
-                &response,
-                &method,
-                status,
-                expected_length,
-                expected_transfer_encoding,
+                format!("{err:?}").contains("gzip"),
+                "should surface the gzip finalization failure: {err:?}"
             );
+        });
+    }
 
-            let drained = futures::executor::block_on(
-                response
-                    .into_body()
-                    .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
+    #[test]
+    fn stream_publisher_body_async_rejects_truncated_deflate_stream() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
             )
-            .expect("body should drain")
-            .to_vec();
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = non_html_stream_params("deflate");
+            let compressed =
+                deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+            // Cut into the deflate data itself, not just the adler32 trailer.
+            let truncated = &compressed[..compressed.len() / 2];
+            let body =
+                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::copy_from_slice(
+                    truncated,
+                )]));
+            let mut output = Vec::new();
+
+            let err = stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect_err("truncated deflate stream must fail instead of truncating silently");
+
             assert!(
-                drained.is_empty(),
-                "bodiless {method} {status} must deliver zero body bytes, got {} bytes",
-                drained.len()
+                format!("{err:?}").contains("deflate"),
+                "should surface the deflate finalization failure: {err:?}"
             );
-        }
+        });
     }
 
     #[test]
-    fn buffer_publisher_response_normalizes_bodiless_framing() {
-        // The buffered finalizer (Axum/Cloudflare/Spin) must correct bodiless
-        // framing identically to the streaming finalizer.
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-        let services = noop_services();
-
-        for (method, status, expected_length, expected_transfer_encoding) in BODILESS_FRAMING_CASES
-        {
-            let response = Response::builder()
-                .status(status)
-                .header(header::CONTENT_LENGTH, "42")
-                .header(header::TRANSFER_ENCODING, "chunked")
-                .header(header::TRAILER, "expires")
-                .body(EdgeBody::from(
-                    b"origin body bytes that must not reach the client".to_vec(),
-                ))
-                .expect("should build response");
-            let publisher_response = PublisherResponse::Buffered(response);
+    fn stream_publisher_body_async_enforces_decoded_byte_cap() {
+        futures::executor::block_on(async {
+            let mut settings = create_test_settings();
+            // Raw compressed input stays tiny (well under the cap); only the
+            // decoded expansion exceeds it — the decompression-bomb case the
+            // raw-byte cap alone cannot catch.
+            settings.publisher.max_buffered_body_bytes = 1024;
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = non_html_stream_params("gzip");
+            let compressed = gzip_encode(&vec![b'a'; 64 * 1024]);
+            assert!(
+                compressed.len() < 1024,
+                "test precondition: compressed input must stay under the raw cap"
+            );
+            let body =
+                EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from(compressed)]));
+            let mut output = Vec::new();
 
-            let response = futures::executor::block_on(buffer_publisher_response_async(
-                publisher_response,
-                &method,
+            let err = stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
                 &settings,
                 &registry,
                 &orchestrator,
                 &services,
-            ))
-            .expect("should finalize buffered response");
+            )
+            .await
+            .expect_err("decoded expansion past the cap must fail");
+
+            assert!(
+                format!("{err:?}").contains("decoded size exceeded"),
+                "should report the cumulative decoded cap: {err:?}"
+            );
+        });
+    }
+
+    #[test]
+    fn body_chunk_source_resumes_after_cancelled_poll() {
+        futures::executor::block_on(async {
+            let mut pending_once = true;
+            let mut yielded = false;
+            let stream = futures::stream::poll_fn(move |cx| {
+                if pending_once {
+                    pending_once = false;
+                    cx.waker().wake_by_ref();
+                    return std::task::Poll::Pending;
+                }
+                if yielded {
+                    return std::task::Poll::Ready(None);
+                }
+                yielded = true;
+                std::task::Poll::Ready(Some(Ok::<_, io::Error>(bytes::Bytes::from_static(
+                    b"chunk",
+                ))))
+            });
+            let body = EdgeBody::from_stream(stream);
+            let mut source = BodyChunkSource::new(body, STREAM_CHUNK_SIZE);
 
-            assert_bodiless_framing(
-                &response,
-                &method,
-                status,
-                expected_length,
-                expected_transfer_encoding,
-            );
+            {
+                // Poll the pull future once (Pending), then drop it —
+                // simulating a cancelled await (select/timeout wrapper).
+                let mut pull = Box::pin(source.next_chunk());
+                let waker = futures::task::noop_waker();
+                let mut context = std::task::Context::from_waker(&waker);
+                assert!(
+                    pull.as_mut().poll(&mut context).is_pending(),
+                    "first poll should be pending"
+                );
+            }
 
-            let drained = futures::executor::block_on(
-                response
-                    .into_body()
-                    .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
-            )
-            .expect("body should drain")
-            .to_vec();
-            assert!(
-                drained.is_empty(),
-                "bodiless {method} {status} must deliver zero body bytes, got {} bytes",
-                drained.len()
+            let chunk = source
+                .next_chunk()
+                .await
+                .expect("should read after cancelled poll");
+            assert_eq!(
+                chunk.as_deref(),
+                Some(&b"chunk"[..]),
+                "cancelled pull must not lose the origin stream"
             );
-        }
-    }
-
-    #[derive(Default)]
-    struct RecordingTelemetrySink {
-        batches: Mutex<Vec<crate::auction::telemetry::AuctionEventBatch>>,
-    }
-
-    #[async_trait::async_trait(?Send)]
-    impl crate::auction::telemetry::AuctionTelemetrySink for RecordingTelemetrySink {
-        async fn emit_auction_events(
-            &self,
-            _services: &RuntimeServices,
-            batch: crate::auction::telemetry::AuctionEventBatch,
-        ) -> Result<(), Report<TrustedServerError>> {
-            self.batches
-                .lock()
-                .expect("should lock telemetry batches")
-                .push(batch);
-            Ok(())
-        }
+        });
     }
 
     #[test]
-    fn finalizers_emit_abandoned_auction_for_bodiless_dispatched_response() {
-        // A conditional navigation can dispatch an auction and receive a
-        // processable HTML 304 that classification routes to Stream. The
-        // bodiless response has no `</body>` to inject into, so the dispatched
-        // auction is never collected — but both finalizers must still emit a
-        // terminal abandonment event so the SSP work and quota consumption stay
-        // observable instead of vanishing silently.
-        let settings = Arc::new(create_test_settings());
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-
-        let make_params = || {
-            let ec_context =
-                EcContext::new_for_test(None, crate::consent::types::ConsentContext::default());
-            OwnedProcessResponseParams {
+    fn stream_publisher_body_async_collects_exact_projection_before_head_boot() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let state = AdBidsState::default();
+            let auction_request = test_auction_request();
+            let mut params = OwnedProcessResponseParams {
                 csp_nonce_observed: None,
                 template_cache_key: None,
                 seam_ad_slots: None,
@@ -17186,345 +12312,244 @@ mod tests {
                 request_host: "proxy.example.com".to_string(),
                 request_scheme: "https".to_string(),
                 content_type: "text/html; charset=utf-8".to_string(),
-                ad_slots_script: None,
-                ad_bids_state: AdBidsState::default(),
-                auction_observation: Some(AuctionObservationContext::from_parts(
-                    AuctionSource::SpaNavigation,
-                    "proxy.example.com",
-                    "/article",
-                    1,
-                    &ec_context,
-                )),
-                auction_request: Some(test_auction_request()),
+                ad_slots_script: Some(
+                    r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
+                        .to_string(),
+                ),
+                ad_bids_state: state,
+                auction_observation: None,
+                auction_request: Some(auction_request.clone()),
                 dispatched_auction: Some(DispatchedAuction::empty_for_test(
-                    test_auction_request(),
+                    auction_request.clone(),
                     10,
                 )),
-                price_granularity: PriceGranularity::default(),
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
                 gpt_diagnostics: None,
                 suppress_datadome_client_side_tag: false,
-            }
-        };
-        let make_stream_response = || PublisherResponse::Stream {
-            response: Response::builder()
-                .status(StatusCode::NOT_MODIFIED)
-                .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
-                .body(EdgeBody::empty())
-                .expect("should build 304 response"),
-            body: EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
-                b"<html></html>",
-            )])),
-            params: Box::new(make_params()),
-        };
-
-        fn assert_bodiless_abandoned(sink: &RecordingTelemetrySink) {
-            let batches = sink.batches.lock().expect("should lock telemetry batches");
-            assert_eq!(
-                batches.len(),
-                1,
-                "bodiless dispatched response should emit exactly one terminal batch"
-            );
-            let reasons: Vec<String> = batches[0]
-                .rows()
-                .iter()
-                .filter_map(|row| row.terminal_reason.clone())
-                .collect();
-            assert!(
-                reasons.iter().any(|reason| reason == "bodiless_response"),
-                "abandonment must carry the bodiless_response reason, got {reasons:?}"
-            );
-        }
-
-        // Streaming finalizer (Fastly).
-        let streaming_sink = Arc::new(RecordingTelemetrySink::default());
-        let response = futures::executor::block_on(publisher_response_into_streaming_response(
-            make_stream_response(),
-            &Method::GET,
-            Arc::clone(&settings),
-            &registry,
-            Arc::clone(&orchestrator),
-            noop_services_with_telemetry_sink(Arc::clone(&streaming_sink) as _),
-        ))
-        .expect("streaming finalize should succeed");
-        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
-        assert_bodiless_abandoned(&streaming_sink);
-
-        // Buffered finalizer (Axum/Cloudflare/Spin).
-        let buffered_sink = Arc::new(RecordingTelemetrySink::default());
-        let buffered_services = noop_services_with_telemetry_sink(Arc::clone(&buffered_sink) as _);
-        let response = futures::executor::block_on(buffer_publisher_response_async(
-            make_stream_response(),
-            &Method::GET,
-            settings.as_ref(),
-            &registry,
-            orchestrator.as_ref(),
-            &buffered_services,
-        ))
-        .expect("buffered finalize should succeed");
-        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
-        assert_bodiless_abandoned(&buffered_sink);
-    }
-
-    #[test]
-    fn publisher_response_streaming_finalize_processes_gzip_stream() {
-        let compressed =
-            gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-        let split_at = compressed.len() / 2;
-        let output = drain_streaming_finalize_body(
-            "gzip",
-            EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ])),
-        );
-
-        let css = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
-        assert!(
-            css.contains("proxy.example.com"),
-            "streaming response finalize should rewrite gzip body. Got: {css}"
-        );
-        assert!(
-            !css.contains("origin.example.com"),
-            "streaming response finalize should not leave gzip origin URLs. Got: {css}"
-        );
-    }
-
-    #[test]
-    fn publisher_response_streaming_finalize_processes_deflate_stream() {
-        let compressed =
-            deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-        let split_at = compressed.len() / 2;
-        let output = drain_streaming_finalize_body(
-            "deflate",
-            EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ])),
-        );
-
-        let css = String::from_utf8(deflate_decode(&output)).expect("should be valid UTF-8");
-        assert!(
-            css.contains("proxy.example.com"),
-            "streaming response finalize should rewrite deflate body. Got: {css}"
-        );
-        assert!(
-            !css.contains("origin.example.com"),
-            "streaming response finalize should not leave deflate origin URLs. Got: {css}"
-        );
-    }
-
-    #[test]
-    fn publisher_response_streaming_finalize_processes_brotli_stream() {
-        let compressed =
-            brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
-        let split_at = compressed.len() / 2;
-        let output = drain_streaming_finalize_body(
-            "br",
-            EdgeBody::stream(futures::stream::iter(vec![
-                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
-                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
-            ])),
-        );
+                render_trace_overlay: false,
+            };
+            let body = EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::from_static(b"<html><head></head><body>hello"),
+                bytes::Bytes::from_static(b"</body></html>"),
+            ]));
+            let mut output = Vec::new();
 
-        let css = String::from_utf8(brotli_decode(&output)).expect("should be valid UTF-8");
-        assert!(
-            css.contains("proxy.example.com"),
-            "streaming response finalize should rewrite brotli body. Got: {css}"
-        );
-        assert!(
-            !css.contains("origin.example.com"),
-            "streaming response finalize should not leave brotli origin URLs. Got: {css}"
-        );
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("stream body with auction should process on async path");
+
+            let html = String::from_utf8(output).expect("should be valid UTF-8");
+            let auction_id = boot_auction_id(&html);
+            assert!(
+                html.contains("hello"),
+                "should preserve streamed HTML content. Got: {html}"
+            );
+            assert!(
+                auction_id.starts_with("a1_"),
+                "the immutable pre-core boot must contain the collected auction projection with a browser-only auction id. Got: {html}"
+            );
+            assert!(
+                auction_id != auction_request.id,
+                "the immutable pre-core boot must not expose the upstream auction id. Got: {html}"
+            );
+            assert!(
+                auction_id != "initial",
+                "the safe empty projection must not replace a dispatched auction. Got: {html}"
+            );
+            assert!(!html.contains(".adSlots"));
+            assert!(!html.contains(".bids="));
+        });
     }
 
     #[test]
-    fn publisher_response_streaming_finalize_holds_auction_and_keeps_gzip_tail() {
-        let settings = Arc::new(create_test_settings());
-        let registry = Arc::new(
-            IntegrationRegistry::with_plan(
+    fn stream_publisher_body_async_auction_hold_decodes_multi_member_gzip_buffered() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
                 &settings,
                 Arc::new(
                     crate::auction::compile_auction_plan(&settings)
                         .expect("should compile auction plan"),
                 ),
             )
-            .expect("should create integration registry"),
-        );
-        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
-        let services = noop_services();
-        let response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
-            .body(EdgeBody::empty())
-            .expect("should build response");
-        // The trailing content after `</body>` must exceed the flate2 write
-        // decoder's 32 KiB internal output buffer: the close-body tag then
-        // surfaces (and releases the auction hold) mid-stream, while the
-        // trailing markup only surfaces at decoder finalization. This guards
-        // against the EOF decoded tail being dropped once the hold is gone.
-        let trailing_comment = format!("<!-- {} -->", "trailing-content ".repeat(3 * 1024));
-        let page = format!("<html><head></head><body>hello</body>{trailing_comment}</html>");
-        let compressed = gzip_encode(page.as_bytes());
-        let chunks: Vec<bytes::Bytes> = compressed
-            .chunks(STREAM_CHUNK_SIZE)
-            .map(bytes::Bytes::copy_from_slice)
-            .collect();
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: "gzip".to_string(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/html; charset=utf-8".to_string(),
-            ad_slots_script: Some(
-                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
-                    .to_string(),
-            ),
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: Some(test_auction_request()),
-            dispatched_auction: Some(DispatchedAuction::empty_for_test(
-                test_auction_request(),
-                10,
-            )),
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-        let publisher_response = PublisherResponse::Stream {
-            response,
-            body: EdgeBody::stream(futures::stream::iter(chunks)),
-            params: Box::new(params),
-        };
-
-        let response = futures::executor::block_on(publisher_response_into_streaming_response(
-            publisher_response,
-            &Method::GET,
-            Arc::clone(&settings),
-            registry.as_ref(),
-            orchestrator,
-            services,
-        ))
-        .expect("should build streaming response");
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let state = AdBidsState::default();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: "gzip".to_string(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/html; charset=utf-8".to_string(),
+                ad_slots_script: Some(
+                    r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
+                        .to_string(),
+                ),
+                ad_bids_state: state,
+                auction_observation: None,
+                auction_request: Some(test_auction_request()),
+                dispatched_auction: Some(DispatchedAuction::empty_for_test(
+                    test_auction_request(),
+                    10,
+                )),
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            // The document tail lives in the SECOND gzip member. This buffered
+            // `Body::Once` body proves the hard-cutover pipeline preserves every
+            // gzip member after collecting the projection before `<head>`.
+            let mut compressed = gzip_encode(b"<html><head></head><body>hello");
+            compressed.extend(gzip_encode(b"</body></html>"));
+            let body = EdgeBody::from(compressed);
+            let mut output = Vec::new();
 
-        let output = futures::executor::block_on(
-            response
-                .into_body()
-                .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
-        )
-        .expect("streaming body should drain")
-        .to_vec();
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("buffered multi-member gzip auction body should process");
 
-        let html = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
-        assert!(
-            html.contains("var b=JSON.parse("),
-            "should collect the held auction and inject bids. Got tail: {}",
-            &html[html.len().saturating_sub(200)..]
-        );
-        assert!(
-            html.contains("trailing-content"),
-            "should preserve content after the close-body tag"
-        );
-        assert!(
-            html.trim_end().ends_with("</html>"),
-            "should not drop the decoded tail once the auction hold is released. Got tail: {}",
-            &html[html.len().saturating_sub(200)..]
-        );
+            let html = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
+            let auction_id = boot_auction_id(&html);
+            assert!(
+                html.contains("hello"),
+                "should decode the first gzip member. Got: {html}"
+            );
+            assert!(
+                html.contains("</body></html>"),
+                "should decode the second gzip member that a single-member decoder drops. Got: {html}"
+            );
+            assert!(
+                auction_id.starts_with("a1_"),
+                "should emit the collected projection with a browser-only auction id before the head bundle. Got: {html}"
+            );
+            assert!(
+                auction_id != "test-auction",
+                "should not expose the upstream auction id to the browser. Got: {html}"
+            );
+            assert!(!html.contains(".bids="));
+        });
     }
 
     #[test]
-    fn stream_publisher_body_treats_mixed_case_html_as_html() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-        let bids_script =
-            r#"<script>(window.tsjs=window.tsjs||{}).bids=JSON.parse("{}");</script>"#;
-        let state = AdBidsState::with_script(bids_script);
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: String::new(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "Text/HTML; Charset=utf-8".to_string(),
-            ad_slots_script: Some(
-                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
-                    .to_string(),
-            ),
-            ad_bids_state: state,
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-        let mut output = Vec::new();
+    fn stream_publisher_body_async_processes_non_html_stream_after_auction_collect() {
+        futures::executor::block_on(async {
+            let settings = create_test_settings();
+            let registry = IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry");
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let services = noop_services();
+            let mut params = OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: String::new(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/css".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: None,
+                auction_request: Some(test_auction_request()),
+                dispatched_auction: Some(DispatchedAuction::empty_for_test(
+                    test_auction_request(),
+                    10,
+                )),
+                price_granularity: crate::price_bucket::PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            };
+            let body = EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
+                b"body{background:url('https://origin.example.com/asset.png')}",
+            )]));
+            let mut output = Vec::new();
 
-        stream_publisher_body(
-            EdgeBody::from(b"<html><head></head><body>content</body></html>".to_vec()),
-            &mut output,
-            &params,
-            &settings,
-            &registry,
-        )
-        .expect("should process mixed-case HTML content type");
+            stream_publisher_body_async(
+                body,
+                &mut output,
+                &mut params,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            )
+            .await
+            .expect("non-html stream body should process after auction collection");
 
-        let html = String::from_utf8(output).expect("should be valid UTF-8");
-        assert!(
-            html.contains(".adSlots=JSON.parse"),
-            "mixed-case HTML must use the HTML processor and inject ad slots. Got: {html}"
-        );
-        assert!(
-            html.contains(".bids=JSON.parse"),
-            "mixed-case HTML must use the HTML processor and inject bids. Got: {html}"
-        );
+            let css = String::from_utf8(output).expect("should be valid UTF-8");
+            assert!(
+                css.contains("proxy.example.com"),
+                "should rewrite non-html stream after auction collection. Got: {css}"
+            );
+            assert!(
+                !css.contains("origin.example.com"),
+                "should not leave origin host after rewrite. Got: {css}"
+            );
+        });
     }
 
-    /// Mid-stream decoder failure must surface as an error. The adapter
-    /// relies on this: once headers are committed, it logs and drops the
-    /// `StreamingBody` so the client sees a truncated response. If a decode
-    /// failure silently emitted bytes, the client would see a malformed
-    /// document instead.
-    #[test]
-    fn stream_publisher_body_surfaces_mid_stream_decode_error() {
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-
-        // Claim gzip encoding but feed non-gzip bytes. The GzDecoder will
-        // error as soon as it tries to read the gzip header.
+    fn drain_streaming_finalize_body(content_encoding: &str, body: EdgeBody) -> Vec<u8> {
+        let settings = Arc::new(create_test_settings());
+        let registry = Arc::new(
+            IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry"),
+        );
+        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
+        let services = noop_services();
+        let response = Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "text/css")
+            .body(EdgeBody::empty())
+            .expect("should build response");
         let params = OwnedProcessResponseParams {
             csp_nonce_observed: None,
             template_cache_key: None,
             seam_ad_slots: None,
             policy_headers: Vec::new(),
-            content_encoding: "gzip".to_string(),
+            content_encoding: content_encoding.to_string(),
             origin_host: "origin.example.com".to_string(),
             origin_url: "https://origin.example.com".to_string(),
             request_host: "proxy.example.com".to_string(),
             request_scheme: "https".to_string(),
-            content_type: "text/html".to_string(),
+            content_type: "text/css".to_string(),
             ad_slots_script: None,
             ad_bids_state: AdBidsState::default(),
             auction_observation: None,
@@ -17533,1615 +12558,1235 @@ mod tests {
             price_granularity: crate::price_bucket::PriceGranularity::default(),
             gpt_diagnostics: None,
             suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+        let publisher_response = PublisherResponse::Stream {
+            response,
+            body,
+            params: Box::new(params),
         };
 
-        let bogus_body = EdgeBody::from(b"<html>not gzip</html>".to_vec());
-        let mut output = Vec::new();
-        let result = stream_publisher_body(bogus_body, &mut output, &params, &settings, &registry);
+        let response = futures::executor::block_on(publisher_response_into_streaming_response(
+            publisher_response,
+            &Method::GET,
+            Arc::clone(&settings),
+            registry.as_ref(),
+            orchestrator,
+            services,
+        ))
+        .expect("should build streaming response");
 
         assert!(
-            result.is_err(),
-            "decoding bogus gzip as gzip should return Err so the adapter can drop the stream"
+            matches!(response.body(), EdgeBody::Stream(_)),
+            "streaming finalize should keep a lazy Body::Stream"
         );
+
+        futures::executor::block_on(
+            response
+                .into_body()
+                .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
+        )
+        .expect("streaming body should drain")
+        .to_vec()
     }
 
-    /// Pass-through dispatch contract: the adapter treats `PublisherResponse::PassThrough`
-    /// by reattaching the origin body unchanged and letting Fastly emit it.
-    /// Simulate that step and assert byte identity plus Content-Length
-    /// preservation. Distinct from `pass_through_preserves_body_and_content_length`
-    /// which only tests the header preservation; this one walks the full
-    /// take-then-reattach pattern the adapter uses.
     #[test]
-    fn publisher_response_pass_through_reattach_preserves_bytes() {
-        // Simulate a 2xx image/png response: Body::from(bytes), take_body(),
-        // then set_body(body). `classify_response_route` already picks
-        // PassThrough for this combination; this covers the adapter's
-        // reattachment half of the contract.
-        let image_bytes: Vec<u8> = (0..=127).cycle().take(2048).collect();
-
-        let mut response = Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "image/png")
-            .header(header::CONTENT_LENGTH, image_bytes.len() as u64)
-            .body(EdgeBody::from(image_bytes.clone()))
-            .expect("should build test response");
-
-        // Mirror adapter: take body, then reattach.
-        let body = std::mem::replace(response.body_mut(), EdgeBody::empty());
-        *response.body_mut() = body;
-
-        assert_eq!(
-            response
-                .headers()
-                .get(header::CONTENT_LENGTH)
-                .and_then(|v| v.to_str().ok())
-                .expect("content-length should survive"),
-            "2048"
+    fn publisher_response_streaming_finalize_keeps_stream_body_lazy() {
+        let body_bytes = drain_streaming_finalize_body(
+            "",
+            EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
+                b"body{background:url('https://origin.example.com/asset.png')}",
+            )])),
         );
-        let (_, final_body) = response.into_parts();
-        let round_trip = final_body.into_bytes().unwrap_or_default();
-        assert_eq!(
-            round_trip, image_bytes,
-            "pass-through reattach must preserve bytes exactly"
+        let css = String::from_utf8(body_bytes).expect("should be valid UTF-8");
+        assert!(
+            css.contains("proxy.example.com"),
+            "streaming response body should still run publisher rewriting. Got: {css}"
+        );
+        assert!(
+            !css.contains("origin.example.com"),
+            "streaming response body should not leave origin URLs unrewritten. Got: {css}"
         );
     }
 
-    /// Streaming dispatch contract: HTML with a registered post-processor still
-    /// routes through `Stream`, and the shared processor pipeline still applies
-    /// the post-processor rewrite.
-    #[test]
-    fn streaming_html_with_post_processors_rewrites_body() {
-        // Configure nextjs so a post-processor is registered.
-        let mut settings = create_test_settings();
-        settings
-            .integrations
-            .insert_config(
-                "nextjs",
-                &serde_json::json!({
-                    "enabled": true,
-                    "rewrite_attributes": ["href", "link", "url"],
-                }),
-            )
-            .expect("should update nextjs config");
+    /// An origin body stream that yields `chunk` once and then stays `Pending`
+    /// forever without ever signalling EOF — modelling an origin that has sent
+    /// the document head but not yet finished the response.
+    fn origin_chunk_then_pending(chunk: bytes::Bytes) -> EdgeBody {
+        let mut sent = false;
+        EdgeBody::from_stream(futures::stream::poll_fn(move |_cx| {
+            if sent {
+                return std::task::Poll::Pending;
+            }
+            sent = true;
+            std::task::Poll::Ready(Some(Ok::<_, io::Error>(chunk.clone())))
+        }))
+    }
 
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
+    /// Poll a lazy `Body::Stream` exactly once and return the first emitted
+    /// chunk. Panics if the first poll is `Pending` (nothing emitted before the
+    /// origin would need its next chunk) or the stream ends.
+    fn first_lazy_body_chunk(body: EdgeBody) -> bytes::Bytes {
+        let mut stream = body
+            .into_stream()
+            .expect("streaming finalize should keep a lazy Body::Stream");
+        let waker = futures::task::noop_waker();
+        let mut cx = std::task::Context::from_waker(&waker);
+        let next = futures::StreamExt::next(&mut stream);
+        let mut next = std::pin::pin!(next);
+        match std::future::Future::poll(next.as_mut(), &mut cx) {
+            std::task::Poll::Ready(Some(Ok(bytes))) => bytes,
+            std::task::Poll::Ready(other) => {
+                panic!("first poll must emit a chunk, got Ready({other:?})")
+            }
+            std::task::Poll::Pending => {
+                panic!("first poll must emit rewritten content before origin EOF, got Pending")
+            }
+        }
+    }
 
-        assert!(
-            registry.has_html_post_processors(),
-            "nextjs integration must register an HTML post-processor"
-        );
-        assert_eq!(
-            classify_response_route(
-                StatusCode::OK,
-                "text/html; charset=utf-8",
-                "",
-                "proxy.example.com",
-            ),
-            ResponseRoute::Stream,
-            "HTML with post-processors must route to Stream"
-        );
+    fn streaming_finalize_response(params: OwnedProcessResponseParams, body: EdgeBody) -> EdgeBody {
+        streaming_finalize_response_with_settings(params, body, create_test_settings())
+    }
 
-        // Feed a small HTML body through the same pipeline the Stream arm uses.
-        let html =
-            b"<html><body><a href=\"https://origin.example.com/page\">link</a></body></html>";
-        let body = EdgeBody::from(html.to_vec());
+    fn streaming_finalize_response_with_settings(
+        params: OwnedProcessResponseParams,
+        body: EdgeBody,
+        settings: Settings,
+    ) -> EdgeBody {
+        let settings = Arc::new(settings);
+        let registry = Arc::new(
+            IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry"),
+        );
+        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
+        let services = noop_services();
+        let response = Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, &params.content_type)
+            .body(EdgeBody::empty())
+            .expect("should build response");
+        let publisher_response = PublisherResponse::Stream {
+            response,
+            body,
+            params: Box::new(params),
+        };
+        futures::executor::block_on(publisher_response_into_streaming_response(
+            publisher_response,
+            &Method::GET,
+            Arc::clone(&settings),
+            registry.as_ref(),
+            orchestrator,
+            services,
+        ))
+        .expect("should build streaming response")
+        .into_body()
+    }
 
-        let params = OwnedProcessResponseParams {
+    fn html_stream_params(
+        content_encoding: &str,
+        dispatched_auction: Option<DispatchedAuction>,
+    ) -> OwnedProcessResponseParams {
+        OwnedProcessResponseParams {
             csp_nonce_observed: None,
             template_cache_key: None,
             seam_ad_slots: None,
             policy_headers: Vec::new(),
-            content_encoding: String::new(),
+            content_encoding: content_encoding.to_string(),
             origin_host: "origin.example.com".to_string(),
             origin_url: "https://origin.example.com".to_string(),
             request_host: "proxy.example.com".to_string(),
             request_scheme: "https".to_string(),
             content_type: "text/html; charset=utf-8".to_string(),
-            ad_slots_script: None,
+            ad_slots_script: Some(
+                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
+                    .to_string(),
+            ),
             ad_bids_state: AdBidsState::default(),
             auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
+            auction_request: dispatched_auction.as_ref().map(|_| test_auction_request()),
+            dispatched_auction,
             price_granularity: crate::price_bucket::PriceGranularity::default(),
             gpt_diagnostics: None,
             suppress_datadome_client_side_tag: false,
-        };
-        let mut output = Vec::new();
-        stream_publisher_body(body, &mut output, &params, &settings, &registry)
-            .expect("should process streaming HTML");
-
-        assert!(
-            !output.is_empty(),
-            "streaming processed output must not be empty"
-        );
-        let as_str = std::str::from_utf8(&output).expect("output should be valid UTF-8");
-        assert!(
-            as_str.contains("proxy.example.com"),
-            "origin must be rewritten. Got: {as_str}"
-        );
-        assert!(
-            !as_str.contains("origin.example.com"),
-            "origin host must not leak. Got: {as_str}"
-        );
+            render_trace_overlay: false,
+        }
     }
 
-    /// Document-state survives from the streaming pass into the post-processor.
-    /// `NextJsRscPlaceholderRewriter` writes into `IntegrationDocumentState`
-    /// during streaming; `NextJsHtmlPostProcessor` reads it and substitutes.
-    /// Regression test: with post-processors registered, placeholders must
-    /// be inserted during streaming and substituted out of the final output.
     #[test]
-    fn document_state_placeholders_substitute_through_accumulating_path() {
+    fn streaming_finalize_emits_tsjs_head_before_origin_eof_without_legacy_gam_transport() {
         let mut settings = create_test_settings();
         settings
             .integrations
             .insert_config(
-                "nextjs",
+                "gpt",
                 &serde_json::json!({
                     "enabled": true,
-                    "rewrite_attributes": ["href", "link", "url"],
+                    "gam_attribution_enabled": true
                 }),
             )
-            .expect("should update nextjs config");
-        let registry = IntegrationRegistry::with_plan(
-            &settings,
-            Arc::new(
-                crate::auction::compile_auction_plan(&settings)
-                    .expect("should compile auction plan"),
-            ),
-        )
-        .expect("should create integration registry");
-
-        // Small, single-fragment RSC script — placeholder path (not fallback).
-        let html = br#"<html><body><script>self.__next_f.push([1,"1:{\"link\":\"https://origin.example.com/page\"}"])</script></body></html>"#;
-        let params = OwnedProcessResponseParams {
-            csp_nonce_observed: None,
-            template_cache_key: None,
-            seam_ad_slots: None,
-            policy_headers: Vec::new(),
-            content_encoding: String::new(),
-            origin_host: "origin.example.com".to_string(),
-            origin_url: "https://origin.example.com".to_string(),
-            request_host: "proxy.example.com".to_string(),
-            request_scheme: "https".to_string(),
-            content_type: "text/html".to_string(),
-            ad_slots_script: None,
-            ad_bids_state: AdBidsState::default(),
-            auction_observation: None,
-            auction_request: None,
-            dispatched_auction: None,
-            price_granularity: crate::price_bucket::PriceGranularity::default(),
-            gpt_diagnostics: None,
-            suppress_datadome_client_side_tag: false,
-        };
-
-        let mut output = Vec::new();
-        stream_publisher_body(
-            EdgeBody::from(html.to_vec()),
-            &mut output,
-            &params,
-            &settings,
-            &registry,
-        )
-        .expect("should process RSC push");
+            .expect("should insert GPT config");
 
-        let processed = String::from_utf8(output).expect("valid UTF-8");
-        assert!(
-            !processed.contains("__ts_rsc_payload_"),
-            "placeholder must be substituted before reaching output. Got: {processed}"
+        let body = streaming_finalize_response_with_settings(
+            html_stream_params("", None),
+            origin_chunk_then_pending(bytes::Bytes::from_static(
+                b"<html><head></head><body><p>origin remains pending</p>",
+            )),
+            settings,
         );
+        let html = String::from_utf8(first_lazy_body_chunk(body).to_vec())
+            .expect("should emit UTF-8 HTML");
+
         assert!(
-            processed.contains("proxy.example.com/page"),
-            "origin URL must be rewritten in the substituted payload. Got: {processed}"
+            html.contains("id=\"trustedserver-js\""),
+            "first rewritten head chunk should carry the parser-time TSJS runtime: {html}"
         );
         assert!(
-            !processed.contains("origin.example.com"),
-            "origin host must not leak. Got: {processed}"
+            !html.contains("__tsjs_gam_attribution_enabled")
+                && !html.contains("data-ts-gam-attribution"),
+            "hard cutover must not retain either legacy GAM activation transport: {html}"
         );
     }
 
-    #[cfg(test)]
-    mod creative_opportunities_tests {
-        use super::super::{
-            AdBidsState, MatchedSlotsContext, build_ad_slots_script, build_auction_request,
-            build_bid_map, build_bids_script, diagnostics_auction_id, html_escape_for_script,
-            write_bids_to_state,
-        };
-        use crate::auction::types::{ApsRendererV1, ApsTagType, Bid, BidRenderer, MediaType};
-        use crate::consent::ConsentContext;
-        use crate::creative_opportunities::{
-            CreativeOpportunitiesConfig, CreativeOpportunityFormat, CreativeOpportunitySlot,
-        };
-        use crate::http_util::RequestInfo;
-        use crate::price_bucket::PriceGranularity;
-        use crate::settings::Settings;
-        use std::collections::HashMap;
-
-        // Default settings are enough for the creative boundary: the sanitize
-        // pass needs no config, and `rewrite_creative_html` only signs URLs it
-        // actually rewrites (none of these fixtures carry proxyable URLs).
-        fn test_settings() -> Settings {
-            Settings::default()
-        }
-
-        fn make_config() -> CreativeOpportunitiesConfig {
-            CreativeOpportunitiesConfig {
-                enabled: true,
-                gam_network_id: "21765378893".to_string(),
-                auction_timeout_ms: Some(500),
-                price_granularity: PriceGranularity::Dense,
-                section_root: None,
-                assembly_mode: None,
-                template_cache_vary: None,
-                template_cache_max_age_seconds: None,
-                origin_is_cookie_independent: None,
-                section_segment: None,
-                slot: Vec::new(),
-            }
-        }
-
-        fn make_slot() -> CreativeOpportunitySlot {
-            CreativeOpportunitySlot {
-                id: "atf_sidebar_ad".to_string(),
-                gam_unit_path: Some("/21765378893/publisher/atf-sidebar".to_string()),
-                div_id: Some("div-atf-sidebar".to_string()),
-                page_patterns: vec!["/20**".to_string()],
-                formats: vec![CreativeOpportunityFormat {
-                    width: 300,
-                    height: 250,
-                    media_type: MediaType::Banner,
-                }],
-                floor_price: Some(0.50),
-                targeting: [("pos".to_string(), "atf".to_string())]
-                    .into_iter()
-                    .collect(),
-                providers: Default::default(),
-                compiled_patterns: Vec::new(),
-                compiled_unit: None,
-            }
-        }
-
-        fn make_bid(
-            slot_id: &str,
-            price: f64,
-            bidder: &str,
-            ad_id: &str,
-            nurl: &str,
-            burl: &str,
-        ) -> Bid {
-            Bid {
-                slot_id: slot_id.to_string(),
-                price: Some(price),
-                currency: "USD".to_string(),
-                creative: None,
-                adomain: None,
-                bidder: bidder.to_string(),
-                returned_seat: None,
-                width: 300,
-                height: 250,
-                nurl: Some(nurl.to_string()),
-                burl: Some(burl.to_string()),
-                bid_id: None,
-                creative_id: None,
-                renderer: None,
-                ad_id: Some(ad_id.to_string()),
-                cache_id: None,
-                cache_host: None,
-                cache_path: None,
-                metadata: Default::default(),
-            }
-        }
-
-        #[test]
-        fn ad_slots_script_contains_slot_data() {
-            let mut slot = make_slot();
-            slot.targeting
-                .insert("ts".to_string(), "operator-value".to_string());
-            let slots = vec![slot];
-            let config = make_config();
-            let script = build_ad_slots_script(&slots, &config, "/");
-            let slot_json = crate::publisher::build_slot_json(&slots[0], &config, "example")
-                .expect("should build slot JSON");
-            assert!(
-                script.contains("window.tsjs=window.tsjs||{}"),
-                "should initialise tsjs namespace"
-            );
-            assert!(
-                script.contains(".adSlots=JSON.parse"),
-                "should use JSON.parse for adSlots"
-            );
-            assert!(script.contains("atf_sidebar_ad"), "should include slot id");
-            assert!(!script.contains("adInit"), "must NOT contain adInit");
-            assert!(
-                !script.contains("__ts_request_id"),
-                "must NOT contain request_id"
-            );
-            assert_eq!(
-                slot_json["targeting"]["ts"], "operator-value",
-                "should forward operator-provided ts targeting verbatim"
-            );
-        }
-
-        #[test]
-        fn ad_slots_script_is_xss_safe() {
-            let slots = vec![make_slot()];
-            let config = make_config();
-            let script = build_ad_slots_script(&slots, &config, "/");
-            let inner = script
-                .trim_start_matches("<script>")
-                .trim_end_matches("</script>");
-            assert!(!inner.contains('<'), "no unescaped < in script content");
-            assert!(!inner.contains('>'), "no unescaped > in script content");
-        }
-
-        #[test]
-        fn ad_slots_script_omits_only_over_limit_dynamic_slot() {
-            let mut over_limit = make_slot();
-            over_limit.id = "over_limit_dynamic".to_string();
-            over_limit.gam_unit_path = Some("/{section}/{section}".to_string());
-            over_limit
-                .compile_unit_template()
-                .expect("template should compile");
-            let mut valid_static = make_slot();
-            valid_static.id = "valid_static_sibling".to_string();
-            valid_static.gam_unit_path = Some("/12345/example/static".to_string());
-            let slots = vec![over_limit, valid_static];
-            let config = make_config();
-            let request_path = format!("/{}", "a".repeat(60));
-
-            let script = build_ad_slots_script(&slots, &config, &request_path);
-
-            assert!(
-                !script.contains("over_limit_dynamic"),
-                "should omit the over-limit dynamic slot"
-            );
-            assert!(
-                script.contains("valid_static_sibling"),
-                "should retain the valid static sibling"
-            );
-        }
-
-        #[test]
-        fn build_slot_json_renders_section_from_request_path() {
-            let mut config = make_config();
-            config.gam_network_id = "99999".to_string();
-            config.section_root = Some("homepage".to_string());
-            let mut slot = make_slot();
-            slot.gam_unit_path = Some("/{network_id}/example/{section}".to_string());
-            slot.compile_unit_template()
-                .expect("template should compile");
-
-            let news_section = config.section_for_path("/news/article-123");
-            let news = crate::publisher::build_slot_json(&slot, &config, &news_section)
-                .expect("should render slot");
-            assert_eq!(
-                news["gam_unit_path"], "/99999/example/news",
-                "section should derive from the first path segment"
-            );
-
-            let home_section = config.section_for_path("/");
-            let home = crate::publisher::build_slot_json(&slot, &config, &home_section)
-                .expect("should render slot");
-            assert_eq!(
-                home["gam_unit_path"], "/99999/example/homepage",
-                "root path should use section_root"
-            );
+    #[test]
+    fn streaming_finalize_emits_compressed_html_before_origin_eof() {
+        // The FCP regression from #849: the lazy body must emit its first
+        // rewritten, browser-decodable chunk as soon as the origin delivers one
+        // block — not buffer the whole (compressed) response until EOF. The
+        // origin here sends one gzip member and then stays Pending; the first
+        // poll must still yield gzip bytes that decode to the streamed content.
+        // The page exceeds the deflate decoder's internal output buffer so the
+        // first decoded block flushes downstream before the (never-arriving)
+        // EOF, exactly as a real page does.
+        let mut page = b"<html><head></head><body>".to_vec();
+        for i in 0..4000 {
+            page.extend(format!("<p>hello world paragraph {i}</p>").bytes());
         }
+        let params = html_stream_params("gzip", None);
+        let body = streaming_finalize_response(
+            params,
+            origin_chunk_then_pending(bytes::Bytes::from(gzip_encode(&page))),
+        );
 
-        #[test]
-        fn build_slot_json_honours_configured_section_segment() {
-            // Locale-prefixed publisher: `/en/news/article` must resolve to the
-            // `news` unit, not `en`.
-            let mut config = make_config();
-            config.gam_network_id = "99999".to_string();
-            config.section_root = Some("homepage".to_string());
-            config.section_segment = Some(1);
-            let mut slot = make_slot();
-            slot.gam_unit_path = Some("/{network_id}/example/{section}".to_string());
-            slot.compile_unit_template()
-                .expect("template should compile");
-
-            let news_section = config.section_for_path("/en/news/article-123");
-            let news = crate::publisher::build_slot_json(&slot, &config, &news_section)
-                .expect("should render slot");
-            assert_eq!(
-                news["gam_unit_path"], "/99999/example/news",
-                "section should derive from the configured segment index"
-            );
+        let first = first_lazy_body_chunk(body);
+        assert!(
+            !first.is_empty(),
+            "first emitted gzip chunk must not be empty"
+        );
 
-            let locale_root_section = config.section_for_path("/en");
-            let locale_root =
-                crate::publisher::build_slot_json(&slot, &config, &locale_root_section)
-                    .expect("should render slot");
-            assert_eq!(
-                locale_root["gam_unit_path"], "/99999/example/homepage",
-                "a path with no segment at the configured index should use section_root"
-            );
-        }
+        // Decode the flushed (not finished) gzip prefix the way a browser would
+        // decode bytes received so far while the response is still open.
+        let mut decoder = flate2::write::MultiGzDecoder::new(Vec::new());
+        decoder
+            .write_all(&first)
+            .expect("first chunk must be valid gzip");
+        decoder.flush().expect("should flush gzip decoder");
+        let decoded = String::from_utf8(decoder.get_ref().clone()).expect("should be valid UTF-8");
+        assert!(
+            decoded.contains("hello world"),
+            "first poll must emit decodable streamed content before EOF. Got: {decoded}"
+        );
+    }
 
-        #[test]
-        fn bid_map_includes_nurl_and_burl() {
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "atf_sidebar_ad".to_string(),
-                make_bid(
-                    "atf_sidebar_ad",
-                    1.50,
-                    "kargo",
-                    "abc123",
-                    "https://ssp/win",
-                    "https://ssp/bill",
-                ),
-            );
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let entry = map.get("atf_sidebar_ad").expect("should have bid entry");
-            let obj = entry.as_object().expect("should be object");
-            assert_eq!(
-                obj.get("hb_pb").and_then(|v| v.as_str()),
-                Some("1.50"),
-                "should bucket price with dense granularity"
-            );
-            assert_eq!(
-                obj.get("hb_bidder").and_then(|v| v.as_str()),
-                Some("kargo"),
-                "should include bidder"
-            );
-            assert_eq!(
-                obj.get("hb_adid").and_then(|v| v.as_str()),
-                Some("abc123"),
-                "should fall back to ad_id when no cache_id present"
-            );
-            assert_eq!(
-                obj.get("nurl").and_then(|v| v.as_str()),
-                Some("https://ssp/win"),
-                "should include nurl"
-            );
-            assert_eq!(
-                obj.get("burl").and_then(|v| v.as_str()),
-                Some("https://ssp/bill"),
-                "should include burl"
-            );
-        }
+    #[test]
+    fn streaming_finalize_collects_exact_projection_before_lazy_html_head() {
+        // Fastly must complete the dispatched auction before it constructs the
+        // HTML processor. The origin can still stream lazily after that barrier,
+        // but its first `<head>` must carry the exact projection, never the safe
+        // empty placeholder or a legacy body-close transport.
+        let page = b"<html><head></head><body><p>hello</p><p>more streamed content here</p>";
+        let params = html_stream_params(
+            "",
+            Some(DispatchedAuction::empty_for_test(
+                test_auction_request(),
+                10,
+            )),
+        );
+        let body = streaming_finalize_response(
+            params,
+            origin_chunk_then_pending(bytes::Bytes::from(&page[..])),
+        );
 
-        /// Guards the browser-visible token every auction path shares: it must
-        /// be fresh per auction and absent unless diagnostics can consume it.
-        #[test]
-        fn diagnostics_auction_id_is_fresh_and_gated() {
-            let mut settings = test_settings();
-            assert_eq!(
-                diagnostics_auction_id(&settings),
-                None,
-                "no token should be minted without the diagnostics integration"
-            );
+        let first = first_lazy_body_chunk(body);
+        let html = String::from_utf8(first.to_vec()).expect("should be valid UTF-8");
+        let auction_id = boot_auction_id(&html);
+        assert!(
+            html.contains("hello"),
+            "the origin body should remain lazy after the pre-head collect. Got: {html}"
+        );
+        assert!(
+            auction_id.starts_with("a1_"),
+            "the first head chunk must contain the exact collected projection with a browser-only auction id. Got: {html}"
+        );
+        assert!(
+            auction_id != "test-auction",
+            "the first head chunk must not expose the upstream auction id. Got: {html}"
+        );
+        assert!(
+            auction_id != "initial",
+            "a dispatched auction must not boot with the safe empty projection. Got: {html}"
+        );
+        assert!(!html.contains(".adSlots"));
+        assert!(!html.contains(".bids="));
+    }
 
-            settings
-                .integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should enable diagnostics");
-            let first =
-                diagnostics_auction_id(&settings).expect("enabled diagnostics should mint a token");
-            let second =
-                diagnostics_auction_id(&settings).expect("enabled diagnostics should mint a token");
+    #[test]
+    fn streaming_finalize_auction_hold_emits_small_compressed_page_before_collection() {
+        // A small gzip page arrives as one origin chunk whose whole expansion
+        // fits inside `flate2`'s internal decode buffer, and its `</body>` lands
+        // in that same chunk. Both stages that could withhold it must not: the
+        // decoder sync-flushes per source chunk instead of holding output until
+        // its own finalization, and the finish path emits the decoder tail
+        // before awaiting collection. Otherwise the client holds committed
+        // headers and an empty body until the auction resolves.
+        let page = b"<html><head></head><body><p>small compressed page</p></body></html>";
+        let params = html_stream_params(
+            "gzip",
+            Some(DispatchedAuction::empty_for_test(
+                test_auction_request(),
+                500,
+            )),
+        );
+        let body = streaming_finalize_response(
+            params,
+            origin_chunk_then_pending(bytes::Bytes::from(gzip_encode(page))),
+        );
 
-            assert!(
-                first.starts_with("ts-auc-"),
-                "token should use the diagnostics prefix, got `{first}`"
-            );
-            assert_ne!(first, second, "each auction should mint its own token");
-        }
+        let first = first_lazy_body_chunk(body);
+        // Decode the flushed (not finished) prefix the way a browser decodes the
+        // bytes received while the response is still open.
+        let mut decoder = flate2::write::MultiGzDecoder::new(Vec::new());
+        decoder
+            .write_all(&first)
+            .expect("first chunk must be valid gzip");
+        decoder.flush().expect("should flush gzip decoder");
+        let decoded = String::from_utf8(decoder.get_ref().clone()).expect("should be valid UTF-8");
 
-        #[test]
-        fn initial_document_bids_script_includes_auction_id_only_for_winning_bids() {
-            let slot = make_slot();
-            let slots = [slot];
-            let slots_ctx = MatchedSlotsContext {
-                matched_slots: &slots,
-                request_path: "/2024/01/my-article/",
-            };
-            let request_info = RequestInfo {
-                host: "publisher.example.com".to_string(),
-                scheme: "https".to_string(),
-            };
-            let mut auction_request = build_auction_request(
-                &slots_ctx,
-                None,
-                &ConsentContext::default(),
-                &request_info,
-                "publisher.example.com",
-                Some("Mozilla/5.0"),
-            );
-            auction_request.id = "initial-auction-example-123".to_string();
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "atf_sidebar_ad".to_string(),
-                make_bid(
-                    "atf_sidebar_ad",
-                    1.50,
-                    "example_bidder",
-                    "abc123",
-                    "https://example.com/win",
-                    "https://example.com/bill",
-                ),
-            );
+        assert!(
+            decoded.contains("small compressed page"),
+            "first poll must emit the decoded document prefix of a small gzip page. Got: {decoded}"
+        );
+        assert!(
+            !decoded.contains("var b=JSON.parse("),
+            "bids inject only at </body> after collection, which the first poll must not wait for. Got: {decoded}"
+        );
+    }
 
-            let state = AdBidsState::default();
-            write_bids_to_state(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &state,
-                &test_settings(),
-                "",
-                false,
-                Some(&auction_request.id),
-            );
-            let script = state
-                .script_cell()
-                .lock()
-                .expect("should lock initial bid state")
-                .clone()
-                .expect("should generate initial-document bids script");
-            let bid_json = script
-                .strip_prefix(
-                    "<script>(function(){var t=window.tsjs=window.tsjs||{};var b=JSON.parse(\"",
-                )
-                .and_then(|script| {
-                    script.strip_suffix(
-                        "\");var s=t.scheduleInitialAdInit;if(typeof s===\"function\")s(b);else t.bids=b;})();</script>",
-                    )
-                })
-                .expect("should emit the initial-document tsjs.bids script shape");
-            let bid_json: String = serde_json::from_str(&format!("\"{bid_json}\""))
-                .expect("should decode initial-document JSON.parse input");
-            let bids: serde_json::Value = serde_json::from_str(&bid_json)
-                .expect("should serialize initial-document bids as JSON");
+    // (method, status, expected Content-Length, expected Transfer-Encoding)
+    // after bodiless normalization. 204 forbids Content-Length (removed); 205
+    // must advertise a zero-length body; HEAD and 304 legitimately advertise the
+    // GET representation length. Chunked framing is stripped from 204 (forbidden
+    // by RFC 9112 §6.1) and 205 (would conflict with the inserted
+    // `Content-Length: 0`), but preserved for HEAD and 304, whose message length
+    // is fixed by the header section regardless of framing fields
+    // (RFC 9112 §6.3, rule 1).
+    const BODILESS_FRAMING_CASES: [(Method, StatusCode, Option<&str>, Option<&str>); 4] = [
+        (Method::HEAD, StatusCode::OK, Some("42"), Some("chunked")),
+        (Method::GET, StatusCode::NO_CONTENT, None, None),
+        (Method::GET, StatusCode::RESET_CONTENT, Some("0"), None),
+        (
+            Method::GET,
+            StatusCode::NOT_MODIFIED,
+            Some("42"),
+            Some("chunked"),
+        ),
+    ];
 
-            assert_eq!(
-                bids["atf_sidebar_ad"]["hb_auction_id"], auction_request.id,
-                "initial-document bids should expose the current request ID only on the winner"
-            );
+    /// Assert the framing fields left on a normalized bodiless response.
+    fn assert_bodiless_framing(
+        response: &Response<EdgeBody>,
+        method: &Method,
+        status: StatusCode,
+        expected_length: Option<&str>,
+        expected_transfer_encoding: Option<&str>,
+    ) {
+        let header_value = |name: header::HeaderName| {
+            response
+                .headers()
+                .get(name)
+                .and_then(|value| value.to_str().ok())
+                .map(str::to_owned)
+        };
+        assert_eq!(
+            header_value(header::CONTENT_LENGTH).as_deref(),
+            expected_length,
+            "bodiless {method} {status} must carry the corrected Content-Length"
+        );
+        assert_eq!(
+            header_value(header::TRANSFER_ENCODING).as_deref(),
+            expected_transfer_encoding,
+            "bodiless {method} {status} must carry the corrected Transfer-Encoding"
+        );
+        assert_eq!(
+            header_value(header::TRAILER).as_deref(),
+            // `Trailer` only describes fields a chunked body can carry, so it
+            // survives exactly where chunked framing does.
+            expected_transfer_encoding.map(|_| "expires"),
+            "bodiless {method} {status} must drop Trailer with its chunked framing"
+        );
+    }
 
-            write_bids_to_state(
-                &HashMap::new(),
-                PriceGranularity::Dense,
-                &state,
-                &test_settings(),
-                "",
-                false,
-                Some(&auction_request.id),
-            );
-            let empty_script = state
-                .script_cell()
-                .lock()
-                .expect("should lock empty initial bid state")
-                .clone()
-                .expect("should generate empty initial-document bids script");
-            let empty_bid_json = empty_script
-                .strip_prefix(
-                    "<script>(function(){var t=window.tsjs=window.tsjs||{};var b=JSON.parse(\"",
-                )
-                .and_then(|script| {
-                    script.strip_suffix(
-                        "\");var s=t.scheduleInitialAdInit;if(typeof s===\"function\")s(b);else t.bids=b;})();</script>",
-                    )
-                })
-                .expect("should emit the empty initial-document tsjs.bids script shape");
-            let empty_bid_json: String = serde_json::from_str(&format!("\"{empty_bid_json}\""))
-                .expect("should decode empty initial-document JSON.parse input");
-            let empty_bids: serde_json::Value = serde_json::from_str(&empty_bid_json)
-                .expect("should serialize empty initial-document bids as JSON");
-            assert!(
-                empty_bids
-                    .as_object()
-                    .expect("initial-document bids should be an object")
-                    .is_empty(),
-                "initial-document bids should not fabricate metadata without a winner"
-            );
-        }
+    #[test]
+    fn publisher_response_streaming_finalize_normalizes_bodiless_framing() {
+        // Fastly requests the origin body as a stream before classification, so
+        // a buffered-unmodified response can hold an `EdgeBody::Stream`. The
+        // adapter streams any `EdgeBody::Stream` to the client, so bodiless
+        // responses must carry no body and correct framing per status.
+        let settings = Arc::new(create_test_settings());
+        let registry = Arc::new(
+            IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry"),
+        );
+        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
 
-        #[test]
-        fn bid_map_omits_zero_creative_dimensions() {
-            // Missing OpenRTB w/h parse to 0. Emitting w:0/h:0 would make the
-            // bridge (which nullish-coalesces) size the frame to 0 instead of
-            // falling back to the slot format, so a zero dimension must be omitted.
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.width = 0;
-            bid.height = 0;
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            assert!(obj.get("w").is_none(), "should omit zero width");
-            assert!(obj.get("h").is_none(), "should omit zero height");
-        }
+        for (method, status, expected_length, expected_transfer_encoding) in BODILESS_FRAMING_CASES
+        {
+            let response = Response::builder()
+                .status(status)
+                .header(header::CONTENT_LENGTH, "42")
+                .header(header::TRANSFER_ENCODING, "chunked")
+                .header(header::TRAILER, "expires")
+                .body(EdgeBody::stream(futures::stream::iter(vec![
+                    bytes::Bytes::from_static(b"origin body bytes that must not reach the client"),
+                ])))
+                .expect("should build response");
+            let publisher_response = PublisherResponse::Buffered(response);
 
-        #[test]
-        fn bid_map_includes_winning_creative_dimensions() {
-            // The bridge sizes the inline render from these dimensions; without
-            // them it falls back to the first configured slot format, which
-            // mis-sizes a multi-size slot whose winner is not the first format.
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.width = 300;
-            bid.height = 600;
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            assert_eq!(
-                obj.get("w").and_then(serde_json::Value::as_u64),
-                Some(300),
-                "should include winning creative width"
-            );
-            assert_eq!(
-                obj.get("h").and_then(serde_json::Value::as_u64),
-                Some(600),
-                "should include winning creative height"
-            );
-        }
+            let response = futures::executor::block_on(publisher_response_into_streaming_response(
+                publisher_response,
+                &method,
+                Arc::clone(&settings),
+                registry.as_ref(),
+                Arc::clone(&orchestrator),
+                noop_services(),
+            ))
+            .expect("should finalize buffered response");
 
-        #[test]
-        fn client_bid_map_includes_adm_and_omits_debug_bid_by_default() {
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
+            assert!(
+                !matches!(response.body(), EdgeBody::Stream(_)),
+                "bodiless {method} {status} must not carry a streaming body"
             );
-            bid.creative = Some("<div>Creative</div>".to_string());
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-
-            // Production path (include_debug_bid = false): the creative is always
-            // included so the bridge can render it locally, but the verbose
-            // debug_bid blob is not.
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
+            assert_bodiless_framing(
+                &response,
+                &method,
+                status,
+                expected_length,
+                expected_transfer_encoding,
             );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
 
-            assert_eq!(
-                obj.get("adm").and_then(|v| v.as_str()),
-                Some("<div>Creative</div>"),
-                "should include creative markup for local rendering by default"
-            );
+            let drained = futures::executor::block_on(
+                response
+                    .into_body()
+                    .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
+            )
+            .expect("body should drain")
+            .to_vec();
             assert!(
-                obj.get("debug_bid").is_none(),
-                "should omit the debug_bid blob when debug injection is disabled"
+                drained.is_empty(),
+                "bodiless {method} {status} must deliver zero body bytes, got {} bytes",
+                drained.len()
             );
         }
+    }
 
-        #[test]
-        fn build_bid_map_sanitizes_hostile_adm() {
-            // The inline-adm path must run the same opt-in creative-processing
-            // boundary as the `/auction` path (sanitize → rewrite) before the
-            // creative reaches window.tsjs.bids, so with sanitization enabled
-            // hostile executable markup never lands in the client-facing `adm`
-            // for the Prebid Universal Creative to run.
-            let mut settings = test_settings();
-            settings.auction.sanitize_creatives = true;
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.creative = Some(
-                "<div onclick=\"steal()\"><script>alert(1)</script>\
-                 <a href=\"javascript:evil()\">x</a></div>"
-                    .to_string(),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+    #[test]
+    fn buffer_publisher_response_normalizes_bodiless_framing() {
+        // The buffered finalizer (Axum/Cloudflare/Spin) must correct bodiless
+        // framing identically to the streaming finalizer.
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+        let services = noop_services();
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, "", false);
-            let adm = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .and_then(|o| o.get("adm"))
-                .and_then(|v| v.as_str())
-                .expect("should include a sanitized adm");
+        for (method, status, expected_length, expected_transfer_encoding) in BODILESS_FRAMING_CASES
+        {
+            let response = Response::builder()
+                .status(status)
+                .header(header::CONTENT_LENGTH, "42")
+                .header(header::TRANSFER_ENCODING, "chunked")
+                .header(header::TRAILER, "expires")
+                .body(EdgeBody::from(
+                    b"origin body bytes that must not reach the client".to_vec(),
+                ))
+                .expect("should build response");
+            let publisher_response = PublisherResponse::Buffered(response);
 
-            assert!(
-                !adm.contains("<script"),
-                "should strip <script> elements from the inline adm"
-            );
-            assert!(
-                !adm.contains("alert(1)"),
-                "should strip inline script bodies from the inline adm"
-            );
-            assert!(
-                !adm.contains("onclick"),
-                "should strip on* event-handler attributes from the inline adm"
+            let response = futures::executor::block_on(buffer_publisher_response_async(
+                publisher_response,
+                &method,
+                &settings,
+                &registry,
+                &orchestrator,
+                &services,
+            ))
+            .expect("should finalize buffered response");
+
+            assert_bodiless_framing(
+                &response,
+                &method,
+                status,
+                expected_length,
+                expected_transfer_encoding,
             );
+
+            let drained = futures::executor::block_on(
+                response
+                    .into_body()
+                    .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
+            )
+            .expect("body should drain")
+            .to_vec();
             assert!(
-                !adm.contains("javascript:"),
-                "should strip javascript: URIs from the inline adm"
+                drained.is_empty(),
+                "bodiless {method} {status} must deliver zero body bytes, got {} bytes",
+                drained.len()
             );
         }
+    }
 
-        #[test]
-        fn build_bid_map_can_skip_rewriting_while_sanitizing() {
-            let mut settings = test_settings();
-            settings.auction.sanitize_creatives = true;
-            settings.auction.rewrite_creatives = false;
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.creative = Some(
-                "<div onclick=\"steal()\"><script>marker</script>\
-                 <a href=\"https://click.example/landing\">x</a>\
-                 <img src=\"https://cdn.example/ad.png\"></div>"
-                    .to_string(),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+    #[derive(Default)]
+    struct RecordingTelemetrySink {
+        batches: Mutex<Vec<crate::auction::telemetry::AuctionEventBatch>>,
+    }
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &settings,
-                "https://publisher.example",
-                false,
-            );
-            let adm = map
-                .get("atf_sidebar_ad")
-                .and_then(|value| value.as_object())
-                .and_then(|object| object.get("adm"))
-                .and_then(|value| value.as_str())
-                .expect("should include a sanitized adm");
+    #[async_trait::async_trait(?Send)]
+    impl crate::auction::telemetry::AuctionTelemetrySink for RecordingTelemetrySink {
+        async fn emit_auction_events(
+            &self,
+            _services: &RuntimeServices,
+            batch: crate::auction::telemetry::AuctionEventBatch,
+        ) -> Result<(), Report<TrustedServerError>> {
+            self.batches
+                .lock()
+                .expect("should lock telemetry batches")
+                .push(batch);
+            Ok(())
+        }
+    }
 
-            assert!(
-                adm.contains(r#"href="https://click.example/landing""#),
-                "should keep accepted click URLs direct: {adm}"
-            );
-            assert!(
-                adm.contains(r#"src="https://cdn.example/ad.png""#),
-                "should keep accepted resource URLs direct: {adm}"
-            );
-            assert!(
-                !adm.contains("/first-party/"),
-                "should skip first-party URL rewriting: {adm}"
-            );
-            assert!(
-                !adm.contains("data-tsclick"),
-                "should skip click-guard attributes: {adm}"
+    #[test]
+    fn finalizers_emit_abandoned_auction_for_bodiless_dispatched_response() {
+        // A conditional navigation can dispatch an auction and receive a
+        // processable HTML 304 that classification routes to Stream. The
+        // bodiless response has no `</body>` to inject into, so the dispatched
+        // auction is never collected — but both finalizers must still emit a
+        // terminal abandonment event so the SSP work and quota consumption stay
+        // observable instead of vanishing silently.
+        let settings = Arc::new(create_test_settings());
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
+
+        let make_params = || {
+            let ec_context =
+                EcContext::new_for_test(None, crate::consent::types::ConsentContext::default());
+            OwnedProcessResponseParams {
+                csp_nonce_observed: None,
+                template_cache_key: None,
+                seam_ad_slots: None,
+                policy_headers: Vec::new(),
+                content_encoding: String::new(),
+                origin_host: "origin.example.com".to_string(),
+                origin_url: "https://origin.example.com".to_string(),
+                request_host: "proxy.example.com".to_string(),
+                request_scheme: "https".to_string(),
+                content_type: "text/html; charset=utf-8".to_string(),
+                ad_slots_script: None,
+                ad_bids_state: AdBidsState::default(),
+                auction_observation: Some(AuctionObservationContext::from_parts(
+                    AuctionSource::SpaNavigation,
+                    "proxy.example.com",
+                    "/article",
+                    1,
+                    &ec_context,
+                )),
+                auction_request: Some(test_auction_request()),
+                dispatched_auction: Some(DispatchedAuction::empty_for_test(
+                    test_auction_request(),
+                    10,
+                )),
+                price_granularity: PriceGranularity::default(),
+                gpt_diagnostics: None,
+                suppress_datadome_client_side_tag: false,
+                render_trace_overlay: false,
+            }
+        };
+        let make_stream_response = || PublisherResponse::Stream {
+            response: Response::builder()
+                .status(StatusCode::NOT_MODIFIED)
+                .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+                .body(EdgeBody::empty())
+                .expect("should build 304 response"),
+            body: EdgeBody::stream(futures::stream::iter(vec![bytes::Bytes::from_static(
+                b"<html></html>",
+            )])),
+            params: Box::new(make_params()),
+        };
+
+        fn assert_bodiless_abandoned(sink: &RecordingTelemetrySink) {
+            let batches = sink.batches.lock().expect("should lock telemetry batches");
+            assert_eq!(
+                batches.len(),
+                1,
+                "bodiless dispatched response should emit exactly one terminal batch"
             );
+            let reasons: Vec<String> = batches[0]
+                .rows()
+                .iter()
+                .filter_map(|row| row.terminal_reason.clone())
+                .collect();
             assert!(
-                !adm.contains("marker") && !adm.contains("onclick"),
-                "should still sanitize executable markup: {adm}"
+                reasons.iter().any(|reason| reason == "bodiless_response"),
+                "abandonment must carry the bodiless_response reason, got {reasons:?}"
             );
         }
 
-        #[test]
-        fn build_bid_map_omits_oversized_adm() {
-            // Creatives larger than the 1 MiB cap are rejected (empty result)
-            // in every processing mode, so the bid is omitted rather than
-            // recording a blank winner or shipping an unbounded creative to the
-            // client. Runs with default settings to cover the shipped
-            // configuration.
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.creative = Some(format!("<div>{}</div>", "a".repeat(1024 * 1024 + 1)));
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+        // Streaming finalizer (Fastly).
+        let streaming_sink = Arc::new(RecordingTelemetrySink::default());
+        let response = futures::executor::block_on(publisher_response_into_streaming_response(
+            make_stream_response(),
+            &Method::GET,
+            Arc::clone(&settings),
+            &registry,
+            Arc::clone(&orchestrator),
+            noop_services_with_telemetry_sink(Arc::clone(&streaming_sink) as _),
+        ))
+        .expect("streaming finalize should succeed");
+        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
+        assert_bodiless_abandoned(&streaming_sink);
+
+        // Buffered finalizer (Axum/Cloudflare/Spin).
+        let buffered_sink = Arc::new(RecordingTelemetrySink::default());
+        let buffered_services = noop_services_with_telemetry_sink(Arc::clone(&buffered_sink) as _);
+        let response = futures::executor::block_on(buffer_publisher_response_async(
+            make_stream_response(),
+            &Method::GET,
+            settings.as_ref(),
+            &registry,
+            orchestrator.as_ref(),
+            &buffered_services,
+        ))
+        .expect("buffered finalize should succeed");
+        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
+        assert_bodiless_abandoned(&buffered_sink);
+    }
+
+    #[test]
+    fn publisher_response_streaming_finalize_processes_gzip_stream() {
+        let compressed =
+            gzip_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+        let split_at = compressed.len() / 2;
+        let output = drain_streaming_finalize_body(
+            "gzip",
+            EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ])),
+        );
+
+        let css = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
+        assert!(
+            css.contains("proxy.example.com"),
+            "streaming response finalize should rewrite gzip body. Got: {css}"
+        );
+        assert!(
+            !css.contains("origin.example.com"),
+            "streaming response finalize should not leave gzip origin URLs. Got: {css}"
+        );
+    }
+
+    #[test]
+    fn publisher_response_streaming_finalize_processes_deflate_stream() {
+        let compressed =
+            deflate_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+        let split_at = compressed.len() / 2;
+        let output = drain_streaming_finalize_body(
+            "deflate",
+            EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ])),
+        );
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            assert!(
-                !map.contains_key("atf_sidebar_ad"),
-                "should omit the bid when the creative exceeds the 1 MiB cap"
-            );
-        }
+        let css = String::from_utf8(deflate_decode(&output)).expect("should be valid UTF-8");
+        assert!(
+            css.contains("proxy.example.com"),
+            "streaming response finalize should rewrite deflate body. Got: {css}"
+        );
+        assert!(
+            !css.contains("origin.example.com"),
+            "streaming response finalize should not leave deflate origin URLs. Got: {css}"
+        );
+    }
 
-        // A supplied creative that processing rejects must not fall back to the
-        // PBS Cache coordinates: the GPT bridge fetches the cached bid's ORIGINAL
-        // adm, which would undo sanitization and the size cap entirely.
-        fn cached_bid_with_creative(creative: &str) -> Bid {
-            Bid {
-                slot_id: "atf_sidebar_ad".to_string(),
-                price: Some(1.50),
-                currency: "USD".to_string(),
-                creative: Some(creative.to_string()),
-                adomain: None,
-                bidder: "prebid".to_string(),
-                returned_seat: None,
-                width: 300,
-                height: 250,
-                nurl: None,
-                burl: None,
-                ad_id: Some("bid-impression-id".to_string()),
-                bid_id: Some("openrtb-bid-id".to_string()),
-                creative_id: None,
-                // No typed renderer: these cases assert what happens when the
-                // supplied markup is the bid's only render source.
-                renderer: None,
-                cache_id: Some("cache-uuid".to_string()),
-                cache_host: Some("prebid-cache.example.com".to_string()),
-                cache_path: Some("/cache".to_string()),
-                metadata: Default::default(),
-            }
-        }
+    #[test]
+    fn publisher_response_streaming_finalize_processes_brotli_stream() {
+        let compressed =
+            brotli_encode(b"body{background:url('https://origin.example.com/asset.png')}");
+        let split_at = compressed.len() / 2;
+        let output = drain_streaming_finalize_body(
+            "br",
+            EdgeBody::stream(futures::stream::iter(vec![
+                bytes::Bytes::copy_from_slice(&compressed[..split_at]),
+                bytes::Bytes::copy_from_slice(&compressed[split_at..]),
+            ])),
+        );
 
-        // These fixtures carry cache coordinates but no typed renderer, so a
-        // rejected creative leaves the bid with no render source at all and it
-        // is dropped outright — which subsumes the property under test: the
-        // cache coordinates never reach the client, so the cached (unprocessed)
-        // copy of the markup cannot be fetched in place of what was refused.
-        fn assert_no_render_source(settings: &Settings, creative: String, case: &str) {
-            let mut winning_bids = HashMap::new();
-            let mut bid = cached_bid_with_creative("");
-            bid.creative = Some(creative);
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, settings, "", false);
-
-            match map.get("atf_sidebar_ad").and_then(|v| v.as_object()) {
-                None => {}
-                Some(obj) => {
-                    assert!(
-                        obj.get("adm").is_none(),
-                        "{case}: rejected creative should not emit adm"
-                    );
-                    assert!(
-                        obj.get("hb_cache_host").is_none(),
-                        "{case}: rejected creative should suppress hb_cache_host"
-                    );
-                    assert!(
-                        obj.get("hb_cache_path").is_none(),
-                        "{case}: rejected creative should suppress hb_cache_path"
-                    );
-                }
-            }
-        }
+        let css = String::from_utf8(brotli_decode(&output)).expect("should be valid UTF-8");
+        assert!(
+            css.contains("proxy.example.com"),
+            "streaming response finalize should rewrite brotli body. Got: {css}"
+        );
+        assert!(
+            !css.contains("origin.example.com"),
+            "streaming response finalize should not leave brotli origin URLs. Got: {css}"
+        );
+    }
 
-        #[test]
-        fn build_bid_map_suppresses_cache_fallback_for_rejected_creatives() {
-            let mut sanitizing = test_settings();
-            sanitizing.auction.sanitize_creatives = true;
-
-            // Script-only creative: sanitization strips everything.
-            assert_no_render_source(
-                &sanitizing,
-                "<script>document.write('ad')</script>".to_string(),
-                "script-only",
-            );
-            // Oversized creative: rejected by the cap in every mode.
-            assert_no_render_source(
-                &test_settings(),
-                format!("<div>{}</div>", "a".repeat(1024 * 1024 + 1)),
-                "oversized",
-            );
-            // An explicit empty `adm` is a supplied creative, not an absent one:
-            // classifying it as absent would re-enable the raw cache fallback.
-            assert_no_render_source(&test_settings(), String::new(), "explicit-empty");
-        }
+    #[test]
+    fn publisher_response_streaming_finalize_boots_projection_and_keeps_gzip_tail() {
+        let settings = Arc::new(create_test_settings());
+        let registry = Arc::new(
+            IntegrationRegistry::with_plan(
+                &settings,
+                Arc::new(
+                    crate::auction::compile_auction_plan(&settings)
+                        .expect("should compile auction plan"),
+                ),
+            )
+            .expect("should create integration registry"),
+        );
+        let orchestrator = Arc::new(AuctionOrchestrator::new(settings.auction.clone()));
+        let services = noop_services();
+        let response = Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "text/html; charset=utf-8")
+            .body(EdgeBody::empty())
+            .expect("should build response");
+        // The trailing content after `</body>` must exceed the flate2 write
+        // decoder's 32 KiB internal output buffer. This guards against the EOF
+        // decoded tail being dropped after the pre-head projection barrier.
+        let trailing_comment = format!("<!-- {} -->", "trailing-content ".repeat(3 * 1024));
+        let page = format!("<html><head></head><body>hello</body>{trailing_comment}</html>");
+        let compressed = gzip_encode(page.as_bytes());
+        let chunks: Vec<bytes::Bytes> = compressed
+            .chunks(STREAM_CHUNK_SIZE)
+            .map(bytes::Bytes::copy_from_slice)
+            .collect();
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: "gzip".to_string(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html; charset=utf-8".to_string(),
+            ad_slots_script: Some(
+                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
+                    .to_string(),
+            ),
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: Some(test_auction_request()),
+            dispatched_auction: Some(DispatchedAuction::empty_for_test(
+                test_auction_request(),
+                10,
+            )),
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+        let publisher_response = PublisherResponse::Stream {
+            response,
+            body: EdgeBody::stream(futures::stream::iter(chunks)),
+            params: Box::new(params),
+        };
 
-        #[test]
-        fn build_bid_map_keeps_cache_fallback_for_absent_creatives() {
-            // A bid with no supplied creative is the legitimate PBS Cache case:
-            // the coordinates are the only render source.
-            let mut winning_bids = HashMap::new();
-            let mut bid = cached_bid_with_creative("");
-            bid.creative = None;
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .expect("should have a bid entry");
+        let response = futures::executor::block_on(publisher_response_into_streaming_response(
+            publisher_response,
+            &Method::GET,
+            Arc::clone(&settings),
+            registry.as_ref(),
+            orchestrator,
+            services,
+        ))
+        .expect("should build streaming response");
 
-            assert_eq!(
-                obj.get("hb_cache_host").and_then(|v| v.as_str()),
-                Some("prebid-cache.example.com"),
-                "absent creative should keep hb_cache_host"
-            );
-            assert_eq!(
-                obj.get("hb_cache_path").and_then(|v| v.as_str()),
-                Some("/cache"),
-                "absent creative should keep hb_cache_path"
-            );
-        }
+        let output = futures::executor::block_on(
+            response
+                .into_body()
+                .into_bytes_bounded(settings.publisher.max_buffered_body_bytes),
+        )
+        .expect("streaming body should drain")
+        .to_vec();
 
-        #[test]
-        fn build_bid_map_rewrites_inline_adm_to_absolute_first_party_urls() {
-            // The inline `adm` is rendered by the Prebid Universal Creative inside
-            // GAM's iframe (`f.srcdoc = d.ad`), a foreign origin. Proxied URLs must
-            // therefore be emitted **absolute** against the publisher domain — a
-            // root-relative `/first-party/proxy` would resolve against GAM and 404.
-            // The tsjs bundle must NOT be injected into that foreign-origin iframe.
-            let mut settings = test_settings();
-            settings.auction.rewrite_creatives = true;
-            settings.publisher.domain = "example.com".to_string();
-
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "examplessp",
-                "abc123",
-                "https://ssp.example.com/win",
-                "https://ssp.example.com/bill",
-            );
-            bid.creative = Some(
-                "<html><body><img src=\"https://cdn.example.com/pixel.png\"></body></html>"
+        let html = String::from_utf8(gzip_decode(&output)).expect("should be valid UTF-8");
+        let auction_id = boot_auction_id(&html);
+        assert!(
+            auction_id.starts_with("a1_"),
+            "should collect the exact projection with a browser-only auction id before the compressed head. Got head: {}",
+            &html[..html.len().min(500)]
+        );
+        assert!(
+            auction_id != "test-auction",
+            "should not expose the upstream auction id in the compressed head. Got head: {}",
+            &html[..html.len().min(500)]
+        );
+        assert!(!html.contains(".bids="));
+        assert!(
+            html.contains("trailing-content"),
+            "should preserve content after the close-body tag"
+        );
+        assert!(
+            html.trim_end().ends_with("</html>"),
+            "should not drop the decoded tail once the auction hold is released. Got tail: {}",
+            &html[html.len().saturating_sub(200)..]
+        );
+    }
+
+    #[test]
+    fn stream_publisher_body_treats_mixed_case_html_as_hard_cutover_html() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
+        let bids_script =
+            r#"<script>(window.tsjs=window.tsjs||{}).bids=JSON.parse("{}");</script>"#;
+        let state = AdBidsState::with_script(bids_script);
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: String::new(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "Text/HTML; Charset=utf-8".to_string(),
+            ad_slots_script: Some(
+                r#"<script>(window.tsjs=window.tsjs||{}).adSlots=JSON.parse("[]");</script>"#
                     .to_string(),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+            ),
+            ad_bids_state: state,
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+        let mut output = Vec::new();
+
+        stream_publisher_body(
+            EdgeBody::from(b"<html><head></head><body>content</body></html>".to_vec()),
+            &mut output,
+            &params,
+            &settings,
+            &registry,
+        )
+        .expect("should process mixed-case HTML content type");
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, "", false);
-            let adm = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .and_then(|o| o.get("adm"))
-                .and_then(|v| v.as_str())
-                .expect("should include a rewritten adm");
+        let html = String::from_utf8(output).expect("should be valid UTF-8");
+        assert!(
+            boot_auction_id(&html) == "initial",
+            "mixed-case HTML must use the HTML processor and inject the canonical boot projection. Got: {html}"
+        );
+        assert!(
+            !html.contains(".adSlots=JSON.parse") && !html.contains(".bids=JSON.parse"),
+            "mixed-case HTML must not restore legacy TSJS data globals. Got: {html}"
+        );
+    }
 
-            assert!(
-                adm.contains("https://example.com/first-party/proxy?tsurl="),
-                "should emit an absolute first-party proxy URL for the foreign-origin render context, got: {adm}"
-            );
-            assert!(
-                !adm.contains("src=\"/first-party/proxy"),
-                "should not emit a root-relative proxy URL that 404s under GAM's origin, got: {adm}"
-            );
-            assert!(
-                !adm.contains("https://cdn.example.com/pixel.png"),
-                "should proxy the original absolute CDN URL, got: {adm}"
-            );
-            assert!(
-                !adm.contains("/static/tsjs="),
-                "should not inject the tsjs bundle into a foreign-origin creative iframe, got: {adm}"
-            );
-        }
+    /// Mid-stream decoder failure must surface as an error. The adapter
+    /// relies on this: once headers are committed, it logs and drops the
+    /// `StreamingBody` so the client sees a truncated response. If a decode
+    /// failure silently emitted bytes, the client would see a malformed
+    /// document instead.
+    #[test]
+    fn stream_publisher_body_surfaces_mid_stream_decode_error() {
+        let settings = create_test_settings();
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
 
-        #[test]
-        fn build_bid_map_uses_request_origin_for_inline_urls() {
-            // The inline adm's absolute first-party URLs must resolve against the
-            // origin the visitor is on (here an HTTP dev host with a port), not the
-            // configured publisher domain.
-            let mut settings = test_settings();
-            settings.auction.rewrite_creatives = true;
-            settings.publisher.domain = "example.com".to_string();
-
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "examplessp",
-                "abc123",
-                "https://ssp.example.com/win",
-                "https://ssp.example.com/bill",
-            );
-            bid.creative = Some(
-                "<html><body><img src=\"https://cdn.example.com/pixel.png\"></body></html>"
-                    .to_string(),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+        // Claim gzip encoding but feed non-gzip bytes. The GzDecoder will
+        // error as soon as it tries to read the gzip header.
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: "gzip".to_string(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &settings,
-                "http://localhost:7676",
-                false,
-            );
-            let adm = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .and_then(|o| o.get("adm"))
-                .and_then(|v| v.as_str())
-                .expect("should include a rewritten adm");
+        let bogus_body = EdgeBody::from(b"<html>not gzip</html>".to_vec());
+        let mut output = Vec::new();
+        let result = stream_publisher_body(bogus_body, &mut output, &params, &settings, &registry);
 
-            assert!(
-                adm.contains("http://localhost:7676/first-party/proxy?tsurl="),
-                "should emit URLs against the request origin, got: {adm}"
-            );
-            assert!(
-                !adm.contains("https://example.com/first-party/proxy"),
-                "must not fall back to the configured publisher domain, got: {adm}"
-            );
-        }
+        assert!(
+            result.is_err(),
+            "decoding bogus gzip as gzip should return Err so the adapter can drop the stream"
+        );
+    }
 
-        #[test]
-        fn build_bid_map_expands_auction_price_macro_before_rewrite() {
-            // ${AUCTION_PRICE} must be resolved to the clearing price before the
-            // creative is rewritten and signed. Otherwise URL rewriting encodes the
-            // literal macro (`%24%7BAUCTION_PRICE%7D`) into the signed proxy/click
-            // URL, so trackers receive an encoded macro instead of the price and the
-            // signature locks the wrong value.
-            let mut settings = test_settings();
-            settings.publisher.domain = "example.com".to_string();
-
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "examplessp",
-                "abc123",
-                "https://ssp.example.com/win",
-                "https://ssp.example.com/bill",
-            );
-            bid.creative = Some(
-                "<html><body>\
-                 <a href=\"https://ads.example.com/click?p=${AUCTION_PRICE}\">go</a>\
-                 </body></html>"
-                    .to_string(),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+    /// Pass-through dispatch contract: the adapter treats `PublisherResponse::PassThrough`
+    /// by reattaching the origin body unchanged and letting Fastly emit it.
+    /// Simulate that step and assert byte identity plus Content-Length
+    /// preservation. Distinct from `pass_through_preserves_body_and_content_length`
+    /// which only tests the header preservation; this one walks the full
+    /// take-then-reattach pattern the adapter uses.
+    #[test]
+    fn publisher_response_pass_through_reattach_preserves_bytes() {
+        // Simulate a 2xx image/png response: Body::from(bytes), take_body(),
+        // then set_body(body). `classify_response_route` already picks
+        // PassThrough for this combination; this covers the adapter's
+        // reattachment half of the contract.
+        let image_bytes: Vec<u8> = (0..=127).cycle().take(2048).collect();
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, "", false);
-            let adm = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .and_then(|o| o.get("adm"))
-                .and_then(|v| v.as_str())
-                .expect("should include a rewritten adm");
+        let mut response = Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "image/png")
+            .header(header::CONTENT_LENGTH, image_bytes.len() as u64)
+            .body(EdgeBody::from(image_bytes.clone()))
+            .expect("should build test response");
 
-            assert!(
-                !adm.to_uppercase().contains("AUCTION_PRICE"),
-                "no literal or encoded ${{AUCTION_PRICE}} macro should survive: {adm}"
-            );
-            assert!(
-                adm.contains("p=1.5"),
-                "the exact winning CPM should be substituted into the signed URL: {adm}"
-            );
-        }
+        // Mirror adapter: take body, then reattach.
+        let body = std::mem::replace(response.body_mut(), EdgeBody::empty());
+        *response.body_mut() = body;
 
-        #[test]
-        fn build_bid_map_expands_auction_price_macro_in_notification_urls() {
-            // Per OpenRTB the win/billing notices are the primary carriers of
-            // ${AUCTION_PRICE}, and the bridge fires them verbatim. An unexpanded
-            // macro would report an unresolved clearing price to the SSP, and
-            // would disagree with the price already substituted into the adm.
-            let mut winning_bids = HashMap::new();
-            let bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "examplessp",
-                "abc123",
-                "https://ssp.example.com/win?p=${AUCTION_PRICE}",
-                "https://ssp.example.com/bill?p=${AUCTION_PRICE}",
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CONTENT_LENGTH)
+                .and_then(|v| v.to_str().ok())
+                .expect("content-length should survive"),
+            "2048"
+        );
+        let (_, final_body) = response.into_parts();
+        let round_trip = final_body.into_bytes().unwrap_or_default();
+        assert_eq!(
+            round_trip, image_bytes,
+            "pass-through reattach must preserve bytes exactly"
+        );
+    }
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .and_then(|v| v.as_object())
-                .expect("should have bid entry");
-
-            for field in ["nurl", "burl"] {
-                let url = obj
-                    .get(field)
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_else(|| panic!("should include {field}"));
-                assert!(
-                    !url.to_uppercase().contains("AUCTION_PRICE"),
-                    "no literal or encoded ${{AUCTION_PRICE}} macro should survive in {field}: {url}"
-                );
-                assert!(
-                    url.ends_with("?p=1.5"),
-                    "the exact winning CPM should be substituted into {field}: {url}"
-                );
-            }
-        }
+    /// Streaming dispatch contract: HTML with a registered post-processor still
+    /// routes through `Stream`, and the shared processor pipeline still applies
+    /// the post-processor rewrite.
+    #[test]
+    fn streaming_html_with_post_processors_rewrites_body() {
+        // Configure nextjs so a post-processor is registered.
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "nextjs",
+                &serde_json::json!({
+                    "enabled": true,
+                    "rewrite_attributes": ["href", "link", "url"],
+                }),
+            )
+            .expect("should update nextjs config");
 
-        #[test]
-        fn build_bids_script_escapes_line_separators_in_adm() {
-            // U+2028/U+2029 are valid JSON string content but terminate inline
-            // <script> statements; they survive the sanitize boundary as ordinary
-            // text, so build_bids_script must unicode-escape them.
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "s",
-                1.50,
-                "kargo",
-                "abc123",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.creative = Some("<div>a\u{2028}b\u{2029}c</div>".to_string());
-            winning_bids.insert("s".to_string(), bid);
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
+        assert!(
+            registry.has_html_post_processors(),
+            "nextjs integration must register an HTML post-processor"
+        );
+        assert_eq!(
+            classify_response_route(
+                StatusCode::OK,
+                "text/html; charset=utf-8",
                 "",
-                false,
-            );
-            let script = build_bids_script(&map);
-            assert!(
-                !script.contains('\u{2028}') && !script.contains('\u{2029}'),
-                "should unicode-escape both U+2028 and U+2029 in the adm"
-            );
-        }
-
-        #[test]
-        fn client_bid_map_includes_debug_bid_when_debug_injection_enabled() {
-            let mut winning_bids = HashMap::new();
-            let mut bid = make_bid(
-                "atf_sidebar_ad",
-                1.50,
-                "mocktioneer",
-                "bid-ad-id",
-                "https://ssp/win",
-                "https://ssp/bill",
-            );
-            bid.creative = Some("<div>Creative</div>".to_string());
-            bid.adomain = Some(vec!["example.com".to_string()]);
-            bid.cache_id = Some("cache-uuid".to_string());
-            bid.cache_host = Some("cache.example".to_string());
-            bid.cache_path = Some("/cache".to_string());
-            bid.metadata.insert(
-                "raw_field".to_string(),
-                serde_json::Value::String("raw-value".to_string()),
-            );
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+                "proxy.example.com",
+            ),
+            ResponseRoute::Stream,
+            "HTML with post-processors must route to Stream"
+        );
 
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                true,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            let debug_bid = obj
-                .get("debug_bid")
-                .and_then(|v| v.as_object())
-                .expect("should include debug bid when debug injection is enabled");
+        // Feed a small HTML body through the same pipeline the Stream arm uses.
+        let html =
+            b"<html><body><a href=\"https://origin.example.com/page\">link</a></body></html>";
+        let body = EdgeBody::from(html.to_vec());
 
-            assert_eq!(
-                debug_bid.get("slot_id").and_then(|v| v.as_str()),
-                Some("atf_sidebar_ad"),
-                "should expose original slot id"
-            );
-            assert_eq!(
-                debug_bid.get("bidder").and_then(|v| v.as_str()),
-                Some("mocktioneer"),
-                "should expose original bidder"
-            );
-            assert_eq!(
-                debug_bid.get("ad_id").and_then(|v| v.as_str()),
-                Some("bid-ad-id"),
-                "should expose original bid ad id"
-            );
-            assert_eq!(
-                debug_bid.get("cache_id").and_then(|v| v.as_str()),
-                Some("cache-uuid"),
-                "should expose original PBS cache id"
-            );
-            assert_eq!(
-                debug_bid.get("metadata").and_then(|v| v.get("raw_field")),
-                Some(&serde_json::Value::String("raw-value".to_string())),
-                "should expose provider metadata"
-            );
-        }
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: String::new(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html; charset=utf-8".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
+        let mut output = Vec::new();
+        stream_publisher_body(body, &mut output, &params, &settings, &registry)
+            .expect("should process streaming HTML");
 
-        #[test]
-        fn bid_map_uses_cache_id_for_hb_adid_when_present() {
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "atf_sidebar_ad".to_string(),
-                Bid {
-                    slot_id: "atf_sidebar_ad".to_string(),
-                    price: Some(1.50),
-                    currency: "USD".to_string(),
-                    creative: None,
-                    adomain: None,
-                    bidder: "thetradedesk".to_string(),
-                    returned_seat: None,
-                    width: 300,
-                    height: 250,
-                    nurl: None,
-                    burl: None,
-                    bid_id: None,
-                    creative_id: None,
-                    renderer: None,
-                    ad_id: Some("bid-impression-id".to_string()),
-                    cache_id: Some("f47447a0-b759-4f2f-9887-af458b79b570".to_string()),
-                    cache_host: Some("openads.adsrvr.org".to_string()),
-                    cache_path: Some("/cache".to_string()),
-                    metadata: Default::default(),
-                },
-            );
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            assert_eq!(
-                obj.get("hb_adid").and_then(|v| v.as_str()),
-                Some("f47447a0-b759-4f2f-9887-af458b79b570"),
-                "should use cache_id for hb_adid, not ad_id"
-            );
-            assert_eq!(
-                obj.get("hb_cache_host").and_then(|v| v.as_str()),
-                Some("openads.adsrvr.org"),
-                "should emit hb_cache_host"
-            );
-            assert_eq!(
-                obj.get("hb_cache_path").and_then(|v| v.as_str()),
-                Some("/cache"),
-                "should emit hb_cache_path"
-            );
-        }
+        assert!(
+            !output.is_empty(),
+            "streaming processed output must not be empty"
+        );
+        let as_str = std::str::from_utf8(&output).expect("output should be valid UTF-8");
+        assert!(
+            as_str.contains("proxy.example.com"),
+            "origin must be rewritten. Got: {as_str}"
+        );
+        assert!(
+            !as_str.contains("origin.example.com"),
+            "origin host must not leak. Got: {as_str}"
+        );
+    }
 
-        #[test]
-        fn bid_map_falls_back_to_ad_id_when_cache_id_absent() {
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "atf_sidebar_ad".to_string(),
-                Bid {
-                    slot_id: "atf_sidebar_ad".to_string(),
-                    price: Some(0.50),
-                    currency: "USD".to_string(),
-                    creative: None,
-                    adomain: None,
-                    bidder: "amazon-aps".to_string(),
-                    returned_seat: None,
-                    width: 300,
-                    height: 250,
-                    nurl: None,
-                    burl: None,
-                    bid_id: None,
-                    ad_id: Some("aps-bid-token".to_string()),
-                    creative_id: None,
-                    renderer: None,
-                    cache_id: None,
-                    cache_host: None,
-                    cache_path: None,
-                    metadata: Default::default(),
-                },
-            );
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            assert_eq!(
-                obj.get("hb_adid").and_then(|v| v.as_str()),
-                Some("aps-bid-token"),
-                "should fall back to ad_id when cache_id absent"
-            );
-            assert!(
-                obj.get("hb_cache_host").is_none(),
-                "should not emit hb_cache_host when absent"
-            );
-            assert!(
-                obj.get("hb_cache_path").is_none(),
-                "should not emit hb_cache_path when absent"
-            );
-        }
+    /// Document-state survives from the streaming pass into the post-processor.
+    /// `NextJsRscPlaceholderRewriter` writes into `IntegrationDocumentState`
+    /// during streaming; `NextJsHtmlPostProcessor` reads it and substitutes.
+    /// Regression test: with post-processors registered, placeholders must
+    /// be inserted during streaming and substituted out of the final output.
+    #[test]
+    fn document_state_placeholders_substitute_through_accumulating_path() {
+        let mut settings = create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "nextjs",
+                &serde_json::json!({
+                    "enabled": true,
+                    "rewrite_attributes": ["href", "link", "url"],
+                }),
+            )
+            .expect("should update nextjs config");
+        let registry = IntegrationRegistry::with_plan(
+            &settings,
+            Arc::new(
+                crate::auction::compile_auction_plan(&settings)
+                    .expect("should compile auction plan"),
+            ),
+        )
+        .expect("should create integration registry");
 
-        #[test]
-        fn bid_map_exposes_aps_renderer_and_selected_bid_id() {
-            // Sanitization is opt-in, so enable it: the script-only creative
-            // below is what drives this bid onto the renderer path. Left at the
-            // default it would survive processing as an ordinary creative.
-            let mut settings = test_settings();
-            settings.auction.sanitize_creatives = true;
-            let mut bid = make_bid("atf_sidebar_ad", 1.50, "aps", "fallback-ad", "", "");
-            bid.bid_id = Some("selected-bid".to_string());
-            bid.creative = Some("<script>reject()</script>".to_string());
-            bid.nurl = None;
-            bid.burl = None;
-            bid.renderer = Some(BidRenderer::Aps(ApsRendererV1 {
-                version: 1,
-                account_id: "example-account".to_string(),
-                bid_id: "selected-bid".to_string(),
-                creative_id: None,
-                tag_type: ApsTagType::Iframe,
-                creative_url: "https://creative.example/render".to_string(),
-                aax_response: "fictional-base64</script>".to_string(),
-                width: 300,
-                height: 250,
-            }));
-            let winning_bids = HashMap::from([("atf_sidebar_ad".to_string(), bid)]);
-
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, "", false);
-            let obj = map["atf_sidebar_ad"]
-                .as_object()
-                .expect("should include APS bid");
-
-            assert_eq!(obj["hb_bidder"], "aps");
-            assert_eq!(obj["hb_adid"], "selected-bid");
-            assert_eq!(obj["renderer"]["type"], "aps");
-            assert_eq!(obj["renderer"]["bidId"], "selected-bid");
-            assert!(obj.get("adm").is_none());
-
-            let script = build_bids_script(&map);
-            assert!(!script.contains("</script></script>"));
-            assert!(script.contains("\\u003C/script\\u003E"));
-        }
+        // Small, single-fragment RSC script — placeholder path (not fallback).
+        let html = br#"<html><body><script>self.__next_f.push([1,"1:{\"link\":\"https://origin.example.com/page\"}"])</script></body></html>"#;
+        let params = OwnedProcessResponseParams {
+            csp_nonce_observed: None,
+            template_cache_key: None,
+            seam_ad_slots: None,
+            policy_headers: Vec::new(),
+            content_encoding: String::new(),
+            origin_host: "origin.example.com".to_string(),
+            origin_url: "https://origin.example.com".to_string(),
+            request_host: "proxy.example.com".to_string(),
+            request_scheme: "https".to_string(),
+            content_type: "text/html".to_string(),
+            ad_slots_script: None,
+            ad_bids_state: AdBidsState::default(),
+            auction_observation: None,
+            auction_request: None,
+            dispatched_auction: None,
+            price_granularity: crate::price_bucket::PriceGranularity::default(),
+            gpt_diagnostics: None,
+            suppress_datadome_client_side_tag: false,
+            render_trace_overlay: false,
+        };
 
-        #[test]
-        fn bid_map_omits_creative_rejected_by_processing_without_renderer() {
-            // Sanitization is opt-in, so enable it: script-only markup is what
-            // makes processing reject this bid's only render source.
-            let mut settings = test_settings();
-            settings.auction.sanitize_creatives = true;
-            let mut bid = make_bid("atf_sidebar_ad", 1.50, "kargo", "fallback-ad", "", "");
-            bid.creative = Some("<script>reject()</script>".to_string());
-            let winning_bids = HashMap::from([("atf_sidebar_ad".to_string(), bid)]);
+        let mut output = Vec::new();
+        stream_publisher_body(
+            EdgeBody::from(html.to_vec()),
+            &mut output,
+            &params,
+            &settings,
+            &registry,
+        )
+        .expect("should process RSC push");
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, "", false);
+        let processed = String::from_utf8(output).expect("valid UTF-8");
+        assert!(
+            !processed.contains("__ts_rsc_payload_"),
+            "placeholder must be substituted before reaching output. Got: {processed}"
+        );
+        assert!(
+            processed.contains("proxy.example.com/page"),
+            "origin URL must be rewritten in the substituted payload. Got: {processed}"
+        );
+        assert!(
+            !processed.contains("origin.example.com"),
+            "origin host must not leak. Got: {processed}"
+        );
+    }
 
-            assert!(
-                !map.contains_key("atf_sidebar_ad"),
-                "should omit a bid whose only creative was rejected"
-            );
-        }
+    #[cfg(test)]
+    mod creative_opportunities_tests {
+        use super::super::{MatchedSlotsContext, build_auction_request, build_browser_slots_v1};
+        use crate::auction::types::MediaType;
+        use crate::consent::ConsentContext;
+        use crate::creative_opportunities::{
+            CreativeOpportunitiesConfig, CreativeOpportunityFormat, CreativeOpportunitySlot,
+        };
+        use crate::http_util::RequestInfo;
+        use crate::price_bucket::PriceGranularity;
 
-        #[test]
-        fn bid_map_omits_hb_adid_when_both_cache_id_and_ad_id_absent() {
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "atf_sidebar_ad".to_string(),
-                Bid {
-                    slot_id: "atf_sidebar_ad".to_string(),
-                    price: Some(0.50),
-                    currency: "USD".to_string(),
-                    creative: None,
-                    adomain: None,
-                    bidder: "amazon-aps".to_string(),
-                    returned_seat: None,
-                    width: 300,
-                    height: 250,
-                    nurl: None,
-                    burl: None,
-                    bid_id: None,
-                    creative_id: None,
-                    renderer: None,
-                    ad_id: None,
-                    cache_id: None,
-                    cache_host: None,
-                    cache_path: None,
-                    metadata: Default::default(),
-                },
-            );
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
-            assert!(
-                obj.get("hb_adid").is_none(),
-                "should omit hb_adid when no cache_id and no ad_id"
-            );
+        fn make_config() -> CreativeOpportunitiesConfig {
+            CreativeOpportunitiesConfig {
+                enabled: true,
+                gam_network_id: "21765378893".to_string(),
+                auction_timeout_ms: Some(500),
+                price_granularity: PriceGranularity::Dense,
+                section_root: None,
+                assembly_mode: None,
+                template_cache_vary: None,
+                template_cache_max_age_seconds: None,
+                origin_is_cookie_independent: None,
+                section_segment: None,
+                slot: Vec::new(),
+            }
         }
 
-        #[test]
-        fn bid_map_excludes_slot_when_price_is_none() {
-            let mut winning_bids = HashMap::new();
-            winning_bids.insert(
-                "no-price-slot".to_string(),
-                Bid {
-                    slot_id: "no-price-slot".to_string(),
-                    price: None,
-                    currency: "USD".to_string(),
-                    creative: None,
-                    adomain: None,
-                    bidder: "kargo".to_string(),
-                    returned_seat: None,
+        fn make_slot() -> CreativeOpportunitySlot {
+            CreativeOpportunitySlot {
+                id: "atf_sidebar_ad".to_string(),
+                gam_unit_path: Some("/21765378893/publisher/atf-sidebar".to_string()),
+                div_id: Some("div-atf-sidebar".to_string()),
+                page_patterns: vec!["/20**".to_string()],
+                formats: vec![CreativeOpportunityFormat {
                     width: 300,
                     height: 250,
-                    nurl: None,
-                    burl: None,
-                    bid_id: None,
-                    creative_id: None,
-                    renderer: None,
-                    ad_id: None,
-                    cache_id: None,
-                    cache_host: None,
-                    cache_path: None,
-                    metadata: Default::default(),
-                },
-            );
-            let map = build_bid_map(
-                &winning_bids,
-                PriceGranularity::Dense,
-                &test_settings(),
-                "",
-                false,
-            );
-            assert!(
-                map.is_empty(),
-                "slot with no price should be excluded from bid map"
-            );
-        }
-
-        #[test]
-        fn bids_script_is_xss_safe() {
-            let mut map = serde_json::Map::new();
-            map.insert("atf".to_string(), serde_json::json!({"hb_pb": "1.00"}));
-            let script = build_bids_script(&map);
-            let inner = script
-                .trim_start_matches("<script>")
-                .trim_end_matches("</script>");
-            assert!(!inner.contains('<'), "no unescaped < in bids script");
-            assert!(!inner.contains('>'), "no unescaped > in bids script");
+                    media_type: MediaType::Banner,
+                }],
+                floor_price: Some(0.50),
+                targeting: [("pos".to_string(), "atf".to_string())]
+                    .into_iter()
+                    .collect(),
+                providers: Default::default(),
+                compiled_patterns: Vec::new(),
+                compiled_unit: None,
+            }
         }
 
         #[test]
-        fn bids_script_schedules_ad_init_without_retry_timer() {
-            let mut map = serde_json::Map::new();
-            map.insert("atf".to_string(), serde_json::json!({"hb_pb": "1.00"}));
-
-            let script = build_bids_script(&map);
+        fn browser_slots_render_section_from_request_path() {
+            let mut config = make_config();
+            config.gam_network_id = "99999".to_string();
+            config.section_root = Some("homepage".to_string());
+            let mut slot = make_slot();
+            slot.gam_unit_path = Some("/{network_id}/example/{section}".to_string());
+            slot.compile_unit_template()
+                .expect("template should compile");
 
-            assert!(
-                script.contains("t.scheduleInitialAdInit"),
-                "should hand off bids to the deferred adInit scheduler"
-            );
-            assert!(
-                !script.contains("setTimeout"),
-                "should not retry adInit on a timer"
+            let news =
+                build_browser_slots_v1(std::slice::from_ref(&slot), &config, "/news/article-123");
+            assert_eq!(
+                news[0].gam_unit_path, "/99999/example/news",
+                "section should derive from the first path segment"
             );
-            assert!(
-                !script.contains("prevGptSlots"),
-                "should not use TS-owned slots as adInit success signal"
+
+            let home = build_browser_slots_v1(std::slice::from_ref(&slot), &config, "/");
+            assert_eq!(
+                home[0].gam_unit_path, "/99999/example/homepage",
+                "root path should use section_root"
             );
         }
 
         #[test]
-        fn bids_script_defers_ad_init_until_after_hydration() {
-            let mut map = serde_json::Map::new();
-            map.insert("atf".to_string(), serde_json::json!({"hb_pb": "1.00"}));
-
-            let script = build_bids_script(&map);
-
-            // adInit() mutates ad-slot subtrees (GPT defineSlot on the
-            // `-container` wrapper). Running it synchronously at body-parse time
-            // lands those mutations inside React's hydration window and trips a
-            // #418 hydration mismatch. The deferral lifecycle (window `load`,
-            // double `requestAnimationFrame`, generation-0 pinning via
-            // `tsjs.navGeneration`) lives in the GPT bundle module (with a
-            // head-injected fallback in gpt_bootstrap.js) where it is executable
-            // under Vitest (schedule_initial_ad_init.test.ts); this inline
-            // script must only delegate to that scheduler.
-            assert!(
-                script.contains("var s=t.scheduleInitialAdInit"),
-                "should delegate deferral to the installed scheduler"
-            );
-            // The bids payload is handed to the scheduler (which applies it only
-            // while the page is still on navigation generation 0) instead of
-            // being assigned unconditionally, so a faster SPA navigation's live
-            // bids cannot be clobbered by the stale SSR payload.
-            assert!(
-                script.contains("if(typeof s===\"function\")s(b)"),
-                "should pass the SSR bids payload to the scheduler"
-            );
-            assert!(
-                script.contains("else t.bids=b"),
-                "should fall back to a plain bids assignment without a scheduler"
-            );
-            assert!(
-                !script.contains(".bids=JSON.parse"),
-                "should not assign the SSR payload unconditionally"
+        fn browser_slots_honour_configured_section_segment() {
+            // Locale-prefixed publisher: `/en/news/article` must resolve to the
+            // `news` unit, not `en`.
+            let mut config = make_config();
+            config.gam_network_id = "99999".to_string();
+            config.section_root = Some("homepage".to_string());
+            config.section_segment = Some(1);
+            let mut slot = make_slot();
+            slot.gam_unit_path = Some("/{network_id}/example/{section}".to_string());
+            slot.compile_unit_template()
+                .expect("template should compile");
+
+            let news = build_browser_slots_v1(
+                std::slice::from_ref(&slot),
+                &config,
+                "/en/news/article-123",
             );
-            // The one hydration-unsafe thing this script could do is invoke
-            // adInit synchronously at body-parse time — it must not.
-            assert!(
-                !script.contains("adInit()"),
-                "should not invoke adInit synchronously at parse time"
+            assert_eq!(
+                news[0].gam_unit_path, "/99999/example/news",
+                "section should derive from the configured segment index"
             );
-            assert!(
-                !script.contains("setTimeout"),
-                "should not retry adInit on a timer"
+
+            let locale_root = build_browser_slots_v1(std::slice::from_ref(&slot), &config, "/en");
+            assert_eq!(
+                locale_root[0].gam_unit_path, "/99999/example/homepage",
+                "a path with no segment at the configured index should use section_root"
             );
         }
 
@@ -19284,176 +13929,34 @@ mod tests {
                 &slots_ctx,
                 Some("ec-abc"),
                 &ConsentContext::default(),
-                &request_info,
-                "publisher.example.com",
-                Some("Mozilla/5.0"),
-            );
-
-            assert_eq!(
-                request.user.id.as_deref(),
-                Some("ec-abc"),
-                "should forward EC id when identity consent allows it"
-            );
-            assert_eq!(
-                request.id, "ts-ec-abc",
-                "should preserve existing EC-derived request id when present"
-            );
-        }
-
-        #[test]
-        fn html_escape_encodes_special_chars() {
-            assert_eq!(
-                html_escape_for_script("text\\with\\backslash"),
-                "text\\\\with\\\\backslash",
-                "should escape backslashes"
-            );
-            assert_eq!(
-                html_escape_for_script("string\"with\"quotes"),
-                "string\\\"with\\\"quotes",
-                "should escape quotes"
-            );
-            assert_eq!(
-                html_escape_for_script("simple"),
-                "simple",
-                "should not change simple text"
-            );
-            assert_eq!(
-                html_escape_for_script("both\\\"mixed"),
-                "both\\\\\\\"mixed",
-                "should escape both backslashes and quotes"
-            );
-            assert_eq!(
-                html_escape_for_script("<script>alert(1)</script>"),
-                "\\u003Cscript\\u003Ealert(1)\\u003C/script\\u003E",
-                "should unicode-escape angle brackets to prevent script injection"
-            );
-            assert_eq!(
-                html_escape_for_script("a&b"),
-                "a\\u0026b",
-                "should unicode-escape ampersand"
-            );
-            assert_eq!(
-                html_escape_for_script("line\u{2028}sep"),
-                "line\\u2028sep",
-                "should unicode-escape U+2028 line separator"
-            );
-            assert_eq!(
-                html_escape_for_script("para\u{2029}sep"),
-                "para\\u2029sep",
-                "should unicode-escape U+2029 paragraph separator"
-            );
-        }
-    }
-
-    mod page_bids_no_match_tests {
-        use super::super::*;
-        use super::build_services_with_http_client;
-        use crate::auction::AuctionOrchestrator;
-        use crate::auction::provider::{AuctionProvider, ProviderRequestOutcome};
-        use crate::auction::types::{AuctionRequest, AuctionResponse, Bid};
-        use crate::creative_opportunities::{CreativeOpportunityFormat, CreativeOpportunitySlot};
-        use crate::platform::test_support::{StubHttpClient, noop_services};
-        use crate::platform::{PlatformHttpRequest, PlatformResponse};
-        use crate::test_support::tests::crate_test_settings_str;
-        use error_stack::{Report, ResultExt};
-        use http::Method;
-        use std::sync::{Arc, Mutex};
-
-        const AUCTION_ID_TEST_PROVIDER: &str = "auction_id_test_provider";
-        const AUCTION_ID_TEST_BACKEND: &str = "auction-id-test-backend";
-
-        struct AuctionIdTestProvider {
-            captured_request: Arc<Mutex<Option<AuctionRequest>>>,
-            winning_bid: bool,
-        }
-
-        #[async_trait::async_trait(?Send)]
-        impl AuctionProvider for AuctionIdTestProvider {
-            fn provider_name(&self) -> &str {
-                AUCTION_ID_TEST_PROVIDER
-            }
-
-            async fn request_bids(
-                &self,
-                request: &AuctionRequest,
-                context: &AuctionContext<'_>,
-            ) -> Result<ProviderRequestOutcome, Report<TrustedServerError>> {
-                *self
-                    .captured_request
-                    .lock()
-                    .expect("should lock captured auction request") = Some(request.clone());
-                let request = PlatformHttpRequest::new(
-                    Request::builder()
-                        .method(Method::POST)
-                        .uri("https://bidder.example.test/bids")
-                        .body(EdgeBody::empty())
-                        .expect("should build test bidder request"),
-                    AUCTION_ID_TEST_BACKEND,
-                );
-                context
-                    .services
-                    .http_client()
-                    .send_async(request)
-                    .await
-                    .change_context(TrustedServerError::Auction {
-                        message: "test bidder launch failed".to_string(),
-                    })
-                    .map(ProviderRequestOutcome::pending)
-            }
-
-            async fn parse_response(
-                &self,
-                _response: PlatformResponse,
-                response_time_ms: u64,
-            ) -> Result<AuctionResponse, Report<TrustedServerError>> {
-                let bids = if self.winning_bid {
-                    vec![Bid {
-                        slot_id: "atf".to_string(),
-                        price: Some(1.50),
-                        currency: "USD".to_string(),
-                        creative: None,
-                        adomain: None,
-                        bidder: AUCTION_ID_TEST_PROVIDER.to_string(),
-                        returned_seat: None,
-                        width: 300,
-                        height: 250,
-                        nurl: None,
-                        burl: None,
-                        bid_id: None,
-                        creative_id: None,
-                        renderer: None,
-                        ad_id: Some("winner-123".to_string()),
-                        cache_id: None,
-                        cache_host: None,
-                        cache_path: None,
-                        metadata: Default::default(),
-                    }]
-                } else {
-                    Vec::new()
-                };
-                Ok(AuctionResponse::success(
-                    AUCTION_ID_TEST_PROVIDER,
-                    bids,
-                    response_time_ms,
-                ))
-            }
-
-            fn timeout_ms(&self) -> u32 {
-                100
-            }
-
-            fn backend_name(
-                &self,
-                _services: &RuntimeServices,
-                _timeout_ms: u32,
-            ) -> Option<String> {
-                Some(AUCTION_ID_TEST_BACKEND.to_string())
-            }
+                &request_info,
+                "publisher.example.com",
+                Some("Mozilla/5.0"),
+            );
+
+            assert_eq!(
+                request.user.id.as_deref(),
+                Some("ec-abc"),
+                "should forward EC id when identity consent allows it"
+            );
+            assert_eq!(
+                request.id, "ts-ec-abc",
+                "should preserve existing EC-derived request id when present"
+            );
         }
+    }
+
+    mod page_bids_no_match_tests {
+        use super::super::*;
+        use crate::auction::AuctionOrchestrator;
+        use crate::creative_opportunities::{CreativeOpportunityFormat, CreativeOpportunitySlot};
+        use crate::platform::test_support::noop_services;
+        use crate::test_support::tests::crate_test_settings_str;
+        use http::Method;
 
         fn settings_with_co() -> Settings {
             let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n[creative_opportunities]\ngam_network_id = \"12345\"\n",
+                "{}\n[auction]\nenabled = true\n\n[creative_opportunities]\nenabled = true\ngam_network_id = \"12345\"\n",
                 crate_test_settings_str()
             );
             Settings::from_toml(&toml).expect("should parse settings with creative_opportunities")
@@ -19469,18 +13972,19 @@ mod tests {
 
         fn settings_with_co_auction_disabled() -> Settings {
             let toml = format!(
-                "{}\n[auction]\nenabled = false\n\n[creative_opportunities]\ngam_network_id = \"12345\"\n",
+                "{}\n[auction]\nenabled = false\n\n[creative_opportunities]\nenabled = true\ngam_network_id = \"12345\"\n",
                 crate_test_settings_str()
             );
             Settings::from_toml(&toml).expect("should parse settings with creative_opportunities")
         }
 
-        fn settings_with_co_templates_disabled() -> Settings {
+        fn settings_with_co_disabled() -> Settings {
             let toml = format!(
                 "{}\n[auction]\nenabled = true\n\n[creative_opportunities]\nenabled = false\ngam_network_id = \"12345\"\n",
                 crate_test_settings_str()
             );
-            Settings::from_toml(&toml).expect("should parse settings with disabled templates")
+            Settings::from_toml(&toml)
+                .expect("should parse settings with creative opportunity delivery disabled")
         }
 
         async fn run_page_bids(
@@ -19543,67 +14047,11 @@ mod tests {
         }
 
         fn make_page_bids_request(path: &str) -> Request<EdgeBody> {
-            make_page_bids_request_on(PAGE_BIDS_PATH, path)
-        }
-
-        #[tokio::test]
-        async fn page_bids_format_absent_or_json_returns_json() {
-            let settings = settings_with_co();
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            for path_and_format in ["/2024/article", "/2024/article&format=json"] {
-                let response = run_page_bids_response(
-                    &settings,
-                    &orchestrator,
-                    &[],
-                    make_page_bids_request(path_and_format),
-                )
-                .await;
-                assert_eq!(
-                    response.status(),
-                    StatusCode::OK,
-                    "should accept page-bids format in `{path_and_format}`"
-                );
-                assert_eq!(
-                    response.headers().get(header::CONTENT_TYPE),
-                    Some(&HeaderValue::from_static("application/json")),
-                    "should return JSON for `{path_and_format}`"
-                );
-                assert!(
-                    response
-                        .extensions()
-                        .get::<crate::response_privacy::TerminalPrivateResponse>()
-                        .is_some(),
-                    "successful per-user page-bids JSON should remain terminal-private"
-                );
-            }
-        }
-
-        #[tokio::test]
-        async fn page_bids_format_rejects_removed_unknown_and_empty_values() {
-            let settings = settings_with_co();
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            for format in ["fragment", "scrpit", ""] {
-                let response = run_page_bids_response(
-                    &settings,
-                    &orchestrator,
-                    &[],
-                    make_page_bids_request(&format!("/2024/article&format={format}")),
-                )
-                .await;
-                assert_eq!(
-                    response.status(),
-                    StatusCode::BAD_REQUEST,
-                    "should reject page-bids format `{format}`"
-                );
-            }
-        }
-
-        /// Builds a page-bids request against an explicit endpoint path, so the
-        /// canonical route and its deprecated alias can be compared directly.
-        fn make_page_bids_request_on(endpoint: &str, path: &str) -> Request<EdgeBody> {
             let mut req = Request::builder()
                 .method(Method::GET)
-                .uri(format!("https://test-publisher.com{endpoint}?path={path}"))
+                .uri(format!(
+                    "https://test-publisher.com{PAGE_BIDS_PATH}?path={path}"
+                ))
                 .body(EdgeBody::empty())
                 .expect("should build test request");
             // Pass the same-origin gate the way a browser fetch from the
@@ -19654,321 +14102,6 @@ mod tests {
             .expect("should return ok response")
         }
 
-        fn auction_id_test_orchestrator(
-            settings: &Settings,
-            captured_request: Arc<Mutex<Option<AuctionRequest>>>,
-            winning_bid: bool,
-        ) -> AuctionOrchestrator {
-            let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            orchestrator.register_provider(Arc::new(AuctionIdTestProvider {
-                captured_request,
-                winning_bid,
-            }));
-            orchestrator
-        }
-
-        #[tokio::test]
-        async fn page_bids_response_includes_auction_id_only_for_winning_bids() {
-            let mut settings = settings_with_co();
-            settings.auction.providers =
-                crate::auction::AuctionConfig::legacy_provider_map(&[AUCTION_ID_TEST_PROVIDER]);
-            settings
-                .integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should enable diagnostics");
-            let slots = article_slot();
-            let winning_stub = Arc::new(StubHttpClient::new());
-            winning_stub.push_response(200, b"winner".to_vec());
-            let winning_services = build_services_with_http_client(
-                Arc::clone(&winning_stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let winning_request = Arc::new(Mutex::new(None));
-            let winning_orchestrator =
-                auction_id_test_orchestrator(&settings, Arc::clone(&winning_request), true);
-            let ec_context = EcContext::new_for_test(
-                Some("page-auction-example-123".to_string()),
-                crate::consent::ConsentContext {
-                    jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                    ..Default::default()
-                },
-            );
-
-            let winning_response = handle_page_bids(
-                &settings,
-                &winning_services,
-                None,
-                AuctionDispatch {
-                    orchestrator: &winning_orchestrator,
-                    slots: &slots,
-                    registry: None,
-                },
-                &ec_context,
-                make_page_bids_request("/2024/01/my-article/"),
-            )
-            .await
-            .expect("should return winning page-bids response");
-            let winning_body: serde_json::Value = serde_json::from_slice(
-                &winning_response
-                    .into_body()
-                    .into_bytes()
-                    .expect("should read winning page-bids response body"),
-            )
-            .expect("should serialize winning page-bids response as JSON");
-            let auction_request = winning_request
-                .lock()
-                .expect("should lock captured winning request")
-                .clone()
-                .expect("should dispatch a winning auction request");
-
-            assert_eq!(
-                auction_request.id, "ts-page-auction-example-123",
-                "test EC ID should produce a deterministic auction request ID"
-            );
-            let winning_auction_id = winning_body["bids"]["atf"]["hb_auction_id"]
-                .as_str()
-                .expect("page-bids should expose an auction ID on the winner")
-                .to_string();
-            assert!(
-                winning_auction_id.starts_with("ts-auc-"),
-                "page-bids should expose a freshly minted diagnostics token, got `{winning_auction_id}`"
-            );
-            assert_ne!(
-                winning_auction_id, auction_request.id,
-                "browser-visible auction ID must not be the EC-derived request ID"
-            );
-            assert!(
-                !winning_auction_id.contains("page-auction-example-123"),
-                "browser-visible auction ID must not embed the EC ID"
-            );
-
-            let no_winner_stub = Arc::new(StubHttpClient::new());
-            no_winner_stub.push_response(200, b"no-bid".to_vec());
-            let no_winner_services = build_services_with_http_client(
-                Arc::clone(&no_winner_stub) as Arc<dyn crate::platform::PlatformHttpClient>
-            );
-            let no_winner_orchestrator =
-                auction_id_test_orchestrator(&settings, Arc::new(Mutex::new(None)), false);
-            let no_winner_response = handle_page_bids(
-                &settings,
-                &no_winner_services,
-                None,
-                AuctionDispatch {
-                    orchestrator: &no_winner_orchestrator,
-                    slots: &slots,
-                    registry: None,
-                },
-                &ec_context,
-                make_page_bids_request("/2024/01/my-article/"),
-            )
-            .await
-            .expect("should return no-winner page-bids response");
-            let no_winner_body: serde_json::Value = serde_json::from_slice(
-                &no_winner_response
-                    .into_body()
-                    .into_bytes()
-                    .expect("should read no-winner page-bids response body"),
-            )
-            .expect("should serialize no-winner page-bids response as JSON");
-
-            assert!(
-                no_winner_body["bids"]
-                    .as_object()
-                    .expect("page-bids should return a bids object")
-                    .is_empty(),
-                "page-bids should not fabricate auction metadata without a winner"
-            );
-        }
-
-        /// The browser-visible auction ID is minted per auction and only for
-        /// deployments that run the diagnostics integration, so it can neither
-        /// carry EC identity across auctions nor reach pages that ignore it.
-        #[tokio::test]
-        async fn page_bids_auction_id_is_per_auction_and_gated_on_diagnostics() {
-            async fn winning_auction_id(settings: &Settings) -> Option<String> {
-                let slots = article_slot();
-                let stub = Arc::new(StubHttpClient::new());
-                stub.push_response(200, b"winner".to_vec());
-                let services = build_services_with_http_client(
-                    Arc::clone(&stub) as Arc<dyn crate::platform::PlatformHttpClient>
-                );
-                let orchestrator =
-                    auction_id_test_orchestrator(settings, Arc::new(Mutex::new(None)), true);
-                let ec_context = EcContext::new_for_test(
-                    Some("page-auction-example-123".to_string()),
-                    crate::consent::ConsentContext {
-                        jurisdiction: crate::consent::jurisdiction::Jurisdiction::NonRegulated,
-                        ..Default::default()
-                    },
-                );
-                let response = handle_page_bids(
-                    settings,
-                    &services,
-                    None,
-                    AuctionDispatch {
-                        orchestrator: &orchestrator,
-                        slots: &slots,
-                        registry: None,
-                    },
-                    &ec_context,
-                    make_page_bids_request("/2024/01/my-article/"),
-                )
-                .await
-                .expect("should return page-bids response");
-                let body: serde_json::Value = serde_json::from_slice(
-                    &response
-                        .into_body()
-                        .into_bytes()
-                        .expect("should read page-bids response body"),
-                )
-                .expect("should serialize page-bids response as JSON");
-                body["bids"]["atf"]["hb_auction_id"]
-                    .as_str()
-                    .map(str::to_string)
-            }
-
-            let mut settings = settings_with_co();
-            settings.auction.providers =
-                crate::auction::AuctionConfig::legacy_provider_map(&[AUCTION_ID_TEST_PROVIDER]);
-            settings
-                .integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": true }))
-                .expect("should enable diagnostics");
-
-            let first = winning_auction_id(&settings)
-                .await
-                .expect("first auction should expose a diagnostics token");
-            let second = winning_auction_id(&settings)
-                .await
-                .expect("second auction should expose a diagnostics token");
-            assert_ne!(
-                first, second,
-                "each auction for the same visitor should mint its own token"
-            );
-
-            settings
-                .integrations
-                .insert_config("gpt_diagnostics", &serde_json::json!({ "enabled": false }))
-                .expect("should disable diagnostics");
-            assert_eq!(
-                winning_auction_id(&settings).await,
-                None,
-                "no auction metadata should reach the page without the diagnostics integration"
-            );
-        }
-
-        /// The deprecated `/__ts/page-bids` alias must be handled identically to
-        /// the canonical path — same status, same JSON body.
-        ///
-        /// The alias exists so pre-rename tsjs bundles keep getting ads on SPA
-        /// navigations. If the handler ever varied its output by request path
-        /// (slot matching reads the `path` *query parameter*, not the endpoint
-        /// path), those clients would silently get different results from the
-        /// ones on the canonical route.
-        #[tokio::test]
-        async fn deprecated_alias_response_matches_canonical_path() {
-            let settings = settings_with_co();
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-
-            let canonical = run_page_bids_response(
-                &settings,
-                &orchestrator,
-                &article_slot(),
-                make_page_bids_request_on(PAGE_BIDS_PATH, "/2024/01/my-article/"),
-            )
-            .await;
-            let alias = run_page_bids_response(
-                &settings,
-                &orchestrator,
-                &article_slot(),
-                make_page_bids_request_on(PAGE_BIDS_LEGACY_PATH, "/2024/01/my-article/"),
-            )
-            .await;
-
-            assert_eq!(
-                canonical.status(),
-                alias.status(),
-                "alias must return the same status as the canonical path"
-            );
-            assert_eq!(
-                canonical.into_body().into_bytes(),
-                alias.into_body().into_bytes(),
-                "alias must return the same body as the canonical path"
-            );
-        }
-
-        /// Traffic on the deprecated alias must be measurable from edge access
-        /// logs, not just application logs: the removal precondition in
-        /// IABTechLab/trusted-server#970 is "no remaining traffic on the legacy
-        /// path", and operators who cannot read app logs need a response-side
-        /// marker to count.
-        #[tokio::test]
-        async fn deprecated_alias_response_is_marked_deprecated() {
-            let settings = settings_with_co();
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-
-            let canonical = run_page_bids_response(
-                &settings,
-                &orchestrator,
-                &article_slot(),
-                make_page_bids_request_on(PAGE_BIDS_PATH, "/2024/01/my-article/"),
-            )
-            .await;
-            let alias = run_page_bids_response(
-                &settings,
-                &orchestrator,
-                &article_slot(),
-                make_page_bids_request_on(PAGE_BIDS_LEGACY_PATH, "/2024/01/my-article/"),
-            )
-            .await;
-
-            assert_eq!(
-                alias
-                    .headers()
-                    .get(header::LINK)
-                    .and_then(|value| value.to_str().ok()),
-                Some(
-                    "<https://github.com/IABTechLab/trusted-server/issues/970>; rel=\"deprecation\""
-                ),
-                "alias response should carry the RFC 9745 deprecation link relation"
-            );
-            assert!(
-                !canonical.headers().contains_key(header::LINK),
-                "canonical path should not be marked deprecated"
-            );
-        }
-
-        /// A deployment without creative opportunities answers page-bids with a
-        /// 404, but its alias traffic still has to be counted — otherwise a
-        /// silent legacy signal on such a config reads as "no remaining
-        /// traffic" when evaluating IABTechLab/trusted-server#970.
-        #[tokio::test]
-        async fn deprecated_alias_is_marked_without_creative_opportunities() {
-            let settings = settings_without_co();
-            assert!(
-                settings.creative_opportunities.is_none(),
-                "test settings should have no creative opportunities configured"
-            );
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-
-            let response = run_page_bids_response(
-                &settings,
-                &orchestrator,
-                &[],
-                make_page_bids_request_on(PAGE_BIDS_LEGACY_PATH, "/2024/01/my-article/"),
-            )
-            .await;
-
-            assert_eq!(
-                response.status(),
-                StatusCode::NOT_FOUND,
-                "should 404 when creative opportunities are not configured"
-            );
-            assert!(
-                response.headers().contains_key(header::LINK),
-                "alias 404 should still be marked deprecated so it is countable"
-            );
-        }
-
         /// The cross-site gate runs before the not-configured 404, so a
         /// cross-site caller cannot probe whether a deployment has creative
         /// opportunities configured.
@@ -20064,35 +14197,43 @@ mod tests {
         }
 
         #[tokio::test]
-        async fn empty_slots_file_returns_empty_slots_and_bids() {
-            // Spec §8 kill-switch: creative-opportunities.toml with zero slots disables
-            // all server-side auction activity and injection.
+        async fn empty_slots_file_returns_an_exact_empty_projection() {
+            // An enabled configuration with no matching definitions has no work.
             let settings = settings_with_co();
             let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
             let req = make_page_bids_request("/2024/01/my-article/");
 
             let body = run_page_bids(&settings, &orchestrator, &[], req).await;
 
+            assert_eq!(body["version"], 1);
+            assert_eq!(body["auction"]["version"], 1);
+            assert_eq!(body["auction"]["results"], serde_json::json!([]));
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                0,
-                "empty slots should produce zero injected slots"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "empty slots should produce zero bids"
             );
+            assert_eq!(body["slots"], serde_json::json!([]));
+        }
+
+        #[tokio::test]
+        async fn disabled_creative_opportunities_return_an_exact_empty_projection() {
+            let settings = settings_with_co_disabled();
+            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
+            let slots = article_slot();
+            let req = make_page_bids_request("/2024/01/my-article/");
+
+            let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
+
+            assert_eq!(body["version"], 1);
+            assert_eq!(body["auction"]["version"], 1);
+            assert_eq!(body["auction"]["results"], serde_json::json!([]));
+            assert_eq!(body["slots"], serde_json::json!([]));
+            assert_eq!(body["bids"], serde_json::json!([]));
         }
 
         #[tokio::test]
-        async fn bot_user_agent_returns_slots_but_no_bids() {
+        async fn bot_user_agent_returns_a_terminal_projection_without_bids() {
             // Crawlers should get slot definitions (so HTML structure is unchanged)
             // but the server must not burn SSP request quota running a real auction
             // for them. Same gate the publisher path applies.
@@ -20109,25 +14250,22 @@ mod tests {
             let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
 
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                1,
-                "bot request should still get slot definitions"
+                body["auction"]["results"][0],
+                serde_json::json!({
+                    "slot": "atf",
+                    "outcome": "failed",
+                    "reason": "slot_not_eligible"
+                })
             );
             assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "bot request must not run an auction (no SSP cost burned for crawlers)"
             );
         }
 
         #[tokio::test]
-        async fn prefetch_request_returns_slots_but_no_bids() {
+        async fn prefetch_request_returns_a_terminal_projection_without_bids() {
             // Navigations triggered by Sec-Purpose=prefetch should not fire real
             // SSP auctions — the user has not yet visited the page.
             let settings = settings_with_co();
@@ -20138,19 +14276,9 @@ mod tests {
 
             let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
 
+            assert_eq!(body["auction"]["results"][0]["reason"], "slot_not_eligible");
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                1,
-                "prefetch request should still get slot definitions"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "prefetch request must not run an auction"
             );
@@ -20183,7 +14311,9 @@ mod tests {
             set_test_header(&mut req, "sec-purpose", "prefetch");
 
             let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
-            let returned_slots = body["slots"].as_array().expect("slots should be array");
+            let returned_slots = body["auction"]["results"]
+                .as_array()
+                .expect("results should be array");
 
             assert_eq!(
                 returned_slots.len(),
@@ -20191,7 +14321,7 @@ mod tests {
                 "should omit only the over-limit dynamic slot"
             );
             assert_eq!(
-                returned_slots[0]["id"], "valid_static_sibling",
+                returned_slots[0]["slot"], "valid_static_sibling",
                 "should retain the valid static sibling"
             );
         }
@@ -20206,19 +14336,9 @@ mod tests {
 
             let body = run_page_bids(&settings, &orchestrator, &slots, req).await;
 
+            assert_eq!(body["auction"]["results"], serde_json::json!([]));
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                0,
-                "non-matching URL should produce zero injected slots"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "non-matching URL should produce zero bids"
             );
@@ -20254,13 +14374,12 @@ mod tests {
         }
 
         #[tokio::test]
-        async fn disabled_auction_returns_no_slots_or_bids() {
+        async fn disabled_auction_returns_exact_failed_decisions() {
             // [auction].enabled = false is a global kill switch: it must disable
             // the entire server-side ad stack, not just SSP calls. Returning slot
-            // definitions would let the SPA hook assign `ts.adSlots` and call
-            // `adInit()`, creating/refreshing GPT slots client-side even though
-            // the auction is off. Consent is allowed here so the test isolates
-            // the kill switch.
+            // definitions would let the hard-cutover browser runtime create or
+            // refresh GPT slots even though the auction is off. Consent is
+            // allowed here so the test isolates the kill switch.
             let settings = settings_with_co_auction_disabled();
             let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
             let slots = article_slot();
@@ -20268,59 +14387,20 @@ mod tests {
 
             let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
 
+            assert_eq!(body["auction"]["results"][0]["reason"], "auction_disabled");
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                0,
-                "disabled auction must not return slot definitions (kill switch stops the ad stack)"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "disabled auction must not produce bids"
             );
         }
 
         #[tokio::test]
-        async fn disabled_server_side_ad_templates_return_no_slots_or_bids() {
-            // The dedicated template switch must suppress publisher/page-bids
-            // delivery without using the global auction switch.
-            let settings = settings_with_co_templates_disabled();
-            let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
-            let slots = article_slot();
-            let req = make_page_bids_request("/2024/01/my-article/");
-
-            let body = run_page_bids_consent_allowed(&settings, &orchestrator, &slots, req).await;
-
-            assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                0,
-                "disabled server-side ad templates must not return slot definitions"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
-                0,
-                "disabled server-side ad templates must not produce bids"
-            );
-        }
-
-        #[tokio::test]
-        async fn consent_denied_returns_no_slots_or_bids() {
+        async fn consent_denied_returns_exact_failed_decisions() {
             // When consent denies the server-side auction (here: Jurisdiction
             // Unknown fails closed), the endpoint must return no slots so the SPA
             // hook does not create GPT slots client-side — matching the publisher
-            // navigation path's shared `evaluate_ad_stack_gate` gate.
+            // navigation path's `should_run_server_side_ad_stack` gate.
             let settings = settings_with_co();
             let orchestrator = AuctionOrchestrator::new(settings.auction.clone());
             let slots = article_slot();
@@ -20330,19 +14410,9 @@ mod tests {
             // Jurisdiction::Unknown (consent denied).
             let body = run_page_bids(&settings, &orchestrator, &slots, req).await;
 
+            assert_eq!(body["auction"]["results"][0]["reason"], "consent_denied");
             assert_eq!(
-                body["slots"]
-                    .as_array()
-                    .expect("slots should be array")
-                    .len(),
-                0,
-                "consent denial must suppress slot definitions"
-            );
-            assert_eq!(
-                body["bids"]
-                    .as_object()
-                    .expect("bids should be object")
-                    .len(),
+                body["bids"].as_array().expect("bids should be array").len(),
                 0,
                 "consent denial must produce no bids"
             );
@@ -20482,8 +14552,9 @@ mod tests {
 
         fn settings_with_capturing_provider() -> Settings {
             let toml = format!(
-                "{}\n[auction]\nenabled = true\n\n[auction.providers.{CAPTURING_PROVIDER}]\nprotocol = \"openrtb-2.6\"\nendpoint = \"https://capture.example/openrtb2/auction\"\nrouting = \"all_eligible\"\n\n\
-                 [creative_opportunities]\ngam_network_id = \"12345\"\n",
+                "{}\n[auction]\nenabled = true\n\n\
+                 [auction.providers.{CAPTURING_PROVIDER}]\nprotocol = \"openrtb-2.6\"\nprofile = \"standard\"\nendpoint = \"https://capture.example/bid\"\nrouting = \"all_eligible\"\n\n\
+                 [creative_opportunities]\nenabled = true\ngam_network_id = \"12345\"\n",
                 crate_test_settings_str()
             );
             Settings::from_toml(&toml).expect("should parse settings with a capturing provider")
diff --git a/crates/trusted-server-core/src/settings.rs b/crates/trusted-server-core/src/settings.rs
index 8fff7917d..c0902cd1b 100644
--- a/crates/trusted-server-core/src/settings.rs
+++ b/crates/trusted-server-core/src/settings.rs
@@ -2524,11 +2524,9 @@ pub struct DebugConfig {
     /// Content and verbosity of the `auction_html_comment` dump. Ignored
     /// when `auction_html_comment` is false.
     ///
-    /// The default table must stay omitted from serialized config blobs:
-    /// [`DebugConfig`] denies unknown fields, so an older binary rejects a blob
-    /// carrying this table during a mixed-version deployment or rollback. Any
-    /// non-default table still serializes and requires restoring a compatible
-    /// blob before rolling back.
+    /// The default table stays omitted from serialized config blobs to avoid
+    /// emitting redundant configuration. Any non-default table still
+    /// serializes.
     #[serde(
         default,
         skip_serializing_if = "is_default_auction_debug_comment_options"
@@ -2548,6 +2546,10 @@ pub struct DebugConfig {
     /// un-sanitized creative for diagnostics, so never enable in production.
     #[serde(default)]
     pub inject_adm_for_testing: bool,
+
+    /// Enable the host-only render-trace debug cookie route at `GET /_ts/trace`.
+    #[serde(default)]
+    pub trace_route_enabled: bool,
 }
 
 /// Metadata keys safe to surface in the `ts-debug` auction comment.
@@ -2560,7 +2562,7 @@ pub struct DebugConfig {
 /// `metadata_keys` is a subset selector against this const, never a way to
 /// add new keys.
 pub(crate) const AUCTION_DEBUG_METADATA_ALLOWLIST: &[&str] =
-    &["error_type", "http_status", "message"];
+    &["drop_reasons", "error_type", "http_status", "message"];
 
 /// Provider-controlled diagnostic keys exposed only by `Upstream` or `Full`.
 ///
@@ -2587,7 +2589,7 @@ fn default_auction_debug_metadata_keys() -> Vec<String> {
         .collect()
 }
 
-// This predicate preserves rollback compatibility by omitting the default table.
+// Omit the default table from serialized configuration.
 fn is_default_auction_debug_comment_options(value: &AuctionDebugCommentOptions) -> bool {
     *value == AuctionDebugCommentOptions::default()
 }
@@ -2981,6 +2983,12 @@ impl Settings {
         settings.validate_admin_coverage()?;
         settings.validate_admin_handler_passwords()?;
 
+        for pattern in settings.reserved_aps_handler_patterns()? {
+            log::warn!(
+                "Basic Auth handler `{pattern}` matches the reserved /integrations/aps route family; reserved APS renderer and live-runner requests bypass configured handlers"
+            );
+        }
+
         if settings.auction.enabled && !settings.auction.rewrite_creatives {
             log::warn!(
                 "Auction creative rewriting disabled; creative assets and clicks may contact third-party hosts directly"
@@ -3047,14 +3055,13 @@ impl Settings {
         Ok(())
     }
 
-    /// Returns compiled creative opportunity slots when template delivery is enabled.
+    /// Returns compiled creative opportunity slots.
     #[must_use]
     pub fn creative_opportunity_slots(
         &self,
     ) -> &[crate::creative_opportunities::CreativeOpportunitySlot] {
         self.creative_opportunities
             .as_ref()
-            .filter(|co| co.enabled)
             .map(|co| co.slot.as_slice())
             .unwrap_or(&[])
     }
@@ -3192,6 +3199,39 @@ impl Settings {
         Ok(None)
     }
 
+    /// Return handler patterns that match a representative reserved APS path.
+    ///
+    /// Reserved APS resources are dispatched before configured Basic Auth
+    /// handlers. This startup-only check makes that precedence visible without
+    /// attempting undecidable general regex-intersection analysis.
+    ///
+    /// # Errors
+    ///
+    /// Returns a configuration error if a handler regex does not compile.
+    pub(crate) fn reserved_aps_handler_patterns(
+        &self,
+    ) -> Result<Vec<&str>, Report<TrustedServerError>> {
+        const REPRESENTATIVE_PATHS: &[&str] = &[
+            "/integrations/aps",
+            "/integrations/aps/renderer/v2",
+            "/integrations/aps/runner.js",
+        ];
+        let mut patterns = Vec::new();
+        for handler in &self.handlers {
+            let mut overlaps = false;
+            for path in REPRESENTATIVE_PATHS {
+                if handler.matches_path(path)? {
+                    overlaps = true;
+                    break;
+                }
+            }
+            if overlaps {
+                patterns.push(handler.path.as_str());
+            }
+        }
+        Ok(patterns)
+    }
+
     /// Returns whether `path` is within the reserved Trusted Server admin
     /// namespace.
     #[must_use]
@@ -4215,6 +4255,7 @@ mod tests {
         assert_eq!(
             opts.metadata_keys,
             vec![
+                "drop_reasons".to_string(),
                 "error_type".to_string(),
                 "http_status".to_string(),
                 "message".to_string(),
@@ -4330,20 +4371,6 @@ mod tests {
 
     #[test]
     fn default_auction_debug_comment_options_stay_out_of_serialized_config() {
-        // Rollback contract: `DebugConfig` denies unknown fields, so the
-        // previous binary rejects a config blob carrying a table it does not
-        // know. Defaults must therefore serialize to nothing.
-        #[derive(Deserialize)]
-        #[serde(deny_unknown_fields)]
-        struct LegacyDebugConfig {
-            #[serde(default)]
-            ja4_endpoint_enabled: bool,
-            #[serde(default)]
-            auction_html_comment: bool,
-            #[serde(default)]
-            inject_adm_for_testing: bool,
-        }
-
         let value = serde_json::to_value(DebugConfig::default())
             .expect("should serialize the default debug config");
         assert!(
@@ -4351,12 +4378,6 @@ mod tests {
             "default options table should not be serialized, got {value}"
         );
 
-        let legacy: LegacyDebugConfig = serde_json::from_value(value)
-            .expect("legacy schema should accept the default debug payload");
-        assert!(!legacy.ja4_endpoint_enabled);
-        assert!(!legacy.auction_html_comment);
-        assert!(!legacy.inject_adm_for_testing);
-
         let configured = DebugConfig {
             auction_html_comment: true,
             auction_html_comment_options: AuctionDebugCommentOptions {
@@ -4482,6 +4503,23 @@ mod tests {
         settings.validate().expect("Failed to validate settings");
     }
 
+    #[test]
+    fn settings_identifies_handlers_shadowed_by_reserved_aps_routes() {
+        let toml = format!(
+            "{}\n[[handlers]]\npath = \"^/integrations/aps\"\nusername = \"aps-user\"\npassword = \"aps-pass\"\n",
+            crate_test_settings_str()
+        );
+
+        let settings = Settings::from_toml(&toml).expect("should parse APS-overlapping handler");
+
+        assert_eq!(
+            settings
+                .reserved_aps_handler_patterns()
+                .expect("should inspect compiled handler patterns"),
+            vec!["^/integrations/aps"]
+        );
+    }
+
     #[test]
     fn tester_cookie_enabled_parses_from_toml() {
         let toml_str = format!(
@@ -7408,6 +7446,7 @@ proxy_secret = "secret"
 passphrase = "test-secret-key-32-bytes-minimum"
 
 [creative_opportunities]
+enabled = true
 gam_network_id = "21765378893"
 auction_timeout_ms = 500
 section_root = "home"
@@ -7422,10 +7461,6 @@ formats = [{ width = 300, height = 250 }]
         let co = settings
             .creative_opportunities
             .expect("should have creative_opportunities");
-        assert!(
-            co.enabled,
-            "creative-opportunity templates should default to enabled"
-        );
         assert_eq!(co.gam_network_id, "21765378893");
         assert_eq!(co.auction_timeout_ms, Some(500));
         assert_eq!(
@@ -7435,45 +7470,6 @@ formats = [{ width = 300, height = 250 }]
         );
     }
 
-    #[test]
-    fn settings_disables_creative_opportunity_slots_when_configured_off() {
-        let toml = format!(
-            "{}\n[creative_opportunities]\nenabled = false\ngam_network_id = \"21765378893\"\n\n[[creative_opportunities.slot]]\nid = \"atf\"\npage_patterns = [\"/\"]\nformats = [{{ width = 300, height = 250 }}]\n",
-            crate_test_settings_str()
-        );
-        let settings = Settings::from_toml(&toml).expect("should parse disabled templates");
-        assert!(
-            settings.creative_opportunity_slots().is_empty(),
-            "disabled template delivery should expose no runtime slots"
-        );
-    }
-
-    #[test]
-    fn settings_creative_opportunity_enabled_flag_supports_environment_override() {
-        let toml = format!(
-            "{}\n[creative_opportunities]\nenabled = true\ngam_network_id = \"21765378893\"\n",
-            crate_test_settings_str()
-        );
-        let env_key = format!(
-            "{}{}CREATIVE_OPPORTUNITIES{}ENABLED",
-            ENVIRONMENT_VARIABLE_PREFIX,
-            ENVIRONMENT_VARIABLE_SEPARATOR,
-            ENVIRONMENT_VARIABLE_SEPARATOR
-        );
-
-        temp_env::with_var(env_key, Some("false"), || {
-            let settings = Settings::from_toml_and_env(&toml)
-                .expect("should parse template enabled environment override");
-            assert!(
-                !settings
-                    .creative_opportunities
-                    .expect("should have creative opportunities")
-                    .enabled,
-                "environment override should disable template delivery"
-            );
-        });
-    }
-
     #[test]
     fn settings_rejects_invalid_creative_opportunity_slot_id() {
         let toml = r#"
@@ -7492,6 +7488,7 @@ proxy_secret = "secret"
 passphrase = "test-secret-key-32-bytes-minimum"
 
 [creative_opportunities]
+enabled = true
 gam_network_id = "21765378893"
 
 [[creative_opportunities.slot]]
@@ -7528,6 +7525,7 @@ proxy_secret = "secret"
 passphrase = "test-secret-key-32-bytes-minimum"
 
 [creative_opportunities]
+enabled = true
 gam_network_id = "21765378893"
 "#;
         let slot_key = format!(
@@ -7570,6 +7568,7 @@ proxy_secret = "secret"
 passphrase = "test-secret-key-32-bytes-minimum"
 
 [creative_opportunities]
+enabled = true
 gam_network_id = "21765378893"
 
 [[creative_opportunities.slot]]
diff --git a/crates/trusted-server-core/src/test_support.rs b/crates/trusted-server-core/src/test_support.rs
index 89f73534d..d6a4ec8db 100644
--- a/crates/trusted-server-core/src/test_support.rs
+++ b/crates/trusted-server-core/src/test_support.rs
@@ -1,6 +1,24 @@
 #[cfg(test)]
 pub mod tests {
     use crate::settings::Settings;
+    use serde::Deserialize as _;
+
+    /// Decode the one server-sealed lexical TSJS boot transport from generated HTML.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the script omits the sealed transport or contains invalid JSON.
+    #[must_use]
+    pub fn bootstrap_transport(script: &str) -> serde_json::Value {
+        let encoded = script
+            .split_once("const __TSJS_SERVER_BOOT_TRANSPORT_V1__=")
+            .expect("bootstrap should contain the sealed transport")
+            .1;
+        let mut deserializer = serde_json::Deserializer::from_str(encoded);
+        let decoded = String::deserialize(&mut deserializer)
+            .expect("transport should be one JSON string literal");
+        serde_json::from_str(&decoded).expect("decoded transport should be exact JSON")
+    }
 
     #[must_use]
     pub fn crate_test_settings_str() -> String {
diff --git a/crates/trusted-server-core/src/trace_cookie.rs b/crates/trusted-server-core/src/trace_cookie.rs
new file mode 100644
index 000000000..5cdf171b4
--- /dev/null
+++ b/crates/trusted-server-core/src/trace_cookie.rs
@@ -0,0 +1,276 @@
+//! Render-trace toggle endpoint helpers.
+//!
+//! `GET /_ts/trace` arms (or with `?enabled=false` disarms) the first-party
+//! `ts-trace` cookie and redirects to `/`. While the cookie is present, the
+//! TSJS render-trace layer draws a visible badge on every traced creative so
+//! an operator can see on the page itself that a creative was delivered by
+//! Trusted Server — and via which render path (SSAT/GAM or `/auction`).
+//!
+//! The route is gated behind `[debug] trace_route_enabled` and returns
+//! `404 Not Found` while disabled, mirroring the tester-cookie endpoints. The
+//! badge only surfaces data already exposed on `window.tsjs`, so the cookie
+//! gates visibility, not access.
+
+use edgezero_core::body::Body as EdgeBody;
+use error_stack::{Report, ResultExt};
+use http::{HeaderValue, Request, Response, StatusCode, header};
+
+use crate::constants::COOKIE_TS_TRACE;
+use crate::error::TrustedServerError;
+use crate::settings::Settings;
+
+/// How long an armed trace cookie lives, in seconds.
+///
+/// One hour: long enough for a debugging session across reloads and SPA
+/// navigations, short enough that a forgotten toggle expires on its own.
+const TRACE_COOKIE_MAX_AGE_SECS: u32 = 3600;
+
+/// Resolve the server-owned render-trace overlay bit for `DiagnosticsBootV1`.
+///
+/// Only the exact cookie emitted by [`handle_trace_mode`] activates the overlay.
+/// Duplicate reserved cookies fail closed so request header ordering cannot
+/// choose the browser-visible diagnostics state.
+#[must_use]
+pub fn render_trace_overlay_active(request: &Request<EdgeBody>) -> bool {
+    let mut occurrences = 0_usize;
+    let mut active = false;
+    for value in request.headers().get_all(header::COOKIE) {
+        let Ok(value) = value.to_str() else {
+            return false;
+        };
+        for cookie in value.split(';').map(str::trim) {
+            let Some((name, value)) = cookie.split_once('=') else {
+                continue;
+            };
+            if name == COOKIE_TS_TRACE {
+                occurrences += 1;
+                active = value == "1";
+            }
+        }
+    }
+    occurrences == 1 && active
+}
+
+/// Formats the trace cookie `Set-Cookie` header value.
+///
+/// Deliberately host-only (no `Domain` attribute): a `Domain` scoped to
+/// `publisher.cookie_domain` would be rejected by the browser during local
+/// development against `127.0.0.1`/`localhost`, and the overlay only needs to
+/// work on the exact host being debugged. Also neither `HttpOnly` (the TSJS
+/// overlay must read it from `document.cookie`) nor `Secure` (the badge is a
+/// debug aid that must work through plain-HTTP local dev proxies, and the
+/// cookie carries no data worth protecting).
+fn format_trace_cookie() -> String {
+    format!(
+        "{}=1; Path=/; SameSite=Lax; Max-Age={}",
+        COOKIE_TS_TRACE, TRACE_COOKIE_MAX_AGE_SECS,
+    )
+}
+
+/// Formats the trace cookie clearing `Set-Cookie` header value.
+fn format_clear_trace_cookie() -> String {
+    format!("{}=; Path=/; SameSite=Lax; Max-Age=0", COOKIE_TS_TRACE)
+}
+
+/// Whether the request's query string asks to disarm the trace cookie.
+///
+/// Only an explicit `enabled=false` (or `enabled=0`) disarms; any other query
+/// — including none at all — arms it, so `GET /_ts/trace` alone switches the
+/// overlay on.
+fn query_disables(query: Option<&str>) -> bool {
+    query.is_some_and(|q| {
+        q.split('&')
+            .any(|pair| pair == "enabled=false" || pair == "enabled=0")
+    })
+}
+
+/// Handles `GET /_ts/trace`.
+///
+/// Returns `404 Not Found` while `[debug] trace_route_enabled` is false. When
+/// enabled, sets (or with `?enabled=false` clears) the `ts-trace` cookie
+/// as a host-only cookie with no `Domain` attribute and returns `302 Found`
+/// redirecting to `/` — landing back on the homepage confirms the toggle
+/// round-trip worked.
+///
+/// # Errors
+///
+/// Returns [`TrustedServerError::InvalidHeaderValue`] if the fixed host-only cookie
+/// value cannot be rendered as an HTTP header value.
+pub fn handle_trace_mode(
+    settings: &Settings,
+    query: Option<&str>,
+) -> Result<Response<EdgeBody>, Report<TrustedServerError>> {
+    if !settings.debug.trace_route_enabled {
+        let mut response = Response::new(EdgeBody::empty());
+        *response.status_mut() = StatusCode::NOT_FOUND;
+        return Ok(response);
+    }
+
+    let cookie_value = if query_disables(query) {
+        format_clear_trace_cookie()
+    } else {
+        format_trace_cookie()
+    };
+    let set_cookie = HeaderValue::from_str(&cookie_value).change_context(
+        TrustedServerError::InvalidHeaderValue {
+            message: "trace cookie contains invalid header value".to_string(),
+        },
+    )?;
+
+    let mut response = Response::new(EdgeBody::empty());
+    *response.status_mut() = StatusCode::FOUND;
+    response
+        .headers_mut()
+        .insert(header::LOCATION, HeaderValue::from_static("/"));
+    response.headers_mut().insert(
+        header::CACHE_CONTROL,
+        HeaderValue::from_static("no-store, private"),
+    );
+    response
+        .headers_mut()
+        .insert(header::SET_COOKIE, set_cookie);
+    Ok(response)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_support::tests::create_test_settings;
+    use http::{Request, header};
+
+    fn trace_enabled_settings() -> Settings {
+        let mut settings = create_test_settings();
+        settings.debug.trace_route_enabled = true;
+        settings
+    }
+
+    #[test]
+    fn trace_route_arms_cookie_and_redirects_to_root() {
+        let settings = trace_enabled_settings();
+
+        let response = handle_trace_mode(&settings, None).expect("should build trace response");
+
+        assert_eq!(
+            response.status(),
+            StatusCode::FOUND,
+            "enabled trace route should redirect"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get(header::LOCATION)
+                .and_then(|v| v.to_str().ok()),
+            Some("/"),
+            "should redirect to the site root"
+        );
+        assert_eq!(
+            response
+                .headers()
+                .get(header::CACHE_CONTROL)
+                .and_then(|v| v.to_str().ok()),
+            Some("no-store, private"),
+            "trace route should not be cacheable"
+        );
+        let set_cookie = response
+            .headers()
+            .get(header::SET_COOKIE)
+            .expect("should set trace cookie")
+            .to_str()
+            .expect("should render set-cookie as utf-8");
+        assert_eq!(
+            set_cookie, "ts-trace=1; Path=/; SameSite=Lax; Max-Age=3600",
+            "trace cookie should be host-only with a bounded lifetime"
+        );
+    }
+
+    #[test]
+    fn trace_route_clears_cookie_when_disabled_by_query() {
+        let settings = trace_enabled_settings();
+
+        let response = handle_trace_mode(&settings, Some("enabled=false"))
+            .expect("should build trace clear response");
+
+        assert_eq!(
+            response.status(),
+            StatusCode::FOUND,
+            "clearing should still redirect"
+        );
+        let set_cookie = response
+            .headers()
+            .get(header::SET_COOKIE)
+            .expect("should clear trace cookie")
+            .to_str()
+            .expect("should render set-cookie as utf-8");
+        assert_eq!(
+            set_cookie, "ts-trace=; Path=/; SameSite=Lax; Max-Age=0",
+            "trace cookie clear should expire the cookie"
+        );
+    }
+
+    #[test]
+    fn trace_route_arms_cookie_for_unrelated_query() {
+        let settings = trace_enabled_settings();
+
+        let response = handle_trace_mode(&settings, Some("enabled=true&foo=bar"))
+            .expect("should build trace response");
+
+        let set_cookie = response
+            .headers()
+            .get(header::SET_COOKIE)
+            .expect("should set trace cookie")
+            .to_str()
+            .expect("should render set-cookie as utf-8");
+        assert!(
+            set_cookie.starts_with("ts-trace=1;"),
+            "non-disabling query should arm the cookie"
+        );
+    }
+
+    #[test]
+    fn trace_route_is_disabled_by_default() {
+        let settings = create_test_settings();
+
+        let response =
+            handle_trace_mode(&settings, None).expect("should build disabled trace response");
+
+        assert_eq!(
+            response.status(),
+            StatusCode::NOT_FOUND,
+            "disabled trace route should return not found"
+        );
+        assert!(
+            response.headers().get(header::SET_COOKIE).is_none(),
+            "disabled trace route should not set a cookie"
+        );
+    }
+
+    #[test]
+    fn trace_cookie_boot_resolver_accepts_only_one_exact_server_cookie() {
+        for (cookie, expected) in [
+            (None, false),
+            (Some("ts-trace=1"), true),
+            (Some("other=value; ts-trace=1"), true),
+            (Some("ts-trace=0"), false),
+            (Some("ts-trace=true"), false),
+            (Some("ts-trace =1"), false),
+            (Some("ts-trace= 1"), false),
+            (Some("ts-trace=1; ts-trace=1"), false),
+        ] {
+            let mut builder = Request::builder()
+                .method("GET")
+                .uri("https://publisher.example/article");
+            if let Some(cookie) = cookie {
+                builder = builder.header(header::COOKIE, cookie);
+            }
+            let request = builder
+                .body(EdgeBody::empty())
+                .expect("should build trace-cookie request");
+
+            assert_eq!(
+                render_trace_overlay_active(&request),
+                expected,
+                "unexpected boot resolution for {cookie:?}"
+            );
+        }
+    }
+}
diff --git a/crates/trusted-server-core/src/tsjs.rs b/crates/trusted-server-core/src/tsjs.rs
index e8275b814..01e16cc58 100644
--- a/crates/trusted-server-core/src/tsjs.rs
+++ b/crates/trusted-server-core/src/tsjs.rs
@@ -1,4 +1,1133 @@
-use trusted_server_js::{concatenated_hash, single_module_hash};
+use std::collections::HashSet;
+use std::fmt;
+use std::sync::OnceLock;
+
+use error_stack::Report;
+use serde::de::{MapAccess, SeqAccess, Visitor};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest as _, Sha256};
+use trusted_server_js::{
+    TsjsModulePhase, all_integration_metadata, concatenated_hash, release_id, single_module_hash,
+};
+use validator::Validate;
+
+use crate::auction::types::{
+    BidRenderSourceV1, BrowserAuctionProjectionV1, MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+    SlotAuctionDecisionV1,
+};
+use crate::error::TrustedServerError;
+use crate::settings::{IntegrationConfig, Settings};
+
+/// Canonical empty initial auction projection used when no auction ran or a
+/// projection fails closed.
+pub(crate) const EMPTY_AUCTION_PROJECTION_JSON_V1: &str = r#"{"version":1,"auction":{"version":1,"auctionId":"initial","results":[]},"slots":[],"bids":[]}"#;
+
+pub(crate) const INTEGRATION_CONFIG_IDS_V1: [&str; 11] = [
+    "aps",
+    "datadome",
+    "didomi",
+    "google_tag_manager",
+    "gpt",
+    "lockr",
+    "osano",
+    "permutive",
+    "prebid",
+    "sourcepoint",
+    "testlight",
+];
+pub(crate) const INTEGRATION_CONFIG_MAX_DEPTH_V1: usize = 16;
+pub(crate) const INTEGRATION_CONFIG_MAX_VALUES_V1: usize = 4_096;
+pub(crate) const INTEGRATION_CONFIG_MAX_STRING_BYTES_V1: usize = 4_096;
+pub(crate) const INTEGRATION_CONFIG_MAX_ENTRY_BYTES_V1: usize = 65_536;
+const INTEGRATION_CONFIG_MAX_CARRIER_BYTES_V1: usize = 524_288;
+const SERVER_BOOT_TRANSPORT_MAX_BYTES_V1: usize = 10 * 1024 * 1024;
+
+#[derive(Debug)]
+enum EcmascriptJsonValue {
+    Null,
+    Bool(bool),
+    Number(f64),
+    String(String),
+    Array(Vec<Self>),
+    Object(Vec<(String, Self)>),
+}
+
+struct EcmascriptJsonVisitor;
+
+impl<'de> Visitor<'de> for EcmascriptJsonVisitor {
+    type Value = EcmascriptJsonValue;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a finite JSON value")
+    }
+
+    fn visit_unit<E>(self) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::Null)
+    }
+
+    fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::Bool(value))
+    }
+
+    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::Number(value as f64))
+    }
+
+    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::Number(value as f64))
+    }
+
+    fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        if !value.is_finite() {
+            return Err(E::custom("JSON number must be finite"));
+        }
+        Ok(EcmascriptJsonValue::Number(value))
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::String(value.to_owned()))
+    }
+
+    fn visit_string<E>(self, value: String) -> Result<Self::Value, E> {
+        Ok(EcmascriptJsonValue::String(value))
+    }
+
+    fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut values = Vec::with_capacity(sequence.size_hint().unwrap_or(0));
+        while let Some(value) = sequence.next_element()? {
+            values.push(value);
+        }
+        Ok(EcmascriptJsonValue::Array(values))
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let mut values = Vec::with_capacity(map.size_hint().unwrap_or(0));
+        let mut keys = HashSet::new();
+        while let Some((key, value)) = map.next_entry::<String, EcmascriptJsonValue>()? {
+            if !keys.insert(key.clone()) {
+                return Err(serde::de::Error::custom("duplicate JSON object key"));
+            }
+            values.push((key, value));
+        }
+        Ok(EcmascriptJsonValue::Object(values))
+    }
+}
+
+impl<'de> Deserialize<'de> for EcmascriptJsonValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(EcmascriptJsonVisitor)
+    }
+}
+
+fn ecmascript_number_string(value: f64) -> Option<String> {
+    if !value.is_finite() {
+        return None;
+    }
+    if value == 0.0 {
+        return Some("0".to_owned());
+    }
+    let negative = value.is_sign_negative();
+    let raw = serde_json::to_string(&value.abs()).ok()?;
+    let (mantissa, exponent) = raw
+        .split_once(['e', 'E'])
+        .map_or((raw.as_str(), 0), |(mantissa, exponent)| {
+            (mantissa, exponent.parse::<i32>().ok().unwrap_or(i32::MAX))
+        });
+    if exponent == i32::MAX {
+        return None;
+    }
+    let point = mantissa.find('.').unwrap_or(mantissa.len());
+    let mut digits = mantissa
+        .bytes()
+        .filter(|byte| *byte != b'.')
+        .map(char::from)
+        .collect::<String>();
+    let mut decimal_position = i32::try_from(point).ok()?.checked_add(exponent)?;
+    while digits.len() > 1 && digits.starts_with('0') {
+        digits.remove(0);
+        decimal_position = decimal_position.checked_sub(1)?;
+    }
+    while digits.len() > 1 && digits.ends_with('0') {
+        digits.pop();
+    }
+    let digit_count = i32::try_from(digits.len()).ok()?;
+    let mut output = String::new();
+    if negative {
+        output.push('-');
+    }
+    if digit_count <= decimal_position && decimal_position <= 21 {
+        output.push_str(&digits);
+        output.extend(std::iter::repeat_n(
+            '0',
+            usize::try_from(decimal_position - digit_count).ok()?,
+        ));
+    } else if decimal_position > 0 && decimal_position <= 21 {
+        let split = usize::try_from(decimal_position).ok()?;
+        output.push_str(&digits[..split]);
+        output.push('.');
+        output.push_str(&digits[split..]);
+    } else if decimal_position > -6 && decimal_position <= 0 {
+        output.push_str("0.");
+        output.extend(std::iter::repeat_n(
+            '0',
+            usize::try_from(-decimal_position).ok()?,
+        ));
+        output.push_str(&digits);
+    } else {
+        output.push_str(&digits[..1]);
+        if digits.len() > 1 {
+            output.push('.');
+            output.push_str(&digits[1..]);
+        }
+        output.push('e');
+        let scientific_exponent = decimal_position.checked_sub(1)?;
+        if scientific_exponent >= 0 {
+            output.push('+');
+        }
+        output.push_str(&scientific_exponent.to_string());
+    }
+    Some(output)
+}
+
+fn ecmascript_array_index(key: &str) -> Option<u32> {
+    if key.is_empty() || (key.len() > 1 && key.starts_with('0')) {
+        return None;
+    }
+    let value = key.parse::<u32>().ok()?;
+    (value < u32::MAX && value.to_string() == key).then_some(value)
+}
+
+fn write_ecmascript_json(value: &EcmascriptJsonValue, output: &mut String) -> Option<()> {
+    match value {
+        EcmascriptJsonValue::Null => output.push_str("null"),
+        EcmascriptJsonValue::Bool(value) => output.push_str(if *value { "true" } else { "false" }),
+        EcmascriptJsonValue::Number(value) => output.push_str(&ecmascript_number_string(*value)?),
+        EcmascriptJsonValue::String(value) => {
+            output.push_str(&serde_json::to_string(value).ok()?);
+        }
+        EcmascriptJsonValue::Array(values) => {
+            output.push('[');
+            for (index, value) in values.iter().enumerate() {
+                if index != 0 {
+                    output.push(',');
+                }
+                write_ecmascript_json(value, output)?;
+            }
+            output.push(']');
+        }
+        EcmascriptJsonValue::Object(values) => {
+            let mut indexed = values
+                .iter()
+                .filter_map(|(key, value)| {
+                    ecmascript_array_index(key).map(|index| (index, key, value))
+                })
+                .collect::<Vec<_>>();
+            indexed.sort_unstable_by_key(|(index, _, _)| *index);
+            output.push('{');
+            let mut first = true;
+            for (_, key, value) in indexed {
+                if !first {
+                    output.push(',');
+                }
+                first = false;
+                output.push_str(&serde_json::to_string(key).ok()?);
+                output.push(':');
+                write_ecmascript_json(value, output)?;
+            }
+            for (key, value) in values {
+                if ecmascript_array_index(key).is_some() {
+                    continue;
+                }
+                if !first {
+                    output.push(',');
+                }
+                first = false;
+                output.push_str(&serde_json::to_string(key).ok()?);
+                output.push(':');
+                write_ecmascript_json(value, output)?;
+            }
+            output.push('}');
+        }
+    }
+    Some(())
+}
+
+fn ecmascript_json_stringify_v1(json: &str) -> Option<String> {
+    let value = serde_json::from_str::<EcmascriptJsonValue>(json).ok()?;
+    let mut output = String::with_capacity(json.len());
+    write_ecmascript_json(&value, &mut output)?;
+    Some(output)
+}
+
+/// One admitted browser-safe product configuration.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub(crate) struct IntegrationConfigEntryV1 {
+    id: &'static str,
+    config: serde_json::Value,
+}
+
+/// The sole generic product configuration carrier in `BootV1`.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+pub(crate) struct IntegrationConfigsV1 {
+    version: u8,
+    entries: Vec<IntegrationConfigEntryV1>,
+}
+
+impl IntegrationConfigsV1 {
+    /// Admit canonical, explicitly projected browser configuration entries.
+    pub(crate) fn new(
+        entries: Vec<(&'static str, serde_json::Value)>,
+    ) -> Result<Self, Report<TrustedServerError>> {
+        if entries.len() > INTEGRATION_CONFIG_IDS_V1.len() {
+            return Err(integration_config_error("more than 11 product entries"));
+        }
+
+        let mut previous_index = None;
+        let mut value_count = 0;
+        let mut admitted = Vec::with_capacity(entries.len());
+        for (id, config) in entries {
+            let index = INTEGRATION_CONFIG_IDS_V1
+                .iter()
+                .position(|candidate| *candidate == id)
+                .ok_or_else(|| integration_config_error("unknown product id"))?;
+            if previous_index.is_some_and(|previous| index <= previous) {
+                return Err(integration_config_error(
+                    "product entries are duplicated or out of canonical order",
+                ));
+            }
+            if !config.is_object() {
+                return Err(integration_config_error(
+                    "product config must be a non-null object",
+                ));
+            }
+            validate_integration_config_value_v1(&config, 0, &mut value_count)?;
+            let entry = IntegrationConfigEntryV1 { id, config };
+            admitted.push(entry);
+            previous_index = Some(index);
+        }
+
+        let carrier = Self {
+            version: 1,
+            entries: admitted,
+        };
+        carrier.canonical_json_v1()?;
+        Ok(carrier)
+    }
+
+    fn canonical_json_v1(&self) -> Result<String, Report<TrustedServerError>> {
+        for entry in &self.entries {
+            let serialized = serde_json::to_string(entry)
+                .map_err(|_| integration_config_error("product entry serialization failed"))?;
+            let canonical = ecmascript_json_stringify_v1(&serialized).ok_or_else(|| {
+                integration_config_error("product entry ECMAScript serialization failed")
+            })?;
+            if canonical.len() > INTEGRATION_CONFIG_MAX_ENTRY_BYTES_V1 {
+                return Err(integration_config_error(
+                    "product entry exceeds 65,536 UTF-8 JSON bytes",
+                ));
+            }
+        }
+        let serialized = serde_json::to_string(self)
+            .map_err(|_| integration_config_error("carrier serialization failed"))?;
+        let canonical = ecmascript_json_stringify_v1(&serialized)
+            .ok_or_else(|| integration_config_error("carrier ECMAScript serialization failed"))?;
+        if canonical.len() > INTEGRATION_CONFIG_MAX_CARRIER_BYTES_V1 {
+            return Err(integration_config_error(
+                "carrier exceeds 524,288 UTF-8 JSON bytes",
+            ));
+        }
+        Ok(canonical)
+    }
+
+    /// Construct the exact empty carrier used by documents with no product modules.
+    #[must_use]
+    pub(crate) const fn empty() -> Self {
+        Self {
+            version: 1,
+            entries: Vec::new(),
+        }
+    }
+
+    /// Require exact equality between selected catalog products and carrier entries.
+    pub(crate) fn validate_manifest(
+        &self,
+        module_ids: &[&str],
+    ) -> Result<(), Report<TrustedServerError>> {
+        let selected = INTEGRATION_CONFIG_IDS_V1
+            .iter()
+            .copied()
+            .filter(|product_id| {
+                module_ids.iter().any(|module_id| {
+                    integration_config_product_for_module_v1(module_id) == Some(*product_id)
+                })
+            })
+            .collect::<Vec<_>>();
+        let configured = self
+            .entries
+            .iter()
+            .map(|entry| entry.id)
+            .collect::<Vec<_>>();
+        if configured != selected {
+            return Err(integration_config_error(
+                "manifest membership disagrees with product config entries",
+            ));
+        }
+        Ok(())
+    }
+
+    /// Select the canonical product subset required by one generated manifest.
+    pub(crate) fn select_for_manifest(
+        &self,
+        module_ids: &[&str],
+    ) -> Result<Self, Report<TrustedServerError>> {
+        let entries = self
+            .entries
+            .iter()
+            .filter(|entry| {
+                module_ids.iter().any(|module_id| {
+                    integration_config_product_for_module_v1(module_id) == Some(entry.id)
+                })
+            })
+            .map(|entry| (entry.id, entry.config.clone()))
+            .collect::<Vec<_>>();
+        let selected = Self::new(entries)?;
+        selected.validate_manifest(module_ids)?;
+        Ok(selected)
+    }
+
+    fn gpt_gam_attribution_enabled(&self) -> bool {
+        self.entries
+            .iter()
+            .find(|entry| entry.id == "gpt")
+            .and_then(|entry| entry.config.get("gamAttributionEnabled"))
+            .and_then(serde_json::Value::as_bool)
+            .unwrap_or(false)
+    }
+}
+
+impl Default for IntegrationConfigsV1 {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+#[must_use]
+pub(crate) fn is_integration_config_product_v1(id: &str) -> bool {
+    INTEGRATION_CONFIG_IDS_V1.contains(&id)
+}
+
+#[must_use]
+pub(crate) fn integration_config_order_v1(id: &str) -> Option<usize> {
+    INTEGRATION_CONFIG_IDS_V1
+        .iter()
+        .position(|candidate| *candidate == id)
+}
+
+fn validate_integration_config_value_v1(
+    value: &serde_json::Value,
+    depth: usize,
+    value_count: &mut usize,
+) -> Result<(), Report<TrustedServerError>> {
+    if depth > INTEGRATION_CONFIG_MAX_DEPTH_V1 {
+        return Err(integration_config_error("config depth exceeds 16"));
+    }
+    *value_count += 1;
+    if *value_count > INTEGRATION_CONFIG_MAX_VALUES_V1 {
+        return Err(integration_config_error(
+            "carrier exceeds 4,096 JSON values",
+        ));
+    }
+    match value {
+        serde_json::Value::String(string) => {
+            if string.len() > INTEGRATION_CONFIG_MAX_STRING_BYTES_V1 {
+                return Err(integration_config_error(
+                    "config string exceeds 4,096 UTF-8 bytes",
+                ));
+            }
+        }
+        serde_json::Value::Array(values) => {
+            for value in values {
+                validate_integration_config_value_v1(value, depth + 1, value_count)?;
+            }
+        }
+        serde_json::Value::Object(object) => {
+            for (key, value) in object {
+                if key.len() > INTEGRATION_CONFIG_MAX_STRING_BYTES_V1 {
+                    return Err(integration_config_error(
+                        "config key exceeds 4,096 UTF-8 bytes",
+                    ));
+                }
+                validate_integration_config_value_v1(value, depth + 1, value_count)?;
+            }
+        }
+        serde_json::Value::Null | serde_json::Value::Bool(_) | serde_json::Value::Number(_) => {}
+    }
+    Ok(())
+}
+
+fn integration_config_product_for_module_v1(module_id: &str) -> Option<&'static str> {
+    match module_id {
+        "aps" => Some("aps"),
+        "datadome" => Some("datadome"),
+        "didomi" => Some("didomi"),
+        "google_tag_manager" => Some("google_tag_manager"),
+        "gpt" | "gpt_later" => Some("gpt"),
+        "lockr" => Some("lockr"),
+        "osano_consent" | "osano_lifecycle" => Some("osano"),
+        "permutive_context" | "permutive_lifecycle" => Some("permutive"),
+        "prebid" | "prebid_later" => Some("prebid"),
+        "sourcepoint_consent" | "sourcepoint_lifecycle" => Some("sourcepoint"),
+        "testlight" => Some("testlight"),
+        _ => None,
+    }
+}
+
+fn integration_config_error(message: &str) -> Report<TrustedServerError> {
+    Report::new(TrustedServerError::Configuration {
+        message: format!("TSJS integration config: {message}"),
+    })
+}
+
+/// Serialize the production size-admitted first-display bootstrap transport.
+///
+/// # Errors
+///
+/// Returns an error when the projection, catalog inventory, boot bits, or selected
+/// first-display mask is invalid or not admitted by the generated release catalog.
+pub fn tsjs_bootstrap_fragment_v1(
+    config: TsjsBootScriptConfigV1<'_>,
+    publisher_origin: &str,
+) -> Result<String, Report<TrustedServerError>> {
+    tsjs_bootstrap_fragment_with_nonce_v1(config, publisher_origin, None)
+}
+
+/// Serialize the production bootstrap transport with one response-authenticated CSP nonce.
+///
+/// # Errors
+///
+/// Returns an error when the nonce is not a bounded CSP `base64-value`, or when
+/// the ordinary production projection and catalog validation fails.
+pub(crate) fn tsjs_bootstrap_fragment_with_nonce_v1(
+    config: TsjsBootScriptConfigV1<'_>,
+    publisher_origin: &str,
+    csp_nonce: Option<&str>,
+) -> Result<String, Report<TrustedServerError>> {
+    tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(config, publisher_origin, csp_nonce, "")
+}
+
+/// Serialize the controller first, followed by live upstream markup and the selected runtime.
+///
+/// The caller owns `interstitial_html`; it contains only server-generated diagnostics and
+/// integration tags. Keeping that markup between the controller and selected artifact lets the
+/// controller capture its authenticated browser boundary before any live upstream script while
+/// preserving upstream-before-agent ordering.
+pub(crate) fn tsjs_bootstrap_fragment_with_nonce_and_interstitial_v1(
+    config: TsjsBootScriptConfigV1<'_>,
+    publisher_origin: &str,
+    csp_nonce: Option<&str>,
+    interstitial_html: &str,
+) -> Result<String, Report<TrustedServerError>> {
+    let nonce_attribute = match csp_nonce {
+        Some(nonce)
+            if !nonce.is_empty()
+                && nonce.len() <= 256
+                && nonce.bytes().all(|byte| {
+                    byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/' | b'_' | b'-' | b'=')
+                }) =>
+        {
+            format!(r#" nonce="{nonce}""#)
+        }
+        Some(_) => {
+            return Err(boot_manifest_error(
+                "CSP nonce is not a bounded base64-value",
+            ));
+        }
+        None => String::new(),
+    };
+    let selected = selected_metadata(config.module_ids)?;
+    config
+        .integration_configs
+        .validate_manifest(config.module_ids)?;
+    let contains = |id: &str| selected.iter().any(|metadata| metadata.id == id);
+    let creative_required =
+        config.creative.enabled && (config.creative.click_guard || config.creative.render_guard);
+    if contains("creative") != creative_required
+        || (!config.creative.enabled
+            && (config.creative.click_guard || config.creative.render_guard))
+    {
+        return Err(boot_manifest_error(
+            "creative boot bits disagree with manifest membership",
+        ));
+    }
+    if contains("gpt_diagnostics") != config.gpt_diagnostics_active
+        || contains("diagnostics_presentation")
+            != (config.render_trace_overlay || config.gpt_diagnostics_active)
+    {
+        return Err(boot_manifest_error(
+            "diagnostics membership disagrees with boot bits",
+        ));
+    }
+
+    let projection = crate::auction::formats::coordinated_cutover_v1::canonicalize_browser_auction_projection_json_v1(
+        config.auction_projection_json,
+        publisher_origin,
+    )
+    .map_err(|_| boot_manifest_error("auction projection violates the version-1 contract"))?;
+    let projection = ecmascript_json_stringify_v1(&projection)
+        .ok_or_else(|| boot_manifest_error("auction projection ECMAScript serialization failed"))?;
+    if projection.len() > MAX_BROWSER_AUCTION_PROJECTION_BYTES {
+        return Err(boot_manifest_error(
+            "auction projection exceeds 8 MiB after ECMAScript serialization",
+        ));
+    }
+    let projection_value = serde_json::from_str::<BrowserAuctionProjectionV1>(&projection)
+        .map_err(|_| boot_manifest_error("canonical auction projection is unavailable"))?;
+    let projection_digest = hex::encode(Sha256::digest(projection.as_bytes()));
+    let enabled_integrations = selected
+        .iter()
+        .filter_map(|metadata| match metadata.id {
+            "render_runtime"
+            | "diagnostics_presentation"
+            | "gpt_later"
+            | "osano_lifecycle"
+            | "permutive_lifecycle"
+            | "prebid_later"
+            | "sourcepoint_lifecycle" => None,
+            "osano_consent" => Some("osano"),
+            "permutive_context" => Some("permutive"),
+            "sourcepoint_consent" => Some("sourcepoint"),
+            id => Some(id),
+        })
+        .collect::<Vec<_>>();
+    let first_display = select_first_display_slices_v1(
+        &projection_value,
+        FirstDisplaySelectionConfigV1 {
+            enabled_integrations: &enabled_integrations,
+            creative: config.creative,
+            gam_attribution_enabled: config.integration_configs.gpt_gam_attribution_enabled(),
+        },
+    );
+    let agent = match first_display.as_ref() {
+        Some(selection) => Some(
+            TsjsStaticArtifactV1::new_first_display(selection.mask(), selection.slices())
+                .ok_or_else(|| {
+                    boot_manifest_error("first-display artifact composition is unavailable")
+                })?,
+        ),
+        None => None,
+    };
+    let takeover_ids = selected
+        .iter()
+        .filter_map(|metadata| {
+            (metadata.phase == Some(TsjsModulePhase::Takeover)).then_some(metadata.id)
+        })
+        .collect::<Vec<_>>();
+    let runtime_src = tsjs_script_src(&takeover_ids);
+    let slice_ids = first_display.as_ref().map_or_else(
+        || Ok(Vec::new()),
+        |selection| {
+            selection
+                .slices()
+                .iter()
+                .map(|id| {
+                    serde_json::to_string(id).map_err(|_| {
+                        boot_manifest_error("first-display slice serialization failed")
+                    })
+                })
+                .collect::<Result<Vec<_>, _>>()
+        },
+    )?;
+    let integrations = selected
+        .iter()
+        .map(|metadata| {
+            let id = serde_json::to_string(metadata.id)
+                .map_err(|_| boot_manifest_error("integration id serialization failed"))?;
+            match metadata.phase {
+                Some(TsjsModulePhase::Takeover) => {
+                    Ok(format!(r#"{{"id":{id},"phase":"takeover"}}"#))
+                }
+                Some(TsjsModulePhase::Deferred) => {
+                    let trigger = metadata.trigger.ok_or_else(|| {
+                        boot_manifest_error("deferred catalog trigger is unavailable")
+                    })?;
+                    let src = tsjs_single_module_script_src(metadata.id).ok_or_else(|| {
+                        boot_manifest_error("deferred module source is unavailable")
+                    })?;
+                    Ok(format!(
+                        r#"{{"id":{id},"phase":"deferred","trigger":{},"src":{}}}"#,
+                        serde_json::to_string(trigger).map_err(|_| {
+                            boot_manifest_error("deferred trigger serialization failed")
+                        })?,
+                        serde_json::to_string(&src).map_err(|_| {
+                            boot_manifest_error("deferred source serialization failed")
+                        })?
+                    ))
+                }
+                _ => Err(boot_manifest_error(
+                    "catalog integration phase is unavailable",
+                )),
+            }
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let first_display_manifest = agent.as_ref().map_or_else(
+        || "null".to_owned(),
+        |artifact| {
+            format!(
+                r#"{{"src":"{}","slices":[{}]}}"#,
+                artifact.src(),
+                slice_ids.join(",")
+            )
+        },
+    );
+    let manifest = format!(
+        r#"{{"version":1,"releaseId":"{}","firstDisplay":{},"runtimeSrc":"{}","integrations":[{}]}}"#,
+        release_id(),
+        first_display_manifest,
+        runtime_src,
+        integrations.join(",")
+    );
+    let integration_configs_json = config.integration_configs.canonical_json_v1()?;
+    let integration_config_digest =
+        hex::encode(Sha256::digest(integration_configs_json.as_bytes()));
+    let integrity = format!(
+        r#"{{"version":1,"projectionDigest":"{}","integrationConfigDigest":"{}"}}"#,
+        projection_digest, integration_config_digest
+    );
+    let outline = first_display.as_ref().map_or_else(
+        || "null".to_owned(),
+        |_| {
+            format!(
+                r#"{{"version":1,"releaseId":"{}","generation":1,"projectionDigest":"{}","integrationConfigDigest":"{}","slices":[{}],"slotCount":{},"outcomeCount":{},"capabilities":[],"objectKinds":[{}]}}"#,
+                release_id(),
+                projection_digest,
+                integration_config_digest,
+                slice_ids.join(","),
+                projection_value.slots.len(),
+                projection_value.auction.results.len(),
+                if projection_value.bids.is_empty() {
+                    ""
+                } else {
+                    r#""gpt_slot","dom_artifact""#
+                },
+            )
+        },
+    );
+    let transport = format!(
+        r#"{{"version":1,"boot":{{"abi":1,"releaseId":"{}","manifest":{},"auctionProjection":{},"integrations":{},"creative":{{"version":1,"enabled":{},"clickGuard":{},"renderGuard":{}}},"diagnostics":{{"version":1,"renderTraceOverlay":{},"gpt":{{"active":{}}}}}}},"integrity":{},"outline":{}}}"#,
+        release_id(),
+        manifest,
+        projection,
+        integration_configs_json,
+        config.creative.enabled,
+        config.creative.click_guard,
+        config.creative.render_guard,
+        config.render_trace_overlay,
+        config.gpt_diagnostics_active,
+        integrity,
+        outline,
+    );
+    if transport.len() > SERVER_BOOT_TRANSPORT_MAX_BYTES_V1 {
+        return Err(boot_manifest_error(
+            "server boot transport exceeds 10 MiB UTF-8",
+        ));
+    }
+    let transport_literal = serde_json::to_string(&transport)
+        .map_err(|_| boot_manifest_error("server boot transport serialization failed"))?;
+    let transport_literal = escape_json_for_inline_script(&transport_literal);
+    let bootstrap = trusted_server_js::bootstrap_bundle();
+    if bootstrap.to_ascii_lowercase().contains("</script") {
+        return Err(boot_manifest_error(
+            "generated bootstrap contains an inline-script terminator",
+        ));
+    }
+    let controller = format!(
+        "<script{nonce_attribute}>const __TSJS_SERVER_BOOT_TRANSPORT_V1__={transport_literal};{bootstrap}</script>"
+    );
+    let selected_src = agent
+        .as_ref()
+        .map_or(runtime_src.as_str(), |artifact| artifact.src());
+    Ok(format!(
+        r#"{controller}{interstitial_html}<script{nonce_attribute} src="{selected_src}" id="trustedserver-js"></script>"#
+    ))
+}
+
+/// Serialize a production boot fragment with deterministic browser-safe fixture config.
+///
+/// This is available only to workspace integration-test tools. It exercises the
+/// production manifest and immutable boot serializer without exposing the internal
+/// [`IntegrationConfigsV1`] representation to downstream crates.
+///
+/// # Errors
+///
+/// Returns an error when the selected module inventory, projection, creative bits,
+/// diagnostics bits, or generated fixture configuration violates the production ABI.
+#[cfg(feature = "test-utils")]
+pub fn tsjs_bootstrap_fixture_fragment_v1(
+    module_ids: &[&str],
+    auction_projection_json: &str,
+    creative: CreativeBootConfigV1,
+    render_trace_overlay: bool,
+    gpt_diagnostics_active: bool,
+    publisher_origin: &str,
+) -> Result<String, Report<TrustedServerError>> {
+    let entries = INTEGRATION_CONFIG_IDS_V1
+        .iter()
+        .copied()
+        .filter(|product_id| {
+            module_ids.iter().any(|module_id| {
+                integration_config_product_for_module_v1(module_id) == Some(*product_id)
+            })
+        })
+        .map(|product_id| {
+            let config = match product_id {
+                "didomi" => serde_json::json!({ "proxyPath": "/integrations/didomi/" }),
+                "gpt" => serde_json::json!({
+                    "gamAttributionEnabled": false,
+                    "pageBidsEnabled": true,
+                }),
+                "prebid" => serde_json::json!({
+                    "accountId": "fixture",
+                    "timeout": 1_000,
+                    "debug": false,
+                    "bidders": [],
+                }),
+                "sourcepoint" => serde_json::json!({ "rewriteSdk": false }),
+                _ => serde_json::json!({}),
+            };
+            (product_id, config)
+        })
+        .collect::<Vec<_>>();
+    let integration_configs = IntegrationConfigsV1::new(entries)?;
+    tsjs_bootstrap_fragment_v1(
+        TsjsBootScriptConfigV1 {
+            module_ids,
+            integration_configs: &integration_configs,
+            auction_projection_json,
+            creative,
+            render_trace_overlay,
+            gpt_diagnostics_active,
+        },
+        publisher_origin,
+    )
+}
+
+fn selected_metadata(
+    module_ids: &[&str],
+) -> Result<Vec<trusted_server_js::TsjsArtifactMetadata>, Report<TrustedServerError>> {
+    if module_ids.len() > trusted_server_js::MAX_MANIFEST_MODULES {
+        return Err(boot_manifest_error("more than 20 integration modules"));
+    }
+    let requested = module_ids.iter().copied().collect::<HashSet<_>>();
+    if requested.len() != module_ids.len()
+        || requested
+            .iter()
+            .any(|id| *id == "core" || !valid_integration_id(id))
+    {
+        return Err(boot_manifest_error("invalid integration inventory"));
+    }
+
+    let metadata = all_integration_metadata();
+    if requested
+        .iter()
+        .any(|id| !metadata.iter().any(|entry| entry.id == *id))
+    {
+        return Err(boot_manifest_error("invalid integration inventory"));
+    }
+    if metadata
+        .iter()
+        .filter(|entry| entry.include == Some("always"))
+        .any(|entry| !requested.contains(entry.id))
+    {
+        return Err(boot_manifest_error(
+            "integration inventory omits an always-on catalog member",
+        ));
+    }
+    Ok(metadata
+        .into_iter()
+        .filter(|entry| requested.contains(entry.id))
+        .collect())
+}
+
+/// Exact immutable creative boot bits emitted for one document generation.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct CreativeBootConfigV1 {
+    /// Whether the creative integration is a required manifest member.
+    pub enabled: bool,
+    /// Whether automatic click interception activates after kernel commit.
+    pub click_guard: bool,
+    /// Whether automatic render interception activates after kernel commit.
+    pub render_guard: bool,
+}
+
+/// Trusted server-owned inputs for selecting the closed provisional artifact.
+#[derive(Clone, Copy, Debug)]
+pub struct FirstDisplaySelectionConfigV1<'a> {
+    /// Enabled browser integration products; never publisher supplied.
+    pub enabled_integrations: &'a [&'a str],
+    /// Exact server-resolved parser-time creative guard policy.
+    pub creative: CreativeBootConfigV1,
+    /// Whether GPT owns the document-local parser-time GAM attribution obligation.
+    pub gam_attribution_enabled: bool,
+}
+
+/// Exact ordered first-display slice mask selected for one immutable projection.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FirstDisplaySelectionV1 {
+    mask: u16,
+    slices: Vec<&'static str>,
+}
+
+impl FirstDisplaySelectionV1 {
+    /// Return the four-hex-digit transport mask value.
+    #[must_use]
+    pub const fn mask(&self) -> u16 {
+        self.mask
+    }
+
+    /// Return selected slice ids in the fixed build order.
+    #[must_use]
+    pub fn slices(&self) -> &[&'static str] {
+        &self.slices
+    }
+}
+
+const FIRST_DISPLAY_KNOWN_INTEGRATIONS: &[&str] = &[
+    "aps",
+    "creative",
+    "datadome",
+    "didomi",
+    "google_tag_manager",
+    "gpt",
+    "gpt_diagnostics",
+    "lockr",
+    "osano",
+    "permutive",
+    "prebid",
+    "sourcepoint",
+    "testlight",
+];
+
+/// Select the agent only for a complete, closed GPT-mediated initial projection.
+///
+/// An absent selection means the page must boot the persistent runtime directly.
+/// PBS Cache, direct/programmatic projections, unknown obligations, incomplete
+/// joins, and non-GPT configurations fail closed here.
+#[must_use]
+pub fn select_first_display_slices_v1(
+    projection: &BrowserAuctionProjectionV1,
+    config: FirstDisplaySelectionConfigV1<'_>,
+) -> Option<FirstDisplaySelectionV1> {
+    if projection.version != 1
+        || projection.auction.version != 1
+        || projection.auction.results.is_empty()
+        || projection.auction.results.len() > crate::auction::types::MAX_BROWSER_AUCTION_RESULTS
+        || projection.slots.len() != projection.auction.results.len()
+    {
+        return None;
+    }
+
+    let mut enabled = HashSet::new();
+    for integration in config.enabled_integrations {
+        if !FIRST_DISPLAY_KNOWN_INTEGRATIONS.contains(integration) || !enabled.insert(*integration)
+        {
+            return None;
+        }
+    }
+    if !enabled.contains("gpt") {
+        return None;
+    }
+
+    let mut winner_count = 0_usize;
+    let mut aps_participates = false;
+    let mut seen_slots = HashSet::new();
+    for (index, decision) in projection.auction.results.iter().enumerate() {
+        let slot = projection.slots.get(index)?;
+        if slot.slot != decision.slot() || !seen_slots.insert(slot.slot.as_str()) {
+            return None;
+        }
+        if let SlotAuctionDecisionV1::Winner { candidate_id, slot } = decision {
+            let mut matching = projection
+                .bids
+                .iter()
+                .filter(|bid| bid.candidate_id == *candidate_id && bid.slot == *slot);
+            let bid = matching.next()?;
+            if matching.next().is_some() {
+                return None;
+            }
+            match &bid.render_source {
+                BidRenderSourceV1::Aps(_) => {
+                    if !bid.renderer_reservation_id.as_deref().is_some_and(
+                        crate::auction::formats::coordinated_cutover_v1::valid_renderer_reservation_id,
+                    ) {
+                        return None;
+                    }
+                    if !enabled.contains("aps") {
+                        return None;
+                    }
+                    aps_participates = true;
+                }
+                BidRenderSourceV1::Adm(_) => {
+                    if !bid.renderer_reservation_id.as_deref().is_some_and(
+                        crate::auction::formats::coordinated_cutover_v1::valid_renderer_reservation_id,
+                    ) {
+                        return None;
+                    }
+                }
+                BidRenderSourceV1::PbsCache(_) => return None,
+            }
+            winner_count += 1;
+        }
+    }
+    if winner_count != projection.bids.len() {
+        return None;
+    }
+
+    let creative_guard = enabled.contains("creative")
+        && config.creative.enabled
+        && (config.creative.click_guard || config.creative.render_guard);
+    let gpt_participates = winner_count > 0 || config.gam_attribution_enabled;
+    let render_owner_participates = winner_count > 0;
+    let prebid_participates =
+        enabled.contains("prebid") && projection.bids.iter().any(|bid| bid.provider == "prebid");
+    let mut mask = 0_u16;
+    let mut slices = Vec::new();
+    for (index, metadata) in trusted_server_js::all_first_display_metadata()
+        .into_iter()
+        .enumerate()
+    {
+        let selected = match metadata.include {
+            Some("eligible_batch") => true,
+            Some("render_owner_participates") => render_owner_participates,
+            Some("aps_participates") => aps_participates,
+            Some("creative_guard") => creative_guard,
+            Some("gpt_initial") => gpt_participates,
+            Some("prebid_participates") => prebid_participates,
+            Some(predicate) => predicate
+                .strip_prefix("integration:")
+                .is_some_and(|integration| enabled.contains(integration)),
+            None => false,
+        };
+        if selected {
+            mask |= 1_u16 << index;
+            slices.push(metadata.id);
+        }
+    }
+    trusted_server_js::first_display_mask_is_permitted(mask)
+        .then_some(FirstDisplaySelectionV1 { mask, slices })
+}
+
+impl Default for CreativeBootConfigV1 {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            click_guard: true,
+            render_guard: false,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Validate)]
+#[serde(deny_unknown_fields)]
+struct CreativeBrowserConfigV1 {
+    #[serde(default = "default_true")]
+    enabled: bool,
+    #[serde(default = "default_true")]
+    click_guard: bool,
+    #[serde(default)]
+    render_guard: bool,
+}
+
+impl IntegrationConfig for CreativeBrowserConfigV1 {
+    fn is_enabled(&self) -> bool {
+        self.enabled
+    }
+}
+
+const fn default_true() -> bool {
+    true
+}
+
+/// Resolve the exact server-owned creative browser boot policy.
+pub(crate) fn creative_boot_config_v1(
+    settings: &Settings,
+) -> Result<CreativeBootConfigV1, Report<TrustedServerError>> {
+    if !settings.integrations.contains_key("creative") {
+        return Ok(CreativeBootConfigV1::default());
+    }
+    let Some(config) = settings.integration_config::<CreativeBrowserConfigV1>("creative")? else {
+        return Ok(CreativeBootConfigV1 {
+            enabled: false,
+            click_guard: false,
+            render_guard: false,
+        });
+    };
+    Ok(CreativeBootConfigV1 {
+        enabled: true,
+        click_guard: config.click_guard,
+        render_guard: config.render_guard,
+    })
+}
+
+/// Inputs for the one hard-cutover browser boot transport.
+#[derive(Clone, Copy, Debug)]
+pub struct TsjsBootScriptConfigV1<'a> {
+    /// Enabled integration bundles in their actual injection order.
+    pub module_ids: &'a [&'a str],
+    /// Exact browser-safe product configuration subset for this manifest.
+    pub(crate) integration_configs: &'a IntegrationConfigsV1,
+    /// Canonical exact [`BrowserAuctionProjectionV1`](crate::auction::types::BrowserAuctionProjectionV1)
+    /// JSON produced by the auction projection boundary.
+    pub auction_projection_json: &'a str,
+    /// Exact creative integration boot configuration.
+    pub creative: CreativeBootConfigV1,
+    /// Whether the local render-trace overlay is active for this document.
+    pub render_trace_overlay: bool,
+    /// Whether request/session-scoped GPT diagnostics is active.
+    pub gpt_diagnostics_active: bool,
+}
+
+fn escape_json_for_inline_script(json: &str) -> String {
+    let mut escaped = String::with_capacity(json.len());
+    for character in json.chars() {
+        match character {
+            '&' => escaped.push_str("\\u0026"),
+            '<' => escaped.push_str("\\u003c"),
+            '>' => escaped.push_str("\\u003e"),
+            '\u{2028}' => escaped.push_str("\\u2028"),
+            '\u{2029}' => escaped.push_str("\\u2029"),
+            _ => escaped.push(character),
+        }
+    }
+    escaped
+}
+
+fn valid_integration_id(id: &str) -> bool {
+    let bytes = id.as_bytes();
+    !bytes.is_empty()
+        && bytes.len() <= 64
+        && (bytes[0].is_ascii_lowercase() || bytes[0].is_ascii_digit())
+        && bytes.iter().all(|byte| {
+            byte.is_ascii_lowercase() || byte.is_ascii_digit() || *byte == b'_' || *byte == b'-'
+        })
+}
+
+fn boot_manifest_error(message: &str) -> Report<TrustedServerError> {
+    Report::new(TrustedServerError::Configuration {
+        message: format!("TSJS boot manifest: {message}"),
+    })
+}
 
 /// `/static` URL for the tsjs bundle with cache-busting hash based on
 /// the concatenated content of the given module set.
@@ -11,42 +1140,114 @@ pub fn tsjs_script_src(module_ids: &[&str]) -> String {
 /// `<script>` tag for injecting the tsjs bundle.
 #[must_use]
 pub fn tsjs_script_tag(module_ids: &[&str]) -> String {
-    tsjs_script_tag_with_attributes(module_ids, &[])
+    tsjs_script_tag_from_src(&tsjs_script_src(module_ids))
 }
 
-/// Publisher `<script>` tag for the tsjs bundle with trusted static attributes.
+/// `<script>` tag for a precomputed exact TSJS artifact URL.
 #[must_use]
-pub fn tsjs_script_tag_with_attributes(
-    module_ids: &[&str],
-    attributes: &[(&'static str, &'static str)],
-) -> String {
-    let attributes = attributes
-        .iter()
-        .map(|(name, value)| {
-            debug_assert!(
-                !name.is_empty()
-                    && name.bytes().all(|byte| {
-                        byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-'
-                    }),
-                "attribute name should contain only lowercase ASCII letters, digits, and hyphens"
-            );
-            debug_assert!(
-                !value
-                    .bytes()
-                    .any(|byte| matches!(byte, b'"' | b'&' | b'<' | b'>')),
-                "attribute value should not contain HTML-sensitive characters"
-            );
-            format!(" {name}=\"{value}\"")
-        })
-        .collect::<String>();
+pub(crate) fn tsjs_script_tag_from_src(src: &str) -> String {
+    format!(r#"<script src="{src}" id="trustedserver-js"></script>"#)
+}
 
-    format!(
-        "<script src=\"{}\" id=\"trustedserver-js\"{attributes}></script>",
-        tsjs_script_src(module_ids),
-    )
+/// Exact in-memory bytes and content identity for a unified TSJS artifact.
+#[derive(Clone, Debug)]
+pub(crate) struct TsjsStaticArtifactV1 {
+    body: bytes::Bytes,
+    hash: String,
+    src: String,
+}
+
+impl TsjsStaticArtifactV1 {
+    /// Build one exact content-addressed artifact from its canonical modules.
+    #[must_use]
+    pub(crate) fn new(module_ids: &[&str]) -> Self {
+        let body = bytes::Bytes::from(trusted_server_js::concatenate_modules(module_ids));
+        let hash = hex::encode(Sha256::digest(&body));
+        let src = format!("/static/tsjs=tsjs-unified.min.js?v={hash}");
+        Self { body, hash, src }
+    }
+
+    /// Build one exact first-display composition for a validated mask.
+    #[must_use]
+    pub(crate) fn new_first_display(mask: u16, selected_ids: &[&str]) -> Option<Self> {
+        if selected_ids.first() != Some(&"first_display") {
+            return None;
+        }
+        let body = bytes::Bytes::from(trusted_server_js::concatenate_first_display_slices(
+            selected_ids.get(1..).unwrap_or_default(),
+        )?);
+        let hash = hex::encode(Sha256::digest(&body));
+        let src = format!("/static/tsjs=tsjs-first-display.min.js?m={mask:04x}&v={hash}");
+        Some(Self { body, hash, src })
+    }
+
+    /// Return immutable response bytes; cloning [`bytes::Bytes`] shares storage.
+    #[must_use]
+    pub(crate) const fn body(&self) -> &bytes::Bytes {
+        &self.body
+    }
+
+    /// Return the SHA-256 identity of the exact response bytes.
+    #[must_use]
+    pub(crate) fn hash(&self) -> &str {
+        &self.hash
+    }
+
+    /// Return the exact content-addressed static URL.
+    #[must_use]
+    pub(crate) fn src(&self) -> &str {
+        &self.src
+    }
+}
+
+const CREATIVE_TSJS_MODULE_IDS: &[&str] = &["render_runtime", "creative"];
+const EMPTY_CREATIVE_AUCTION_PROJECTION_JSON: &str = r#"{"version":1,"auction":{"version":1,"auctionId":"initial","results":[]},"slots":[],"bids":[]}"#;
+
+/// Build the complete hard-cutover bootstrap for a rewritten creative document.
+///
+/// Rewritten creatives are independent documents, so they need their own exact
+/// boot transport and runtime artifact. The inventory is intentionally limited
+/// to the always-on render runtime and creative integration; publisher-page
+/// integrations and deferred presentation code do not belong in creative HTML.
+///
+/// # Errors
+///
+/// Returns an error when the creative settings or exact boot manifest are invalid.
+pub(crate) fn creative_tsjs_bootstrap_v1(
+    settings: &Settings,
+) -> Result<Option<String>, Report<TrustedServerError>> {
+    let creative = creative_boot_config_v1(settings)?;
+    if !creative.enabled || (!creative.click_guard && !creative.render_guard) {
+        return Ok(None);
+    }
+    let fragment = tsjs_bootstrap_fragment_v1(
+        TsjsBootScriptConfigV1 {
+            module_ids: CREATIVE_TSJS_MODULE_IDS,
+            integration_configs: &IntegrationConfigsV1::empty(),
+            auction_projection_json: EMPTY_CREATIVE_AUCTION_PROJECTION_JSON,
+            creative,
+            render_trace_overlay: false,
+            gpt_diagnostics_active: false,
+        },
+        "https://creative.invalid",
+    )?;
+    Ok(Some(fragment))
+}
+
+/// Return the exact takeover module inventory admitted for rewritten creatives.
+#[must_use]
+pub(crate) const fn creative_tsjs_module_ids() -> &'static [&'static str] {
+    CREATIVE_TSJS_MODULE_IDS
+}
+
+/// Return the process-wide exact artifact used by rewritten creative documents.
+#[must_use]
+pub(crate) fn creative_tsjs_static_artifact_v1() -> &'static TsjsStaticArtifactV1 {
+    static ARTIFACT: OnceLock<TsjsStaticArtifactV1> = OnceLock::new();
+    ARTIFACT.get_or_init(|| TsjsStaticArtifactV1::new(CREATIVE_TSJS_MODULE_IDS))
 }
 
-/// `/static` URL for the unified bundle when exact module IDs are unavailable.
+/// `/static` URL for the unified bundle with a conservative cache-busting hash.
 ///
 /// This intentionally omits `?v=` because the serving path can only mark a URL
 /// immutable when the hash matches the exact enabled module set. Use
@@ -72,24 +1273,25 @@ pub fn tsjs_unified_script_tag() -> String {
 
 /// `/static` URL for one module with its own cache-busting hash.
 #[must_use]
-pub fn tsjs_single_module_script_src(module_id: &str) -> String {
-    let hash = single_module_hash(module_id).unwrap_or_default();
-    format!("/static/tsjs=tsjs-{module_id}.min.js?v={hash}")
+pub fn tsjs_single_module_script_src(module_id: &str) -> Option<String> {
+    let metadata = trusted_server_js::integration_metadata(module_id)?;
+    if metadata.phase != Some(TsjsModulePhase::Deferred) {
+        return None;
+    }
+    let hash = single_module_hash(module_id)?;
+    Some(format!("/static/tsjs=tsjs-{module_id}.min.js?v={hash}"))
 }
 
 /// `/static` URL for a single deferred module with its own cache-busting hash.
 #[must_use]
-pub fn tsjs_deferred_script_src(module_id: &str) -> String {
+pub fn tsjs_deferred_script_src(module_id: &str) -> Option<String> {
     tsjs_single_module_script_src(module_id)
 }
 
 /// `<script defer>` tag for a single deferred module.
 #[must_use]
-pub fn tsjs_deferred_script_tag(module_id: &str) -> String {
-    format!(
-        "<script src=\"{}\" defer></script>",
-        tsjs_deferred_script_src(module_id)
-    )
+pub fn tsjs_deferred_script_tag(module_id: &str) -> Option<String> {
+    tsjs_deferred_script_src(module_id).map(|src| format!("<script src=\"{src}\" defer></script>"))
 }
 
 /// Generate all deferred `<script defer>` tags for the given module IDs.
@@ -99,13 +1301,446 @@ pub fn tsjs_deferred_script_tag(module_id: &str) -> String {
 pub fn tsjs_deferred_script_tags(module_ids: &[&str]) -> String {
     module_ids
         .iter()
-        .map(|id| tsjs_deferred_script_tag(id))
+        .filter_map(|id| tsjs_deferred_script_tag(id))
         .collect::<String>()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::test_support::tests::bootstrap_transport;
+
+    const VALID_BROWSER_AUCTION_PROJECTION_JSON: &str = r#"{"version":1,"auction":{"version":1,"auctionId":"initial","results":[]},"slots":[],"bids":[]}"#;
+    const PERFORMANCE_ORIGIN: &str = "https://performance.example";
+
+    #[test]
+    fn ecmascript_json_corpus_matches_the_browser_stringify_contract() {
+        let corpus: serde_json::Value = serde_json::from_str(include_str!(
+            "../../trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json"
+        ))
+        .expect("shared ECMAScript JSON corpus should parse");
+        for case in corpus
+            .as_array()
+            .expect("shared ECMAScript JSON corpus should be an array")
+        {
+            let name = case["name"].as_str().expect("case should have a name");
+            let input = case["input"].as_str().expect("case should have input");
+            let expected = case["expected"]
+                .as_str()
+                .expect("case should have expected bytes");
+            assert_eq!(
+                ecmascript_json_stringify_v1(input).as_deref(),
+                Some(expected),
+                "shared case should match: {name}"
+            );
+        }
+    }
+
+    #[test]
+    fn integration_configs_serialize_once_in_canonical_product_order() {
+        let configs = IntegrationConfigsV1::new(vec![
+            ("aps", serde_json::json!({})),
+            ("datadome", serde_json::json!({})),
+            ("didomi", serde_json::json!({ "proxyPath": "/consent/" })),
+            ("google_tag_manager", serde_json::json!({})),
+            (
+                "gpt",
+                serde_json::json!({
+                    "gamAttributionEnabled": true,
+                    "pageBidsEnabled": true,
+                }),
+            ),
+            ("lockr", serde_json::json!({})),
+            ("osano", serde_json::json!({})),
+            ("permutive", serde_json::json!({})),
+            ("prebid", serde_json::json!({ "accountId": "publisher" })),
+            ("sourcepoint", serde_json::json!({ "rewriteSdk": true })),
+            ("testlight", serde_json::json!({})),
+        ])
+        .expect("canonical browser-safe integration configs should be admitted");
+
+        assert_eq!(
+            serde_json::to_string(&configs).expect("carrier should serialize"),
+            r#"{"version":1,"entries":[{"id":"aps","config":{}},{"id":"datadome","config":{}},{"id":"didomi","config":{"proxyPath":"/consent/"}},{"id":"google_tag_manager","config":{}},{"id":"gpt","config":{"gamAttributionEnabled":true,"pageBidsEnabled":true}},{"id":"lockr","config":{}},{"id":"osano","config":{}},{"id":"permutive","config":{}},{"id":"prebid","config":{"accountId":"publisher"}},{"id":"sourcepoint","config":{"rewriteSdk":true}},{"id":"testlight","config":{}}]}"#,
+        );
+    }
+
+    #[test]
+    fn integration_configs_reject_noncanonical_duplicate_unknown_or_non_object_entries() {
+        for entries in [
+            vec![
+                ("datadome", serde_json::json!({})),
+                ("aps", serde_json::json!({})),
+            ],
+            vec![
+                ("aps", serde_json::json!({})),
+                ("aps", serde_json::json!({})),
+            ],
+            vec![("unknown", serde_json::json!({}))],
+            vec![("aps", serde_json::json!(null))],
+        ] {
+            assert!(
+                IntegrationConfigsV1::new(entries).is_err(),
+                "invalid integration carrier entries must fail closed"
+            );
+        }
+    }
+
+    #[test]
+    fn integration_configs_enforce_recursive_json_and_serialized_size_caps() {
+        let long_string = "a".repeat(INTEGRATION_CONFIG_MAX_STRING_BYTES_V1 + 1);
+        assert!(
+            IntegrationConfigsV1::new(vec![("aps", serde_json::json!({ "value": long_string }),)])
+                .is_err(),
+            "strings above the UTF-8 cap must be rejected"
+        );
+
+        let long_key = "k".repeat(INTEGRATION_CONFIG_MAX_STRING_BYTES_V1 + 1);
+        assert!(
+            IntegrationConfigsV1::new(vec![(
+                "aps",
+                serde_json::Value::Object(serde_json::Map::from_iter([(
+                    long_key,
+                    serde_json::Value::Null,
+                )])),
+            )])
+            .is_err(),
+            "keys above the UTF-8 cap must be rejected"
+        );
+
+        let mut too_deep = serde_json::Value::Null;
+        for _ in 0..=INTEGRATION_CONFIG_MAX_DEPTH_V1 {
+            too_deep = serde_json::json!([too_deep]);
+        }
+        assert!(
+            IntegrationConfigsV1::new(vec![("aps", serde_json::json!({ "value": too_deep }),)])
+                .is_err(),
+            "values above the recursive depth cap must be rejected"
+        );
+
+        let too_many_values = vec![serde_json::Value::Null; INTEGRATION_CONFIG_MAX_VALUES_V1];
+        assert!(
+            IntegrationConfigsV1::new(vec![(
+                "aps",
+                serde_json::json!({ "values": too_many_values }),
+            )])
+            .is_err(),
+            "the config object and array also count toward the value cap"
+        );
+
+        let oversized_entry = "x".repeat(INTEGRATION_CONFIG_MAX_ENTRY_BYTES_V1);
+        assert!(
+            IntegrationConfigsV1::new(vec![(
+                "aps",
+                serde_json::json!({ "value": oversized_entry }),
+            )])
+            .is_err(),
+            "canonical entry JSON above the byte cap must be rejected"
+        );
+
+        let chunk = "z".repeat(INTEGRATION_CONFIG_MAX_STRING_BYTES_V1);
+        let carrier_entries = INTEGRATION_CONFIG_IDS_V1
+            .iter()
+            .take(9)
+            .map(|id| {
+                (
+                    *id,
+                    serde_json::json!({ "chunks": vec![chunk.clone(); 15] }),
+                )
+            })
+            .collect::<Vec<_>>();
+        assert!(
+            IntegrationConfigsV1::new(carrier_entries).is_err(),
+            "the complete carrier byte cap must be enforced independently"
+        );
+    }
+
+    #[test]
+    fn integration_configs_must_match_manifest_product_predicates_exactly() {
+        let aps = IntegrationConfigsV1::new(vec![("aps", serde_json::json!({}))])
+            .expect("APS should admit its required empty browser projection");
+        let empty = IntegrationConfigsV1::empty();
+
+        assert!(
+            aps.validate_manifest(&["render_runtime", "aps"]).is_ok(),
+            "APS manifest membership must match its one product config"
+        );
+        assert!(
+            aps.validate_manifest(&["render_runtime"]).is_err(),
+            "an unselected product config must be rejected"
+        );
+        assert!(
+            empty.validate_manifest(&["render_runtime", "aps"]).is_err(),
+            "a selected product without config must be rejected"
+        );
+
+        let prebid = IntegrationConfigsV1::new(vec![("prebid", serde_json::json!({}))])
+            .expect("Prebid config should be admitted");
+        assert!(
+            prebid
+                .validate_manifest(&["render_runtime", "prebid", "prebid_later"])
+                .is_ok(),
+            "takeover and deferred modules must share one product config"
+        );
+    }
+
+    #[test]
+    fn production_bootstrap_embeds_the_carrier_and_rejects_manifest_mismatch() {
+        let aps = IntegrationConfigsV1::new(vec![("aps", serde_json::json!({}))])
+            .expect("APS browser projection should be admitted");
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "aps"],
+                integration_configs: &aps,
+                auction_projection_json: VALID_BROWSER_AUCTION_PROJECTION_JSON,
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            PERFORMANCE_ORIGIN,
+        )
+        .expect("matching carrier and manifest should serialize");
+        let transport = bootstrap_transport(&script);
+        assert_eq!(
+            transport
+                .as_object()
+                .map(|record| record.keys().cloned().collect::<Vec<_>>()),
+            Some(vec![
+                "boot".to_owned(),
+                "integrity".to_owned(),
+                "outline".to_owned(),
+                "version".to_owned(),
+            ]),
+            "production transport must have one exact four-key root"
+        );
+        assert!(transport["integrity"]["projectionDigest"].is_string());
+        assert!(transport["integrity"]["integrationConfigDigest"].is_string());
+        assert!(transport["outline"].is_null());
+        assert!(!script.contains("__TSJS_SERVER_BOOT_INPUT_V1__"));
+        assert!(!script.contains(r#""target""#));
+        assert!(
+            transport["boot"]["integrations"]
+                == serde_json::json!({"version":1,"entries":[{"id":"aps","config":{}}]}),
+            "boot must contain the sole typed integration carrier: {script}"
+        );
+
+        assert!(
+            tsjs_bootstrap_fragment_v1(
+                TsjsBootScriptConfigV1 {
+                    module_ids: &["render_runtime", "aps"],
+                    integration_configs: &IntegrationConfigsV1::empty(),
+                    auction_projection_json: VALID_BROWSER_AUCTION_PROJECTION_JSON,
+                    creative: CreativeBootConfigV1 {
+                        enabled: false,
+                        click_guard: false,
+                        render_guard: false,
+                    },
+                    render_trace_overlay: false,
+                    gpt_diagnostics_active: false,
+                },
+                PERFORMANCE_ORIGIN,
+            )
+            .is_err(),
+            "HTML emission must reject manifest/config mismatch"
+        );
+    }
+
+    #[test]
+    fn production_bootstrap_applies_one_validated_nonce_to_both_script_tags() {
+        let configs = IntegrationConfigsV1::new(vec![("aps", serde_json::json!({}))])
+            .expect("APS browser projection should be admitted");
+        let config = || TsjsBootScriptConfigV1 {
+            module_ids: &["render_runtime", "aps"],
+            integration_configs: &configs,
+            auction_projection_json: VALID_BROWSER_AUCTION_PROJECTION_JSON,
+            creative: CreativeBootConfigV1 {
+                enabled: false,
+                click_guard: false,
+                render_guard: false,
+            },
+            render_trace_overlay: false,
+            gpt_diagnostics_active: false,
+        };
+
+        let script = tsjs_bootstrap_fragment_with_nonce_v1(
+            config(),
+            PERFORMANCE_ORIGIN,
+            Some("response-nonce_123="),
+        )
+        .expect("a bounded CSP base64-value should be admitted");
+        assert_eq!(script.matches(r#" nonce="response-nonce_123=""#).count(), 2);
+        assert_eq!(script.matches("<script").count(), 2);
+
+        for invalid in ["", "contains space", r#"quote\""#, "semicolon;"] {
+            assert!(
+                tsjs_bootstrap_fragment_with_nonce_v1(config(), PERFORMANCE_ORIGIN, Some(invalid),)
+                    .is_err(),
+                "invalid nonce text must fail closed: {invalid:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn production_bootstrap_centrally_escapes_integration_config_markup() {
+        let configs = IntegrationConfigsV1::new(vec![(
+            "prebid",
+            serde_json::json!({
+                "accountId": "</ScRiPt><script>&",
+                "timeout": 1_000,
+                "debug": false,
+                "bidders": [],
+            }),
+        )])
+        .expect("Prebid browser projection should be admitted");
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "prebid"],
+                integration_configs: &configs,
+                auction_projection_json: VALID_BROWSER_AUCTION_PROJECTION_JSON,
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            PERFORMANCE_ORIGIN,
+        )
+        .expect("valid integration config should serialize inside boot");
+
+        assert!(!script.contains("</ScRiPt><script>&"));
+        assert!(script.contains(r#"\u003c/ScRiPt\u003e\u003cscript\u003e\u0026"#));
+    }
+
+    fn projection_with_adm(adm: &str) -> String {
+        use crate::auction::types::{
+            AdmRenderSourceV1, AuctionDecisionSetV1, BidRenderSourceV1, BrowserAuctionBidV1,
+            BrowserAuctionProjectionV1, BrowserAuctionSlotV1, SlotAuctionDecisionV1,
+        };
+
+        serde_json::to_string(&BrowserAuctionProjectionV1 {
+            version: 1,
+            auction: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "initial".to_string(),
+                results: vec![SlotAuctionDecisionV1::Winner {
+                    slot: "slot-1".to_string(),
+                    candidate_id: "AAAAAAAAAAAA".to_string(),
+                }],
+            },
+            slots: vec![BrowserAuctionSlotV1 {
+                slot: "slot-1".to_string(),
+                gam_unit_path: "/123/slot-1".to_string(),
+                div_id: "slot-1".to_string(),
+                formats: vec![[300, 250]],
+                targeting: Default::default(),
+            }],
+            bids: vec![BrowserAuctionBidV1 {
+                candidate_id: "AAAAAAAAAAAA".to_string(),
+                slot: "slot-1".to_string(),
+                provider: "test".to_string(),
+                upstream_bid_id: "bid-1".to_string(),
+                cpm: 1.0,
+                currency: "USD".to_string(),
+                targeting: Default::default(),
+                renderer_reservation_id: Some("r1_aaaaaaaaaaaaaaaaaaaaaa".to_string()),
+                render_source: BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+                    version: 1,
+                    adm: adm.to_string(),
+                    width: 300,
+                    height: 250,
+                }),
+            }],
+        })
+        .expect("should serialize a canonical ADM projection")
+    }
+
+    #[test]
+    fn first_display_outline_binds_the_canonical_integration_config_digest() {
+        let configs = IntegrationConfigsV1::new(vec![(
+            "gpt",
+            serde_json::json!({
+                "gamAttributionEnabled": false,
+                "pageBidsEnabled": false,
+            }),
+        )])
+        .expect("GPT browser config should be admitted");
+        let canonical = serde_json::to_string(&configs).expect("carrier should serialize");
+        let expected_digest = hex::encode(Sha256::digest(canonical.as_bytes()));
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "gpt"],
+                integration_configs: &configs,
+                auction_projection_json: &projection_with_adm("<main>ad</main>"),
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            "https://publisher.example",
+        )
+        .expect("first-display bootstrap should serialize");
+
+        assert!(
+            bootstrap_transport(&script)["integrity"]["integrationConfigDigest"].as_str()
+                == Some(expected_digest.as_str()),
+            "outline must bind the exact canonical carrier: {script}"
+        );
+        assert_eq!(
+            bootstrap_transport(&script)["outline"]["integrationConfigDigest"],
+            expected_digest,
+            "outline must copy the always-present integrity value"
+        );
+    }
+
+    #[test]
+    fn production_bootstrap_selects_gpt_initial_for_attribution_without_a_winner() {
+        let configs = IntegrationConfigsV1::new(vec![(
+            "gpt",
+            serde_json::json!({
+                "gamAttributionEnabled": true,
+                "pageBidsEnabled": false,
+            }),
+        )])
+        .expect("GPT browser config should be admitted");
+        let projection = serde_json::to_string(&first_display_projection(None))
+            .expect("no-bid projection should serialize");
+
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "gpt"],
+                integration_configs: &configs,
+                auction_projection_json: &projection,
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            "https://publisher.example",
+        )
+        .expect("attribution-only first-display bootstrap should serialize");
+
+        assert!(
+            bootstrap_transport(&script)["boot"]["manifest"]["firstDisplay"]["slices"]
+                == serde_json::json!(["first_display", "gpt_initial"]),
+            "typed GAM attribution must select the GPT parser-time owner: {script}"
+        );
+        assert!(
+            script.contains("m=0081"),
+            "attribution-only first display must use the admitted GPT mask: {script}"
+        );
+    }
 
     fn hash_query_value(src: &str) -> &str {
         src.split_once("?v=")
@@ -121,6 +1756,158 @@ mod tests {
         );
     }
 
+    #[test]
+    fn release_id_is_shared_by_generated_metadata_and_every_bundle() {
+        let release = release_id();
+
+        assert_eq!(release.len(), 64, "should be one SHA-256 release id");
+        assert!(
+            release
+                .chars()
+                .all(|character| character.is_ascii_digit() || ('a'..='f').contains(&character)),
+            "should use lowercase hexadecimal"
+        );
+        for id in trusted_server_js::all_module_ids() {
+            let bundle = trusted_server_js::module_bundle(id).expect("should include known module");
+            assert_eq!(
+                bundle.matches(release).count(),
+                1,
+                "module {id} should carry the shared release id exactly once"
+            );
+        }
+    }
+
+    #[test]
+    fn production_bootstrap_keeps_deferred_modules_out_of_html_script_tags() {
+        let controller = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &[
+                    "render_runtime",
+                    "gpt",
+                    "diagnostics_presentation",
+                    "gpt_later",
+                ],
+                integration_configs: &IntegrationConfigsV1::new(vec![(
+                    "gpt",
+                    serde_json::json!({
+                        "gamAttributionEnabled": false,
+                        "pageBidsEnabled": false,
+                    }),
+                )])
+                .expect("GPT browser config should be admitted"),
+                auction_projection_json: VALID_BROWSER_AUCTION_PROJECTION_JSON,
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: true,
+                gpt_diagnostics_active: false,
+            },
+            PERFORMANCE_ORIGIN,
+        )
+        .expect("should serialize the production bootstrap");
+
+        assert_eq!(
+            bootstrap_transport(&controller)["boot"]["manifest"]["runtimeSrc"],
+            format!(
+                "/static/tsjs=tsjs-unified.min.js?v={}",
+                concatenated_hash(&["render_runtime", "gpt"])
+            ),
+            "should carry the exact runtime artifact source in BootManifestV1"
+        );
+        assert!(
+            controller.ends_with(&format!(
+                r#"<script src="/static/tsjs=tsjs-unified.min.js?v={}" id="trustedserver-js"></script>"#,
+                concatenated_hash(&["render_runtime", "gpt"])
+            )),
+            "should emit exactly one runtime script tag"
+        );
+        assert!(
+            controller.matches("<script").count() == 2
+                && !controller
+                    .contains(r#"<script src="/static/tsjs=tsjs-diagnostics_presentation"#)
+                && !controller.contains(r#"<script src="/static/tsjs=tsjs-gpt_later"#),
+            "deferred modules must be present only in the manifest, not parser-time tags"
+        );
+    }
+
+    #[test]
+    fn production_bootstrap_rejects_diagnostics_mismatch_and_escapes_projection_markup() {
+        let mismatched = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "creative"],
+                integration_configs: &IntegrationConfigsV1::empty(),
+                auction_projection_json: r#"{"version":1,"auction":{"version":1,"auctionId":"initial","results":[]},"slots":[],"bids":[]}"#,
+                creative: CreativeBootConfigV1 {
+                    enabled: true,
+                    click_guard: true,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: true,
+            },
+            "https://publisher.example",
+        );
+        assert!(
+            mismatched.is_err(),
+            "should reject an active diagnostics bit without its module"
+        );
+
+        let projection = projection_with_adm("</ScRiPt><script>&");
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime", "creative"],
+                integration_configs: &IntegrationConfigsV1::empty(),
+                auction_projection_json: &projection,
+                creative: CreativeBootConfigV1 {
+                    enabled: true,
+                    click_guard: true,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            "https://publisher.example",
+        )
+        .expect("should escape valid projection JSON");
+        assert!(!script.contains("</ScRiPt><script>&"));
+        assert!(script.contains(r#"\u003c/ScRiPt\u003e\u003cscript\u003e\u0026"#));
+    }
+
+    #[test]
+    fn production_boot_rejects_a_noncanonical_browser_projection() {
+        let script = tsjs_bootstrap_fragment_v1(
+            TsjsBootScriptConfigV1 {
+                module_ids: &["render_runtime"],
+                integration_configs: &IntegrationConfigsV1::empty(),
+                auction_projection_json: r#"{"version":1,"auction":{"version":1,"auctionId":"initial","results":[]},"slots":[],"bids":[],"unexpected":true}"#,
+                creative: CreativeBootConfigV1 {
+                    enabled: false,
+                    click_guard: false,
+                    render_guard: false,
+                },
+                render_trace_overlay: false,
+                gpt_diagnostics_active: false,
+            },
+            "https://publisher.example",
+        );
+
+        assert!(
+            script.is_err(),
+            "production boot must enforce the same canonical projection contract as fixtures"
+        );
+    }
+
+    #[test]
+    fn inline_script_json_escaping_is_byte_exact_for_every_guarded_character() {
+        assert_eq!(
+            escape_json_for_inline_script("plain &<>\u{2028}\u{2029} tail"),
+            r"plain \u0026\u003c\u003e\u2028\u2029 tail",
+            "should preserve plain UTF-8 while escaping every script-significant character"
+        );
+    }
+
     #[test]
     fn tsjs_script_src_formats_unified_bundle_url_with_hash() {
         let src = tsjs_script_src(&["creative"]);
@@ -203,112 +1990,120 @@ mod tests {
     }
 
     #[test]
-    fn publisher_tsjs_script_tag_renders_static_attributes() {
-        let module_ids = ["gpt"];
-        let src = tsjs_script_src(&module_ids);
+    fn creative_bootstrap_uses_only_the_required_takeover_modules() {
+        let settings = crate::test_support::tests::create_test_settings();
+        let bootstrap = creative_tsjs_bootstrap_v1(&settings)
+            .expect("should build the creative bootstrap")
+            .expect("the default creative integration should be enabled");
+        let expected_src = tsjs_script_src(&["render_runtime", "creative"]);
 
+        assert!(bootstrap.contains("__TSJS_SERVER_BOOT_TRANSPORT_V1__"));
+        assert!(!bootstrap.contains("__TSJS_SERVER_BOOT_INPUT_V1__"));
+        let transport = bootstrap_transport(&bootstrap);
         assert_eq!(
-            tsjs_script_tag_with_attributes(&module_ids, &[("data-ts-gam-attribution", "true")]),
-            format!(
-                "<script src=\"{src}\" id=\"trustedserver-js\" data-ts-gam-attribution=\"true\"></script>"
-            ),
-            "should render trusted static attributes on the publisher bundle tag"
+            transport["boot"]["manifest"]["integrations"],
+            serde_json::json!([
+                {"id":"render_runtime","phase":"takeover"},
+                {"id":"creative","phase":"takeover"}
+            ]),
+            "{bootstrap}"
         );
-        assert_eq!(
-            tsjs_script_tag(&module_ids),
-            format!("<script src=\"{src}\" id=\"trustedserver-js\"></script>"),
-            "should keep the generic tag byte-for-byte unmarked"
+        assert!(
+            bootstrap.contains(&format!(r#"src="{expected_src}""#)),
+            "{bootstrap}"
+        );
+        assert_eq!(bootstrap.matches("id=\"trustedserver-js\"").count(), 1);
+        assert!(
+            transport["boot"]["manifest"]["integrations"]
+                .as_array()
+                .is_some_and(|entries| entries.iter().all(|entry| entry["id"] != "gpt"))
+        );
+        assert!(
+            transport["boot"]["manifest"]["integrations"]
+                .as_array()
+                .is_some_and(|entries| entries.iter().all(|entry| entry["phase"] != "deferred"))
         );
     }
 
     #[test]
-    #[should_panic(
-        expected = "attribute name should contain only lowercase ASCII letters, digits, and hyphens"
-    )]
-    fn publisher_tsjs_script_tag_rejects_invalid_attribute_name() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("data-bad_name", "true")]);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "attribute name should contain only lowercase ASCII letters, digits, and hyphens"
-    )]
-    fn publisher_tsjs_script_tag_rejects_empty_attribute_name() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("", "true")]);
-    }
-
-    #[test]
-    #[should_panic(expected = "attribute value should not contain HTML-sensitive characters")]
-    fn publisher_tsjs_script_tag_rejects_double_quote_in_attribute_value() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("data-safe-name", "bad\"value")]);
-    }
-
-    #[test]
-    #[should_panic(expected = "attribute value should not contain HTML-sensitive characters")]
-    fn publisher_tsjs_script_tag_rejects_ampersand_in_attribute_value() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("data-safe-name", "bad&value")]);
-    }
-
-    #[test]
-    #[should_panic(expected = "attribute value should not contain HTML-sensitive characters")]
-    fn publisher_tsjs_script_tag_rejects_less_than_in_attribute_value() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("data-safe-name", "bad<value")]);
-    }
+    fn creative_bootstrap_is_absent_when_both_guards_are_disabled() {
+        let mut settings = crate::test_support::tests::create_test_settings();
+        settings
+            .integrations
+            .insert_config(
+                "creative",
+                &serde_json::json!({
+                    "enabled": true,
+                    "click_guard": false,
+                    "render_guard": false,
+                }),
+            )
+            .expect("should configure creative browser policy");
 
-    #[test]
-    #[should_panic(expected = "attribute value should not contain HTML-sensitive characters")]
-    fn publisher_tsjs_script_tag_rejects_greater_than_in_attribute_value() {
-        let _ = tsjs_script_tag_with_attributes(&["gpt"], &[("data-safe-name", "bad>value")]);
+        assert_eq!(
+            creative_tsjs_bootstrap_v1(&settings)
+                .expect("should resolve the creative bootstrap policy"),
+            None,
+            "zero browser work must not inject a runtime into creative HTML"
+        );
     }
 
     #[test]
-    fn tsjs_unified_helpers_use_unversioned_fallback_without_registry() {
-        let src = tsjs_unified_script_src();
-
-        assert_eq!(
-            src, "/static/tsjs=tsjs-unified.min.js",
-            "registry-free unified helper should not emit an unverifiable hash"
-        );
-        assert_eq!(
-            tsjs_unified_script_tag(),
-            format!(r#"<script src="{src}" id="trustedserver-js"></script>"#),
-            "should wrap the registry-free unified source"
+    fn production_bootstrap_accepts_enabled_creative_with_no_guards_and_no_module() {
+        assert!(
+            tsjs_bootstrap_fragment_v1(
+                TsjsBootScriptConfigV1 {
+                    module_ids: &["render_runtime"],
+                    integration_configs: &IntegrationConfigsV1::empty(),
+                    auction_projection_json: EMPTY_CREATIVE_AUCTION_PROJECTION_JSON,
+                    creative: CreativeBootConfigV1 {
+                        enabled: true,
+                        click_guard: false,
+                        render_guard: false,
+                    },
+                    render_trace_overlay: false,
+                    gpt_diagnostics_active: false,
+                },
+                "https://publisher.example"
+            )
+            .is_ok(),
+            "creative membership is required only when a guard has browser work"
         );
     }
 
     #[test]
     fn tsjs_single_module_script_src_formats_known_module_url_with_hash() {
-        let src = tsjs_single_module_script_src("creative");
+        let src =
+            tsjs_single_module_script_src("prebid_later").expect("should name a deferred module");
 
         assert!(
-            src.starts_with("/static/tsjs=tsjs-creative.min.js?v="),
+            src.starts_with("/static/tsjs=tsjs-prebid_later.min.js?v="),
             "should use per-module static bundle path"
         );
         assert_sha256_hex_hash(hash_query_value(&src));
+        assert_eq!(tsjs_single_module_script_src("creative"), None);
     }
 
     #[test]
-    fn tsjs_deferred_script_src_hashes_prebid_shim_and_empties_unknown_module() {
-        let prebid_src = tsjs_deferred_script_src("prebid");
+    fn tsjs_deferred_script_src_hashes_only_catalogued_deferred_modules() {
+        let prebid_src =
+            tsjs_deferred_script_src("prebid_later").expect("should name Prebid later slice");
         assert!(
-            prebid_src.starts_with("/static/tsjs=tsjs-prebid.min.js?v="),
-            "prebid shim should be served from the deferred tsjs route"
+            prebid_src.starts_with("/static/tsjs=tsjs-prebid_later.min.js?v="),
+            "Prebid later slice should use the deferred TSJS route"
         );
         assert_sha256_hex_hash(hash_query_value(&prebid_src));
-        assert_eq!(
-            tsjs_deferred_script_src("unknown-module"),
-            "/static/tsjs=tsjs-unknown-module.min.js?v=",
-            "should document current unknown-module hash behavior"
-        );
+        assert_eq!(tsjs_deferred_script_src("unknown-module"), None);
+        assert_eq!(tsjs_deferred_script_src("prebid"), None);
     }
 
     #[test]
     fn tsjs_deferred_script_tag_marks_script_defer() {
-        let src = tsjs_deferred_script_src("prebid");
+        let src = tsjs_deferred_script_src("prebid_later").expect("should name Prebid later slice");
 
         assert_eq!(
-            tsjs_deferred_script_tag("prebid"),
-            format!("<script src=\"{src}\" defer></script>"),
+            tsjs_deferred_script_tag("prebid_later"),
+            Some(format!("<script src=\"{src}\" defer></script>")),
             "should generate a deferred script tag"
         );
     }
@@ -325,11 +2120,12 @@ mod tests {
     #[test]
     fn tsjs_deferred_script_tags_preserves_input_order() {
         assert_eq!(
-            tsjs_deferred_script_tags(&["prebid", "creative"]),
+            tsjs_deferred_script_tags(&["prebid_later", "sourcepoint_lifecycle"]),
             format!(
                 "{}{}",
-                tsjs_deferred_script_tag("prebid"),
-                tsjs_deferred_script_tag("creative")
+                tsjs_deferred_script_tag("prebid_later").expect("should build Prebid tag"),
+                tsjs_deferred_script_tag("sourcepoint_lifecycle")
+                    .expect("should build Sourcepoint tag")
             ),
             "should preserve caller-provided deferred module order"
         );
@@ -351,20 +2147,331 @@ mod tests {
     }
 
     #[test]
-    fn tsjs_script_src_differs_for_different_module_sets() {
-        assert_ne!(
-            tsjs_script_src(&["lockr"]),
-            tsjs_script_src(&["lockr", "permutive"]),
-            "should bust the cache when the module set content changes"
+    fn tsjs_deferred_script_src_rejects_unknown_module() {
+        assert_eq!(tsjs_deferred_script_src("does-not-exist"), None);
+    }
+
+    fn first_display_projection(source: Option<BidRenderSourceV1>) -> BrowserAuctionProjectionV1 {
+        use crate::auction::types::{
+            AuctionDecisionSetV1, BrowserAuctionBidV1, BrowserAuctionSlotV1, SlotAuctionDecisionV1,
+        };
+
+        let slot = BrowserAuctionSlotV1 {
+            slot: "slot-1".to_string(),
+            gam_unit_path: "/123/home".to_string(),
+            div_id: "div-1".to_string(),
+            formats: vec![[300, 250]],
+            targeting: std::collections::BTreeMap::new(),
+        };
+        let (results, bids) = source.map_or_else(
+            || {
+                (
+                    vec![SlotAuctionDecisionV1::NoBid {
+                        slot: "slot-1".to_string(),
+                    }],
+                    vec![],
+                )
+            },
+            |render_source| {
+                (
+                    vec![SlotAuctionDecisionV1::Winner {
+                        slot: "slot-1".to_string(),
+                        candidate_id: "candidate-1".to_string(),
+                    }],
+                    vec![BrowserAuctionBidV1 {
+                        candidate_id: "candidate-1".to_string(),
+                        slot: "slot-1".to_string(),
+                        provider: "prebid".to_string(),
+                        upstream_bid_id: "bid-1".to_string(),
+                        cpm: 1.0,
+                        currency: "USD".to_string(),
+                        targeting: std::collections::BTreeMap::new(),
+                        renderer_reservation_id: match render_source {
+                            BidRenderSourceV1::Aps(_) | BidRenderSourceV1::Adm(_) => {
+                                Some("r1_aaaaaaaaaaaaaaaaaaaaaa".to_string())
+                            }
+                            BidRenderSourceV1::PbsCache(_) => None,
+                        },
+                        render_source,
+                    }],
+                )
+            },
         );
+        BrowserAuctionProjectionV1 {
+            version: 1,
+            auction: AuctionDecisionSetV1 {
+                version: 1,
+                auction_id: "initial".to_string(),
+                results,
+            },
+            slots: vec![slot],
+            bids,
+        }
+    }
+
+    fn adm_source() -> BidRenderSourceV1 {
+        use crate::auction::types::AdmRenderSourceV1;
+        BidRenderSourceV1::Adm(AdmRenderSourceV1 {
+            version: 1,
+            adm: "<div>creative</div>".to_string(),
+            width: 300,
+            height: 250,
+        })
+    }
+
+    fn aps_source() -> BidRenderSourceV1 {
+        use crate::auction::types::{ApsRendererV1, ApsTagType};
+        BidRenderSourceV1::Aps(ApsRendererV1 {
+            version: 1,
+            account_id: "account-1".to_string(),
+            bid_id: "bid-1".to_string(),
+            creative_id: None,
+            tag_type: ApsTagType::Iframe,
+            creative_url: "https://creative.example/render".to_string(),
+            aax_response: "envelope".to_string(),
+            width: 300,
+            height: 250,
+        })
+    }
+
+    fn cache_source() -> BidRenderSourceV1 {
+        use crate::auction::types::BaselinePbsCacheSourceV1;
+        BidRenderSourceV1::PbsCache(BaselinePbsCacheSourceV1 {
+            version: 1,
+            cache_id: "cache-1".to_string(),
+            cache_host: "cache.example".to_string(),
+            cache_path: "/cache".to_string(),
+            width: 300,
+            height: 250,
+        })
     }
 
     #[test]
-    fn tsjs_deferred_script_src_has_empty_hash_for_unknown_module() {
+    fn first_display_selection_admits_only_the_closed_projected_batch() {
+        let no_bid = first_display_projection(None);
+        let adm = first_display_projection(Some(adm_source()));
+        let enabled = ["gpt"];
+
+        let no_bid_selected = select_first_display_slices_v1(
+            &no_bid,
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &enabled,
+                creative: CreativeBootConfigV1::default(),
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("closed no-bid batch should select the base agent");
+        assert_eq!(no_bid_selected.mask(), 0x0001);
+        assert_eq!(no_bid_selected.slices(), &["first_display"]);
+
+        let adm_selected = select_first_display_slices_v1(
+            &adm,
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &enabled,
+                creative: CreativeBootConfigV1::default(),
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("closed GPT ADM batch should select GPT initial ownership");
+        assert_eq!(adm_selected.mask(), 0x0083);
         assert_eq!(
-            tsjs_deferred_script_src("does-not-exist"),
-            "/static/tsjs=tsjs-does-not-exist.min.js?v=",
-            "should fall back to an empty cache-busting hash for an unknown module"
+            adm_selected.slices(),
+            &["first_display", "render_owner_initial", "gpt_initial"]
+        );
+
+        for invalid in [None, Some("not-a-reservation".to_string())] {
+            let mut malformed = adm.clone();
+            malformed.bids[0].renderer_reservation_id = invalid;
+            assert!(
+                select_first_display_slices_v1(
+                    &malformed,
+                    FirstDisplaySelectionConfigV1 {
+                        enabled_integrations: &enabled,
+                        creative: CreativeBootConfigV1::default(),
+                        gam_attribution_enabled: false,
+                    },
+                )
+                .is_none(),
+                "a rendering mask must require one exact reservation capability"
+            );
+        }
+
+        assert!(
+            select_first_display_slices_v1(
+                &first_display_projection(Some(cache_source())),
+                FirstDisplaySelectionConfigV1 {
+                    enabled_integrations: &enabled,
+                    creative: CreativeBootConfigV1::default(),
+                    gam_attribution_enabled: false,
+                },
+            )
+            .is_none(),
+            "PBS Cache must stay on the direct persistent GPT path"
+        );
+        let mut direct = no_bid.clone();
+        direct.slots.clear();
+        assert!(
+            select_first_display_slices_v1(
+                &direct,
+                FirstDisplaySelectionConfigV1 {
+                    enabled_integrations: &enabled,
+                    creative: CreativeBootConfigV1::default(),
+                    gam_attribution_enabled: false,
+                },
+            )
+            .is_none(),
+            "direct/programmatic projection must not select the agent"
+        );
+    }
+
+    #[test]
+    fn first_display_selection_derives_exact_permitted_slices_from_trusted_configuration() {
+        let creative_selected = select_first_display_slices_v1(
+            &first_display_projection(Some(adm_source())),
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &["creative", "gpt"],
+                creative: CreativeBootConfigV1 {
+                    enabled: true,
+                    click_guard: false,
+                    render_guard: true,
+                },
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("bounded creative/GPT configuration should select the agent");
+
+        assert_eq!(
+            creative_selected.slices(),
+            &[
+                "first_display",
+                "render_owner_initial",
+                "creative_initial",
+                "gpt_initial",
+            ]
+        );
+        assert_eq!(creative_selected.mask(), 0x008b);
+
+        let aps_selected = select_first_display_slices_v1(
+            &first_display_projection(Some(aps_source())),
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &["aps", "gpt"],
+                creative: CreativeBootConfigV1::default(),
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("bounded APS/GPT configuration should select the agent");
+        assert_eq!(
+            aps_selected.slices(),
+            &[
+                "first_display",
+                "render_owner_initial",
+                "aps_initial",
+                "gpt_initial",
+            ]
+        );
+        assert_eq!(aps_selected.mask(), 0x0087);
+
+        let aps_creative_selected = select_first_display_slices_v1(
+            &first_display_projection(Some(aps_source())),
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &["aps", "creative", "gpt"],
+                creative: CreativeBootConfigV1 {
+                    enabled: true,
+                    click_guard: true,
+                    render_guard: false,
+                },
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("bounded APS/creative/GPT configuration should select the agent");
+        assert_eq!(aps_creative_selected.mask(), 0x008f);
+
+        let mut prebid_projection = first_display_projection(Some(adm_source()));
+        prebid_projection.bids[0].provider = "prebid".to_owned();
+        let prebid_selected = select_first_display_slices_v1(
+            &prebid_projection,
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &["gpt", "prebid"],
+                creative: CreativeBootConfigV1::default(),
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("bounded Prebid/GPT configuration should select the agent");
+        assert_eq!(
+            prebid_selected.slices(),
+            &[
+                "first_display",
+                "render_owner_initial",
+                "gpt_initial",
+                "prebid_initial",
+            ]
+        );
+        assert_eq!(prebid_selected.mask(), 0x1083);
+    }
+
+    #[test]
+    fn first_display_selection_obeys_generated_size_admission() {
+        let enabled = [
+            "aps",
+            "creative",
+            "datadome",
+            "didomi",
+            "google_tag_manager",
+            "gpt",
+            "lockr",
+            "osano",
+            "permutive",
+            "prebid",
+            "sourcepoint",
+            "testlight",
+        ];
+        let mut projection = first_display_projection(Some(adm_source()));
+        projection.bids[0].provider = "prebid".to_owned();
+        assert!(
+            select_first_display_slices_v1(
+                &projection,
+                FirstDisplaySelectionConfigV1 {
+                    enabled_integrations: &enabled,
+                    creative: CreativeBootConfigV1 {
+                        enabled: true,
+                        click_guard: false,
+                        render_guard: true,
+                    },
+                    gam_attribution_enabled: false,
+                },
+            )
+            .is_none(),
+            "an oversized optional composition must fall through to persistent boot"
+        );
+        let selected = select_first_display_slices_v1(
+            &projection,
+            FirstDisplaySelectionConfigV1 {
+                enabled_integrations: &["creative", "gpt", "prebid"],
+                creative: CreativeBootConfigV1 {
+                    enabled: true,
+                    click_guard: false,
+                    render_guard: true,
+                },
+                gam_attribution_enabled: false,
+            },
+        )
+        .expect("the bounded owner/creative/GPT/Prebid composition should fit");
+        assert!(trusted_server_js::first_display_mask_is_permitted(
+            selected.mask()
+        ));
+
+        let unknown = ["gpt", "publisher_supplied"];
+        assert!(
+            select_first_display_slices_v1(
+                &first_display_projection(None),
+                FirstDisplaySelectionConfigV1 {
+                    enabled_integrations: &unknown,
+                    creative: CreativeBootConfigV1::default(),
+                    gam_attribution_enabled: false,
+                },
+            )
+            .is_none(),
+            "an unknown obligation must force direct persistent boot"
         );
     }
 }
diff --git a/crates/trusted-server-integration-tests/Cargo.toml b/crates/trusted-server-integration-tests/Cargo.toml
index 7477fdbd1..72afd6f21 100644
--- a/crates/trusted-server-integration-tests/Cargo.toml
+++ b/crates/trusted-server-integration-tests/Cargo.toml
@@ -17,6 +17,15 @@ name = "parity"
 path = "tests/parity.rs"
 harness = true
 
+[[test]]
+name = "aps_runner_proxy"
+path = "tests/aps_runner_proxy.rs"
+harness = true
+required-features = ["aps-runner-proxy"]
+
+[features]
+aps-runner-proxy = []
+
 [lints]
 workspace = true
 
@@ -24,7 +33,7 @@ workspace = true
 edgezero-core = { workspace = true }
 serde_json = { workspace = true }
 toml = { workspace = true }
-trusted-server-core = { workspace = true }
+trusted-server-core = { workspace = true, features = ["test-utils"] }
 
 [dev-dependencies]
 axum = { workspace = true }
@@ -40,9 +49,10 @@ log = { workspace = true }
 reqwest = { workspace = true, features = ["blocking", "cookies"] }
 scraper = { workspace = true }
 testcontainers = { workspace = true }
+tempfile = { 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" }
+trusted-server-adapter-axum = { path = "../trusted-server-adapter-axum", features = ["aps-runner-proxy-integration-test"] }
+trusted-server-adapter-cloudflare = { path = "../trusted-server-adapter-cloudflare", features = ["aps-runner-proxy-integration-test"] }
+trusted-server-adapter-spin = { path = "../trusted-server-adapter-spin", features = ["aps-runner-proxy-integration-test"] }
 urlencoding = { workspace = true }
diff --git a/crates/trusted-server-integration-tests/README.md b/crates/trusted-server-integration-tests/README.md
index e82cb8837..e5b6cc9fd 100644
--- a/crates/trusted-server-integration-tests/README.md
+++ b/crates/trusted-server-integration-tests/README.md
@@ -7,7 +7,7 @@ containers using [Testcontainers](https://testcontainers.com/) and
 ## Prerequisites
 
 - **Docker** — running and accessible
-- **Viceroy** — Fastly local simulator (`cargo install viceroy --version 0.17.0 --locked --force`)
+- **Viceroy** — Fastly local simulator (`cargo install viceroy --version 0.19.0 --locked --force`)
 - **wasm32-wasip1 target** — `rustup target add wasm32-wasip1`
 - **Node.js** — version pinned in `.tool-versions`, for browser tests only
 
diff --git a/crates/trusted-server-integration-tests/browser/fixtures/fictional-aps-runner.js b/crates/trusted-server-integration-tests/browser/fixtures/fictional-aps-runner.js
new file mode 100644
index 000000000..750d51a01
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/fixtures/fictional-aps-runner.js
@@ -0,0 +1,110 @@
+// Fictional hermetic APS runner fixture.
+// This implements only Trusted Server's documented queue/callback test shape.
+// It is not copied, transformed, or derived from APS runner bytes.
+(function () {
+  "use strict";
+
+  if (!(window._aps instanceof Map)) return;
+  window._aps.forEach(function (account) {
+    if (!account || !Array.isArray(account.queue)) return;
+    account.queue.splice(0).forEach(function (event) {
+      var detail = event && event.detail;
+      var keys = detail && Object.getOwnPropertyNames(detail).sort();
+      if (
+        !detail ||
+        JSON.stringify(keys) !==
+          JSON.stringify([
+            "aaxResponse",
+            "reject",
+            "resolve",
+            "seatBidId",
+            "source",
+          ]) ||
+        detail.source !== "internal" ||
+        typeof detail.resolve !== "function" ||
+        typeof detail.reject !== "function"
+      ) {
+        if (detail && typeof detail.reject === "function") {
+          detail.reject(new Error("fictional_detail_invalid"));
+        }
+        return;
+      }
+
+      window.setTimeout(function () {
+        var bidId = detail.seatBidId;
+        if (bidId.indexOf("silent-") === 0) return;
+        if (bidId.indexOf("reject-") === 0) {
+          detail.reject(new Error("fictional_rejection"));
+          return;
+        }
+        if (bidId.indexOf("deferred-") === 0) {
+          window.__fictionalApsResolve = function () {
+            delete window.__fictionalApsResolve;
+            detail.resolve();
+          };
+          return;
+        }
+        var decoded;
+        var bid;
+        try {
+          decoded = JSON.parse(atob(detail.aaxResponse));
+          bid = decoded.seatbid[0].bid[0];
+        } catch (_error) {
+          detail.reject(new Error("fictional_envelope_invalid"));
+          return;
+        }
+        if (bidId.indexOf("nested-") === 0) {
+          var frame = document.createElement("iframe");
+          frame.setAttribute("data-fictional-creative", "nested");
+          frame.setAttribute("sandbox", "allow-scripts");
+          frame.setAttribute("width", String(bid.w));
+          frame.setAttribute("height", String(bid.h));
+          frame.style.border = "0";
+          frame.style.display = "block";
+          frame.style.width = String(bid.w) + "px";
+          frame.style.height = String(bid.h) + "px";
+          frame.style.margin = "0";
+          frame.style.overflow = "hidden";
+          frame.srcdoc =
+            "<!doctype html><style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}</style><script>parent.postMessage({message:'fictional-nested-ready'},'*')<\/script>";
+          frame.onload = function () {
+            detail.resolve();
+          };
+          document.body.appendChild(frame);
+          return;
+        }
+        if (bidId.indexOf("creative-") === 0) {
+          var creative = document.createElement(bid.ext.tagtype);
+          creative.setAttribute("data-fictional-creative", bid.ext.tagtype);
+          creative.onload = function () {
+            detail.resolve();
+          };
+          creative.onerror = function () {
+            detail.reject(new Error("fictional_creative_load_failed"));
+          };
+          if (bid.ext.tagtype === "iframe") {
+            creative.setAttribute("width", String(bid.w));
+            creative.setAttribute("height", String(bid.h));
+            creative.style.border = "0";
+            creative.style.display = "block";
+            creative.style.width = String(bid.w) + "px";
+            creative.style.height = String(bid.h) + "px";
+            creative.style.margin = "0";
+            creative.style.overflow = "hidden";
+          }
+          creative.src =
+            bidId.indexOf("creative-cross-origin-") === 0
+              ? "https://redirect.example/final.js"
+              : bid.ext.creativeurl;
+          document.body.appendChild(creative);
+          return;
+        }
+        detail.resolve();
+        if (bidId.indexOf("duplicate-") === 0) {
+          detail.resolve();
+          detail.reject(new Error("fictional_duplicate_rejection"));
+        }
+      }, 50);
+    });
+  });
+})();
diff --git a/crates/trusted-server-integration-tests/browser/helpers/gam-test-network.ts b/crates/trusted-server-integration-tests/browser/helpers/gam-test-network.ts
new file mode 100644
index 000000000..5b7802f42
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/helpers/gam-test-network.ts
@@ -0,0 +1,1525 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  expect,
+  type ConsoleMessage,
+  type ElementHandle,
+  type Frame,
+  type Page,
+  type Request,
+  type TestInfo,
+} from "@playwright/test";
+
+type BrowserName = "chromium" | "firefox" | "webkit";
+
+const RELEASE_ID_PATTERN = /^[0-9a-f]{64}$/u;
+const APS_RENDERER_PATH = "/integrations/aps/renderer/v2";
+const APS_RUNNER_PATH = "/integrations/aps/runner.js";
+const EVIDENCE_ROOT = resolve(__dirname, "../real-gam-evidence");
+const TERMINAL_STATE = "terminal";
+const WIDTH = 300;
+const HEIGHT = 250;
+
+export const REAL_GAM_PUC_RELEASE = "1.17.2";
+
+const PROTOCOL_MESSAGES = [
+  "Prebid Request",
+  "Prebid Response",
+  "TS Render Owner Register",
+  "TS Render Owner Registered",
+  "TS Render Owner Refused",
+  "TS APS Top Mount Started",
+  "TS ADM Start",
+  "TS Owner Inserted",
+  "TS Owner Settled",
+  "TS ADM Loaded",
+  "TS ADM Failed",
+  "TS APS Document Accepted",
+  "TS APS Runner Loaded",
+  "TS APS Render Completed",
+  "TS APS Render Failed",
+] as const;
+
+const GPT_EVENT_NAMES = [
+  "slotRequested",
+  "slotResponseReceived",
+  "slotRenderEnded",
+  "slotOnload",
+  "impressionViewable",
+  "slotVisibilityChanged",
+] as const;
+
+type RealGamOutcome = "accepted" | "failed";
+type ExpectedReason =
+  | "bridge_id_mismatch"
+  | "descriptor_invalid"
+  | "bridge_claim_timeout"
+  | "owner_registration_timeout"
+  | "renderer_document_no_load"
+  | "runner_failed";
+
+interface LifecycleCounts {
+  readonly creativeRequests: number;
+  readonly bridgeClaims: number;
+  readonly rendererFrames: number;
+  readonly runnerLoads: number;
+  readonly renderCompletions: number;
+  readonly acceptedResults: number;
+  readonly duplicateRenders: number;
+  readonly ownedFrames: number;
+  readonly childRenders: number;
+  readonly oldAttemptMutations: number;
+}
+
+interface OrderingExpectation {
+  readonly parentTerminalBeforeChild: boolean;
+}
+
+export interface RealGamCaseContract {
+  readonly caseId: string;
+  readonly flow: string;
+  readonly outcome: RealGamOutcome;
+  readonly reason: ExpectedReason | null;
+  readonly deadlineMs: number;
+  readonly dimensions: Readonly<{ width: number; height: number }> | null;
+  readonly slotCount: number;
+  readonly gptCycles: number;
+  readonly pucOwners: number;
+  readonly terminalRendererFrames: number;
+  readonly terminalOwnedFrames: number;
+  readonly counts: LifecycleCounts;
+  readonly ordering: OrderingExpectation | null;
+}
+
+export interface RealGamEnvironment {
+  readonly pageUrl: string;
+  readonly authorization: string;
+  readonly expectedReleaseId: string;
+}
+
+interface CaseSnapshot {
+  readonly version: 1;
+  readonly caseId: string;
+  readonly releaseId: string;
+  readonly flow: string;
+  readonly outcome: RealGamOutcome;
+  readonly reason: ExpectedReason | null;
+  readonly durationMs: number;
+  readonly dimensions: Readonly<{ width: number; height: number }> | null;
+  readonly counts: LifecycleCounts;
+  readonly ordering: Readonly<{
+    parentTerminalSequence: number;
+    childRenderSequence: number;
+  }> | null;
+}
+
+interface NetworkEvidence {
+  readonly sequence: number;
+  readonly atMs: number;
+  readonly kind:
+    | "test-page"
+    | "first-party"
+    | "gpt"
+    | "renderer"
+    | "runner-proxy"
+    | "creative"
+    | "third-party";
+  readonly method: string;
+  readonly resourceType: string;
+  status?: number;
+  failure?: boolean;
+}
+
+interface ConsoleEvidence {
+  readonly sequence: number;
+  readonly atMs: number;
+  readonly type: string;
+  readonly textBytes: number;
+  readonly textSha256: string;
+  readonly argumentCount: number;
+  readonly sourceKind: NetworkEvidence["kind"];
+}
+
+interface PageErrorEvidence {
+  readonly sequence: number;
+  readonly atMs: number;
+  readonly textBytes: number;
+  readonly textSha256: string;
+}
+
+interface ProtocolEvidence {
+  readonly message: (typeof PROTOCOL_MESSAGES)[number];
+  readonly atMs: number;
+}
+
+interface GptEvidence {
+  readonly event: (typeof GPT_EVENT_NAMES)[number];
+  readonly atMs: number;
+}
+
+interface ObserverSnapshot {
+  readonly protocol: readonly ProtocolEvidence[];
+  readonly gpt: readonly GptEvidence[];
+}
+
+interface ElementGeometry {
+  readonly role: "slot" | "puc-owner" | "owned-frame" | "renderer" | "creative";
+  readonly width: number;
+  readonly height: number;
+  readonly clientWidth: number;
+  readonly clientHeight: number;
+  readonly scrollWidth: number;
+  readonly scrollHeight: number;
+  readonly marginTop: string;
+  readonly marginRight: string;
+  readonly marginBottom: string;
+  readonly marginLeft: string;
+  readonly overflowX: string;
+  readonly overflowY: string;
+}
+
+interface DocumentGeometry {
+  readonly role:
+    "puc-owner-document" | "renderer-document" | "creative-document";
+  readonly width: number;
+  readonly height: number;
+  readonly clientWidth: number;
+  readonly clientHeight: number;
+  readonly scrollWidth: number;
+  readonly scrollHeight: number;
+  readonly bodyMarginTop: string;
+  readonly bodyMarginRight: string;
+  readonly bodyMarginBottom: string;
+  readonly bodyMarginLeft: string;
+  readonly overflowX: string;
+  readonly overflowY: string;
+}
+
+interface DomEvidence {
+  readonly terminalRoots: number;
+  readonly elements: readonly ElementGeometry[];
+  readonly documents: readonly DocumentGeometry[];
+}
+
+interface RenderTraceEvidence {
+  readonly path: "auction" | "ssat" | "gam-refresh" | null;
+  readonly rendered: boolean;
+  readonly servedFrom:
+    "inline" | "gam" | "debug-adm" | "pbs-cache" | "prebid" | null;
+  readonly gamEmpty: boolean | null;
+  readonly injected: boolean | null;
+  readonly visible: boolean | null;
+  readonly count: number;
+  readonly seq: number;
+}
+
+const ZERO_COUNTS: LifecycleCounts = Object.freeze({
+  creativeRequests: 0,
+  bridgeClaims: 0,
+  rendererFrames: 0,
+  runnerLoads: 0,
+  renderCompletions: 0,
+  acceptedResults: 0,
+  duplicateRenders: 0,
+  ownedFrames: 0,
+  childRenders: 0,
+  oldAttemptMutations: 0,
+});
+
+function counts(overrides: Partial<LifecycleCounts>): LifecycleCounts {
+  return Object.freeze({ ...ZERO_COUNTS, ...overrides });
+}
+
+function acceptedCase(
+  caseId: string,
+  options: {
+    flow?: string;
+    slots?: number;
+    cycles?: number;
+    pucOwners?: number;
+    ownedFrames?: number;
+    childRenders?: number;
+    bridgeClaims?: number;
+    ordering?: OrderingExpectation;
+    direct?: boolean;
+  } = {},
+): RealGamCaseContract {
+  const slots = options.slots ?? 1;
+  const cycles = options.cycles ?? slots;
+  const direct = options.direct ?? false;
+  const rendererCount = options.ownedFrames ? 0 : cycles;
+  return Object.freeze({
+    caseId,
+    flow: options.flow ?? caseId,
+    outcome: "accepted" as const,
+    reason: null,
+    deadlineMs: 45_000,
+    dimensions: Object.freeze({ width: WIDTH, height: HEIGHT }),
+    slotCount: slots,
+    gptCycles: direct ? 0 : cycles,
+    pucOwners: options.pucOwners ?? (direct ? 0 : slots),
+    terminalRendererFrames: rendererCount === 0 ? 0 : slots,
+    terminalOwnedFrames: options.ownedFrames ?? 0,
+    counts: counts({
+      creativeRequests: rendererCount,
+      bridgeClaims: options.bridgeClaims ?? (direct ? 0 : cycles),
+      rendererFrames: rendererCount,
+      runnerLoads: rendererCount,
+      renderCompletions: rendererCount,
+      acceptedResults: cycles,
+      ownedFrames: options.ownedFrames ?? 0,
+      childRenders: options.childRenders ?? 0,
+    }),
+    ordering: options.ordering ?? null,
+  });
+}
+
+function failedCase(
+  caseId: string,
+  reason: ExpectedReason,
+  overrides: Partial<LifecycleCounts>,
+): RealGamCaseContract {
+  return Object.freeze({
+    caseId,
+    flow: caseId,
+    outcome: "failed" as const,
+    reason,
+    deadlineMs: 15_000,
+    dimensions: null,
+    slotCount: 1,
+    gptCycles: 1,
+    pucOwners: 0,
+    terminalRendererFrames: 0,
+    terminalOwnedFrames: 0,
+    counts: counts(overrides),
+    ordering: null,
+  });
+}
+
+/**
+ * The protected page implements these fixed, non-secret case identifiers. Real GAM,
+ * APS, Prebid, and PUC configuration stays in that environment, outside this source.
+ */
+export const REAL_GAM_CASES: readonly RealGamCaseContract[] = Object.freeze([
+  acceptedCase("ssat-aps-puc"),
+  acceptedCase("trusted-server-prebid-aps-puc"),
+  acceptedCase("page-bids-aps-puc"),
+  acceptedCase("direct-aps", { direct: true }),
+  acceptedCase("direct-adm", { direct: true, ownedFrames: 1 }),
+  acceptedCase("direct-cache", { direct: true, ownedFrames: 1 }),
+  acceptedCase("attributable-empty-gam-fallback", {
+    pucOwners: 0,
+    childRenders: 1,
+    bridgeClaims: 0,
+    ordering: Object.freeze({ parentTerminalBeforeChild: true }),
+  }),
+  acceptedCase("sra-aps-puc", { slots: 2, cycles: 2, pucOwners: 2 }),
+  acceptedCase("refresh-aps-puc", { cycles: 2 }),
+  acceptedCase("spa-navigation", { cycles: 2 }),
+  acceptedCase("gpt-handoff"),
+  acceptedCase("hydrated-dom-replacement"),
+  acceptedCase("collapsed-shell-resize"),
+  failedCase("wrong-id", "bridge_id_mismatch", { bridgeClaims: 1 }),
+  failedCase("wrong-source", "bridge_id_mismatch", { bridgeClaims: 1 }),
+  failedCase("invalid-descriptor", "descriptor_invalid", { bridgeClaims: 1 }),
+  failedCase("no-outer-claim", "bridge_claim_timeout", {}),
+  failedCase("no-owner-registration", "owner_registration_timeout", {
+    bridgeClaims: 1,
+  }),
+  failedCase("no-document-ack", "renderer_document_no_load", {
+    bridgeClaims: 1,
+    rendererFrames: 1,
+  }),
+  failedCase("aps-runner-failure", "runner_failed", {
+    bridgeClaims: 1,
+    rendererFrames: 1,
+    runnerLoads: 1,
+  }),
+]);
+
+function requiredEnvironment(name: string): string {
+  const value = process.env[name];
+  if (!value)
+    throw new Error(`${name} is required for the protected real-GAM suite`);
+  if (/\r|\n/u.test(value))
+    throw new Error(`${name} must not contain line breaks`);
+  return value;
+}
+
+export function getRealGamEnvironment(): RealGamEnvironment {
+  const pageUrl = requiredEnvironment("TS_REAL_GAM_PAGE_URL");
+  const authorization = requiredEnvironment("TS_REAL_GAM_AUTH_HEADER");
+  const expectedReleaseId = requiredEnvironment(
+    "TS_REAL_GAM_EXPECTED_RELEASE_ID",
+  );
+  let parsed: URL;
+  try {
+    parsed = new URL(pageUrl);
+  } catch {
+    throw new Error("TS_REAL_GAM_PAGE_URL must be an absolute HTTPS URL");
+  }
+  if (
+    parsed.protocol !== "https:" ||
+    parsed.username !== "" ||
+    parsed.password !== "" ||
+    parsed.hash !== ""
+  ) {
+    throw new Error(
+      "TS_REAL_GAM_PAGE_URL must be HTTPS without credentials or a fragment",
+    );
+  }
+  if (!RELEASE_ID_PATTERN.test(expectedReleaseId)) {
+    throw new Error(
+      "TS_REAL_GAM_EXPECTED_RELEASE_ID must be a lowercase 64-character release id",
+    );
+  }
+  if (Buffer.byteLength(authorization, "utf8") < 16) {
+    throw new Error(
+      "TS_REAL_GAM_AUTH_HEADER must contain at least 16 UTF-8 bytes",
+    );
+  }
+  return Object.freeze({ pageUrl, authorization, expectedReleaseId });
+}
+
+function sha256(value: string): string {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+
+function elapsed(startedAt: number): number {
+  return Math.max(0, Date.now() - startedAt);
+}
+
+function safeMethod(method: string): string {
+  return /^(?:GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS)$/u.test(method)
+    ? method
+    : "OTHER";
+}
+
+function safeResourceType(resourceType: string): string {
+  return /^(?:document|stylesheet|image|media|font|script|texttrack|xhr|fetch|eventsource|websocket|manifest|other)$/u.test(
+    resourceType,
+  )
+    ? resourceType
+    : "other";
+}
+
+function parsedUrl(value: string): URL | undefined {
+  try {
+    return new URL(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function hasRendererAncestor(frame: Frame): boolean {
+  let current: Frame | null = frame;
+  while (current) {
+    const url = parsedUrl(current.url());
+    if (url?.pathname === APS_RENDERER_PATH) return true;
+    current = current.parentFrame();
+  }
+  return false;
+}
+
+export function classifyRealGamNetworkUrl(
+  rawUrl: string,
+  pageOrigin: string,
+  request?: Request,
+): NetworkEvidence["kind"] {
+  const url = parsedUrl(rawUrl);
+  if (!url) return "third-party";
+  if (url.origin === pageOrigin && url.pathname === APS_RENDERER_PATH) {
+    return "renderer";
+  }
+  if (url.origin === pageOrigin && url.pathname === APS_RUNNER_PATH) {
+    return "runner-proxy";
+  }
+  if (
+    (url.hostname === "securepubads.g.doubleclick.net" &&
+      url.pathname === "/tag/js/gpt.js") ||
+    (url.hostname === "www.googletagservices.com" &&
+      url.pathname === "/tag/js/gpt.js")
+  ) {
+    return "gpt";
+  }
+  if (request?.isNavigationRequest()) {
+    try {
+      if (hasRendererAncestor(request.frame())) return "creative";
+    } catch {
+      // A service-worker request has no associated frame.
+    }
+  }
+  if (url.origin === pageOrigin) {
+    try {
+      if (request && request.frame() === request.frame().page().mainFrame()) {
+        return "test-page";
+      }
+    } catch {
+      // Detached frames are still safely classified as first party.
+    }
+    return "first-party";
+  }
+  return "third-party";
+}
+
+async function installBrowserObservers(page: Page): Promise<void> {
+  await page.addInitScript(
+    ({ protocolMessages, gptEventNames }) => {
+      const observer = {
+        protocol: [] as Array<{ message: string; atMs: number }>,
+        gpt: [] as Array<{ event: string; atMs: number }>,
+        gptArmed: false,
+      };
+      Object.defineProperty(window, "__tsRealGamObserver", {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: observer,
+      });
+      const allowedMessages = new Set(protocolMessages);
+      window.addEventListener("message", (event) => {
+        let message: unknown;
+        try {
+          message =
+            typeof event.data === "object" && event.data !== null
+              ? Reflect.get(event.data, "message")
+              : undefined;
+        } catch {
+          return;
+        }
+        if (
+          typeof message === "string" &&
+          allowedMessages.has(message as (typeof protocolMessages)[number])
+        ) {
+          observer.protocol.push({ message, atMs: performance.now() });
+        }
+      });
+
+      const armGpt = (): boolean => {
+        if (observer.gptArmed) return true;
+        let googletag: unknown;
+        try {
+          const descriptor = Object.getOwnPropertyDescriptor(
+            window,
+            "googletag",
+          );
+          googletag =
+            descriptor && "value" in descriptor ? descriptor.value : undefined;
+        } catch {
+          return false;
+        }
+        if (typeof googletag !== "object" || googletag === null) return false;
+        let commandQueue: unknown;
+        try {
+          commandQueue = Reflect.get(googletag, "cmd");
+        } catch {
+          return false;
+        }
+        if (!Array.isArray(commandQueue)) return false;
+        commandQueue.push(() => {
+          if (observer.gptArmed) return;
+          let pubads: unknown;
+          try {
+            const method = Reflect.get(googletag as object, "pubads");
+            pubads =
+              typeof method === "function"
+                ? Reflect.apply(method, googletag, [])
+                : undefined;
+          } catch {
+            return;
+          }
+          if (typeof pubads !== "object" || pubads === null) return;
+          let addEventListener: unknown;
+          try {
+            addEventListener = Reflect.get(pubads, "addEventListener");
+          } catch {
+            return;
+          }
+          if (typeof addEventListener !== "function") return;
+          for (const eventName of gptEventNames) {
+            try {
+              Reflect.apply(addEventListener, pubads, [
+                eventName,
+                () => {
+                  observer.gpt.push({
+                    event: eventName,
+                    atMs: performance.now(),
+                  });
+                },
+              ]);
+            } catch {
+              // Unsupported informational GPT events do not weaken core event checks.
+            }
+          }
+          observer.gptArmed = true;
+        });
+        return true;
+      };
+
+      let attempts = 0;
+      const interval = window.setInterval(() => {
+        attempts += 1;
+        if (armGpt() || attempts >= 400) window.clearInterval(interval);
+      }, 25);
+      armGpt();
+    },
+    { protocolMessages: PROTOCOL_MESSAGES, gptEventNames: GPT_EVENT_NAMES },
+  );
+}
+
+class EvidenceCollector {
+  readonly #page: Page;
+  readonly #pageOrigin: string;
+  readonly #startedAt = Date.now();
+  readonly #network: NetworkEvidence[] = [];
+  readonly #requestIndexes = new Map<Request, number>();
+  readonly #console: ConsoleEvidence[] = [];
+  readonly #pageErrors: PageErrorEvidence[] = [];
+
+  constructor(page: Page, pageUrl: string) {
+    this.#page = page;
+    this.#pageOrigin = new URL(pageUrl).origin;
+
+    page.on("request", (request) => {
+      const record: NetworkEvidence = {
+        sequence: this.#network.length + 1,
+        atMs: elapsed(this.#startedAt),
+        kind: classifyRealGamNetworkUrl(
+          request.url(),
+          this.#pageOrigin,
+          request,
+        ),
+        method: safeMethod(request.method()),
+        resourceType: safeResourceType(request.resourceType()),
+      };
+      this.#requestIndexes.set(request, this.#network.length);
+      this.#network.push(record);
+    });
+    page.on("response", (response) => {
+      const index = this.#requestIndexes.get(response.request());
+      if (index === undefined) return;
+      const record = this.#network[index];
+      if (record) record.status = response.status();
+    });
+    page.on("requestfailed", (request) => {
+      const index = this.#requestIndexes.get(request);
+      if (index === undefined) return;
+      const record = this.#network[index];
+      if (record) record.failure = true;
+    });
+    page.on("console", (message) => this.#recordConsole(message));
+    page.on("pageerror", (error) => {
+      const text = String(error.message);
+      this.#pageErrors.push({
+        sequence: this.#pageErrors.length + 1,
+        atMs: elapsed(this.#startedAt),
+        textBytes: Buffer.byteLength(text, "utf8"),
+        textSha256: sha256(text),
+      });
+    });
+  }
+
+  #recordConsole(message: ConsoleMessage): void {
+    const text = message.text();
+    this.#console.push({
+      sequence: this.#console.length + 1,
+      atMs: elapsed(this.#startedAt),
+      type: message.type(),
+      textBytes: Buffer.byteLength(text, "utf8"),
+      textSha256: sha256(text),
+      argumentCount: message.args().length,
+      sourceKind: classifyRealGamNetworkUrl(
+        message.location().url,
+        this.#pageOrigin,
+      ),
+    });
+  }
+
+  network(): readonly NetworkEvidence[] {
+    return this.#network;
+  }
+
+  artifact(
+    browserName: BrowserName,
+    contract: RealGamCaseContract,
+    snapshot: CaseSnapshot,
+    observers: ObserverSnapshot,
+    dom: DomEvidence,
+    renderTrace: readonly RenderTraceEvidence[],
+  ): Readonly<Record<string, unknown>> {
+    return Object.freeze({
+      schemaVersion: 1,
+      browser: browserName,
+      caseId: contract.caseId,
+      releaseId: snapshot.releaseId,
+      workflowRunId: process.env.GITHUB_RUN_ID ?? null,
+      commitSha: process.env.GITHUB_SHA ?? null,
+      snapshot,
+      evidence: Object.freeze({
+        console: this.#console,
+        pageErrors: this.#pageErrors,
+        network: this.#network,
+        protocol: observers.protocol,
+        gpt: observers.gpt,
+        dom,
+        renderTrace,
+      }),
+    });
+  }
+
+  failureArtifact(
+    browserName: BrowserName,
+    contract: RealGamCaseContract,
+    phase: string,
+    observers: ObserverSnapshot,
+    renderTrace: readonly RenderTraceEvidence[],
+  ): Readonly<Record<string, unknown>> {
+    return Object.freeze({
+      schemaVersion: 1,
+      browser: browserName,
+      caseId: contract.caseId,
+      releaseId: process.env.TS_REAL_GAM_EXPECTED_RELEASE_ID ?? null,
+      workflowRunId: process.env.GITHUB_RUN_ID ?? null,
+      commitSha: process.env.GITHUB_SHA ?? null,
+      harnessOutcome: "failed",
+      phase,
+      evidence: Object.freeze({
+        console: this.#console,
+        pageErrors: this.#pageErrors,
+        network: this.#network,
+        protocol: observers.protocol,
+        gpt: observers.gpt,
+        renderTrace,
+      }),
+    });
+  }
+}
+
+function assertExactKeys(value: object, keys: readonly string[]): void {
+  expect(Object.keys(value).sort()).toEqual([...keys].sort());
+}
+
+function isFiniteNonnegativeInteger(value: unknown): value is number {
+  return Number.isInteger(value) && typeof value === "number" && value >= 0;
+}
+
+function parseCounts(value: unknown): LifecycleCounts {
+  expect(value).toBeTruthy();
+  expect(typeof value).toBe("object");
+  const record = value as Record<string, unknown>;
+  assertExactKeys(record, Object.keys(ZERO_COUNTS));
+  for (const key of Object.keys(ZERO_COUNTS)) {
+    expect(
+      isFiniteNonnegativeInteger(record[key]),
+      `${key} must be a count`,
+    ).toBe(true);
+  }
+  return record as unknown as LifecycleCounts;
+}
+
+function parseSnapshot(value: unknown): CaseSnapshot {
+  expect(value).toBeTruthy();
+  expect(typeof value).toBe("object");
+  const record = value as Record<string, unknown>;
+  assertExactKeys(record, [
+    "version",
+    "caseId",
+    "releaseId",
+    "flow",
+    "outcome",
+    "reason",
+    "durationMs",
+    "dimensions",
+    "counts",
+    "ordering",
+  ]);
+  expect(record.version).toBe(1);
+  expect(typeof record.caseId).toBe("string");
+  expect(typeof record.releaseId).toBe("string");
+  expect(typeof record.flow).toBe("string");
+  expect(record.outcome === "accepted" || record.outcome === "failed").toBe(
+    true,
+  );
+  expect(record.reason === null || typeof record.reason === "string").toBe(
+    true,
+  );
+  expect(isFiniteNonnegativeInteger(record.durationMs)).toBe(true);
+  if (record.dimensions !== null) {
+    expect(typeof record.dimensions).toBe("object");
+    assertExactKeys(record.dimensions as object, ["width", "height"]);
+    expect(
+      isFiniteNonnegativeInteger(
+        (record.dimensions as Record<string, unknown>).width,
+      ),
+    ).toBe(true);
+    expect(
+      isFiniteNonnegativeInteger(
+        (record.dimensions as Record<string, unknown>).height,
+      ),
+    ).toBe(true);
+  }
+  parseCounts(record.counts);
+  if (record.ordering !== null) {
+    expect(typeof record.ordering).toBe("object");
+    assertExactKeys(record.ordering as object, [
+      "parentTerminalSequence",
+      "childRenderSequence",
+    ]);
+    const ordering = record.ordering as Record<string, unknown>;
+    expect(isFiniteNonnegativeInteger(ordering.parentTerminalSequence)).toBe(
+      true,
+    );
+    expect(isFiniteNonnegativeInteger(ordering.childRenderSequence)).toBe(true);
+  }
+  return value as CaseSnapshot;
+}
+
+export async function openProtectedRealGamPage(
+  page: Page,
+  environment: RealGamEnvironment,
+): Promise<void> {
+  try {
+    await page.goto(environment.pageUrl, { waitUntil: "domcontentloaded" });
+  } catch {
+    throw new Error("the protected real-GAM page could not be opened");
+  }
+  const valid = await page.evaluate(
+    ({ expectedReleaseId, expectedPucRelease, expectedCaseIds }) => {
+      try {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          window,
+          "__tsRealGamTestNetwork",
+        );
+        if (!descriptor || !("value" in descriptor)) return false;
+        const api = descriptor.value as Record<string, unknown>;
+        if (
+          typeof api !== "object" ||
+          api === null ||
+          !Object.isFrozen(api) ||
+          Object.getOwnPropertySymbols(api).length !== 0 ||
+          Object.getOwnPropertyNames(api).sort().join("\n") !==
+            ["caseIds", "pucRelease", "releaseId", "run", "version"]
+              .sort()
+              .join("\n")
+        ) {
+          return false;
+        }
+        const version = Object.getOwnPropertyDescriptor(api, "version");
+        const releaseId = Object.getOwnPropertyDescriptor(api, "releaseId");
+        const pucRelease = Object.getOwnPropertyDescriptor(api, "pucRelease");
+        const caseIds = Object.getOwnPropertyDescriptor(api, "caseIds");
+        const run = Object.getOwnPropertyDescriptor(api, "run");
+        if (
+          !version ||
+          !("value" in version) ||
+          version.value !== 1 ||
+          !releaseId ||
+          !("value" in releaseId) ||
+          releaseId.value !== expectedReleaseId ||
+          !pucRelease ||
+          !("value" in pucRelease) ||
+          pucRelease.value !== expectedPucRelease ||
+          !caseIds ||
+          !("value" in caseIds) ||
+          !Array.isArray(caseIds.value) ||
+          !Object.isFrozen(caseIds.value) ||
+          !run ||
+          !("value" in run) ||
+          typeof run.value !== "function"
+        ) {
+          return false;
+        }
+        return (
+          caseIds.value.length === expectedCaseIds.length &&
+          caseIds.value.every(
+            (caseId: unknown, index: number) =>
+              caseId === expectedCaseIds[index],
+          )
+        );
+      } catch {
+        return false;
+      }
+    },
+    {
+      expectedReleaseId: environment.expectedReleaseId,
+      expectedPucRelease: REAL_GAM_PUC_RELEASE,
+      expectedCaseIds: REAL_GAM_CASES.map(({ caseId }) => caseId),
+    },
+  );
+  expect(
+    valid,
+    "the protected page must expose the exact frozen test-network contract",
+  ).toBe(true);
+}
+
+async function invokeCase(
+  page: Page,
+  contract: RealGamCaseContract,
+  expectedReleaseId: string,
+): Promise<CaseSnapshot> {
+  let raw: unknown;
+  try {
+    raw = await page.evaluate(
+      async ({ expected, releaseId }) => {
+        const exactKeys = (value: object, keys: readonly string[]): boolean =>
+          Object.getOwnPropertySymbols(value).length === 0 &&
+          Object.getOwnPropertyNames(value).sort().join("\n") ===
+            [...keys].sort().join("\n");
+        const integer = (value: unknown): value is number =>
+          typeof value === "number" && Number.isInteger(value) && value >= 0;
+        const descriptor = Object.getOwnPropertyDescriptor(
+          window,
+          "__tsRealGamTestNetwork",
+        );
+        if (!descriptor || !("value" in descriptor)) throw new Error();
+        const api = descriptor.value as Record<string, unknown>;
+        const run = Object.getOwnPropertyDescriptor(api, "run");
+        if (!run || !("value" in run) || typeof run.value !== "function") {
+          throw new Error();
+        }
+        const result = await Reflect.apply(run.value, api, [expected.caseId]);
+        if (
+          typeof result !== "object" ||
+          result === null ||
+          !exactKeys(result, [
+            "version",
+            "caseId",
+            "releaseId",
+            "flow",
+            "outcome",
+            "reason",
+            "durationMs",
+            "dimensions",
+            "counts",
+            "ordering",
+          ])
+        ) {
+          throw new Error();
+        }
+        const source = result as Record<string, unknown>;
+        if (
+          source.version !== 1 ||
+          source.caseId !== expected.caseId ||
+          source.releaseId !== releaseId ||
+          source.flow !== expected.flow ||
+          source.outcome !== expected.outcome ||
+          source.reason !== expected.reason ||
+          !integer(source.durationMs) ||
+          source.durationMs > expected.deadlineMs
+        ) {
+          throw new Error();
+        }
+        const dimensions = source.dimensions as Record<string, unknown> | null;
+        if (
+          (expected.dimensions === null && dimensions !== null) ||
+          (expected.dimensions !== null &&
+            (typeof dimensions !== "object" ||
+              dimensions === null ||
+              !exactKeys(dimensions, ["width", "height"]) ||
+              dimensions.width !== expected.dimensions.width ||
+              dimensions.height !== expected.dimensions.height))
+        ) {
+          throw new Error();
+        }
+        const resultCounts = source.counts as Record<string, unknown> | null;
+        const countKeys = Object.keys(expected.counts);
+        if (
+          typeof resultCounts !== "object" ||
+          resultCounts === null ||
+          !exactKeys(resultCounts, countKeys) ||
+          countKeys.some(
+            (key) =>
+              !integer(resultCounts[key]) ||
+              resultCounts[key] !==
+                expected.counts[key as keyof typeof expected.counts],
+          )
+        ) {
+          throw new Error();
+        }
+        const resultOrdering = source.ordering as Record<
+          string,
+          unknown
+        > | null;
+        let safeOrdering: {
+          parentTerminalSequence: number;
+          childRenderSequence: number;
+        } | null = null;
+        if (expected.ordering === null) {
+          if (resultOrdering !== null) throw new Error();
+        } else {
+          if (
+            typeof resultOrdering !== "object" ||
+            resultOrdering === null ||
+            !exactKeys(resultOrdering, [
+              "parentTerminalSequence",
+              "childRenderSequence",
+            ]) ||
+            !integer(resultOrdering.parentTerminalSequence) ||
+            !integer(resultOrdering.childRenderSequence) ||
+            resultOrdering.parentTerminalSequence >=
+              resultOrdering.childRenderSequence
+          ) {
+            throw new Error();
+          }
+          safeOrdering = {
+            parentTerminalSequence: resultOrdering.parentTerminalSequence,
+            childRenderSequence: resultOrdering.childRenderSequence,
+          };
+        }
+        // Return only fixed expected values plus validated numbers. Descriptor,
+        // account, bid, creative, ticket, nonce, headers, and bodies cannot cross.
+        return {
+          version: 1,
+          caseId: expected.caseId,
+          releaseId,
+          flow: expected.flow,
+          outcome: expected.outcome,
+          reason: expected.reason,
+          durationMs: source.durationMs,
+          dimensions: expected.dimensions,
+          counts: expected.counts,
+          ordering: safeOrdering,
+        };
+      },
+      { expected: contract, releaseId: expectedReleaseId },
+    );
+  } catch {
+    throw new Error(
+      "the protected case did not produce its exact attested snapshot",
+    );
+  }
+  return parseSnapshot(raw);
+}
+
+function assertSnapshot(
+  snapshot: CaseSnapshot,
+  contract: RealGamCaseContract,
+  expectedReleaseId: string,
+): void {
+  expect(snapshot.version).toBe(1);
+  expect(snapshot.caseId).toBe(contract.caseId);
+  expect(snapshot.releaseId).toBe(expectedReleaseId);
+  expect(snapshot.flow).toBe(contract.flow);
+  expect(snapshot.outcome).toBe(contract.outcome);
+  expect(snapshot.reason).toBe(contract.reason);
+  expect(snapshot.durationMs).toBeLessThanOrEqual(contract.deadlineMs);
+  expect(snapshot.dimensions).toEqual(contract.dimensions);
+  expect(snapshot.counts).toEqual(contract.counts);
+  if (contract.ordering?.parentTerminalBeforeChild) {
+    expect(snapshot.ordering).not.toBeNull();
+    expect(snapshot.ordering!.parentTerminalSequence).toBeLessThan(
+      snapshot.ordering!.childRenderSequence,
+    );
+  } else {
+    expect(snapshot.ordering).toBeNull();
+  }
+}
+
+async function assertRuntimeRelease(
+  page: Page,
+  expectedReleaseId: string,
+): Promise<void> {
+  const releaseMatches = await page.evaluate((releaseId) => {
+    const tsjs = (window as unknown as { tsjs?: Record<string, unknown> }).tsjs;
+    if (!tsjs || typeof tsjs !== "object") return false;
+    const boot = tsjs.boot as Record<string, unknown> | undefined;
+    const manifest = boot?.manifest as Record<string, unknown> | undefined;
+    return (
+      tsjs.releaseId === releaseId &&
+      boot?.releaseId === releaseId &&
+      manifest?.releaseId === releaseId
+    );
+  }, expectedReleaseId);
+  expect(releaseMatches).toBe(true);
+}
+
+async function collectObservers(page: Page): Promise<ObserverSnapshot> {
+  const protocol: ProtocolEvidence[] = [];
+  const gpt: GptEvidence[] = [];
+  for (const frame of page.frames()) {
+    const snapshot = await frame
+      .evaluate(() => {
+        const observer = (
+          window as unknown as {
+            __tsRealGamObserver?: {
+              protocol: Array<{ message: string; atMs: number }>;
+              gpt: Array<{ event: string; atMs: number }>;
+            };
+          }
+        ).__tsRealGamObserver;
+        return observer
+          ? { protocol: [...observer.protocol], gpt: [...observer.gpt] }
+          : null;
+      })
+      .catch(() => null);
+    if (!snapshot) continue;
+    for (const event of snapshot.protocol) {
+      if (
+        PROTOCOL_MESSAGES.includes(
+          event.message as (typeof PROTOCOL_MESSAGES)[number],
+        ) &&
+        typeof event.atMs === "number" &&
+        Number.isFinite(event.atMs)
+      ) {
+        protocol.push(event as ProtocolEvidence);
+      }
+    }
+    for (const event of snapshot.gpt) {
+      if (
+        GPT_EVENT_NAMES.includes(
+          event.event as (typeof GPT_EVENT_NAMES)[number],
+        ) &&
+        typeof event.atMs === "number" &&
+        Number.isFinite(event.atMs)
+      ) {
+        gpt.push(event as GptEvidence);
+      }
+    }
+  }
+  return Object.freeze({ protocol, gpt });
+}
+
+function countNamed(
+  events: readonly GptEvidence[],
+  eventName: GptEvidence["event"],
+): number {
+  return events.filter(({ event }) => event === eventName).length;
+}
+
+function assertObservers(
+  observers: ObserverSnapshot,
+  contract: RealGamCaseContract,
+): void {
+  expect(countNamed(observers.gpt, "slotRequested")).toBe(contract.gptCycles);
+  expect(countNamed(observers.gpt, "slotResponseReceived")).toBe(
+    contract.gptCycles,
+  );
+  expect(countNamed(observers.gpt, "slotRenderEnded")).toBe(contract.gptCycles);
+  expect(
+    observers.protocol.filter(({ message }) => message === "Prebid Request")
+      .length,
+  ).toBe(contract.counts.bridgeClaims);
+}
+
+function assertNetwork(
+  network: readonly NetworkEvidence[],
+  contract: RealGamCaseContract,
+): void {
+  const count = (kind: NetworkEvidence["kind"]): number =>
+    network.filter((record) => record.kind === kind).length;
+  expect(count("renderer")).toBe(contract.counts.rendererFrames);
+  expect(count("runner-proxy")).toBe(contract.counts.runnerLoads);
+  expect(count("creative")).toBe(contract.counts.creativeRequests);
+  if (contract.gptCycles > 0) expect(count("gpt")).toBeGreaterThanOrEqual(1);
+  for (const record of network) {
+    if (record.kind === "renderer" || record.kind === "runner-proxy") {
+      expect(record.failure).not.toBe(true);
+      expect(record.status).toBe(200);
+    }
+  }
+}
+
+async function observeElements(
+  page: Page,
+  selector: string,
+  role: ElementGeometry["role"],
+): Promise<{
+  evidence: ElementGeometry[];
+  frames: Frame[];
+}> {
+  const evidence: ElementGeometry[] = [];
+  const contentFrames: Frame[] = [];
+  for (const frame of page.frames()) {
+    const handles = await frame.locator(selector).elementHandles();
+    for (const handle of handles) {
+      const geometry = await elementGeometry(handle, role);
+      evidence.push(geometry);
+      if (role === "puc-owner") {
+        const contentFrame = await (
+          handle as ElementHandle<HTMLIFrameElement>
+        ).contentFrame();
+        if (contentFrame) contentFrames.push(contentFrame);
+      }
+    }
+  }
+  return { evidence, frames: contentFrames };
+}
+
+async function elementGeometry(
+  handle: ElementHandle<Node>,
+  role: ElementGeometry["role"],
+): Promise<ElementGeometry> {
+  const box = await handle.boundingBox();
+  expect(box, `${role} must have a rendered box`).not.toBeNull();
+  const css = await handle.evaluate((element) => {
+    const htmlElement = element as HTMLElement;
+    const style = getComputedStyle(htmlElement);
+    return {
+      clientWidth: htmlElement.clientWidth,
+      clientHeight: htmlElement.clientHeight,
+      scrollWidth: htmlElement.scrollWidth,
+      scrollHeight: htmlElement.scrollHeight,
+      marginTop: style.marginTop,
+      marginRight: style.marginRight,
+      marginBottom: style.marginBottom,
+      marginLeft: style.marginLeft,
+      overflowX: style.overflowX,
+      overflowY: style.overflowY,
+    };
+  });
+  return {
+    role,
+    width: box!.width,
+    height: box!.height,
+    ...css,
+  };
+}
+
+async function documentGeometry(
+  frame: Frame,
+  role: DocumentGeometry["role"],
+): Promise<DocumentGeometry> {
+  return frame.evaluate((documentRole) => {
+    const root = document.documentElement;
+    const body = document.body;
+    if (!root || !body) throw new Error(`${documentRole} must have a body`);
+    const bodyStyle = getComputedStyle(body);
+    const rootStyle = getComputedStyle(root);
+    return {
+      role: documentRole,
+      width: innerWidth,
+      height: innerHeight,
+      clientWidth: root.clientWidth,
+      clientHeight: root.clientHeight,
+      scrollWidth: Math.max(root.scrollWidth, body.scrollWidth),
+      scrollHeight: Math.max(root.scrollHeight, body.scrollHeight),
+      bodyMarginTop: bodyStyle.marginTop,
+      bodyMarginRight: bodyStyle.marginRight,
+      bodyMarginBottom: bodyStyle.marginBottom,
+      bodyMarginLeft: bodyStyle.marginLeft,
+      overflowX:
+        bodyStyle.overflowX === "visible"
+          ? rootStyle.overflowX
+          : bodyStyle.overflowX,
+      overflowY:
+        bodyStyle.overflowY === "visible"
+          ? rootStyle.overflowY
+          : bodyStyle.overflowY,
+    };
+  }, role);
+}
+
+function assertElementGeometry(
+  geometry: ElementGeometry,
+  dimensions: Readonly<{ width: number; height: number }>,
+): void {
+  expect(geometry.width).toBe(dimensions.width);
+  expect(geometry.height).toBe(dimensions.height);
+  expect(geometry.clientWidth).toBeLessThanOrEqual(dimensions.width);
+  expect(geometry.clientHeight).toBeLessThanOrEqual(dimensions.height);
+  expect(geometry.scrollWidth).toBeLessThanOrEqual(dimensions.width);
+  expect(geometry.scrollHeight).toBeLessThanOrEqual(dimensions.height);
+  expect(geometry.marginTop).toBe("0px");
+  expect(geometry.marginRight).toBe("0px");
+  expect(geometry.marginBottom).toBe("0px");
+  expect(geometry.marginLeft).toBe("0px");
+  expect(["hidden", "clip"]).toContain(geometry.overflowX);
+  expect(["hidden", "clip"]).toContain(geometry.overflowY);
+}
+
+function assertDocumentGeometry(
+  geometry: DocumentGeometry,
+  dimensions: Readonly<{ width: number; height: number }>,
+): void {
+  expect(geometry.width).toBe(dimensions.width);
+  expect(geometry.height).toBe(dimensions.height);
+  expect(geometry.clientWidth).toBe(dimensions.width);
+  expect(geometry.clientHeight).toBe(dimensions.height);
+  expect(geometry.scrollWidth).toBeLessThanOrEqual(dimensions.width);
+  expect(geometry.scrollHeight).toBeLessThanOrEqual(dimensions.height);
+  expect(geometry.bodyMarginTop).toBe("0px");
+  expect(geometry.bodyMarginRight).toBe("0px");
+  expect(geometry.bodyMarginBottom).toBe("0px");
+  expect(geometry.bodyMarginLeft).toBe("0px");
+  expect(["hidden", "clip"]).toContain(geometry.overflowX);
+  expect(["hidden", "clip"]).toContain(geometry.overflowY);
+}
+
+async function collectDom(
+  page: Page,
+  contract: RealGamCaseContract,
+): Promise<DomEvidence> {
+  const caseSelector = `[data-ts-real-gam-case="${contract.caseId}"]`;
+  const root = page.locator(caseSelector);
+  await expect(root).toHaveCount(1);
+  await expect(root).toHaveAttribute("data-ts-real-gam-state", TERMINAL_STATE);
+  const terminalRoots = await root.count();
+
+  const slots = await observeElements(
+    page,
+    `${caseSelector} [data-ts-real-gam-slot]`,
+    "slot",
+  );
+  expect(slots.evidence).toHaveLength(contract.slotCount);
+
+  const owners = await observeElements(
+    page,
+    `[data-ts-real-gam-owner="${contract.caseId}"]`,
+    "puc-owner",
+  );
+  expect(owners.evidence).toHaveLength(contract.pucOwners);
+
+  const owned = await observeElements(
+    page,
+    `[data-ts-real-gam-owned-frame="${contract.caseId}"]`,
+    "owned-frame",
+  );
+  expect(owned.evidence).toHaveLength(contract.terminalOwnedFrames);
+
+  const renderer = await observeElements(
+    page,
+    `iframe[src*="${APS_RENDERER_PATH}"]`,
+    "renderer",
+  );
+  expect(renderer.evidence).toHaveLength(contract.terminalRendererFrames);
+
+  const rendererFrames = page.frames().filter((frame) => {
+    const url = parsedUrl(frame.url());
+    return url?.pathname === APS_RENDERER_PATH;
+  });
+  expect(rendererFrames).toHaveLength(contract.terminalRendererFrames);
+
+  const creativeElements: ElementGeometry[] = [];
+  const creativeFrames: Frame[] = [];
+  for (const frame of rendererFrames) {
+    const children = frame.childFrames();
+    expect(children).toHaveLength(1);
+    creativeFrames.push(...children);
+    const handles = await frame.locator("iframe").elementHandles();
+    expect(handles).toHaveLength(1);
+    creativeElements.push(await elementGeometry(handles[0]!, "creative"));
+  }
+
+  const documents: DocumentGeometry[] = [];
+  for (const frame of owners.frames) {
+    documents.push(await documentGeometry(frame, "puc-owner-document"));
+  }
+  for (const frame of rendererFrames) {
+    documents.push(await documentGeometry(frame, "renderer-document"));
+  }
+  for (const frame of creativeFrames) {
+    documents.push(await documentGeometry(frame, "creative-document"));
+  }
+
+  if (contract.dimensions) {
+    for (const geometry of [
+      ...owners.evidence,
+      ...owned.evidence,
+      ...renderer.evidence,
+      ...creativeElements,
+    ]) {
+      assertElementGeometry(geometry, contract.dimensions);
+    }
+    for (const geometry of documents) {
+      assertDocumentGeometry(geometry, contract.dimensions);
+    }
+  }
+
+  return Object.freeze({
+    terminalRoots,
+    elements: Object.freeze([
+      ...slots.evidence,
+      ...owners.evidence,
+      ...owned.evidence,
+      ...renderer.evidence,
+      ...creativeElements,
+    ]),
+    documents: Object.freeze(documents),
+  });
+}
+
+async function collectRenderTrace(
+  page: Page,
+): Promise<readonly RenderTraceEvidence[]> {
+  return page.evaluate(() => {
+    const tsjs = (window as unknown as { tsjs?: Record<string, unknown> }).tsjs;
+    const diagnostics = tsjs?.diagnostics as
+      Record<string, unknown> | undefined;
+    const renderTrace = diagnostics?.renderTrace as
+      Record<string, unknown> | undefined;
+    const history = renderTrace?.history;
+    if (typeof history !== "function") return [];
+    let records: unknown;
+    try {
+      records = Reflect.apply(history, renderTrace, []);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(records)) return [];
+    return records.map((record) => {
+      const value =
+        typeof record === "object" && record !== null
+          ? (record as Record<string, unknown>)
+          : {};
+      const path = value.path;
+      const servedFrom = value.servedFrom;
+      return {
+        path:
+          path === "auction" || path === "ssat" || path === "gam-refresh"
+            ? path
+            : null,
+        rendered: value.rendered === true,
+        servedFrom:
+          servedFrom === "inline" ||
+          servedFrom === "gam" ||
+          servedFrom === "debug-adm" ||
+          servedFrom === "pbs-cache" ||
+          servedFrom === "prebid"
+            ? servedFrom
+            : null,
+        gamEmpty: typeof value.gamEmpty === "boolean" ? value.gamEmpty : null,
+        injected: typeof value.injected === "boolean" ? value.injected : null,
+        visible: typeof value.visible === "boolean" ? value.visible : null,
+        count:
+          typeof value.count === "number" && Number.isFinite(value.count)
+            ? value.count
+            : 0,
+        seq:
+          typeof value.seq === "number" && Number.isFinite(value.seq)
+            ? value.seq
+            : 0,
+      };
+    });
+  });
+}
+
+function assertSafeArtifact(
+  serialized: string,
+  environment: RealGamEnvironment,
+): void {
+  if (
+    serialized.includes(environment.authorization) ||
+    serialized.includes(environment.pageUrl)
+  ) {
+    throw new Error(
+      "a protected value reached the sanitized evidence boundary",
+    );
+  }
+  if (
+    /"(?:accountId|aaxResponse|adm|authorization|creativeBody|descriptor|lifecycleTicket|nonce|postData|requestHeaders|responseBody|responseHeaders)"\s*:/u.test(
+      serialized,
+    ) ||
+    serialized.includes("<script") ||
+    serialized.includes("<!doctype")
+  ) {
+    throw new Error(
+      "an unsafe field or response body reached browser evidence",
+    );
+  }
+}
+
+async function writeEvidence(
+  page: Page,
+  testInfo: TestInfo,
+  browserName: BrowserName,
+  contract: RealGamCaseContract,
+  artifact: Readonly<Record<string, unknown>>,
+  environment: RealGamEnvironment,
+): Promise<void> {
+  const directory = resolve(EVIDENCE_ROOT, browserName, contract.caseId);
+  mkdirSync(directory, { recursive: true });
+  const evidencePath = resolve(directory, "sanitized-trace-v1.json");
+  const serialized = `${JSON.stringify(artifact, null, 2)}\n`;
+  assertSafeArtifact(serialized, environment);
+  writeFileSync(evidencePath, serialized, { encoding: "utf8", mode: 0o600 });
+
+  const screenshotPath = resolve(directory, "terminal.png");
+  await page.screenshot({
+    path: screenshotPath,
+    fullPage: true,
+    animations: "disabled",
+    mask: [page.locator("[data-ts-real-gam-secret]")],
+  });
+  await testInfo.attach("sanitized-real-gam-trace", {
+    path: evidencePath,
+    contentType: "application/json",
+  });
+  await testInfo.attach("real-gam-terminal-screenshot", {
+    path: screenshotPath,
+    contentType: "image/png",
+  });
+}
+
+export async function runAttestedRealGamCase(options: {
+  readonly page: Page;
+  readonly browserName: BrowserName;
+  readonly testInfo: TestInfo;
+  readonly environment: RealGamEnvironment;
+  readonly contract: RealGamCaseContract;
+}): Promise<void> {
+  const { page, browserName, testInfo, environment, contract } = options;
+  const collector = new EvidenceCollector(page, environment.pageUrl);
+  let phase = "observer-installation";
+  try {
+    await installBrowserObservers(page);
+    phase = "protected-page-contract";
+    await openProtectedRealGamPage(page, environment);
+    phase = "case-snapshot";
+    const snapshot = await invokeCase(
+      page,
+      contract,
+      environment.expectedReleaseId,
+    );
+    assertSnapshot(snapshot, contract, environment.expectedReleaseId);
+    phase = "runtime-release-binding";
+    await assertRuntimeRelease(page, environment.expectedReleaseId);
+    phase = "browser-observers";
+    const observers = await collectObservers(page);
+    assertObservers(observers, contract);
+    phase = "network-contract";
+    assertNetwork(collector.network(), contract);
+    phase = "terminal-dom";
+    const dom = await collectDom(page, contract);
+    phase = "sanitized-render-trace";
+    const renderTrace = await collectRenderTrace(page);
+    const artifact = collector.artifact(
+      browserName,
+      contract,
+      snapshot,
+      observers,
+      dom,
+      renderTrace,
+    );
+    phase = "evidence-write";
+    await writeEvidence(
+      page,
+      testInfo,
+      browserName,
+      contract,
+      artifact,
+      environment,
+    );
+  } catch {
+    const observers = await collectObservers(page).catch(() =>
+      Object.freeze({ protocol: [], gpt: [] }),
+    );
+    const renderTrace = await collectRenderTrace(page).catch(() => []);
+    const failureArtifact = collector.failureArtifact(
+      browserName,
+      contract,
+      phase,
+      observers,
+      renderTrace,
+    );
+    await writeEvidence(
+      page,
+      testInfo,
+      browserName,
+      contract,
+      failureArtifact,
+      environment,
+    ).catch(() => undefined);
+    throw new Error(`${contract.caseId} failed during ${phase}`);
+  }
+}
diff --git a/crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts b/crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts
index 6763b6b4b..df2110732 100644
--- a/crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts
+++ b/crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts
@@ -2,115 +2,458 @@ import type { Page } from "@playwright/test";
 
 /** Install a deterministic documented-event GPT stub before publisher scripts run. */
 export async function installGptStub(page: Page): Promise<void> {
-    await page.addInitScript(() => {
-        type StubSlot = {
-            getSlotElementId(): string;
-            getAdUnitPath(): string;
-        };
-        type StubEvent = { slot: StubSlot } & Record<string, unknown>;
-        type StubListener = (event: StubEvent) => void;
+  await page.addInitScript(() => {
+    type StubSlot = {
+      addService(service: object): StubSlot;
+      clearTargeting(key?: string): StubSlot;
+      getAdUnitPath(): string;
+      getSlotElementId(): string;
+      getTargeting(key: string): string[];
+      setTargeting(key: string, value: string | string[]): StubSlot;
+    };
+    type StubEvent = { slot: StubSlot } & Record<string, unknown>;
+    type StubListener = (event: StubEvent) => void;
 
-        const listeners = new Map<string, StubListener[]>();
-        const slots = new Map<string, StubSlot>();
-        const pubadsService = {
-            addEventListener(name: string, listener: StubListener) {
-                const current = listeners.get(name) ?? [];
-                current.push(listener);
-                listeners.set(name, current);
-            },
-            refresh() {},
-        };
-        const commandQueue = {
-            push(callback: () => void) {
-                callback();
-                return 1;
-            },
-        };
-        const googletag = {
-            cmd: commandQueue,
-            display() {},
-            defineSlot() {},
-            pubads: () => pubadsService,
-        };
-        const references = {
-            commandPush: commandQueue.push,
-            display: googletag.display,
-            defineSlot: googletag.defineSlot,
-            refresh: pubadsService.refresh,
-            fetch: window.fetch,
-            xhrOpen: window.XMLHttpRequest.prototype.open,
-            pushState: window.history.pushState,
-            replaceState: window.history.replaceState,
-        };
+    const listeners = new Map<string, Set<StubListener>>();
+    const slots = new Map<string, StubSlot>();
+    const physicalSlots = new Set<StubSlot>();
+    const displayCalls: StubSlot[] = [];
+    const refreshCalls: StubSlot[][] = [];
+    const universalCreativeLifecycle: string[] = [];
+    const emissions: Array<Readonly<Record<string, unknown>>> = [];
+    const pageTargeting = new Map<string, string[]>();
+    let initialLoadDisabled = false;
+    let requestStartOnDisplay = false;
+    let nonemptyCompletionOnDisplay = false;
+    let destroySucceeds = true;
+
+    const createSlot = (id: string, adUnitPath: string): StubSlot => {
+      const targeting = new Map<string, string[]>();
+      const slot: StubSlot = {
+        addService() {
+          return slot;
+        },
+        clearTargeting(key?: string) {
+          if (key === undefined) targeting.clear();
+          else targeting.delete(key);
+          return slot;
+        },
+        getAdUnitPath: () => adUnitPath,
+        getSlotElementId: () => id,
+        getTargeting(key: string) {
+          return [...(targeting.get(key) ?? [])];
+        },
+        setTargeting(key: string, value: string | string[]) {
+          targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+          return slot;
+        },
+      };
+      slots.set(id, slot);
+      return slot;
+    };
+
+    const slotForTarget = (target: unknown): StubSlot | undefined => {
+      if (typeof target === "string") return slots.get(target);
+      if (typeof target !== "object" || target === null) return undefined;
+      return [...physicalSlots].find((candidate) => candidate === target);
+    };
+
+    const emit = (
+      name: string,
+      slot: StubSlot,
+      facts: Record<string, unknown> = {},
+    ): void => {
+      for (const listener of listeners.get(name) ?? []) {
+        listener({ slot, ...facts });
+      }
+    };
+
+    const pubadsService = {
+      addEventListener(name: string, listener: StubListener) {
+        const current = listeners.get(name) ?? new Set<StubListener>();
+        current.add(listener);
+        listeners.set(name, current);
+      },
+      removeEventListener(name: string, listener: StubListener) {
+        const current = listeners.get(name);
+        current?.delete(listener);
+        if (current?.size === 0) listeners.delete(name);
+      },
+      disableInitialLoad() {
+        initialLoadDisabled = true;
+      },
+      enableSingleRequest() {},
+      getConfig() {
+        return { disableInitialLoad: initialLoadDisabled };
+      },
+      getSlots() {
+        return [...physicalSlots];
+      },
+      getTargeting(key: string) {
+        return [...(pageTargeting.get(key) ?? [])];
+      },
+      setTargeting(key: string, value: string | string[]) {
+        pageTargeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return pubadsService;
+      },
+      refresh(requestedSlots?: StubSlot[]) {
+        const requested = requestedSlots ?? [...physicalSlots];
+        refreshCalls.push([...requested]);
+      },
+    };
+    const commandQueue = {
+      push(callback: () => void) {
+        callback();
+        return 1;
+      },
+    };
+    const googletag = {
+      apiReady: true,
+      pubadsReady: true,
+      cmd: commandQueue,
+      destroySlots(requested?: StubSlot[]) {
+        if (!destroySucceeds) return false;
+        const candidates = requested ?? [...physicalSlots];
+        for (const slot of candidates) physicalSlots.delete(slot);
+        return true;
+      },
+      display(target: string | StubSlot) {
+        const slot = slotForTarget(target);
+        if (slot) {
+          displayCalls.push(slot);
+          if (requestStartOnDisplay) {
+            emissions.push({
+              name: "slotRequested",
+              listeners: listeners.get("slotRequested")?.size ?? 0,
+              physical: physicalSlots.has(slot),
+            });
+            emit("slotRequested", slot);
+            if (nonemptyCompletionOnDisplay) {
+              emissions.push({
+                name: "slotRenderEnded",
+                listeners: listeners.get("slotRenderEnded")?.size ?? 0,
+                physical: physicalSlots.has(slot),
+              });
+              emit("slotRenderEnded", slot, {
+                isEmpty: false,
+                responseIdentifier: "fictional-response-1",
+                size: [300, 250],
+              });
+            }
+          }
+        }
+      },
+      defineSlot(adUnitPath: string, _sizes: unknown, elementId: string) {
+        const existing = slots.get(elementId);
+        const slot = existing ?? createSlot(elementId, adUnitPath);
+        physicalSlots.add(slot);
+        return slot;
+      },
+      getConfig() {
+        return { disableInitialLoad: initialLoadDisabled };
+      },
+      pubads: () => pubadsService,
+      setConfig(config: { disableInitialLoad?: unknown }) {
+        if (typeof config?.disableInitialLoad === "boolean") {
+          initialLoadDisabled = config.disableInitialLoad;
+        }
+      },
+    };
+    const references = {
+      commandPush: commandQueue.push,
+      display: googletag.display,
+      defineSlot: googletag.defineSlot,
+      refresh: pubadsService.refresh,
+      fetch: window.fetch,
+      xhrOpen: window.XMLHttpRequest.prototype.open,
+    };
+    const publisherHistoryReferences = {
+      pushState: window.history.pushState,
+      replaceState: window.history.replaceState,
+    };
 
-        const browserWindow = window as unknown as {
-            googletag: typeof googletag;
-            __gptDiagnosticsStub: {
-                slot(id: string, adUnitPath?: string): StubSlot;
-                emit(
-                    name: string,
-                    slotId: string,
-                    facts?: Record<string, unknown>,
-                ): void;
-                listenerCounts(): Record<string, number>;
-                captureReferences(): void;
-                referencesUnchanged(): boolean;
+    function fictionalUniversalCreative(
+      adId: string,
+      lifecycleIndex: number,
+    ): void {
+      type OwnerResponse = {
+        adId: string;
+        renderer: string;
+      };
+      type FictionalPucWindow = Window & {
+        __fictionalPucOutcome?: string;
+        render?: (
+          data: OwnerResponse,
+          helper: object,
+          creativeWindow: Window,
+        ) => Promise<void>;
+      };
+
+      const pucWindow = window as FictionalPucWindow;
+      pucWindow.__fictionalPucOutcome = "pending";
+      const recordOutcome = (outcome: string): void => {
+        pucWindow.__fictionalPucOutcome = outcome;
+        (
+          window.parent as Window & {
+            __recordFictionalPucOutcome(index: number, value: string): void;
+          }
+        ).__recordFictionalPucOutcome(lifecycleIndex, outcome);
+      };
+
+      const prebidMessenger = (): Promise<OwnerResponse> =>
+        new Promise((resolve, reject) => {
+          const channel = new MessageChannel();
+          const timeout = window.setTimeout(() => {
+            channel.port1.close();
+            reject(new Error("fictional PUC response timeout"));
+          }, 5_000);
+          channel.port1.onmessage = (event) => {
+            window.clearTimeout(timeout);
+            channel.port1.close();
+            try {
+              const response = JSON.parse(String(event.data)) as OwnerResponse;
+              resolve(response);
+            } catch (error) {
+              reject(error);
+            }
+          };
+          channel.port1.start();
+          window.parent.postMessage(
+            JSON.stringify({
+              message: "Prebid Request",
+              adId,
+              adServerDomain: window.parent.location.host,
+            }),
+            "*",
+            [channel.port2],
+          );
+        });
+
+      const runDynamicRenderer = async (
+        response: OwnerResponse,
+      ): Promise<void> => {
+        if (typeof response.renderer !== "string") {
+          throw new Error("fictional PUC response refused");
+        }
+        window.eval(response.renderer);
+        if (typeof pucWindow.render !== "function") {
+          throw new Error("fictional PUC dynamic renderer unavailable");
+        }
+        const helper = {
+          sendMessage(
+            message: string,
+            payload: Record<string, unknown>,
+            callback: (event: MessageEvent) => void,
+          ) {
+            const channel = new MessageChannel();
+            let active = true;
+            channel.port1.onmessage = (event) => {
+              if (active) callback(event);
+            };
+            channel.port1.start();
+            window.parent.postMessage(
+              JSON.stringify({
+                message,
+                adId: response.adId,
+                ...payload,
+              }),
+              "*",
+              [channel.port2],
+            );
+            return () => {
+              active = false;
+              channel.port1.close();
             };
+          },
+        };
+        await pucWindow.render(response, helper, window);
+      };
+
+      void prebidMessenger()
+        .then(runDynamicRenderer)
+        .then(
+          () => {
+            recordOutcome("accepted");
+          },
+          (error: unknown) => {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            recordOutcome(`failed:${message}`);
+          },
+        );
+    }
+
+    const browserWindow = window as unknown as {
+      googletag: typeof googletag;
+      __recordFictionalPucOutcome(index: number, value: string): void;
+      __gptDiagnosticsStub: {
+        captureReferences(): void;
+        emitNonemptyCompletionOnDisplay(value?: boolean): void;
+        emitRequestStartOnDisplay(value?: boolean): void;
+        displayCount(): number;
+        emit(
+          name: string,
+          slotId: string,
+          facts?: Record<string, unknown>,
+        ): void;
+        listenerCounts(): Record<string, number>;
+        referenceOwnership(): {
+          diagnosticsSafe: boolean;
+          pairedHistoryWrappers: boolean;
+        };
+        refreshCount(): number;
+        publisherDestroy(slotId: string, succeeds?: boolean): boolean;
+        publisherRefresh(slotId: string): void;
+        renderUniversalCreative(slotId: string, adId: string): void;
+        slot(id: string, adUnitPath?: string): StubSlot;
+        targeting(slotId: string, key: string): readonly string[];
+        universalCreativeSnapshot(): Readonly<Record<string, unknown>>;
+      };
+    };
+    browserWindow.googletag = googletag;
+    browserWindow.__recordFictionalPucOutcome = (index, value) => {
+      universalCreativeLifecycle[index] = value;
+    };
+    browserWindow.__gptDiagnosticsStub = {
+      slot(id: string, adUnitPath = `/example/site/${id}`) {
+        return slots.get(id) ?? createSlot(id, adUnitPath);
+      },
+      emit(name: string, slotId: string, facts: Record<string, unknown> = {}) {
+        const slot = this.slot(slotId);
+        emissions.push({
+          name,
+          listeners: listeners.get(name)?.size ?? 0,
+          physical: physicalSlots.has(slot),
+        });
+        emit(name, slot, facts);
+      },
+      listenerCounts() {
+        return Object.fromEntries(
+          [...listeners.entries()].map(([name, registered]) => [
+            name,
+            registered.size,
+          ]),
+        );
+      },
+      displayCount() {
+        return displayCalls.length;
+      },
+      emitRequestStartOnDisplay(value = true) {
+        requestStartOnDisplay = value;
+      },
+      emitNonemptyCompletionOnDisplay(value = true) {
+        nonemptyCompletionOnDisplay = value;
+      },
+      refreshCount() {
+        return refreshCalls.length;
+      },
+      publisherDestroy(slotId: string, succeeds = true) {
+        const slot = slots.get(slotId);
+        if (!slot || !physicalSlots.has(slot)) {
+          throw new Error(`missing fictional publisher slot: ${slotId}`);
+        }
+        destroySucceeds = succeeds;
+        try {
+          return googletag.destroySlots([slot]);
+        } finally {
+          destroySucceeds = true;
+        }
+      },
+      publisherRefresh(slotId: string) {
+        const slot = slots.get(slotId);
+        if (!slot || !physicalSlots.has(slot)) {
+          throw new Error(`missing fictional publisher slot: ${slotId}`);
+        }
+        pubadsService.refresh([slot]);
+        emissions.push({
+          name: "slotRequested",
+          listeners: listeners.get("slotRequested")?.size ?? 0,
+          physical: physicalSlots.has(slot),
+        });
+        emit("slotRequested", slot, {
+          responseIdentifier: "fictional-publisher-refresh",
+        });
+      },
+      targeting(slotId: string, key: string) {
+        return slots.get(slotId)?.getTargeting(key) ?? [];
+      },
+      renderUniversalCreative(slotId: string, adId: string) {
+        const root = document.getElementById(slotId);
+        if (!root) throw new Error(`missing fictional PUC slot: ${slotId}`);
+        const frame = document.createElement("iframe");
+        const lifecycleIndex = universalCreativeLifecycle.length;
+        universalCreativeLifecycle.push("pending");
+        frame.dataset.fictionalPuc = "";
+        frame.srcdoc = `<!doctype html><body><script>(${String(fictionalUniversalCreative)})(${JSON.stringify(adId)},${lifecycleIndex});<\/script></body>`;
+        root.appendChild(frame);
+      },
+      universalCreativeSnapshot() {
+        const frames = Array.from(
+          document.querySelectorAll<HTMLIFrameElement>(
+            "iframe[data-fictional-puc]",
+          ),
+        );
+        return {
+          lifecycle: [...universalCreativeLifecycle],
+          pucFrames: frames.length,
+          ownerFrames: frames.map(
+            (frame) =>
+              frame.contentDocument?.querySelectorAll(
+                'iframe[title="Ad content"]',
+              ).length ?? -1,
+          ),
+          ownerSources: frames.map(
+            (frame) =>
+              frame.contentDocument?.querySelector<HTMLIFrameElement>(
+                'iframe[title="Ad content"]',
+              )?.srcdoc ?? "",
+          ),
+          emissions: [...emissions],
+          listeners: this.listenerCounts(),
+          displays: displayCalls.map((slot) => slot.getSlotElementId()),
+          refreshes: refreshCalls.map((slots) =>
+            slots.map((slot) => slot.getSlotElementId()),
+          ),
+          slotChildren: Array.from(
+            document.getElementById(displayCalls[0]?.getSlotElementId() ?? "")
+              ?.children ?? [],
+          ).map((element) => ({
+            tag: element.tagName,
+            fictionalPuc:
+              element instanceof HTMLIFrameElement &&
+              element.dataset.fictionalPuc !== undefined,
+            title: element.getAttribute("title"),
+            adm:
+              element instanceof HTMLIFrameElement &&
+              element.srcdoc.includes("fictional creative"),
+          })),
         };
-        browserWindow.googletag = googletag;
-        browserWindow.__gptDiagnosticsStub = {
-            slot(id: string, adUnitPath = `/example/site/${id}`) {
-                let slot = slots.get(id);
-                if (!slot) {
-                    slot = {
-                        getSlotElementId: () => id,
-                        getAdUnitPath: () => adUnitPath,
-                    };
-                    slots.set(id, slot);
-                }
-                return slot;
-            },
-            emit(
-                name: string,
-                slotId: string,
-                facts: Record<string, unknown> = {},
-            ) {
-                const slot = this.slot(slotId);
-                for (const listener of listeners.get(name) ?? []) {
-                    listener({ slot, ...facts });
-                }
-            },
-            listenerCounts() {
-                return Object.fromEntries(
-                    [...listeners.entries()].map(([name, registered]) => [
-                        name,
-                        registered.length,
-                    ]),
-                );
-            },
-            captureReferences() {
-                references.commandPush = commandQueue.push;
-                references.display = googletag.display;
-                references.defineSlot = googletag.defineSlot;
-                references.refresh = pubadsService.refresh;
-                references.fetch = window.fetch;
-                references.xhrOpen = window.XMLHttpRequest.prototype.open;
-                references.pushState = window.history.pushState;
-                references.replaceState = window.history.replaceState;
-            },
-            referencesUnchanged() {
-                return (
-                    commandQueue.push === references.commandPush &&
-                    googletag.display === references.display &&
-                    googletag.defineSlot === references.defineSlot &&
-                    pubadsService.refresh === references.refresh &&
-                    window.fetch === references.fetch &&
-                    window.XMLHttpRequest.prototype.open ===
-                        references.xhrOpen &&
-                    window.history.pushState === references.pushState &&
-                    window.history.replaceState === references.replaceState
-                );
-            },
+      },
+      captureReferences() {
+        references.commandPush = commandQueue.push;
+        references.display = googletag.display;
+        references.defineSlot = googletag.defineSlot;
+        references.refresh = pubadsService.refresh;
+        references.fetch = window.fetch;
+        references.xhrOpen = window.XMLHttpRequest.prototype.open;
+      },
+      referenceOwnership() {
+        const pushStateChanged =
+          window.history.pushState !== publisherHistoryReferences.pushState;
+        const replaceStateChanged =
+          window.history.replaceState !==
+          publisherHistoryReferences.replaceState;
+        return {
+          diagnosticsSafe:
+            commandQueue.push === references.commandPush &&
+            googletag.display === references.display &&
+            googletag.defineSlot === references.defineSlot &&
+            pubadsService.refresh === references.refresh &&
+            window.fetch === references.fetch &&
+            window.XMLHttpRequest.prototype.open === references.xhrOpen,
+          pairedHistoryWrappers: pushStateChanged && replaceStateChanged,
         };
-    });
+      },
+    };
+  });
 }
diff --git a/crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts b/crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts
new file mode 100644
index 000000000..09bad1e1c
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts
@@ -0,0 +1,359 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { Page } from "@playwright/test";
+
+const TSJS_CRATE = resolve(__dirname, "../../../trusted-server-js");
+const DIST = resolve(TSJS_CRATE, "dist");
+
+interface ReleaseArtifact {
+  id: string;
+  role:
+    | "bootstrap"
+    | "core"
+    | "integration"
+    | "first_display_base"
+    | "first_display_slice";
+  phase: "first_display" | "takeover" | "deferred" | null;
+  file: string;
+}
+
+interface Release {
+  version: 1;
+  releaseId: string;
+  artifacts: ReleaseArtifact[];
+}
+
+export interface RuntimeTsjsFixture {
+  releaseId: string;
+  bootstrapBody: string;
+  runtimeBody: string;
+  runtimeSrc: string;
+  manifest: {
+    version: 1;
+    releaseId: string;
+    firstDisplay: null;
+    runtimeSrc: string;
+    integrations: Array<{ id: string; phase: "takeover" }>;
+  };
+}
+
+export interface FirstDisplayTsjsFixture {
+  releaseId: string;
+  bootstrapBody: string;
+  firstDisplayBody: string;
+  firstDisplaySrc: string;
+  runtimeBody: string;
+  runtimeSrc: string;
+  deferred: readonly Readonly<{
+    id: string;
+    body: string;
+    src: string;
+  }>[];
+  boot: Readonly<Record<string, unknown>>;
+  outline: Readonly<Record<string, unknown>>;
+}
+
+interface FirstDisplayTsjsFixtureInput {
+  readonly auctionProjection: Readonly<Record<string, unknown>>;
+  readonly integrations: Readonly<Record<string, unknown>>;
+  readonly creative?: Readonly<Record<string, unknown>>;
+  readonly diagnostics?: Readonly<Record<string, unknown>>;
+  readonly firstDisplayIds: readonly string[];
+  readonly takeoverIds: readonly string[];
+  readonly deferredIds?: readonly string[];
+}
+
+const FIRST_DISPLAY_IDS = Object.freeze([
+  "first_display",
+  "render_owner_initial",
+  "aps_initial",
+  "creative_initial",
+  "datadome_initial",
+  "didomi_initial",
+  "google_tag_manager_initial",
+  "gpt_initial",
+  "lockr_initial",
+  "osano_initial",
+  "permutive_initial",
+  "sourcepoint_initial",
+  "prebid_initial",
+  "testlight_initial",
+] as const);
+
+interface ServerBootDigestInputV1 {
+  readonly auctionProjection: unknown;
+  readonly integrations: unknown;
+  readonly [key: string]: unknown;
+}
+
+/** Serialize the exact string-only server boot carrier consumed by bootstrap. */
+export function serverBootTransportLiteralV1(
+  boot: ServerBootDigestInputV1,
+  outline: unknown = null,
+): string {
+  const projection = JSON.stringify(boot.auctionProjection);
+  const integrationConfigs = JSON.stringify(boot.integrations);
+  if (projection === undefined || integrationConfigs === undefined) {
+    throw new Error("TSJS server boot digest input is not JSON");
+  }
+  const transport = JSON.stringify({
+    version: 1,
+    boot,
+    integrity: {
+      version: 1,
+      projectionDigest: createHash("sha256")
+        .update(projection, "utf8")
+        .digest("hex"),
+      integrationConfigDigest: createHash("sha256")
+        .update(integrationConfigs, "utf8")
+        .digest("hex"),
+    },
+    outline,
+  });
+  return JSON.stringify(transport);
+}
+
+function exactArtifact(release: Release, id: string): ReleaseArtifact {
+  const matches = release.artifacts.filter((artifact) => artifact.id === id);
+  if (matches.length !== 1)
+    throw new Error(`expected one TSJS artifact for ${id}`);
+  return matches[0]!;
+}
+
+function jsonDigest(value: unknown): string {
+  const encoded = JSON.stringify(value);
+  if (encoded === undefined) throw new Error("TSJS fixture value is not JSON");
+  return createHash("sha256").update(encoded, "utf8").digest("hex");
+}
+
+function releaseFixture(): { release: Release; dist: string } {
+  const release = JSON.parse(
+    readFileSync(resolve(DIST, "tsjs-release-v1.json"), "utf8"),
+  ) as Release;
+  if (release.version !== 1 || !/^[0-9a-f]{64}$/u.test(release.releaseId)) {
+    throw new Error("TSJS release manifest is invalid");
+  }
+  return { release, dist: DIST };
+}
+
+/** Build the same content-addressed persistent-runtime response and manifest as production. */
+export function runtimeTsjsFixture(ids: readonly string[]): RuntimeTsjsFixture {
+  const { release } = releaseFixture();
+  const artifacts = [exactArtifact(release, "core")].concat(
+    ids.map((id) => exactArtifact(release, id)),
+  );
+  for (const artifact of artifacts.slice(1)) {
+    if (artifact.phase !== "takeover") {
+      throw new Error(`TSJS fixture module ${artifact.id} is not takeover`);
+    }
+  }
+  const runtimeBody = artifacts
+    .map((artifact) => readFileSync(resolve(DIST, artifact.file), "utf8"))
+    .join(";\n");
+  const hash = createHash("sha256").update(runtimeBody, "utf8").digest("hex");
+  const runtimeSrc = `/static/tsjs=tsjs-unified.min.js?v=${hash}`;
+  const bootstrapBody = readFileSync(
+    resolve(DIST, exactArtifact(release, "bootstrap").file),
+    "utf8",
+  );
+  return {
+    releaseId: release.releaseId,
+    bootstrapBody,
+    runtimeBody,
+    runtimeSrc,
+    manifest: {
+      version: 1,
+      releaseId: release.releaseId,
+      firstDisplay: null,
+      runtimeSrc,
+      integrations: ids.map((id) => ({ id, phase: "takeover" as const })),
+    },
+  };
+}
+
+/** Build one exact parser-blocking first-display mask and its persistent takeover. */
+export function firstDisplayTsjsFixture(
+  input: FirstDisplayTsjsFixtureInput,
+): FirstDisplayTsjsFixture {
+  const { release, dist } = releaseFixture();
+  const firstDisplayArtifacts = input.firstDisplayIds.map((id, index) => {
+    const expectedIndex = FIRST_DISPLAY_IDS.indexOf(
+      id as (typeof FIRST_DISPLAY_IDS)[number],
+    );
+    if (
+      expectedIndex < 0 ||
+      (index > 0 &&
+        expectedIndex <=
+          FIRST_DISPLAY_IDS.indexOf(
+            input.firstDisplayIds[
+              index - 1
+            ] as (typeof FIRST_DISPLAY_IDS)[number],
+          ))
+    ) {
+      throw new Error(`TSJS first-display fixture order is invalid at ${id}`);
+    }
+    const artifact = exactArtifact(release, id);
+    if (artifact.phase !== "first_display") {
+      throw new Error(`TSJS fixture module ${id} is not first-display`);
+    }
+    return artifact;
+  });
+  if (input.firstDisplayIds[0] !== "first_display") {
+    throw new Error("TSJS first-display fixture requires the base slice");
+  }
+  const mask = input.firstDisplayIds.reduce((value, id) => {
+    const index = FIRST_DISPLAY_IDS.indexOf(
+      id as (typeof FIRST_DISPLAY_IDS)[number],
+    );
+    return value | (1 << index);
+  }, 0);
+  const firstDisplayBody = firstDisplayArtifacts
+    .map((artifact) => readFileSync(resolve(dist, artifact.file), "utf8"))
+    .join(";\n");
+  const firstDisplayHash = createHash("sha256")
+    .update(firstDisplayBody, "utf8")
+    .digest("hex");
+  const firstDisplaySrc = `/static/tsjs=tsjs-first-display.min.js?m=${mask
+    .toString(16)
+    .padStart(4, "0")}&v=${firstDisplayHash}`;
+  const runtime = runtimeTsjsFixture(input.takeoverIds);
+  const deferred = (input.deferredIds ?? []).map((id) => {
+    const artifact = exactArtifact(release, id);
+    if (artifact.phase !== "deferred") {
+      throw new Error(`TSJS fixture module ${artifact.id} is not deferred`);
+    }
+    const body = readFileSync(resolve(dist, artifact.file), "utf8");
+    const hash = createHash("sha256").update(body, "utf8").digest("hex");
+    return Object.freeze({
+      id,
+      body,
+      src: `/static/tsjs=tsjs-${id}.min.js?v=${hash}`,
+    });
+  });
+  const manifest = {
+    ...runtime.manifest,
+    firstDisplay: {
+      src: firstDisplaySrc,
+      slices: [...input.firstDisplayIds],
+    },
+    integrations: [
+      ...runtime.manifest.integrations,
+      ...deferred.map(({ id, src }) => ({
+        id,
+        phase: "deferred" as const,
+        trigger: "first_display_or_idle" as const,
+        src,
+      })),
+    ],
+  };
+  const creative = input.creative ?? {
+    version: 1,
+    enabled: false,
+    clickGuard: false,
+    renderGuard: false,
+  };
+  const diagnostics = input.diagnostics ?? {
+    version: 1,
+    renderTraceOverlay: false,
+    gpt: { active: false },
+  };
+  const boot = {
+    abi: 1,
+    releaseId: release.releaseId,
+    manifest,
+    auctionProjection: input.auctionProjection,
+    integrations: input.integrations,
+    creative,
+    diagnostics,
+  };
+  const projectionDigest = jsonDigest(input.auctionProjection);
+  const integrationConfigDigest = jsonDigest(input.integrations);
+  const slots = input.auctionProjection.slots;
+  const outcomes = (
+    input.auctionProjection.auction as Readonly<Record<string, unknown>>
+  ).results;
+  const bids = input.auctionProjection.bids;
+  if (
+    !Array.isArray(slots) ||
+    !Array.isArray(outcomes) ||
+    !Array.isArray(bids)
+  ) {
+    throw new Error("TSJS first-display fixture projection is invalid");
+  }
+  const outline = {
+    version: 1,
+    releaseId: release.releaseId,
+    generation: 1,
+    projectionDigest,
+    integrationConfigDigest,
+    slices: [...input.firstDisplayIds],
+    slotCount: slots.length,
+    outcomeCount: outcomes.length,
+    capabilities: [],
+    objectKinds: bids.length === 0 ? [] : ["gpt_slot", "dom_artifact"],
+  };
+  return {
+    releaseId: release.releaseId,
+    bootstrapBody: runtime.bootstrapBody,
+    firstDisplayBody,
+    firstDisplaySrc,
+    runtimeBody: runtime.runtimeBody,
+    runtimeSrc: runtime.runtimeSrc,
+    deferred,
+    boot,
+    outline,
+  };
+}
+
+/** Serve a fixture from the exact content-addressed production route. */
+export async function routeRuntimeTsjsFixture(
+  page: Page,
+  fixture: RuntimeTsjsFixture,
+): Promise<void> {
+  const absoluteUrl = new URL(fixture.runtimeSrc, page.url()).toString();
+  await page.route(absoluteUrl, (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/javascript; charset=utf-8",
+      headers: { "x-content-type-options": "nosniff" },
+      body: fixture.runtimeBody,
+    }),
+  );
+}
+
+/** Execute a fixture through the authenticated parser-equivalent script boundary. */
+export async function loadRuntimeTsjsFixture(
+  page: Page,
+  fixture: RuntimeTsjsFixture,
+): Promise<void> {
+  await routeRuntimeTsjsFixture(page, fixture);
+  const boot = await page.evaluate(
+    () => (window as unknown as { tsjs: Record<string, unknown> }).tsjs.boot,
+  );
+  if (typeof boot !== "object" || boot === null || Array.isArray(boot)) {
+    throw new Error("TSJS runtime fixture boot is unavailable");
+  }
+  await page.addScriptTag({
+    content: `const __TSJS_SERVER_BOOT_TRANSPORT_V1__=${serverBootTransportLiteralV1(boot as ServerBootDigestInputV1)};${fixture.bootstrapBody}`,
+  });
+  await page.evaluate(
+    (src) =>
+      new Promise<void>((resolveLoad, rejectLoad) => {
+        const script = document.createElement("script");
+        script.id = "trustedserver-js";
+        script.src = src;
+        script.addEventListener("load", () => resolveLoad(), { once: true });
+        script.addEventListener(
+          "error",
+          () =>
+            rejectLoad(
+              new Error("persistent TSJS runtime fixture did not load"),
+            ),
+          { once: true },
+        );
+        document.head.appendChild(script);
+      }),
+    fixture.runtimeSrc,
+  );
+}
diff --git a/crates/trusted-server-integration-tests/browser/package-lock.json b/crates/trusted-server-integration-tests/browser/package-lock.json
index 00f5a6d07..39b512a1d 100644
--- a/crates/trusted-server-integration-tests/browser/package-lock.json
+++ b/crates/trusted-server-integration-tests/browser/package-lock.json
@@ -8,18 +8,7 @@
       "name": "integration-tests-browser",
       "version": "1.0.0",
       "devDependencies": {
-        "@playwright/test": "^1.49.0",
-        "prebid-universal-creative": "1.17.2"
-      }
-    },
-    "node_modules/@gulpjs/messages": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@gulpjs/messages/-/messages-1.1.0.tgz",
-      "integrity": "sha512-Ys9sazDatyTgZVb4xPlDufLweJ/Os2uHWOv+Caxvy2O85JcnT4M3vc73bi8pdLWlv3fdWQz3pdI9tVwo8rQQSg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.13.0"
+        "@playwright/test": "^1.49.0"
       }
     },
     "node_modules/@playwright/test": {
@@ -38,308 +27,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/array-each": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz",
-      "integrity": "sha512-zHjL5SZa68hkKHBFBK6DJCTtr9sfTCPCaph/L7tMSLcTFgy+zX7E+6q5UArbtOtMBCtxdICpfTCspRse+ywyXA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/array-slice": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz",
-      "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/babel-plugin-transform-object-assign": {
-      "version": "6.22.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-object-assign/-/babel-plugin-transform-object-assign-6.22.0.tgz",
-      "integrity": "sha512-N6Pddn/0vgLjnGr+mS7ttlFkQthqcnINE9EMOxB0CF8F4t6kuJXz6NUeLfSoRbLmkGh0mgDs9i2isdaZj0Ghtg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "babel-runtime": "^6.22.0"
-      }
-    },
-    "node_modules/babel-runtime": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz",
-      "integrity": "sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "core-js": "^2.4.0",
-        "regenerator-runtime": "^0.11.0"
-      }
-    },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
-    "node_modules/cliui": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
-      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.0",
-        "wrap-ansi": "^7.0.0"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/copy-props": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/copy-props/-/copy-props-4.0.0.tgz",
-      "integrity": "sha512-bVWtw1wQLzzKiYROtvNlbJgxgBYt2bMJpkCbKmXM3xyijvcjjWXEk5nyrrT3bgJ7ODb19ZohE2T0Y3FgNPyoTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "each-props": "^3.0.0",
-        "is-plain-object": "^5.0.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/core-js": {
-      "version": "2.6.12",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz",
-      "integrity": "sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==",
-      "deprecated": "core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "MIT"
-    },
-    "node_modules/detect-file": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz",
-      "integrity": "sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/each-props": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/each-props/-/each-props-3.0.0.tgz",
-      "integrity": "sha512-IYf1hpuWrdzse/s/YJOrFmU15lyhSzxelNVAHTEG3DtP4QsLTWZUzcUL3HMXmKQxXpa4EIrBPpwRgj0aehdvAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-plain-object": "^5.0.0",
-        "object.defaults": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/es-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
-      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/escalade": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/expand-tilde": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz",
-      "integrity": "sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "homedir-polyfill": "^1.0.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/extend": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
-      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/findup-sync": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-5.0.0.tgz",
-      "integrity": "sha512-MzwXju70AuyflbgeOhzvQWAvvQdo1XL0A9bVvlXsYcFEBM87WR4OakL4OfZq+QRmr+duJubio+UtNQCPsVESzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "detect-file": "^1.0.0",
-        "is-glob": "^4.0.3",
-        "micromatch": "^4.0.4",
-        "resolve-dir": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/fined": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/fined/-/fined-2.0.0.tgz",
-      "integrity": "sha512-OFRzsL6ZMHz5s0JrsEr+TpdGNCtrVtnuG3x1yzGNiQHT0yaDnXAj8V/lWcpJVrnoDpcwXcASxAZYbuXda2Y82A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "expand-tilde": "^2.0.2",
-        "is-plain-object": "^5.0.0",
-        "object.defaults": "^1.1.0",
-        "object.pick": "^1.3.0",
-        "parse-filepath": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/flagged-respawn": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-2.0.0.tgz",
-      "integrity": "sha512-Gq/a6YCi8zexmGHMuJwahTGzXlAZAOsbCVKduWXC6TlLCjjFRlExMJc4GC2NYPYZ0r/brw9P7CpRgQmlPVeOoA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/for-in": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz",
-      "integrity": "sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/for-own": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz",
-      "integrity": "sha512-0OABksIGrxKK8K4kynWkQ7y1zounQxP+CWnyclVwj81KW3vlLlGUx57DKGcP/LH216GzqnstnPocF16Nxs0Ycg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "for-in": "^1.0.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/fsevents": {
       "version": "2.3.2",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
@@ -355,450 +42,6 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
-    "node_modules/function-bind": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
-      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/get-caller-file": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
-      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "6.* || 8.* || >= 10.*"
-      }
-    },
-    "node_modules/global-modules": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz",
-      "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "global-prefix": "^1.0.1",
-        "is-windows": "^1.0.1",
-        "resolve-dir": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/global-prefix": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz",
-      "integrity": "sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "expand-tilde": "^2.0.2",
-        "homedir-polyfill": "^1.0.1",
-        "ini": "^1.3.4",
-        "is-windows": "^1.0.1",
-        "which": "^1.2.14"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/glogg": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/glogg/-/glogg-2.2.0.tgz",
-      "integrity": "sha512-eWv1ds/zAlz+M1ioHsyKJomfY7jbDDPpwSkv14KQj89bycx1nvK5/2Cj/T9g7kzJcX5Bc7Yv22FjfBZS/jl94A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "sparkles": "^2.1.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/gulp-cli": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/gulp-cli/-/gulp-cli-3.1.0.tgz",
-      "integrity": "sha512-zZzwlmEsTfXcxRKiCHsdyjZZnFvXWM4v1NqBJSYbuApkvVKivjcmOS2qruAJ+PkEHLFavcDKH40DPc1+t12a9Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@gulpjs/messages": "^1.1.0",
-        "chalk": "^4.1.2",
-        "copy-props": "^4.0.0",
-        "gulplog": "^2.2.0",
-        "interpret": "^3.1.1",
-        "liftoff": "^5.0.1",
-        "mute-stdout": "^2.0.0",
-        "replace-homedir": "^2.0.0",
-        "semver-greatest-satisfied-range": "^2.0.0",
-        "string-width": "^4.2.3",
-        "v8flags": "^4.0.0",
-        "yargs": "^16.2.0"
-      },
-      "bin": {
-        "gulp": "bin/gulp.js"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/gulplog": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/gulplog/-/gulplog-2.2.0.tgz",
-      "integrity": "sha512-V2FaKiOhpR3DRXZuYdRLn/qiY0yI5XmqbTKrYbdemJ+xOh2d2MOweI/XFgMzd/9+1twdvMwllnZbWZNJ+BOm4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "glogg": "^2.2.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/hasown": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
-      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "function-bind": "^1.1.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/homedir-polyfill": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz",
-      "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "parse-passwd": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/ini": {
-      "version": "1.3.8",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
-      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/interpret": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-3.1.1.tgz",
-      "integrity": "sha512-6xwYfHbajpoF0xLW+iwLkhwgvLoZDfjYfoFNu8ftMoXINzwuymNLd9u/KmwtdT2GbR+/Cz66otEGEVVUHX9QLQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/is-absolute": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz",
-      "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-relative": "^1.0.0",
-        "is-windows": "^1.0.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-core-module": {
-      "version": "2.16.2",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
-      "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-plain-object": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.1.0.tgz",
-      "integrity": "sha512-bUi/yjmtKYcRVUtWRGr0UA6xEFh2I6zWUwMrUXB3s7bmYCaZ8a+0ZsTRkrawh/mzlSD1Y0Ph8bp/U+TvBpWDNw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-relative": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz",
-      "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-unc-path": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-unc-path": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz",
-      "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "unc-path-regex": "^0.1.2"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-windows": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
-      "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-      "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/isobject": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/liftoff": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-5.0.1.tgz",
-      "integrity": "sha512-wwLXMbuxSF8gMvubFcFRp56lkFV69twvbU5vDPbaw+Q+/rF8j0HKjGbIdlSi+LuJm9jf7k9PB+nTxnsLMPcv2Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "extend": "^3.0.2",
-        "findup-sync": "^5.0.0",
-        "fined": "^2.0.0",
-        "flagged-respawn": "^2.0.0",
-        "is-plain-object": "^5.0.0",
-        "rechoir": "^0.8.0",
-        "resolve": "^1.20.0"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/map-cache": {
-      "version": "0.2.2",
-      "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz",
-      "integrity": "sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/micromatch": {
-      "version": "4.0.8",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
-      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "braces": "^3.0.3",
-        "picomatch": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=8.6"
-      }
-    },
-    "node_modules/mute-stdout": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/mute-stdout/-/mute-stdout-2.0.0.tgz",
-      "integrity": "sha512-32GSKM3Wyc8dg/p39lWPKYu8zci9mJFzV1Np9Of0ZEpe6Fhssn/FbI7ywAMd40uX+p3ZKh3T5EeCFv81qS3HmQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/object.defaults": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz",
-      "integrity": "sha512-c/K0mw/F11k4dEUBMW8naXUuBuhxRCfG7W+yFy8EcijU/rSmazOUd1XAEEe6bC0OuXY4HUKjTJv7xbxIMqdxrA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-each": "^1.0.1",
-        "array-slice": "^1.0.0",
-        "for-own": "^1.0.0",
-        "isobject": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/object.pick": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
-      "integrity": "sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "isobject": "^3.0.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/parse-filepath": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz",
-      "integrity": "sha512-FwdRXKCohSVeXqwtYonZTXtbGJKrn+HNyWDYVcp5yuJlesTwNH4rsmRZ+GrKAPJ5bLpRxESMeS+Rl0VCHRvB2Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-absolute": "^1.0.0",
-        "map-cache": "^0.2.0",
-        "path-root": "^0.1.1"
-      },
-      "engines": {
-        "node": ">=0.8"
-      }
-    },
-    "node_modules/parse-passwd": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz",
-      "integrity": "sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/path-root": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz",
-      "integrity": "sha512-QLcPegTHF11axjfojBIoDygmS2E3Lf+8+jI6wOVmNVenrKSo3mFdSGiIgdSHenczw3wPtlVMQaFVwGmM7BJdtg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-root-regex": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/path-root-regex": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz",
-      "integrity": "sha512-4GlJ6rZDhQZFE0DPVKh0e9jmZ5egZfxTkp7bcRDuPlJXbAwhxcl2dINPUAsjLdejqaLsCeg8axcLjIbvBjN4pQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/picomatch": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
-      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
-      }
-    },
     "node_modules/playwright": {
       "version": "1.58.2",
       "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.58.2.tgz",
@@ -830,312 +73,6 @@
       "engines": {
         "node": ">=18"
       }
-    },
-    "node_modules/postscribe": {
-      "version": "2.0.8",
-      "resolved": "https://registry.npmjs.org/postscribe/-/postscribe-2.0.8.tgz",
-      "integrity": "sha512-Sxt6pek38NKX85Vb/PbcritqVxsgPZQFLcuf4o0f7lXRb76jM0XP79SGwCBPRTuv+U2zqByQan8EzRjqquD73A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prescribe": ">=1.1.2"
-      }
-    },
-    "node_modules/prebid-universal-creative": {
-      "version": "1.17.2",
-      "resolved": "https://registry.npmjs.org/prebid-universal-creative/-/prebid-universal-creative-1.17.2.tgz",
-      "integrity": "sha512-+1fB/eD3eXF+m8T0S4GL/wrXatx/tpeTtZ6ptFQnjQxtejiM0GuoFWdJvx5xlqkP1Z14WEE6/eRc1zWcxvg/Dg==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "babel-plugin-transform-object-assign": "^6.22.0",
-        "gulp-cli": "^3.0.0",
-        "postscribe": "^2.0.8"
-      }
-    },
-    "node_modules/prescribe": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/prescribe/-/prescribe-1.1.3.tgz",
-      "integrity": "sha512-HEg0ElY5tmmCshST4tzl47+SirJO2cVo6j/+O4d6xIz+80ixNcN0GgPQsn76AgeTTIAQOrwq1rfoptubQuZ1Uw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/rechoir": {
-      "version": "0.8.0",
-      "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz",
-      "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "resolve": "^1.20.0"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/regenerator-runtime": {
-      "version": "0.11.1",
-      "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz",
-      "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/replace-homedir": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/replace-homedir/-/replace-homedir-2.0.0.tgz",
-      "integrity": "sha512-bgEuQQ/BHW0XkkJtawzrfzHFSN70f/3cNOiHa2QsYxqrjaC30X1k74FJ6xswVBP0sr0SpGIdVFuPwfrYziVeyw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/require-directory": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/resolve": {
-      "version": "1.22.12",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
-      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "is-core-module": "^2.16.1",
-        "path-parse": "^1.0.7",
-        "supports-preserve-symlinks-flag": "^1.0.0"
-      },
-      "bin": {
-        "resolve": "bin/resolve"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/resolve-dir": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz",
-      "integrity": "sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "expand-tilde": "^2.0.0",
-        "global-modules": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "optional": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      }
-    },
-    "node_modules/semver-greatest-satisfied-range": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-2.0.0.tgz",
-      "integrity": "sha512-lH3f6kMbwyANB7HuOWRMlLCa2itaCrZJ+SAqqkSZrZKO/cAsk2EOyaKHUtNkVLFyFW9pct22SFesFp3Z7zpA0g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "sver": "^1.8.3"
-      },
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/sparkles": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/sparkles/-/sparkles-2.1.0.tgz",
-      "integrity": "sha512-r7iW1bDw8R/cFifrD3JnQJX0K1jqT0kprL48BiBpLZLJPmAm34zsVBsK5lc7HirZYZqMW65dOXZgbAGt/I6frg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/string-width": {
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/strip-ansi": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/supports-preserve-symlinks-flag": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
-      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/sver": {
-      "version": "1.8.4",
-      "resolved": "https://registry.npmjs.org/sver/-/sver-1.8.4.tgz",
-      "integrity": "sha512-71o1zfzyawLfIWBOmw8brleKyvnbn73oVHNCsu51uPMz/HWiKkkXsI31JjHW5zqXEqnPYkIiHd8ZmL7FCimLEA==",
-      "dev": true,
-      "license": "MIT",
-      "optionalDependencies": {
-        "semver": "^6.3.0"
-      }
-    },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
-    "node_modules/unc-path-regex": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz",
-      "integrity": "sha512-eXL4nmJT7oCpkZsHZUOJo8hcX3GbsiDOa0Qu9F646fi8dT3XuSVopVqAcEiVzSKKH7UoDti23wNX3qGFxcW5Qg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/v8flags": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/v8flags/-/v8flags-4.0.1.tgz",
-      "integrity": "sha512-fcRLaS4H/hrZk9hYwbdRM35D0U8IYMfEClhXxCivOojl+yTRAZH3Zy2sSy6qVCiGbV9YAtPssP6jaChqC9vPCg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 10.13.0"
-      }
-    },
-    "node_modules/which": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
-      "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "isexe": "^2.0.0"
-      },
-      "bin": {
-        "which": "bin/which"
-      }
-    },
-    "node_modules/wrap-ansi": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/y18n": {
-      "version": "5.0.8",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yargs": {
-      "version": "16.2.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.2.tgz",
-      "integrity": "sha512-Nt9ZJjXTv5R8MHbqby/wXQ6Gi0Bb3TcYZkR1bzuL4yB2OxWPkXknz513gEF0GoA6tn00UpbPvERW8rzCuWCA6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^7.0.2",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.0",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^20.2.2"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/yargs-parser": {
-      "version": "20.2.9",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
-      "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=10"
-      }
     }
   }
 }
diff --git a/crates/trusted-server-integration-tests/browser/package.json b/crates/trusted-server-integration-tests/browser/package.json
index 42855b5b2..13282f289 100644
--- a/crates/trusted-server-integration-tests/browser/package.json
+++ b/crates/trusted-server-integration-tests/browser/package.json
@@ -8,7 +8,6 @@
     "test:wordpress": "TEST_FRAMEWORK=wordpress npx playwright test"
   },
   "devDependencies": {
-    "@playwright/test": "^1.49.0",
-    "prebid-universal-creative": "1.17.2"
+    "@playwright/test": "^1.49.0"
   }
 }
diff --git a/crates/trusted-server-integration-tests/browser/playwright.config.ts b/crates/trusted-server-integration-tests/browser/playwright.config.ts
index 8a1ef3b5b..961b947c9 100644
--- a/crates/trusted-server-integration-tests/browser/playwright.config.ts
+++ b/crates/trusted-server-integration-tests/browser/playwright.config.ts
@@ -1,5 +1,22 @@
 import { defineConfig } from "@playwright/test";
 
+const SUPPORTED_PROJECTS = ["chromium", "firefox", "webkit"] as const;
+const requestedProjects: string[] = (
+  process.env.TS_BROWSER_PROJECTS ?? "chromium"
+)
+  .split(/[\s,]+/u)
+  .filter(Boolean);
+
+for (const project of requestedProjects) {
+  if (
+    !SUPPORTED_PROJECTS.includes(project as (typeof SUPPORTED_PROJECTS)[number])
+  ) {
+    throw new Error(
+      `Unsupported TS_BROWSER_PROJECTS entry: ${project}. Expected chromium, firefox, or webkit.`,
+    );
+  }
+}
+
 export default defineConfig({
   testDir: "./tests",
   globalSetup: "./global-setup.ts",
@@ -13,12 +30,10 @@ export default defineConfig({
     screenshot: "only-on-failure",
     trace: "retain-on-failure",
   },
-  projects: [
-    {
-      name: "chromium",
-      use: { browserName: "chromium" },
-    },
-  ],
+  projects: requestedProjects.map((name) => ({
+    name,
+    use: { browserName: name as "chromium" | "firefox" | "webkit" },
+  })),
   reporter: [["list"], ["html", { open: "never" }]],
   outputDir: "./test-results",
 });
diff --git a/crates/trusted-server-integration-tests/browser/playwright.performance.config.ts b/crates/trusted-server-integration-tests/browser/playwright.performance.config.ts
new file mode 100644
index 000000000..6732fc077
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/playwright.performance.config.ts
@@ -0,0 +1,12 @@
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  testDir: ".",
+  timeout: 30_000,
+  retries: 0,
+  workers: 1,
+  use: { headless: true },
+  projects: [{ name: "chromium", use: { browserName: "chromium" } }],
+  reporter: [["list"]],
+  outputDir: "./test-results",
+});
diff --git a/crates/trusted-server-integration-tests/browser/playwright.real-gam.config.ts b/crates/trusted-server-integration-tests/browser/playwright.real-gam.config.ts
new file mode 100644
index 000000000..4ad640888
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/playwright.real-gam.config.ts
@@ -0,0 +1,39 @@
+import { defineConfig } from "@playwright/test";
+
+const pageUrl = process.env.TS_REAL_GAM_PAGE_URL;
+const authorization = process.env.TS_REAL_GAM_AUTH_HEADER;
+const releaseId = process.env.TS_REAL_GAM_EXPECTED_RELEASE_ID;
+
+if (!pageUrl || !authorization || !releaseId) {
+  throw new Error(
+    "TS_REAL_GAM_PAGE_URL, TS_REAL_GAM_AUTH_HEADER, and TS_REAL_GAM_EXPECTED_RELEASE_ID are required",
+  );
+}
+
+export default defineConfig({
+  testDir: "./tests/shared",
+  testMatch: "aps-real-gam.spec.ts",
+  timeout: 75_000,
+  expect: { timeout: 15_000 },
+  retries: 0,
+  workers: 3,
+  fullyParallel: false,
+  forbidOnly: true,
+  use: {
+    headless: true,
+    extraHTTPHeaders: { Authorization: authorization },
+    ignoreHTTPSErrors: false,
+    screenshot: "off",
+    trace: "off",
+    video: "off",
+  },
+  projects: (["chromium", "firefox", "webkit"] as const).map((browserName) => ({
+    name: browserName,
+    use: { browserName },
+  })),
+  reporter: [
+    ["list"],
+    ["html", { open: "never", outputFolder: "playwright-report" }],
+  ],
+  outputDir: "./test-results",
+});
diff --git a/crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts b/crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts
index 55996306a..072a2bdfd 100644
--- a/crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts
+++ b/crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts
@@ -3,6 +3,12 @@ import { installGptStub } from "../../helpers/gpt-stub.js";
 import { readState, runtimeUrl } from "../../helpers/state.js";
 
 const HOST_ID = "trusted-server-gpt-diagnostics";
+const TAKEOVER_TSJS_MODULE =
+    /tsjs=tsjs-unified(?:\.min)?\.js(?:[?#]|$)/i;
+const STANDALONE_GPT_DIAGNOSTICS_MODULE =
+    /tsjs=tsjs-gpt_diagnostics(?:\.min)?\.js(?:[?#]|$)/i;
+const DIAGNOSTICS_PRESENTATION_MODULE =
+    /tsjs=tsjs-diagnostics_presentation(?:\.min)?\.js(?:[?#]|$)/i;
 const EVENT_NAMES = [
     "slotRequested",
     "slotResponseReceived",
@@ -19,9 +25,32 @@ test.beforeEach(async ({ page }, testInfo) => {
 });
 
 async function waitForApi(page: Page): Promise<void> {
-    await page.waitForFunction(() =>
-        Boolean((window as any).tsjs?.gptDiagnostics),
-    );
+    try {
+        await page.waitForFunction(
+            () => Boolean((window as any).tsjs?.diagnostics?.gpt),
+            undefined,
+            { timeout: 10_000 },
+        );
+    } catch (error) {
+        const state = await page.evaluate(() => {
+            const api = (window as any).tsjs;
+            return {
+                internal: api?._internal,
+                names: Object.getOwnPropertyNames(api ?? {}).sort(),
+                diagnostics: Object.getOwnPropertyNames(
+                    api?.diagnostics ?? {},
+                ).sort(),
+                bootGptActive: api?.boot?.diagnostics?.gpt?.active,
+                listeners: (
+                    window as any
+                ).__gptDiagnosticsStub.listenerCounts(),
+            };
+        });
+        throw new Error(
+            `GPT diagnostics API did not activate: ${JSON.stringify(state)}`,
+            { cause: error },
+        );
+    }
 }
 
 async function emit(
@@ -49,7 +78,7 @@ test.describe("GPT runtime diagnostics", () => {
         const diagnosticNetworkRequests: string[] = [];
         const diagnosticModuleRequests: string[] = [];
         page.on("request", (request) => {
-            if (/tsjs-gpt_diagnostics/i.test(request.url())) {
+            if (STANDALONE_GPT_DIAGNOSTICS_MODULE.test(request.url())) {
                 diagnosticModuleRequests.push(request.url());
             }
             if (
@@ -64,7 +93,11 @@ test.describe("GPT runtime diagnostics", () => {
 
         expect(
             await page.evaluate(() => ({
-                api: Boolean((window as any).tsjs?.gptDiagnostics),
+                api: Boolean((window as any).tsjs?.diagnostics?.gpt),
+                legacyApi: Object.prototype.hasOwnProperty.call(
+                    (window as any).tsjs,
+                    "gptDiagnostics",
+                ),
                 host: Boolean(
                     document.getElementById("trusted-server-gpt-diagnostics"),
                 ),
@@ -72,20 +105,28 @@ test.describe("GPT runtime diagnostics", () => {
                     window as any
                 ).__gptDiagnosticsStub.listenerCounts(),
             })),
-        ).toEqual({ api: false, host: false, listenerCounts: {} });
+        ).toEqual({
+            api: false,
+            legacyApi: false,
+            host: false,
+            listenerCounts: { slotRequested: 1, slotRenderEnded: 1 },
+        });
         expect(diagnosticNetworkRequests).toEqual([]);
         expect(diagnosticModuleRequests).toEqual([]);
     });
 
-    test("activates, cleans the URL, persists in the browser session, and deactivates", async ({
+    test("activates, cleans the URL, enforces the session contract, and deactivates", async ({
         browser,
+        browserName,
         page,
     }) => {
-        const moduleRequests: string[] = [];
+        const takeoverRequests: string[] = [];
+        const standaloneDiagnosticsRequests: string[] = [];
         page.on("request", (request) => {
-            if (/tsjs-gpt_diagnostics/i.test(request.url())) {
-                moduleRequests.push(request.url());
-            }
+            if (TAKEOVER_TSJS_MODULE.test(request.url()))
+                takeoverRequests.push(request.url());
+            if (STANDALONE_GPT_DIAGNOSTICS_MODULE.test(request.url()))
+                standaloneDiagnosticsRequests.push(request.url());
         });
         const activationResponse = await page.goto(
             runtimeUrl(
@@ -98,11 +139,31 @@ test.describe("GPT runtime diagnostics", () => {
         expect(activationResponse?.headers()["cache-control"]).toContain(
             "no-store",
         );
-        expect(moduleRequests).toHaveLength(1);
+        expect(takeoverRequests).toHaveLength(1);
+        expect(standaloneDiagnosticsRequests).toEqual([]);
         const activationCookie = (await page.context().cookies()).find(
             (cookie) => cookie.name === "__Host-ts-console",
         );
-        expect(activationCookie).toMatchObject({ value: "1", httpOnly: true });
+        // WebKit does not persist Secure cookies delivered by the suite's local
+        // HTTP transport. The response contract is still asserted above, while
+        // Chromium and Firefox exercise the browser-managed session lifecycle.
+        const supportsHarnessSecureCookie =
+            browserName !== "webkit" ||
+            new URL(page.url()).protocol === "https:";
+        if (supportsHarnessSecureCookie) {
+            expect(activationCookie).toMatchObject({
+                value: "1",
+                path: "/",
+                secure: true,
+                httpOnly: true,
+                sameSite: "Lax",
+            });
+        } else {
+            expect(activationCookie).toBeUndefined();
+            expect(activationResponse?.headers()["set-cookie"]).toContain(
+                "__Host-ts-console=1; Path=/; Secure; HttpOnly; SameSite=Lax",
+            );
+        }
         expect(new URL(page.url()).search).toBe("?unrelated=kept");
         expect(new URL(page.url()).hash).toBe("#fixture");
         const listenerCounts = await page.evaluate(() =>
@@ -111,44 +172,51 @@ test.describe("GPT runtime diagnostics", () => {
         for (const eventName of EVENT_NAMES)
             expect(listenerCounts[eventName]).toBe(1);
 
-        await page
-            .getByRole("navigation", { name: "Fixture navigation" })
-            .getByRole("link", { name: "Home" })
-            .click();
-        await page.waitForURL("**/");
-        expect(
-            await page.evaluate(() =>
-                Boolean((window as any).tsjs?.gptDiagnostics),
-            ),
-        ).toBe(true);
-        await page.goBack();
-        await page.waitForURL("**/gpt-diagnostics?unrelated=kept#fixture");
-        await waitForApi(page);
-
-        const sameSessionPage = await page.context().newPage();
-        await installGptStub(sameSessionPage);
-        await sameSessionPage.goto(runtimeUrl("/gpt-diagnostics"), {
-            waitUntil: "load",
-        });
-        await waitForApi(sameSessionPage);
-        await sameSessionPage.close();
+        if (supportsHarnessSecureCookie) {
+            await page
+                .getByRole("navigation", { name: "Fixture navigation" })
+                .getByRole("link", { name: "Home" })
+                .click();
+            await page.waitForURL("**/");
+            expect(
+                await page.evaluate(() =>
+                    Boolean((window as any).tsjs?.diagnostics?.gpt),
+                ),
+            ).toBe(true);
+            await page.goBack();
+            await page.waitForURL("**/gpt-diagnostics?unrelated=kept#fixture");
+            await waitForApi(page);
 
-        await page.goto(
-            runtimeUrl("/gpt-diagnostics?unrelated=second#persisted"),
-            {
+            const sameSessionPage = await page.context().newPage();
+            await installGptStub(sameSessionPage);
+            await sameSessionPage.goto(runtimeUrl("/gpt-diagnostics"), {
                 waitUntil: "load",
-            },
-        );
-        await waitForApi(page);
-        expect(new URL(page.url()).search).toBe("?unrelated=second");
-        expect(new URL(page.url()).hash).toBe("#persisted");
+            });
+            await waitForApi(sameSessionPage);
+            await sameSessionPage.close();
+
+            await page.goto(
+                runtimeUrl("/gpt-diagnostics?unrelated=second#persisted"),
+                {
+                    waitUntil: "load",
+                },
+            );
+            await waitForApi(page);
+            expect(new URL(page.url()).search).toBe("?unrelated=second");
+            expect(new URL(page.url()).hash).toBe("#persisted");
+        }
 
-        await page.goto(
+        const deactivationResponse = await page.goto(
             runtimeUrl(
                 "/gpt-diagnostics?unrelated=kept&ts_console=false#disabled",
             ),
             { waitUntil: "load" },
         );
+        if (!supportsHarnessSecureCookie) {
+            expect(deactivationResponse?.headers()["set-cookie"]).toContain(
+                "__Host-ts-console=; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=0",
+            );
+        }
         expect(new URL(page.url()).search).toBe("?unrelated=kept");
         expect(new URL(page.url()).hash).toBe("#disabled");
         expect(
@@ -158,7 +226,11 @@ test.describe("GPT runtime diagnostics", () => {
         ).toBe(false);
         expect(
             await page.evaluate(() => ({
-                api: Boolean((window as any).tsjs?.gptDiagnostics),
+                api: Boolean((window as any).tsjs?.diagnostics?.gpt),
+                legacyApi: Object.prototype.hasOwnProperty.call(
+                    (window as any).tsjs,
+                    "gptDiagnostics",
+                ),
                 host: Boolean(
                     document.getElementById("trusted-server-gpt-diagnostics"),
                 ),
@@ -166,7 +238,12 @@ test.describe("GPT runtime diagnostics", () => {
                     window as any
                 ).__gptDiagnosticsStub.listenerCounts(),
             })),
-        ).toEqual({ api: false, host: false, listeners: {} });
+        ).toEqual({
+            api: false,
+            legacyApi: false,
+            host: false,
+            listeners: { slotRequested: 1, slotRenderEnded: 1 },
+        });
 
         const separateContext = await browser.newContext();
         const separatePage = await separateContext.newPage();
@@ -176,7 +253,7 @@ test.describe("GPT runtime diagnostics", () => {
         });
         expect(
             await separatePage.evaluate(() =>
-                Boolean((window as any).tsjs?.gptDiagnostics),
+                Boolean((window as any).tsjs?.diagnostics?.gpt),
             ),
         ).toBe(false);
         await separatePage.waitForLoadState("networkidle");
@@ -186,10 +263,14 @@ test.describe("GPT runtime diagnostics", () => {
     test("captures lifecycle truth, conservative overlap, binding changes, remount, and export", async ({
         page,
     }, testInfo) => {
+        test.setTimeout(60_000);
         const pageErrors: string[] = [];
         const diagnosticNetworkRequests: string[] = [];
+        const presentationModuleRequests: string[] = [];
         page.on("pageerror", (error) => pageErrors.push(error.message));
         page.on("request", (request) => {
+            if (DIAGNOSTICS_PRESENTATION_MODULE.test(request.url()))
+                presentationModuleRequests.push(request.url());
             if (
                 ["fetch", "xhr", "beacon"].includes(request.resourceType()) &&
                 /diagnostic|trace/i.test(request.url())
@@ -205,7 +286,10 @@ test.describe("GPT runtime diagnostics", () => {
         await page.evaluate(() =>
             (window as any).__gptDiagnosticsStub.captureReferences(),
         );
-        await expect(page.locator(`#${HOST_ID}`)).toHaveCount(1);
+        await expect(page.locator(`#${HOST_ID}`)).toHaveCount(1, {
+            timeout: 15_000,
+        });
+        expect(presentationModuleRequests).toHaveLength(1);
         expect(
             await page
                 .locator(`#${HOST_ID}`)
@@ -252,14 +336,14 @@ test.describe("GPT runtime diagnostics", () => {
         );
 
         await page.waitForFunction(() => {
-            const snapshot = (window as any).tsjs.gptDiagnostics.snapshot();
+            const snapshot = (window as any).tsjs.diagnostics.gpt.snapshot();
             return (
                 snapshot.slots.length === 2 &&
                 snapshot.callbackIssues.length > 0
             );
         });
         const snapshot = await page.evaluate(() =>
-            (window as any).tsjs.gptDiagnostics.snapshot(),
+            (window as any).tsjs.diagnostics.gpt.snapshot(),
         );
         expect(snapshot.slots).toHaveLength(2);
         const primary = snapshot.slots.find(
@@ -303,13 +387,13 @@ test.describe("GPT runtime diagnostics", () => {
         await page.getByRole("button", { name: "Toggle duplicate ID" }).click();
         await page.waitForFunction(
             () =>
-                (window as any).tsjs.gptDiagnostics.snapshot().slots[0].binding
+                (window as any).tsjs.diagnostics.gpt.snapshot().slots[0].binding
                     .status === "ambiguous",
         );
         expect(
             await page.evaluate(
                 () =>
-                    (window as any).tsjs.gptDiagnostics.snapshot().slots[0]
+                    (window as any).tsjs.diagnostics.gpt.snapshot().slots[0]
                         .binding,
             ),
         ).toEqual({ status: "ambiguous", reason: "duplicate_dom_id" });
@@ -319,7 +403,7 @@ test.describe("GPT runtime diagnostics", () => {
             .click();
         await page.waitForFunction(
             () =>
-                (window as any).tsjs.gptDiagnostics.snapshot().slots[0].binding
+                (window as any).tsjs.diagnostics.gpt.snapshot().slots[0].binding
                     .status === "bound",
         );
 
@@ -328,13 +412,13 @@ test.describe("GPT runtime diagnostics", () => {
             .click();
         await expect(page.locator(`#${HOST_ID}`)).toHaveCount(1);
 
-        await page.evaluate(() => (window as any).tsjs.gptDiagnostics.hide());
+        await page.evaluate(() => (window as any).tsjs.diagnostics.gpt.hide());
         await expect(page.locator(`#${HOST_ID}`)).toHaveCount(0);
         await emit(page, "slotRequested", "gpt-diagnostics-slot-secondary");
-        await page.evaluate(() => (window as any).tsjs.gptDiagnostics.show());
+        await page.evaluate(() => (window as any).tsjs.diagnostics.gpt.show());
         await expect(page.locator(`#${HOST_ID}`)).toHaveCount(1);
         const hiddenPeriodSnapshot = await page.evaluate(() =>
-            (window as any).tsjs.gptDiagnostics.snapshot(),
+            (window as any).tsjs.diagnostics.gpt.snapshot(),
         );
         expect(
             hiddenPeriodSnapshot.slots.find(
@@ -344,7 +428,9 @@ test.describe("GPT runtime diagnostics", () => {
         ).toHaveLength(2);
 
         const downloadPromise = page.waitForEvent("download");
-        await page.evaluate(() => (window as any).tsjs.gptDiagnostics.export());
+        await page.evaluate(() =>
+            (window as any).tsjs.diagnostics.gpt.export(),
+        );
         const download = await downloadPromise;
         expect(download.suggestedFilename()).toMatch(
             /^trusted-server-gpt-diagnostics-.*\.json$/,
@@ -368,9 +454,9 @@ test.describe("GPT runtime diagnostics", () => {
 
         expect(
             await page.evaluate(() =>
-                (window as any).__gptDiagnosticsStub.referencesUnchanged(),
+                (window as any).__gptDiagnosticsStub.referenceOwnership(),
             ),
-        ).toBe(true);
+        ).toEqual({ diagnosticsSafe: true, pairedHistoryWrappers: true });
         expect(
             await page
                 .locator("#gpt-diagnostics-slot-primary")
diff --git a/crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts b/crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts
index f7643d932..a4d7df2c2 100644
--- a/crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts
+++ b/crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts
@@ -1,6 +1,19 @@
 import { test, expect, type Page } from "@playwright/test";
 import { readState, runtimeUrl } from "../../helpers/state.js";
 
+const KERNEL_API_NAMES = [
+  "_internal",
+  "_registerIntegration",
+  "addAdUnits",
+  "boot",
+  "diagnostics",
+  "log",
+  "que",
+  "releaseId",
+  "requestAds",
+  "version",
+] as const;
+
 test.beforeEach(async ({}, testInfo) => {
   const state = readState();
   if (state.framework !== "nextjs") {
@@ -22,6 +35,38 @@ async function waitForHydration(page: Page): Promise<void> {
   });
 }
 
+async function captureKernel(page: Page): Promise<void> {
+  await page.waitForFunction(
+    () => (window as any).tsjs?._internal?.state === "kernel",
+  );
+  expect(
+    await page.evaluate(() => {
+      const browserWindow = window as any;
+      browserWindow.__initialTsjsReference = browserWindow.tsjs;
+      return {
+        names: Object.getOwnPropertyNames(browserWindow.tsjs).sort(),
+        legacy: Object.prototype.hasOwnProperty.call(
+          browserWindow.tsjs,
+          "gptDiagnostics",
+        ),
+      };
+    }),
+  ).toEqual({ names: KERNEL_API_NAMES, legacy: false });
+}
+
+async function expectSameKernel(page: Page): Promise<void> {
+  expect(
+    await page.evaluate(() => {
+      const browserWindow = window as any;
+      return {
+        sameOwner: browserWindow.tsjs === browserWindow.__initialTsjsReference,
+        state: browserWindow.tsjs?._internal?.state,
+        names: Object.getOwnPropertyNames(browserWindow.tsjs).sort(),
+      };
+    }),
+  ).toEqual({ sameOwner: true, state: "kernel", names: KERNEL_API_NAMES });
+}
+
 test.describe("Next.js client-side navigation", () => {
   test("4-page SPA navigation chain preserves script injection without full reload", async ({
     page,
@@ -33,6 +78,7 @@ test.describe("Next.js client-side navigation", () => {
 
     // Script present on initial load
     await expect(page.locator("script#trustedserver-js")).toHaveCount(1);
+    await captureKernel(page);
 
     // Wait for the client router to hydrate before clicking any links.
     await waitForHydration(page);
@@ -50,16 +96,19 @@ test.describe("Next.js client-side navigation", () => {
     await page.click('#site-nav a[href="/about"]');
     await page.waitForURL("**/about", { waitUntil: "domcontentloaded" });
     await expect(page.locator("script#trustedserver-js")).toHaveCount(1);
+    await expectSameKernel(page);
 
     // Navigate: About → Dashboard
     await page.click('#site-nav a[href="/dashboard"]');
     await page.waitForURL("**/dashboard", { waitUntil: "domcontentloaded" });
     await expect(page.locator("script#trustedserver-js")).toHaveCount(1);
+    await expectSameKernel(page);
 
     // Navigate: Dashboard → Contact
     await page.click('#site-nav a[href="/contact"]');
     await page.waitForURL("**/contact", { waitUntil: "domcontentloaded" });
     await expect(page.locator("script#trustedserver-js")).toHaveCount(1);
+    await expectSameKernel(page);
 
     // Prove all navigations were true SPA — no document-level requests fired
     expect(documentRequests).toEqual([]);
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts
new file mode 100644
index 000000000..5ea4ce5dc
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts
@@ -0,0 +1,597 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { expect, test, type Page } from "@playwright/test";
+import { installGptStub } from "../../helpers/gpt-stub.js";
+import { runtimeUrl } from "../../helpers/state.js";
+import {
+  loadRuntimeTsjsFixture,
+  runtimeTsjsFixture,
+} from "../../helpers/tsjs-fixture.js";
+
+const GPT_FIXTURE = runtimeTsjsFixture(["render_runtime", "aps", "gpt"]);
+
+const SLOT = "puc-lifecycle-slot";
+const RESERVATION_ID = "r1_AAAAAAAAAAAAAAAAAAAAAA";
+const APS_RENDERER_URL = "https://puc.test/integrations/aps/renderer/v2";
+const APS_RUNNER_URL = "https://puc.test/integrations/aps/runner.js";
+const FICTIONAL_APS_RUNNER = readFileSync(
+  resolve(__dirname, "../../fixtures/fictional-aps-runner.js"),
+  "utf8",
+);
+
+function apsDescriptor() {
+  const bid = {
+    id: "duplicate-puc-top-mount-bid",
+    price: 1.25,
+    w: 300,
+    h: 250,
+    ext: {
+      creativeurl: "https://creative.example/render",
+      tagtype: "iframe",
+    },
+  };
+  return {
+    type: "aps",
+    version: 1,
+    accountId: "fictional-account",
+    bidId: bid.id,
+    creativeId: "fictional-creative",
+    tagType: bid.ext.tagtype,
+    creativeUrl: bid.ext.creativeurl,
+    aaxResponse: Buffer.from(
+      JSON.stringify({ seatbid: [{ bid: [bid] }] }),
+      "utf8",
+    ).toString("base64"),
+    width: bid.w,
+    height: bid.h,
+  };
+}
+
+function boot() {
+  return {
+    abi: 1,
+    releaseId: GPT_FIXTURE.releaseId,
+    manifest: GPT_FIXTURE.manifest,
+    auctionProjection: {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: "puc-browser-lifecycle",
+        results: [
+          { slot: SLOT, outcome: "winner", candidateId: "AAAAAAAAAAAA" },
+        ],
+      },
+      slots: [
+        {
+          slot: SLOT,
+          gamUnitPath: `/123/${SLOT}`,
+          divId: SLOT,
+          formats: [[300, 250]],
+          targeting: {},
+        },
+      ],
+      bids: [
+        {
+          candidateId: "AAAAAAAAAAAA",
+          slot: SLOT,
+          provider: "fictional",
+          upstreamBidId: "puc-browser-bid",
+          cpm: 1.25,
+          currency: "USD",
+          targeting: { hb_bidder: "fictional" },
+          rendererReservationId: RESERVATION_ID,
+          renderSource: apsDescriptor(),
+        },
+      ],
+    },
+    integrations: {
+      version: 1,
+      entries: [
+        { id: "aps", config: {} },
+        {
+          id: "gpt",
+          config: {
+            gamAttributionEnabled: false,
+            pageBidsEnabled: true,
+          },
+        },
+      ],
+    },
+    creative: {
+      version: 1,
+      enabled: false,
+      clickGuard: false,
+      renderGuard: false,
+    },
+    diagnostics: {
+      version: 1,
+      renderTraceOverlay: false,
+      gpt: { active: false },
+    },
+  };
+}
+
+async function openLifecyclePage(
+  page: Page,
+  nonemptyCompletionOnDisplay = false,
+): Promise<void> {
+  await installGptStub(page);
+  const rendererResponse = await page.request.get(
+    runtimeUrl("/integrations/aps/renderer/v2"),
+  );
+  expect(rendererResponse.status()).toBe(200);
+  const rendererDocument = await rendererResponse.text();
+  await page.route(APS_RENDERER_URL, (route) =>
+    route.fulfill({
+      status: 200,
+      body: rendererDocument,
+      headers: {
+        "content-type": "text/html; charset=utf-8",
+        "content-security-policy":
+          rendererResponse.headers()["content-security-policy"] ?? "",
+        "referrer-policy": "no-referrer",
+        "x-content-type-options": "nosniff",
+      },
+    }),
+  );
+  await page.route(APS_RUNNER_URL, (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/javascript",
+      body: FICTIONAL_APS_RUNNER,
+    }),
+  );
+  await page.route("https://puc.test/fixture", (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "text/html",
+      body: `<!doctype html><div id="${SLOT}"></div>`,
+    }),
+  );
+  await page.goto("https://puc.test/fixture");
+  await page.evaluate(
+    ({ initialBoot, completeOnDisplay }) => {
+      const browserWindow = window as unknown as {
+        tsjs: Record<string, unknown>;
+        __gptDiagnosticsStub: {
+          emitNonemptyCompletionOnDisplay(): void;
+          emitRequestStartOnDisplay(): void;
+        };
+      };
+      browserWindow.__gptDiagnosticsStub.emitRequestStartOnDisplay();
+      if (completeOnDisplay) {
+        browserWindow.__gptDiagnosticsStub.emitNonemptyCompletionOnDisplay();
+      }
+      browserWindow.tsjs = {
+        boot: initialBoot,
+        que: [],
+      };
+    },
+    {
+      initialBoot: boot(),
+      completeOnDisplay: nonemptyCompletionOnDisplay,
+    },
+  );
+  await loadRuntimeTsjsFixture(page, GPT_FIXTURE);
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          (
+            window as unknown as {
+              tsjs?: { _internal?: { state?: string } };
+            }
+          ).tsjs?._internal?.state,
+      ),
+    )
+    .toMatch(/^(?:kernel|fallback)$/u);
+  const runtimeState = await page.evaluate(() => {
+    const browserWindow = window as unknown as {
+      tsjs?: { _internal?: unknown };
+    };
+    return {
+      internal: browserWindow.tsjs?._internal,
+      marks: performance
+        .getEntriesByType("mark")
+        .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+    };
+  });
+  expect(runtimeState.internal, JSON.stringify(runtimeState)).toMatchObject({
+    state: "kernel",
+  });
+  await expect
+    .poll(() =>
+      page.evaluate(() =>
+        (
+          window as unknown as {
+            __gptDiagnosticsStub: { displayCount(): number };
+          }
+        ).__gptDiagnosticsStub.displayCount(),
+      ),
+    )
+    .toBe(1);
+}
+
+async function emitNonemptyGam(page: Page): Promise<void> {
+  await page.evaluate((slot) => {
+    const stub = (
+      window as unknown as {
+        __gptDiagnosticsStub: {
+          emit(
+            name: string,
+            slotId: string,
+            facts?: Record<string, unknown>,
+          ): void;
+        };
+      }
+    ).__gptDiagnosticsStub;
+    stub.emit("slotRenderEnded", slot, {
+      isEmpty: false,
+      responseIdentifier: "fictional-response-1",
+    });
+  }, SLOT);
+}
+
+async function startFictionalPuc(page: Page): Promise<void> {
+  await page.evaluate(
+    ({ slot, reservationId }) =>
+      (
+        window as unknown as {
+          __gptDiagnosticsStub: {
+            renderUniversalCreative(slotId: string, adId: string): void;
+          };
+        }
+      ).__gptDiagnosticsStub.renderUniversalCreative(slot, reservationId),
+    { slot: SLOT, reservationId: RESERVATION_ID },
+  );
+}
+
+async function expectAcceptedLifecycle(page: Page): Promise<void> {
+  await expect
+    .poll(() =>
+      page.evaluate(() =>
+        (
+          window as unknown as {
+            __gptDiagnosticsStub: {
+              universalCreativeSnapshot(): Readonly<Record<string, unknown>>;
+            };
+          }
+        ).__gptDiagnosticsStub.universalCreativeSnapshot(),
+      ),
+    )
+    .toEqual({
+      lifecycle: ["accepted"],
+      pucFrames: 1,
+      ownerFrames: [0],
+      ownerSources: [""],
+      emissions: [
+        { name: "slotRequested", listeners: 1, physical: true },
+        { name: "slotRenderEnded", listeners: 1, physical: true },
+      ],
+      listeners: expect.objectContaining({
+        slotRequested: 1,
+        slotRenderEnded: 1,
+      }),
+      displays: [SLOT],
+      refreshes: [],
+      slotChildren: [
+        { tag: "IFRAME", fictionalPuc: true, title: null, adm: false },
+        {
+          tag: "IFRAME",
+          fictionalPuc: false,
+          title: "Ad content",
+          adm: false,
+        },
+      ],
+    });
+
+  expect(
+    await page.evaluate((slot) => {
+      const root = document.getElementById(slot);
+      const puc = root?.querySelector<HTMLIFrameElement>(
+        "iframe[data-fictional-puc]",
+      );
+      const creative = root?.querySelector<HTMLIFrameElement>(
+        ':scope > iframe[title="Ad content"]',
+      );
+      return {
+        hbAdId: (
+          window as unknown as {
+            __gptDiagnosticsStub: {
+              targeting(slotId: string, key: string): readonly string[];
+            };
+          }
+        ).__gptDiagnosticsStub.targeting(slot, "hb_adid"),
+        pucCount: root?.querySelectorAll("iframe[data-fictional-puc]").length,
+        ownerCreativeCount: puc?.contentDocument?.querySelectorAll(
+          'iframe[title="Ad content"]',
+        ).length,
+        creativeCount: root?.querySelectorAll(
+          ':scope > iframe[title="Ad content"]',
+        ).length,
+        creativeWidth: creative?.getAttribute("width"),
+        creativeHeight: creative?.getAttribute("height"),
+        creativeVisibility: creative?.style.visibility,
+      };
+    }, SLOT),
+  ).toEqual({
+    hbAdId: [RESERVATION_ID],
+    pucCount: 1,
+    creativeCount: 1,
+    creativeWidth: "300",
+    creativeHeight: "250",
+    creativeVisibility: "visible",
+    ownerCreativeCount: 0,
+  });
+}
+
+test.describe("APS/PUC lifecycle over the hard-cutover runtime", () => {
+  test("joins a PUC claim buffered before attributable GAM completion", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await startFictionalPuc(page);
+    await emitNonemptyGam(page);
+    await expectAcceptedLifecycle(page);
+  });
+
+  test("joins a PUC claim arriving after attributable GAM completion", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page, true);
+    await startFictionalPuc(page);
+    await expectAcceptedLifecycle(page);
+  });
+
+  test("contains a simultaneous duplicate PUC claim without duplicating the creative", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await page.evaluate(
+      ({ slot, reservationId }) => {
+        const stub = (
+          window as unknown as {
+            __gptDiagnosticsStub: {
+              renderUniversalCreative(slotId: string, adId: string): void;
+            };
+          }
+        ).__gptDiagnosticsStub;
+        stub.renderUniversalCreative(slot, reservationId);
+        stub.renderUniversalCreative(slot, reservationId);
+      },
+      { slot: SLOT, reservationId: RESERVATION_ID },
+    );
+    await emitNonemptyGam(page);
+
+    await expect
+      .poll(() =>
+        page.evaluate(() =>
+          (
+            window as unknown as {
+              __gptDiagnosticsStub: {
+                universalCreativeSnapshot(): Readonly<{
+                  lifecycle: readonly string[];
+                  ownerFrames: readonly number[];
+                  pucFrames: number;
+                }>;
+              };
+            }
+          ).__gptDiagnosticsStub.universalCreativeSnapshot(),
+        ),
+      )
+      .toMatchObject({
+        lifecycle: ["accepted", "failed:fictional PUC response refused"],
+        ownerFrames: [0, 0],
+        pucFrames: 2,
+      });
+
+    expect(
+      await page.evaluate((slot) => {
+        const root = document.getElementById(slot);
+        const pucFrames = Array.from(
+          root?.querySelectorAll<HTMLIFrameElement>(
+            "iframe[data-fictional-puc]",
+          ) ?? [],
+        );
+        return {
+          pucFrames: pucFrames.length,
+          ownerCreativeFrames: pucFrames.reduce(
+            (total, frame) =>
+              total +
+              (frame.contentDocument?.querySelectorAll(
+                'iframe[title="Ad content"]',
+              ).length ?? 0),
+            0,
+          ),
+          topCreativeFrames:
+            root?.querySelectorAll(':scope > iframe[title="Ad content"]')
+              .length ?? 0,
+        };
+      }, SLOT),
+    ).toEqual({
+      pucFrames: 2,
+      ownerCreativeFrames: 0,
+      topCreativeFrames: 1,
+    });
+  });
+
+  test("retires the exact APS overlay before a publisher refresh returns", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await startFictionalPuc(page);
+    await emitNonemptyGam(page);
+    await expectAcceptedLifecycle(page);
+
+    expect(
+      await page.evaluate((slot) => {
+        const stub = (
+          window as unknown as {
+            __gptDiagnosticsStub: {
+              publisherRefresh(slotId: string): void;
+              universalCreativeSnapshot(): Readonly<{
+                lifecycle: readonly string[];
+              }>;
+            };
+          }
+        ).__gptDiagnosticsStub;
+        stub.publisherRefresh(slot);
+        const root = document.getElementById(slot);
+        return {
+          lifecycle: stub.universalCreativeSnapshot().lifecycle,
+          position: root?.style.getPropertyValue("position"),
+          pucFrames:
+            root?.querySelectorAll("iframe[data-fictional-puc]").length ?? -1,
+          topCreativeFrames:
+            root?.querySelectorAll(':scope > iframe[title="Ad content"]')
+              .length ?? -1,
+        };
+      }, SLOT),
+    ).toEqual({
+      lifecycle: ["accepted"],
+      position: "",
+      pucFrames: 1,
+      topCreativeFrames: 0,
+    });
+  });
+
+  test("keeps the overlay on failed publisher destroy and retires it on success", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await startFictionalPuc(page);
+    await emitNonemptyGam(page);
+    await expectAcceptedLifecycle(page);
+
+    expect(
+      await page.evaluate((slot) => {
+        const stub = (
+          window as unknown as {
+            __gptDiagnosticsStub: {
+              publisherDestroy(slotId: string, succeeds?: boolean): boolean;
+            };
+          }
+        ).__gptDiagnosticsStub;
+        const result = stub.publisherDestroy(slot, false);
+        const root = document.getElementById(slot);
+        return {
+          result,
+          position: root?.style.getPropertyValue("position"),
+          topCreativeFrames:
+            root?.querySelectorAll(':scope > iframe[title="Ad content"]')
+              .length ?? -1,
+        };
+      }, SLOT),
+    ).toEqual({ result: false, position: "relative", topCreativeFrames: 1 });
+
+    expect(
+      await page.evaluate(
+        (slot) =>
+          (
+            window as unknown as {
+              __gptDiagnosticsStub: {
+                publisherDestroy(slotId: string, succeeds?: boolean): boolean;
+              };
+            }
+          ).__gptDiagnosticsStub.publisherDestroy(slot, true),
+        SLOT,
+      ),
+    ).toBe(true);
+    await expect
+      .poll(() =>
+        page.evaluate((slot) => {
+          const root = document.getElementById(slot);
+          return {
+            position: root?.style.getPropertyValue("position"),
+            topCreativeFrames:
+              root?.querySelectorAll(':scope > iframe[title="Ad content"]')
+                .length ?? -1,
+          };
+        }, SLOT),
+      )
+      .toEqual({ position: "", topCreativeFrames: 0 });
+  });
+
+  test("retires a moved APS node and restores the exact host style", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await startFictionalPuc(page);
+    await emitNonemptyGam(page);
+    await expectAcceptedLifecycle(page);
+
+    await page.evaluate((slot) => {
+      const root = document.getElementById(slot);
+      const overlay = root?.querySelector<HTMLIFrameElement>(
+        ':scope > iframe[title="Ad content"]',
+      );
+      if (!overlay) throw new Error("missing fictional APS overlay");
+      document.body.appendChild(overlay);
+    }, SLOT);
+
+    await expect
+      .poll(() =>
+        page.evaluate(
+          (slot) => ({
+            position: document
+              .getElementById(slot)
+              ?.style.getPropertyValue("position"),
+            movedOverlays: document.body.querySelectorAll(
+              ':scope > iframe[title="Ad content"]',
+            ).length,
+          }),
+          SLOT,
+        ),
+      )
+      .toEqual({ position: "", movedOverlays: 0 });
+  });
+
+  test("retires the detached artifact when the publisher replaces its host", async ({
+    page,
+  }) => {
+    await openLifecyclePage(page);
+    await startFictionalPuc(page);
+    await emitNonemptyGam(page);
+    await expectAcceptedLifecycle(page);
+
+    await page.evaluate((slot) => {
+      const current = document.getElementById(slot);
+      if (!current) throw new Error("missing fictional APS host");
+      const replacement = document.createElement("div");
+      replacement.id = slot;
+      current.replaceWith(replacement);
+      (
+        window as unknown as {
+          __detachedFictionalApsHost?: HTMLElement;
+        }
+      ).__detachedFictionalApsHost = current;
+    }, SLOT);
+
+    await expect
+      .poll(() =>
+        page.evaluate((slot) => {
+          const detached = (
+            window as unknown as {
+              __detachedFictionalApsHost?: HTMLElement;
+            }
+          ).__detachedFictionalApsHost;
+          const replacement = document.getElementById(slot);
+          return {
+            detachedPosition: detached?.style.getPropertyValue("position"),
+            detachedOverlays:
+              detached?.querySelectorAll(':scope > iframe[title="Ad content"]')
+                .length ?? -1,
+            replacementChildren: replacement?.children.length ?? -1,
+            replacementPosition:
+              replacement?.style.getPropertyValue("position"),
+          };
+        }, SLOT),
+      )
+      .toEqual({
+        detachedPosition: "",
+        detachedOverlays: 0,
+        replacementChildren: 0,
+        replacementPosition: "",
+      });
+  });
+});
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/aps-real-gam.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/aps-real-gam.spec.ts
new file mode 100644
index 000000000..1974dceaf
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/aps-real-gam.spec.ts
@@ -0,0 +1,159 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { expect, test } from "@playwright/test";
+import {
+  REAL_GAM_CASES,
+  REAL_GAM_PUC_RELEASE,
+  classifyRealGamNetworkUrl,
+  getRealGamEnvironment,
+  openProtectedRealGamPage,
+  runAttestedRealGamCase,
+} from "../../helpers/gam-test-network.js";
+
+const browserPackage = resolve(__dirname, "../..");
+const realGamConfig = resolve(browserPackage, "playwright.real-gam.config.ts");
+const browserPackageJson = resolve(browserPackage, "package.json");
+const browserPackageLock = resolve(browserPackage, "package-lock.json");
+const realGamConfigured = [
+  process.env.TS_REAL_GAM_PAGE_URL,
+  process.env.TS_REAL_GAM_AUTH_HEADER,
+  process.env.TS_REAL_GAM_EXPECTED_RELEASE_ID,
+].every(Boolean);
+
+test.describe("protected real-GAM test network", () => {
+  test.describe.configure({ mode: "serial" });
+
+  test("the dedicated config cannot acquire local test infrastructure", () => {
+    const source = readFileSync(realGamConfig, "utf8");
+
+    expect(source).not.toMatch(/from\s+["'].\/playwright\.config/u);
+    expect(source).not.toContain("globalSetup");
+    expect(source).not.toContain("globalTeardown");
+    expect(source).not.toMatch(/viceroy|docker|wasm/iu);
+    expect(source).toContain('testMatch: "aps-real-gam.spec.ts"');
+  });
+
+  test("the protected contract enumerates every required flow exactly once", () => {
+    const caseIds = REAL_GAM_CASES.map(({ caseId }) => caseId);
+    expect(caseIds).toEqual([
+      "ssat-aps-puc",
+      "trusted-server-prebid-aps-puc",
+      "page-bids-aps-puc",
+      "direct-aps",
+      "direct-adm",
+      "direct-cache",
+      "attributable-empty-gam-fallback",
+      "sra-aps-puc",
+      "refresh-aps-puc",
+      "spa-navigation",
+      "gpt-handoff",
+      "hydrated-dom-replacement",
+      "collapsed-shell-resize",
+      "wrong-id",
+      "wrong-source",
+      "invalid-descriptor",
+      "no-outer-claim",
+      "no-owner-registration",
+      "no-document-ack",
+      "aps-runner-failure",
+    ]);
+    expect(new Set(caseIds).size).toBe(caseIds.length);
+  });
+
+  test("the network classifier recognizes only the live APS runner route", () => {
+    const pageOrigin = "https://real-gam.example";
+
+    expect(
+      classifyRealGamNetworkUrl(
+        `${pageOrigin}/integrations/aps/runner.js?slot=leaderboard`,
+        pageOrigin,
+      ),
+    ).toBe("runner-proxy");
+    expect(
+      classifyRealGamNetworkUrl(
+        `${pageOrigin}/integrations/aps/runner/v1.js?slot=leaderboard`,
+        pageOrigin,
+      ),
+    ).toBe("first-party");
+    expect(
+      classifyRealGamNetworkUrl(
+        "https://third-party.example/integrations/aps/runner.js",
+        pageOrigin,
+      ),
+    ).toBe("third-party");
+    expect(
+      classifyRealGamNetworkUrl(
+        "https://third-party.example/integrations/aps/renderer/v2",
+        pageOrigin,
+      ),
+    ).toBe("third-party");
+  });
+
+  test("the protected contract pins the externally hosted PUC release", () => {
+    expect(REAL_GAM_PUC_RELEASE).toBe("1.17.2");
+  });
+
+  test("PUC remains external to the locally authored browser harness", () => {
+    const packageJson = readFileSync(browserPackageJson, "utf8");
+    const packageLock = readFileSync(browserPackageLock, "utf8");
+
+    expect(packageJson).not.toContain("prebid-universal-creative");
+    expect(packageLock).not.toContain("prebid-universal-creative");
+  });
+
+  test("the protected contract rejects an unpinned PUC release", async ({
+    page,
+  }) => {
+    const pageUrl = "https://real-gam.example/contract";
+    const expectedReleaseId = "a".repeat(64);
+
+    await page.route(pageUrl, (route) =>
+      route.fulfill({ status: 200, contentType: "text/html", body: "<!doctype html>" }),
+    );
+    await page.addInitScript(
+      ({ caseIds, releaseId }) => {
+        Object.defineProperty(window, "__tsRealGamTestNetwork", {
+          value: Object.freeze({
+            version: 1,
+            releaseId,
+            pucRelease: "latest",
+            caseIds: Object.freeze(caseIds),
+            run: () => undefined,
+          }),
+        });
+      },
+      {
+        caseIds: REAL_GAM_CASES.map(({ caseId }) => caseId),
+        releaseId: expectedReleaseId,
+      },
+    );
+
+    await expect(
+      openProtectedRealGamPage(page, {
+        pageUrl,
+        authorization: "not-used-by-this-contract-test",
+        expectedReleaseId,
+      }),
+    ).rejects.toThrow(/exact frozen test-network contract/u);
+  });
+
+  for (const contract of REAL_GAM_CASES) {
+    test(`${contract.caseId} satisfies its attested contract`, async ({
+      page,
+      browserName,
+    }, testInfo) => {
+      test.skip(
+        !realGamConfigured,
+        "protected real-GAM cases run only through playwright.real-gam.config.ts",
+      );
+      test.setTimeout(contract.deadlineMs + 30_000);
+      await runAttestedRealGamCase({
+        page,
+        browserName,
+        testInfo,
+        environment: getRealGamEnvironment(),
+        contract,
+      });
+    });
+  }
+});
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts
index e7ee7c1c7..62680bafa 100644
--- a/crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts
@@ -1,1298 +1,773 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { expect, test, type Page } from "@playwright/test";
+import { expect, test } from "@playwright/test";
 import { runtimeUrl } from "../../helpers/state.js";
 
-const RUNNER_URL = "https://client.aps.amazon-adsystem.com/prebid-creative.js";
-const PUBLISHER_CORE_URL = "https://tsjs.example/trusted-server-core.js";
 const IFRAME_CREATIVE_URL = "https://creative.example/iframe";
-const SCRIPT_CREATIVE_URL = "https://creative.example/script.js";
+const APS_TEST_ORIGIN = "https://aps-renderer.test";
+const APS_TEST_RENDERER_URL = `${APS_TEST_ORIGIN}/integrations/aps/renderer/v2`;
+const APS_TEST_RUNNER_URL = `${APS_TEST_ORIGIN}/integrations/aps/runner.js`;
 const SANDBOX =
-    "allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation";
-const TSJS_CRATE = resolve(__dirname, "../../../../trusted-server-js");
-const PUC_BANNER = readFileSync(
-    resolve(
-        __dirname,
-        "../../node_modules/prebid-universal-creative/dist/banner.js",
-    ),
-    "utf8",
+  "allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation";
+const PERMANENT_SANDBOX =
+  "allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation";
+const FICTIONAL_APS_RUNNER = readFileSync(
+  resolve(__dirname, "../../fixtures/fictional-aps-runner.js"),
+  "utf8",
 );
 
-function clientAuctionBundlePaths() {
-    const manifestPath = resolve(TSJS_CRATE, "dist/prebid/manifest.json");
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
-        filename: string;
-    };
-    return {
-        core: resolve(TSJS_CRATE, "dist/tsjs-core.js"),
-        gpt: resolve(TSJS_CRATE, "dist/tsjs-gpt.js"),
-        prebid: resolve(TSJS_CRATE, "dist/prebid", manifest.filename),
-        prebidShim: resolve(TSJS_CRATE, "dist/tsjs-prebid.js"),
-    };
-}
-
-/**
- * Load the client auction scripts in the order the server serves them.
- *
- * A coupled external bundle ships Prebid.js with the tsjs shim (and the
- * trustedServer adapter) already installed. A decoupled external bundle is
- * pure Prebid.js and stamps its manifest on `window.__tsjs_prebid_bundle`;
- * the shim then arrives as the separately served deferred tsjs module, so
- * this helper loads it whenever the stamp is present.
- */
-async function loadClientAuctionBundles(page: Page): Promise<void> {
-    const bundles = clientAuctionBundlePaths();
-    await page.addScriptTag({ path: bundles.core });
-    await page.addScriptTag({ path: bundles.gpt });
-    await page.addScriptTag({ path: bundles.prebid });
-    const decoupledBundle = await page.evaluate(() =>
-        Boolean(
-            (window as unknown as { __tsjs_prebid_bundle?: unknown })
-                .__tsjs_prebid_bundle,
-        ),
-    );
-    if (decoupledBundle) {
-        await page.addScriptTag({ path: bundles.prebidShim });
-    }
-}
-
 function descriptor(
-    tagType: "iframe" | "script",
-    creativeUrl = tagType === "iframe"
-        ? IFRAME_CREATIVE_URL
-        : SCRIPT_CREATIVE_URL,
+  bidId = "fictional-iframe-bid",
+  overrides: Record<string, unknown> = {},
 ) {
-    const envelope = {
-        seatbid: [
-            {
-                bid: [
-                    {
-                        id: `fictional-${tagType}-bid`,
-                        price: 1.23,
-                        w: 300,
-                        h: 250,
-                        ext: { creativeurl: creativeUrl, tagtype: tagType },
-                    },
-                ],
-            },
+  const tagType = overrides.tagType === "script" ? "script" : "iframe";
+  const creativeUrl =
+    typeof overrides.creativeUrl === "string"
+      ? overrides.creativeUrl
+      : IFRAME_CREATIVE_URL;
+  const width = typeof overrides.width === "number" ? overrides.width : 300;
+  const height = typeof overrides.height === "number" ? overrides.height : 250;
+  const envelope = {
+    seatbid: [
+      {
+        bid: [
+          {
+            id: bidId,
+            price: 1.23,
+            w: width,
+            h: height,
+            ext: { creativeurl: creativeUrl, tagtype: tagType },
+          },
         ],
-    };
-    return {
-        type: "aps",
-        version: 1,
-        accountId: "example-account-id",
-        bidId: `fictional-${tagType}-bid`,
-        creativeId: `fictional-${tagType}-creative`,
-        tagType,
-        creativeUrl,
-        aaxResponse: Buffer.from(JSON.stringify(envelope), "utf8").toString(
-            "base64",
-        ),
-        width: 300,
-        height: 250,
-    };
+      },
+    ],
+  };
+  return {
+    type: "aps",
+    version: 1,
+    accountId: "example-account-id",
+    bidId,
+    creativeId: `fictional-${tagType}-creative`,
+    tagType,
+    creativeUrl,
+    aaxResponse: Buffer.from(JSON.stringify(envelope), "utf8").toString(
+      "base64",
+    ),
+    width,
+    height,
+    ...overrides,
+  };
 }
 
-function testPage(rendererUrl: string) {
-    return `<!doctype html>
-<meta charset="utf-8">
-<div id="slots"></div>
-<script>
-window.apsMessages = [];
-window.startApsFrame = function(options) {
+function containerCsp(
+  creativeOrigin: string,
+  outer: boolean,
+  scriptCreative = false,
+): string {
+  const scriptSources = scriptCreative
+    ? `'unsafe-inline' ${APS_TEST_ORIGIN} ${creativeOrigin}`
+    : `'unsafe-inline' ${APS_TEST_ORIGIN}`;
+  return (
+    "default-src 'none'; base-uri 'none'; object-src 'none'; script-src " +
+    `${scriptSources}; connect-src https: ${APS_TEST_ORIGIN}; frame-src ` +
+    `${outer ? "data: " : ""}${creativeOrigin}; img-src https: data: blob:; ` +
+    "media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; " +
+    "worker-src https: blob:; form-action https:;"
+  );
+}
+
+test.describe("APS renderer v2 protocol", () => {
+  test("leaves every removed or unknown APS route unserved", async ({
+    page,
+  }) => {
+    for (const path of [
+      "/integrations/aps/renderer",
+      "/integrations/aps/renderer/v1",
+      "/integrations/aps/runner/v1.js",
+    ]) {
+      const response = await page.request.get(runtimeUrl(path));
+      expect(response.status(), path).toBe(404);
+    }
+  });
+
+  test("uses one port, reports ordered progress, and fails closed", async ({
+    page,
+    browserName,
+  }) => {
+    test.setTimeout(60_000);
+    const rendererResponse = await page.request.get(
+      runtimeUrl("/integrations/aps/renderer/v2"),
+    );
+    expect(rendererResponse.status()).toBe(200);
+    expect(rendererResponse.headers()["content-type"]).toBe(
+      "text/html; charset=utf-8",
+    );
+    expect(rendererResponse.headers()["cache-control"]).toBe(
+      "public, max-age=31536000, immutable",
+    );
+    expect(rendererResponse.headers()["x-content-type-options"]).toBe(
+      "nosniff",
+    );
+    expect(rendererResponse.headers()["referrer-policy"]).toBe("no-referrer");
+    expect(rendererResponse.headers()["x-frame-options"]).toBeUndefined();
+    const csp = rendererResponse.headers()["content-security-policy"];
+    expect(csp).toBe(
+      "default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;",
+    );
+    const rendererDocument = await rendererResponse.text();
+
+    // Fulfil the exact served document and its parent at one HTTPS test origin so
+    // frame-ancestors 'self', parent-origin authentication, and the live runner
+    // proxy URL all exercise the production shape over the local test transport.
+    await page.route(APS_TEST_RENDERER_URL, (route) =>
+      route.fulfill({
+        status: 200,
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "content-security-policy": csp!,
+          "x-content-type-options": "nosniff",
+          "referrer-policy": "no-referrer",
+        },
+        body: rendererDocument,
+      }),
+    );
+
+    let runnerRequests = 0;
+    await page.route(APS_TEST_RUNNER_URL, async (route) => {
+      runnerRequests += 1;
+      await route.fulfill({
+        status: 200,
+        headers: {
+          "content-type": "application/javascript; charset=utf-8",
+          "access-control-allow-origin": "*",
+          "cross-origin-resource-policy": "cross-origin",
+          "x-content-type-options": "nosniff",
+          "referrer-policy": "no-referrer",
+        },
+        body: FICTIONAL_APS_RUNNER,
+      });
+    });
+    await page.route("https://external.example/blocked.js", (route) => {
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript",
+        body: "document.documentElement.dataset.externalScript='executed'",
+      });
+    });
+    await page.route("https://other.example/other.js", (route) => {
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript",
+        body: "document.documentElement.dataset.otherScript='executed'",
+      });
+    });
+    await page.route("https://redirect.example/final.js", (route) => {
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript",
+        body: "document.documentElement.dataset.redirectedScript='executed'",
+      });
+    });
+    await page.route("https://creative.example/**", (route) => {
+      const url = new URL(route.request().url());
+      if (url.pathname === "/iframe-policy") {
+        return route.fulfill({
+          status: 200,
+          contentType: "text/html",
+          headers: {
+            "content-security-policy":
+              "default-src 'none'; script-src 'none'; style-src 'unsafe-inline'",
+          },
+          body: `<!doctype html><style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}</style><script src="https://external.example/blocked.js"></script>`,
+        });
+      }
+      if (url.pathname === "/script-allowed.js") {
+        return route.fulfill({
+          status: 200,
+          contentType: "application/javascript",
+          body: `document.documentElement.dataset.scriptCreative='executed';var script=document.createElement('script');script.src='https://other.example/other.js';document.head.appendChild(script);`,
+        });
+      }
+      if (url.pathname === "/script-redirect.js") {
+        return route.fulfill({
+          status: 302,
+          headers: { location: "https://redirect.example/final.js" },
+        });
+      }
+      return route.abort();
+    });
+    await page.route(`${APS_TEST_ORIGIN}/aps-v2-protocol-test`, (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "text/html",
+        headers: {
+          "content-security-policy":
+            "default-src 'none'; script-src 'unsafe-inline'; frame-src 'self' data: https://creative.example",
+        },
+        body: `<!doctype html><meta charset="utf-8"><div id="slots"></div><script>
+window.apsV2Records = Object.create(null);
+window.startApsV2 = function(options) {
   var slot = document.createElement('div');
   slot.id = options.slotId;
+  slot.style.height = options.renderer.height + 'px';
+  slot.style.overflow = 'hidden';
+  slot.style.position = 'relative';
+  slot.style.width = options.renderer.width + 'px';
   slot.innerHTML = '<span class="existing">existing publisher content</span>';
   document.getElementById('slots').appendChild(slot);
-
   var frame = document.createElement('iframe');
-  frame.width = '300';
-  frame.height = '250';
+  frame.setAttribute('sandbox', ${JSON.stringify(SANDBOX)});
+  frame.setAttribute('width', String(options.renderer.width));
+  frame.setAttribute('height', String(options.renderer.height));
+  frame.src = ${JSON.stringify(APS_TEST_RENDERER_URL)} + '#' + options.bootstrapNonce;
+  frame.style.border = '0';
   frame.style.display = 'none';
-  if (!options.omitSandbox) {
-    frame.setAttribute('sandbox', ${JSON.stringify(SANDBOX)});
-  }
-  frame.src = ${JSON.stringify(rendererUrl)} +
-    (options.includeFragment === false ? '' : '#tsaps=' + options.fragmentNonce);
-
+  frame.style.height = options.renderer.height + 'px';
+  frame.style.margin = '0';
+  frame.style.overflow = 'hidden';
+  frame.style.width = options.renderer.width + 'px';
+  var record = {messages: [], snapshots: [], bootstrapConfiguration: null, frame: frame, port: null};
+  window.apsV2Records[options.slotId] = record;
   function receive(event) {
-    if (event.source !== frame.contentWindow || !event.data) return;
-    window.apsMessages.push({ slotId: options.slotId, data: event.data });
-    if (event.data.message === 'trusted-server/aps/renderer-ready' &&
-        event.data.nonce === options.fragmentNonce) {
-      var existing = slot.querySelector('.existing');
-      if (existing) existing.remove();
-      frame.style.display = '';
+    if (event.source !== frame.contentWindow || event.origin !== 'null' ||
+        typeof event.data !== 'string') return;
+    var value;
+    try { value = JSON.parse(event.data); } catch (_error) { return; }
+    if (value.message === 'TS APS Bootstrap Ready' && value.version === 1 &&
+        value.bootstrapNonce === options.bootstrapNonce && event.ports.length === 0) {
+      frame.setAttribute('sandbox', ${JSON.stringify(PERMANENT_SANDBOX)});
+      var creativeOrigin = new URL(options.renderer.creativeUrl).origin;
+      if (options.adversarialBootstrap) {
+        var invalidChannel = new MessageChannel();
+        frame.contentWindow.postMessage('{"message":', '*', []);
+        frame.contentWindow.postMessage('x'.repeat(16385), '*', []);
+        frame.contentWindow.postMessage(JSON.stringify({
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce: 'b1_0000000000000000000000',
+          rendererNonce: options.rendererNonce,
+          creativeOrigin: creativeOrigin,
+          tagType: options.renderer.tagType
+        }), '*', []);
+        frame.contentWindow.postMessage(JSON.stringify({
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce: options.bootstrapNonce,
+          rendererNonce: options.rendererNonce,
+          creativeOrigin: creativeOrigin,
+          tagType: options.renderer.tagType
+        }), '*', [invalidChannel.port1]);
+        invalidChannel.port2.close();
+      }
+      record.bootstrapConfiguration = {
+        message: 'TS APS Bootstrap Configure',
+        version: 2,
+        bootstrapNonce: options.bootstrapNonce,
+        rendererNonce: options.rendererNonce,
+        creativeOrigin: creativeOrigin,
+        tagType: options.renderer.tagType
+      };
+      frame.contentWindow.postMessage(JSON.stringify(record.bootstrapConfiguration), '*', []);
+      if (options.adversarialBootstrap) {
+        frame.contentWindow.postMessage(JSON.stringify(record.bootstrapConfiguration), '*', []);
+      }
+      return;
     }
-  }
-  window.addEventListener('message', receive);
-  frame.onload = function() {
-    frame.contentWindow.postMessage({
-      nonce: options.messageNonce,
+    if (value.message !== 'TS APS Container Ready' || value.version !== 1 ||
+        value.bootstrapNonce !== options.bootstrapNonce ||
+        value.rendererNonce !== options.rendererNonce || event.ports.length !== 1) return;
+    window.removeEventListener('message', receive, true);
+    record.port = event.ports[0];
+    record.port.onmessage = function(portEvent) {
+      record.messages.push(portEvent.data);
+      record.snapshots.push({
+        message: portEvent.data && portEvent.data.message,
+        display: frame.style.display,
+        existing: slot.querySelectorAll('.existing').length
+      });
+      if (portEvent.data && portEvent.data.message === 'TS APS Render Completed') {
+        var existing = slot.querySelector('.existing');
+        if (existing) existing.remove();
+        frame.style.display = '';
+      }
+    };
+    record.port.start();
+    record.port.postMessage({
+      version: 1,
+      nonce: options.rendererNonce,
+      publisherOrigin: location.origin,
       renderer: options.renderer
-    }, '*');
-  };
+    });
+  }
+  window.addEventListener('message', receive, true);
   slot.appendChild(frame);
 };
-</script>`;
-}
-
-const FAKE_RUNNER = `(function(){
-  var runnerRead = false;
-  var runnerWrite = false;
-  try { void top.document.body; runnerRead = true; } catch (_error) {}
-  try { top.document.body.dataset.apsCompromised = 'runner'; runnerWrite = true; } catch (_error) {}
-  parent.postMessage({
-    message: 'fictional-runner-security',
-    runnerRead: runnerRead,
-    runnerWrite: runnerWrite,
-    accountMap: window._aps instanceof Map
-  }, '*');
-
-  addEventListener('message', function(event) {
-    if (event.data && event.data.message === 'fictional-creative-security') {
-      parent.postMessage(event.data, '*');
-    }
-  });
-
-  window._aps.forEach(function(account) {
-    var events = account.queue.splice(0);
-    events.forEach(function(event) {
-      var response = JSON.parse(atob(event.detail.aaxResponse));
-      var bid = response.seatbid[0].bid[0];
-      if (bid.ext.tagtype === 'iframe') {
-        var frame = document.createElement('iframe');
-        frame.setAttribute('sandbox', 'allow-scripts allow-same-origin');
-        frame.width = String(bid.w);
-        frame.height = String(bid.h);
-        frame.style.border = '0';
-        frame.src = bid.ext.creativeurl;
-        document.body.appendChild(frame);
-      } else {
-        var script = document.createElement('script');
-        script.src = bid.ext.creativeurl;
-        document.head.appendChild(script);
-      }
-    });
-  });
-})();`;
-
-const IFRAME_CREATIVE = `<!doctype html><script>
-var creativeRead = false;
-var creativeWrite = false;
-try { void top.document.body; creativeRead = true; } catch (_error) {}
-try { top.document.body.dataset.apsCompromised = 'iframe'; creativeWrite = true; } catch (_error) {}
-parent.postMessage({
-  message: 'fictional-creative-security',
-  tagType: 'iframe',
-  creativeRead: creativeRead,
-  creativeWrite: creativeWrite
-}, '*');
-<\/script>`;
-
-const SCRIPT_CREATIVE = `(function(){
-  var creativeRead = false;
-  var creativeWrite = false;
-  try { void top.document.body; creativeRead = true; } catch (_error) {}
-  try { top.document.body.dataset.apsCompromised = 'script'; creativeWrite = true; } catch (_error) {}
-  parent.postMessage({
-    message: 'fictional-creative-security',
-    tagType: 'script',
-    creativeRead: creativeRead,
-    creativeWrite: creativeWrite
-  }, '*');
-})();`;
-
-test.describe("APS rendering", () => {
-    test("renders through real PUC and expands only its authenticated 1x1 shell", async ({
-        page,
-    }) => {
-        const adId = "fictional-inline-ad-id";
-        const publisherOrigin = new URL(runtimeUrl("/")).origin;
-        const outerCreativeUrl = runtimeUrl("/fictional-puc-shell");
-        let creativeRequests = 0;
-
-        await page.route(runtimeUrl("/aps-puc-topology-test"), (route) =>
-            route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: '<!doctype html><div id="div-aps"></div><div id="div-other"></div>',
-            }),
-        );
-        await page.route(outerCreativeUrl, (route) =>
-            route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: `<!doctype html><script>${PUC_BANNER}</script><script>
-window.ucTag.renderAd(document, { adId: ${JSON.stringify(adId)}, pubUrl: ${JSON.stringify(publisherOrigin)} });
 </script>`,
-            }),
-        );
-        await page.route(IFRAME_CREATIVE_URL, (route) => {
-            creativeRequests += 1;
-            return route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: IFRAME_CREATIVE,
-            });
-        });
-
-        await page.goto(runtimeUrl("/aps-puc-topology-test"));
-        await page.addScriptTag({ path: clientAuctionBundlePaths().gpt });
-        await page.evaluate(
-            ({ creativeUrl, outerUrl, selectedAdId }) => {
-                const typedWindow = window as unknown as {
-                    tsjs: Record<string, unknown>;
-                    pucEvents: Array<Record<string, unknown>>;
-                };
-                typedWindow.tsjs = {
-                    bids: {
-                        "aps-slot": {
-                            hb_adid: selectedAdId,
-                            hb_bidder: "fictional",
-                            hb_pb: "1.23",
-                            adm: `<iframe src="${creativeUrl}" width="300" height="250"></iframe>`,
-                            w: 300,
-                            h: 250,
-                        },
-                    },
-                    adSlots: [
-                        {
-                            id: "aps-slot",
-                            div_id: "div-aps",
-                            gam_unit_path: "/fictional/aps",
-                            formats: [[300, 250]],
-                        },
-                    ],
-                };
-                typedWindow.pucEvents = [];
-                const locator = document.createElement("iframe");
-                locator.name = "__pb_locator__";
-                document.body.appendChild(locator);
-                window.addEventListener("message", (event) => {
-                    try {
-                        const message = JSON.parse(
-                            String(event.data),
-                        ) as Record<string, unknown>;
-                        if (message.message === "Prebid Event") {
-                            typedWindow.pucEvents.push(message);
-                        }
-                    } catch {
-                        // Ignore unrelated publisher messages.
-                    }
-                });
-
-                const slot = document.getElementById("div-aps")!;
-                slot.style.width = "1px";
-                slot.style.height = "1px";
-                const outerShell = document.createElement("div");
-                outerShell.id = "aps-outer-shell";
-                outerShell.style.width = "1px";
-                outerShell.style.height = "1px";
-                const innerShell = document.createElement("div");
-                innerShell.id = "aps-inner-shell";
-                innerShell.style.width = "1px";
-                innerShell.style.height = "1px";
-                const frame = document.createElement("iframe");
-                frame.id = "google_ads_iframe_fictional_0";
-                frame.width = "1";
-                frame.height = "1";
-                frame.style.width = "1px";
-                frame.style.height = "1px";
-                frame.src = outerUrl;
-                innerShell.appendChild(frame);
-                outerShell.appendChild(innerShell);
-                slot.appendChild(outerShell);
-
-                const other = document.getElementById("div-other")!;
-                const otherFrame = document.createElement("iframe");
-                otherFrame.width = "1";
-                otherFrame.height = "1";
-                otherFrame.style.width = "1px";
-                otherFrame.style.height = "1px";
-                other.appendChild(otherFrame);
-            },
-            {
-                creativeUrl: IFRAME_CREATIVE_URL,
-                outerUrl: outerCreativeUrl,
-                selectedAdId: adId,
-            },
-        );
-
-        await expect.poll(() => creativeRequests).toBe(1);
-        await expect
-            .poll(() =>
-                page.evaluate(() =>
-                    (
-                        window as unknown as {
-                            pucEvents: Array<Record<string, unknown>>;
-                        }
-                    ).pucEvents.some(
-                        (event) => event.event === "adRenderSucceeded",
-                    ),
-                ),
-            )
-            .toBe(true);
-        await expect(page.locator("#google_ads_iframe_fictional_0")).toHaveCSS(
-            "width",
-            "300px",
-        );
-        await expect(page.locator("#google_ads_iframe_fictional_0")).toHaveCSS(
-            "height",
-            "250px",
-        );
-        await expect(page.locator("#div-aps")).toHaveCSS("width", "300px");
-        await expect(page.locator("#div-aps")).toHaveCSS("height", "250px");
-        await expect(page.locator("#aps-outer-shell")).toHaveCSS(
-            "width",
-            "300px",
-        );
-        await expect(page.locator("#aps-outer-shell")).toHaveCSS(
-            "height",
-            "250px",
-        );
-        await expect(page.locator("#aps-inner-shell")).toHaveCSS(
-            "width",
-            "300px",
-        );
-        await expect(page.locator("#aps-inner-shell")).toHaveCSS(
-            "height",
-            "250px",
-        );
-        await expect(page.locator("#div-other iframe")).toHaveCSS(
-            "width",
-            "1px",
-        );
-        await expect(page.locator("#div-other iframe")).toHaveCSS(
-            "height",
-            "1px",
-        );
-    });
-
-    test("renders a trustedServer adapter bid using Prebid's generated GAM ad ID", async ({
-        page,
-    }) => {
-        const apsRenderer = descriptor("iframe");
-        const responseBody = {
-            id: "fictional-auction",
-            seatbid: [
+      }),
+    );
+    await page.goto(`${APS_TEST_ORIGIN}/aps-v2-protocol-test`);
+
+    const start = async (
+      slotId: string,
+      bidId: string,
+      rendererOverrides: Record<string, unknown> = {},
+      adversarialBootstrap = false,
+    ) => {
+      const bootstrapNonce = `b1_${slotId.padEnd(22, "b").slice(0, 22)}`;
+      const rendererNonce = `n1_${slotId.padEnd(22, "n").slice(0, 22)}`;
+      await page.evaluate(
+        ({ slotId, bootstrapNonce, rendererNonce, renderer }) => {
+          (
+            window as unknown as {
+              startApsV2(options: Record<string, unknown>): void;
+            }
+          ).startApsV2({ slotId, bootstrapNonce, rendererNonce, renderer });
+        },
+        {
+          slotId,
+          bootstrapNonce,
+          rendererNonce,
+          renderer: descriptor(bidId, rendererOverrides),
+          adversarialBootstrap,
+        },
+      );
+      return rendererNonce;
+    };
+    const messages = (slotId: string) =>
+      page.evaluate(
+        (id) =>
+          (
+            window as unknown as {
+              apsV2Records: Record<
+                string,
+                { messages: Array<Record<string, unknown>> }
+              >;
+            }
+          ).apsV2Records[id]?.messages ?? [],
+        slotId,
+      );
+    const snapshots = (slotId: string) =>
+      page.evaluate(
+        (id) =>
+          (
+            window as unknown as {
+              apsV2Records: Record<
+                string,
                 {
-                    seat: "aps",
-                    bid: [
-                        {
-                            id: apsRenderer.bidId,
-                            impid: "div-aps",
-                            price: 1.23,
-                            crid: apsRenderer.creativeId,
-                            w: 300,
-                            h: 250,
-                            ext: {
-                                trusted_server: { renderer: apsRenderer },
-                            },
-                        },
-                    ],
-                },
-            ],
-            ext: {},
-        };
-        let auctionRequests = 0;
-        await page.route(runtimeUrl("/aps-prebid-adapter-test"), (route) =>
-            route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: '<!doctype html><div id="div-aps"></div><div id="div-other"></div>',
-            }),
-        );
-        await page.route(runtimeUrl("/auction"), (route) => {
-            auctionRequests += 1;
-            return route.fulfill({
-                status: 200,
-                contentType: "application/json",
-                body: JSON.stringify(responseBody),
-            });
-        });
-
-        await page.goto(runtimeUrl("/aps-prebid-adapter-test"));
-        await loadClientAuctionBundles(page);
-
-        const result = await page.evaluate(async () => {
-            type PrebidBid = {
-                ad?: string;
-                adId: string;
-                bidderCode: string;
-                status?: string;
-            };
-            type PrebidApi = {
-                getAllWinningBids(): PrebidBid[];
-                getBidResponsesForAdUnitCode(code: string): {
-                    bids: PrebidBid[];
-                };
-                onEvent(
-                    name: string,
-                    callback: (value: Record<string, unknown>) => void,
-                ): void;
-                requestBids(options: Record<string, unknown>): void;
-            };
-            const pbjs = (window as unknown as { pbjs: PrebidApi }).pbjs;
-            const bidWon: string[] = [];
-            const renderSucceeded: string[] = [];
-            pbjs.onEvent("bidWon", (bid) => bidWon.push(String(bid.adId)));
-            pbjs.onEvent("adRenderSucceeded", (event) =>
-                renderSucceeded.push(String(event.adId)),
-            );
-
-            const acceptedBid = await new Promise<PrebidBid | undefined>(
-                (resolveBid) => {
-                    pbjs.requestBids({
-                        adUnits: [
-                            {
-                                code: "div-aps",
-                                mediaTypes: { banner: { sizes: [[300, 250]] } },
-                                bids: [],
-                            },
-                        ],
-                        bidsBackHandler: () =>
-                            resolveBid(
-                                pbjs
-                                    .getBidResponsesForAdUnitCode("div-aps")
-                                    .bids.find(
-                                        (bid) => bid.bidderCode === "aps",
-                                    ),
-                            ),
-                        timeout: 1_000,
-                    });
-                },
-            );
-            if (!acceptedBid)
-                throw new Error("APS bid was not accepted by Prebid");
-
-            const foreignUniversalCreativeResponse = await new Promise<
-                Record<string, unknown> | undefined
-            >((resolveResponse) => {
-                const frame = document.createElement("iframe");
-                const adIdJson = JSON.stringify(acceptedBid.adId);
-                frame.srcdoc = `<script>
-const renderChannel = new MessageChannel();
-renderChannel.port1.onmessage = function(event) {
-  parent.postMessage({ type: 'captured-foreign-prebid-response', payload: event.data }, '*');
-};
-parent.postMessage(JSON.stringify({
-  message: 'Prebid Request',
-  adId: ${adIdJson}
-}), '*', [renderChannel.port2]);
-<\/script>`;
-                let timeout = 0;
-                const receive = (event: MessageEvent) => {
-                    if (event.data?.type !== "captured-foreign-prebid-response")
-                        return;
-                    window.removeEventListener("message", receive);
-                    window.clearTimeout(timeout);
-                    resolveResponse(JSON.parse(String(event.data.payload)));
-                };
-                window.addEventListener("message", receive);
-                document.getElementById("div-other")!.appendChild(frame);
-                timeout = window.setTimeout(() => {
-                    window.removeEventListener("message", receive);
-                    resolveResponse(undefined);
-                }, 200);
-            });
-
-            const universalCreativeResponse = await new Promise<
-                Record<string, unknown>
-            >((resolveResponse, rejectResponse) => {
-                const frame = document.createElement("iframe");
-                const adIdJson = JSON.stringify(acceptedBid.adId);
-                frame.srcdoc = `<script>
-const renderChannel = new MessageChannel();
-renderChannel.port1.onmessage = function(event) {
-  parent.postMessage({ type: 'captured-prebid-response', payload: event.data }, '*');
-  const eventChannel = new MessageChannel();
-  parent.postMessage(JSON.stringify({
-    message: 'Prebid Event',
-    adId: ${adIdJson},
-    event: 'adRenderSucceeded'
-  }), '*', [eventChannel.port2]);
-};
-parent.postMessage(JSON.stringify({
-  message: 'Prebid Request',
-  adId: ${adIdJson}
-}), '*', [renderChannel.port2]);
-<\/script>`;
-                const receive = (event: MessageEvent) => {
-                    if (event.data?.type !== "captured-prebid-response") return;
-                    window.removeEventListener("message", receive);
-                    resolveResponse(JSON.parse(String(event.data.payload)));
-                };
-                window.addEventListener("message", receive);
-                document.getElementById("div-aps")!.appendChild(frame);
-                window.setTimeout(
-                    () =>
-                        rejectResponse(
-                            new Error("Universal Creative response timed out"),
-                        ),
-                    3_000,
-                );
-            });
-            await new Promise((resolveTick) =>
-                window.setTimeout(resolveTick, 50),
-            );
-
-            return {
-                acceptedAd: acceptedBid.ad,
-                acceptedAdId: acceptedBid.adId,
-                acceptedStatus: acceptedBid.status,
-                bidWon,
-                foreignUniversalCreativeResponse,
-                renderSucceeded,
-                universalCreativeResponse,
-                winningAdIds: pbjs.getAllWinningBids().map((bid) => bid.adId),
-                registrySize: Object.keys(
-                    (
-                        window as unknown as {
-                            tsjs?: {
-                                apsPrebidRenderers?: Record<string, unknown>;
-                            };
-                        }
-                    ).tsjs?.apsPrebidRenderers ?? {},
-                ).length,
-            };
-        });
-
-        expect(auctionRequests).toBe(1);
-        expect(result.acceptedAd).toBe("");
-        expect(result.acceptedAdId).not.toBe(apsRenderer.bidId);
-        expect(result.foreignUniversalCreativeResponse).toBeUndefined();
-        expect(result.universalCreativeResponse).toEqual(
-            expect.objectContaining({
-                message: "Prebid Response",
-                adId: result.acceptedAdId,
-                rendererVersion: 4,
-                apsRenderer,
-            }),
-        );
-        expect(result.bidWon).toEqual([result.acceptedAdId]);
-        expect(result.renderSucceeded).toEqual([result.acceptedAdId]);
-        expect(result.winningAdIds).toContain(result.acceptedAdId);
-        expect(result.acceptedStatus).toBe("rendered");
-        expect(result.registrySize).toBe(0);
-    });
-
-    test("enforces nonce gating and isolates iframe and script behavior under restrictive CSP", async ({
-        page,
-    }) => {
-        const rendererResponse = await page.request.get(
-            runtimeUrl("/integrations/aps/renderer"),
-        );
-        expect(rendererResponse.status()).toBe(200);
-        expect(rendererResponse.headers()["content-type"]).toContain(
-            "text/html",
-        );
-        const rendererCsp =
-            rendererResponse.headers()["content-security-policy"];
-        expect(rendererCsp).toContain("default-src 'none'");
-        expect(rendererCsp).toContain("sandbox allow-forms");
-        expect(rendererCsp).not.toContain("allow-same-origin");
-        expect(rendererResponse.headers()["referrer-policy"]).toBe(
-            "no-referrer",
-        );
-
-        let runnerRequests = 0;
-        await page.route(RUNNER_URL, async (route) => {
-            runnerRequests += 1;
-            await route.fulfill({
-                status: 200,
-                contentType: "application/javascript",
-                body: FAKE_RUNNER,
-            });
-        });
-        await page.route(IFRAME_CREATIVE_URL, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: IFRAME_CREATIVE,
-            });
-        });
-        await page.route(SCRIPT_CREATIVE_URL, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "application/javascript",
-                body: SCRIPT_CREATIVE,
-            });
-        });
-        await page.route(runtimeUrl("/aps-security-test"), async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                headers: {
-                    "Content-Security-Policy":
-                        "default-src 'none'; script-src 'unsafe-inline'; frame-src 'self'",
-                },
-                body: testPage(runtimeUrl("/integrations/aps/renderer")),
-            });
-        });
-
-        await page.goto(runtimeUrl("/aps-security-test"));
-
-        const validNonce = "ABCDEFGHIJKLMNOPQRSTUV";
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "iframe-slot",
-                    fragmentNonce: nonce,
-                    messageNonce: nonce,
-                    renderer,
-                });
-            },
-            { renderer: descriptor("iframe"), nonce: validNonce },
-        );
-
-        await expect
-            .poll(async () =>
-                page.evaluate(() =>
-                    (
-                        window as unknown as {
-                            apsMessages: Array<{ data: { message?: string } }>;
-                        }
-                    ).apsMessages.some(
-                        ({ data }) =>
-                            data.message === "fictional-creative-security",
-                    ),
-                ),
-            )
-            .toBe(true);
-        await expect(page.locator("#iframe-slot .existing")).toHaveCount(0);
-
-        const validState = await page.evaluate(() => {
-            const frame = document.querySelector<HTMLIFrameElement>(
-                "#iframe-slot iframe",
-            )!;
-            const messages = (
-                window as unknown as {
-                    apsMessages: Array<{ data: Record<string, unknown> }>;
+                  snapshots: Array<{
+                    message: string;
+                    display: string;
+                    existing: number;
+                  }>;
                 }
-            ).apsMessages.map(({ data }) => data);
-            let publisherCanReadFrame = false;
-            try {
-                publisherCanReadFrame = Boolean(
-                    frame.contentWindow?.document.body,
-                );
-            } catch (_error) {
-                publisherCanReadFrame = false;
+              >;
             }
-            return {
-                existing: Boolean(
-                    document.querySelector("#iframe-slot .existing"),
-                ),
-                sandbox: frame.getAttribute("sandbox"),
-                publisherCanReadFrame,
-                compromised: document.body.dataset.apsCompromised,
-                messages,
-            };
-        });
-
-        expect(validState.existing).toBe(false);
-        expect(validState.sandbox).toBe(SANDBOX);
-        expect(validState.sandbox).not.toContain("allow-same-origin");
-        expect(validState.publisherCanReadFrame).toBe(false);
-        expect(validState.compromised).toBeUndefined();
-        expect(validState.messages).toContainEqual(
-            expect.objectContaining({
-                message: "fictional-runner-security",
-                runnerRead: false,
-                runnerWrite: false,
-                accountMap: true,
-            }),
-        );
-        expect(validState.messages).toContainEqual(
-            expect.objectContaining({
-                message: "fictional-creative-security",
-                tagType: "iframe",
-                creativeRead: false,
-                creativeWrite: false,
-            }),
-        );
-
-        const cspNonce = "csp-sandbox-0123456789";
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "csp-sandbox-slot",
-                    fragmentNonce: nonce,
-                    messageNonce: nonce,
-                    omitSandbox: true,
-                    renderer,
-                });
-            },
-            { renderer: descriptor("script"), nonce: cspNonce },
-        );
-        await expect
-            .poll(async () =>
-                page.evaluate(() =>
-                    (
-                        window as unknown as {
-                            apsMessages: Array<{
-                                slotId: string;
-                                data: Record<string, unknown>;
-                            }>;
-                        }
-                    ).apsMessages.some(
-                        ({ slotId, data }) =>
-                            slotId === "csp-sandbox-slot" &&
-                            data.message === "fictional-creative-security" &&
-                            data.tagType === "script",
-                    ),
-                ),
-            )
-            .toBe(true);
-        await expect(page.locator("#csp-sandbox-slot .existing")).toHaveCount(
-            0,
-        );
-        const cspState = await page.evaluate(() => {
-            const frame = document.querySelector<HTMLIFrameElement>(
-                "#csp-sandbox-slot iframe",
-            )!;
-            let publisherCanReadFrame = false;
-            try {
-                publisherCanReadFrame = Boolean(
-                    frame.contentWindow?.document.body,
-                );
-            } catch (_error) {
-                publisherCanReadFrame = false;
+          ).apsV2Records[id]?.snapshots ?? [],
+        slotId,
+      );
+    const bootstrapConfiguration = (slotId: string) =>
+      page.evaluate(
+        (id) =>
+          (
+            window as unknown as {
+              apsV2Records: Record<
+                string,
+                { bootstrapConfiguration: Record<string, unknown> | null }
+              >;
             }
-            return {
-                sandbox: frame.getAttribute("sandbox"),
-                existing: Boolean(
-                    document.querySelector("#csp-sandbox-slot .existing"),
-                ),
-                publisherCanReadFrame,
-                compromised: document.body.dataset.apsCompromised,
-                messages: (
-                    window as unknown as {
-                        apsMessages: Array<{
-                            slotId: string;
-                            data: Record<string, unknown>;
-                        }>;
-                    }
-                ).apsMessages
-                    .filter(({ slotId }) => slotId === "csp-sandbox-slot")
-                    .map(({ data }) => data),
-            };
-        });
-        expect(cspState.sandbox).toBeNull();
-        expect(cspState.existing).toBe(false);
-        expect(cspState.publisherCanReadFrame).toBe(false);
-        expect(cspState.compromised).toBeUndefined();
-        expect(cspState.messages).toContainEqual(
-            expect.objectContaining({
-                message: "fictional-runner-security",
-                runnerRead: false,
-                runnerWrite: false,
-            }),
-        );
-        expect(cspState.messages).toContainEqual(
-            expect.objectContaining({
-                message: "fictional-creative-security",
-                tagType: "script",
-                creativeRead: false,
-                creativeWrite: false,
-            }),
-        );
-
-        const messagesBeforeReplay = await page.evaluate(
-            () =>
-                (
-                    window as unknown as {
-                        apsMessages: Array<{ data: Record<string, unknown> }>;
-                    }
-                ).apsMessages.length,
-        );
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                const frame = document.querySelector<HTMLIFrameElement>(
-                    "#iframe-slot iframe",
-                )!;
-                frame.contentWindow!.postMessage({ nonce, renderer }, "*");
-            },
-            { renderer: descriptor("iframe"), nonce: validNonce },
-        );
-        await page.waitForTimeout(100);
-        expect(
-            await page.evaluate(
-                () =>
-                    (
-                        window as unknown as {
-                            apsMessages: Array<{
-                                data: Record<string, unknown>;
-                            }>;
-                        }
-                    ).apsMessages.length,
-            ),
-        ).toBe(messagesBeforeReplay);
-
-        const requestsBeforeInvalid = runnerRequests;
-        const wrongNonce = "ZYXWVUTSRQPONMLKJIHGFE";
-        await page.evaluate(
-            ({ renderer, fragmentNonce, messageNonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "mismatch-slot",
-                    fragmentNonce,
-                    messageNonce,
-                    renderer,
-                });
-            },
-            {
-                renderer: descriptor("iframe"),
-                fragmentNonce: validNonce,
-                messageNonce: wrongNonce,
-            },
-        );
-        await page.waitForTimeout(100);
-        expect(runnerRequests).toBe(requestsBeforeInvalid);
-        await expect(page.locator("#mismatch-slot .existing")).toHaveCount(1);
-
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "missing-fragment-slot",
-                    fragmentNonce: nonce,
-                    messageNonce: nonce,
-                    includeFragment: false,
-                    renderer,
-                });
-            },
-            { renderer: descriptor("iframe"), nonce: validNonce },
-        );
-        await page.waitForTimeout(100);
-        expect(runnerRequests).toBe(requestsBeforeInvalid);
-        await expect(
-            page.locator("#missing-fragment-slot .existing"),
-        ).toHaveCount(1);
-
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "malformed-slot",
-                    fragmentNonce: nonce,
-                    messageNonce: nonce,
-                    renderer: { ...renderer, unexpected: true },
-                });
-            },
-            { renderer: descriptor("iframe"), nonce: wrongNonce },
-        );
-        await page.waitForTimeout(100);
-        expect(runnerRequests).toBe(requestsBeforeInvalid);
-        await expect(page.locator("#malformed-slot .existing")).toHaveCount(1);
-
-        const scriptNonce = "0123456789abcdefghijkl";
-        await page.evaluate(
-            ({ renderer, nonce }) => {
-                (
-                    window as unknown as {
-                        startApsFrame(options: Record<string, unknown>): void;
-                    }
-                ).startApsFrame({
-                    slotId: "script-slot",
-                    fragmentNonce: nonce,
-                    messageNonce: nonce,
-                    renderer,
-                });
-            },
-            { renderer: descriptor("script"), nonce: scriptNonce },
-        );
-
-        await expect
-            .poll(async () =>
-                page.evaluate(() =>
-                    (
-                        window as unknown as {
-                            apsMessages: Array<{
-                                data: Record<string, unknown>;
-                            }>;
-                        }
-                    ).apsMessages.some(
-                        ({ data }) =>
-                            data.message === "fictional-creative-security" &&
-                            data.tagType === "script",
-                    ),
-                ),
-            )
-            .toBe(true);
-        await expect(page.locator("#script-slot .existing")).toHaveCount(0);
-
-        const scriptState = await page.evaluate(() => ({
-            existing: Boolean(document.querySelector("#script-slot .existing")),
-            compromised: document.body.dataset.apsCompromised,
-            scriptSecurity: (
-                window as unknown as {
-                    apsMessages: Array<{ data: Record<string, unknown> }>;
-                }
-            ).apsMessages.find(
-                ({ data }) =>
-                    data.message === "fictional-creative-security" &&
-                    data.tagType === "script",
-            )?.data,
-        }));
-        expect(scriptState.existing).toBe(false);
-        expect(scriptState.compromised).toBeUndefined();
-        expect(scriptState.scriptSecurity).toEqual(
-            expect.objectContaining({
-                creativeRead: false,
-                creativeWrite: false,
-            }),
-        );
+          ).apsV2Records[id]?.bootstrapConfiguration ?? null,
+        slotId,
+      );
+
+    await start("duplicate-success", "duplicate-success-bid");
+    await expect
+      .poll(async () =>
+        (await messages("duplicate-success")).map((message) => message.message),
+      )
+      .toEqual([
+        "TS APS Document Accepted",
+        "TS APS Runner Loaded",
+        "TS APS Render Completed",
+      ]);
+    await expect(page.locator("#duplicate-success .existing")).toHaveCount(0);
+    expect(
+      (await messages("duplicate-success")).filter((message) =>
+        String(message.message).includes("Render "),
+      ),
+    ).toHaveLength(1);
+
+    await start("reject-case", "reject-case-bid");
+    await expect
+      .poll(async () => await messages("reject-case"))
+      .toContainEqual(
+        expect.objectContaining({
+          message: "TS APS Render Failed",
+          reason: "runner_failed",
+        }),
+      );
+    await expect(page.locator("#reject-case .existing")).toHaveCount(1);
+
+    await start("silent-case", "silent-case-bid");
+    await expect
+      .poll(async () =>
+        (await messages("silent-case")).map((message) => message.message),
+      )
+      .toEqual(["TS APS Document Accepted", "TS APS Runner Loaded"]);
+    await page.waitForTimeout(150);
+    expect(await messages("silent-case")).toHaveLength(2);
+
+    await start("deferred-visibility", "deferred-visibility-bid");
+    await expect
+      .poll(async () =>
+        (await messages("deferred-visibility")).map(
+          (message) => message.message,
+        ),
+      )
+      .toEqual(["TS APS Document Accepted", "TS APS Runner Loaded"]);
+    expect(await snapshots("deferred-visibility")).toEqual([
+      {
+        message: "TS APS Document Accepted",
+        display: "none",
+        existing: 1,
+      },
+      {
+        message: "TS APS Runner Loaded",
+        display: "none",
+        existing: 1,
+      },
+    ]);
+    await expect(page.locator("#deferred-visibility > iframe")).toHaveCSS(
+      "display",
+      "none",
+    );
+    await page
+      .frameLocator("#deferred-visibility > iframe")
+      .frameLocator('iframe[title="Ad content"]')
+      .locator("body")
+      .evaluate(() =>
+        (
+          window as unknown as {
+            __fictionalApsResolve?: () => void;
+          }
+        ).__fictionalApsResolve?.(),
+      );
+    await expect
+      .poll(async () =>
+        (await messages("deferred-visibility")).map(
+          (message) => message.message,
+        ),
+      )
+      .toEqual([
+        "TS APS Document Accepted",
+        "TS APS Runner Loaded",
+        "TS APS Render Completed",
+      ]);
+    await expect(page.locator("#deferred-visibility > iframe")).toBeVisible();
+    await expect(page.locator("#deferred-visibility .existing")).toHaveCount(0);
+
+    const nestedRendererNonce = await start(
+      "nested-case",
+      "nested-case-bid",
+      {},
+      true,
+    );
+    await expect
+      .poll(async () => await messages("nested-case"))
+      .toContainEqual(
+        expect.objectContaining({
+          message: "TS APS Render Completed",
+        }),
+      );
+    const nestedOuterFrame = page.locator("#nested-case > iframe");
+    const nestedOuter = page.frameLocator("#nested-case > iframe");
+    const nestedInnerFrame = nestedOuter.locator(
+      'body > iframe[title="Ad content"]',
+    );
+    const nestedInner = nestedOuter.frameLocator(
+      'body > iframe[title="Ad content"]',
+    );
+    const nestedCreativeFrame = nestedInner.locator(
+      'body > iframe[data-fictional-creative="nested"]',
+    );
+    const nestedCreative = nestedInner.frameLocator(
+      'body > iframe[data-fictional-creative="nested"]',
+    );
+    await expect(nestedOuterFrame).toHaveCount(1);
+    await expect(nestedInnerFrame).toHaveCount(1);
+    await expect(nestedCreativeFrame).toHaveCount(1);
+    await expect(nestedOuterFrame).toHaveAttribute(
+      "sandbox",
+      PERMANENT_SANDBOX,
+    );
+    await expect(nestedInnerFrame).toHaveAttribute(
+      "sandbox",
+      PERMANENT_SANDBOX,
+    );
+    await expect(nestedCreativeFrame).toHaveAttribute(
+      "sandbox",
+      "allow-scripts",
+    );
+    expect(
+      await nestedOuter.locator("html").evaluate(() => location.origin),
+    ).toBe("null");
+    expect(
+      await nestedInner.locator("html").evaluate(() => location.origin),
+    ).toBe("null");
+    expect(
+      await nestedCreative.locator("html").evaluate(() => location.origin),
+    ).toBe("null");
+    for (const frame of [nestedOuter, nestedInner, nestedCreative]) {
+      expect(
+        await frame.locator("html").evaluate(() => {
+          try {
+            return window.top?.document === document;
+          } catch {
+            return false;
+          }
+        }),
+      ).toBe(false);
+    }
+    await expect(
+      nestedOuter.locator('meta[http-equiv="Content-Security-Policy"]'),
+    ).toHaveAttribute(
+      "content",
+      containerCsp("https://creative.example", true),
+    );
+    await expect(
+      nestedInner.locator('meta[http-equiv="Content-Security-Policy"]'),
+    ).toHaveAttribute(
+      "content",
+      containerCsp("https://creative.example", false),
+    );
+    const nestedBootstrapNonce = `b1_${"nested-case".padEnd(22, "b").slice(0, 22)}`;
+    expect(nestedRendererNonce).not.toBe(nestedBootstrapNonce);
+    await expect(nestedOuterFrame).toHaveAttribute(
+      "src",
+      `${APS_TEST_RENDERER_URL}#${nestedBootstrapNonce}`,
+    );
+    expect(await nestedInnerFrame.getAttribute("src")).toContain(
+      `#${nestedRendererNonce}`,
+    );
+    for (const html of [
+      await nestedOuter
+        .locator("html")
+        .evaluate((element) => element.outerHTML),
+      await nestedInner
+        .locator("html")
+        .evaluate((element) => element.outerHTML),
+    ]) {
+      expect(html).not.toContain("nested-case-bid");
+      expect(html).not.toContain("example-account-id");
+      expect(html).not.toContain("fictional-nested-case-creative");
+    }
+    expect(
+      await page.locator("#nested-case").evaluate((slot) => ({
+        iframeAncestor: slot.parentElement?.closest("iframe") !== null,
+        gamAncestor:
+          slot.parentElement?.closest(
+            "[data-google-query-id],[data-google-container-id]",
+          ) !== null,
+        safeFrameAncestor:
+          slot.parentElement?.closest('[id*="safeframe" i]') !== null,
+      })),
+    ).toEqual({
+      iframeAncestor: false,
+      gamAncestor: false,
+      safeFrameAncestor: false,
     });
-
-    test("rejects same-origin creative URLs through the TSJS rendering path", async ({
-        page,
-    }) => {
-        const publisherOrigin = "https://publisher.example";
-        const rendererUrl = `${publisherOrigin}/integrations/aps/renderer`;
-        const auctionUrl = `${publisherOrigin}/auction`;
-        const testUrl = `${publisherOrigin}/aps-same-origin-test`;
-        const runtimeRenderer = await page.request.get(
-            runtimeUrl("/integrations/aps/renderer"),
-        );
-        const rendererDocument = await runtimeRenderer.text();
-        let creativeUrl = SCRIPT_CREATIVE_URL;
-        let runnerRequests = 0;
-
-        await page.route(RUNNER_URL, async (route) => {
-            runnerRequests += 1;
-            await route.fulfill({
-                status: 200,
-                contentType: "application/javascript",
-                body: FAKE_RUNNER,
-            });
-        });
-        await page.route(rendererUrl, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                headers: {
-                    "Content-Security-Policy":
-                        runtimeRenderer.headers()["content-security-policy"],
-                    "Referrer-Policy": "no-referrer",
-                },
-                body: rendererDocument,
-            });
-        });
-        await page.route(auctionUrl, async (route) => {
-            const renderer = descriptor("script", creativeUrl);
-            await route.fulfill({
-                status: 200,
-                contentType: "application/json",
-                body: JSON.stringify({
-                    id: "fictional-auction",
-                    seatbid: [
-                        {
-                            seat: "aps",
-                            bid: [
-                                {
-                                    id: renderer.bidId,
-                                    impid: "same-origin-slot",
-                                    price: 1.23,
-                                    w: 300,
-                                    h: 250,
-                                    ext: {
-                                        trusted_server: { renderer },
-                                    },
-                                },
-                            ],
-                        },
-                    ],
-                    ext: {},
-                }),
-            });
-        });
-        await page.route(testUrl, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                headers: {
-                    "Content-Security-Policy":
-                        "default-src 'none'; script-src 'unsafe-inline'; connect-src 'self'; frame-src 'self'",
-                },
-                body: '<!doctype html><div id="same-origin-slot"><span class="existing">existing publisher content</span></div>',
-            });
-        });
-
-        await page.goto(testUrl);
-        await page.addScriptTag({ path: clientAuctionBundlePaths().core });
-        await page.evaluate(() => {
-            const tsjs = (
-                window as unknown as {
-                    tsjs: {
-                        addAdUnits(units: Array<Record<string, unknown>>): void;
-                        log: {
-                            info(message: string, ...args: unknown[]): void;
-                        };
-                        requestAds(): void;
-                    };
-                    auctionRenderCompletions?: number;
-                }
-            ).tsjs;
-            tsjs.addAdUnits([
-                {
-                    code: "same-origin-slot",
-                    mediaTypes: { banner: { sizes: [[300, 250]] } },
-                    bids: [],
-                },
-            ]);
-            const originalInfo = tsjs.log.info.bind(tsjs.log);
-            tsjs.log.info = (message: string, ...args: unknown[]) => {
-                if (
-                    message === "requestAds: rendered creatives from response"
-                ) {
-                    (
-                        window as unknown as {
-                            auctionRenderCompletions: number;
-                        }
-                    ).auctionRenderCompletions += 1;
-                }
-                originalInfo(message, ...args);
-            };
-            (
-                window as unknown as {
-                    auctionRenderCompletions: number;
-                }
-            ).auctionRenderCompletions = 0;
-            tsjs.requestAds();
-        });
-
-        await expect.poll(() => runnerRequests).toBe(1);
-        await expect
-            .poll(() =>
-                page.evaluate(
-                    () =>
-                        (
-                            window as unknown as {
-                                auctionRenderCompletions: number;
-                            }
-                        ).auctionRenderCompletions,
-                ),
-            )
-            .toBe(1);
-        await expect(page.locator("#same-origin-slot .existing")).toHaveCount(
-            0,
-        );
-        const productSandbox = await page
-            .locator("#same-origin-slot > iframe")
-            .getAttribute("sandbox");
-        expect(productSandbox).toBe(SANDBOX);
-        expect(productSandbox).not.toContain("allow-same-origin");
-
-        creativeUrl = `${publisherOrigin}/fictional-same-origin.js`;
-        await page.locator("#same-origin-slot").evaluate((slot) => {
-            slot.innerHTML =
-                '<span class="existing">existing publisher content</span>';
-        });
-        await page.evaluate(() => {
-            (
-                window as unknown as {
-                    tsjs: { requestAds(): void };
-                }
-            ).tsjs.requestAds();
-        });
-
-        await expect
-            .poll(() =>
-                page.evaluate(
-                    () =>
-                        (
-                            window as unknown as {
-                                auctionRenderCompletions: number;
-                            }
-                        ).auctionRenderCompletions,
-                ),
-            )
-            .toBe(2);
-        expect(runnerRequests).toBe(1);
-        await expect(page.locator("#same-origin-slot iframe")).toHaveCount(0);
-        await expect(page.locator("#same-origin-slot .existing")).toHaveCount(
-            1,
-        );
+    expect(await bootstrapConfiguration("nested-case")).toEqual({
+      message: "TS APS Bootstrap Configure",
+      version: 2,
+      bootstrapNonce: nestedBootstrapNonce,
+      rendererNonce: nestedRendererNonce,
+      creativeOrigin: "https://creative.example",
+      tagType: "iframe",
     });
 
-    test("renders publisher-native mode through the injected friendly-frame runner", async ({
-        page,
-    }) => {
-        const publisherOrigin = "https://publisher.example";
-        const auctionUrl = `${publisherOrigin}/auction`;
-        const testUrl = `${publisherOrigin}/aps-publisher-native-test`;
-        const renderer = descriptor("iframe");
-        const coreBundle = readFileSync(clientAuctionBundlePaths().core, "utf8");
-        let runnerRequests = 0;
-        let runnerReferrer: string | undefined;
-        let creativeReferrer: string | undefined;
-
-        await page.route(PUBLISHER_CORE_URL, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "application/javascript",
-                body: coreBundle,
-            });
-        });
-        await page.route(RUNNER_URL, async (route) => {
-            runnerRequests += 1;
-            runnerReferrer = route.request().headers()["referer"];
-            await route.fulfill({
-                status: 200,
-                contentType: "application/javascript",
-                body: FAKE_RUNNER,
-            });
-        });
-        await page.route(IFRAME_CREATIVE_URL, async (route) => {
-            creativeReferrer = route.request().headers()["referer"];
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                body: IFRAME_CREATIVE,
-            });
-        });
-        await page.route(auctionUrl, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "application/json",
-                body: JSON.stringify({
-                    id: "fictional-native-auction",
-                    seatbid: [
-                        {
-                            seat: "aps",
-                            bid: [
-                                {
-                                    id: renderer.bidId,
-                                    impid: "publisher-native-slot",
-                                    price: 1.23,
-                                    w: renderer.width,
-                                    h: renderer.height,
-                                    ext: { trusted_server: { renderer } },
-                                },
-                            ],
-                        },
-                    ],
-                    ext: {},
-                }),
-            });
-        });
-        await page.route(testUrl, async (route) => {
-            await route.fulfill({
-                status: 200,
-                contentType: "text/html",
-                headers: {
-                    "Content-Security-Policy":
-                        "default-src 'none'; script-src https://tsjs.example https://client.aps.amazon-adsystem.com https://creative.example; connect-src 'self'; frame-src https://creative.example",
-                },
-                body: `<!doctype html>
-<div id="publisher-native-slot"><span class="existing">existing publisher content</span></div>`,
-            });
+    await start("creative-script", "creative-script-bid", {
+      creativeUrl: "https://creative.example/script-allowed.js",
+      tagType: "script",
+    });
+    await expect
+      .poll(async () => await messages("creative-script"))
+      .toContainEqual(
+        expect.objectContaining({ message: "TS APS Render Completed" }),
+      );
+    const scriptInner = page
+      .frameLocator("#creative-script > iframe")
+      .frameLocator('iframe[title="Ad content"]');
+    await expect(
+      page
+        .frameLocator("#creative-script > iframe")
+        .locator('meta[http-equiv="Content-Security-Policy"]'),
+    ).toHaveAttribute(
+      "content",
+      containerCsp("https://creative.example", true, true),
+    );
+    await expect(
+      scriptInner.locator('meta[http-equiv="Content-Security-Policy"]'),
+    ).toHaveAttribute(
+      "content",
+      containerCsp("https://creative.example", false, true),
+    );
+    expect(
+      await scriptInner.locator("html").evaluate(() => ({
+        allowed: document.documentElement.dataset.scriptCreative,
+        unrelated: document.documentElement.dataset.otherScript,
+      })),
+    ).toEqual({ allowed: "executed", unrelated: undefined });
+
+    // WebKit's Playwright interception backend cannot synthesize a redirect
+    // response. Exercise the same exact-origin CSP boundary there by asking the
+    // fictional runner to attempt the redirected final URL directly; Chromium
+    // and Firefox retain the end-to-end redirect case.
+    const redirectBidId =
+      browserName === "webkit"
+        ? "creative-cross-origin-bid"
+        : "creative-redirect-bid";
+    await start("creative-redirect", redirectBidId, {
+      creativeUrl: "https://creative.example/script-redirect.js",
+      tagType: "script",
+    });
+    await expect
+      .poll(async () => await messages("creative-redirect"))
+      .toContainEqual(
+        expect.objectContaining({
+          message: "TS APS Render Failed",
+          reason: "runner_failed",
+        }),
+      );
+    const redirectInner = page
+      .frameLocator("#creative-redirect > iframe")
+      .frameLocator('iframe[title="Ad content"]');
+    expect(
+      await redirectInner
+        .locator("html")
+        .evaluate(() => document.documentElement.dataset.redirectedScript),
+    ).toBeUndefined();
+
+    for (const { slotId, bidId, width, height } of [
+      {
+        slotId: "creative-boundary-min",
+        bidId: "creative-min",
+        width: 1,
+        height: 1,
+      },
+      {
+        slotId: "creative-boundary-max",
+        bidId: "creative-max",
+        width: 4096,
+        height: 4096,
+      },
+    ]) {
+      await start(slotId, bidId, {
+        creativeUrl: "https://creative.example/iframe-policy",
+        tagType: "iframe",
+        width,
+        height,
+      });
+      await expect
+        .poll(async () => await messages(slotId))
+        .toContainEqual(
+          expect.objectContaining({ message: "TS APS Render Completed" }),
+        );
+      const outerFrame = page.locator(`#${slotId} > iframe`);
+      const outer = page.frameLocator(`#${slotId} > iframe`);
+      const innerFrame = outer.locator('iframe[title="Ad content"]');
+      const inner = outer.frameLocator('iframe[title="Ad content"]');
+      const creativeFrame = inner.locator(
+        'iframe[data-fictional-creative="iframe"]',
+      );
+      const creative = inner.frameLocator(
+        'iframe[data-fictional-creative="iframe"]',
+      );
+      for (const frame of [outerFrame, creativeFrame]) {
+        await expect(frame).toHaveAttribute("width", String(width));
+        await expect(frame).toHaveAttribute("height", String(height));
+      }
+      for (const [frame, declaredOverflow] of [
+        [outerFrame, "hidden"],
+        [innerFrame, ""],
+        [creativeFrame, "hidden"],
+      ] as const) {
+        const frameBox = await frame.evaluate((element) => {
+          const value = element as HTMLElement;
+          const box = value.getBoundingClientRect();
+          const computed = getComputedStyle(value);
+          return {
+            width: box.width,
+            height: box.height,
+            clientWidth: value.clientWidth,
+            clientHeight: value.clientHeight,
+            margin: computed.margin,
+            declaredOverflow: value.style.overflow,
+            computedOverflow: computed.overflow,
+          };
         });
-
-        await page.goto(testUrl);
-        await page.evaluate(async (scriptUrl) => {
-            await new Promise<void>((resolveScript, rejectScript) => {
-                const script = document.createElement("script");
-                script.setAttribute(
-                    "data-ts-aps-rendering-mode",
-                    "publisher_native",
-                );
-                script.src = scriptUrl;
-                script.addEventListener("load", () => resolveScript(), {
-                    once: true,
-                });
-                script.addEventListener(
-                    "error",
-                    () => rejectScript(new Error("TSJS core failed to load")),
-                    { once: true },
-                );
-                document.head.appendChild(script);
-            });
-        }, PUBLISHER_CORE_URL);
-        await page.evaluate(() => {
-            const tsjs = (
-                window as unknown as {
-                    tsjs: {
-                        addAdUnits(units: Array<Record<string, unknown>>): void;
-                        requestAds(): void;
-                    };
-                }
-            ).tsjs;
-            tsjs.addAdUnits([
-                {
-                    code: "publisher-native-slot",
-                    mediaTypes: { banner: { sizes: [[300, 250]] } },
-                    bids: [],
-                },
-            ]);
-            tsjs.requestAds();
+        expect(frameBox).toMatchObject({
+          width,
+          height,
+          clientWidth: width,
+          clientHeight: height,
+          margin: "0px",
+          declaredOverflow,
         });
-
-        await expect.poll(() => runnerRequests).toBe(1);
-        const frame = page.locator("#publisher-native-slot > iframe");
-        await expect(frame).toHaveCount(1);
-        await expect(frame).toBeVisible();
-        expect(await frame.getAttribute("sandbox")).toBeNull();
-        await expect(
-            frame
-                .contentFrame()
-                .locator(`iframe[src="${IFRAME_CREATIVE_URL}"]`),
-        ).toHaveCount(1);
-        await expect(
-            page.locator("#publisher-native-slot .existing"),
-        ).toHaveCount(0);
-        expect(runnerReferrer).toBeUndefined();
-        expect(creativeReferrer).toBeUndefined();
+        // Chromium normalizes overflow on replaced iframe elements to `clip`;
+        // Firefox/WebKit may preserve the declared `hidden` computed value.
+        expect(["clip", "hidden"]).toContain(frameBox.computedOverflow);
+      }
+      for (const frame of [outer, inner, creative]) {
         expect(
-            await frame.evaluate((element: HTMLIFrameElement) => {
-                const document = element.contentDocument!;
-                const creative = document.body.querySelector("iframe")!;
-                return {
-                    bodyMargin: getComputedStyle(document.body).margin,
-                    bodyPadding: getComputedStyle(document.body).padding,
-                    creativeDisplay: getComputedStyle(creative).display,
-                    clientWidth: document.documentElement.clientWidth,
-                    clientHeight: document.documentElement.clientHeight,
-                    scrollWidth: document.documentElement.scrollWidth,
-                    scrollHeight: document.documentElement.scrollHeight,
-                };
-            }),
+          await frame.locator("body").evaluate((body) => {
+            const computed = getComputedStyle(body);
+            return {
+              clientWidth: body.clientWidth,
+              clientHeight: body.clientHeight,
+              scrollWidth: body.scrollWidth,
+              scrollHeight: body.scrollHeight,
+              margin: computed.margin,
+              overflow: computed.overflow,
+            };
+          }),
         ).toEqual({
-            bodyMargin: "0px",
-            bodyPadding: "0px",
-            creativeDisplay: "block",
-            clientWidth: 300,
-            clientHeight: 250,
-            scrollWidth: 300,
-            scrollHeight: 250,
+          clientWidth: width,
+          clientHeight: height,
+          scrollWidth: width,
+          scrollHeight: height,
+          margin: "0px",
+          overflow: "hidden",
         });
-        expect(
-            await page
-                .locator("#publisher-native-slot")
-                .evaluate(
-                    (slot) =>
-                        slot.querySelectorAll(
-                            'iframe[src*="/integrations/aps/renderer"]',
-                        ).length,
-                ),
-        ).toBe(0);
+      }
+      expect(
+        await creative
+          .locator("html")
+          .evaluate(() => document.documentElement.dataset.externalScript),
+      ).toBeUndefined();
+    }
+    const requestsBeforeInvalid = runnerRequests;
+    await start("invalid-case", "invalid-case-bid", {
+      unexpected: true,
     });
+    await expect
+      .poll(async () => await messages("invalid-case"))
+      .toContainEqual(
+        expect.objectContaining({
+          message: "TS APS Render Failed",
+          reason: "descriptor_invalid",
+        }),
+      );
+    expect(runnerRequests).toBe(requestsBeforeInvalid);
+
+    await page.unroute(APS_TEST_RUNNER_URL);
+    await page.route(APS_TEST_RUNNER_URL, (route) => route.abort());
+    await start("load-failure-case", "load-failure-case-bid");
+    await expect
+      .poll(async () => await messages("load-failure-case"))
+      .toContainEqual(
+        expect.objectContaining({
+          message: "TS APS Render Failed",
+          reason: "runner_no_load",
+        }),
+      );
+  });
 });
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts
index 580e7db3e..31acebc5a 100644
--- a/crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts
@@ -1,5 +1,13 @@
 import { test, expect } from "@playwright/test";
 import { runtimeUrl } from "../../helpers/state.js";
+import {
+  routeRuntimeTsjsFixture,
+  runtimeTsjsFixture,
+  serverBootTransportLiteralV1,
+  type RuntimeTsjsFixture,
+} from "../../helpers/tsjs-fixture.js";
+
+const CREATIVE_FIXTURE = runtimeTsjsFixture(["render_runtime", "creative"]);
 
 // Creative iframes are sandboxed WITHOUT `allow-same-origin`, so the creative
 // runtime executes in an opaque origin whose `location.href` is `about:srcdoc`.
@@ -15,13 +23,63 @@ const CREATIVE_SANDBOX_TOKENS = [
   "allow-top-navigation-by-user-activation",
 ].join(" ");
 
-// A creative <head> script that tries to redirect click resolution to an
-// attacker origin. It executes before the runtime injected at the top of
-// <body>, so the stamp must be non-writable for the recovery below to stay on
-// the first-party origin.
-const HOSTILE_STAMP_OVERWRITE = `<script>
-  try { window.__tsCreativeOrigin = 'https://attacker.invalid'; } catch (e) {}
-</script>`;
+// Mirrors the srcdoc document the client builds: the first-party parent stamps
+// its own origin ahead of any creative markup, then the runtime, then the
+// creative. The anchor carries a root-relative signed click exactly as the
+// server-side rewriter emits it.
+function creativeDocument(
+  origin: string,
+  bundleUrl: string,
+  fixture: RuntimeTsjsFixture,
+  signedClick: string,
+): string {
+  const transport = serverBootTransportLiteralV1({
+    abi: 1,
+    releaseId: fixture.releaseId,
+    manifest: fixture.manifest,
+    auctionProjection: {
+      version: 1,
+      auction: { version: 1, auctionId: "creative-sandbox", results: [] },
+      slots: [],
+      bids: [],
+    },
+    integrations: { version: 1, entries: [] },
+    creative: {
+      version: 1,
+      enabled: true,
+      clickGuard: true,
+      renderGuard: false,
+    },
+    diagnostics: {
+      version: 1,
+      renderTraceOverlay: false,
+      gpt: { active: false },
+    },
+  });
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+      Object.defineProperty(window, '__tsCreativeOrigin', {
+        value: ${JSON.stringify(origin)},
+        writable: false,
+        configurable: false,
+        enumerable: false,
+      });
+      window.tsjs = { que: [] };
+      const __TSJS_SERVER_BOOT_TRANSPORT_V1__ = ${transport};
+      ${fixture.bootstrapBody}
+    </script>
+    <script>
+      try { window.__tsCreativeOrigin = 'https://attacker.invalid'; } catch (_error) {}
+    </script>
+    <script src="${bundleUrl}" id="trustedserver-js"></script>
+  </head>
+  <body>
+    <a id="creative-link" href="${signedClick}" data-tsclick="${signedClick}">ad</a>
+  </body>
+</html>`;
+}
 
 test.describe("Sandboxed creative iframe", () => {
   test("recovers a mutated click through the signed GET rebuild chain", async ({
@@ -52,38 +110,8 @@ test.describe("Sandboxed creative iframe", () => {
 
     await page.goto(runtimeUrl("/"), { waitUntil: "domcontentloaded" });
 
-    // Reuse whichever hashed bundle URL the server injected into the page so
-    // this test never has to know the current content hash; fall back to the
-    // stable unified path if the fixture page carries no injected script.
-    const injectedBundle = await page.evaluate(() => {
-      const script = Array.from(document.querySelectorAll("script[src]")).find(
-        (element) =>
-          (element as HTMLScriptElement).src.includes("/static/tsjs="),
-      );
-      return script ? (script as HTMLScriptElement).src : null;
-    });
-    const bundleUrl =
-      injectedBundle ?? runtimeUrl("/static/tsjs=tsjs-unified.min.js");
-
-    // Mirrors the srcdoc document the client builds: the first-party parent
-    // stamps its own origin ahead of any creative markup, then the runtime,
-    // then the creative — here preceded by hostile markup attempting to move
-    // the stamp.
-    const creativeDocument = `<!DOCTYPE html>
-<html>
-  <head>
-    <script>
-      Object.defineProperty(window, '__tsCreativeOrigin', {
-        value: '${origin}', writable: false, configurable: false, enumerable: false,
-      });
-    </script>
-  </head>
-  <body>
-    ${HOSTILE_STAMP_OVERWRITE}
-    <script src="${bundleUrl}"></script>
-    <a id="creative-link" href="${signedClick}" data-tsclick="${signedClick}">ad</a>
-  </body>
-</html>`;
+    await routeRuntimeTsjsFixture(page, CREATIVE_FIXTURE);
+    const bundleUrl = new URL(CREATIVE_FIXTURE.runtimeSrc, origin).toString();
 
     const rebuildResponse = page.waitForResponse(
       (response) => response.url().includes("/first-party/proxy-rebuild"),
@@ -105,12 +133,50 @@ test.describe("Sandboxed creative iframe", () => {
         iframe.style.height = "250px";
         document.body.appendChild(iframe);
       },
-      { sandbox: CREATIVE_SANDBOX_TOKENS, html: creativeDocument },
+      {
+        sandbox: CREATIVE_SANDBOX_TOKENS,
+        html: creativeDocument(
+          new URL(runtimeUrl("/")).origin,
+          bundleUrl,
+          CREATIVE_FIXTURE,
+          signedClick,
+        ),
+      },
     );
 
     const frame = page.frameLocator("iframe");
     const link = frame.locator("#creative-link");
     await link.waitFor({ state: "attached", timeout: 10_000 });
+    await expect
+      .poll(() =>
+        frame.locator("html").evaluate(() => {
+          const api = (window as any).tsjs;
+          return {
+            state: api?._internal?.state,
+            names: Object.getOwnPropertyNames(api ?? {}).sort(),
+            legacyCreativeGlobal: Object.prototype.hasOwnProperty.call(
+              window,
+              "tscreative",
+            ),
+          };
+        }),
+      )
+      .toEqual({
+        state: "kernel",
+        names: [
+          "_internal",
+          "_registerIntegration",
+          "addAdUnits",
+          "boot",
+          "diagnostics",
+          "log",
+          "que",
+          "releaseId",
+          "requestAds",
+          "version",
+        ],
+        legacyCreativeGlobal: false,
+      });
 
     // The creative mutates its own click target, the shape the click guard
     // exists to repair.
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts
new file mode 100644
index 000000000..edd2be7df
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts
@@ -0,0 +1,2596 @@
+import { execFileSync } from "node:child_process";
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+} from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import {
+  chromium,
+  expect,
+  test,
+  type Browser,
+  type BrowserContext,
+  type Page,
+} from "@playwright/test";
+import { measureBytes } from "../../../../trusted-server-js/lib/scripts/bundle-metrics.mjs";
+
+const REPO_ROOT = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+  encoding: "utf8",
+}).trim();
+const WARMUPS = 5;
+const SAMPLES = 50;
+const PERCENTILE = 90;
+const MAXIMUM_P90_RATIO = 1.1;
+const EXPECTED_CHROMIUM = "145.0.7632.6";
+const MACHINE_CLASS = "github-hosted:ubuntu-24.04";
+const RUNNER_IMAGE = "ubuntu-24.04";
+const FIXTURE_ID = "tsjs-baseline-paired-network-v3";
+const CONTROLLER_ID = "generated-server-v1+production-rc-v1";
+const COMPARISON_START_MARK = "tsjs:comparison-start";
+const FIRST_OBSERVABLE_ACTION_MARK = "tsjs:first-observable-action";
+const NETWORK_PROFILE = Object.freeze({
+  offline: false,
+  latency: 150,
+  downloadThroughput: 200_000,
+  uploadThroughput: 93_750,
+  packetLoss: 0,
+});
+// The rc baseline always ships creative with core, and production's default
+// creative guard is enabled. Keep both comparison sides on that same shape.
+const SELECTED_IDS = ["render_runtime", "creative", "gpt"] as const;
+const DEFERRED_IDS = ["diagnostics_presentation", "gpt_later"] as const;
+const LEGACY_AD_INIT_INLINE = "window.tsjs.adInit();";
+const HEAP_CHECKPOINTS = [
+  "afterBoot",
+  "afterFirstRender",
+  "afterRefresh",
+  "afterSpaNavigation",
+] as const;
+const HARD_HEAP_CEILING_BYTES = 4 * 1024 * 1024;
+const HEAP_OPERATION_TIMEOUT_MS = 30_000;
+const APS_ACTION_P90_CEILING_MS = 900;
+const APS_ACTION_TO_COMPLETION_P90_CEILING_MS = 1_500;
+const APS_COMPLETION_TO_PAINT_P90_CEILING_MS = 250;
+const APS_TOTAL_P90_CEILING_MS = 2_500;
+const APS_AFTER_PAINT_HEAP_CEILING_BYTES = 3 * 1024 * 1024;
+const APS_AFTER_TAKEOVER_HEAP_CEILING_BYTES = 3_932_160;
+const FICTIONAL_APS_RUNNER = readFileSync(
+  resolve(
+    REPO_ROOT,
+    "crates/trusted-server-integration-tests/browser/fixtures/fictional-aps-runner.js",
+  ),
+  "utf8",
+);
+
+type PerformanceCase = "gpt" | "aps";
+
+type HeapCheckpoint = (typeof HEAP_CHECKPOINTS)[number];
+
+interface ReleaseArtifact {
+  id: string;
+  role:
+    | "bootstrap"
+    | "first_display_base"
+    | "first_display_slice"
+    | "core"
+    | "integration";
+  phase: "first_display" | "takeover" | "deferred" | null;
+  trigger: "first_display_or_idle" | null;
+  file: string;
+  hash: string;
+}
+
+interface Release {
+  version: 1;
+  releaseId: string;
+  artifacts: ReleaseArtifact[];
+}
+
+interface FixtureResources {
+  performanceCase: PerformanceCase;
+  artifactModel: "release-v1" | "legacy-rc-v1";
+  release: Release | null;
+  controllerDocument: string | null;
+  selectedBody: string;
+  selectedTransferBytes: number;
+  selectedSrc: string;
+  runtimeBody: string | null;
+  runtimeSrc: string | null;
+  deferred: Map<string, { body: string; src: string }>;
+  referenceTransfer: ReferenceTransfer;
+  apsRendererDocument: string | null;
+  apsRendererPath:
+    "/integrations/aps/renderer" | "/integrations/aps/renderer/v2" | null;
+}
+
+interface ReferenceTransferSource {
+  semanticEndpoint: string;
+  delivery: "inline" | "external";
+  rawBytes: number;
+  gzipBytes: number;
+  brotliBytes: number;
+  sha256: string;
+}
+
+interface ReferenceTransfer {
+  sources: ReferenceTransferSource[];
+  rawBytes: number;
+  gzipBytes: number;
+  brotliBytes: number;
+}
+
+function externalAgentTransfer(
+  transfer: ReferenceTransfer,
+): ReferenceTransferSource {
+  const external = transfer.sources.filter(
+    ({ delivery }) => delivery === "external",
+  );
+  if (external.length !== 1) {
+    throw new Error("reference transfer must contain one external agent");
+  }
+  return external[0]!;
+}
+
+interface FixtureRun {
+  context: BrowserContext;
+  page: Page;
+  selectedRequests: string[];
+  runtimeRequests: string[];
+  deferredRequests: string[];
+  pageErrors: string[];
+  consoleMessages: string[];
+  close(): Promise<void>;
+}
+
+interface FixtureServer {
+  origin: string;
+  close(): Promise<void>;
+}
+
+interface FixtureServerOptions {
+  rejectRuntime?: boolean;
+}
+
+interface OpenFixtureOptions {
+  manualDisplay?: boolean;
+  probeAttemptResources?: boolean;
+  waitUntil?: "commit" | "load";
+}
+
+interface BrowserObservation {
+  timingMs: number;
+  markTimingMs: number;
+  bidsScriptCount: number;
+  firstDisplayCount: number;
+  firstDisplayPaintCount: number;
+  measureCount: number;
+  runtimeState: string | undefined;
+  releaseId: string | undefined;
+  displayCount: number;
+  diagnosticsPresentationCount: number;
+  selectedScriptCount: number;
+  deferred: Array<{
+    id: string;
+    startTime: number;
+    responseEnd: number;
+    loadTime: number;
+    preparationTime: number;
+    executionTime: number;
+  }>;
+  paintTime: number;
+  preloadBeforePaintCount: number;
+}
+
+interface ComparisonObservation {
+  timingMs: number;
+  displayCount: number;
+  releaseId: string | undefined;
+  actionToCompletionMs?: number;
+  completionToPaintMs?: number;
+  totalToPaintMs?: number;
+}
+
+function exactArtifact(release: Release, id: string): ReleaseArtifact {
+  const matches = release.artifacts.filter((artifact) => artifact.id === id);
+  if (matches.length !== 1)
+    throw new Error(`expected one release artifact for ${id}`);
+  return matches[0]!;
+}
+
+function apsDescriptor() {
+  const bid = {
+    id: "performance-aps-bid",
+    price: 1.25,
+    w: 300,
+    h: 250,
+    ext: {
+      creativeurl: "https://creative.example/performance",
+      tagtype: "iframe",
+    },
+  };
+  return {
+    type: "aps",
+    version: 1,
+    accountId: "fictional-performance-account",
+    bidId: bid.id,
+    creativeId: "fictional-performance-creative",
+    tagType: bid.ext.tagtype,
+    creativeUrl: bid.ext.creativeurl,
+    aaxResponse: Buffer.from(
+      JSON.stringify({ seatbid: [{ bid: [bid] }] }),
+      "utf8",
+    ).toString("base64"),
+    width: bid.w,
+    height: bid.h,
+  };
+}
+
+function legacyBootInline(performanceCase: PerformanceCase): string {
+  const slots = [
+    {
+      id: "perf-slot",
+      gam_unit_path: "/123/performance",
+      div_id: "perf-slot",
+      formats: [[300, 250]],
+      targeting: {},
+    },
+  ];
+  const bids =
+    performanceCase === "aps"
+      ? {
+          "perf-slot": {
+            hb_adid: "performance-aps-bid",
+            hb_bidder: "aps",
+            hb_pb: "1.25",
+            renderer: apsDescriptor(),
+          },
+        }
+      : {};
+  return `window.tsjs={adSlots:${JSON.stringify(slots)},bids:${JSON.stringify(bids)},navGeneration:0};window.__tsjs_gpt_enabled=true;`;
+}
+
+function exactControllerInline(document: string): string {
+  const normalized = document.toLowerCase();
+  const opening = "<script>";
+  const closing = "</script";
+  const inline: string[] = [];
+  let cursor = 0;
+  for (;;) {
+    const start = normalized.indexOf(opening, cursor);
+    if (start < 0) break;
+    const bodyStart = start + opening.length;
+    let closeStart = normalized.indexOf(closing, bodyStart);
+    let closeEnd = -1;
+    while (closeStart >= 0) {
+      closeEnd = closeStart + closing.length;
+      while (
+        closeEnd < normalized.length &&
+        (normalized[closeEnd] === " " ||
+          normalized[closeEnd] === "\t" ||
+          normalized[closeEnd] === "\n" ||
+          normalized[closeEnd] === "\r" ||
+          normalized[closeEnd] === "\f")
+      ) {
+        closeEnd += 1;
+      }
+      if (normalized[closeEnd] === ">") break;
+      closeStart = normalized.indexOf(closing, closeEnd);
+    }
+    if (closeStart < 0 || closeEnd < 0)
+      throw new Error(
+        "production controller contains an unclosed inline script",
+      );
+    inline.push(document.slice(bodyStart, closeStart));
+    cursor = closeEnd + 1;
+  }
+  if (
+    inline.length !== 1 ||
+    !inline[0]?.includes('performance.mark("tsjs:bids-script")')
+  ) {
+    throw new Error(
+      "production controller must contain one TSJS bids-script inline source",
+    );
+  }
+  return inline[0];
+}
+
+function measureReferenceTransfer(
+  sources: ReadonlyArray<{
+    semanticEndpoint: string;
+    delivery: "inline" | "external";
+    body: string;
+  }>,
+): ReferenceTransfer {
+  if (sources.length === 0)
+    throw new Error("semantic transfer must not be empty");
+  const endpoints = new Set<string>();
+  const measured = sources.map(({ semanticEndpoint, delivery, body }) => {
+    if (
+      !semanticEndpoint ||
+      endpoints.has(semanticEndpoint) ||
+      body.length === 0
+    ) {
+      throw new Error("semantic transfer source is empty or duplicated");
+    }
+    endpoints.add(semanticEndpoint);
+    return {
+      semanticEndpoint,
+      delivery,
+      ...measureBytes(Buffer.from(body, "utf8")),
+    };
+  });
+  return {
+    sources: measured,
+    rawBytes: measured.reduce((total, source) => total + source.rawBytes, 0),
+    gzipBytes: measured.reduce((total, source) => total + source.gzipBytes, 0),
+    brotliBytes: measured.reduce(
+      (total, source) => total + source.brotliBytes,
+      0,
+    ),
+  };
+}
+
+function loadReleaseFixtureResources(
+  repositoryRoot: string,
+  performanceCase: PerformanceCase = "gpt",
+): FixtureResources {
+  const tsjsCrate = resolve(repositoryRoot, "crates/trusted-server-js");
+  const dist = resolve(tsjsCrate, "dist");
+  const releaseFile = resolve(dist, "tsjs-release-v1.json");
+  const release = JSON.parse(readFileSync(releaseFile, "utf8")) as Release;
+  expect(release.version).toBe(1);
+  const selectedIds =
+    performanceCase === "aps"
+      ? (["render_runtime", "aps", "creative", "gpt"] as const)
+      : SELECTED_IDS;
+  const runtimeArtifacts = [exactArtifact(release, "core")].concat(
+    selectedIds.map((id) => exactArtifact(release, id)),
+  );
+  for (const artifact of runtimeArtifacts.slice(1)) {
+    expect(artifact.phase).toBe("takeover");
+  }
+  expect(runtimeArtifacts.map(({ id }) => id)).toEqual([
+    "core",
+    ...selectedIds,
+  ]);
+  const runtimeBody = runtimeArtifacts
+    .map((artifact) => readFileSync(resolve(dist, artifact.file), "utf8"))
+    .join(";\n");
+  const runtimeHash = createHash("sha256").update(runtimeBody).digest("hex");
+  const runtimeSrc = `/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`;
+  const firstDisplayIds =
+    performanceCase === "aps"
+      ? ([
+          "first_display",
+          "render_owner_initial",
+          "aps_initial",
+          "creative_initial",
+          "gpt_initial",
+        ] as const)
+      : ([
+          "first_display",
+          "render_owner_initial",
+          "creative_initial",
+          "gpt_initial",
+        ] as const);
+  const firstDisplayArtifacts = firstDisplayIds.map((id) =>
+    exactArtifact(release, id),
+  );
+  for (const artifact of firstDisplayArtifacts)
+    expect(artifact.phase).toBe("first_display");
+  const selectedBody = firstDisplayArtifacts
+    .filter(({ id }) => id !== "first_display")
+    .map((artifact) => readFileSync(resolve(dist, artifact.file), "utf8"))
+    .join(";\n");
+  const selectedHash = createHash("sha256").update(selectedBody).digest("hex");
+  const mask = performanceCase === "aps" ? "008f" : "008b";
+  const selectedSrc = `/static/tsjs=tsjs-first-display.min.js?m=${mask}&v=${selectedHash}`;
+  const deferred = new Map<string, { body: string; src: string }>();
+  for (const id of DEFERRED_IDS) {
+    const artifact = exactArtifact(release, id);
+    expect(artifact.phase).toBe("deferred");
+    expect(artifact.trigger).toBe("first_display_or_idle");
+    deferred.set(id, {
+      body: readFileSync(resolve(dist, artifact.file), "utf8"),
+      src: `/static/tsjs=tsjs-${id}.min.js?v=${artifact.hash}`,
+    });
+  }
+  const directory = mkdtempSync(join(tmpdir(), "tsjs-performance-controller-"));
+  const projectionPath = resolve(directory, "projection.json");
+  let controllerDocument: string;
+  try {
+    writeFileSync(
+      projectionPath,
+      `${JSON.stringify(initialProjection(performanceCase))}\n`,
+    );
+    const host = /^host: (.+)$/mu.exec(
+      execFileSync("rustc", ["-vV"], { encoding: "utf8" }),
+    )?.[1];
+    if (!host) throw new Error("Rust host target is unavailable");
+    controllerDocument = execFileSync(
+      "cargo",
+      [
+        "run",
+        "--quiet",
+        "--package",
+        "trusted-server-integration-tests",
+        "--bin",
+        "generate-tsjs-fixture",
+        "--target",
+        host,
+        "--",
+        "--projection",
+        projectionPath,
+        "--ids",
+        [...selectedIds, ...DEFERRED_IDS].join(","),
+      ],
+      {
+        cwd: repositoryRoot,
+        encoding: "utf8",
+        env: { ...process.env, TSJS_SKIP_BUILD: "1" },
+      },
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+  const selectedTag = `<script src="${selectedSrc}" id="trustedserver-js"></script>`;
+  // The single generated bootstrap carries mutually exclusive direct-runtime and
+  // first-display branches; each branch owns one mark callsite.
+  expect(
+    controllerDocument.match(/performance\.mark\("tsjs:bids-script"\)/gu),
+  ).toHaveLength(2);
+  expect(controllerDocument.match(/id="trustedserver-js"/gu)).toHaveLength(1);
+  expect(controllerDocument).toContain(selectedTag);
+  expect(controllerDocument).toContain(
+    `\\"releaseId\\":\\"${release.releaseId}\\"`,
+  );
+  expect(controllerDocument).toContain(`\\"runtimeSrc\\":\\"${runtimeSrc}\\"`);
+  expect(controllerDocument).not.toContain(
+    `<script src="${runtimeSrc}" id="trustedserver-js"></script>`,
+  );
+  for (const { src } of deferred.values())
+    expect(controllerDocument).toContain(src);
+  const referenceTransfer = measureReferenceTransfer([
+    {
+      semanticEndpoint: "inline:boot-controller",
+      delivery: "inline",
+      body: exactControllerInline(controllerDocument),
+    },
+    {
+      semanticEndpoint: `external:${selectedSrc}`,
+      delivery: "external",
+      body: selectedBody,
+    },
+  ]);
+  return {
+    performanceCase,
+    artifactModel: "release-v1",
+    release,
+    controllerDocument,
+    selectedBody,
+    selectedTransferBytes: Buffer.byteLength(selectedBody, "utf8"),
+    selectedSrc,
+    runtimeBody,
+    runtimeSrc,
+    deferred,
+    referenceTransfer,
+    apsRendererDocument:
+      performanceCase === "aps"
+        ? readFileSync(
+            resolve(
+              repositoryRoot,
+              "crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html",
+            ),
+            "utf8",
+          )
+        : null,
+    apsRendererPath:
+      performanceCase === "aps" ? "/integrations/aps/renderer/v2" : null,
+  };
+}
+
+function legacyApsRendererDocument(repositoryRoot: string): string {
+  const source = readFileSync(
+    resolve(
+      repositoryRoot,
+      "crates/trusted-server-core/src/integrations/aps.rs",
+    ),
+    "utf8",
+  );
+  const match = /const APS_RENDERER_DOCUMENT: &str = r#"([\s\S]*?)"#;/u.exec(
+    source,
+  );
+  if (!match?.[1])
+    throw new Error("legacy rc APS renderer document is unavailable");
+  return match[1];
+}
+
+function loadLegacyBaselineFixtureResources(
+  repositoryRoot: string,
+  performanceCase: PerformanceCase = "gpt",
+): FixtureResources {
+  const dist = resolve(repositoryRoot, "crates/trusted-server-js/dist");
+  const selectedBody = ["tsjs-core.js", "tsjs-creative.js", "tsjs-gpt.js"]
+    .map((file) => readFileSync(resolve(dist, file), "utf8"))
+    .join(";\n");
+  const selectedHash = createHash("sha256").update(selectedBody).digest("hex");
+  const selectedSrc = `/static/tsjs=tsjs-unified.min.js?v=${selectedHash}`;
+  const referenceTransfer = measureReferenceTransfer([
+    {
+      semanticEndpoint: "inline:legacy-boot",
+      delivery: "inline",
+      body: legacyBootInline(performanceCase),
+    },
+    {
+      semanticEndpoint: "inline:legacy-ad-init",
+      delivery: "inline",
+      body: LEGACY_AD_INIT_INLINE,
+    },
+    {
+      semanticEndpoint: `external:${selectedSrc}`,
+      delivery: "external",
+      body: selectedBody,
+    },
+  ]);
+  return {
+    performanceCase,
+    artifactModel: "legacy-rc-v1",
+    release: null,
+    controllerDocument: null,
+    selectedBody,
+    selectedTransferBytes: Buffer.byteLength(selectedBody, "utf8"),
+    selectedSrc,
+    runtimeBody: null,
+    runtimeSrc: null,
+    deferred: new Map(),
+    referenceTransfer,
+    apsRendererDocument:
+      performanceCase === "aps"
+        ? legacyApsRendererDocument(repositoryRoot)
+        : null,
+    apsRendererPath:
+      performanceCase === "aps" ? "/integrations/aps/renderer" : null,
+  };
+}
+
+function loadBaselineFixtureResources(
+  repositoryRoot: string,
+  performanceCase: PerformanceCase = "gpt",
+): FixtureResources {
+  const releaseFile = resolve(
+    repositoryRoot,
+    "crates/trusted-server-js/dist/tsjs-release-v1.json",
+  );
+  return existsSync(releaseFile)
+    ? loadReleaseFixtureResources(repositoryRoot, performanceCase)
+    : loadLegacyBaselineFixtureResources(repositoryRoot, performanceCase);
+}
+
+function initialProjection(performanceCase: PerformanceCase = "gpt") {
+  const candidateId = "AAAAAAAAAAAA";
+  return {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: "performance-initial",
+      results: [{ slot: "perf-slot", outcome: "winner", candidateId }],
+    },
+    slots: [
+      {
+        slot: "perf-slot",
+        gamUnitPath: "/123/performance",
+        divId: "perf-slot",
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [
+      {
+        candidateId,
+        slot: "perf-slot",
+        provider: "trusted",
+        upstreamBidId: "performance-upstream",
+        cpm: 1,
+        currency: "USD",
+        targeting: { hb_bidder: "trusted" },
+        rendererReservationId: `r1_${"a".repeat(22)}`,
+        renderSource:
+          performanceCase === "aps"
+            ? apsDescriptor()
+            : {
+                type: "adm",
+                version: 1,
+                adm: "<main>fictional performance creative</main>",
+                width: 300,
+                height: 250,
+              },
+      },
+    ],
+  };
+}
+
+function fixtureDocument(
+  resources: FixtureResources,
+  manualDisplay: boolean,
+): string {
+  const selectedTag = `<script src="${resources.selectedSrc}" id="trustedserver-js"></script>`;
+  const comparisonSetup = `<script>window.__fixtureGpt.setManual(true);performance.mark("${COMPARISON_START_MARK}");</script>`;
+  if (resources.artifactModel === "legacy-rc-v1") {
+    const release = manualDisplay ? "" : "window.__fixtureGpt.release();";
+    return `<!doctype html><html><head><meta charset="utf-8"><script>${legacyBootInline(resources.performanceCase)}</script>${comparisonSetup}${selectedTag}</head><body><div id="perf-slot"></div><script>${LEGACY_AD_INIT_INLINE}${release}</script></body></html>`;
+  }
+  if (!resources.controllerDocument)
+    throw new Error("generated controller document is unavailable");
+  const controlledSelectedTag = `${comparisonSetup}${selectedTag}`;
+  const withControlledGpt = resources.controllerDocument.replace(
+    selectedTag,
+    controlledSelectedTag,
+  );
+  if (withControlledGpt === resources.controllerDocument)
+    throw new Error("generated controller selected tag is unavailable");
+  if (manualDisplay) return withControlledGpt;
+  const released = withControlledGpt.replace(
+    "</body>",
+    "<script>window.__fixtureGpt.release();</script></body>",
+  );
+  if (released === withControlledGpt)
+    throw new Error("generated controller body is unavailable");
+  return released;
+}
+
+async function installFixtureGpt(
+  context: BrowserContext,
+  performanceCase: PerformanceCase,
+): Promise<void> {
+  await context.addInitScript((selectedCase) => {
+    type Listener = (event: Record<string, unknown>) => void;
+    type Slot = {
+      addService(service: object): Slot;
+      clearTargeting(key?: string): Slot;
+      getAdUnitPath(): string;
+      getSlotElementId(): string;
+      getTargeting(key: string): string[];
+      setTargeting(key: string, value: string | string[]): Slot;
+    };
+    const listeners = new Map<string, Set<Listener>>();
+    const slots = new Map<string, Slot>();
+    const physical = new Set<Slot>();
+    const commands: Array<() => void> = [];
+    const calls: string[] = [];
+    let ready = true;
+    let displayCount = 0;
+    const markFirstObservableAction = () => {
+      if (
+        performance.getEntriesByName("tsjs:first-observable-action").length ===
+        0
+      ) {
+        performance.mark("tsjs:first-observable-action");
+      }
+    };
+    const createSlot = (id: string, path: string): Slot => {
+      const targeting = new Map<string, string[]>();
+      const slot: Slot = {
+        addService: () => slot,
+        clearTargeting: (key?: string) => {
+          calls.push(`clearTargeting:${key ?? "*"}`);
+          if (key === undefined) targeting.clear();
+          else targeting.delete(key);
+          return slot;
+        },
+        getAdUnitPath: () => path,
+        getSlotElementId: () => id,
+        getTargeting: (key: string) => {
+          calls.push(`getTargeting:${key}`);
+          return [...(targeting.get(key) ?? [])];
+        },
+        setTargeting: (key: string, value: string | string[]) => {
+          calls.push(`setTargeting:${key}`);
+          targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+          return slot;
+        },
+      };
+      slots.set(id, slot);
+      return slot;
+    };
+    const emit = (
+      name: string,
+      slot: Slot,
+      facts: Record<string, unknown> = {},
+    ) => {
+      for (const listener of listeners.get(name) ?? [])
+        listener({ slot, ...facts });
+    };
+    const startFictionalPuc = (slot: Slot): void => {
+      const adId = slot.getTargeting("hb_adid")[0];
+      const root = document.getElementById(slot.getSlotElementId());
+      if (!adId || !root)
+        throw new Error("fictional APS PUC input is unavailable");
+      const frame = document.createElement("iframe");
+      frame.dataset.fictionalPuc = "";
+      frame.srcdoc = `<!doctype html><body><script>(${String(
+        function fictionalUniversalCreative(reservationId: string) {
+          type OwnerResponse = { adId: string; renderer: string };
+          type PucWindow = Window & {
+            render?: (
+              data: OwnerResponse,
+              helper: object,
+              target: Window,
+            ) => Promise<void>;
+          };
+          const request = (): Promise<OwnerResponse> =>
+            new Promise((resolveRequest, rejectRequest) => {
+              const channel = new MessageChannel();
+              const timeout = window.setTimeout(() => {
+                channel.port1.close();
+                rejectRequest(new Error("fictional PUC response timeout"));
+              }, 5_000);
+              channel.port1.onmessage = (event) => {
+                window.clearTimeout(timeout);
+                channel.port1.close();
+                try {
+                  resolveRequest(
+                    JSON.parse(String(event.data)) as OwnerResponse,
+                  );
+                } catch (error) {
+                  rejectRequest(error);
+                }
+              };
+              channel.port1.start();
+              window.parent.postMessage(
+                JSON.stringify({
+                  message: "Prebid Request",
+                  adId: reservationId,
+                  adServerDomain: window.parent.location.host,
+                }),
+                "*",
+                [channel.port2],
+              );
+            });
+          void request().then(async (response) => {
+            const pucWindow = window as PucWindow;
+            window.eval(response.renderer);
+            if (typeof pucWindow.render !== "function") {
+              throw new Error("fictional PUC renderer is unavailable");
+            }
+            const helper = {
+              sendMessage(
+                message: string,
+                payload: Record<string, unknown>,
+                callback: (event: MessageEvent) => void,
+              ) {
+                const channel = new MessageChannel();
+                channel.port1.onmessage = callback;
+                channel.port1.start();
+                window.parent.postMessage(
+                  JSON.stringify({ message, adId: response.adId, ...payload }),
+                  "*",
+                  [channel.port2],
+                );
+                return () => channel.port1.close();
+              },
+            };
+            await pucWindow.render(response, helper, window);
+          });
+        },
+      )})(${JSON.stringify(adId)});<\/script></body>`;
+      root.appendChild(frame);
+    };
+    const completeSlot = (slot: Slot): void => {
+      emit("slotRequested", slot);
+      emit("slotRenderEnded", slot, { isEmpty: selectedCase !== "aps" });
+      if (selectedCase === "aps") startFictionalPuc(slot);
+    };
+    const pubads = {
+      addEventListener(name: string, listener: Listener) {
+        calls.push(`addEventListener:${name}`);
+        const registered = listeners.get(name) ?? new Set<Listener>();
+        registered.add(listener);
+        listeners.set(name, registered);
+      },
+      removeEventListener(name: string, listener: Listener) {
+        listeners.get(name)?.delete(listener);
+      },
+      disableInitialLoad() {},
+      enableSingleRequest() {},
+      getConfig: () => ({ disableInitialLoad: false }),
+      getSlots: () => [...physical],
+      refresh(requested?: Slot[]) {
+        markFirstObservableAction();
+        calls.push("refresh");
+        for (const slot of requested ?? [...physical]) {
+          queueMicrotask(() => completeSlot(slot));
+        }
+      },
+    };
+    const googletag = {
+      apiReady: true,
+      pubadsReady: true,
+      cmd: {
+        push(command: () => void) {
+          if (ready) command();
+          else commands.push(command);
+          return commands.length;
+        },
+      },
+      defineSlot(path: string, _sizes: unknown, id: string) {
+        calls.push(`defineSlot:${id}`);
+        const slot = slots.get(id) ?? createSlot(id, path);
+        physical.add(slot);
+        return slot;
+      },
+      destroySlots(requested?: Slot[]) {
+        for (const slot of requested ?? [...physical]) physical.delete(slot);
+        return true;
+      },
+      display(target: string | Slot) {
+        markFirstObservableAction();
+        calls.push("display");
+        const slot = typeof target === "string" ? slots.get(target) : target;
+        if (!slot) return;
+        displayCount += 1;
+        queueMicrotask(() => completeSlot(slot));
+      },
+      getConfig: () => ({ disableInitialLoad: false }),
+      pubads: () => pubads,
+      setConfig() {},
+    };
+    const loadTimes = new Map<string, number>();
+    const preparationTimes = new Map<string, number>();
+    const executionTimes = new Map<string, number>();
+    const preloadTimes: number[] = [];
+    new MutationObserver((records) => {
+      for (const record of records) {
+        for (const added of record.addedNodes) {
+          if (added instanceof HTMLLinkElement) {
+            if (
+              added.relList.contains("preload") &&
+              /tsjs-(?:diagnostics_presentation|gpt_later)\.min\.js/u.test(
+                added.href,
+              )
+            ) {
+              preloadTimes.push(performance.now());
+            }
+            continue;
+          }
+          if (!(added instanceof HTMLScriptElement)) continue;
+          const match = /tsjs-([a-z0-9_-]+)\.min\.js/u.exec(added.src);
+          if (!match?.[1]) continue;
+          added.addEventListener(
+            "load",
+            () => {
+              const id = match[1]!;
+              loadTimes.set(id, performance.now());
+              // The runtime's property onload handler was registered before this
+              // observer listener. It invokes synchronous module preparation before
+              // its first await, so reaching this listener proves preparation ran.
+              preparationTimes.set(id, performance.now());
+              queueMicrotask(() => {
+                // The loader's await continuation was queued before this listener;
+                // these deferred modules activate synchronously in that continuation.
+                executionTimes.set(id, performance.now());
+              });
+            },
+            {
+              once: true,
+            },
+          );
+        }
+      }
+    }).observe(document, { childList: true, subtree: true });
+    window.googletag = googletag;
+    Object.defineProperty(window, "__fixtureGpt", {
+      configurable: true,
+      value: {
+        displayCount: () => displayCount,
+        calls: () => [...calls],
+        executionTime: (id: string) => executionTimes.get(id),
+        loadTime: (id: string) => loadTimes.get(id),
+        preparationTime: (id: string) => preparationTimes.get(id),
+        preloadTimes: () => [...preloadTimes],
+        publisherRefresh() {
+          const slot = [...physical][0];
+          if (!slot)
+            return Promise.reject(
+              new Error("publisher GPT slot is unavailable"),
+            );
+          const service = googletag.pubads();
+          return new Promise<void>((resolveRefresh, rejectRefresh) => {
+            const timeout = window.setTimeout(() => {
+              service.removeEventListener("slotRenderEnded", onRendered);
+              rejectRefresh(
+                new Error("publisher GPT refresh did not complete"),
+              );
+            }, 5_000);
+            const onRendered: Listener = (event) => {
+              if (event.slot !== slot) return;
+              window.clearTimeout(timeout);
+              service.removeEventListener("slotRenderEnded", onRendered);
+              resolveRefresh();
+            };
+            service.addEventListener("slotRenderEnded", onRendered);
+            service.refresh([slot]);
+          });
+        },
+        release() {
+          ready = true;
+          googletag.apiReady = true;
+          commands.splice(0).forEach((command) => command());
+        },
+        setManual(manual: boolean) {
+          ready = !manual;
+          googletag.apiReady = !manual;
+        },
+      },
+    });
+  }, performanceCase);
+}
+
+async function installAttemptResourceProbe(
+  context: BrowserContext,
+): Promise<void> {
+  await context.addInitScript(() => {
+    const activeMessageListeners =
+      new Set<EventListenerOrEventListenerObject>();
+    const activeTimeouts = new Set<number>();
+    const activePorts = new Set<MessagePort>();
+    let createdMessageListeners = 0;
+    let createdTimeouts = 0;
+    let createdPorts = 0;
+
+    const nativeAddEventListener = window.addEventListener.bind(window);
+    const nativeRemoveEventListener = window.removeEventListener.bind(window);
+    window.addEventListener = ((
+      type: string,
+      listener: EventListenerOrEventListenerObject,
+      options?: boolean | AddEventListenerOptions,
+    ) => {
+      if (type === "message" && !activeMessageListeners.has(listener)) {
+        activeMessageListeners.add(listener);
+        createdMessageListeners += 1;
+      }
+      nativeAddEventListener(type, listener, options);
+    }) as typeof window.addEventListener;
+    window.removeEventListener = ((
+      type: string,
+      listener: EventListenerOrEventListenerObject,
+      options?: boolean | EventListenerOptions,
+    ) => {
+      if (type === "message") activeMessageListeners.delete(listener);
+      nativeRemoveEventListener(type, listener, options);
+    }) as typeof window.removeEventListener;
+
+    const nativeSetTimeout = window.setTimeout.bind(window);
+    const nativeClearTimeout = window.clearTimeout.bind(window);
+    window.setTimeout = ((
+      handler: TimerHandler,
+      timeout?: number,
+      ...arguments_: unknown[]
+    ) => {
+      let handle = 0;
+      const run = () => {
+        activeTimeouts.delete(handle);
+        if (typeof handler === "function") {
+          Reflect.apply(handler, window, arguments_);
+        } else {
+          window.eval(handler);
+        }
+      };
+      handle = nativeSetTimeout(run, timeout);
+      activeTimeouts.add(handle);
+      createdTimeouts += 1;
+      return handle;
+    }) as typeof window.setTimeout;
+    window.clearTimeout = ((handle?: number) => {
+      if (typeof handle === "number") activeTimeouts.delete(handle);
+      nativeClearTimeout(handle);
+    }) as typeof window.clearTimeout;
+
+    const NativeMessageChannel = window.MessageChannel;
+    const TrackedMessageChannel = function (): MessageChannel {
+      const channel = new NativeMessageChannel();
+      for (const port of [channel.port1, channel.port2]) {
+        activePorts.add(port);
+        createdPorts += 1;
+        const nativeClose = port.close.bind(port);
+        let closed = false;
+        Object.defineProperty(port, "close", {
+          configurable: true,
+          value: () => {
+            if (!closed) {
+              closed = true;
+              activePorts.delete(port);
+            }
+            nativeClose();
+          },
+        });
+      }
+      return channel;
+    } as unknown as typeof MessageChannel;
+    Object.setPrototypeOf(TrackedMessageChannel, NativeMessageChannel);
+    TrackedMessageChannel.prototype = NativeMessageChannel.prototype;
+    window.MessageChannel = TrackedMessageChannel;
+
+    Object.defineProperty(window, "__tsjsAttemptResources", {
+      configurable: false,
+      value: () => ({
+        activeMessageListeners: activeMessageListeners.size,
+        activePorts: activePorts.size,
+        activeTimeouts: activeTimeouts.size,
+        createdMessageListeners,
+        createdPorts,
+        createdTimeouts,
+      }),
+    });
+  });
+}
+
+function noBidAuction(requestBody: unknown) {
+  const request = requestBody as {
+    id?: unknown;
+    imp?: Array<{ id?: unknown }>;
+  };
+  const auctionId =
+    typeof request.id === "string" ? request.id : "performance-refresh";
+  const results = (Array.isArray(request.imp) ? request.imp : []).map(
+    (imp) => ({
+      slot: typeof imp.id === "string" ? imp.id : "perf-slot",
+      outcome: "no_bid",
+    }),
+  );
+  return {
+    id: auctionId,
+    cur: "USD",
+    seatbid: [],
+    ext: {
+      trusted_server: { slot_results: { version: 1, auctionId, results } },
+    },
+  };
+}
+
+function sendResponse(
+  response: ServerResponse,
+  status: number,
+  contentType: string,
+  body: string,
+  script = false,
+): void {
+  response.writeHead(status, {
+    "Content-Type": contentType,
+    ...(script ? { "X-Content-Type-Options": "nosniff" } : {}),
+  });
+  response.end(body);
+}
+
+async function requestJson(request: IncomingMessage): Promise<unknown> {
+  request.setEncoding("utf8");
+  let body = "";
+  for await (const chunk of request) body += chunk;
+  return JSON.parse(body) as unknown;
+}
+
+async function serveFixtureRequest(
+  request: IncomingMessage,
+  response: ServerResponse,
+  resources: FixtureResources,
+  options: FixtureServerOptions,
+): Promise<void> {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (url.pathname === "/fixture") {
+    sendResponse(
+      response,
+      200,
+      "text/html; charset=utf-8",
+      fixtureDocument(resources, url.searchParams.get("manual") === "1"),
+    );
+    return;
+  }
+  if (`${url.pathname}${url.search}` === resources.selectedSrc) {
+    sendResponse(
+      response,
+      200,
+      "application/javascript; charset=utf-8",
+      resources.selectedBody,
+      true,
+    );
+    return;
+  }
+  if (
+    resources.runtimeBody !== null &&
+    resources.runtimeSrc !== null &&
+    `${url.pathname}${url.search}` === resources.runtimeSrc
+  ) {
+    if (options.rejectRuntime) {
+      sendResponse(
+        response,
+        503,
+        "text/plain; charset=utf-8",
+        "persistent runtime rejected by test fixture",
+      );
+      return;
+    }
+    sendResponse(
+      response,
+      200,
+      "application/javascript; charset=utf-8",
+      resources.runtimeBody,
+      true,
+    );
+    return;
+  }
+  for (const [id, artifact] of resources.deferred) {
+    if (`${url.pathname}${url.search}` !== artifact.src) continue;
+    if (id === "gpt_later")
+      await new Promise((resolveDelay) => setTimeout(resolveDelay, 200));
+    sendResponse(
+      response,
+      200,
+      "application/javascript; charset=utf-8",
+      artifact.body,
+      true,
+    );
+    return;
+  }
+  if (
+    resources.apsRendererDocument !== null &&
+    url.pathname === resources.apsRendererPath
+  ) {
+    response.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Content-Security-Policy":
+        resources.artifactModel === "release-v1"
+          ? "default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;"
+          : "default-src 'none'; sandbox allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src http: https: data:; img-src https: data:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:;",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff",
+    });
+    response.end(resources.apsRendererDocument);
+    return;
+  }
+  if (
+    resources.performanceCase === "aps" &&
+    url.pathname === "/integrations/aps/runner.js"
+  ) {
+    response.writeHead(200, {
+      "Access-Control-Allow-Origin": "*",
+      "Content-Type": "application/javascript; charset=utf-8",
+      "Cross-Origin-Resource-Policy": "cross-origin",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff",
+    });
+    response.end(FICTIONAL_APS_RUNNER);
+    return;
+  }
+  if (url.pathname === "/_ts/auction") {
+    sendResponse(
+      response,
+      200,
+      "application/json",
+      JSON.stringify(noBidAuction(await requestJson(request))),
+    );
+    return;
+  }
+  if (url.pathname === "/_ts/page-bids") {
+    sendResponse(
+      response,
+      200,
+      "application/json",
+      JSON.stringify({
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: "performance-navigation",
+          results: [{ slot: "perf-slot", outcome: "no_bid" }],
+        },
+        slots: [
+          {
+            slot: "perf-slot",
+            gamUnitPath: "/123/performance",
+            divId: "perf-slot",
+            formats: [[300, 250]],
+            targeting: {},
+          },
+        ],
+        bids: [],
+      }),
+    );
+    return;
+  }
+  sendResponse(response, 404, "text/plain; charset=utf-8", "not found");
+}
+
+async function startFixtureServer(
+  resources: FixtureResources,
+  options: FixtureServerOptions = {},
+): Promise<FixtureServer> {
+  const server = createServer((request, response) => {
+    void serveFixtureRequest(request, response, resources, options).catch(
+      (error) => {
+        const failure =
+          error instanceof Error ? error : new Error(String(error));
+        if (response.headersSent) {
+          response.destroy(failure);
+          return;
+        }
+        sendResponse(
+          response,
+          500,
+          "text/plain; charset=utf-8",
+          "fixture server failure",
+        );
+      },
+    );
+  });
+  await new Promise<void>((resolveListen, rejectListen) => {
+    const onError = (error: Error) => {
+      server.off("listening", onListening);
+      rejectListen(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolveListen();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(0, "127.0.0.1");
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("fixture server address is unavailable");
+  }
+  let closed = false;
+  return {
+    origin: `http://127.0.0.1:${address.port}`,
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      await new Promise<void>((resolveClose, rejectClose) => {
+        server.close((error) => {
+          if (error) rejectClose(error);
+          else resolveClose();
+        });
+        server.closeAllConnections();
+      });
+    },
+  };
+}
+
+async function openFixture(
+  browser: Browser,
+  fixtureServer: FixtureServer,
+  resources: FixtureResources,
+  options: OpenFixtureOptions = {},
+): Promise<FixtureRun> {
+  const {
+    manualDisplay = false,
+    probeAttemptResources = false,
+    waitUntil = "load",
+  } = options;
+  const context = await browser.newContext();
+  if (probeAttemptResources) await installAttemptResourceProbe(context);
+  await installFixtureGpt(context, resources.performanceCase);
+  const page = await context.newPage();
+  const networkSession = await context.newCDPSession(page);
+  await networkSession.send("Network.enable");
+  await networkSession.send("Network.emulateNetworkConditions", {
+    offline: false,
+    latency: 150,
+    downloadThroughput: 200_000,
+    uploadThroughput: 93_750,
+    packetLoss: 0,
+  });
+  const selectedRequests: string[] = [];
+  const runtimeRequests: string[] = [];
+  const deferredRequests: string[] = [];
+  const pageErrors: string[] = [];
+  const consoleMessages: string[] = [];
+  page.on("request", (request) => {
+    const url = request.url();
+    if (url.endsWith(resources.selectedSrc)) selectedRequests.push(url);
+    if (resources.runtimeSrc && url.endsWith(resources.runtimeSrc))
+      runtimeRequests.push(url);
+    if (
+      DEFERRED_IDS.some((id) => url.includes(`/static/tsjs=tsjs-${id}.min.js`))
+    ) {
+      deferredRequests.push(url);
+    }
+  });
+  page.on("pageerror", (error) => pageErrors.push(error.message));
+  page.on("console", (message) =>
+    consoleMessages.push(`${message.type()}: ${message.text()}`),
+  );
+  const fixtureUrl = `${fixtureServer.origin}/fixture${manualDisplay ? "?manual=1" : ""}`;
+  await page.goto(fixtureUrl, { waitUntil });
+  return {
+    context,
+    page,
+    selectedRequests,
+    runtimeRequests,
+    deferredRequests,
+    pageErrors,
+    consoleMessages,
+    close: () => context.close(),
+  };
+}
+
+async function observeComparisonFixture(
+  run: FixtureRun,
+  resources: FixtureResources,
+): Promise<ComparisonObservation> {
+  await expect
+    .poll(() =>
+      run.page.evaluate(
+        (mark) => performance.getEntriesByName(mark).length,
+        FIRST_OBSERVABLE_ACTION_MARK,
+      ),
+    )
+    .toBe(1);
+  if (
+    resources.performanceCase === "aps" &&
+    resources.artifactModel === "release-v1"
+  ) {
+    await waitForMark(run, "tsjs:first-display-terminal");
+    await waitForMark(run, "tsjs:first-display-paint");
+  }
+  const observation = await run.page.evaluate(
+    ({ startMark, actionMark, includeAps }) => {
+      const start = performance.getEntriesByName(startMark);
+      const action = performance.getEntriesByName(actionMark);
+      const bids = performance.getEntriesByName("tsjs:bids-script");
+      const firstDisplay = performance.getEntriesByName("tsjs:first-display");
+      const terminal = performance.getEntriesByName(
+        "tsjs:first-display-terminal",
+      );
+      const paint = performance.getEntriesByName("tsjs:first-display-paint");
+      return {
+        timingMs:
+          (action[0]?.startTime ?? Number.NaN) -
+          (start[0]?.startTime ?? Number.NaN),
+        displayCount: window.__fixtureGpt.displayCount(),
+        releaseId: window.tsjs?.releaseId,
+        ...(includeAps
+          ? {
+              actionToCompletionMs:
+                (terminal[0]?.startTime ?? Number.NaN) -
+                (firstDisplay[0]?.startTime ?? Number.NaN),
+              completionToPaintMs:
+                (paint[0]?.startTime ?? Number.NaN) -
+                (terminal[0]?.startTime ?? Number.NaN),
+              totalToPaintMs:
+                (paint[0]?.startTime ?? Number.NaN) -
+                (bids[0]?.startTime ?? Number.NaN),
+            }
+          : {}),
+      };
+    },
+    {
+      startMark: COMPARISON_START_MARK,
+      actionMark: FIRST_OBSERVABLE_ACTION_MARK,
+      includeAps:
+        resources.performanceCase === "aps" &&
+        resources.artifactModel === "release-v1",
+    },
+  );
+  expect(run.selectedRequests).toHaveLength(1);
+  const selectedRequest = new URL(run.selectedRequests[0]!);
+  expect(`${selectedRequest.pathname}${selectedRequest.search}`).toBe(
+    resources.selectedSrc,
+  );
+  expect(run.pageErrors).toEqual([]);
+  expect(observation.displayCount).toBe(1);
+  expect(Number.isFinite(observation.timingMs)).toBe(true);
+  expect(observation.timingMs).toBeGreaterThan(0);
+  if (observation.actionToCompletionMs !== undefined) {
+    expect(Number.isFinite(observation.actionToCompletionMs)).toBe(true);
+    expect(observation.actionToCompletionMs).toBeGreaterThanOrEqual(0);
+    expect(observation.actionToCompletionMs).toBeLessThanOrEqual(5_000);
+    expect(Number.isFinite(observation.completionToPaintMs)).toBe(true);
+    expect(observation.completionToPaintMs).toBeGreaterThanOrEqual(0);
+    expect(Number.isFinite(observation.totalToPaintMs)).toBe(true);
+    expect(observation.totalToPaintMs).toBeGreaterThanOrEqual(0);
+  }
+  return observation;
+}
+
+async function waitForMark(run: FixtureRun, name: string): Promise<void> {
+  const { page } = run;
+  try {
+    await expect
+      .poll(() =>
+        page.evaluate(
+          (mark) => performance.getEntriesByName(mark).length,
+          name,
+        ),
+      )
+      .toBe(1);
+  } catch (error) {
+    const diagnostics = await page.evaluate(() => ({
+      runtimeState: window.tsjs?._internal?.state,
+      runtimeReason: (window.tsjs?._internal as { reason?: string } | undefined)
+        ?.reason,
+      names: window.tsjs ? Object.getOwnPropertyNames(window.tsjs) : [],
+      marks: performance
+        .getEntriesByType("mark")
+        .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+      displayCount: window.__fixtureGpt.displayCount(),
+      gptCalls: window.__fixtureGpt.calls(),
+      renderTrace: window.tsjs?.diagnostics?.renderTrace?.current(),
+      renderHistory: window.tsjs?.diagnostics?.renderTrace?.history(),
+    }));
+    throw new Error(
+      `${name} was not recorded: ${JSON.stringify({ ...diagnostics, consoleMessages: run.consoleMessages, selectedRequests: run.selectedRequests, runtimeRequests: run.runtimeRequests, deferredRequests: run.deferredRequests, pageErrors: run.pageErrors })}; ${String(error)}`,
+    );
+  }
+}
+
+async function waitForKernel(run: FixtureRun): Promise<void> {
+  try {
+    await expect
+      .poll(() => run.page.evaluate(() => window.tsjs?._internal?.state))
+      .toBe("kernel");
+  } catch (error) {
+    const diagnostics = await run.page.evaluate(() => ({
+      runtimeState: window.tsjs?._internal?.state,
+      runtimeReason: (window.tsjs?._internal as { reason?: string } | undefined)
+        ?.reason,
+      names: window.tsjs ? Object.getOwnPropertyNames(window.tsjs) : [],
+      marks: performance
+        .getEntriesByType("mark")
+        .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+    }));
+    throw new Error(
+      `persistent runtime did not commit: ${JSON.stringify({ ...diagnostics, consoleMessages: run.consoleMessages, selectedRequests: run.selectedRequests, runtimeRequests: run.runtimeRequests, deferredRequests: run.deferredRequests, pageErrors: run.pageErrors })}; ${String(error)}`,
+    );
+  }
+}
+
+async function observeFixture(
+  run: FixtureRun,
+  resources: FixtureResources,
+): Promise<BrowserObservation> {
+  const comparison = await observeComparisonFixture(run, resources);
+  await waitForMark(run, "tsjs:first-display");
+  await waitForMark(run, "tsjs:first-display-paint");
+  await waitForKernel(run);
+  for (const id of DEFERRED_IDS) {
+    try {
+      await expect
+        .poll(() =>
+          run.page.evaluate(
+            (moduleId) => window.__fixtureGpt.executionTime(moduleId),
+            id,
+          ),
+        )
+        .not.toBeUndefined();
+    } catch (error) {
+      const lifecycle = await run.page.evaluate(
+        (deferredIds) =>
+          deferredIds.map((moduleId) => ({
+            id: moduleId,
+            loadTime: window.__fixtureGpt.loadTime(moduleId),
+            preparationTime: window.__fixtureGpt.preparationTime(moduleId),
+            executionTime: window.__fixtureGpt.executionTime(moduleId),
+          })),
+        DEFERRED_IDS,
+      );
+      throw new Error(
+        `deferred ${id} did not execute: ${JSON.stringify({ lifecycle, deferredRequests: run.deferredRequests, consoleMessages: run.consoleMessages, pageErrors: run.pageErrors })}; ${String(error)}`,
+      );
+    }
+  }
+  const observation = await run.page.evaluate((deferredIds) => {
+    const entries = (name: string) => performance.getEntriesByName(name);
+    const bids = entries("tsjs:bids-script");
+    const display = entries("tsjs:first-display");
+    const paint = entries("tsjs:first-display-paint");
+    const measure = entries("tsjs:boot-to-first-display");
+    const resources = performance.getEntriesByType(
+      "resource",
+    ) as PerformanceResourceTiming[];
+    const deferred = deferredIds.map((id) => {
+      const resource = resources.find((entry) =>
+        entry.name.includes(`tsjs-${id}.min.js`),
+      );
+      if (!resource)
+        throw new Error(`missing real deferred resource entry for ${id}`);
+      const loadTime = window.__fixtureGpt.loadTime(id);
+      const preparationTime = window.__fixtureGpt.preparationTime(id);
+      const executionTime = window.__fixtureGpt.executionTime(id);
+      if (
+        loadTime === undefined ||
+        preparationTime === undefined ||
+        executionTime === undefined
+      ) {
+        throw new Error(
+          `missing real deferred lifecycle observation for ${id}`,
+        );
+      }
+      return {
+        id,
+        startTime: resource.startTime,
+        responseEnd: resource.responseEnd,
+        loadTime,
+        preparationTime,
+        executionTime,
+      };
+    });
+    const paintTime = paint[0]?.startTime ?? -1;
+    return {
+      timingMs: Number.NaN,
+      markTimingMs:
+        (display[0]?.startTime ?? Number.NaN) -
+        (bids[0]?.startTime ?? Number.NaN),
+      bidsScriptCount: bids.length,
+      firstDisplayCount: display.length,
+      firstDisplayPaintCount: paint.length,
+      measureCount: measure.length,
+      runtimeState: window.tsjs?._internal?.state,
+      releaseId: window.tsjs?.releaseId,
+      displayCount: window.__fixtureGpt.displayCount(),
+      diagnosticsPresentationCount: document.querySelectorAll(
+        "#ts-render-trace-panel",
+      ).length,
+      selectedScriptCount: document.querySelectorAll("script#trustedserver-js")
+        .length,
+      deferred,
+      paintTime,
+      preloadBeforePaintCount: window.__fixtureGpt
+        .preloadTimes()
+        .filter((time) => time < paintTime).length,
+    };
+  }, DEFERRED_IDS);
+  observation.timingMs = comparison.timingMs;
+  expect(observation.bidsScriptCount).toBe(1);
+  expect(observation.firstDisplayCount).toBe(1);
+  expect(observation.firstDisplayPaintCount).toBe(1);
+  expect(observation.measureCount).toBe(1);
+  expect(observation.runtimeState).toBe("kernel");
+  expect(observation.displayCount).toBe(1);
+  expect(observation.diagnosticsPresentationCount).toBe(1);
+  expect(observation.selectedScriptCount).toBe(1);
+  expect(run.selectedRequests).toHaveLength(1);
+  expect(run.deferredRequests).toHaveLength(DEFERRED_IDS.length);
+  expect(run.pageErrors).toEqual([]);
+  expect(Number.isFinite(observation.timingMs)).toBe(true);
+  expect(observation.timingMs).toBeGreaterThanOrEqual(0);
+  expect(Number.isFinite(observation.markTimingMs)).toBe(true);
+  expect(observation.preloadBeforePaintCount).toBe(0);
+  expect(
+    observation.deferred.every(
+      (entry) => entry.startTime >= observation.paintTime,
+    ),
+  ).toBe(true);
+  expect(
+    observation.deferred.every(
+      (entry) => entry.preparationTime >= observation.paintTime,
+    ),
+  ).toBe(true);
+  expect(
+    observation.deferred.every(
+      (entry) => entry.executionTime >= observation.paintTime,
+    ),
+  ).toBe(true);
+  expect(
+    observation.deferred.every(
+      (entry) =>
+        entry.startTime <= entry.responseEnd &&
+        entry.responseEnd <= entry.loadTime &&
+        entry.loadTime <= entry.preparationTime &&
+        entry.preparationTime <= entry.executionTime,
+    ),
+  ).toBe(true);
+  expect(
+    Math.max(...observation.deferred.map((entry) => entry.startTime)) -
+      Math.min(...observation.deferred.map((entry) => entry.startTime)),
+  ).toBeLessThanOrEqual(50);
+  const deferredByResponseEnd = [...observation.deferred].sort(
+    (left, right) => left.responseEnd - right.responseEnd,
+  );
+  expect(deferredByResponseEnd[0]!.executionTime).toBeLessThan(
+    deferredByResponseEnd.at(-1)!.responseEnd,
+  );
+  return observation;
+}
+
+async function withHeapOperationTimeout<T>(
+  description: string,
+  operation: Promise<T>,
+): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise<never>((_resolve, reject) => {
+        timeout = setTimeout(
+          () =>
+            reject(
+              new Error(
+                `${description} exceeded ${HEAP_OPERATION_TIMEOUT_MS} ms`,
+              ),
+            ),
+          HEAP_OPERATION_TIMEOUT_MS,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}
+
+async function runHeapPhase<T>(
+  label: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  console.log(`[tsjs-performance] heap ${label}: start`);
+  try {
+    const result = await withHeapOperationTimeout(label, operation());
+    console.log(`[tsjs-performance] heap ${label}: complete`);
+    return result;
+  } catch (error) {
+    console.error(`[tsjs-performance] heap ${label}: failed: ${String(error)}`);
+    throw error;
+  }
+}
+
+async function collectHeap(page: Page, label: string): Promise<number> {
+  await runHeapPhase(`${label}:request-gc`, () => page.requestGC());
+  const session = await runHeapPhase(`${label}:session-open`, () =>
+    page.context().newCDPSession(page),
+  );
+  try {
+    const usage = await runHeapPhase(`${label}:get-usage`, () =>
+      session.send("Runtime.getHeapUsage"),
+    );
+    return usage.usedSize as number;
+  } finally {
+    await runHeapPhase(`${label}:session-detach`, () => session.detach());
+  }
+}
+
+async function collectHeapCheckpoints(
+  browser: Browser,
+  fixtureServer: FixtureServer,
+  resources: FixtureResources,
+): Promise<Record<HeapCheckpoint, number>> {
+  const label = resources.artifactModel;
+  const heapRun = await runHeapPhase(`${label}:open`, () =>
+    openFixture(browser, fixtureServer, resources, {
+      manualDisplay: true,
+    }),
+  );
+  const retainedHeapBytes = {} as Record<HeapCheckpoint, number>;
+  try {
+    await runHeapPhase(`${label}:runtime-ready`, () =>
+      expect
+        .poll(() => heapRun.page.evaluate(() => typeof window.tsjs))
+        .toBe("object"),
+    );
+    retainedHeapBytes.afterBoot = await collectHeap(
+      heapRun.page,
+      `${label}:after-boot`,
+    );
+    await runHeapPhase(`${label}:release`, () =>
+      heapRun.page.evaluate(() => window.__fixtureGpt.release()),
+    );
+    await runHeapPhase(`${label}:first-render`, () =>
+      observeComparisonFixture(heapRun, resources),
+    );
+    if (resources.artifactModel === "release-v1") {
+      await runHeapPhase(`${label}:first-display-paint`, () =>
+        waitForMark(heapRun, "tsjs:first-display-paint"),
+      );
+    }
+    retainedHeapBytes.afterFirstRender = await collectHeap(
+      heapRun.page,
+      `${label}:after-first-render`,
+    );
+    await runHeapPhase(`${label}:publisher-refresh`, () =>
+      heapRun.page.evaluate(() => window.__fixtureGpt.publisherRefresh()),
+    );
+    retainedHeapBytes.afterRefresh = await collectHeap(
+      heapRun.page,
+      `${label}:after-refresh`,
+    );
+    for (const id of resources.deferred.keys()) {
+      await runHeapPhase(`${label}:deferred-${id}`, () =>
+        expect
+          .poll(() =>
+            heapRun.page.evaluate(
+              (moduleId) => window.__fixtureGpt.executionTime(moduleId),
+              id,
+            ),
+          )
+          .not.toBeUndefined(),
+      );
+    }
+    const navigationResponse = heapRun.page.waitForResponse((response) =>
+      response.url().includes("/_ts/page-bids"),
+    );
+    await runHeapPhase(`${label}:spa-dispatch`, () =>
+      heapRun.page.evaluate(() =>
+        history.pushState({}, "", "/fixture/navigation"),
+      ),
+    );
+    const response = await runHeapPhase(
+      `${label}:spa-response`,
+      () => navigationResponse,
+    );
+    await runHeapPhase(`${label}:spa-response-finished`, async () => {
+      expect(await response.finished()).toBeNull();
+    });
+    await runHeapPhase(`${label}:spa-reconciliation`, () =>
+      expect
+        .poll(() =>
+          heapRun.page.evaluate(() => {
+            const googletag = window.googletag as {
+              pubads(): {
+                getSlots(): Array<{ getSlotElementId(): string }>;
+              };
+            };
+            return googletag
+              .pubads()
+              .getSlots()
+              .map((slot) => slot.getSlotElementId());
+          }),
+        )
+        .toEqual(["perf-slot"]),
+    );
+    retainedHeapBytes.afterSpaNavigation = await collectHeap(
+      heapRun.page,
+      `${label}:after-spa-navigation`,
+    );
+    return retainedHeapBytes;
+  } finally {
+    await runHeapPhase(`${label}:close`, () => heapRun.close());
+  }
+}
+
+async function collectPairedHeapCheckpoints(
+  baselineServer: FixtureServer,
+  baselineResources: FixtureResources,
+  candidateServer: FixtureServer,
+  candidateResources: FixtureResources,
+): Promise<{
+  baseline: Record<HeapCheckpoint, number>;
+  candidate: Record<HeapCheckpoint, number>;
+}> {
+  const heapBrowser = await chromium.launch({ headless: true });
+  try {
+    expect(heapBrowser.version()).toBe(EXPECTED_CHROMIUM);
+    const baseline = await collectHeapCheckpoints(
+      heapBrowser,
+      baselineServer,
+      baselineResources,
+    );
+    const candidate = await collectHeapCheckpoints(
+      heapBrowser,
+      candidateServer,
+      candidateResources,
+    );
+    return { baseline, candidate };
+  } finally {
+    await withHeapOperationTimeout("heap browser close", heapBrowser.close());
+  }
+}
+
+async function collectApsHeapCheckpoints(
+  fixtureServer: FixtureServer,
+  resources: FixtureResources,
+): Promise<{
+  afterProtectedPaint: number;
+  afterTakeoverQueueDrain: number;
+}> {
+  const heapBrowser = await chromium.launch({ headless: true });
+  try {
+    expect(heapBrowser.version()).toBe(EXPECTED_CHROMIUM);
+    const run = await openFixture(heapBrowser, fixtureServer, resources);
+    try {
+      await waitForMark(run, "tsjs:first-display-paint");
+      const afterProtectedPaint = await collectHeap(
+        run.page,
+        "aps:after-protected-paint",
+      );
+      await waitForKernel(run);
+      for (const id of DEFERRED_IDS) {
+        await expect
+          .poll(() =>
+            run.page.evaluate(
+              (moduleId) => window.__fixtureGpt.executionTime(moduleId),
+              id,
+            ),
+          )
+          .not.toBeUndefined();
+      }
+      const afterTakeoverQueueDrain = await collectHeap(
+        run.page,
+        "aps:after-takeover-queue-drain",
+      );
+      return { afterProtectedPaint, afterTakeoverQueueDrain };
+    } finally {
+      await run.close();
+    }
+  } finally {
+    await withHeapOperationTimeout(
+      "APS heap browser close",
+      heapBrowser.close(),
+    );
+  }
+}
+
+function p90(values: readonly number[]): number {
+  const ordered = [...values].sort((left, right) => left - right);
+  return ordered[Math.ceil((PERCENTILE / 100) * ordered.length) - 1]!;
+}
+
+function packageVersion(packagePath: string): string {
+  return (JSON.parse(readFileSync(packagePath, "utf8")) as { version: string })
+    .version;
+}
+
+declare global {
+  interface Window {
+    googletag: unknown;
+    __fixtureGpt: {
+      displayCount(): number;
+      calls(): string[];
+      executionTime(id: string): number | undefined;
+      loadTime(id: string): number | undefined;
+      preparationTime(id: string): number | undefined;
+      preloadTimes(): number[];
+      publisherRefresh(): Promise<void>;
+      release(): void;
+      setManual(manual: boolean): void;
+    };
+    __tsjsAttemptResources(): {
+      activeMessageListeners: number;
+      activePorts: number;
+      activeTimeouts: number;
+      createdMessageListeners: number;
+      createdPorts: number;
+      createdTimeouts: number;
+    };
+    tsjs?: {
+      _internal?: { initialDisplayCommitted?: boolean; state?: string };
+      diagnostics?: {
+        renderTrace?: { current(): unknown; history(): unknown };
+      };
+      releaseId?: string;
+      requestAds(options?: { slots?: readonly string[] }): Promise<unknown>;
+    };
+  }
+}
+
+test("measures each distinct semantic transfer source exactly once", () => {
+  const inlineBody = 'performance.mark("tsjs:bids-script");';
+  const externalBody = "window.tsjs={};";
+  const inline = measureBytes(Buffer.from(inlineBody, "utf8"));
+  const external = measureBytes(Buffer.from(externalBody, "utf8"));
+  const transfer = measureReferenceTransfer([
+    {
+      semanticEndpoint: "inline:boot-controller",
+      delivery: "inline",
+      body: inlineBody,
+    },
+    {
+      semanticEndpoint: `external:/static/tsjs=tsjs-unified.min.js?v=${external.sha256}`,
+      delivery: "external",
+      body: externalBody,
+    },
+  ]);
+
+  expect(transfer.sources).toHaveLength(2);
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"] as const) {
+    expect(transfer[metric]).toBe(inline[metric] + external[metric]);
+  }
+  expect(() =>
+    measureReferenceTransfer([
+      {
+        semanticEndpoint: "inline:boot-controller",
+        delivery: "inline",
+        body: inlineBody,
+      },
+      {
+        semanticEndpoint: "inline:boot-controller",
+        delivery: "inline",
+        body: inlineBody,
+      },
+    ]),
+  ).toThrow("semantic transfer source is empty or duplicated");
+});
+
+test("gates selected agent transfer against the exact rc base build", () => {
+  const mode = process.env.TSJS_PERF_MODE;
+  const baselineRoot = process.env.TSJS_PERF_BASE_ROOT;
+  const baseSha = process.env.TSJS_PERF_BASE_SHA;
+  if (!baselineRoot || !baseSha) {
+    if (
+      mode === "preswitch" ||
+      mode === "postswitch" ||
+      mode === "pull-request"
+    ) {
+      throw new Error(
+        "exact-rc selected-agent transfer comparison is required in CI and release modes",
+      );
+    }
+    test.skip(
+      true,
+      "exact-rc selected-agent transfer comparison unavailable; check:bundle still enforces controller and agent ceilings",
+    );
+    return;
+  }
+  expect(baseSha).toMatch(/^[0-9a-f]{40}$/u);
+  expect(
+    execFileSync("git", ["-C", baselineRoot, "rev-parse", "HEAD"], {
+      encoding: "utf8",
+    }).trim(),
+  ).toBe(baseSha);
+  const baselineResources = loadBaselineFixtureResources(baselineRoot);
+  const candidateResources = loadReleaseFixtureResources(REPO_ROOT);
+  const baselineAgent = externalAgentTransfer(
+    baselineResources.referenceTransfer,
+  );
+  const candidateAgent = externalAgentTransfer(
+    candidateResources.referenceTransfer,
+  );
+
+  const regressions = (
+    ["rawBytes", "gzipBytes", "brotliBytes"] as const
+  ).filter((metric) => candidateAgent[metric] > baselineAgent[metric]);
+  expect(
+    regressions,
+    JSON.stringify({
+      baselineAgent,
+      candidateAgent,
+    }),
+  ).toEqual([]);
+});
+
+test("boots the generated first-display artifact through persistent takeover", async ({
+  browser,
+}) => {
+  const resources = loadReleaseFixtureResources(REPO_ROOT);
+  const server = await startFixtureServer(resources);
+  try {
+    const run = await openFixture(browser, server, resources);
+    try {
+      try {
+        await observeFixture(run, resources);
+      } catch (error) {
+        const diagnostics = await run.page.evaluate(() => ({
+          runtimeState: window.tsjs?._internal?.state,
+          runtimeReason: (
+            window.tsjs?._internal as { reason?: string } | undefined
+          )?.reason,
+          names: window.tsjs ? Object.getOwnPropertyNames(window.tsjs) : [],
+          marks: performance
+            .getEntriesByType("mark")
+            .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+          displayCount: window.__fixtureGpt.displayCount(),
+          gptCalls: window.__fixtureGpt.calls(),
+        }));
+        throw new Error(
+          `first-display smoke failed: ${JSON.stringify({ ...diagnostics, consoleMessages: run.consoleMessages, selectedRequests: run.selectedRequests, runtimeRequests: run.runtimeRequests, deferredRequests: run.deferredRequests, pageErrors: run.pageErrors })}; ${String(error)}`,
+        );
+      }
+    } finally {
+      await run.close();
+    }
+  } finally {
+    await server.close();
+  }
+});
+
+test("drives the generated APS agent through fictional PUC, terminal, paint, and takeover", async ({
+  browser,
+}) => {
+  const resources = loadReleaseFixtureResources(REPO_ROOT, "aps");
+  const server = await startFixtureServer(resources);
+  try {
+    const run = await openFixture(browser, server, resources);
+    try {
+      let observation: BrowserObservation;
+      try {
+        observation = await observeFixture(run, resources);
+      } catch (error) {
+        const diagnostics = await run.page.evaluate(() => ({
+          marks: performance
+            .getEntriesByType("mark")
+            .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+          calls: window.__fixtureGpt.calls(),
+          frames: [...document.querySelectorAll("iframe")].map((frame) => ({
+            src: frame.src,
+            title: frame.title,
+            puc: frame.dataset.fictionalPuc !== undefined,
+          })),
+          trace: window.tsjs?.diagnostics?.renderTrace?.current(),
+          resources: performance
+            .getEntriesByType("resource")
+            .map((entry) => entry.name),
+        }));
+        throw new Error(
+          `APS performance smoke failed: ${JSON.stringify({ diagnostics, pageErrors: run.pageErrors, consoleMessages: run.consoleMessages })}; ${String(error)}`,
+        );
+      }
+      expect(observation.releaseId).toBe(resources.release?.releaseId);
+      expect(observation.firstDisplayCount).toBe(1);
+      expect(observation.firstDisplayPaintCount).toBe(1);
+    } finally {
+      await run.close();
+    }
+  } finally {
+    await server.close();
+  }
+});
+
+test("generated first-display fallback releases its runtime and provisional resources", async ({
+  browser,
+}) => {
+  const resources = loadReleaseFixtureResources(REPO_ROOT);
+  const server = await startFixtureServer(resources, { rejectRuntime: true });
+  try {
+    const run = await openFixture(browser, server, resources, {
+      probeAttemptResources: true,
+    });
+    try {
+      await expect
+        .poll(() => run.page.evaluate(() => window.tsjs?._internal?.state))
+        .toBe("fallback");
+      const observation = await run.page.evaluate(() => ({
+        initialDisplayCommitted:
+          window.tsjs?._internal?.initialDisplayCommitted,
+        privateFields: [
+          "_firstDisplayTakeover",
+          "_registerFirstDisplay",
+        ].filter((name) =>
+          Object.prototype.hasOwnProperty.call(window.tsjs ?? {}, name),
+        ),
+        resources: window.__tsjsAttemptResources(),
+        runtimeScripts: document.querySelectorAll(
+          "script#trustedserver-js-runtime",
+        ).length,
+        selectedScripts: document.querySelectorAll("script#trustedserver-js")
+          .length,
+      }));
+
+      expect(run.runtimeRequests).toHaveLength(1);
+      expect(observation.initialDisplayCommitted).toBe(true);
+      expect(observation.privateFields).toEqual([]);
+      expect(observation.runtimeScripts).toBe(0);
+      expect(observation.selectedScripts).toBe(1);
+      expect(observation.resources).toMatchObject({
+        activeMessageListeners: 0,
+        activePorts: 0,
+        activeTimeouts: 0,
+      });
+      expect(observation.resources.createdTimeouts).toBeGreaterThan(0);
+    } finally {
+      await run.close();
+    }
+  } finally {
+    await server.close();
+  }
+});
+
+test.describe("TSJS first-display performance gate", () => {
+  test.describe.configure({ retries: 0, mode: "serial" });
+  const activeFixtureServers: FixtureServer[] = [];
+
+  test.afterEach(async () => {
+    await Promise.all(
+      activeFixtureServers.splice(0).map((server) => server.close()),
+    );
+  });
+
+  test("records complete real timing, heap, and request-ordering evidence", async ({
+    browser,
+    browserName,
+  }) => {
+    // Each GPT/APS pair receives five warmups and 50 samples per variant. GPT
+    // samples stop at the common action; candidate APS samples also retain the
+    // real terminal/paint marks needed by the absolute lifecycle gate.
+    test.setTimeout(2_400_000);
+    const mode = process.env.TSJS_PERF_MODE;
+    test.skip(
+      mode !== "preswitch" && mode !== "postswitch" && mode !== "pull-request",
+      "performance evidence run only",
+    );
+    expect(browserName).toBe("chromium");
+    expect(browser.version()).toBe(EXPECTED_CHROMIUM);
+    expect(process.env.TSJS_PERF_MACHINE_CLASS).toBe(MACHINE_CLASS);
+    expect(process.env.TSJS_PERF_RUNNER_IMAGE).toBe(RUNNER_IMAGE);
+    const baselineRoot = process.env.TSJS_PERF_BASE_ROOT;
+    const baseSha = process.env.TSJS_PERF_BASE_SHA;
+    expect(baselineRoot, "TSJS_PERF_BASE_ROOT is required").toBeTruthy();
+    expect(baseSha, "TSJS_PERF_BASE_SHA is required").toMatch(
+      /^[0-9a-f]{40}$/u,
+    );
+    expect(
+      execFileSync("git", ["-C", baselineRoot!, "rev-parse", "HEAD"], {
+        encoding: "utf8",
+      }).trim(),
+    ).toBe(baseSha);
+    const baselineResources = loadBaselineFixtureResources(baselineRoot!);
+    const candidateResources = loadReleaseFixtureResources(REPO_ROOT);
+    const apsBaselineResources = loadBaselineFixtureResources(
+      baselineRoot!,
+      "aps",
+    );
+    const apsCandidateResources = loadReleaseFixtureResources(REPO_ROOT, "aps");
+    const baselineServer = await startFixtureServer(baselineResources);
+    const candidateServer = await startFixtureServer(candidateResources);
+    const apsBaselineServer = await startFixtureServer(apsBaselineResources);
+    const apsCandidateServer = await startFixtureServer(apsCandidateResources);
+    activeFixtureServers.push(
+      baselineServer,
+      candidateServer,
+      apsBaselineServer,
+      apsCandidateServer,
+    );
+
+    const observeTimingVariant = async (
+      fixtureServer: FixtureServer,
+      resources: FixtureResources,
+    ): Promise<ComparisonObservation> => {
+      const run = await openFixture(browser, fixtureServer, resources, {
+        waitUntil: "commit",
+      });
+      try {
+        const comparison = await observeComparisonFixture(run, resources);
+        return comparison;
+      } finally {
+        await run.close();
+      }
+    };
+
+    for (let index = 0; index < WARMUPS; index += 1) {
+      const variants =
+        index % 2 === 0
+          ? ([
+              [baselineServer, baselineResources],
+              [candidateServer, candidateResources],
+            ] as const)
+          : ([
+              [candidateServer, candidateResources],
+              [baselineServer, baselineResources],
+            ] as const);
+      for (const [server, resources] of variants) {
+        await observeTimingVariant(server, resources);
+      }
+    }
+
+    const baselineSamples: number[] = [];
+    const candidateSamples: number[] = [];
+    for (let index = 0; index < SAMPLES; index += 1) {
+      const variants =
+        index % 2 === 0
+          ? ([
+              ["baseline", baselineServer, baselineResources],
+              ["candidate", candidateServer, candidateResources],
+            ] as const)
+          : ([
+              ["candidate", candidateServer, candidateResources],
+              ["baseline", baselineServer, baselineResources],
+            ] as const);
+      for (const [variant, server, resources] of variants) {
+        const observation = await observeTimingVariant(server, resources);
+        if (variant === "baseline") {
+          baselineSamples.push(observation.timingMs);
+        } else {
+          candidateSamples.push(observation.timingMs);
+        }
+      }
+    }
+    expect(baselineSamples).toHaveLength(SAMPLES);
+    expect(candidateSamples).toHaveLength(SAMPLES);
+    const baselineP90 = p90(baselineSamples);
+    const candidateP90 = p90(candidateSamples);
+    expect(baselineP90).toBeGreaterThan(0);
+    expect
+      .soft(candidateP90, "candidate p90")
+      .toBeLessThanOrEqual(baselineP90 * MAXIMUM_P90_RATIO);
+    const baselineAgent = externalAgentTransfer(
+      baselineResources.referenceTransfer,
+    );
+    const candidateAgent = externalAgentTransfer(
+      candidateResources.referenceTransfer,
+    );
+    for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"] as const) {
+      expect
+        .soft(
+          candidateAgent[metric],
+          `candidate ${metric} selected-agent transfer`,
+        )
+        .toBeLessThanOrEqual(baselineAgent[metric]);
+    }
+
+    for (let index = 0; index < WARMUPS; index += 1) {
+      const variants =
+        index % 2 === 0
+          ? ([
+              [apsBaselineServer, apsBaselineResources],
+              [apsCandidateServer, apsCandidateResources],
+            ] as const)
+          : ([
+              [apsCandidateServer, apsCandidateResources],
+              [apsBaselineServer, apsBaselineResources],
+            ] as const);
+      for (const [server, resources] of variants) {
+        await observeTimingVariant(server, resources);
+      }
+    }
+
+    const apsBaselineActionSamples: number[] = [];
+    const apsCandidateActionSamples: number[] = [];
+    const apsActionToCompletionSamples: number[] = [];
+    const apsCompletionToPaintSamples: number[] = [];
+    const apsTotalToPaintSamples: number[] = [];
+    for (let index = 0; index < SAMPLES; index += 1) {
+      const variants =
+        index % 2 === 0
+          ? ([
+              ["baseline", apsBaselineServer, apsBaselineResources],
+              ["candidate", apsCandidateServer, apsCandidateResources],
+            ] as const)
+          : ([
+              ["candidate", apsCandidateServer, apsCandidateResources],
+              ["baseline", apsBaselineServer, apsBaselineResources],
+            ] as const);
+      for (const [variant, server, resources] of variants) {
+        const observation = await observeTimingVariant(server, resources);
+        if (variant === "baseline") {
+          apsBaselineActionSamples.push(observation.timingMs);
+          continue;
+        }
+        apsCandidateActionSamples.push(observation.timingMs);
+        apsActionToCompletionSamples.push(observation.actionToCompletionMs!);
+        apsCompletionToPaintSamples.push(observation.completionToPaintMs!);
+        apsTotalToPaintSamples.push(observation.totalToPaintMs!);
+      }
+    }
+    for (const samples of [
+      apsBaselineActionSamples,
+      apsCandidateActionSamples,
+      apsActionToCompletionSamples,
+      apsCompletionToPaintSamples,
+      apsTotalToPaintSamples,
+    ]) {
+      expect(samples).toHaveLength(SAMPLES);
+    }
+    const apsBaselineActionP90 = p90(apsBaselineActionSamples);
+    const apsCandidateActionP90 = p90(apsCandidateActionSamples);
+    const apsActionToCompletionP90 = p90(apsActionToCompletionSamples);
+    const apsCompletionToPaintP90 = p90(apsCompletionToPaintSamples);
+    const apsTotalToPaintP90 = p90(apsTotalToPaintSamples);
+    expect
+      .soft(apsCandidateActionP90, "APS candidate action p90")
+      .toBeLessThanOrEqual(apsBaselineActionP90 * MAXIMUM_P90_RATIO);
+    expect
+      .soft(apsCandidateActionP90, "APS absolute action p90")
+      .toBeLessThanOrEqual(APS_ACTION_P90_CEILING_MS);
+    expect
+      .soft(apsActionToCompletionP90, "APS action-to-completion p90")
+      .toBeLessThanOrEqual(APS_ACTION_TO_COMPLETION_P90_CEILING_MS);
+    expect
+      .soft(apsCompletionToPaintP90, "APS completion-to-paint p90")
+      .toBeLessThanOrEqual(APS_COMPLETION_TO_PAINT_P90_CEILING_MS);
+    expect
+      .soft(apsTotalToPaintP90, "APS total-to-paint p90")
+      .toBeLessThanOrEqual(APS_TOTAL_P90_CEILING_MS);
+    const apsBaselineAgent = externalAgentTransfer(
+      apsBaselineResources.referenceTransfer,
+    );
+    const apsCandidateAgent = externalAgentTransfer(
+      apsCandidateResources.referenceTransfer,
+    );
+    for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"] as const) {
+      expect
+        .soft(
+          apsCandidateAgent[metric],
+          `APS candidate ${metric} selected-agent transfer`,
+        )
+        .toBeLessThanOrEqual(apsBaselineAgent[metric] * MAXIMUM_P90_RATIO);
+    }
+
+    const representativeRun = await openFixture(
+      browser,
+      candidateServer,
+      candidateResources,
+      { waitUntil: "load" },
+    );
+    const representative = await observeFixture(
+      representativeRun,
+      candidateResources,
+    ).finally(() => representativeRun.close());
+    expect(representative.releaseId).toBe(
+      candidateResources.release?.releaseId,
+    );
+    const apsRepresentativeRun = await openFixture(
+      browser,
+      apsCandidateServer,
+      apsCandidateResources,
+      { waitUntil: "load" },
+    );
+    const apsRepresentative = await observeFixture(
+      apsRepresentativeRun,
+      apsCandidateResources,
+    ).finally(() => apsRepresentativeRun.close());
+    expect(apsRepresentative.releaseId).toBe(
+      apsCandidateResources.release?.releaseId,
+    );
+
+    const { baseline: baselineHeapBytes, candidate: candidateHeapBytes } =
+      await collectPairedHeapCheckpoints(
+        baselineServer,
+        baselineResources,
+        candidateServer,
+        candidateResources,
+      );
+    for (const name of HEAP_CHECKPOINTS) {
+      expect
+        .soft(baselineHeapBytes[name], `${name} rc-baseline retained heap`)
+        .toBeLessThanOrEqual(HARD_HEAP_CEILING_BYTES);
+      expect
+        .soft(candidateHeapBytes[name], `${name} candidate retained heap`)
+        .toBeLessThanOrEqual(HARD_HEAP_CEILING_BYTES);
+    }
+    const apsHeapBytes = await collectApsHeapCheckpoints(
+      apsCandidateServer,
+      apsCandidateResources,
+    );
+    expect
+      .soft(apsHeapBytes.afterProtectedPaint, "APS heap after protected paint")
+      .toBeLessThanOrEqual(APS_AFTER_PAINT_HEAP_CEILING_BYTES);
+    expect
+      .soft(
+        apsHeapBytes.afterTakeoverQueueDrain,
+        "APS heap after takeover and queue drain",
+      )
+      .toBeLessThanOrEqual(APS_AFTER_TAKEOVER_HEAP_CEILING_BYTES);
+
+    const evidenceId = process.env.TSJS_EVIDENCE_ID;
+    const headSha = process.env.TSJS_PERF_HEAD_SHA;
+    const outputArgument = process.env.TSJS_PERF_OUTPUT;
+    expect(evidenceId, "TSJS_EVIDENCE_ID is required").toMatch(
+      /^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/u,
+    );
+    expect(headSha, "GITHUB_SHA is required").toMatch(/^[0-9a-f]{40}$/u);
+    expect(outputArgument, "TSJS_PERF_OUTPUT is required").toBeTruthy();
+    const outputPath = isAbsolute(outputArgument!)
+      ? outputArgument!
+      : resolve(REPO_ROOT, outputArgument!);
+    const deferredBeforePaint = representative.deferred.filter(
+      ({ startTime }) => startTime < representative.paintTime,
+    ).length;
+    const deferredPreparationBeforePaint = representative.deferred.filter(
+      ({ preparationTime }) => preparationTime < representative.paintTime,
+    ).length;
+    const deferredExecutionBeforePaint = representative.deferred.filter(
+      ({ executionTime }) => executionTime < representative.paintTime,
+    ).length;
+    const deferredStarts = representative.deferred.map(
+      ({ startTime }) => startTime,
+    );
+    const deferredByResponseEnd = [...representative.deferred].sort(
+      (left, right) => left.responseEnd - right.responseEnd,
+    );
+    const apsDeferredBeforePaint = apsRepresentative.deferred.filter(
+      ({ startTime }) => startTime < apsRepresentative.paintTime,
+    ).length;
+    const apsDeferredPreparationBeforePaint = apsRepresentative.deferred.filter(
+      ({ preparationTime }) => preparationTime < apsRepresentative.paintTime,
+    ).length;
+    const apsDeferredExecutionBeforePaint = apsRepresentative.deferred.filter(
+      ({ executionTime }) => executionTime < apsRepresentative.paintTime,
+    ).length;
+    const npmVersion = execFileSync("npm", ["--version"], {
+      encoding: "utf8",
+    }).trim();
+    const evidence = {
+      schemaVersion: 7,
+      evidenceId,
+      mode,
+      headSha,
+      environment: {
+        chromium: browser.version(),
+        controller: CONTROLLER_ID,
+        machineClass: process.env.TSJS_PERF_MACHINE_CLASS,
+        runnerImage: process.env.TSJS_PERF_RUNNER_IMAGE,
+        fixture: FIXTURE_ID,
+        node: process.version,
+        npm: npmVersion,
+        typescript: packageVersion(
+          resolve(
+            REPO_ROOT,
+            "crates/trusted-server-js/lib/node_modules/typescript/package.json",
+          ),
+        ),
+      },
+      sampling: {
+        warmupsPerVariant: WARMUPS,
+        samplesPerVariant: SAMPLES,
+        percentile: PERCENTILE,
+        interleaving: "alternating-baseline-candidate",
+      },
+      networkProfile: {
+        mechanism: "cdp-Network.emulateNetworkConditions",
+        appliedBeforeNavigation: true,
+        latencyMs: NETWORK_PROFILE.latency,
+        downloadThroughputBytesPerSecond: NETWORK_PROFILE.downloadThroughput,
+        uploadThroughputBytesPerSecond: NETWORK_PROFILE.uploadThroughput,
+        packetLossPercent: NETWORK_PROFILE.packetLoss,
+      },
+      marks: {
+        source: "fixture-first-observable-action",
+        comparisonStart: true,
+        firstObservableAction: true,
+        candidateBidsScript: representative.bidsScriptCount === 1,
+        candidateFirstDisplay: representative.firstDisplayCount === 1,
+        candidateFirstDisplayPaint: representative.firstDisplayPaintCount === 1,
+      },
+      performance: {
+        requestToFirstActionMs: {
+          baseline: {
+            sha: baseSha,
+            artifactModel: baselineResources.artifactModel,
+            selectedTransferBytes: baselineResources.selectedTransferBytes,
+            samples: baselineSamples,
+            p90: baselineP90,
+          },
+          candidate: {
+            artifactModel: candidateResources.artifactModel,
+            selectedTransferBytes: candidateResources.selectedTransferBytes,
+            samples: candidateSamples,
+            p90: candidateP90,
+          },
+          percentile: PERCENTILE,
+          maximumRatio: MAXIMUM_P90_RATIO,
+          observedRatio: candidateP90 / baselineP90,
+        },
+      },
+      transfer: {
+        algorithm: "split-preaction-transfer-v2",
+        baselineReferenceTransfer: {
+          sha: baseSha,
+          artifactModel: baselineResources.artifactModel,
+          ...baselineResources.referenceTransfer,
+        },
+        candidateReferenceTransfer: {
+          sha: headSha,
+          artifactModel: candidateResources.artifactModel,
+          ...candidateResources.referenceTransfer,
+        },
+      },
+      heap: {
+        collection: "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+        hardCeilingBytes: HARD_HEAP_CEILING_BYTES,
+        baseline: {
+          sha: baseSha,
+          checkpoints: baselineHeapBytes,
+        },
+        candidate: { checkpoints: candidateHeapBytes },
+      },
+      requests: {
+        selected: { count: 1 },
+        deferred: {
+          count: representative.deferred.length,
+          requestBeforePaintCount: deferredBeforePaint,
+          preloadBeforePaintCount: representative.preloadBeforePaintCount,
+          preparationBeforePaintCount: deferredPreparationBeforePaint,
+          executionBeforePaintCount: deferredExecutionBeforePaint,
+          independentlyTriggered:
+            Math.max(...deferredStarts) - Math.min(...deferredStarts) <= 50,
+          headOfLineBlocking:
+            deferredByResponseEnd[0]!.executionTime >=
+            deferredByResponseEnd.at(-1)!.responseEnd,
+        },
+      },
+      aps: {
+        marks: {
+          source: "performance-entry",
+          candidateBidsScript: apsRepresentative.bidsScriptCount === 1,
+          candidateFirstDisplay: apsRepresentative.firstDisplayCount === 1,
+          candidateFirstDisplayTerminal: true,
+          candidateFirstDisplayPaint:
+            apsRepresentative.firstDisplayPaintCount === 1,
+        },
+        performance: {
+          firstAction: {
+            baseline: {
+              sha: baseSha,
+              artifactModel: apsBaselineResources.artifactModel,
+              selectedTransferBytes: apsBaselineResources.selectedTransferBytes,
+              samples: apsBaselineActionSamples,
+              p90: apsBaselineActionP90,
+            },
+            candidate: {
+              artifactModel: apsCandidateResources.artifactModel,
+              selectedTransferBytes:
+                apsCandidateResources.selectedTransferBytes,
+              samples: apsCandidateActionSamples,
+              p90: apsCandidateActionP90,
+            },
+            percentile: PERCENTILE,
+            maximumRatio: MAXIMUM_P90_RATIO,
+            absoluteCeilingMs: APS_ACTION_P90_CEILING_MS,
+            observedRatio: apsCandidateActionP90 / apsBaselineActionP90,
+          },
+          actionToCompletion: {
+            samples: apsActionToCompletionSamples,
+            p90: apsActionToCompletionP90,
+            ceilingMs: APS_ACTION_TO_COMPLETION_P90_CEILING_MS,
+          },
+          completionToPaint: {
+            samples: apsCompletionToPaintSamples,
+            p90: apsCompletionToPaintP90,
+            ceilingMs: APS_COMPLETION_TO_PAINT_P90_CEILING_MS,
+          },
+          totalToPaint: {
+            samples: apsTotalToPaintSamples,
+            p90: apsTotalToPaintP90,
+            ceilingMs: APS_TOTAL_P90_CEILING_MS,
+          },
+        },
+        transfer: {
+          algorithm: "split-preaction-transfer-v2",
+          maximumRatio: MAXIMUM_P90_RATIO,
+          baselineReferenceTransfer: {
+            sha: baseSha,
+            artifactModel: apsBaselineResources.artifactModel,
+            ...apsBaselineResources.referenceTransfer,
+          },
+          candidateReferenceTransfer: {
+            sha: headSha,
+            artifactModel: apsCandidateResources.artifactModel,
+            ...apsCandidateResources.referenceTransfer,
+          },
+        },
+        heap: {
+          collection: "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+          afterProtectedPaint: {
+            usedSize: apsHeapBytes.afterProtectedPaint,
+            ceilingBytes: APS_AFTER_PAINT_HEAP_CEILING_BYTES,
+          },
+          afterTakeoverQueueDrain: {
+            usedSize: apsHeapBytes.afterTakeoverQueueDrain,
+            ceilingBytes: APS_AFTER_TAKEOVER_HEAP_CEILING_BYTES,
+          },
+        },
+        requests: {
+          selected: { count: 1 },
+          deferred: {
+            count: apsRepresentative.deferred.length,
+            requestBeforePaintCount: apsDeferredBeforePaint,
+            preloadBeforePaintCount: apsRepresentative.preloadBeforePaintCount,
+            preparationBeforePaintCount: apsDeferredPreparationBeforePaint,
+            executionBeforePaintCount: apsDeferredExecutionBeforePaint,
+          },
+        },
+        assertions: { correctness: true, loadOrder: true },
+      },
+      assertions: { correctness: true, loadOrder: true },
+      provenance: {
+        workflowName: process.env.TSJS_PERF_WORKFLOW_NAME,
+        workflowFile: process.env.TSJS_PERF_WORKFLOW_FILE,
+        runId: Number(process.env.GITHUB_RUN_ID),
+        runAttempt: Number(process.env.GITHUB_RUN_ATTEMPT),
+        artifactName: process.env.TSJS_PERF_ARTIFACT_NAME,
+        headSha,
+      },
+      result: "complete",
+    };
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `${JSON.stringify(evidence, null, 2)}\n`);
+  });
+});
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-policy.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-policy.spec.ts
new file mode 100644
index 000000000..bd8805e1f
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-policy.spec.ts
@@ -0,0 +1,418 @@
+import { expect, test, type Page } from "@playwright/test";
+import {
+  firstDisplayTsjsFixture,
+  runtimeTsjsFixture,
+  serverBootTransportLiteralV1,
+} from "../../helpers/tsjs-fixture.js";
+
+const NONCE = "tsjs-policy-nonce";
+const POLICY_SLOT = "policy-slot";
+const DIRECT = runtimeTsjsFixture(["render_runtime"]);
+const DEFERRED = firstDisplayTsjsFixture({
+  firstDisplayIds: ["first_display"],
+  takeoverIds: ["render_runtime"],
+  deferredIds: ["diagnostics_presentation"],
+  auctionProjection: {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: "policy",
+      results: [{ slot: POLICY_SLOT, outcome: "no_bid" }],
+    },
+    slots: [
+      {
+        slot: POLICY_SLOT,
+        gamUnitPath: `/123/${POLICY_SLOT}`,
+        divId: POLICY_SLOT,
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [],
+  },
+  integrations: { version: 1, entries: [] },
+  diagnostics: {
+    version: 1,
+    renderTraceOverlay: true,
+    gpt: { active: false },
+  },
+});
+
+function directBoot() {
+  return {
+    abi: 1,
+    releaseId: DIRECT.releaseId,
+    manifest: DIRECT.manifest,
+    auctionProjection: {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: "policy-direct",
+        results: [{ slot: POLICY_SLOT, outcome: "no_bid" }],
+      },
+      slots: [
+        {
+          slot: POLICY_SLOT,
+          gamUnitPath: `/123/${POLICY_SLOT}`,
+          divId: POLICY_SLOT,
+          formats: [[300, 250]],
+          targeting: {},
+        },
+      ],
+      bids: [],
+    },
+    integrations: { version: 1, entries: [] },
+    creative: {
+      version: 1,
+      enabled: false,
+      clickGuard: false,
+      renderGuard: false,
+    },
+    diagnostics: {
+      version: 1,
+      renderTraceOverlay: false,
+      gpt: { active: false },
+    },
+  };
+}
+
+function deferredBoot() {
+  return {
+    ...DEFERRED.boot,
+    manifest: {
+      ...(DEFERRED.boot.manifest as Record<string, unknown>),
+      firstDisplay: null,
+    },
+  };
+}
+
+interface PolicyPageOptions {
+  readonly path: string;
+  readonly csp: string;
+  readonly nonce?: string;
+  readonly deferred?: boolean;
+  readonly takeover?: boolean;
+  readonly prelude?: string;
+  readonly tail?: string;
+  readonly removeDeferred?: boolean;
+}
+
+async function servePolicyPage(page: Page, options: PolicyPageOptions) {
+  const fixture = options.deferred ? DEFERRED : DIRECT;
+  const boot = options.takeover
+    ? DEFERRED.boot
+    : options.deferred
+      ? deferredBoot()
+      : directBoot();
+  const runtimeUrl = new URL(
+    fixture.runtimeSrc,
+    "https://runtime.test",
+  ).toString();
+  const firstDisplayUrl = options.takeover
+    ? new URL(DEFERRED.firstDisplaySrc, "https://runtime.test").toString()
+    : undefined;
+  const deferredResource = options.deferred ? DEFERRED.deferred[0] : undefined;
+  const deferredUrl = deferredResource
+    ? new URL(deferredResource.src, "https://runtime.test").toString()
+    : undefined;
+  const runtimeRequests: string[] = [];
+  const deferredRequests: string[] = [];
+  const routeHits = { deferred: 0, firstDisplay: 0, runtime: 0 };
+  page.on("request", (request) => {
+    if (request.url() === runtimeUrl) runtimeRequests.push(request.url());
+    if (request.url() === deferredUrl) deferredRequests.push(request.url());
+  });
+  await page.route(runtimeUrl, (route) => {
+    routeHits.runtime += 1;
+    return route.fulfill({
+      status: 200,
+      contentType: "application/javascript; charset=utf-8",
+      headers: { "x-content-type-options": "nosniff" },
+      body: fixture.runtimeBody,
+    });
+  });
+  if (firstDisplayUrl) {
+    await page.route(firstDisplayUrl, (route) => {
+      routeHits.firstDisplay += 1;
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript; charset=utf-8",
+        headers: { "x-content-type-options": "nosniff" },
+        body: DEFERRED.firstDisplayBody,
+      });
+    });
+  }
+  if (deferredResource && deferredUrl) {
+    await page.route(deferredUrl, (route) => {
+      routeHits.deferred += 1;
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript; charset=utf-8",
+        headers: { "x-content-type-options": "nosniff" },
+        body: deferredResource.body,
+      });
+    });
+  }
+  const nonce = options.nonce ? ` nonce="${options.nonce}"` : "";
+  const probe = options.deferred
+    ? `window.__policyProbe={insertions:0,removals:0};const __policyObserver=new MutationObserver(records=>{for(const record of records){for(const node of record.addedNodes){if(!(node instanceof HTMLScriptElement)||!node.src.includes("tsjs-diagnostics_presentation.min.js"))continue;window.__policyProbe.insertions+=1;${options.removeDeferred ? 'node.replaceWith(document.createElement("script"));window.__policyProbe.removals+=1;' : ""}}}});__policyObserver.observe(document,{childList:true,subtree:true});`
+    : "";
+  const controllerBody = `window.tsjs={que:[]};${probe}${options.prelude ?? ""}const __TSJS_SERVER_BOOT_TRANSPORT_V1__=${serverBootTransportLiteralV1(boot, options.takeover ? DEFERRED.outline : null)};${fixture.bootstrapBody}`;
+  await page.route(`https://runtime.test${options.path}`, (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "text/html; charset=utf-8",
+      headers: { "content-security-policy": options.csp },
+      body: `<!doctype html><html><head><meta charset="utf-8"><script${nonce}>${controllerBody}</script></head><body><div id="${POLICY_SLOT}"></div><script${nonce} src="${options.takeover ? DEFERRED.firstDisplaySrc : fixture.runtimeSrc}" id="trustedserver-js"></script>${options.tail ? `<script${nonce}>${options.tail}</script>` : ""}</body></html>`,
+    }),
+  );
+  await page.goto(`https://runtime.test${options.path}`);
+  return {
+    deferredRequests,
+    routeHits,
+    runtimeRequests,
+  };
+}
+
+async function runtimeState(page: Page): Promise<string | undefined> {
+  return page.evaluate(
+    () =>
+      (
+        window as unknown as {
+          tsjs?: { _internal?: { state?: string } };
+        }
+      ).tsjs?._internal?.state,
+  );
+}
+
+async function releaseDeferredGate(page: Page): Promise<void> {
+  await page.evaluate(async (slot) => {
+    const target = (
+      window as unknown as {
+        tsjs: {
+          requestAds(options: {
+            slots: readonly string[];
+            timeoutMs: number;
+          }): Promise<unknown>;
+        };
+      }
+    ).tsjs;
+    await target.requestAds({ slots: [slot], timeoutMs: 100 });
+  }, POLICY_SLOT);
+}
+
+for (const fixture of [
+  {
+    name: "same-origin allowlisting",
+    path: "/policy-same-origin",
+    csp: "default-src 'none'; script-src 'self' 'unsafe-inline'",
+  },
+  {
+    name: "matching nonce",
+    path: "/policy-matching-nonce",
+    csp: `default-src 'none'; script-src 'self' 'nonce-${NONCE}'`,
+    nonce: NONCE,
+  },
+  {
+    name: "nonce-only",
+    path: "/policy-nonce-only",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}'`,
+    nonce: NONCE,
+  },
+  {
+    name: "strict-dynamic",
+    path: "/policy-strict-dynamic",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}' 'strict-dynamic'`,
+    nonce: NONCE,
+  },
+] as const) {
+  test(`boots the authenticated direct runtime under ${fixture.name}`, async ({
+    page,
+  }) => {
+    const requests = await servePolicyPage(page, fixture);
+    await expect.poll(() => runtimeState(page)).toBe("kernel");
+    expect(requests.runtimeRequests).toHaveLength(1);
+  });
+}
+
+test("a full script policy block starts no TSJS execution or request", async ({
+  page,
+}) => {
+  const requests = await servePolicyPage(page, {
+    path: "/policy-blocked",
+    csp: "default-src 'none'; script-src 'none'",
+  });
+  expect(await runtimeState(page)).toBeUndefined();
+  expect(requests.routeHits.runtime).toBe(0);
+});
+
+for (const fixture of [
+  {
+    name: "the allowed fixed Trusted Types policy",
+    path: "/policy-tt-named",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}'; require-trusted-types-for 'script'; trusted-types trusted-server#tsjs-v1`,
+  },
+  {
+    name: "a rejected fixed name and exact-preserving publisher default",
+    path: "/policy-tt-default",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}'; require-trusted-types-for 'script'; trusted-types default`,
+    prelude:
+      'trustedTypes.createPolicy("default",{createScriptURL:value=>value});',
+  },
+] as const) {
+  test(`loads a deferred module with ${fixture.name}`, async ({
+    browserName,
+    page,
+  }) => {
+    test.skip(
+      browserName !== "chromium",
+      "Trusted Types enforcement is Chromium-only",
+    );
+    const requests = await servePolicyPage(page, {
+      ...fixture,
+      nonce: NONCE,
+      deferred: true,
+    });
+    await expect.poll(() => runtimeState(page)).toBe("kernel");
+    await releaseDeferredGate(page);
+    await expect.poll(() => requests.deferredRequests.length).toBe(1);
+    await expect
+      .poll(() => page.locator("#ts-render-trace-panel").count())
+      .toBe(1);
+  });
+}
+
+test("the first-display owner creates the fixed Trusted Types policy once and leases it to deferred loading", async ({
+  browserName,
+  page,
+}) => {
+  test.skip(
+    browserName !== "chromium",
+    "Trusted Types enforcement is Chromium-only",
+  );
+  const requests = await servePolicyPage(page, {
+    path: "/policy-tt-takeover",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}' 'strict-dynamic'; require-trusted-types-for 'script'; trusted-types trusted-server#tsjs-v1`,
+    nonce: NONCE,
+    deferred: true,
+    takeover: true,
+    prelude:
+      'window.__policyCreates=[];const __nativeCreatePolicy=trustedTypes.createPolicy.bind(trustedTypes);Object.defineProperty(trustedTypes,"createPolicy",{value:(name,rules)=>{if(window.__policyCreates.includes(name))throw new TypeError("duplicate TSJS policy");window.__policyCreates.push(name);return __nativeCreatePolicy(name,rules);}});',
+  });
+  await expect.poll(() => runtimeState(page)).toBe("kernel");
+  await releaseDeferredGate(page);
+  await expect.poll(() => requests.deferredRequests.length).toBe(1);
+  await expect
+    .poll(() => page.locator("#ts-render-trace-panel").count())
+    .toBe(1);
+  expect(requests.routeHits.firstDisplay).toBe(1);
+  expect(requests.routeHits.runtime).toBe(1);
+  expect(
+    await page.evaluate(
+      () =>
+        (
+          window as unknown as {
+            __policyCreates: string[];
+          }
+        ).__policyCreates,
+    ),
+  ).toEqual(["trusted-server#tsjs-v1"]);
+});
+
+for (const fixture of [
+  {
+    name: "mutates the URL",
+    path: "/policy-tt-mutate",
+    prelude:
+      'trustedTypes.createPolicy("default",{createScriptURL:value=>value+"&publisher=mutated"});',
+  },
+  {
+    name: "throws synchronously",
+    path: "/policy-tt-throw",
+    prelude:
+      'trustedTypes.createPolicy("default",{createScriptURL:()=>{throw new TypeError("publisher policy");}});',
+  },
+] as const) {
+  test(`a publisher default policy that ${fixture.name} blocks before insertion`, async ({
+    browserName,
+    page,
+  }) => {
+    test.skip(
+      browserName !== "chromium",
+      "Trusted Types enforcement is Chromium-only",
+    );
+    const requests = await servePolicyPage(page, {
+      ...fixture,
+      csp: `default-src 'none'; script-src 'nonce-${NONCE}'; require-trusted-types-for 'script'; trusted-types default`,
+      nonce: NONCE,
+      deferred: true,
+    });
+    await expect.poll(() => runtimeState(page)).toBe("kernel");
+    await releaseDeferredGate(page);
+    await page.waitForTimeout(150);
+    const probe = await page.evaluate(
+      () =>
+        (
+          window as unknown as {
+            __policyProbe: { insertions: number; removals: number };
+          }
+        ).__policyProbe,
+    );
+    expect(probe.insertions).toBe(0);
+    expect(requests.deferredRequests).toEqual([]);
+    expect(await page.locator("#ts-render-trace-panel").count()).toBe(0);
+  });
+}
+
+test("a missing propagated nonce blocks after insertion without replacing the kernel", async ({
+  page,
+}) => {
+  const requests = await servePolicyPage(page, {
+    path: "/policy-missing-deferred-nonce",
+    csp: `default-src 'none'; script-src 'nonce-${NONCE}'`,
+    nonce: NONCE,
+    deferred: true,
+    tail: 'document.querySelector("script#trustedserver-js").nonce="";',
+  });
+  await expect.poll(() => runtimeState(page)).toBe("kernel");
+  await releaseDeferredGate(page);
+  await page.waitForTimeout(150);
+  const insertions = await page.evaluate(
+    () =>
+      (
+        window as unknown as {
+          __policyProbe: { insertions: number };
+        }
+      ).__policyProbe.insertions,
+  );
+  expect(insertions).toBe(1);
+  expect(requests.routeHits.deferred).toBe(0);
+  expect(await page.locator("#ts-render-trace-panel").count()).toBe(0);
+  expect(await runtimeState(page)).toBe("kernel");
+});
+
+test("removing the authenticated deferred node cannot register or replace the kernel", async ({
+  page,
+}) => {
+  const requests = await servePolicyPage(page, {
+    path: "/policy-deferred-replaced",
+    csp: "default-src 'none'; script-src 'self' 'unsafe-inline'",
+    deferred: true,
+    removeDeferred: true,
+  });
+  await expect.poll(() => runtimeState(page)).toBe("kernel");
+  await releaseDeferredGate(page);
+  await page.waitForTimeout(150);
+  const probe = await page.evaluate(
+    () =>
+      (
+        window as unknown as {
+          __policyProbe: { insertions: number; removals: number };
+        }
+      ).__policyProbe,
+  );
+  expect(probe).toEqual({ insertions: 1, removals: 1 });
+  expect(requests.deferredRequests.length).toBeLessThanOrEqual(1);
+  expect(await page.locator("#ts-render-trace-panel").count()).toBe(0);
+  expect(await runtimeState(page)).toBe("kernel");
+});
diff --git a/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts
new file mode 100644
index 000000000..ee0436478
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts
@@ -0,0 +1,672 @@
+import { expect, test, type Page } from "@playwright/test";
+import { installGptStub } from "../../helpers/gpt-stub.js";
+import {
+  firstDisplayTsjsFixture,
+  loadRuntimeTsjsFixture,
+  runtimeTsjsFixture,
+  serverBootTransportLiteralV1,
+  type RuntimeTsjsFixture,
+} from "../../helpers/tsjs-fixture.js";
+
+const KERNEL_FIXTURE = runtimeTsjsFixture(["render_runtime"]);
+const FALLBACK_FIXTURE = runtimeTsjsFixture([]);
+const FIRST_DISPLAY_SLOT = "first-display-owner-slot";
+const FIRST_DISPLAY_FIXTURE = firstDisplayTsjsFixture({
+  firstDisplayIds: ["first_display", "render_owner_initial", "gpt_initial"],
+  takeoverIds: ["render_runtime", "gpt", "gpt_diagnostics"],
+  deferredIds: ["diagnostics_presentation"],
+  auctionProjection: {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: "browser-first-display-owner",
+      results: [
+        {
+          slot: FIRST_DISPLAY_SLOT,
+          outcome: "winner",
+          candidateId: "AAAAAAAAAAAA",
+        },
+      ],
+    },
+    slots: [
+      {
+        slot: FIRST_DISPLAY_SLOT,
+        gamUnitPath: `/123/${FIRST_DISPLAY_SLOT}`,
+        divId: FIRST_DISPLAY_SLOT,
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [
+      {
+        candidateId: "AAAAAAAAAAAA",
+        slot: FIRST_DISPLAY_SLOT,
+        provider: "fictional",
+        upstreamBidId: "first-display-owner-bid",
+        cpm: 1.25,
+        currency: "USD",
+        targeting: { hb_bidder: "fictional" },
+        rendererReservationId: "r1_AAAAAAAAAAAAAAAAAAAAAA",
+        renderSource: {
+          type: "adm",
+          version: 1,
+          adm: "<main>fictional first-display creative</main>",
+          width: 300,
+          height: 250,
+        },
+      },
+    ],
+  },
+  integrations: {
+    version: 1,
+    entries: [
+      {
+        id: "gpt",
+        config: {
+          gamAttributionEnabled: false,
+          pageBidsEnabled: true,
+        },
+      },
+    ],
+  },
+  diagnostics: {
+    version: 1,
+    renderTraceOverlay: true,
+    gpt: { active: true },
+  },
+});
+
+function boot(fixture: RuntimeTsjsFixture) {
+  return {
+    abi: 1,
+    releaseId: fixture.releaseId,
+    manifest: fixture.manifest,
+    auctionProjection: {
+      version: 1,
+      auction: { version: 1, auctionId: "browser-initial", results: [] },
+      slots: [],
+      bids: [],
+    },
+    integrations: { version: 1, entries: [] },
+    creative: {
+      version: 1,
+      enabled: false,
+      clickGuard: false,
+      renderGuard: false,
+    },
+    diagnostics: {
+      version: 1,
+      renderTraceOverlay: false,
+      gpt: { active: false },
+    },
+  };
+}
+
+async function waitForRuntime(page: Page, state: "kernel" | "fallback") {
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          (
+            window as unknown as {
+              tsjs?: { _internal?: { state?: string } };
+            }
+          ).tsjs?._internal?.state,
+      ),
+    )
+    .toBe(state);
+}
+
+async function openRuntimePage(page: Page) {
+  await page.route("https://runtime.test/fixture", (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "text/html",
+      body: '<!doctype html><div id="runtime-slot"></div>',
+    }),
+  );
+  await page.goto("https://runtime.test/fixture");
+}
+
+async function installFirstDisplayResourceProbe(page: Page): Promise<void> {
+  await page.addInitScript(() => {
+    const events: Array<{ kind: string; beforePaint: boolean }> = [];
+    const record = (kind: string): void => {
+      events.push({
+        kind,
+        beforePaint:
+          performance.getEntriesByName("tsjs:first-display-paint", "mark")
+            .length === 0,
+      });
+    };
+
+    const nativeCreateElement = Document.prototype.createElement;
+    Document.prototype.createElement = function (
+      qualifiedName: string,
+      options?: ElementCreationOptions,
+    ): HTMLElement {
+      const normalized = String(qualifiedName).toLowerCase();
+      if (normalized === "script" || normalized === "link") {
+        record(`create:${normalized}`);
+      }
+      return nativeCreateElement.call(this, qualifiedName, options);
+    };
+
+    const nativeFetch = window.fetch;
+    window.fetch = ((...arguments_: Parameters<typeof window.fetch>) => {
+      record("fetch");
+      return Reflect.apply(nativeFetch, window, arguments_);
+    }) as typeof window.fetch;
+
+    const nativeXhrOpen = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function (...arguments_: unknown[]): void {
+      record("xhr");
+      Reflect.apply(nativeXhrOpen, this, arguments_);
+    } as typeof XMLHttpRequest.prototype.open;
+
+    const wrapConstructor = (name: "Worker" | "SharedWorker"): void => {
+      const nativeConstructor = Reflect.get(window, name);
+      if (typeof nativeConstructor !== "function") return;
+      const wrapped = function (this: unknown, ...arguments_: unknown[]) {
+        record(name.toLowerCase());
+        return Reflect.construct(nativeConstructor, arguments_, new.target);
+      };
+      Object.setPrototypeOf(wrapped, nativeConstructor);
+      Object.defineProperty(wrapped, "prototype", {
+        value: nativeConstructor.prototype,
+      });
+      Reflect.set(window, name, wrapped);
+    };
+    wrapConstructor("Worker");
+    wrapConstructor("SharedWorker");
+
+    const nativeCreateObjectUrl = URL.createObjectURL;
+    URL.createObjectURL = ((object: Blob | MediaSource): string => {
+      record("blob-url");
+      return Reflect.apply(nativeCreateObjectUrl, URL, [object]) as string;
+    }) as typeof URL.createObjectURL;
+
+    Object.defineProperty(window, "__firstDisplayResourceProbe", {
+      value: () => events.map((entry) => ({ ...entry })),
+    });
+  });
+}
+
+test.describe("TSJS hard-cutover runtime", () => {
+  test("loads the render owner only inside one parser-blocking first-display request before paint", async ({
+    page,
+  }) => {
+    await installGptStub(page);
+    await installFirstDisplayResourceProbe(page);
+    const firstDisplayUrl = new URL(
+      FIRST_DISPLAY_FIXTURE.firstDisplaySrc,
+      "https://runtime.test",
+    ).toString();
+    const runtimeUrl = new URL(
+      FIRST_DISPLAY_FIXTURE.runtimeSrc,
+      "https://runtime.test",
+    ).toString();
+    const deferredUrls = FIRST_DISPLAY_FIXTURE.deferred.map((resource) =>
+      new URL(resource.src, "https://runtime.test").toString(),
+    );
+    const firstDisplayRequests: string[] = [];
+    const allRequests: string[] = [];
+    const pageErrors: string[] = [];
+    const consoleMessages: string[] = [];
+    const deferredRegistrationAttack = `window.__deferredRegistrationAttack={attempted:false,prepareCalled:false,registrationAccepted:false};const __deferredRegistrationObserver=new MutationObserver(records=>{for(const record of records){for(const node of record.addedNodes){if(!(node instanceof HTMLScriptElement)||!node.src.includes("tsjs-diagnostics_presentation.min.js"))continue;__deferredRegistrationObserver.disconnect();window.__deferredRegistrationAttack.attempted=true;try{Object.defineProperty(document,"currentScript",{configurable:true,value:node});}catch{}const forged=Object.freeze({abi:1,id:"diagnostics_presentation",phase:"deferred",releaseId:${JSON.stringify(FIRST_DISPLAY_FIXTURE.releaseId)},prepare:()=>{window.__deferredRegistrationAttack.prepareCalled=true;return Object.freeze({activate:()=>undefined});}});window.__deferredRegistrationAttack.registrationAccepted=window.tsjs._registerIntegration(forged);}}});__deferredRegistrationObserver.observe(document,{childList:true,subtree:true});`;
+    page.on("request", (request) => allRequests.push(request.url()));
+    page.on("pageerror", (error) => pageErrors.push(error.message));
+    page.on("console", (message) =>
+      consoleMessages.push(`${message.type()}: ${message.text()}`),
+    );
+    await page.route(firstDisplayUrl, (route) => {
+      firstDisplayRequests.push(route.request().url());
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript; charset=utf-8",
+        headers: { "x-content-type-options": "nosniff" },
+        body: FIRST_DISPLAY_FIXTURE.firstDisplayBody,
+      });
+    });
+    await page.route(runtimeUrl, (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "application/javascript; charset=utf-8",
+        headers: { "x-content-type-options": "nosniff" },
+        body: FIRST_DISPLAY_FIXTURE.runtimeBody,
+      }),
+    );
+    for (const resource of FIRST_DISPLAY_FIXTURE.deferred) {
+      await page.route(
+        new URL(resource.src, "https://runtime.test").toString(),
+        (route) =>
+          route.fulfill({
+            status: 200,
+            contentType: "application/javascript; charset=utf-8",
+            headers: { "x-content-type-options": "nosniff" },
+            body: resource.body,
+          }),
+      );
+    }
+    await page.route("https://runtime.test/first-display-owner", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "text/html; charset=utf-8",
+        body: `<!doctype html><html><head><meta charset="utf-8"><link rel="icon" href="data:,"><script>window.tsjs={que:[]};window.__takeoverAttack={claimExposed:false,currentScriptShadowed:false,namespaceReplacementBlocked:false,replacementBlocked:false};const __takeoverObserver=new MutationObserver(records=>{for(const record of records){for(const node of record.addedNodes){if(!(node instanceof HTMLScriptElement)||node.id!=="trustedserver-js-runtime")continue;__takeoverObserver.disconnect();const original=node._claimRuntimeV1;if(typeof original!=="function")continue;try{Object.defineProperty(node,"_claimRuntimeV1",{configurable:true,value:()=>undefined});}catch{window.__takeoverAttack.replacementBlocked=true;}try{Object.defineProperty(document,"currentScript",{configurable:true,value:node});window.__takeoverAttack.currentScriptShadowed=document.currentScript===node;}catch{}window.__takeoverAttack.claimExposed||=original(node)!==undefined;try{const retainedTarget=window.tsjs;Object.defineProperty(window,"tsjs",{configurable:true,get(){window.__takeoverAttack.claimExposed||=original(node)!==undefined;return retainedTarget;}});}catch{window.__takeoverAttack.namespaceReplacementBlocked=true;}}}});__takeoverObserver.observe(document,{childList:true,subtree:true});${deferredRegistrationAttack}window.__gptDiagnosticsStub.emitRequestStartOnDisplay();const __TSJS_SERVER_BOOT_TRANSPORT_V1__=${serverBootTransportLiteralV1(FIRST_DISPLAY_FIXTURE.boot, FIRST_DISPLAY_FIXTURE.outline)};${FIRST_DISPLAY_FIXTURE.bootstrapBody}</script></head><body><div id="${FIRST_DISPLAY_SLOT}"></div><script src="${FIRST_DISPLAY_FIXTURE.firstDisplaySrc}" id="trustedserver-js"></script><script>window.__firstDisplayParserObservation={async:document.querySelector("script#trustedserver-js").async,defer:document.querySelector("script#trustedserver-js").defer,firstAction:performance.getEntriesByName("tsjs:first-display","mark").length};window.__gptDiagnosticsStub.emit("slotRenderEnded",${JSON.stringify(FIRST_DISPLAY_SLOT)},{isEmpty:true,responseIdentifier:"fictional-empty-gam"});</script></body></html>`,
+      }),
+    );
+
+    await page.goto("https://runtime.test/first-display-owner");
+    await expect
+      .poll(() =>
+        page.evaluate(
+          () =>
+            performance.getEntriesByName("tsjs:first-display-paint", "mark")
+              .length,
+        ),
+      )
+      .toBe(1);
+    await expect
+      .poll(() =>
+        page.evaluate(
+          () =>
+            (
+              window as unknown as {
+                tsjs?: { _internal?: { state?: string } };
+              }
+            ).tsjs?._internal?.state,
+        ),
+      )
+      .toMatch(/^(?:kernel|fallback)$/u);
+    const runtimeDiagnostic = await page.evaluate(() => ({
+      internal: (
+        window as unknown as {
+          tsjs?: { _internal?: unknown };
+        }
+      ).tsjs?._internal,
+      marks: performance
+        .getEntriesByType("mark")
+        .map((entry) => ({ name: entry.name, startTime: entry.startTime })),
+      frames: [...document.querySelectorAll("iframe")].map((frame) => ({
+        connected: frame.isConnected,
+        parent: frame.parentElement?.id ?? null,
+        title: frame.title,
+      })),
+    }));
+    expect(
+      runtimeDiagnostic.internal,
+      JSON.stringify({
+        ...runtimeDiagnostic,
+        allRequests,
+        consoleMessages,
+        firstDisplayRequests,
+        pageErrors,
+      }),
+    ).toMatchObject({ state: "kernel" });
+    await expect
+      .poll(() => [...allRequests])
+      .toEqual([
+        "https://runtime.test/first-display-owner",
+        firstDisplayUrl,
+        runtimeUrl,
+        ...deferredUrls,
+      ]);
+    await expect
+      .poll(() =>
+        page.evaluate(
+          () =>
+            (
+              window as unknown as {
+                __deferredRegistrationAttack: { attempted: boolean };
+              }
+            ).__deferredRegistrationAttack.attempted,
+        ),
+      )
+      .toBe(true);
+
+    const observation = await page.evaluate((slotId) => {
+      const browserWindow = window as unknown as {
+        __firstDisplayParserObservation: {
+          async: boolean;
+          defer: boolean;
+          firstAction: number;
+        };
+        __firstDisplayResourceProbe(): Array<{
+          kind: string;
+          beforePaint: boolean;
+        }>;
+      };
+      return {
+        deferredRegistrationAttack: (
+          browserWindow as unknown as {
+            __deferredRegistrationAttack: Readonly<{
+              attempted: boolean;
+              prepareCalled: boolean;
+              registrationAccepted: boolean;
+            }>;
+          }
+        ).__deferredRegistrationAttack,
+        takeoverAttack: (
+          browserWindow as unknown as {
+            __takeoverAttack: Readonly<{
+              claimExposed: boolean;
+              currentScriptShadowed: boolean;
+              namespaceReplacementBlocked: boolean;
+              replacementBlocked: boolean;
+            }>;
+          }
+        ).__takeoverAttack,
+        parser: browserWindow.__firstDisplayParserObservation,
+        loaderCallsBeforePaint: browserWindow
+          .__firstDisplayResourceProbe()
+          .filter((entry) => entry.beforePaint)
+          .map((entry) => entry.kind),
+        loaderCallsAfterPaint: browserWindow
+          .__firstDisplayResourceProbe()
+          .filter((entry) => !entry.beforePaint)
+          .map((entry) => entry.kind),
+        firstDisplayScripts: document.querySelectorAll(
+          "script#trustedserver-js",
+        ).length,
+        creativeFrames: document.querySelectorAll(
+          `#${slotId} > iframe[title="Ad content"]`,
+        ).length,
+        tracePanels: document.querySelectorAll("#ts-render-trace-panel").length,
+        diagnosticRequests: (
+          window as unknown as {
+            tsjs: {
+              diagnostics: {
+                gpt: {
+                  snapshot(): {
+                    slots: Array<{
+                      slotElementId?: string;
+                      requests: Array<Record<string, unknown>>;
+                    }>;
+                  };
+                };
+              };
+            };
+          }
+        ).tsjs.diagnostics.gpt
+          .snapshot()
+          .slots.find((slot) => slot.slotElementId === slotId)?.requests,
+      };
+    }, FIRST_DISPLAY_SLOT);
+
+    expect(firstDisplayRequests).toEqual([firstDisplayUrl]);
+    expect(
+      allRequests.filter((url) => /tsjs-render_owner_initial/u.test(url)),
+    ).toEqual([]);
+    expect(observation.parser).toEqual({
+      async: false,
+      defer: false,
+      firstAction: 1,
+    });
+    expect(observation.takeoverAttack).toEqual({
+      claimExposed: false,
+      currentScriptShadowed: true,
+      namespaceReplacementBlocked: true,
+      replacementBlocked: true,
+    });
+    expect(observation.deferredRegistrationAttack).toEqual({
+      attempted: true,
+      prepareCalled: false,
+      registrationAccepted: false,
+    });
+    expect(observation.loaderCallsBeforePaint).toEqual([]);
+    expect(observation.loaderCallsAfterPaint).toEqual([
+      "create:script",
+      "create:script",
+    ]);
+    expect(observation.firstDisplayScripts).toBe(1);
+    expect(observation.creativeFrames).toBe(1);
+    expect(observation.tracePanels).toBe(1);
+    expect(observation.diagnosticRequests).toEqual([
+      expect.objectContaining({
+        isEmpty: true,
+        requestedSlotSizes: [[300, 250]],
+        trustedServerAuctionId: "browser-first-display-owner",
+        trustedServerOpportunity: "renderable_candidate",
+      }),
+    ]);
+  });
+
+  test("generated bootstrap transfers one direct-runtime watchdog to the persistent owner", async ({
+    page,
+  }) => {
+    const runtimeRequests: string[] = [];
+    const runtimeUrl = new URL(
+      KERNEL_FIXTURE.runtimeSrc,
+      "https://runtime.test",
+    ).toString();
+    await page.route(runtimeUrl, (route) => {
+      runtimeRequests.push(route.request().url());
+      return route.fulfill({
+        status: 200,
+        contentType: "application/javascript; charset=utf-8",
+        headers: { "x-content-type-options": "nosniff" },
+        body: `queueMicrotask(()=>window.__runtimeOrder.push("publisher-microtask"));${KERNEL_FIXTURE.runtimeBody}`,
+      });
+    });
+    await page.route("https://runtime.test/direct", (route) =>
+      route.fulfill({
+        status: 200,
+        contentType: "text/html; charset=utf-8",
+        body: `<!doctype html><head><script>window.__runtimeOrder=[];window.tsjs={que:[()=>window.__runtimeOrder.push("kernel-commit")]};const __TSJS_SERVER_BOOT_TRANSPORT_V1__=${serverBootTransportLiteralV1(boot(KERNEL_FIXTURE))};${KERNEL_FIXTURE.bootstrapBody}</script><script src="${KERNEL_FIXTURE.runtimeSrc}" id="trustedserver-js"></script><script>window.__runtimeOrder.push("publisher-parser:"+window.tsjs?._internal?.state)</script></head><body></body>`,
+      }),
+    );
+
+    await page.goto("https://runtime.test/direct");
+    await waitForRuntime(page, "kernel");
+
+    const observation = await page.evaluate(() => ({
+      claimPresent: Object.prototype.hasOwnProperty.call(
+        (window as unknown as { tsjs: object }).tsjs,
+        "_claimDirectRuntime",
+      ),
+      runtimeScripts: document.querySelectorAll("script#trustedserver-js")
+        .length,
+      bidsMarks: performance.getEntriesByName("tsjs:bids-script", "mark")
+        .length,
+      order: (
+        window as unknown as { __runtimeOrder: string[] }
+      ).__runtimeOrder.slice(),
+      state: (window as unknown as { tsjs: { _internal: { state: string } } })
+        .tsjs._internal.state,
+    }));
+
+    expect(runtimeRequests).toEqual([runtimeUrl]);
+    expect(observation).toEqual({
+      claimPresent: false,
+      runtimeScripts: 1,
+      bidsMarks: 1,
+      order: [
+        "kernel-commit",
+        "publisher-microtask",
+        "publisher-parser:kernel",
+      ],
+      state: "kernel",
+    });
+  });
+
+  test("publishes only the kernel API and drains a hostile preload queue once", async ({
+    page,
+  }) => {
+    await openRuntimePage(page);
+    await page.evaluate((initialBoot) => {
+      const browserWindow = window as unknown as {
+        queueOrder: string[];
+        tsjs: Record<string, unknown> & { que: Array<() => void> };
+      };
+      browserWindow.queueOrder = [];
+      const que = [
+        () => {
+          browserWindow.queueOrder.push("first");
+          browserWindow.tsjs.que.push(() =>
+            browserWindow.queueOrder.push("nested"),
+          );
+        },
+        () => {
+          browserWindow.queueOrder.push("throw");
+          throw new Error("publisher callback failure");
+        },
+        () => browserWindow.queueOrder.push("last"),
+      ];
+      browserWindow.tsjs = {
+        boot: initialBoot,
+        que,
+        bids: { legacy: true },
+        renderAdUnit() {},
+        renderAllAdUnits() {},
+        setConfig() {},
+        getConfig() {},
+      };
+    }, boot(KERNEL_FIXTURE));
+
+    await loadRuntimeTsjsFixture(page, KERNEL_FIXTURE);
+    await waitForRuntime(page, "kernel");
+
+    const state = await page.evaluate(() => {
+      const api = (window as unknown as { tsjs: Record<string, unknown> }).tsjs;
+      return {
+        names: Object.getOwnPropertyNames(api).sort(),
+        queueOrder: (
+          window as unknown as { queueOrder: string[] }
+        ).queueOrder.slice(),
+        queueFrozen: Object.isFrozen(api.que),
+        bootFrozen: Object.isFrozen(api.boot),
+        releaseId: api.releaseId,
+        legacy: [
+          "bids",
+          "renderAdUnit",
+          "renderAllAdUnits",
+          "setConfig",
+          "getConfig",
+          "adInit",
+          "renders",
+          "gptDiagnostics",
+        ].filter((name) => Object.prototype.hasOwnProperty.call(api, name)),
+      };
+    });
+
+    expect(state.names).toEqual([
+      "_internal",
+      "_registerIntegration",
+      "addAdUnits",
+      "boot",
+      "diagnostics",
+      "log",
+      "que",
+      "releaseId",
+      "requestAds",
+      "version",
+    ]);
+    expect(state.queueOrder).toEqual(
+      expect.arrayContaining(["first", "nested", "throw", "last"]),
+    );
+    expect(new Set(state.queueOrder).size).toBe(4);
+    expect(state.queueFrozen).toBe(true);
+    expect(state.bootFrozen).toBe(true);
+    expect(state.releaseId).toBe(KERNEL_FIXTURE.releaseId);
+    expect(state.legacy).toEqual([]);
+  });
+
+  test("terminal fallback cannot be revived by a late integration bundle", async ({
+    page,
+  }) => {
+    await openRuntimePage(page);
+    await page.evaluate((initialBoot) => {
+      const browserWindow = window as unknown as {
+        tsjs: Record<string, unknown>;
+        fallbackEffects: { messageListeners: number; timeouts: number };
+      };
+      browserWindow.fallbackEffects = { messageListeners: 0, timeouts: 0 };
+      const nativeAddEventListener = window.addEventListener.bind(window);
+      window.addEventListener = ((
+        type: string,
+        listener: EventListenerOrEventListenerObject,
+      ) => {
+        if (type === "message")
+          browserWindow.fallbackEffects.messageListeners += 1;
+        nativeAddEventListener(type, listener);
+      }) as typeof window.addEventListener;
+      const nativeSetTimeout = window.setTimeout.bind(window);
+      window.setTimeout = ((handler: TimerHandler, timeout?: number) => {
+        browserWindow.fallbackEffects.timeouts += 1;
+        return nativeSetTimeout(handler, timeout);
+      }) as typeof window.setTimeout;
+      browserWindow.tsjs = {
+        boot: initialBoot,
+        que: [],
+      };
+    }, boot(FALLBACK_FIXTURE));
+
+    await loadRuntimeTsjsFixture(page, FALLBACK_FIXTURE);
+    await waitForRuntime(page, "fallback");
+    const before = await page.evaluate(() => ({
+      effects: {
+        ...(
+          window as unknown as {
+            fallbackEffects: { messageListeners: number; timeouts: number };
+          }
+        ).fallbackEffects,
+      },
+      names: Object.getOwnPropertyNames(
+        (window as unknown as { tsjs: object }).tsjs,
+      ).sort(),
+    }));
+
+    await page.addScriptTag({
+      content: "window.tsjs._registerIntegration({});",
+    });
+    await page.evaluate(() => {
+      window.dispatchEvent(
+        new MessageEvent("message", { data: { message: "Prebid Request" } }),
+      );
+    });
+    await page.waitForTimeout(25);
+
+    const after = await page.evaluate(() => {
+      const browserWindow = window as unknown as {
+        tsjs: {
+          _internal: { state: string; reason: string };
+          _registerIntegration(value: unknown): boolean;
+        };
+        fallbackEffects: { messageListeners: number; timeouts: number };
+        googletag?: unknown;
+      };
+      return {
+        internal: browserWindow.tsjs._internal,
+        registrationAccepted: browserWindow.tsjs._registerIntegration({}),
+        effects: { ...browserWindow.fallbackEffects },
+        frames: document.querySelectorAll("iframe").length,
+        scripts: document.querySelectorAll("script").length,
+        hasGoogletag: Object.prototype.hasOwnProperty.call(window, "googletag"),
+      };
+    });
+
+    expect(before.names).toEqual([
+      "_internal",
+      "_registerIntegration",
+      "addAdUnits",
+      "boot",
+      "log",
+      "que",
+      "releaseId",
+      "requestAds",
+      "version",
+    ]);
+    expect(after.internal).toMatchObject({
+      state: "fallback",
+      reason: "abi_mismatch",
+    });
+    expect(after.registrationAccepted).toBe(false);
+    expect(after.effects.messageListeners).toBe(
+      before.effects.messageListeners,
+    );
+    expect(after.effects.timeouts).toBe(before.effects.timeouts);
+    expect(after.frames).toBe(0);
+    expect(after.scripts).toBe(3);
+    expect(after.hasGoogletag).toBe(false);
+  });
+});
diff --git a/crates/trusted-server-integration-tests/fixtures/cloudflare/aps-runner-proxy-service.js b/crates/trusted-server-integration-tests/fixtures/cloudflare/aps-runner-proxy-service.js
new file mode 100644
index 000000000..c2558deba
--- /dev/null
+++ b/crates/trusted-server-integration-tests/fixtures/cloudflare/aps-runner-proxy-service.js
@@ -0,0 +1,35 @@
+const APS_RUNNER_URL =
+  "https://client.aps.amazon-adsystem.com/prebid-creative.js";
+const FORBIDDEN_HEADERS = [
+  "authorization",
+  "cookie",
+  "forwarded",
+  "referer",
+  "x-forwarded-for",
+  "x-publisher-secret",
+];
+
+export default {
+  async fetch(request, environment) {
+    const logicalUrl = request.headers.get("x-ts-aps-logical-url");
+    const invalidRequest =
+      request.method !== "GET" ||
+      request.url !== APS_RUNNER_URL ||
+      request.headers.get("accept-encoding") !== "identity" ||
+      logicalUrl !== APS_RUNNER_URL ||
+      FORBIDDEN_HEADERS.some((name) => request.headers.has(name));
+
+    if (invalidRequest) {
+      return new Response(null, { status: 500 });
+    }
+
+    const headers = new Headers();
+    headers.set("accept-encoding", "identity");
+    headers.set("x-ts-aps-logical-url", logicalUrl);
+    return fetch(environment.APS_RUNNER_PROXY_TEST_ENDPOINT, {
+      method: "GET",
+      headers,
+      redirect: "manual",
+    });
+  },
+};
diff --git a/crates/trusted-server-integration-tests/fixtures/configs/aps-real-gam.template.toml b/crates/trusted-server-integration-tests/fixtures/configs/aps-real-gam.template.toml
new file mode 100644
index 000000000..f9e51ed82
--- /dev/null
+++ b/crates/trusted-server-integration-tests/fixtures/configs/aps-real-gam.template.toml
@@ -0,0 +1,54 @@
+# Contract template for the protected real-GAM page. Values are deliberately
+# fictional placeholders; actual GAM, APS, Prebid, PUC, URL, and authorization
+# configuration exists only in the protected `aps-real-gam` environment.
+schema_version = 1
+browser_contract_global = "__tsRealGamTestNetwork"
+expected_external_puc_release = "1.17.2"
+
+[environment]
+page_url = "__PROTECTED_HTTPS_PAGE_URL__"
+authorization_header = "__PROTECTED_AUTHORIZATION_VALUE__"
+expected_release_id = "__DEPLOYED_TSJS_RELEASE_ID__"
+
+[page_contract]
+version = 1
+case_root_attribute = "data-ts-real-gam-case"
+terminal_state_attribute = "data-ts-real-gam-state"
+terminal_state_value = "terminal"
+slot_attribute = "data-ts-real-gam-slot"
+puc_owner_attribute = "data-ts-real-gam-owner" # value is the case id
+owned_frame_attribute = "data-ts-real-gam-owned-frame" # value is the case id
+screenshot_secret_mask_attribute = "data-ts-real-gam-secret"
+
+case_ids = [
+  "ssat-aps-puc",
+  "trusted-server-prebid-aps-puc",
+  "page-bids-aps-puc",
+  "direct-aps",
+  "direct-adm",
+  "direct-cache",
+  "attributable-empty-gam-fallback",
+  "sra-aps-puc",
+  "refresh-aps-puc",
+  "spa-navigation",
+  "gpt-handoff",
+  "hydrated-dom-replacement",
+  "collapsed-shell-resize",
+  "wrong-id",
+  "wrong-source",
+  "invalid-descriptor",
+  "no-outer-claim",
+  "no-owner-registration",
+  "no-document-ack",
+  "aps-runner-failure",
+]
+
+[evidence]
+capture_response_bodies = false
+capture_request_headers = false
+capture_response_headers = false
+capture_post_data = false
+capture_native_trace = false
+capture_har = false
+capture_video = false
+sanitized_trace_directory = "real-gam-evidence"
diff --git a/crates/trusted-server-integration-tests/fixtures/configs/cloudflare-aps-runner-proxy-fixture.toml b/crates/trusted-server-integration-tests/fixtures/configs/cloudflare-aps-runner-proxy-fixture.toml
new file mode 100644
index 000000000..2abfc29d8
--- /dev/null
+++ b/crates/trusted-server-integration-tests/fixtures/configs/cloudflare-aps-runner-proxy-fixture.toml
@@ -0,0 +1,7 @@
+name = "aps-runner-proxy-fixture"
+main = "../cloudflare/aps-runner-proxy-service.js"
+compatibility_date = "2024-09-23"
+
+[vars]
+# Replaced in a temporary copy by the integration-test controller.
+APS_RUNNER_PROXY_TEST_ENDPOINT = "__APS_RUNNER_PROXY_TEST_ENDPOINT__"
diff --git a/crates/trusted-server-integration-tests/fixtures/configs/spin-aps-runner-proxy.toml b/crates/trusted-server-integration-tests/fixtures/configs/spin-aps-runner-proxy.toml
new file mode 100644
index 000000000..2bded070a
--- /dev/null
+++ b/crates/trusted-server-integration-tests/fixtures/configs/spin-aps-runner-proxy.toml
@@ -0,0 +1,32 @@
+spin_manifest_version = 2
+
+[application]
+name = "trusted-server-aps-runner-proxy-integration"
+version = "0.1.0"
+
+[variables]
+v_trusted_x5fserver_x5fconfig = { required = true }
+aps_runner_proxy_test_endpoint = { required = true }
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fadmin_x5fpassword = { required = true, secret = true }
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fproxy_x5fsecret = { required = true, secret = true }
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fec_x5fpassphrase = { required = true, secret = true }
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5falpha = { required = true, secret = true }
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5fbravo = { required = true, secret = true }
+
+[[trigger.http]]
+route = "/..."
+component = "trusted-server"
+
+[component.trusted-server]
+source = "__APS_RUNNER_PROXY_WASM__"
+allowed_outbound_hosts = ["http://127.0.0.1:*"]
+key_value_stores = ["default"]
+
+[component.trusted-server.variables]
+v_trusted_x5fserver_x5fconfig = "{{ v_trusted_x5fserver_x5fconfig }}"
+aps_runner_proxy_test_endpoint = "{{ aps_runner_proxy_test_endpoint }}"
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fadmin_x5fpassword = "{{ v_trusted_x5fserver_x5fsecrets_v_integration_x5fadmin_x5fpassword }}"
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fproxy_x5fsecret = "{{ v_trusted_x5fserver_x5fsecrets_v_integration_x5fproxy_x5fsecret }}"
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fec_x5fpassphrase = "{{ v_trusted_x5fserver_x5fsecrets_v_integration_x5fec_x5fpassphrase }}"
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5falpha = "{{ v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5falpha }}"
+v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5fbravo = "{{ v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5fbravo }}"
diff --git a/crates/trusted-server-integration-tests/fixtures/configs/trusted-server.integration.toml b/crates/trusted-server-integration-tests/fixtures/configs/trusted-server.integration.toml
index dae3f57cc..0cc3def6f 100644
--- a/crates/trusted-server-integration-tests/fixtures/configs/trusted-server.integration.toml
+++ b/crates/trusted-server-integration-tests/fixtures/configs/trusted-server.integration.toml
@@ -83,10 +83,8 @@ cache_ttl_seconds = 3600
 rewrite_sdk = true
 
 [integrations.gpt]
-enabled = false
-gam_attribution_enabled = false
+enabled = true
 script_url = "https://ads.example.com/gpt.js"
-cache_ttl_seconds = 3600
 rewrite_script = true
 
 [integrations.gpt_diagnostics]
diff --git a/crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs b/crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs
new file mode 100644
index 000000000..8b218a4f4
--- /dev/null
+++ b/crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs
@@ -0,0 +1,199 @@
+use std::env;
+use std::error::Error;
+use std::fs;
+use std::io::Write as _;
+use std::path::PathBuf;
+
+use trusted_server_core::tsjs::{CreativeBootConfigV1, tsjs_bootstrap_fixture_fragment_v1};
+
+type DynError = Box<dyn Error + Send + Sync + 'static>;
+const PERFORMANCE_ORIGIN: &str = "https://performance.example";
+
+#[derive(Debug, Eq, PartialEq)]
+struct Args {
+    ids: Vec<String>,
+    projection: PathBuf,
+}
+
+fn main() -> Result<(), DynError> {
+    let args = parse_args(env::args().skip(1))?;
+    let html = run(&args)?;
+    let stdout = std::io::stdout();
+    let mut output = stdout.lock();
+    output.write_all(html.as_bytes())?;
+    Ok(())
+}
+
+fn run(args: &Args) -> Result<String, DynError> {
+    let projection = fs::read_to_string(&args.projection).map_err(|error| {
+        error_box(format!(
+            "failed to read production projection '{}': {error}",
+            args.projection.display()
+        ))
+    })?;
+    let ids = args.ids.iter().map(String::as_str).collect::<Vec<_>>();
+    let controller = tsjs_bootstrap_fixture_fragment_v1(
+        &ids,
+        &projection,
+        CreativeBootConfigV1 {
+            enabled: true,
+            click_guard: ids.contains(&"creative"),
+            render_guard: false,
+        },
+        true,
+        false,
+        PERFORMANCE_ORIGIN,
+    )
+    .map_err(|error| {
+        error_box(format!(
+            "failed to build production TSJS fixture: {error:?}"
+        ))
+    })?;
+    Ok(format!(
+        "<!doctype html><html><head>{controller}</head><body><div id=\"perf-slot\"></div></body></html>"
+    ))
+}
+
+fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Args, DynError> {
+    let mut ids = None;
+    let mut projection = None;
+    let mut iter = args.into_iter();
+    while let Some(argument) = iter.next() {
+        match argument.as_str() {
+            "--ids" => ids = Some(next_string_arg(&mut iter, "--ids")?),
+            "--projection" => {
+                projection = Some(PathBuf::from(next_string_arg(&mut iter, "--projection")?));
+            }
+            "--help" | "-h" => return Err(error_box(usage())),
+            other => {
+                return Err(error_box(format!(
+                    "unknown argument '{other}'\n\n{}",
+                    usage()
+                )));
+            }
+        }
+    }
+
+    let ids = ids
+        .ok_or_else(|| error_box(format!("missing --ids\n\n{}", usage())))?
+        .split(',')
+        .map(ToOwned::to_owned)
+        .collect::<Vec<_>>();
+    if ids.iter().any(String::is_empty) {
+        return Err(error_box(
+            "--ids must be one comma-separated non-empty list",
+        ));
+    }
+    Ok(Args {
+        ids,
+        projection: projection
+            .ok_or_else(|| error_box(format!("missing --projection\n\n{}", usage())))?,
+    })
+}
+
+fn next_string_arg(
+    iter: &mut impl Iterator<Item = String>,
+    flag: &'static str,
+) -> Result<String, DynError> {
+    iter.next()
+        .ok_or_else(|| error_box(format!("{flag} requires a value")))
+}
+
+fn usage() -> String {
+    "usage: generate-tsjs-fixture --projection <path> --ids <comma-separated-integration-ids>"
+        .to_string()
+}
+
+fn error_box(message: impl Into<String>) -> DynError {
+    std::io::Error::other(message.into()).into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+
+    const CANONICAL_PROJECTION: &str = r#"{
+  "version": 1,
+  "auction": {
+    "version": 1,
+    "auctionId": "performance-initial",
+    "results": [{
+      "slot": "perf-slot",
+      "outcome": "winner",
+      "candidateId": "AAAAAAAAAAAA"
+    }]
+  },
+  "slots": [{
+    "slot": "perf-slot",
+    "gamUnitPath": "/123/performance",
+    "divId": "perf-slot",
+    "formats": [[300, 250]],
+    "targeting": {}
+  }],
+  "bids": [{
+    "candidateId": "AAAAAAAAAAAA",
+    "slot": "perf-slot",
+    "provider": "trusted",
+    "upstreamBidId": "performance-upstream",
+    "cpm": 1,
+    "currency": "USD",
+    "targeting": {"hb_bidder": "trusted"},
+    "rendererReservationId": "r1_aaaaaaaaaaaaaaaaaaaaaa",
+    "renderSource": {
+      "type": "adm",
+      "version": 1,
+      "adm": "<main>fictional performance creative</main>",
+      "width": 300,
+      "height": 250
+    }
+  }]
+}"#;
+
+    #[test]
+    fn fixture_uses_the_size_admitted_agent_before_the_post_paint_runtime() {
+        let mut projection = NamedTempFile::new().expect("should create canonical projection");
+        projection
+            .write_all(CANONICAL_PROJECTION.as_bytes())
+            .expect("should write canonical projection");
+        let args = Args {
+            ids: vec![
+                "render_runtime".to_string(),
+                "creative".to_string(),
+                "gpt".to_string(),
+                "diagnostics_presentation".to_string(),
+                "gpt_later".to_string(),
+            ],
+            projection: projection.path().to_path_buf(),
+        };
+        let html = run(&args).expect("should serialize an production TSJS fixture");
+
+        assert!(html.contains(r#"id="perf-slot""#));
+        assert!(html.contains(
+            r#"\"creative\":{\"version\":1,\"enabled\":true,\"clickGuard\":true,\"renderGuard\":false}"#
+        ));
+        assert!(html.contains(r#"\"renderTraceOverlay\":true"#));
+        assert!(html.contains(
+            r#"{\"id\":\"gpt\",\"config\":{\"gamAttributionEnabled\":false,\"pageBidsEnabled\":true}}"#
+        ));
+        assert!(html.contains(r#"\"id\":\"diagnostics_presentation\",\"phase\":\"deferred\""#));
+        assert!(html.contains(r#"\"id\":\"gpt_later\",\"phase\":\"deferred\""#));
+        assert!(html.contains(
+            r#"\"firstDisplay\":{\"src\":\"/static/tsjs=tsjs-first-display.min.js?m=008b\u0026v="#
+        ));
+        assert!(html.contains(
+            r#"\"slices\":[\"first_display\",\"render_owner_initial\",\"creative_initial\",\"gpt_initial\"]"#
+        ));
+        assert!(html.contains(r#"\"runtimeSrc\":\"/static/tsjs=tsjs-unified.min.js?v="#));
+        assert_eq!(html.matches("<script").count(), 2);
+        assert!(html.contains(r#"<script src="/static/tsjs=tsjs-first-display.min.js?m=008b&v="#));
+        assert!(!html.contains(r#"<script src="/static/tsjs=tsjs-unified.min.js"#));
+        assert!(!html.contains(r#"<script src="/static/tsjs=tsjs-gpt_later"#));
+    }
+
+    #[test]
+    fn projection_and_ids_are_required() {
+        assert!(parse_args(["--ids".to_string(), "gpt".to_string()]).is_err());
+        assert!(parse_args(["--projection".to_string(), "fixture.json".to_string()]).is_err());
+    }
+}
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 58c26736e..43a1d72d6 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
@@ -17,6 +17,7 @@ struct Args {
     app_config: PathBuf,
     output: PathBuf,
     origin_url: Option<String>,
+    enable_auction: bool,
 }
 
 fn main() -> Result<(), DynError> {
@@ -37,7 +38,8 @@ fn run(args: &Args) -> Result<(), DynError> {
         ))
     })?;
 
-    let envelope_json = build_app_config_envelope(&app_config, args.origin_url.as_deref())?;
+    let envelope_json =
+        build_app_config_envelope(&app_config, args.origin_url.as_deref(), args.enable_auction)?;
     let generated_config = inject_generated_config_stores(&template, &envelope_json)?;
 
     if let Some(parent) = args.output.parent() {
@@ -63,6 +65,7 @@ fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Args, DynError>
     let mut app_config = None;
     let mut output = None;
     let mut origin_url = None;
+    let mut enable_auction = false;
 
     let mut iter = args.into_iter();
     while let Some(arg) = iter.next() {
@@ -71,6 +74,7 @@ fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Args, DynError>
             "--app-config" => app_config = Some(next_path_arg(&mut iter, "--app-config")?),
             "--output" => output = Some(next_path_arg(&mut iter, "--output")?),
             "--origin-url" => origin_url = Some(next_string_arg(&mut iter, "--origin-url")?),
+            "--enable-auction" => enable_auction = true,
             "--help" | "-h" => return Err(error_box(usage())),
             other => {
                 return Err(error_box(format!(
@@ -88,6 +92,7 @@ fn parse_args(args: impl IntoIterator<Item = String>) -> Result<Args, DynError>
             .ok_or_else(|| error_box(format!("missing --app-config\n\n{}", usage())))?,
         output: output.ok_or_else(|| error_box(format!("missing --output\n\n{}", usage())))?,
         origin_url,
+        enable_auction,
     })
 }
 
@@ -107,12 +112,13 @@ fn next_string_arg(
 }
 
 fn usage() -> String {
-    "usage: generate-viceroy-config --template <path> --app-config <path> --output <path> [--origin-url <url>]".to_string()
+    "usage: generate-viceroy-config --template <path> --app-config <path> --output <path> [--origin-url <url>] [--enable-auction]".to_string()
 }
 
 fn build_app_config_envelope(
     app_config_toml: &str,
     origin_url: Option<&str>,
+    enable_auction: bool,
 ) -> Result<String, DynError> {
     let app_config: TrustedServerAppConfig = toml::from_str(app_config_toml)
         .map_err(|error| error_box(format!("invalid Trusted Server app config: {error}")))?;
@@ -120,6 +126,9 @@ fn build_app_config_envelope(
     if let Some(origin_url) = origin_url {
         settings.publisher.origin_url = origin_url.to_string();
     }
+    if enable_auction {
+        settings.auction.enabled = true;
+    }
     let app_config = TrustedServerAppConfig::new(settings)
         .map_err(|report| error_box(format!("invalid Trusted Server app config: {report:?}")))?;
 
@@ -264,15 +273,50 @@ mod tests {
                 template: PathBuf::from("template.toml"),
                 app_config: PathBuf::from("trusted-server.toml"),
                 output: PathBuf::from("generated.toml"),
-                origin_url: Some("http://127.0.0.1:9999".to_string())
+                origin_url: Some("http://127.0.0.1:9999".to_string()),
+                enable_auction: false,
             },
             "should parse expected args"
         );
     }
 
+    #[test]
+    fn browser_generation_can_enable_the_configured_auction_plan() {
+        let args = parse_args([
+            "--template".to_string(),
+            "template.toml".to_string(),
+            "--app-config".to_string(),
+            "trusted-server.toml".to_string(),
+            "--output".to_string(),
+            "generated.toml".to_string(),
+            "--enable-auction".to_string(),
+        ])
+        .expect("should parse browser auction opt-in");
+        assert!(args.enable_auction);
+
+        let envelope = build_app_config_envelope(APP_CONFIG, None, true)
+            .expect("should build browser envelope");
+        let settings = settings_from_config_blob(
+            &envelope,
+            &integration_secret_store(),
+            &StoreName::from("trusted_server_secrets"),
+        )
+        .expect("should verify browser envelope");
+
+        assert!(settings.auction.enabled);
+        assert!(
+            settings
+                .auction
+                .providers
+                .values()
+                .any(|provider| provider.profile == "aps")
+        );
+    }
+
     #[test]
     fn generated_config_contains_blob_without_removed_rollout_flags() {
-        let envelope = build_app_config_envelope(APP_CONFIG, None).expect("should build envelope");
+        let envelope =
+            build_app_config_envelope(APP_CONFIG, None, false).expect("should build envelope");
         let generated = inject_generated_config_stores(TEMPLATE, &envelope)
             .expect("should inject generated stores");
 
@@ -296,7 +340,8 @@ mod tests {
 
     #[test]
     fn generated_config_is_valid_toml() {
-        let envelope = build_app_config_envelope(APP_CONFIG, None).expect("should build envelope");
+        let envelope =
+            build_app_config_envelope(APP_CONFIG, None, false).expect("should build envelope");
         let generated = inject_generated_config_stores(TEMPLATE, &envelope)
             .expect("should inject generated stores");
         let parsed: toml::Value = toml::from_str(&generated).expect("should parse as TOML");
@@ -312,7 +357,7 @@ mod tests {
 
     #[test]
     fn generated_blob_verifies_and_applies_origin_override() {
-        let envelope = build_app_config_envelope(APP_CONFIG, Some("http://127.0.0.1:9999"))
+        let envelope = build_app_config_envelope(APP_CONFIG, Some("http://127.0.0.1:9999"), false)
             .expect("should build envelope");
         let settings = settings_from_config_blob(
             &envelope,
@@ -329,7 +374,7 @@ mod tests {
 
     #[test]
     fn invalid_app_config_fails() {
-        let result = build_app_config_envelope("not valid toml", None);
+        let result = build_app_config_envelope("not valid toml", None, false);
 
         assert!(result.is_err(), "should reject invalid app config");
     }
@@ -338,7 +383,7 @@ mod tests {
     fn invalid_non_secret_app_config_fails_before_envelope_generation() {
         let invalid = APP_CONFIG.replace("domain = \"localhost\"", "domain = \"invalid/domain\"");
 
-        let err = build_app_config_envelope(&invalid, None)
+        let err = build_app_config_envelope(&invalid, None, false)
             .expect_err("should reject invalid non-secret config before creating an envelope");
 
         assert!(
diff --git a/crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs b/crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs
new file mode 100644
index 000000000..aaa91747a
--- /dev/null
+++ b/crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs
@@ -0,0 +1,707 @@
+#![allow(dead_code, unused_imports)]
+
+mod common;
+mod environments;
+
+use common::aps_runner_upstream::{ApsRunnerUpstream, FictionalResponse, ResponseWrite};
+use common::runtime::{RuntimeEnvironment, wasm_binary_path};
+use environments::spin::SpinRuntime;
+use environments::{axum::AxumDevServer, cloudflare::CloudflareWorkers, fastly::FastlyViceroy};
+use reqwest::blocking::{Client, Response};
+use std::collections::BTreeSet;
+use std::time::{Duration, Instant};
+use trusted_server_core::integrations::aps::{
+    APS_RUNNER_MAX_RESPONSE_BYTES, APS_RUNNER_ROUTE, APS_RUNNER_UPSTREAM_URL,
+};
+
+const SUCCESS_HEADERS: [&str; 5] = [
+    "access-control-allow-origin",
+    "content-type",
+    "cross-origin-resource-policy",
+    "referrer-policy",
+    "x-content-type-options",
+];
+
+// The platform policy owns an exact five-second dispatch-through-final-byte
+// deadline. This black-box clock additionally observes downstream request
+// dispatch, local error serialization, and response delivery, so retain a
+// bounded allowance for work outside the transport window.
+const DOWNSTREAM_DEADLINE_OBSERVATION_ALLOWANCE: Duration = Duration::from_millis(250);
+const RENDERER_V2_PATH: &str = "/integrations/aps/renderer/v2";
+const CLOUDFLARE_READINESS_TIMEOUT: Duration = Duration::from_secs(30);
+const RENDERER_V2_CSP: &str = "default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;";
+const RENDERER_V2_DOCUMENT: &str = include_str!(
+    "../../trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html"
+);
+
+struct CorpusCase {
+    name: &'static str,
+    upstream: FictionalResponse,
+    expected_status: u16,
+    expected_body: Option<Vec<u8>>,
+    maximum_elapsed: Option<Duration>,
+}
+
+impl CorpusCase {
+    fn success(name: &'static str, upstream: FictionalResponse, body: Vec<u8>) -> Self {
+        Self {
+            name,
+            upstream,
+            expected_status: 200,
+            expected_body: Some(body),
+            maximum_elapsed: None,
+        }
+    }
+
+    fn failure(name: &'static str, upstream: FictionalResponse) -> Self {
+        Self {
+            name,
+            upstream,
+            expected_status: 502,
+            expected_body: Some(Vec::new()),
+            maximum_elapsed: None,
+        }
+    }
+
+    fn deadline(name: &'static str, upstream: FictionalResponse) -> Self {
+        Self {
+            maximum_elapsed: Some(
+                Duration::from_secs(5) + DOWNSTREAM_DEADLINE_OBSERVATION_ALLOWANCE,
+            ),
+            ..Self::failure(name, upstream)
+        }
+    }
+}
+
+fn runtime_from_env() -> Box<dyn RuntimeEnvironment> {
+    let runtime = std::env::var("APS_RUNNER_PROXY_RUNTIME")
+        .expect("should select one APS runner-proxy adapter runtime");
+    let environment: Option<Box<dyn RuntimeEnvironment>> = match runtime.as_str() {
+        "axum" => Some(Box::new(AxumDevServer)),
+        "fastly" => Some(Box::new(FastlyViceroy)),
+        "cloudflare" => Some(Box::new(CloudflareWorkers)),
+        "spin" => Some(Box::new(SpinRuntime)),
+        _ => None,
+    };
+    environment.expect("should select a known APS runner-proxy adapter runtime")
+}
+
+fn fixed(status: &str, headers: &[(&str, &str)], body: impl AsRef<[u8]>) -> FictionalResponse {
+    FictionalResponse::fixed(status, headers, body)
+}
+
+fn corpus(runtime_id: &str) -> Vec<CorpusCase> {
+    let exact_body = b"/* fictional runner: \xCE\xBB */".to_vec();
+    let exact_length = exact_body.len().to_string();
+    let cap_body = vec![b'x'; APS_RUNNER_MAX_RESPONSE_BYTES];
+    let cap_length = cap_body.len().to_string();
+    let one_over = vec![b'y'; APS_RUNNER_MAX_RESPONSE_BYTES + 1];
+    let over_declared = (APS_RUNNER_MAX_RESPONSE_BYTES + 1).to_string();
+    let slow_headers = b"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/javascript\r\nTransfer-Encoding: chunked\r\n\r\n".to_vec();
+    let mut slow_writes = vec![ResponseWrite::now(slow_headers)];
+    for _ in 0..6 {
+        slow_writes.push(ResponseWrite::after(
+            Duration::from_millis(900),
+            b"1\r\nx\r\n".to_vec(),
+        ));
+    }
+    slow_writes.push(ResponseWrite::now(b"0\r\n\r\n".to_vec()));
+    let near_deadline_body = vec![b'n'; 24];
+    let near_deadline_headers = format!(
+        "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/javascript\r\nContent-Length: {}\r\n\r\n",
+        near_deadline_body.len()
+    )
+    .into_bytes();
+    let mut near_deadline_writes = vec![ResponseWrite::now(near_deadline_headers)];
+    for byte in &near_deadline_body {
+        near_deadline_writes.push(ResponseWrite::after(
+            Duration::from_millis(195),
+            vec![*byte],
+        ));
+    }
+    let over_total_headers = b"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/javascript\r\nContent-Length: 26\r\n\r\n".to_vec();
+    let mut over_total_writes = vec![ResponseWrite::now(over_total_headers)];
+    for _ in 0..26 {
+        over_total_writes.push(ResponseWrite::after(Duration::from_millis(195), vec![b't']));
+    }
+
+    let mut cases = vec![
+        CorpusCase::success(
+            "byte-preserving JavaScript with identity evidence",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Encoding", "identity"),
+                    ("Content-Length", &exact_length),
+                    ("Set-Cookie", "must-not-reach-browser=1"),
+                    ("X-Fictional-Upstream", "must-be-dropped"),
+                ],
+                &exact_body,
+            ),
+            exact_body,
+        ),
+        CorpusCase::success(
+            "missing length and encoding",
+            fixed(
+                "200 OK",
+                &[("Content-Type", "text/javascript; charset=UTF-8")],
+                b"ok",
+            ),
+            b"ok".to_vec(),
+        ),
+        CorpusCase::failure(
+            "non-200 status",
+            fixed(
+                "204 No Content",
+                &[("Content-Type", "application/javascript")],
+                [],
+            ),
+        ),
+        CorpusCase::failure(
+            "redirect is not followed",
+            fixed(
+                "302 Found",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Location", "https://example.invalid/runner.js"),
+                ],
+                b"redirect body",
+            ),
+        ),
+        CorpusCase::failure(
+            "missing content type",
+            fixed("200 OK", &[], b"ok"),
+        ),
+        CorpusCase::failure(
+            "duplicate content type",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Type", "text/javascript"),
+                ],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "rejected content type",
+            fixed("200 OK", &[("Content-Type", "text/plain")], b"ok"),
+        ),
+        CorpusCase::failure(
+            "unknown content type parameter",
+            fixed(
+                "200 OK",
+                &[("Content-Type", "application/javascript; version=1")],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "listed identity encoding",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Encoding", "identity, gzip"),
+                ],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "non-identity encoding",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Encoding", "gzip"),
+                ],
+                [
+                    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcb, 0xcf,
+                    0x06, 0x00, 0x47, 0xdd, 0xdc, 0x79, 0x02, 0x00, 0x00, 0x00,
+                ],
+            ),
+        ),
+        CorpusCase::failure(
+            "duplicate content length",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", "2"),
+                    ("Content-Length", "2"),
+                ],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "noncanonical content length",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", "02"),
+                ],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "declared length mismatch",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", "3"),
+                ],
+                b"ok",
+            ),
+        ),
+        CorpusCase::failure(
+            "declared length over cap",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", &over_declared),
+                ],
+                [],
+            ),
+        ),
+        CorpusCase::failure(
+            "invalid UTF-8",
+            fixed(
+                "200 OK",
+                &[("Content-Type", "application/javascript")],
+                [0xff, 0xfe],
+            ),
+        ),
+        CorpusCase::success(
+            "exactly at the body cap",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", &cap_length),
+                ],
+                &cap_body,
+            ),
+            cap_body,
+        ),
+        CorpusCase::failure(
+            "buffered body one byte over cap",
+            fixed(
+                "200 OK",
+                &[("Content-Type", "application/javascript")],
+                &one_over,
+            ),
+        ),
+        CorpusCase::failure(
+            "streamed body one byte over cap",
+            FictionalResponse::chunked(
+                "200 OK",
+                &[("Content-Type", "application/javascript")],
+                vec![(Duration::ZERO, one_over)],
+            ),
+        ),
+        CorpusCase::success(
+            "sub-250ms drip completing after 4.5 seconds preserves the full deadline",
+            FictionalResponse::raw(near_deadline_writes),
+            near_deadline_body,
+        ),
+        CorpusCase::deadline(
+            "first-byte stall",
+            FictionalResponse::raw(vec![ResponseWrite::after(
+                Duration::from_millis(5_500),
+                b"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok".to_vec(),
+            )]),
+        ),
+        CorpusCase::deadline(
+            "mid-body stall after partial chunk",
+            FictionalResponse::raw(vec![
+                ResponseWrite::now(
+                    b"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/javascript\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nx\r\n".to_vec(),
+                ),
+                ResponseWrite::after(Duration::from_millis(5_500), b"0\r\n\r\n".to_vec()),
+            ]),
+        ),
+        CorpusCase::deadline(
+            "slow drip exceeds total deadline",
+            FictionalResponse::raw(slow_writes),
+        ),
+        CorpusCase::deadline(
+            "sub-250ms drip exceeds the true total deadline",
+            FictionalResponse::raw(over_total_writes),
+        ),
+        CorpusCase::success(
+            "late bytes cannot contaminate the next request",
+            fixed(
+                "200 OK",
+                &[
+                    ("Content-Type", "application/javascript"),
+                    ("Content-Length", "4"),
+                ],
+                b"next",
+            ),
+            b"next".to_vec(),
+        ),
+    ];
+    if matches!(runtime_id, "cloudflare" | "spin") {
+        cases.insert(
+            cases.len() - 1,
+            CorpusCase {
+                maximum_elapsed: Some(
+                    Duration::from_secs(4) + Duration::from_millis(750),
+                ),
+                ..CorpusCase::failure(
+                    "first-byte timeout is distinct from the total timeout",
+                    FictionalResponse::raw(vec![ResponseWrite::after(
+                        Duration::from_millis(4_500),
+                        b"HTTP/1.1 200 OK\r\nContent-Type: application/javascript\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok".to_vec(),
+                    )]),
+                )
+            },
+        );
+    }
+    if runtime_id == "spin" {
+        cases.insert(
+            cases.len() - 1,
+            CorpusCase {
+                maximum_elapsed: Some(Duration::from_secs(1)),
+                ..CorpusCase::failure(
+                    "Spin between-bytes timeout is distinct from the total timeout",
+                    FictionalResponse::raw(vec![
+                        ResponseWrite::now(
+                            b"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/javascript\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nx\r\n".to_vec(),
+                        ),
+                        ResponseWrite::after(
+                            Duration::from_millis(750),
+                            b"0\r\n\r\n".to_vec(),
+                        ),
+                    ]),
+                )
+            },
+        );
+    }
+    cases
+}
+
+fn assert_outbound_request(
+    runtime_id: &str,
+    case_name: &str,
+    request: &common::aps_runner_upstream::ObservedRequest,
+) {
+    assert_eq!(
+        request.request_line, "GET /prebid-creative.js HTTP/1.1",
+        "{case_name}: fixed upstream path and method"
+    );
+    assert_eq!(
+        request.header_values("accept-encoding"),
+        vec!["identity"],
+        "{case_name}: exact identity request; observed {request:?}"
+    );
+    assert_eq!(
+        request.header_values("x-ts-aps-logical-url"),
+        vec![APS_RUNNER_UPSTREAM_URL],
+        "{case_name}: transport seam must attest the fixed logical URL"
+    );
+    if matches!(runtime_id, "axum" | "fastly") {
+        assert_eq!(
+            request.header_values("host"),
+            vec!["client.aps.amazon-adsystem.com"],
+            "{case_name}: transport must preserve the fixed logical APS authority"
+        );
+    } else {
+        assert_eq!(
+            request.header_values("host").len(),
+            1,
+            "{case_name}: runtime-owned transport authority must be singular"
+        );
+    }
+    for forbidden in [
+        "authorization",
+        "cookie",
+        "forwarded",
+        "referer",
+        "x-forwarded-for",
+        "x-publisher-secret",
+    ] {
+        assert!(
+            request.header_values(forbidden).is_empty(),
+            "{case_name}: `{forbidden}` must not reach the fictional upstream"
+        );
+    }
+}
+
+fn assert_success(case_name: &str, response: &Response) {
+    assert_eq!(
+        response.headers()["content-type"],
+        "application/javascript; charset=utf-8",
+        "{case_name}"
+    );
+    assert_eq!(
+        response.headers()["access-control-allow-origin"],
+        "*",
+        "{case_name}"
+    );
+    assert_eq!(
+        response.headers()["cross-origin-resource-policy"],
+        "cross-origin",
+        "{case_name}"
+    );
+    assert_eq!(response.headers()["x-content-type-options"], "nosniff");
+    assert_eq!(response.headers()["referrer-policy"], "no-referrer");
+    assert!(!response.headers().contains_key("set-cookie"));
+    assert!(!response.headers().contains_key("x-fictional-upstream"));
+    assert!(!response.headers().contains_key("x-geo-info-available"));
+    let semantic_headers: BTreeSet<&str> = response
+        .headers()
+        .keys()
+        .map(reqwest::header::HeaderName::as_str)
+        .filter(|name| {
+            !matches!(
+                *name,
+                "connection" | "content-length" | "date" | "server" | "transfer-encoding"
+            )
+        })
+        .collect();
+    assert_eq!(
+        semantic_headers,
+        BTreeSet::from(SUCCESS_HEADERS),
+        "{case_name}: successful proxy application headers must be exact"
+    );
+}
+
+fn exact_renderer_method_response(response: Response) -> bool {
+    if response.status().as_u16() != 405
+        || response.headers().get_all("allow").iter().count() != 1
+        || response
+            .headers()
+            .get("allow")
+            .is_none_or(|value| value != "GET")
+        || response.headers().get_all("cache-control").iter().count() != 1
+        || response
+            .headers()
+            .get("cache-control")
+            .is_none_or(|value| value != "no-store")
+    {
+        return false;
+    }
+    let semantic_headers: BTreeSet<&str> = response
+        .headers()
+        .keys()
+        .map(reqwest::header::HeaderName::as_str)
+        .filter(|name| {
+            !matches!(
+                *name,
+                "connection" | "content-length" | "date" | "server" | "transfer-encoding"
+            )
+        })
+        .collect();
+    semantic_headers == BTreeSet::from(["allow", "cache-control"])
+        && response.bytes().is_ok_and(|body| body.is_empty())
+}
+
+fn assert_exact_local_failure(response: Response, status: u16, allow_get: bool) {
+    assert_eq!(
+        response.status().as_u16(),
+        status,
+        "unexpected local failure response headers: {:?}",
+        response.headers()
+    );
+    assert_eq!(response.headers()["cache-control"], "no-store");
+    if allow_get {
+        assert_eq!(response.headers()["allow"], "GET");
+    } else {
+        assert!(!response.headers().contains_key("allow"));
+    }
+    let semantic_headers: BTreeSet<&str> = response
+        .headers()
+        .keys()
+        .map(reqwest::header::HeaderName::as_str)
+        .filter(|name| {
+            !matches!(
+                *name,
+                "connection" | "content-length" | "date" | "server" | "transfer-encoding"
+            )
+        })
+        .collect();
+    let expected = if allow_get {
+        BTreeSet::from(["allow", "cache-control"])
+    } else {
+        BTreeSet::from(["cache-control"])
+    };
+    assert_eq!(semantic_headers, expected);
+    assert!(
+        response
+            .bytes()
+            .expect("local failure body should be readable")
+            .is_empty()
+    );
+}
+
+fn wait_for_cloudflare_renderer_readiness(client: &Client, base_url: &str) {
+    let deadline = Instant::now() + CLOUDFLARE_READINESS_TIMEOUT;
+    let mut consecutive = 0_u8;
+    while consecutive < 2 {
+        let exact = client
+            .request(
+                reqwest::Method::from_bytes(b"PROPFIND").expect("PROPFIND should be valid"),
+                format!("{base_url}{RENDERER_V2_PATH}"),
+            )
+            .send()
+            .is_ok_and(exact_renderer_method_response);
+        consecutive = if exact { consecutive + 1 } else { 0 };
+        if consecutive == 2 {
+            return;
+        }
+        assert!(
+            Instant::now() < deadline,
+            "Cloudflare renderer route did not produce two consecutive exact readiness responses"
+        );
+        std::thread::sleep(Duration::from_millis(100));
+    }
+}
+
+#[test]
+#[ignore = "requires a feature-gated adapter artifact and its local runtime"]
+fn actual_adapter_proxy_corpus() {
+    let _ = env_logger::try_init();
+    let fixture = ApsRunnerUpstream::start().expect("should start fictional APS upstream");
+    let runtime = runtime_from_env();
+    let runtime_id = runtime.id();
+    let process = runtime
+        .spawn_aps_runner_proxy(&wasm_binary_path(), &fixture.endpoint_url())
+        .expect("should spawn APS runner proxy artifact");
+    let client = Client::builder()
+        .redirect(reqwest::redirect::Policy::none())
+        // This is only a downstream dead-test guard. Deadline corpus cases
+        // retain their independent five-second transport assertion plus the
+        // bounded black-box observation allowance above.
+        // Leave enough headroom for an 8 MiB boundary response through local
+        // wasm runtimes on a loaded CI worker.
+        .timeout(Duration::from_secs(30))
+        .build()
+        .expect("should build downstream client");
+
+    if runtime_id == "cloudflare" {
+        wait_for_cloudflare_renderer_readiness(&client, &process.base_url);
+    }
+
+    // Independent corpus assertion: readiness never substitutes for endpoint acceptance.
+    let response = client
+        .request(
+            reqwest::Method::from_bytes(b"PROPFIND").expect("PROPFIND should be valid"),
+            format!("{}{}", process.base_url, RENDERER_V2_PATH),
+        )
+        .header("authorization", "Bearer must-not-reach-publisher")
+        .send()
+        .expect("PROPFIND reserved request should complete");
+    assert_exact_local_failure(response, 405, true);
+
+    let renderer = client
+        .get(format!("{}{}", process.base_url, RENDERER_V2_PATH))
+        .send()
+        .expect("renderer request should complete");
+    assert_eq!(renderer.status().as_u16(), 200);
+    assert_eq!(
+        renderer.headers()["content-type"],
+        "text/html; charset=utf-8"
+    );
+    assert_eq!(
+        renderer.headers()["cache-control"],
+        "public, max-age=31536000, immutable"
+    );
+    assert_eq!(renderer.headers()["x-content-type-options"], "nosniff");
+    assert_eq!(renderer.headers()["referrer-policy"], "no-referrer");
+    assert_eq!(
+        renderer.headers()["content-security-policy"],
+        RENDERER_V2_CSP
+    );
+    assert!(!renderer.headers().contains_key("x-frame-options"));
+    let semantic_headers: BTreeSet<&str> = renderer
+        .headers()
+        .keys()
+        .map(reqwest::header::HeaderName::as_str)
+        .filter(|name| {
+            !matches!(
+                *name,
+                "connection" | "content-length" | "date" | "server" | "transfer-encoding"
+            )
+        })
+        .collect();
+    assert_eq!(
+        semantic_headers,
+        BTreeSet::from([
+            "cache-control",
+            "content-security-policy",
+            "content-type",
+            "referrer-policy",
+            "x-content-type-options",
+        ])
+    );
+    assert_eq!(
+        renderer
+            .bytes()
+            .expect("renderer body should be readable")
+            .as_ref(),
+        RENDERER_V2_DOCUMENT.as_bytes()
+    );
+
+    for path in [
+        "/integrations/aps/renderer/v1",
+        "/integrations/aps/runner/v1.js",
+    ] {
+        let response = client
+            .get(format!("{}{path}", process.base_url))
+            .send()
+            .expect("unknown APS route request should complete");
+        assert_exact_local_failure(response, 404, false);
+    }
+    fixture.assert_no_proxy_observation(0, Duration::from_millis(150));
+
+    for (observation_index, case) in corpus(runtime_id).into_iter().enumerate() {
+        fixture.enqueue(case.upstream);
+        let started = Instant::now();
+        let response = client
+            .get(format!("{}{}", process.base_url, APS_RUNNER_ROUTE))
+            .header("authorization", "Bearer must-not-leave-downstream")
+            .header("cookie", "must-not-leave-downstream=1")
+            .header("x-forwarded-for", "203.0.113.19")
+            .header("x-publisher-secret", "must-not-leave-downstream")
+            .send()
+            .expect("should receive an APS runner-proxy downstream response");
+        let elapsed = started.elapsed();
+        assert_eq!(
+            response.status().as_u16(),
+            case.expected_status,
+            "{}",
+            case.name
+        );
+        if case.expected_status == 200 {
+            assert_success(case.name, &response);
+        } else {
+            assert_eq!(
+                response.headers()["cache-control"],
+                "no-store",
+                "{}",
+                case.name
+            );
+        }
+        let body = response
+            .bytes()
+            .expect("should read the APS runner-proxy downstream response body");
+        if let Some(expected) = case.expected_body {
+            assert_eq!(body.as_ref(), expected, "{}", case.name);
+        }
+        if let Some(maximum) = case.maximum_elapsed {
+            assert!(
+                elapsed <= maximum,
+                "{}: deadline returned after {elapsed:?}, expected <= {maximum:?}",
+                case.name
+            );
+        }
+        let observed = fixture
+            .wait_for_observation(observation_index)
+            .expect("should observe the APS runner-proxy upstream request");
+        assert_outbound_request(runtime_id, case.name, &observed);
+    }
+}
diff --git a/crates/trusted-server-integration-tests/tests/common/aps_runner_upstream.rs b/crates/trusted-server-integration-tests/tests/common/aps_runner_upstream.rs
new file mode 100644
index 000000000..d046861c5
--- /dev/null
+++ b/crates/trusted-server-integration-tests/tests/common/aps_runner_upstream.rs
@@ -0,0 +1,297 @@
+use crate::common::runtime::{TestError, TestResult};
+use error_stack::{Report, ResultExt as _};
+use std::collections::VecDeque;
+use std::io::{Read as _, Write as _};
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+use std::time::{Duration, Instant};
+
+const MAX_REQUEST_HEAD_BYTES: usize = 64 * 1024;
+
+#[derive(Debug, Clone)]
+pub struct ResponseWrite {
+    delay_before: Duration,
+    bytes: Vec<u8>,
+}
+
+impl ResponseWrite {
+    #[must_use]
+    pub fn now(bytes: impl Into<Vec<u8>>) -> Self {
+        Self {
+            delay_before: Duration::ZERO,
+            bytes: bytes.into(),
+        }
+    }
+
+    #[must_use]
+    pub fn after(delay_before: Duration, bytes: impl Into<Vec<u8>>) -> Self {
+        Self {
+            delay_before,
+            bytes: bytes.into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FictionalResponse {
+    writes: Vec<ResponseWrite>,
+}
+
+impl FictionalResponse {
+    #[must_use]
+    pub fn raw(writes: Vec<ResponseWrite>) -> Self {
+        Self { writes }
+    }
+
+    #[must_use]
+    pub fn fixed(status: &str, headers: &[(&str, &str)], body: impl AsRef<[u8]>) -> Self {
+        let body = body.as_ref();
+        let mut response = format!("HTTP/1.1 {status}\r\nConnection: close\r\n").into_bytes();
+        for (name, value) in headers {
+            response.extend_from_slice(name.as_bytes());
+            response.extend_from_slice(b": ");
+            response.extend_from_slice(value.as_bytes());
+            response.extend_from_slice(b"\r\n");
+        }
+        response.extend_from_slice(b"\r\n");
+        response.extend_from_slice(body);
+        Self::raw(vec![ResponseWrite::now(response)])
+    }
+
+    #[must_use]
+    pub fn chunked(
+        status: &str,
+        headers: &[(&str, &str)],
+        chunks: Vec<(Duration, Vec<u8>)>,
+    ) -> Self {
+        let mut head =
+            format!("HTTP/1.1 {status}\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n")
+                .into_bytes();
+        for (name, value) in headers {
+            head.extend_from_slice(name.as_bytes());
+            head.extend_from_slice(b": ");
+            head.extend_from_slice(value.as_bytes());
+            head.extend_from_slice(b"\r\n");
+        }
+        head.extend_from_slice(b"\r\n");
+        let mut writes = vec![ResponseWrite::now(head)];
+        for (delay, chunk) in chunks {
+            let mut framed = format!("{:x}\r\n", chunk.len()).into_bytes();
+            framed.extend_from_slice(&chunk);
+            framed.extend_from_slice(b"\r\n");
+            writes.push(ResponseWrite::after(delay, framed));
+        }
+        writes.push(ResponseWrite::now(b"0\r\n\r\n".to_vec()));
+        Self::raw(writes)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ObservedRequest {
+    pub request_line: String,
+    headers: Vec<(String, String)>,
+}
+
+impl ObservedRequest {
+    #[must_use]
+    pub fn header_values(&self, name: &str) -> Vec<&str> {
+        self.headers
+            .iter()
+            .filter_map(|(candidate, value)| {
+                candidate
+                    .eq_ignore_ascii_case(name)
+                    .then_some(value.as_str())
+            })
+            .collect()
+    }
+}
+
+#[derive(Debug, Default)]
+struct FixtureState {
+    plans: VecDeque<FictionalResponse>,
+    observations: Vec<ObservedRequest>,
+    stopping: bool,
+}
+
+/// Loopback-only fictional APS upstream controlled through in-process state.
+///
+/// There is deliberately no HTTP control route: the browser-facing request
+/// cannot select a response plan or change the transport target.
+pub struct ApsRunnerUpstream {
+    address: SocketAddr,
+    state: Arc<(Mutex<FixtureState>, Condvar)>,
+    accept_thread: Option<thread::JoinHandle<()>>,
+}
+
+impl ApsRunnerUpstream {
+    pub fn start() -> TestResult<Self> {
+        let listener = TcpListener::bind("127.0.0.1:0")
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to bind fictional APS runner upstream")?;
+        let address = listener
+            .local_addr()
+            .change_context(TestError::RuntimeSpawn)?;
+        let state = Arc::new((Mutex::new(FixtureState::default()), Condvar::new()));
+        let server_state = Arc::clone(&state);
+        let accept_thread = thread::spawn(move || {
+            for incoming in listener.incoming() {
+                let Ok(stream) = incoming else {
+                    break;
+                };
+                let state = Arc::clone(&server_state);
+                thread::spawn(move || serve_one(stream, &state));
+                let stopping = server_state
+                    .0
+                    .lock()
+                    .expect("fixture state should not be poisoned")
+                    .stopping;
+                if stopping {
+                    break;
+                }
+            }
+        });
+        Ok(Self {
+            address,
+            state,
+            accept_thread: Some(accept_thread),
+        })
+    }
+
+    #[must_use]
+    pub fn endpoint_url(&self) -> String {
+        format!("http://{}/prebid-creative.js", self.address)
+    }
+
+    pub fn enqueue(&self, response: FictionalResponse) {
+        let mut state = self
+            .state
+            .0
+            .lock()
+            .expect("fixture state should not be poisoned");
+        state.plans.push_back(response);
+    }
+
+    pub fn wait_for_observation(&self, previous_count: usize) -> TestResult<ObservedRequest> {
+        let deadline = Instant::now() + Duration::from_secs(2);
+        let (lock, changed) = &*self.state;
+        let mut state = lock.lock().expect("fixture state should not be poisoned");
+        while proxy_observations(&state).count() <= previous_count {
+            let now = Instant::now();
+            if now >= deadline {
+                return Err(Report::new(TestError::RuntimeNotReady)
+                    .attach("fictional APS runner upstream did not observe the request"));
+            }
+            let result = changed
+                .wait_timeout(state, deadline - now)
+                .expect("fixture state should not be poisoned");
+            state = result.0;
+        }
+        Ok(proxy_observations(&state)
+            .nth(previous_count)
+            .expect("proxy observation count was checked")
+            .clone())
+    }
+
+    pub fn assert_no_proxy_observation(&self, previous_count: usize, duration: Duration) {
+        let deadline = Instant::now() + duration;
+        let (lock, changed) = &*self.state;
+        let mut state = lock.lock().expect("fixture state should not be poisoned");
+        while Instant::now() < deadline && proxy_observations(&state).count() <= previous_count {
+            let remaining = deadline.saturating_duration_since(Instant::now());
+            if remaining.is_zero() {
+                break;
+            }
+            state = changed
+                .wait_timeout(state, remaining)
+                .expect("fixture state should not be poisoned")
+                .0;
+        }
+        assert_eq!(
+            proxy_observations(&state).count(),
+            previous_count,
+            "reserved non-GET request must not reach the APS upstream"
+        );
+    }
+}
+
+fn proxy_observations(state: &FixtureState) -> impl Iterator<Item = &ObservedRequest> {
+    state
+        .observations
+        .iter()
+        .filter(|request| !request.header_values("x-ts-aps-logical-url").is_empty())
+}
+
+impl Drop for ApsRunnerUpstream {
+    fn drop(&mut self) {
+        self.state
+            .0
+            .lock()
+            .expect("fixture state should not be poisoned")
+            .stopping = true;
+        let _ = TcpStream::connect(self.address);
+        if let Some(handle) = self.accept_thread.take() {
+            let _ = handle.join();
+        }
+    }
+}
+
+fn serve_one(mut stream: TcpStream, state: &Arc<(Mutex<FixtureState>, Condvar)>) {
+    let Ok(observation) = read_request(&mut stream) else {
+        return;
+    };
+    let response = {
+        let (lock, changed) = &**state;
+        let mut state = lock.lock().expect("fixture state should not be poisoned");
+        state.observations.push(observation);
+        changed.notify_all();
+        state.plans.pop_front()
+    };
+    let Some(response) = response else {
+        let _ = stream.write_all(
+            b"HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+        );
+        return;
+    };
+    for write in response.writes {
+        if !write.delay_before.is_zero() {
+            thread::sleep(write.delay_before);
+        }
+        if stream.write_all(&write.bytes).is_err() {
+            break;
+        }
+        let _ = stream.flush();
+    }
+}
+
+fn read_request(stream: &mut TcpStream) -> std::io::Result<ObservedRequest> {
+    stream.set_read_timeout(Some(Duration::from_secs(2)))?;
+    let mut bytes = Vec::new();
+    let mut chunk = [0_u8; 1024];
+    while !bytes.windows(4).any(|window| window == b"\r\n\r\n") {
+        let read = stream.read(&mut chunk)?;
+        if read == 0 {
+            break;
+        }
+        bytes.extend_from_slice(&chunk[..read]);
+        if bytes.len() > MAX_REQUEST_HEAD_BYTES {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "request head exceeded fixture cap",
+            ));
+        }
+    }
+    let head = std::str::from_utf8(&bytes)
+        .map_err(|_| std::io::Error::new(std::io::ErrorKind::InvalidData, "non-UTF-8 request"))?;
+    let mut lines = head.split("\r\n");
+    let request_line = lines.next().unwrap_or_default().to_string();
+    let headers = lines
+        .take_while(|line| !line.is_empty())
+        .filter_map(|line| line.split_once(':'))
+        .map(|(name, value)| (name.trim().to_string(), value.trim().to_string()))
+        .collect();
+    Ok(ObservedRequest {
+        request_line,
+        headers,
+    })
+}
diff --git a/crates/trusted-server-integration-tests/tests/common/assertions.rs b/crates/trusted-server-integration-tests/tests/common/assertions.rs
index 2b739edae..50ef7a684 100644
--- a/crates/trusted-server-integration-tests/tests/common/assertions.rs
+++ b/crates/trusted-server-integration-tests/tests/common/assertions.rs
@@ -76,6 +76,49 @@ pub fn assert_unique_script_tag(html: &str) -> TestResult<()> {
     Ok(())
 }
 
+/// Return the exact content-addressed TSJS URL injected into publisher HTML.
+///
+/// The hard cutover intentionally has no unversioned transport alias, so the
+/// integration corpus must discover and validate the release URL produced by
+/// the server instead of constructing a stale filename itself.
+///
+/// # Errors
+///
+/// Returns an error when the script is missing, duplicated, or does not use
+/// the canonical relative unified path plus one lowercase SHA-256 query value.
+pub fn trustedserver_script_src(html: &str) -> TestResult<String> {
+    const PREFIX: &str = "/static/tsjs=tsjs-unified.min.js?v=";
+
+    let document = Html::parse_document(html);
+    let selector = parse_selector("script#trustedserver-js")?;
+    let scripts = document.select(&selector).collect::<Vec<_>>();
+    let [script] = scripts.as_slice() else {
+        return Err(if scripts.is_empty() {
+            Report::new(TestError::ScriptTagNotFound)
+        } else {
+            Report::new(TestError::DuplicateScriptTag)
+        });
+    };
+    let src = script
+        .value()
+        .attr("src")
+        .ok_or_else(|| Report::new(TestError::ScriptTagNotFound))?;
+    let hash = src.strip_prefix(PREFIX).ok_or_else(|| {
+        Report::new(TestError::UnexpectedContent)
+            .attach("trustedserver-js must use the content-addressed unified route")
+    })?;
+    if hash.len() != 64
+        || !hash
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+    {
+        return Err(Report::new(TestError::UnexpectedContent)
+            .attach("trustedserver-js release hash must be lowercase SHA-256"));
+    }
+
+    Ok(src.to_owned())
+}
+
 /// Assert that origin host URLs in `href`/`src` attributes have been rewritten.
 ///
 /// Checks that the proxied HTML no longer contains the origin host in `href`
@@ -317,6 +360,29 @@ mod tests {
         assert_script_tag_present(html).expect("should find trustedserver-js script tag");
     }
 
+    #[test]
+    fn content_addressed_script_src_returns_the_injected_release_url() {
+        let hash = "a".repeat(64);
+        let html = format!(
+            r#"<!DOCTYPE html><script src="/static/tsjs=tsjs-unified.min.js?v={hash}" id="trustedserver-js"></script>"#
+        );
+
+        assert_eq!(
+            trustedserver_script_src(&html).expect("should read the canonical injected URL"),
+            format!("/static/tsjs=tsjs-unified.min.js?v={hash}")
+        );
+    }
+
+    #[test]
+    fn content_addressed_script_src_rejects_the_removed_unversioned_alias() {
+        let html = r#"<!DOCTYPE html><script src="/static/tsjs=tsjs-unified.min.js" id="trustedserver-js"></script>"#;
+
+        assert!(
+            trustedserver_script_src(html).is_err(),
+            "the integration corpus must not resurrect the removed unversioned route"
+        );
+    }
+
     #[test]
     fn script_tag_present_fails_when_no_script() {
         let html = r#"
diff --git a/crates/trusted-server-integration-tests/tests/common/config.rs b/crates/trusted-server-integration-tests/tests/common/config.rs
index 037fa4658..4dfb4b6cf 100644
--- a/crates/trusted-server-integration-tests/tests/common/config.rs
+++ b/crates/trusted-server-integration-tests/tests/common/config.rs
@@ -7,7 +7,7 @@ use crate::common::runtime::{TestError, TestResult};
 const GENERATED_AT: &str = "2026-06-23T00:00:00Z";
 const APP_CONFIG: &str = include_str!("../../fixtures/configs/trusted-server.integration.toml");
 
-pub fn integration_app_config_envelope(origin_port: u16) -> TestResult<String> {
+fn app_config_envelope(origin_port: u16, aps_proxy_fixture: bool) -> TestResult<String> {
     let origin_url = format!("http://127.0.0.1:{origin_port}");
     let app_config: TrustedServerAppConfig = toml::from_str(APP_CONFIG).map_err(|error| {
         Report::new(TestError::ConfigGeneration).attach(format!(
@@ -16,6 +16,15 @@ pub fn integration_app_config_envelope(origin_port: u16) -> TestResult<String> {
     })?;
     let mut settings = app_config.into_settings();
     settings.publisher.origin_url = origin_url;
+    if aps_proxy_fixture {
+        settings.auction.enabled = true;
+        settings
+            .auction
+            .providers
+            .retain(|_, provider| provider.profile == "aps");
+        settings.auction.bidders.clear();
+        settings.auction.mediator = None;
+    }
     let app_config = TrustedServerAppConfig::new(settings).map_err(|report| {
         Report::new(TestError::ConfigGeneration)
             .attach(format!("invalid generated integration config: {report:?}"))
@@ -33,6 +42,15 @@ pub fn integration_app_config_envelope(origin_port: u16) -> TestResult<String> {
     })
 }
 
+pub fn integration_app_config_envelope(origin_port: u16) -> TestResult<String> {
+    app_config_envelope(origin_port, false)
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+pub fn aps_runner_proxy_app_config_envelope(origin_port: u16) -> TestResult<String> {
+    app_config_envelope(origin_port, true)
+}
+
 pub fn cloudflare_config_json(origin_port: u16) -> TestResult<String> {
     let envelope = integration_app_config_envelope(origin_port)?;
     serde_json::to_string(&serde_json::json!({ "app_config": envelope })).map_err(|error| {
@@ -42,10 +60,56 @@ pub fn cloudflare_config_json(origin_port: u16) -> TestResult<String> {
     })
 }
 
+#[cfg(feature = "aps-runner-proxy")]
+pub fn cloudflare_aps_runner_proxy_config_json(origin_port: u16) -> TestResult<String> {
+    let envelope = aps_runner_proxy_app_config_envelope(origin_port)?;
+    serde_json::to_string(&serde_json::json!({ "app_config": envelope })).map_err(|error| {
+        Report::new(TestError::ConfigGeneration).attach(format!(
+            "failed to serialize Cloudflare APS proxy config binding: {error}"
+        ))
+    })
+}
+
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "aps-runner-proxy")]
+    use super::{aps_runner_proxy_app_config_envelope, integration_app_config_envelope};
     const FASTLY_CONFIG: &str = include_str!("../../../../fastly.toml");
 
+    #[cfg(feature = "aps-runner-proxy")]
+    #[test]
+    fn aps_proxy_envelope_enables_only_its_auction_fixture() {
+        let regular: serde_json::Value = serde_json::from_str(
+            &integration_app_config_envelope(8888).expect("should build regular fixture envelope"),
+        )
+        .expect("should parse regular fixture envelope");
+        let aps_proxy: serde_json::Value = serde_json::from_str(
+            &aps_runner_proxy_app_config_envelope(8888)
+                .expect("should build APS proxy fixture envelope"),
+        )
+        .expect("should parse APS proxy fixture envelope");
+
+        assert_eq!(regular["data"]["auction"]["enabled"], false);
+        assert_eq!(aps_proxy["data"]["auction"]["enabled"], true);
+        assert_eq!(
+            aps_proxy["data"]["auction"]["providers"]
+                .as_object()
+                .expect("proxy providers should be an object")
+                .keys()
+                .collect::<Vec<_>>(),
+            ["aps-main"]
+        );
+        assert_eq!(
+            aps_proxy["data"]["auction"]["bidders"],
+            serde_json::json!({})
+        );
+        assert_eq!(
+            regular["data"]["auction"]["providers"]["aps-main"],
+            aps_proxy["data"]["auction"]["providers"]["aps-main"],
+            "the proxy fixture should preserve the canonical APS provider configuration"
+        );
+    }
+
     #[test]
     fn local_fastly_config_defines_runtime_kv_stores() {
         let parsed: toml::Value =
diff --git a/crates/trusted-server-integration-tests/tests/common/mod.rs b/crates/trusted-server-integration-tests/tests/common/mod.rs
index f5a4b578e..3e460100a 100644
--- a/crates/trusted-server-integration-tests/tests/common/mod.rs
+++ b/crates/trusted-server-integration-tests/tests/common/mod.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "aps-runner-proxy")]
+pub mod aps_runner_upstream;
 pub mod assertions;
 pub mod config;
 pub mod ec;
diff --git a/crates/trusted-server-integration-tests/tests/common/runtime.rs b/crates/trusted-server-integration-tests/tests/common/runtime.rs
index 048c76d44..6ee32a222 100644
--- a/crates/trusted-server-integration-tests/tests/common/runtime.rs
+++ b/crates/trusted-server-integration-tests/tests/common/runtime.rs
@@ -97,6 +97,21 @@ pub trait RuntimeEnvironment: Send + Sync {
     /// Returns [`TestError::RuntimeNotReady`] if the health check times out.
     fn spawn(&self, wasm_path: &Path) -> TestResult<RuntimeProcess>;
 
+    /// Spawn the dedicated APS runner-proxy integration artifact.
+    ///
+    /// `fixture_url` is selected by the private test controller, never an
+    /// incoming browser request. Implementations must pass it only through
+    /// their feature-gated transport seam.
+    #[cfg(feature = "aps-runner-proxy")]
+    fn spawn_aps_runner_proxy(
+        &self,
+        _wasm_path: &Path,
+        _fixture_url: &str,
+    ) -> TestResult<RuntimeProcess> {
+        Err(Report::new(TestError::RuntimeSpawn)
+            .attach("runtime does not implement the APS runner proxy test artifact"))
+    }
+
     /// Health check endpoint (may differ by platform)
     fn health_check_path(&self) -> &str {
         "/health"
diff --git a/crates/trusted-server-integration-tests/tests/environments/axum.rs b/crates/trusted-server-integration-tests/tests/environments/axum.rs
index 3623d8491..3de90684d 100644
--- a/crates/trusted-server-integration-tests/tests/environments/axum.rs
+++ b/crates/trusted-server-integration-tests/tests/environments/axum.rs
@@ -1,9 +1,13 @@
+#[cfg(feature = "aps-runner-proxy")]
+use crate::common::config::aps_runner_proxy_app_config_envelope;
 use crate::common::config::integration_app_config_envelope;
 use crate::common::runtime::{
     RuntimeEnvironment, RuntimeProcess, RuntimeProcessHandle, TestError, TestResult, origin_port,
 };
 use error_stack::ResultExt as _;
 use std::io::{BufRead as _, BufReader};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt as _;
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
 
@@ -53,18 +57,49 @@ impl RuntimeEnvironment for AxumDevServer {
     }
 
     fn spawn(&self, _wasm_path: &Path) -> TestResult<RuntimeProcess> {
+        self.spawn_inner(None)
+    }
+
+    #[cfg(feature = "aps-runner-proxy")]
+    fn spawn_aps_runner_proxy(
+        &self,
+        _wasm_path: &Path,
+        fixture_url: &str,
+    ) -> TestResult<RuntimeProcess> {
+        self.spawn_inner(Some(fixture_url))
+    }
+
+    fn health_check_path(&self) -> &str {
+        "/health"
+    }
+}
+
+impl AxumDevServer {
+    fn spawn_inner(&self, aps_runner_fixture_url: Option<&str>) -> TestResult<RuntimeProcess> {
         let binary = self.binary_path();
         let port = super::find_available_port().unwrap_or(AXUM_DEFAULT_PORT);
 
+        #[cfg(feature = "aps-runner-proxy")]
+        let app_config = if aps_runner_fixture_url.is_some() {
+            aps_runner_proxy_app_config_envelope(origin_port())?
+        } else {
+            integration_app_config_envelope(origin_port())?
+        };
+        #[cfg(not(feature = "aps-runner-proxy"))]
         let app_config = integration_app_config_envelope(origin_port())?;
 
-        let mut child = Command::new(&binary)
-            .env("PORT", port.to_string())
-            .env(
-                "TRUSTED_SERVER_CONFIG_TRUSTED_SERVER_CONFIG_TRUSTED_SERVER_CONFIG",
-                app_config,
-            )
-            .envs(INTEGRATION_SECRET_ENV.iter().copied())
+        let mut command = Command::new(&binary);
+        command.env("PORT", port.to_string()).env(
+            "TRUSTED_SERVER_CONFIG_TRUSTED_SERVER_CONFIG_TRUSTED_SERVER_CONFIG",
+            app_config,
+        );
+        command.envs(INTEGRATION_SECRET_ENV.iter().copied());
+        if let Some(fixture_url) = aps_runner_fixture_url {
+            command.env("TS_APS_RUNNER_PROXY_TEST_ENDPOINT", fixture_url);
+        }
+        #[cfg(unix)]
+        command.process_group(0);
+        let mut child = command
             .stdout(Stdio::null())
             .stderr(Stdio::piped())
             .spawn()
@@ -73,6 +108,7 @@ impl RuntimeEnvironment for AxumDevServer {
                 "Failed to spawn trusted-server-axum binary at {}",
                 binary.display()
             ))?;
+        super::register_process_group(&mut child)?;
 
         if let Some(stderr) = child.stderr.take() {
             std::thread::spawn(move || {
@@ -97,13 +133,6 @@ impl RuntimeEnvironment for AxumDevServer {
             base_url,
         })
     }
-
-    fn health_check_path(&self) -> &str {
-        "/health"
-    }
-}
-
-impl AxumDevServer {
     /// Resolve the path to the compiled `trusted-server-axum` binary.
     ///
     /// Respects the `AXUM_BINARY_PATH` environment variable for CI overrides.
@@ -149,6 +178,11 @@ impl RuntimeProcessHandle for AxumHandle {}
 
 impl Drop for AxumHandle {
     fn drop(&mut self) {
+        #[cfg(unix)]
+        unsafe {
+            libc::killpg(self.child.id() as libc::pid_t, libc::SIGTERM);
+        }
+        #[cfg(not(unix))]
         let _ = self.child.kill();
         let _ = self.child.wait();
     }
diff --git a/crates/trusted-server-integration-tests/tests/environments/cloudflare.rs b/crates/trusted-server-integration-tests/tests/environments/cloudflare.rs
index 10d16c0a7..5d6c25671 100644
--- a/crates/trusted-server-integration-tests/tests/environments/cloudflare.rs
+++ b/crates/trusted-server-integration-tests/tests/environments/cloudflare.rs
@@ -1,11 +1,16 @@
+#[cfg(feature = "aps-runner-proxy")]
+use crate::common::config::cloudflare_aps_runner_proxy_config_json;
 use crate::common::config::cloudflare_config_json;
 use crate::common::runtime::{
     RuntimeEnvironment, RuntimeProcess, RuntimeProcessHandle, TestError, TestResult, origin_port,
 };
 use error_stack::{Report, ResultExt as _};
+#[cfg(feature = "aps-runner-proxy")]
+use std::io::Write as _;
 use std::io::{BufRead as _, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::{Child, Command, Stdio};
+use tempfile::{NamedTempFile, TempDir};
 
 /// Cloudflare Workers runtime via `wrangler dev`.
 ///
@@ -26,6 +31,17 @@ const CLOUDFLARE_DEFAULT_PORT: u16 = 8787;
 const CI_CONFIG_TEMPLATE: &str = "wrangler.ci.toml";
 const GENERATED_CI_CONFIG: &str = "wrangler.integration.generated.toml";
 const TRUSTED_SERVER_CONFIG_PLACEHOLDER: &str = "TRUSTED_SERVER_CONFIG = \"{}\"";
+#[cfg(feature = "aps-runner-proxy")]
+const APS_RUNNER_PROXY_CONFIG_TEMPLATE: &str = "wrangler.aps-runner-proxy.toml";
+#[cfg(feature = "aps-runner-proxy")]
+const APS_RUNNER_PROXY_CONFIG: &str =
+    include_str!("../../../trusted-server-adapter-cloudflare/wrangler.aps-runner-proxy.toml");
+#[cfg(feature = "aps-runner-proxy")]
+const APS_RUNNER_PROXY_FIXTURE_CONFIG: &str =
+    include_str!("../../fixtures/configs/cloudflare-aps-runner-proxy-fixture.toml");
+#[cfg(feature = "aps-runner-proxy")]
+const APS_RUNNER_PROXY_ENDPOINT_PLACEHOLDER: &str =
+    "APS_RUNNER_PROXY_TEST_ENDPOINT = \"__APS_RUNNER_PROXY_TEST_ENDPOINT__\"";
 
 fn write_generated_ci_config(wrangler_dir: &Path) -> TestResult<String> {
     let template_path = wrangler_dir.join(CI_CONFIG_TEMPLATE);
@@ -61,6 +77,173 @@ fn inject_cloudflare_config(template: &str, config_json: &str) -> TestResult<Str
     ))
 }
 
+#[cfg(feature = "aps-runner-proxy")]
+fn validate_loopback_fixture_url(fixture_url: &str) -> TestResult<()> {
+    let url = reqwest::Url::parse(fixture_url)
+        .change_context(TestError::RuntimeSpawn)
+        .attach("Cloudflare APS proxy fixture URL is invalid")?;
+    let is_loopback = url
+        .host_str()
+        .and_then(|host| host.parse::<std::net::IpAddr>().ok())
+        .is_some_and(|address| address.is_loopback());
+    if url.scheme() != "http"
+        || !is_loopback
+        || url.port().is_none()
+        || !url.username().is_empty()
+        || url.password().is_some()
+        || url.query().is_some()
+        || url.fragment().is_some()
+    {
+        return Err(Report::new(TestError::RuntimeSpawn).attach(
+            "Cloudflare APS proxy fixture URL must be explicit loopback HTTP without credentials, query, or fragment",
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+fn write_temporary_config(directory: &Path, contents: &str) -> TestResult<NamedTempFile> {
+    let _: toml::Value = toml::from_str(contents)
+        .change_context(TestError::RuntimeSpawn)
+        .attach("generated Cloudflare APS proxy Wrangler config is invalid")?;
+    let mut config = tempfile::Builder::new()
+        .prefix(".aps-runner-proxy-")
+        .suffix(".toml")
+        .tempfile_in(directory)
+        .change_context(TestError::RuntimeSpawn)
+        .attach("failed to create temporary Cloudflare APS proxy Wrangler config")?;
+    config
+        .write_all(contents.as_bytes())
+        .change_context(TestError::RuntimeSpawn)
+        .attach("failed to write temporary Cloudflare APS proxy Wrangler config")?;
+    Ok(config)
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+fn generated_aps_runner_proxy_configs(
+    wrangler_dir: &Path,
+    fixture_url: &str,
+) -> TestResult<(NamedTempFile, NamedTempFile)> {
+    validate_loopback_fixture_url(fixture_url)?;
+
+    let main_template_path = wrangler_dir.join(APS_RUNNER_PROXY_CONFIG_TEMPLATE);
+    let main_template = std::fs::read_to_string(&main_template_path)
+        .change_context(TestError::RuntimeSpawn)
+        .attach(format!(
+            "failed to read Cloudflare APS proxy config at {}",
+            main_template_path.display()
+        ))?;
+    let config_json = cloudflare_aps_runner_proxy_config_json(origin_port())?;
+    let main_config = inject_cloudflare_config(&main_template, &config_json)?;
+
+    let placeholder_count = APS_RUNNER_PROXY_FIXTURE_CONFIG
+        .matches(APS_RUNNER_PROXY_ENDPOINT_PLACEHOLDER)
+        .count();
+    if placeholder_count != 1 {
+        return Err(Report::new(TestError::RuntimeSpawn).attach(format!(
+            "Cloudflare APS fixture config must contain one endpoint placeholder, found {placeholder_count}"
+        )));
+    }
+    let endpoint = toml::Value::String(fixture_url.to_string()).to_string();
+    let fixture_config = APS_RUNNER_PROXY_FIXTURE_CONFIG.replace(
+        APS_RUNNER_PROXY_ENDPOINT_PLACEHOLDER,
+        &format!("APS_RUNNER_PROXY_TEST_ENDPOINT = {endpoint}"),
+    );
+    let fixture_config_directory =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/configs");
+
+    Ok((
+        write_temporary_config(wrangler_dir, &main_config)?,
+        write_temporary_config(&fixture_config_directory, &fixture_config)?,
+    ))
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+#[derive(Default)]
+struct CloudflareApsRouteReadiness {
+    consecutive_exact_contracts: u8,
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+impl CloudflareApsRouteReadiness {
+    fn observe(
+        &mut self,
+        status: u16,
+        allow: Option<&str>,
+        cache_control: Option<&str>,
+        body_is_empty: bool,
+    ) -> bool {
+        let is_exact_contract = status == 405
+            && allow == Some("GET")
+            && cache_control == Some("no-store")
+            && body_is_empty;
+        self.consecutive_exact_contracts = if is_exact_contract {
+            self.consecutive_exact_contracts.saturating_add(1)
+        } else {
+            0
+        };
+        self.consecutive_exact_contracts >= 2
+    }
+}
+
+#[cfg(feature = "aps-runner-proxy")]
+fn wait_for_aps_route_ready(base_url: &str, options: super::ReadyCheckOptions) -> TestResult<()> {
+    let client = reqwest::blocking::Client::builder()
+        .timeout(options.interval)
+        .build()
+        .change_context(TestError::RuntimeSpawn)
+        .attach("failed to build Cloudflare APS readiness client")?;
+    let renderer_url = format!(
+        "{}{}",
+        base_url,
+        trusted_server_core::integrations::aps::APS_RENDERER_V2_ROUTE
+    );
+    let probe_method =
+        reqwest::Method::from_bytes(b"PROPFIND").expect("should parse PROPFIND readiness method");
+    let mut readiness = CloudflareApsRouteReadiness::default();
+
+    for _ in 0..options.max_attempts {
+        if let Ok(response) = client.request(probe_method.clone(), &renderer_url).send() {
+            let status = response.status().as_u16();
+            let allow = response
+                .headers()
+                .get(reqwest::header::ALLOW)
+                .and_then(|value| value.to_str().ok())
+                .map(str::to_owned);
+            let cache_control = response
+                .headers()
+                .get(reqwest::header::CACHE_CONTROL)
+                .and_then(|value| value.to_str().ok())
+                .map(str::to_owned);
+            let semantic_headers_are_exact = response
+                .headers()
+                .keys()
+                .map(reqwest::header::HeaderName::as_str)
+                .filter(|name| {
+                    !matches!(
+                        *name,
+                        "connection" | "content-length" | "date" | "server" | "transfer-encoding"
+                    )
+                })
+                .all(|name| matches!(name, "allow" | "cache-control"));
+            let body_is_empty = response.bytes().is_ok_and(|body| body.is_empty());
+
+            if readiness.observe(
+                status,
+                allow.as_deref(),
+                cache_control.as_deref(),
+                semantic_headers_are_exact && body_is_empty,
+            ) {
+                return Ok(());
+            }
+        }
+
+        std::thread::sleep(options.interval);
+    }
+
+    Err(Report::new(options.timeout_error).attach(options.timeout_message))
+}
+
 impl RuntimeEnvironment for CloudflareWorkers {
     fn id(&self) -> &'static str {
         "cloudflare"
@@ -127,6 +310,7 @@ impl RuntimeEnvironment for CloudflareWorkers {
             ))?;
 
         let mut child = child;
+        super::register_process_group(&mut child)?;
         if let Some(stderr) = child.stderr.take() {
             std::thread::spawn(move || {
                 let reader = BufReader::new(stderr);
@@ -138,7 +322,11 @@ impl RuntimeEnvironment for CloudflareWorkers {
             });
         }
 
-        let handle = CloudflareHandle { child };
+        let handle = CloudflareHandle {
+            child,
+            _configs: Vec::new(),
+            _state_directory: None,
+        };
         let base_url = format!("http://127.0.0.1:{port}");
 
         super::wait_for_ready(&base_url, self.health_check_path(), true)?;
@@ -149,6 +337,102 @@ impl RuntimeEnvironment for CloudflareWorkers {
         })
     }
 
+    #[cfg(feature = "aps-runner-proxy")]
+    fn spawn_aps_runner_proxy(
+        &self,
+        _wasm_path: &Path,
+        fixture_url: &str,
+    ) -> TestResult<RuntimeProcess> {
+        let wrangler_dir = self.wrangler_dir();
+        let (main_config, fixture_config) =
+            generated_aps_runner_proxy_configs(&wrangler_dir, fixture_url)?;
+        let state_directory = tempfile::tempdir()
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to create temporary Cloudflare APS proxy state directory")?;
+        let port = super::find_available_port()?;
+
+        let mut command = Command::new("wrangler");
+        command
+            .arg("dev")
+            .arg("--config")
+            .arg(main_config.path())
+            .arg("--config")
+            .arg(fixture_config.path())
+            .args(["--port", &port.to_string(), "--ip", "127.0.0.1"])
+            .arg("--persist-to")
+            .arg(state_directory.path())
+            .args(["--local", "--log-level", "info"])
+            .env(
+                "WRANGLER_LOG_PATH",
+                state_directory.path().join("wrangler.log"),
+            )
+            .current_dir(&wrangler_dir)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        #[cfg(unix)]
+        {
+            use std::os::unix::process::CommandExt as _;
+            command.process_group(0);
+        }
+        let mut child = command
+            .spawn()
+            .change_context(TestError::RuntimeSpawn)
+            .attach(format!(
+                "failed to spawn Cloudflare APS proxy Worker in {}",
+                wrangler_dir.display()
+            ))?;
+        super::register_process_group(&mut child)?;
+
+        if let Some(stdout) = child.stdout.take() {
+            std::thread::spawn(move || {
+                let reader = BufReader::new(stdout);
+                for line in reader.lines().map_while(Result::ok) {
+                    if !line.is_empty() {
+                        log::debug!("cloudflare APS proxy: {line}");
+                    }
+                }
+            });
+        }
+        if let Some(stderr) = child.stderr.take() {
+            std::thread::spawn(move || {
+                let reader = BufReader::new(stderr);
+                for line in reader.lines().map_while(Result::ok) {
+                    if !line.is_empty() {
+                        log::debug!("cloudflare APS proxy: {line}");
+                    }
+                }
+            });
+        }
+
+        let handle = CloudflareHandle {
+            child,
+            _configs: vec![main_config, fixture_config],
+            _state_directory: Some(state_directory),
+        };
+        let base_url = format!("http://127.0.0.1:{port}");
+        wait_for_aps_route_ready(
+            &base_url,
+            super::ReadyCheckOptions {
+                // Wrangler performs noticeably more startup work for the
+                // two-Worker service-binding fixture than the other local
+                // runtimes. Keep this process-readiness allowance independent
+                // from the APS proxy's strict upstream deadlines.
+                max_attempts: 120,
+                interval: std::time::Duration::from_millis(500),
+                fallback_to_root: false,
+                timeout_error: TestError::RuntimeNotReady,
+                timeout_message: format!(
+                    "Cloudflare APS runtime at {base_url} not ready after 60s"
+                ),
+            },
+        )?;
+
+        Ok(RuntimeProcess {
+            inner: Box::new(handle),
+            base_url,
+        })
+    }
+
     fn health_check_path(&self) -> &str {
         "/.well-known/trusted-server.json"
     }
@@ -170,6 +454,8 @@ impl CloudflareWorkers {
 
 struct CloudflareHandle {
     child: Child,
+    _configs: Vec<NamedTempFile>,
+    _state_directory: Option<TempDir>,
 }
 
 impl RuntimeProcessHandle for CloudflareHandle {}
@@ -233,4 +519,94 @@ mod tests {
 
         assert!(result.is_err(), "should reject duplicate placeholders");
     }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_fixture_config_has_one_private_endpoint_placeholder() {
+        assert_eq!(
+            APS_RUNNER_PROXY_FIXTURE_CONFIG
+                .matches(APS_RUNNER_PROXY_ENDPOINT_PLACEHOLDER)
+                .count(),
+            1,
+            "should define exactly one private fixture endpoint"
+        );
+        assert!(
+            !APS_RUNNER_PROXY_FIXTURE_CONFIG.contains("https://*:*"),
+            "should not grant wildcard outbound access"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_main_config_provides_every_shared_fixture_secret() {
+        for key in [
+            "integration_admin_password",
+            "integration_proxy_secret",
+            "integration_ec_passphrase",
+            "integration_partner_token_alpha",
+            "integration_partner_token_bravo",
+        ] {
+            assert!(
+                APS_RUNNER_PROXY_CONFIG.contains(&format!("{key} =")),
+                "APS Worker test config should provide `{key}`"
+            );
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_fixture_url_rejects_non_loopback_targets() {
+        assert!(
+            validate_loopback_fixture_url("https://example.com/prebid-creative.js").is_err(),
+            "should reject a public fixture target"
+        );
+        assert!(
+            validate_loopback_fixture_url("http://127.0.0.1:1234/prebid-creative.js").is_ok(),
+            "should accept an explicit loopback fixture target"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_route_readiness_requires_two_consecutive_exact_contracts() {
+        let mut readiness = CloudflareApsRouteReadiness::default();
+
+        assert!(
+            !readiness.observe(405, Some("GET"), Some("no-store"), true),
+            "should not accept only one exact observation"
+        );
+        assert!(
+            !readiness.observe(503, None, None, false),
+            "should reset after a transient startup response"
+        );
+        assert!(
+            !readiness.observe(405, Some("GET"), Some("no-store"), true),
+            "should restart the consecutive count"
+        );
+        assert!(
+            readiness.observe(405, Some("GET"), Some("no-store"), true),
+            "should accept two consecutive exact observations"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_route_readiness_rejects_partial_405_contracts() {
+        for (status, allow, cache_control, body_is_empty) in [
+            (200, Some("GET"), Some("no-store"), true),
+            (405, Some("POST"), Some("no-store"), true),
+            (405, Some("GET"), Some("public"), true),
+            (405, Some("GET"), Some("no-store"), false),
+        ] {
+            let mut readiness = CloudflareApsRouteReadiness::default();
+            assert!(
+                !readiness.observe(status, allow, cache_control, body_is_empty),
+                "should reject an incomplete local method contract"
+            );
+            assert!(
+                !readiness.observe(405, Some("GET"), Some("no-store"), true),
+                "should require two exact observations after rejection"
+            );
+        }
+    }
 }
diff --git a/crates/trusted-server-integration-tests/tests/environments/fastly.rs b/crates/trusted-server-integration-tests/tests/environments/fastly.rs
index 124a380f6..b2771a257 100644
--- a/crates/trusted-server-integration-tests/tests/environments/fastly.rs
+++ b/crates/trusted-server-integration-tests/tests/environments/fastly.rs
@@ -1,10 +1,22 @@
+#[cfg(feature = "aps-runner-proxy")]
+use crate::common::config::aps_runner_proxy_app_config_envelope;
 use crate::common::runtime::{
     RuntimeEnvironment, RuntimeProcess, RuntimeProcessHandle, TestError, TestResult,
 };
 use error_stack::{Report, ResultExt as _};
+use std::ffi::OsString;
+#[cfg(feature = "aps-runner-proxy")]
+use std::io::Write as _;
 use std::io::{BufRead as _, BufReader};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt as _;
 use std::path::Path;
 use std::process::{Child, Command, Stdio};
+use tempfile::NamedTempFile;
+#[cfg(feature = "aps-runner-proxy")]
+use trusted_server_core::integrations::aps::{
+    APS_RUNNER_BLOCKING_READ_TIMEOUT, APS_RUNNER_FIRST_BYTE_TIMEOUT,
+};
 
 /// Fastly Compute runtime using Viceroy local simulator.
 ///
@@ -19,9 +31,73 @@ impl RuntimeEnvironment for FastlyViceroy {
     }
 
     fn spawn(&self, wasm_path: &Path) -> TestResult<RuntimeProcess> {
+        self.spawn_with_config(wasm_path, None)
+    }
+
+    #[cfg(feature = "aps-runner-proxy")]
+    fn spawn_aps_runner_proxy(
+        &self,
+        wasm_path: &Path,
+        fixture_url: &str,
+    ) -> TestResult<RuntimeProcess> {
+        let config = self.aps_runner_proxy_config(fixture_url)?;
+        self.spawn_with_config(wasm_path, Some(config))
+    }
+}
+
+impl FastlyViceroy {
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_runner_proxy_backend_definition(authority: &str) -> toml::Value {
+        let first_byte_timeout_ms = i64::try_from(APS_RUNNER_FIRST_BYTE_TIMEOUT.as_millis())
+            .expect("should fit the APS first-byte timeout in Viceroy configuration");
+        let between_bytes_timeout_ms = i64::try_from(APS_RUNNER_BLOCKING_READ_TIMEOUT.as_millis())
+            .expect("should fit the APS between-bytes timeout in Viceroy configuration");
+        toml::Value::Table(toml::Table::from_iter([
+            (
+                "url".to_string(),
+                toml::Value::String(format!("http://{authority}/")),
+            ),
+            (
+                "override_host".to_string(),
+                toml::Value::String("client.aps.amazon-adsystem.com".to_string()),
+            ),
+            (
+                "first_byte_timeout_ms".to_string(),
+                toml::Value::Integer(first_byte_timeout_ms),
+            ),
+            (
+                "between_bytes_timeout_ms".to_string(),
+                toml::Value::Integer(between_bytes_timeout_ms),
+            ),
+        ]))
+    }
+
+    /// Select the Viceroy executable for this test process.
+    ///
+    /// `VICEROY_BIN` allows a task to validate a different simulator build
+    /// without changing the repository's pinned installation or mutating
+    /// `PATH`.
+    fn viceroy_binary() -> OsString {
+        Self::viceroy_binary_from_override(std::env::var_os("VICEROY_BIN"))
+    }
+
+    fn viceroy_binary_from_override(override_binary: Option<OsString>) -> OsString {
+        override_binary
+            .filter(|binary| !binary.as_os_str().is_empty())
+            .unwrap_or_else(|| OsString::from("viceroy"))
+    }
+
+    fn spawn_with_config(
+        &self,
+        wasm_path: &Path,
+        generated_config: Option<NamedTempFile>,
+    ) -> TestResult<RuntimeProcess> {
         let port = super::find_available_port()?;
 
-        let viceroy_config = self.viceroy_config_path();
+        let viceroy_config = generated_config.as_ref().map_or_else(
+            || self.viceroy_config_path(),
+            |file| file.path().to_path_buf(),
+        );
         if !viceroy_config.exists() {
             return Err(Report::new(TestError::RuntimeSpawn).attach(format!(
                 "Viceroy config `{}` does not exist; run `scripts/generate-integration-viceroy-configs.sh` or `scripts/integration-tests.sh`, or set VICEROY_CONFIG_PATH to a generated config",
@@ -29,17 +105,22 @@ impl RuntimeEnvironment for FastlyViceroy {
             )));
         }
 
-        let mut child = Command::new("viceroy")
+        let mut command = Command::new(Self::viceroy_binary());
+        command
             .arg(wasm_path)
             .arg("-C")
             .arg(&viceroy_config)
             .arg("--addr")
             .arg(format!("127.0.0.1:{port}"))
             .stdout(Stdio::null())
-            .stderr(Stdio::piped())
+            .stderr(Stdio::piped());
+        #[cfg(unix)]
+        command.process_group(0);
+        let mut child = command
             .spawn()
             .change_context(TestError::RuntimeSpawn)
             .attach("Failed to spawn viceroy process")?;
+        super::register_process_group(&mut child)?;
 
         if let Some(stderr) = child.stderr.take() {
             std::thread::spawn(move || {
@@ -53,7 +134,10 @@ impl RuntimeEnvironment for FastlyViceroy {
         }
 
         // Wrap immediately so Drop::drop kills the process if readiness check fails
-        let handle = ViceroyHandle { child };
+        let handle = ViceroyHandle {
+            child,
+            _generated_config: generated_config,
+        };
         let base_url = format!("http://127.0.0.1:{port}");
 
         // Fastly exposes a dedicated `/health` route, so root fallback only
@@ -65,9 +149,73 @@ impl RuntimeEnvironment for FastlyViceroy {
             base_url,
         })
     }
-}
 
-impl FastlyViceroy {
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_runner_proxy_config(&self, fixture_url: &str) -> TestResult<NamedTempFile> {
+        let fixture = reqwest::Url::parse(fixture_url)
+            .change_context(TestError::RuntimeSpawn)
+            .attach("invalid fictional APS runner fixture URL")?;
+        if fixture.scheme() != "http"
+            || !matches!(fixture.host_str(), Some("127.0.0.1" | "::1"))
+            || fixture.port().is_none()
+            || fixture.path() != "/prebid-creative.js"
+            || fixture.query().is_some()
+            || fixture.fragment().is_some()
+        {
+            return Err(Report::new(TestError::RuntimeSpawn)
+                .attach("fictional APS runner fixture must be the exact loopback path"));
+        }
+        let base_path = self.viceroy_config_path();
+        let source = std::fs::read_to_string(&base_path)
+            .change_context(TestError::RuntimeSpawn)
+            .attach(format!(
+                "failed to read generated Viceroy config at {}",
+                base_path.display()
+            ))?;
+        let mut config: toml::Value = toml::from_str(&source)
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to parse generated Viceroy config")?;
+        config["local_server"]["config_stores"]["trusted_server_config"]["contents"]["trusted_server_config"] =
+            toml::Value::String(aps_runner_proxy_app_config_envelope(
+                crate::common::runtime::origin_port(),
+            )?);
+        let backends = config
+            .get_mut("local_server")
+            .and_then(toml::Value::as_table_mut)
+            .and_then(|local| local.get_mut("backends"))
+            .and_then(toml::Value::as_table_mut)
+            .ok_or_else(|| {
+                Report::new(TestError::RuntimeSpawn)
+                    .attach("generated Viceroy config is missing local_server.backends")
+            })?;
+        let host = fixture.host_str().ok_or_else(|| {
+            Report::new(TestError::RuntimeSpawn).attach("fixture has no authority")
+        })?;
+        let port = fixture.port().ok_or_else(|| {
+            Report::new(TestError::RuntimeSpawn).attach("fixture has no explicit port")
+        })?;
+        let authority = if host.contains(':') {
+            format!("[{host}]:{port}")
+        } else {
+            format!("{host}:{port}")
+        };
+        backends.insert(
+            "aps_runner_proxy_fixture".to_string(),
+            Self::aps_runner_proxy_backend_definition(&authority),
+        );
+        let serialized = toml::to_string(&config)
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to serialize APS Viceroy config")?;
+        let mut output = NamedTempFile::new()
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to create temporary APS Viceroy config")?;
+        output
+            .write_all(serialized.as_bytes())
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to write temporary APS Viceroy config")?;
+        Ok(output)
+    }
+
     /// Path to the generated Viceroy configuration.
     ///
     /// This contains `[local_server]` configuration (backends, KV stores,
@@ -94,13 +242,60 @@ impl FastlyViceroy {
 /// preventing orphaned Viceroy processes.
 struct ViceroyHandle {
     child: Child,
+    _generated_config: Option<NamedTempFile>,
 }
 
 impl RuntimeProcessHandle for ViceroyHandle {}
 
 impl Drop for ViceroyHandle {
     fn drop(&mut self) {
+        #[cfg(unix)]
+        unsafe {
+            libc::killpg(self.child.id() as libc::pid_t, libc::SIGTERM);
+        }
+        #[cfg(not(unix))]
         let _ = self.child.kill();
         let _ = self.child.wait();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::FastlyViceroy;
+    use std::ffi::OsString;
+
+    #[test]
+    fn viceroy_binary_uses_task_specific_override_or_default() {
+        assert_eq!(
+            FastlyViceroy::viceroy_binary_from_override(None),
+            OsString::from("viceroy")
+        );
+        assert_eq!(
+            FastlyViceroy::viceroy_binary_from_override(Some(OsString::new())),
+            OsString::from("viceroy")
+        );
+        assert_eq!(
+            FastlyViceroy::viceroy_binary_from_override(Some(OsString::from(
+                "/tmp/viceroy 0.19/bin/viceroy"
+            ))),
+            OsString::from("/tmp/viceroy 0.19/bin/viceroy")
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "aps-runner-proxy")]
+    fn aps_runner_proxy_static_backend_has_bounded_transport_timeouts() {
+        let definition = FastlyViceroy::aps_runner_proxy_backend_definition("127.0.0.1:43210");
+
+        assert_eq!(
+            definition["first_byte_timeout_ms"].as_integer(),
+            Some(4_000),
+            "fixture should enforce the APS first-byte timeout"
+        );
+        assert_eq!(
+            definition["between_bytes_timeout_ms"].as_integer(),
+            Some(250),
+            "fixture should enforce the APS between-bytes timeout"
+        );
+    }
+}
diff --git a/crates/trusted-server-integration-tests/tests/environments/mod.rs b/crates/trusted-server-integration-tests/tests/environments/mod.rs
index 41b3d69c0..430404b41 100644
--- a/crates/trusted-server-integration-tests/tests/environments/mod.rs
+++ b/crates/trusted-server-integration-tests/tests/environments/mod.rs
@@ -1,9 +1,13 @@
 pub mod axum;
 pub mod cloudflare;
 pub mod fastly;
+#[cfg(feature = "aps-runner-proxy")]
+pub mod spin;
 
 use crate::common::runtime::{RuntimeEnvironment, TestError, TestResult};
-use error_stack::Report;
+use error_stack::{Report, ResultExt as _};
+use std::io::Write as _;
+use std::process::Child;
 use std::time::Duration;
 
 /// Runtime factory function type — avoids trait object static initialization issues.
@@ -26,6 +30,48 @@ pub static RUNTIME_ENVIRONMENTS: &[RuntimeFactory] = &[
     || Box::new(cloudflare::CloudflareWorkers),
 ];
 
+/// Record an isolated runtime process group for the task-level shell trap.
+///
+/// The APS corpus launcher supplies a freshly-created file. Recording happens
+/// immediately after spawn so an interrupted Cargo process cannot leave the
+/// adapter's separately-isolated process tree behind.
+#[cfg(unix)]
+pub(crate) fn register_process_group(child: &mut Child) -> TestResult<()> {
+    let Some(path) = std::env::var_os("APS_RUNNER_PROXY_PROCESS_GROUP_FILE") else {
+        return Ok(());
+    };
+    let path = std::path::PathBuf::from(path);
+    let result = (|| {
+        if !path.is_absolute() {
+            return Err(Report::new(TestError::RuntimeSpawn)
+                .attach("APS process-group registry path must be absolute"));
+        }
+        let mut registry = std::fs::OpenOptions::new()
+            .append(true)
+            .open(&path)
+            .change_context(TestError::RuntimeSpawn)
+            .attach(format!(
+                "failed to open APS process-group registry {}",
+                path.display()
+            ))?;
+        writeln!(registry, "{}", child.id())
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to register APS runtime process group")
+    })();
+    if result.is_err() {
+        unsafe {
+            libc::killpg(child.id() as libc::pid_t, libc::SIGTERM);
+        }
+        let _ = child.wait();
+    }
+    result
+}
+
+#[cfg(not(unix))]
+pub(crate) fn register_process_group(_child: &mut Child) -> TestResult<()> {
+    Ok(())
+}
+
 /// Readiness polling configuration for runtimes and frontend containers.
 pub(crate) struct ReadyCheckOptions {
     pub(crate) max_attempts: usize,
diff --git a/crates/trusted-server-integration-tests/tests/environments/spin.rs b/crates/trusted-server-integration-tests/tests/environments/spin.rs
new file mode 100644
index 000000000..90dee34eb
--- /dev/null
+++ b/crates/trusted-server-integration-tests/tests/environments/spin.rs
@@ -0,0 +1,206 @@
+use crate::common::config::aps_runner_proxy_app_config_envelope;
+use crate::common::runtime::{
+    RuntimeEnvironment, RuntimeProcess, RuntimeProcessHandle, TestError, TestResult, origin_port,
+};
+use crate::environments::ReadyCheckOptions;
+use error_stack::{Report, ResultExt as _};
+use std::io::{BufRead as _, BufReader, Write as _};
+use std::path::Path;
+use std::process::{Child, Command, Stdio};
+use std::time::Duration;
+use tempfile::{NamedTempFile, TempDir};
+
+const APS_RUNNER_PROXY_MANIFEST: &str =
+    include_str!("../../fixtures/configs/spin-aps-runner-proxy.toml");
+const WASM_PLACEHOLDER: &str = "__APS_RUNNER_PROXY_WASM__";
+const INTEGRATION_SECRET_VARIABLES: &[(&str, &str)] = &[
+    (
+        "v_trusted_x5fserver_x5fsecrets_v_integration_x5fadmin_x5fpassword",
+        "integration-admin-password-32-bytes-ok",
+    ),
+    (
+        "v_trusted_x5fserver_x5fsecrets_v_integration_x5fproxy_x5fsecret",
+        "integration-test-proxy-secret-32-bytes-ok",
+    ),
+    (
+        "v_trusted_x5fserver_x5fsecrets_v_integration_x5fec_x5fpassphrase",
+        "integration-test-ec-secret-padded-32",
+    ),
+    (
+        "v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5falpha",
+        "integration-test-token-alpha-32-bytes-ok",
+    ),
+    (
+        "v_trusted_x5fserver_x5fsecrets_v_integration_x5fpartner_x5ftoken_x5fbravo",
+        "integration-test-token-bravo-32-bytes-ok",
+    ),
+];
+
+pub struct SpinRuntime;
+
+impl RuntimeEnvironment for SpinRuntime {
+    fn id(&self) -> &'static str {
+        "spin"
+    }
+
+    fn spawn(&self, _wasm_path: &Path) -> TestResult<RuntimeProcess> {
+        Err(Report::new(TestError::RuntimeSpawn)
+            .attach("Spin is available only in the dedicated APS proxy corpus for now"))
+    }
+
+    fn spawn_aps_runner_proxy(
+        &self,
+        wasm_path: &Path,
+        fixture_url: &str,
+    ) -> TestResult<RuntimeProcess> {
+        let port = super::find_available_port()?;
+        let app_config = aps_runner_proxy_app_config_envelope(origin_port())?;
+        let manifest = generated_manifest(wasm_path)?;
+        let state_directory = tempfile::tempdir()
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to create temporary Spin state directory")?;
+        let listen = format!("127.0.0.1:{port}");
+
+        let mut command = Command::new("spin");
+        command
+            .args(["up", "--from"])
+            .arg(manifest.path())
+            .args([
+                "--variable",
+                &format!("v_trusted_x5fserver_x5fconfig={app_config}"),
+            ])
+            .args([
+                "--variable",
+                &format!("aps_runner_proxy_test_endpoint={fixture_url}"),
+            ])
+            .arg("--state-dir")
+            .arg(state_directory.path())
+            .args(["--listen", &listen])
+            .stdout(Stdio::null())
+            .stderr(Stdio::piped());
+        for (name, value) in INTEGRATION_SECRET_VARIABLES {
+            command.args(["--variable", &format!("{name}={value}")]);
+        }
+        #[cfg(unix)]
+        {
+            use std::os::unix::process::CommandExt as _;
+            command.process_group(0);
+        }
+        let mut child = command
+            .spawn()
+            .change_context(TestError::RuntimeSpawn)
+            .attach("failed to spawn Spin APS runner proxy artifact")?;
+        super::register_process_group(&mut child)?;
+
+        if let Some(stderr) = child.stderr.take() {
+            std::thread::spawn(move || {
+                let reader = BufReader::new(stderr);
+                for line in reader.lines().map_while(Result::ok) {
+                    if !line.is_empty() {
+                        log::debug!("spin: {line}");
+                    }
+                }
+            });
+        }
+
+        let handle = SpinHandle {
+            child,
+            _manifest: manifest,
+            _state_directory: state_directory,
+        };
+        let base_url = format!("http://{listen}");
+        super::wait_for_http_ready(
+            &base_url,
+            self.health_check_path(),
+            ReadyCheckOptions {
+                max_attempts: 120,
+                interval: Duration::from_millis(500),
+                fallback_to_root: true,
+                timeout_error: TestError::RuntimeNotReady,
+                timeout_message: format!("Spin runtime at {base_url} not ready after 60s"),
+            },
+        )?;
+        Ok(RuntimeProcess {
+            inner: Box::new(handle),
+            base_url,
+        })
+    }
+
+    fn health_check_path(&self) -> &str {
+        "/health"
+    }
+}
+
+fn generated_manifest(wasm_path: &Path) -> TestResult<NamedTempFile> {
+    if APS_RUNNER_PROXY_MANIFEST.matches(WASM_PLACEHOLDER).count() != 1 {
+        return Err(Report::new(TestError::RuntimeSpawn)
+            .attach("Spin APS proxy manifest must contain one WASM placeholder"));
+    }
+    let wasm_path = wasm_path
+        .canonicalize()
+        .change_context(TestError::RuntimeSpawn)?;
+    let wasm_path = wasm_path.to_str().ok_or_else(|| {
+        Report::new(TestError::RuntimeSpawn).attach("Spin WASM path is not UTF-8")
+    })?;
+    let rendered = APS_RUNNER_PROXY_MANIFEST.replace(WASM_PLACEHOLDER, wasm_path);
+    let _: toml::Value = toml::from_str(&rendered)
+        .change_context(TestError::RuntimeSpawn)
+        .attach("generated Spin APS proxy manifest is invalid")?;
+    let mut output = tempfile::Builder::new()
+        .suffix(".toml")
+        .tempfile()
+        .change_context(TestError::RuntimeSpawn)
+        .attach("failed to create temporary Spin APS proxy manifest")?;
+    output
+        .write_all(rendered.as_bytes())
+        .change_context(TestError::RuntimeSpawn)
+        .attach("failed to write Spin APS proxy manifest")?;
+    Ok(output)
+}
+
+struct SpinHandle {
+    child: Child,
+    _manifest: NamedTempFile,
+    _state_directory: TempDir,
+}
+
+impl RuntimeProcessHandle for SpinHandle {}
+
+impl Drop for SpinHandle {
+    fn drop(&mut self) {
+        #[cfg(unix)]
+        {
+            let pgid = self.child.id() as libc::pid_t;
+            unsafe {
+                libc::killpg(pgid, libc::SIGTERM);
+            }
+        }
+        #[cfg(not(unix))]
+        {
+            let _ = self.child.kill();
+        }
+        let _ = self.child.wait();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn manifest_has_one_wasm_placeholder_and_required_test_variables() {
+        assert_eq!(
+            APS_RUNNER_PROXY_MANIFEST.matches(WASM_PLACEHOLDER).count(),
+            1
+        );
+        assert!(APS_RUNNER_PROXY_MANIFEST.contains("aps_runner_proxy_test_endpoint"));
+        assert!(APS_RUNNER_PROXY_MANIFEST.contains("v_trusted_x5fserver_x5fconfig"));
+        for (name, _) in INTEGRATION_SECRET_VARIABLES {
+            assert!(
+                APS_RUNNER_PROXY_MANIFEST.contains(name),
+                "manifest should declare and map `{name}`"
+            );
+        }
+        assert!(!APS_RUNNER_PROXY_MANIFEST.contains("https://*:*"));
+    }
+}
diff --git a/crates/trusted-server-integration-tests/tests/frameworks/scenarios.rs b/crates/trusted-server-integration-tests/tests/frameworks/scenarios.rs
index c1bbafe8d..6a66ab1ac 100644
--- a/crates/trusted-server-integration-tests/tests/frameworks/scenarios.rs
+++ b/crates/trusted-server-integration-tests/tests/frameworks/scenarios.rs
@@ -119,7 +119,17 @@ impl TestScenario {
             }
 
             Self::ScriptServing => {
-                let url = format!("{base_url}/static/tsjs=tsjs-unified.min.js");
+                let html = reqwest::blocking::get(base_url)
+                    .change_context(TestError::HttpRequest)
+                    .attach(format!(
+                        "scenario: ScriptServing discovery, framework: {framework_id}"
+                    ))?
+                    .text()
+                    .change_context(TestError::ResponseParse)
+                    .attach(format!("framework: {framework_id}"))?;
+                let script_src = assertions::trustedserver_script_src(&html)
+                    .attach(format!("framework: {framework_id}"))?;
+                let url = format!("{base_url}{script_src}");
 
                 let resp = reqwest::blocking::get(&url)
                     .change_context(TestError::HttpRequest)
diff --git a/crates/trusted-server-integration-tests/tests/parity.rs b/crates/trusted-server-integration-tests/tests/parity.rs
index acf7f5f4b..13959c628 100644
--- a/crates/trusted-server-integration-tests/tests/parity.rs
+++ b/crates/trusted-server-integration-tests/tests/parity.rs
@@ -14,10 +14,12 @@ use edgezero_adapter_axum::service::EdgeZeroAxumService;
 use edgezero_core::http::request_builder;
 use edgezero_core::router::RouterService;
 use http::HeaderMap;
+use std::collections::BTreeMap;
 use tower::{Service as _, ServiceExt as _};
 use trusted_server_adapter_axum::app::TrustedServerApp as AxumApp;
 use trusted_server_adapter_cloudflare::app::TrustedServerApp as CloudflareApp;
 use trusted_server_adapter_spin::app::TrustedServerApp as SpinApp;
+use trusted_server_core::integrations::aps::APS_RENDERER_V2_ROUTE;
 use trusted_server_core::settings::Settings;
 
 /// Shared test settings for all adapters.
@@ -44,6 +46,19 @@ fn test_settings() -> Settings {
 
             [ec]
             passphrase = "test-secret-key-32-bytes-minimum"
+
+            [auction]
+            enabled = true
+
+            [auction.providers.aps-main]
+            protocol = "openrtb-2.6"
+            profile = "aps"
+            endpoint = "https://aps.example/e/pb/bid"
+            routing = "all_eligible"
+
+            [auction.providers.aps-main.profile_config]
+            account_id = "parity-test-aps-account"
+            allow_script_creatives = true
         "#,
     )
     .expect("should parse parity test settings")
@@ -703,27 +718,22 @@ async fn page_bids_options_preflight_denied_parity() {
     // browser. The denial is unconditional (independent of creative-opportunity
     // configuration), so all adapters must agree on 403.
     //
-    // The deprecated `/__ts/page-bids` alias routes to the same handler, so it
-    // must deny the preflight identically — an alias that fell through to the
-    // origin would reopen the hole the canonical path closes.
-    for path in ["/_ts/page-bids", "/__ts/page-bids"] {
-        let (axum_status, _) = axum_options(path).await;
-        let (cf_status, _) = cf_options(path).await;
-        let (spin_status, _) = spin_options(path).await;
+    let path = "/_ts/page-bids";
+    let (axum_status, _) = axum_options(path).await;
+    let (cf_status, _) = cf_options(path).await;
+    let (spin_status, _) = spin_options(path).await;
 
-        assert_eq!(
-            axum_status, 403,
-            "Axum OPTIONS {path} must be denied with 403, got {axum_status}"
-        );
-        assert_eq!(
-            cf_status, 403,
-            "Cloudflare OPTIONS {path} must be denied with 403, got {cf_status}"
-        );
-        assert_eq!(
-            spin_status, 403,
-            "Spin OPTIONS {path} must be denied with 403, got {spin_status}"
-        );
-    }
+    assert_eq!(axum_status, 403, "Axum OPTIONS must be denied");
+    assert_eq!(cf_status, 403, "Cloudflare OPTIONS must be denied");
+    assert_eq!(spin_status, 403, "Spin OPTIONS must be denied");
+
+    let removed = "/__ts/page-bids";
+    let (axum_status, _) = axum_options(removed).await;
+    let (cf_status, _) = cf_options(removed).await;
+    let (spin_status, _) = spin_options(removed).await;
+    assert_eq!(axum_status, 404, "Axum removed alias must be unknown");
+    assert_eq!(cf_status, 404, "Cloudflare removed alias must be unknown");
+    assert_eq!(spin_status, 404, "Spin removed alias must be unknown");
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -758,6 +768,94 @@ async fn spin_auction_ignores_spoofed_forwarded_headers() {
     );
 }
 
+fn canonical_headers(headers: &HeaderMap) -> BTreeMap<String, Vec<String>> {
+    let mut canonical = BTreeMap::<String, Vec<String>>::new();
+    for (name, value) in headers {
+        canonical
+            .entry(name.as_str().to_string())
+            .or_default()
+            .push(
+                value
+                    .to_str()
+                    .expect("renderer response headers should be UTF-8")
+                    .to_string(),
+            );
+    }
+    canonical
+}
+
+fn aps_renderer_request() -> edgezero_core::http::Request {
+    request_builder()
+        .method("GET")
+        .uri(APS_RENDERER_V2_ROUTE)
+        .body(edgezero_core::body::Body::empty())
+        .expect("should build APS renderer request")
+}
+
+fn response_parts(response: edgezero_core::http::Response) -> (u16, HeaderMap, bytes::Bytes) {
+    let status = response.status().as_u16();
+    let headers = response.headers().clone();
+    let body = response
+        .into_body()
+        .into_bytes()
+        .expect("APS renderer response body should be buffered");
+    (status, headers, body)
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn aps_renderer_v2_response_is_exact_across_portable_adapters() {
+    let axum = trusted_server_adapter_axum::app::dispatch_reserved_with_settings(
+        test_settings(),
+        aps_renderer_request(),
+    )
+    .await
+    .expect("Axum reserved dispatcher should initialize")
+    .expect("Axum APS renderer path should be reserved");
+    let cloudflare = trusted_server_adapter_cloudflare::app::dispatch_reserved_with_settings(
+        test_settings(),
+        aps_renderer_request(),
+    )
+    .await
+    .expect("Cloudflare reserved dispatcher should initialize")
+    .expect("Cloudflare APS renderer path should be reserved");
+    let spin = trusted_server_adapter_spin::app::dispatch_reserved_with_settings(
+        test_settings(),
+        aps_renderer_request(),
+    )
+    .await
+    .expect("Spin reserved dispatcher should initialize")
+    .expect("Spin APS renderer path should be reserved");
+    let axum = response_parts(axum);
+    let cloudflare = response_parts(cloudflare);
+    let spin = response_parts(spin);
+
+    assert_eq!(axum.0, 200, "Axum renderer should be available");
+    assert_eq!(cloudflare.0, 200, "Cloudflare renderer should be available");
+    assert_eq!(spin.0, 200, "Spin renderer should be available");
+    assert_eq!(axum.2, cloudflare.2, "renderer bytes should match");
+    assert_eq!(cloudflare.2, spin.2, "renderer bytes should match");
+
+    let axum_headers = canonical_headers(&axum.1);
+    let cloudflare_headers = canonical_headers(&cloudflare.1);
+    let spin_headers = canonical_headers(&spin.1);
+    assert_eq!(
+        axum_headers, cloudflare_headers,
+        "renderer response headers should match"
+    );
+    assert_eq!(
+        cloudflare_headers, spin_headers,
+        "renderer response headers should match"
+    );
+    assert!(
+        !axum_headers.contains_key("x-geo-info-available"),
+        "the exact renderer contract should bypass generic response decoration"
+    );
+    assert!(
+        !axum_headers.contains_key("x-frame-options"),
+        "the sandbox contract deliberately omits X-Frame-Options"
+    );
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn publisher_proxy_fallback_parity() {
     // Cookie (Set-Cookie) parity for the publisher proxy requires a live origin.
diff --git a/crates/trusted-server-js/Cargo.toml b/crates/trusted-server-js/Cargo.toml
index 67a4ac698..6c60d39fd 100644
--- a/crates/trusted-server-js/Cargo.toml
+++ b/crates/trusted-server-js/Cargo.toml
@@ -18,7 +18,8 @@ path = "src/lib.rs"
 
 [build-dependencies]
 build-print = { workspace = true }
-hex = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
 sha2 = { workspace = true }
 which = { workspace = true }
 
diff --git a/crates/trusted-server-js/build.rs b/crates/trusted-server-js/build.rs
index ba6cd88f2..7cd37b913 100644
--- a/crates/trusted-server-js/build.rs
+++ b/crates/trusted-server-js/build.rs
@@ -4,7 +4,6 @@
     reason = "build script failures should stop Cargo with a clear diagnostic"
 )]
 
-use std::cmp::Ordering;
 use std::env;
 use std::fmt::Write as _;
 use std::fs;
@@ -12,39 +11,84 @@ use std::path::{Path, PathBuf};
 use std::process::{Command, ExitStatus};
 
 use build_print::{info, warn};
+use serde::Deserialize;
 use sha2::{Digest as _, Sha256};
 
+const RELEASE_SENTINEL: &str = "__TSJS_RELEASE_ID_SENTINEL_V1__";
+const RELEASE_PREFIX: &[u8] = b"tsjs-release-v1\0";
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct ReleaseManifest {
+    version: u8,
+    release_id: String,
+    artifacts: Vec<ReleaseArtifact>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ReleaseArtifact {
+    id: String,
+    role: String,
+    phase: Option<String>,
+    trigger: Option<String>,
+    inputs: Vec<String>,
+    outputs: Vec<String>,
+    file: String,
+    bytes: usize,
+    hash: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct CatalogManifest {
+    version: u8,
+    first_display: Vec<FirstDisplayCatalogModule>,
+    permitted_first_display_masks: Vec<String>,
+    modules: Vec<CatalogModule>,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+struct FirstDisplayCatalogModule {
+    order: usize,
+    id: String,
+    include: String,
+    allowed_imports: Vec<String>,
+    inputs: Vec<String>,
+    outputs: Vec<String>,
+    obligation: String,
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct CatalogModule {
+    id: String,
+    phase: String,
+    trigger: Option<String>,
+    include: String,
+}
+
 fn main() {
-    // Rebuild if TS sources change (belt-and-suspenders): enumerate every file under lib/
     println!("cargo:rerun-if-changed=lib");
     watch_dir_recursively(Path::new("lib"));
 
-    // Allow opt-out or force via env
     let skip = env::var("TSJS_SKIP_BUILD").is_ok_and(|value| value == "1");
-
     let crate_dir = PathBuf::from(
         env::var("CARGO_MANIFEST_DIR").expect("should set CARGO_MANIFEST_DIR for build script"),
     );
     let out_dir = PathBuf::from(env::var("OUT_DIR").expect("should set OUT_DIR for build script"));
     let ts_dir = crate_dir.join("lib");
     let dist_dir = crate_dir.join("dist");
-
-    // Ensure dist exists
     fs::create_dir_all(&dist_dir).expect("should create dist directory");
 
-    // Only try to build if we have a library project
     if !ts_dir.join("package.json").exists() {
-        // No TS project; rely on prebuilt dist if present
         return;
     }
-
-    // If Node/npm is absent, keep going if dist exists
     let npm = which::which("npm").ok();
     if npm.is_none() {
         warn!("tsjs: npm not found; will use existing dist if available");
     }
-
-    // Install deps if node_modules missing
     if !skip
         && let Some(npm_path) = npm.as_deref()
         && !ts_dir.join("node_modules").exists()
@@ -57,8 +101,6 @@ fn main() {
             warn!("tsjs: npm ci failed; using existing dist if available");
         }
     }
-
-    // Run tests if requested
     if !skip
         && env::var("TSJS_TEST").is_ok_and(|value| value == "1")
         && let Some(npm_path) = npm.as_deref()
@@ -69,11 +111,8 @@ fn main() {
             .status()
             .expect("should run requested TSJS tests");
     }
-
-    // Build all module files
     if !skip && let Some(npm_path) = npm.as_deref() {
-        info!("tsjs: Building per-module bundles");
-
+        info!("tsjs: Building phase-aware release artifacts");
         let status = Command::new(npm_path)
             .args(["run", "build"])
             .current_dir(&ts_dir)
@@ -84,118 +123,405 @@ fn main() {
         );
     }
 
-    // Discover all tsjs-*.js files in dist/
-    let mut modules: Vec<(String, String)> = Vec::new(); // (id, filename)
-    if let Ok(entries) = fs::read_dir(&dist_dir) {
-        for entry in entries.flatten() {
-            let filename = entry.file_name().to_string_lossy().to_string();
-            if let Some(id) = filename
-                .strip_prefix("tsjs-")
-                .and_then(|stem| stem.strip_suffix(".js"))
-            {
-                modules.push((id.to_owned(), filename));
-            }
-        }
+    let manifest = read_and_validate_release(&dist_dir);
+    let catalog = read_and_validate_catalog(&dist_dir, &manifest);
+    for artifact in &manifest.artifacts {
+        copy_bundle(&artifact.file, &crate_dir, &dist_dir, &out_dir);
     }
+    generate_metadata(&manifest, &catalog, &out_dir);
+    info!(
+        "tsjs: Embedded {} canonical release artifacts",
+        manifest.artifacts.len()
+    );
+}
 
-    // Sort alphabetically but ensure "core" is always first
-    modules.sort_by(|left, right| {
-        if left.0 == "core" {
-            Ordering::Less
-        } else if right.0 == "core" {
-            Ordering::Greater
-        } else {
-            left.0.cmp(&right.0)
-        }
-    });
-
+fn read_and_validate_catalog(dist_dir: &Path, release: &ReleaseManifest) -> CatalogManifest {
+    let catalog_text = fs::read_to_string(dist_dir.join("tsjs-catalog-v1.json"))
+        .expect("should read generated catalog manifest");
+    let catalog: CatalogManifest =
+        serde_json::from_str(&catalog_text).expect("should parse exact catalog manifest");
+    assert_eq!(
+        catalog.version, 1,
+        "tsjs: catalog manifest version must be one"
+    );
+    assert_eq!(
+        catalog.modules.len(),
+        20,
+        "tsjs: catalog must contain twenty modules"
+    );
+    let first_display_artifacts = release
+        .artifacts
+        .iter()
+        .filter(|artifact| {
+            artifact.role == "first_display_base" || artifact.role == "first_display_slice"
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        catalog.first_display.len(),
+        14,
+        "tsjs: first-display catalog must contain base plus thirteen slices"
+    );
+    assert_eq!(
+        first_display_artifacts.len(),
+        catalog.first_display.len(),
+        "tsjs: first-display catalog/release count mismatch"
+    );
+    let mut previous_mask = None;
     assert!(
-        !modules.is_empty(),
-        "tsjs: no tsjs-*.js files found in {}. Ensure `npm run build` succeeds.",
-        dist_dir.display()
+        !catalog.permitted_first_display_masks.is_empty(),
+        "tsjs: at least one first-display mask must satisfy the release ceilings"
     );
-
-    info!(
-        "tsjs: Discovered {} module files: {:?}",
-        modules.len(),
-        modules
+    let mask_limit = 1_u16 << catalog.first_display.len();
+    let mask_bit = |id: &str| {
+        catalog
+            .first_display
             .iter()
-            .map(|(id, _)| id.as_str())
-            .collect::<Vec<_>>()
+            .position(|module| module.id == id)
+            .map(|index| 1_u16 << index)
+            .unwrap_or_else(|| panic!("tsjs: first-display catalog is missing {id}"))
+    };
+    let gpt_mask = mask_bit("gpt_initial");
+    let render_owner_mask = mask_bit("render_owner_initial");
+    let aps_mask = mask_bit("aps_initial");
+    let prebid_mask = mask_bit("prebid_initial");
+    for encoded in &catalog.permitted_first_display_masks {
+        assert!(
+            encoded.len() == 4
+                && encoded
+                    .bytes()
+                    .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)),
+            "tsjs: permitted first-display mask must be four lowercase hex digits"
+        );
+        let mask = u16::from_str_radix(encoded, 16)
+            .expect("should parse validated permitted first-display mask");
+        assert_eq!(
+            mask & 1,
+            1,
+            "tsjs: permitted first-display mask must contain the base"
+        );
+        assert!(
+            mask < mask_limit,
+            "tsjs: permitted first-display mask contains an unknown slice bit"
+        );
+        assert!(
+            mask & (render_owner_mask | aps_mask | prebid_mask) == 0 || mask & gpt_mask != 0,
+            "tsjs: render-owner, APS, and Prebid participation require GPT initial ownership"
+        );
+        assert!(
+            mask & aps_mask == 0 || mask & render_owner_mask != 0,
+            "tsjs: APS participation requires render-owner initial ownership"
+        );
+        assert!(
+            previous_mask.is_none_or(|previous| mask > previous),
+            "tsjs: permitted first-display masks must be unique and ordered"
+        );
+        previous_mask = Some(mask);
+    }
+    for (index, (module, artifact)) in catalog
+        .first_display
+        .iter()
+        .zip(first_display_artifacts)
+        .enumerate()
+    {
+        assert_eq!(
+            module.order,
+            index + 1,
+            "tsjs: first-display order mismatch"
+        );
+        assert_eq!(module.id, artifact.id, "tsjs: first-display id mismatch");
+        assert_eq!(
+            artifact.role,
+            if index == 0 {
+                "first_display_base"
+            } else {
+                "first_display_slice"
+            },
+            "tsjs: first-display role mismatch"
+        );
+        assert_eq!(artifact.phase.as_deref(), Some("first_display"));
+        assert!(artifact.trigger.is_none());
+        assert_eq!(module.inputs, artifact.inputs);
+        assert_eq!(module.outputs, artifact.outputs);
+        assert!(!module.allowed_imports.is_empty());
+        assert!(!module.obligation.is_empty());
+        assert!(
+            module.include == "eligible_batch"
+                || module.include == "render_owner_participates"
+                || module.include == "aps_participates"
+                || module.include == "creative_guard"
+                || module.include == "gpt_initial"
+                || module.include == "prebid_participates"
+                || module.include.starts_with("integration:"),
+            "tsjs: unknown first-display inclusion predicate"
+        );
+    }
+    let integration_artifacts = release
+        .artifacts
+        .iter()
+        .filter(|artifact| artifact.role == "integration")
+        .collect::<Vec<_>>();
+    assert_eq!(integration_artifacts.len(), catalog.modules.len());
+    for (module, artifact) in catalog.modules.iter().zip(integration_artifacts) {
+        assert_eq!(module.id, artifact.id, "tsjs: catalog/release id mismatch");
+        assert_eq!(
+            Some(module.phase.as_str()),
+            artifact.phase.as_deref(),
+            "tsjs: catalog/release phase mismatch"
+        );
+        assert_eq!(
+            module.trigger.as_deref(),
+            artifact.trigger.as_deref(),
+            "tsjs: catalog/release trigger mismatch"
+        );
+        assert!(
+            module.include == "always"
+                || module.include == "creative_guard"
+                || module.include == "gpt_diagnostics_active"
+                || module.include == "diagnostics_presentation"
+                || module.include == "prebid_and_gpt"
+                || module.include.starts_with("integration:"),
+            "tsjs: unknown catalog inclusion predicate"
+        );
+    }
+    catalog
+}
+
+fn read_and_validate_release(dist_dir: &Path) -> ReleaseManifest {
+    let manifest_text = fs::read_to_string(dist_dir.join("tsjs-release-v1.json"))
+        .expect("should read generated release manifest");
+    let manifest: ReleaseManifest =
+        serde_json::from_str(&manifest_text).expect("should parse exact release manifest");
+    assert_eq!(
+        manifest.version, 1,
+        "tsjs: release manifest version must be one"
+    );
+    assert!(
+        valid_hash(&manifest.release_id),
+        "tsjs: generated manifest has invalid release id"
+    );
+    assert_eq!(
+        manifest.artifacts.len(),
+        36,
+        "tsjs: release must contain bootstrap, fourteen first-display components, core, and twenty integrations"
     );
+    assert_eq!(manifest.artifacts[0].id, "bootstrap");
+    assert_eq!(manifest.artifacts[0].role, "bootstrap");
+    assert_eq!(manifest.artifacts[1].id, "first_display");
+    assert_eq!(manifest.artifacts[1].role, "first_display_base");
+    assert_eq!(manifest.artifacts[15].id, "core");
+    assert_eq!(manifest.artifacts[15].role, "core");
 
-    // Copy each module file to OUT_DIR
-    for (_, filename) in &modules {
-        copy_bundle(filename, true, &dist_dir, &out_dir);
-    }
+    let mut canonical = Vec::new();
+    canonical.extend_from_slice(RELEASE_PREFIX);
+    push_u64(&mut canonical, manifest.artifacts.len());
+    let mut ids = std::collections::HashSet::new();
+    let mut integration_index = 0_usize;
+    for (index, artifact) in manifest.artifacts.iter().enumerate() {
+        assert!(ids.insert(&artifact.id), "tsjs: duplicate artifact id");
+        match artifact.role.as_str() {
+            "bootstrap" | "core" => {
+                assert!(artifact.phase.is_none() && artifact.trigger.is_none());
+            }
+            "first_display_base" | "first_display_slice" => {
+                assert!((1..=14).contains(&index));
+                assert_eq!(artifact.phase.as_deref(), Some("first_display"));
+                assert!(artifact.trigger.is_none());
+            }
+            "integration" => {
+                assert!(index >= 16);
+                if integration_index < 14 {
+                    assert_eq!(artifact.phase.as_deref(), Some("takeover"));
+                    assert!(artifact.trigger.is_none());
+                } else {
+                    assert_eq!(artifact.phase.as_deref(), Some("deferred"));
+                    assert_eq!(artifact.trigger.as_deref(), Some("first_display_or_idle"));
+                    assert!(
+                        artifact.outputs.is_empty(),
+                        "tsjs: deferred provider is forbidden"
+                    );
+                }
+                integration_index += 1;
+            }
+            role => panic!("tsjs: unknown release artifact role {role}"),
+        }
 
-    // Generate tsjs_modules.rs with include_str!() for each module
-    let mut codegen = String::new();
-    codegen.push_str("// Auto-generated by build.rs - DO NOT EDIT\n\n");
+        let source = fs::read_to_string(dist_dir.join(&artifact.file))
+            .unwrap_or_else(|error| panic!("tsjs: failed to read {}: {error}", artifact.file));
+        assert_eq!(
+            source.len(),
+            artifact.bytes,
+            "tsjs: artifact byte length mismatch"
+        );
+        assert_eq!(
+            hex_digest(source.as_bytes()),
+            artifact.hash,
+            "tsjs: artifact content hash mismatch"
+        );
+        assert_eq!(
+            source.matches(&manifest.release_id).count(),
+            1,
+            "tsjs: artifact must carry the release id exactly once"
+        );
+        assert!(
+            !source.contains(RELEASE_SENTINEL),
+            "tsjs: release sentinel remains"
+        );
+        let normalized = source.replacen(&manifest.release_id, RELEASE_SENTINEL, 1);
+        push_frame(&mut canonical, artifact.id.as_bytes());
+        push_frame(&mut canonical, artifact.role.as_bytes());
+        push_frame(
+            &mut canonical,
+            artifact.phase.as_deref().unwrap_or_default().as_bytes(),
+        );
+        push_frame(
+            &mut canonical,
+            artifact.trigger.as_deref().unwrap_or_default().as_bytes(),
+        );
+        push_frame(&mut canonical, normalized.as_bytes());
+    }
+    assert_eq!(
+        hex_digest(&canonical),
+        manifest.release_id,
+        "tsjs: sentinel-normalized release hash mismatch"
+    );
+    manifest
+}
 
+fn generate_metadata(manifest: &ReleaseManifest, catalog: &CatalogManifest, out_dir: &Path) {
+    let mut code = String::from("// Auto-generated by build.rs - DO NOT EDIT\n\n");
+    let integrations = manifest
+        .artifacts
+        .iter()
+        .filter(|artifact| artifact.role == "integration")
+        .count();
+    let takeover = manifest
+        .artifacts
+        .iter()
+        .filter(|artifact| artifact.phase.as_deref() == Some("takeover"))
+        .count();
+    writeln!(
+        code,
+        "pub(crate) const TSJS_RELEASE_ID: &str = {:?};",
+        manifest.release_id
+    )
+    .expect("should write release id");
+    writeln!(
+        code,
+        "pub(crate) const GENERATED_MAX_TAKEOVER_MODULES: usize = {takeover};\npub(crate) const GENERATED_MAX_MANIFEST_MODULES: usize = {integrations};"
+    )
+    .expect("should write generated capacities");
+    writeln!(
+        code,
+        "pub(crate) const PERMITTED_FIRST_DISPLAY_MASKS: &[u16] = &[{}];",
+        catalog
+            .permitted_first_display_masks
+            .iter()
+            .map(|mask| format!("0x{mask}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+    .expect("should write permitted first-display masks");
+    code.push_str(
+        "pub(crate) const TSJS_BOOTSTRAP: &str = include_str!(concat!(env!(\"OUT_DIR\"), \"/tsjs-bootstrap.js\"));\n\n",
+    );
     writeln!(
-        codegen,
-        "pub(crate) const TSJS_MODULES: [TsjsModuleMeta; {}] = [",
-        modules.len()
+        code,
+        "pub(crate) const TSJS_ARTIFACTS: [TsjsGeneratedArtifactMeta; {}] = [",
+        manifest.artifacts.len()
     )
-    .expect("should write generated module header");
-    for (id, filename) in &modules {
-        let sha256 = bundle_sha256(&out_dir.join(filename));
+    .expect("should write generated artifact header");
+    for artifact in &manifest.artifacts {
+        let inputs = rust_string_slice(&artifact.inputs);
+        let outputs = rust_string_slice(&artifact.outputs);
+        let include = match artifact.role.as_str() {
+            "integration" => catalog
+                .modules
+                .iter()
+                .find(|module| module.id == artifact.id)
+                .map(|module| module.include.as_str()),
+            "first_display_base" | "first_display_slice" => catalog
+                .first_display
+                .iter()
+                .find(|module| module.id == artifact.id)
+                .map(|module| module.include.as_str()),
+            _ => None,
+        };
         writeln!(
-            codegen,
-            "    TsjsModuleMeta {{\n        bundle: include_str!(concat!(env!(\"OUT_DIR\"), \"/{filename}\")),\n        id: \"{id}\",\n        sha256: \"{sha256}\",\n    }},\n"
+            code,
+            "    TsjsGeneratedArtifactMeta {{ id: {:?}, role: {:?}, phase: {}, trigger: {}, include: {}, inputs: {inputs}, outputs: {outputs}, file: {:?}, hash: {:?}, bundle: include_str!(concat!(env!(\"OUT_DIR\"), {:?})) }},",
+            artifact.id,
+            artifact.role,
+            rust_option(artifact.phase.as_deref()),
+            rust_option(artifact.trigger.as_deref()),
+            rust_option(include),
+            artifact.file,
+            artifact.hash,
+            format!("/{}", artifact.file),
         )
-        .expect("should write generated module entry");
+        .expect("should write generated artifact");
     }
-    codegen.push_str("];\n");
-    codegen.push_str("\npub(crate) struct TsjsModuleMeta {\n");
-    codegen.push_str("    pub bundle: &'static str,\n");
-    codegen.push_str("    pub id: &'static str,\n");
-    codegen.push_str("    pub sha256: &'static str,\n");
-    codegen.push_str("}\n");
+    code.push_str(
+        "];\n\npub(crate) struct TsjsGeneratedArtifactMeta {\n    pub bundle: &'static str,\n    pub file: &'static str,\n    pub hash: &'static str,\n    pub id: &'static str,\n    pub include: Option<&'static str>,\n    pub inputs: &'static [&'static str],\n    pub outputs: &'static [&'static str],\n    pub phase: Option<&'static str>,\n    pub role: &'static str,\n    pub trigger: Option<&'static str>,\n}\n",
+    );
+    fs::write(out_dir.join("tsjs_modules.rs"), code).expect("should write generated TSJS metadata");
+}
 
-    let generated_path = out_dir.join("tsjs_modules.rs");
-    fs::write(&generated_path, &codegen).unwrap_or_else(|err| {
-        panic!(
-            "tsjs: failed to write generated code to {}: {err}",
-            generated_path.display()
-        );
-    });
+fn rust_string_slice(values: &[String]) -> String {
+    format!(
+        "&[{}]",
+        values
+            .iter()
+            .map(|value| format!("{value:?}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
 }
 
-fn bundle_sha256(path: &Path) -> String {
-    let content = fs::read(path).unwrap_or_else(|err| {
-        panic!(
-            "tsjs: failed to read copied bundle {} for hashing: {err}",
-            path.display()
-        );
-    });
-    hex::encode(Sha256::digest(&content))
+fn rust_option(value: Option<&str>) -> String {
+    value.map_or_else(|| "None".to_owned(), |value| format!("Some({value:?})"))
 }
 
-fn copy_bundle(filename: &str, required: bool, dist_dir: &Path, out_dir: &Path) {
-    let source = dist_dir.join(filename);
-    let target = out_dir.join(filename);
+fn push_u64(target: &mut Vec<u8>, value: usize) {
+    let value = u64::try_from(value).expect("should fit release frame length in u64");
+    target.extend_from_slice(&value.to_be_bytes());
+}
 
-    if source.exists() {
-        if let Err(err) = fs::copy(&source, &target) {
-            assert!(
-                !required,
-                "tsjs: failed to copy {} to {}: {err}",
-                source.display(),
-                target.display()
-            );
-        }
-        return;
-    }
+fn push_frame(target: &mut Vec<u8>, bytes: &[u8]) {
+    push_u64(target, bytes.len());
+    target.extend_from_slice(bytes);
+}
 
-    assert!(
-        !required,
-        "tsjs: bundle {filename} not found: {}. Ensure Node is installed and `npm run build` succeeds, or commit dist/{filename}.",
-        source.display()
-    );
+fn valid_hash(value: &str) -> bool {
+    value.len() == 64
+        && value
+            .bytes()
+            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+}
 
-    fs::write(&target, "").expect("should write optional empty bundle placeholder");
+fn hex_digest(bytes: &[u8]) -> String {
+    Sha256::digest(bytes)
+        .iter()
+        .map(|byte| format!("{byte:02x}"))
+        .collect()
+}
+
+fn copy_bundle(filename: &str, crate_dir: &Path, dist_dir: &Path, out_dir: &Path) {
+    let primary = dist_dir.join(filename);
+    let fallback = crate_dir.join("dist").join(filename);
+    let target = out_dir.join(filename);
+    for source in [&primary, &fallback] {
+        if source.exists() {
+            fs::copy(source, &target).unwrap_or_else(|error| {
+                panic!(
+                    "tsjs: failed to copy {} to {}: {error}",
+                    source.display(),
+                    target.display()
+                )
+            });
+            return;
+        }
+    }
+    panic!("tsjs: bundle {filename} was not generated");
 }
 
 fn watch_dir_recursively(root: &Path) {
@@ -203,15 +529,14 @@ fn watch_dir_recursively(root: &Path) {
         return;
     }
     let mut stack = vec![root.to_path_buf()];
-    while let Some(dir) = stack.pop() {
-        let Ok(read) = fs::read_dir(&dir) else {
+    while let Some(directory) = stack.pop() {
+        let Ok(entries) = fs::read_dir(&directory) else {
             continue;
         };
-        for entry in read.flatten() {
+        for entry in entries.flatten() {
             let path = entry.path();
-            // Always ask Cargo to rerun if this path changes
-            if let Some(path_str) = path.to_str() {
-                println!("cargo:rerun-if-changed={path_str}");
+            if let Some(path_string) = path.to_str() {
+                println!("cargo:rerun-if-changed={path_string}");
             }
             if path.is_dir() {
                 stack.push(path);
diff --git a/crates/trusted-server-js/lib/.prettierignore b/crates/trusted-server-js/lib/.prettierignore
index 72274829b..6b02254be 100644
--- a/crates/trusted-server-js/lib/.prettierignore
+++ b/crates/trusted-server-js/lib/.prettierignore
@@ -1,4 +1,5 @@
 node_modules
 dist
 coverage
-
+src/core/contracts/generated/renderer_validator_v1.ts
+test/fixtures/performance/aps-tsjs-prechange.json
diff --git a/crates/trusted-server-js/lib/build-all.mjs b/crates/trusted-server-js/lib/build-all.mjs
index 2bfee01b1..742d3e90d 100644
--- a/crates/trusted-server-js/lib/build-all.mjs
+++ b/crates/trusted-server-js/lib/build-all.mjs
@@ -1,93 +1,493 @@
-/**
- * Multi-entry Vite build script.
- *
- * Builds each integration as a separate IIFE file so the Rust server can
- * concatenate only the enabled modules at runtime.
- *
- * Output (in ../dist/):
- *   tsjs-core.js          — core API (always included)
- *   tsjs-<integration>.js — one per discovered integration
- *
- * The prebid integration builds here as the tsjs shim only — Prebid.js itself
- * is never bundled into tsjs. Use build-prebid-external.mjs to generate the
- * pure Prebid.js external bundle (core + adapters + user ID modules) that the
- * shim requires at runtime via integrations.prebid.external_bundle_url.
- */
+/** Build the phase-aware, content-addressed TSJS release from its canonical catalog. */
 
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { transform } from 'esbuild';
 import { build } from 'vite';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const srcDir = path.resolve(__dirname, 'src');
-const distDir = path.resolve(__dirname, '..', 'dist');
-const integrationsDir = path.join(srcDir, 'integrations');
-
-// Clean dist directory
-fs.rmSync(distDir, { recursive: true, force: true });
-fs.mkdirSync(distDir, { recursive: true });
-
-// Discover integration modules: directories in src/integrations/ with index.ts
-const integrationModules = fs.existsSync(integrationsDir)
-  ? fs
-      .readdirSync(integrationsDir)
-      .filter((name) => {
-        const fullPath = path.join(integrationsDir, name);
-        return (
-          fs.statSync(fullPath).isDirectory() && fs.existsSync(path.join(fullPath, 'index.ts'))
-        );
-      })
-      .sort()
-      : [];
+import {
+  deriveInventorySetFiles,
+  measureBundleSet,
+  measureBytes,
+  measureReachableFirstDisplayMasks,
+  BUNDLE_SEPARATOR,
+} from './scripts/bundle-metrics.mjs';
+import { computeReleaseId, RELEASE_SENTINEL, stampRelease } from './scripts/release-v1.mjs';
+
+const libDirectory = path.dirname(fileURLToPath(import.meta.url));
+const sourceDirectory = path.join(libDirectory, 'src');
+const distributionDirectory = path.resolve(libDirectory, '..', 'dist');
+const metricsFile = 'tsjs-build-metrics-v1.json';
+const releaseFile = 'tsjs-release-v1.json';
+const catalogFile = 'tsjs-catalog-v1.json';
+const bootstrapFile = 'tsjs-bootstrap.js';
+const runtimeClaimBanner =
+  '(()=>{const __TSJS_RUNTIME_CLAIMED_V1__=(()=>{try{const source=window.tsjs,claim=source&&source._claimRuntimeV1;return typeof claim==="function"?claim(source):undefined}catch{return undefined}})();';
+const runtimeClaimFooter = '})();';
+
+// Closure-private implementation names used only inside the inline artifact.
+// Registration, takeover, handoff, and public API protocol keys are excluded.
+const bootstrapPrivateProperties =
+  /^(?:stateValue|registrations|disposers|authenticated|reject|unwind)$/;
+
+// These properties are closure-private implementation details of the base agent.
+// Mangle only that artifact: protocol, registration, handoff, and public agent keys
+// intentionally keep their authored names across independently built components.
+const firstDisplayBasePrivateProperties =
+  /^(?:options|driver|production|renderer|startedAtMs|performance|paint|onProtectedPaint|onSettled|onFailure|onPrebidAdmissionFailure|mutationDocument|initialMutationRevision|identityIssuer|gptInput|onAgentReady|sliceBindings|stateValue|agentBatch|handoffOwner|handoffCapsule|mutationObserver|observedMutationRevision|displayWasCommitted|failed|pending|actionStarted|disposedDriver|handoffFinalized|committedArtifactsDetached|lastTimingMs|firstActionAtMs|terminalAtMs|paintAtMs|bound|productionBatch|recordTerminal|recordFirstAction|scheduleProtectedPaint|readTiming|startProduction|acceptedSlotIds|closeDriverIngress|captureDriverHandoff|detachDriverArtifacts|captureHandoffData|disposeDriver|installNativeMutationIngress|observeDomMutations|isOwnedRuntimeInsertion|closeNativeMutationIngress|disposeNativeMutationIngress|observeNativeMutation|finalizeHandoff|detachCommittedArtifacts|mutationRevision|start|settle|fail|dispose|activate|sliceHost|install|parserState|observations|own|afterActivate|claimTimer|completionTimer|controlRelease|directFrame|documentAccepted|documentAcceptancePending|documentRelease|documentTimer|documentTransferred|insertionTimer|pendingDocumentTerminal|ownerSource|ownerTicket|bootstrapNonce|rendererNonce|phaseValue|registryState|expiresAtInternal|ordinalInternal|controlPort|claim|inserted|ticket|cycle|onTerminal|reservationId|timer|attempt|batch|slotResults|reasons|acceptedTrace|nextTraceSequence)$/;
+
+const combinedBootstrapPrivateProperties = new RegExp(
+  `${bootstrapPrivateProperties.source}|${firstDisplayBasePrivateProperties.source}`
+);
+
+// The source-neutral owner keeps these fields inside one independently built IIFE.
+const firstDisplayRenderOwnerPrivateProperties =
+  /^(?:claimTimer|controlRelease|insertionTimer|ownerSource|ownerTicket|phaseValue|registryState|expiresAtInternal|ordinalInternal|controlPort|claim|gam|inserted|ticket|active|cycle|onTerminal|reservationId|timer|attempt|execution|originalCount|exact|exactShape|ports|port|source|bind|recordGam|recordFailure|sweepCommittedArtifacts|sealTsAdmission|closeIngress|captureHandoff|detachCommittedArtifacts|artifacts|tombstones|clockEpochMs|nextReservationOrdinal|nextTicketOrdinal|expiresAtMs|ordinal)$/;
+
+// APS keeps these renderer-specific fields inside its independently built IIFE.
+// Cross-artifact strategy, protocol, callback, and artifact keys remain authored.
+const firstDisplayApsPrivateProperties =
+  /^(?:callbacks|overlay|active|accepted|bootstrapNavigated|bootstrapNonceInternal|bootstrapSource|completionTimer|cycle|documentAccepted|documentPort|documentRelease|documentTimer|frame|hostPositionOwned|pendingTerminal|previousHostPosition|previousHostPositionPriority|rendererNonceInternal|originalCount|exact|ports|rendererUrl|sandbox|permanentSandbox|deadlines|documentAcceptanceMs|completionMs|isBootstrapNonce|isRendererNonce|bootstrapPolicy|parseDocumentMessage|parseWindowMessage)$/;
+
+// These names are private to the GPT initial IIFE and never cross its protocol
+// receipt or handoff boundary. Keep the cross-artifact protocol keys authored.
+const firstDisplayGptPrivateProperties =
+  /^(?:options|clearTimer|setTimer|projection|diagnosticsActive|onNativeMutation|binding|command|cycleMap|createdSlots|diagnosticFacts|diagnosticListeners|targetingObservers|targetingRestorers|publisherCallRestorers|timers|service|started|disposed|ingressClosed|firstAction|commandQueue|commandQueueIndex|createdBinding|renderListener|requestedListener|committedSlotsDetached|detachedSlots|diagnosticFactOverflow|diagnosticFactDrops|targetingWriteDepth|ensureBinding|restoreCreatedBinding|activate|installListeners|removeListener|removePendingCommand|failCycle|failRows|journalPublisherTargeting|observePublisherTargeting|observePublisherCalls|restorePublisherCalls|restoreTargetingObservers|restorePublisherTargeting|notifyNativeMutation|captureDiagnosticFact|clearOwnedTimer|incrementDiagnosticDrops|writeTargeting|invalidateTargeting|sealedTargetingOwnership|targetingWrites|ingressClosing|diagnosticRecords|nextDiagnosticCycleOrdinal|publicCycle|requestTimer|completionTimer|requestOperation|requestInvoked|bindingState|operations|requested|settled|current|valid|consumed|operation|protocol|restore|handle|fired|deadlines|externalReadyMs|requestStartMs|completionMs|requestPlan|classifyRenderEnded|encodedBytes|readPhysicalElementId|retireCycle|snapshotDestroyedCycles|invalidateCyclesForElement|invalidateCyclesForPublisherCall|consumeTargetingWrite|invalidateStaleTargetingObservers|captureRetainedTargeting|targetingOwnership|cycles|facts|nextTraceTokenOrdinal|overflowCount|dropCount|nextCycleOrdinal|quarantines|records|responseIdentifier|seen|state|unknownPriorCycle|ordinal|timer|start|closeIngress|captureHandoff|captureDiagnosticsHandoff|detachCommittedSlots|dispose)$/;
+
+fs.rmSync(distributionDirectory, { recursive: true, force: true });
+fs.mkdirSync(distributionDirectory, { recursive: true });
+
+// Build the TypeScript catalog itself as a temporary Node module. This keeps the
+// browser, release builder, and generated Rust metadata on one authored authority.
+const catalogModuleFile = '.release-catalog-v1.mjs';
+const catalogSource = fs.readFileSync(
+  path.join(sourceDirectory, 'kernel', 'release_catalog.ts'),
+  'utf8'
+);
+const transformedCatalog = await transform(catalogSource, {
+  format: 'esm',
+  loader: 'ts',
+  target: 'es2020',
+});
+fs.writeFileSync(path.join(distributionDirectory, catalogModuleFile), transformedCatalog.code);
+const catalogModule = await import(
+  `${pathToFileURL(path.join(distributionDirectory, catalogModuleFile)).href}?build=${Date.now()}`
+);
+const releaseCatalog = catalogModule.RELEASE_CATALOG;
+const firstDisplayCatalog = catalogModule.FIRST_DISPLAY_CATALOG;
+catalogModule.validateReleaseCatalog(releaseCatalog);
+if (releaseCatalog.length !== 20) throw new Error('[build-all] Catalog must contain 20 rows');
+if (firstDisplayCatalog.length !== 14 || firstDisplayCatalog[0]?.id !== 'first_display') {
+  throw new Error('[build-all] First-display catalog must contain its base and thirteen slices');
+}
+const runtimeCatalog = releaseCatalog.map(({ id, phase, trigger, config, consumes, provides }) => ({
+  id,
+  phase,
+  trigger,
+  config,
+  consumes,
+  provides,
+}));
+fs.rmSync(path.join(distributionDirectory, catalogModuleFile));
+
+const sourceById = Object.freeze({
+  render_runtime: 'integrations/render_runtime/transport_marker.ts',
+  aps: 'integrations/aps/index.ts',
+  creative: 'integrations/creative/index.ts',
+  datadome: 'integrations/datadome/index.ts',
+  didomi: 'integrations/didomi/index.ts',
+  google_tag_manager: 'integrations/google_tag_manager/index.ts',
+  gpt: 'integrations/gpt/index.ts',
+  gpt_diagnostics: 'integrations/gpt_diagnostics/index.ts',
+  lockr: 'integrations/lockr/index.ts',
+  osano_consent: 'integrations/osano/consent.ts',
+  permutive_context: 'integrations/permutive/context.ts',
+  sourcepoint_consent: 'integrations/sourcepoint/consent.ts',
+  prebid: 'integrations/prebid/index.ts',
+  testlight: 'integrations/testlight/index.ts',
+  diagnostics_presentation: 'integrations/gpt_diagnostics/presentation.ts',
+  gpt_later: 'integrations/gpt/later.ts',
+  osano_lifecycle: 'integrations/osano/lifecycle.ts',
+  permutive_lifecycle: 'integrations/permutive/lifecycle.ts',
+  prebid_later: 'integrations/prebid/later.ts',
+  sourcepoint_lifecycle: 'integrations/sourcepoint/lifecycle.ts',
+});
+
+const firstDisplaySourceById = Object.freeze({
+  first_display: 'first_display/base_marker.ts',
+  render_owner_initial: 'first_display/slices/render_owner.ts',
+  aps_initial: 'first_display/slices/aps.ts',
+  creative_initial: 'first_display/slices/creative.ts',
+  datadome_initial: 'first_display/slices/datadome.ts',
+  didomi_initial: 'first_display/slices/didomi.ts',
+  google_tag_manager_initial: 'first_display/slices/google_tag_manager.ts',
+  gpt_initial: 'first_display/slices/gpt.ts',
+  lockr_initial: 'first_display/slices/lockr.ts',
+  osano_initial: 'first_display/slices/osano.ts',
+  permutive_initial: 'first_display/slices/permutive.ts',
+  sourcepoint_initial: 'first_display/slices/sourcepoint.ts',
+  prebid_initial: 'first_display/slices/prebid.ts',
+  testlight_initial: 'first_display/slices/testlight.ts',
+});
+
+const catalogIds = releaseCatalog.map(({ id }) => id);
+if (
+  Object.keys(sourceById).length !== releaseCatalog.length ||
+  catalogIds.some((id) => !(id in sourceById))
+) {
+  throw new Error('[build-all] Catalog/source inventory mismatch');
+}
+if (new Set(Object.values(sourceById)).size !== releaseCatalog.length) {
+  throw new Error('[build-all] Every catalog artifact must have one distinct source entry');
+}
+if (
+  Object.keys(firstDisplaySourceById).length !== firstDisplayCatalog.length ||
+  firstDisplayCatalog.some(({ id }) => !(id in firstDisplaySourceById)) ||
+  new Set(Object.values(firstDisplaySourceById)).size !== firstDisplayCatalog.length
+) {
+  throw new Error('[build-all] First-display catalog/source inventory mismatch');
+}
 
-console.log('[build-all] Discovered integrations:', integrationModules);
+const artifacts = [
+  {
+    id: 'bootstrap',
+    role: 'bootstrap',
+    phase: '',
+    trigger: '',
+    inputs: [],
+    outputs: [],
+    file: bootstrapFile,
+    entry: 'core/bootstrap.ts',
+  },
+  ...firstDisplayCatalog.map((entry, index) => ({
+    id: entry.id,
+    role: index === 0 ? 'first_display_base' : 'first_display_slice',
+    phase: 'first_display',
+    trigger: '',
+    inputs: [...entry.inputs],
+    outputs: [...entry.outputs],
+    file: `tsjs-${entry.id}.js`,
+    entry: firstDisplaySourceById[entry.id],
+    maskBit: index,
+  })),
+  {
+    id: 'core',
+    role: 'core',
+    phase: '',
+    trigger: '',
+    inputs: [],
+    outputs: ['runtime.v1'],
+    file: 'tsjs-core.js',
+    entry: 'composition/runtime_transport.ts',
+  },
+  ...releaseCatalog.map((entry) => ({
+    id: entry.id,
+    role: 'integration',
+    phase: entry.phase,
+    trigger: entry.trigger ?? '',
+    inputs: [...entry.consumes],
+    outputs: [...entry.provides],
+    file: `tsjs-${entry.id}.js`,
+    entry: sourceById[entry.id],
+  })),
+];
 
-/** Build a single module as a self-contained IIFE. */
-async function buildModule(name, entryPath) {
-  const outFile = `tsjs-${name}.js`;
-  console.log(`[build-all] Building ${outFile} from ${path.relative(__dirname, entryPath)}`);
+const ids = new Set();
+const files = new Set();
+for (const artifact of artifacts) {
+  if (ids.has(artifact.id) || files.has(artifact.file)) {
+    throw new Error(`[build-all] Duplicate artifact: ${artifact.id}`);
+  }
+  if (/(?:^|\/)(?:test|fixtures?|fakes?|no-?op)(?:\/|$)/iu.test(artifact.entry)) {
+    throw new Error(`[build-all] Test/fake/no-op artifact source: ${artifact.entry}`);
+  }
+  ids.add(artifact.id);
+  files.add(artifact.file);
+}
 
-  await build({
+async function buildArtifact(artifact) {
+  const entryPath = path.join(sourceDirectory, artifact.entry);
+  if (!fs.existsSync(entryPath)) throw new Error(`[build-all] Missing source: ${artifact.entry}`);
+  console.log(`[build-all] Building ${artifact.file} from ${artifact.entry}`);
+  const result = await build({
     configFile: false,
-    root: __dirname,
+    root: libDirectory,
+    ...(artifact.role === 'bootstrap'
+      ? { esbuild: { mangleProps: combinedBootstrapPrivateProperties, mangleQuoted: true } }
+      : artifact.id === 'first_display'
+        ? { esbuild: { mangleProps: firstDisplayBasePrivateProperties, mangleQuoted: true } }
+        : artifact.id === 'render_owner_initial'
+          ? {
+              esbuild: {
+                mangleProps: firstDisplayRenderOwnerPrivateProperties,
+                mangleQuoted: true,
+              },
+            }
+          : artifact.id === 'aps_initial'
+            ? { esbuild: { mangleProps: firstDisplayApsPrivateProperties, mangleQuoted: true } }
+            : artifact.id === 'gpt_initial'
+              ? { esbuild: { mangleProps: firstDisplayGptPrivateProperties, mangleQuoted: true } }
+              : {}),
+    define: {
+      __TSJS_EMBEDDED_RELEASE_ID_V1__: JSON.stringify(RELEASE_SENTINEL),
+      __TSJS_EMBEDDED_INTEGRATION_IDS_V1__: JSON.stringify(catalogIds),
+      __TSJS_EMBEDDED_RUNTIME_CATALOG_V1__: JSON.stringify(runtimeCatalog),
+      __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__: JSON.stringify(releaseCatalog.length),
+    },
     build: {
       emptyOutDir: false,
-      outDir: distDir,
+      outDir: distributionDirectory,
       assetsDir: '.',
+      target: 'es2022',
       sourcemap: false,
       minify: 'esbuild',
       rollupOptions: {
         input: entryPath,
         output: {
           format: 'iife',
-          dir: distDir,
-          entryFileNames: outFile,
-          inlineDynamicImports: true,
+          dir: distributionDirectory,
+          entryFileNames: artifact.file,
           extend: false,
-          // Use a unique IIFE name per module to avoid conflicts
-          name: name === 'core' ? 'tsjs' : `tsjs_${name}`,
+          name: `tsjs_${artifact.id}`,
+          ...(artifact.id === 'core'
+            ? { banner: runtimeClaimBanner, footer: runtimeClaimFooter }
+            : {}),
         },
       },
     },
     logLevel: 'warn',
   });
 
-  console.log(`[build-all] Built ${outFile}`);
+  const outputs = (Array.isArray(result) ? result : [result]).flatMap((item) => item.output);
+  const chunk = outputs.find((item) => item.type === 'chunk' && item.fileName === artifact.file);
+  if (!chunk || chunk.type !== 'chunk') {
+    throw new Error(`[build-all] Missing generated chunk metadata: ${artifact.file}`);
+  }
+  artifact.moduleIds = Object.freeze(
+    Object.keys(chunk.modules).map((moduleId) => path.relative(libDirectory, moduleId))
+  );
+  artifact.moduleContributions = Object.freeze(
+    Object.entries(chunk.modules).map(([moduleId, contribution]) => ({
+      file: path.relative(libDirectory, moduleId),
+      renderedBytes: contribution.renderedLength,
+    }))
+  );
+
+  const filePath = path.join(distributionDirectory, artifact.file);
+  const source = fs.readFileSync(filePath, 'utf8');
+  const sentinelCount = source.split(RELEASE_SENTINEL).length - 1;
+  if (sentinelCount > 1) {
+    throw new Error(`[build-all] Multiple release sentinels before stamping: ${artifact.file}`);
+  }
+  if (sentinelCount === 0) fs.writeFileSync(filePath, `${source}\n;void"${RELEASE_SENTINEL}";\n`);
 }
 
-// Build core first (synchronously), then all integrations in parallel
-await buildModule('core', path.join(srcDir, 'core', 'index.ts'));
+await buildArtifact(artifacts[0]);
+await Promise.all(artifacts.slice(1).map(buildArtifact));
 
-await Promise.all(
-  integrationModules.map((name) => buildModule(name, path.join(integrationsDir, name, 'index.ts')))
+const deferredEntries = new Set(
+  artifacts
+    .filter(({ phase }) => phase === 'deferred')
+    .map(({ entry }) => path.normalize(`src/${entry}`))
 );
+for (const artifact of artifacts) {
+  if (artifact.role !== 'core' && artifact.phase !== 'takeover') continue;
+  const reachedDeferred = artifact.moduleIds.find((moduleId) =>
+    deferredEntries.has(path.normalize(moduleId))
+  );
+  if (reachedDeferred) {
+    throw new Error(`[build-all] ${artifact.id} reaches deferred source entry ${reachedDeferred}`);
+  }
+}
+const persistentEntryPrefixes = Object.freeze([
+  'src/core/',
+  'src/kernel/integration_registry.ts',
+  'src/kernel/runtime.ts',
+  'src/kernel/sessions.ts',
+  'src/services/',
+  'src/integrations/',
+]);
+for (const artifact of artifacts.filter(({ phase }) => phase === 'first_display')) {
+  const catalogEntry = firstDisplayCatalog.find(({ id }) => id === artifact.id);
+  if (!catalogEntry)
+    throw new Error(`[build-all] Missing first-display catalog row: ${artifact.id}`);
+  const ownEntry = path.normalize(`src/${artifact.entry}`);
+  const allowed = new Set(
+    catalogEntry.allowedImports.map((moduleId) => path.normalize(`src/${moduleId}.ts`))
+  );
+  const forbidden = artifact.moduleIds.find((moduleId) =>
+    persistentEntryPrefixes.some(
+      (prefix) =>
+        path.normalize(moduleId).startsWith(path.normalize(prefix)) &&
+        !allowed.has(path.normalize(moduleId))
+    )
+  );
+  if (forbidden) {
+    throw new Error(`[build-all] ${artifact.id} reaches persistent source ${forbidden}`);
+  }
+  const undeclared = artifact.moduleIds.find((moduleId) => {
+    const normalized = path.normalize(moduleId);
+    return normalized !== ownEntry && !allowed.has(normalized);
+  });
+  if (undeclared) {
+    throw new Error(
+      `[build-all] ${artifact.id} reaches undeclared first-display source ${undeclared}`
+    );
+  }
+}
+for (const artifact of artifacts.filter(
+  ({ role, phase }) => role === 'core' || phase === 'takeover' || phase === 'deferred'
+)) {
+  const forbidden = artifact.moduleIds.find((moduleId) =>
+    path.normalize(moduleId).startsWith(path.normalize('src/first_display/'))
+  );
+  if (forbidden) {
+    throw new Error(`[build-all] ${artifact.id} reaches first-display source ${forbidden}`);
+  }
+}
+const generatedJavaScript = fs
+  .readdirSync(distributionDirectory)
+  .filter((file) => file.endsWith('.js'));
+const expectedJavaScript = artifacts.map(({ file }) => file);
+if (
+  generatedJavaScript.length !== expectedJavaScript.length ||
+  expectedJavaScript.some((file) => !generatedJavaScript.includes(file))
+) {
+  throw new Error('[build-all] Missing or unknown production JavaScript artifact');
+}
 
-// List all built files
-const builtFiles = fs
-  .readdirSync(distDir)
-  .filter((f) => f.startsWith('tsjs-') && f.endsWith('.js'))
-  .sort();
+const releaseId = computeReleaseId(
+  artifacts.map((artifact) => ({
+    id: artifact.id,
+    role: artifact.role,
+    phase: artifact.phase,
+    trigger: artifact.trigger,
+    bytes: fs.readFileSync(path.join(distributionDirectory, artifact.file)),
+  }))
+);
+
+for (const artifact of artifacts) {
+  const filePath = path.join(distributionDirectory, artifact.file);
+  fs.writeFileSync(filePath, stampRelease(fs.readFileSync(filePath), releaseId));
+}
+
+const artifactInventory = artifacts.map((artifact) => {
+  const bytes = fs.readFileSync(path.join(distributionDirectory, artifact.file));
+  return {
+    id: artifact.id,
+    role: artifact.role,
+    phase: artifact.phase || null,
+    trigger: artifact.trigger || null,
+    inputs: artifact.inputs,
+    outputs: artifact.outputs,
+    file: artifact.file,
+    bytes: bytes.byteLength,
+    hash: createHash('sha256').update(bytes).digest('hex'),
+  };
+});
+fs.writeFileSync(
+  path.join(distributionDirectory, releaseFile),
+  `${JSON.stringify({ version: 1, releaseId, artifacts: artifactInventory })}\n`
+);
+const bootstrapArtifact = artifacts[0];
+const bootstrapBytes = fs.readFileSync(path.join(distributionDirectory, bootstrapFile));
+const artifactContents = new Map(
+  artifactInventory.map(({ file }) => [
+    file,
+    fs.readFileSync(path.join(distributionDirectory, file)),
+  ])
+);
+const inventorySetFiles = deriveInventorySetFiles(artifactInventory, releaseCatalog);
+const firstDisplayMaskCatalog = firstDisplayCatalog.map(({ id }, maskBit) => ({
+  id,
+  maskBit,
+  file: `tsjs-${id}.js`,
+}));
+const firstDisplayMasks = await measureReachableFirstDisplayMasks(
+  firstDisplayMaskCatalog,
+  artifactContents
+);
+fs.writeFileSync(
+  path.join(distributionDirectory, catalogFile),
+  `${JSON.stringify({
+    version: 1,
+    firstDisplay: firstDisplayCatalog.map(
+      ({ order, id, include, allowedImports, inputs, outputs, obligation }) => ({
+        order,
+        id,
+        include,
+        allowedImports,
+        inputs,
+        outputs,
+        obligation,
+      })
+    ),
+    permittedFirstDisplayMasks: firstDisplayMasks
+      .filter(({ permitted }) => permitted)
+      .map(({ mask }) => mask),
+    modules: releaseCatalog.map(({ id, phase, trigger, include }) => ({
+      id,
+      phase,
+      trigger,
+      include,
+    })),
+  })}\n`
+);
+const metrics = {
+  schemaVersion: 1,
+  compression: {
+    concatenationSeparator: BUNDLE_SEPARATOR.toString('utf8'),
+    gzipLevel: 9,
+    gzipMtime: 0,
+    brotliMode: 'text',
+    brotliQuality: 11,
+  },
+  modules: artifacts.slice(1).map((artifact) => {
+    const bytes = fs.readFileSync(path.join(distributionDirectory, artifact.file));
+    return {
+      file: artifact.file,
+      entry: path.normalize(`src/${artifact.entry}`),
+      rawBytes: bytes.byteLength,
+      sha256: createHash('sha256').update(bytes).digest('hex'),
+      sources: artifact.moduleContributions,
+    };
+  }),
+  bootstrap: {
+    file: bootstrapFile,
+    entry: path.normalize(`src/${bootstrapArtifact.entry}`),
+    ...measureBytes(bootstrapBytes),
+    sources: bootstrapArtifact.moduleContributions,
+  },
+  firstDisplay: {
+    catalog: firstDisplayMaskCatalog,
+    components: Object.fromEntries(
+      artifacts
+        .filter(({ phase }) => phase === 'first_display')
+        .map((artifact) => [
+          artifact.id,
+          {
+            file: artifact.file,
+            entry: path.normalize(`src/${artifact.entry}`),
+            ...measureBytes(fs.readFileSync(path.join(distributionDirectory, artifact.file))),
+            sources: artifact.moduleContributions,
+          },
+        ])
+    ),
+    masks: firstDisplayMasks,
+  },
+  sets: Object.fromEntries(
+    Object.entries(inventorySetFiles).map(([setName, setFiles]) => [
+      setName,
+      measureBundleSet(setFiles, artifactContents),
+    ])
+  ),
+};
+fs.writeFileSync(
+  path.join(distributionDirectory, metricsFile),
+  `${JSON.stringify(metrics, null, 2)}\n`
+);
 
-console.log('[build-all] Built files:', builtFiles);
-console.log(`[build-all] Total: ${builtFiles.length} modules`);
+console.log(`[build-all] Built ${artifacts.length} canonical artifacts`);
+console.log(`[build-all] Wrote ${releaseFile} for release ${releaseId}`);
diff --git a/crates/trusted-server-js/lib/build-prebid-external.mjs b/crates/trusted-server-js/lib/build-prebid-external.mjs
index eb6e42826..1a77b9b70 100644
--- a/crates/trusted-server-js/lib/build-prebid-external.mjs
+++ b/crates/trusted-server-js/lib/build-prebid-external.mjs
@@ -34,6 +34,35 @@ const PREBID_LIVE_INTENT_STANDARD = path.join(
 );
 const PREBID_GLOBAL_MODULE = path.join(PREBID_PACKAGE_DIR, 'dist', 'src', 'src', 'prebidGlobal.js');
 const LIVE_INTENT_SHIM = path.join(prebidDir, 'prebid_modules', 'liveIntentIdSystem.ts');
+export const ARTIFACT_RELEASE_SENTINEL = '0'.repeat(64);
+const ARTIFACT_PROPERTY = '__trustedServerArtifactV1';
+const EXPECTED_PREBID_VERSION = '10.26.0';
+const LEGACY_RUNTIME_FLAG_PREFIX = ['__', 'tsjs', '_'].join('');
+
+/** Refuse to publish an external Prebid artifact carrying a retired TSJS runtime flag. */
+export function assertNoLegacyRuntimeFlags(bundleCode) {
+  if (bundleCode.includes(LEGACY_RUNTIME_FLAG_PREFIX)) {
+    throw new Error(
+      '[build-prebid-external] Generated artifact contains a legacy TSJS runtime flag'
+    );
+  }
+}
+
+const TS_OWNED_PREBID_ARTIFACT_MARKERS = [
+  /\bTS (?:APS|ADM|Owner|Render Owner)\b/u,
+  /\/_ts\/(?:auction|page-bids)\b/u,
+  /\b(?:rendererReservationId|lifecycleTicket)\b/u,
+  /\btsjs\.(?:addAdUnits|diagnostics|requestAds)\b/u,
+];
+
+/** Keep the independently useful external bundle free of TS-owned behavior. */
+export function assertPurePrebidArtifact(bundleCode) {
+  if (TS_OWNED_PREBID_ARTIFACT_MARKERS.some((expression) => expression.test(bundleCode))) {
+    throw new Error(
+      '[build-prebid-external] Generated artifact contains TS-owned auction or render behavior'
+    );
+  }
+}
 
 export function parseArgs(argv) {
   const options = new Map();
@@ -66,10 +95,14 @@ export function parseArgs(argv) {
 }
 
 function parseList(raw) {
-  return raw
+  const values = raw
     .split(',')
     .map((value) => value.trim())
     .filter(Boolean);
+  if (new Set(values).size !== values.length) {
+    throw new Error('[build-prebid-external] Module lists must not contain duplicates');
+  }
+  return values.sort();
 }
 
 function requireExistingFile(filePath, description) {
@@ -102,7 +135,8 @@ function validateUserIdImport(entry) {
   } catch (error) {
     throw new Error(
       `[build-prebid-external] Required Prebid user ID module "${entry.moduleName}" ` +
-        `could not be resolved from ${entry.importPath}: ${error.message}`
+        `could not be resolved from ${entry.importPath}: ${error.message}`,
+      { cause: error }
     );
   }
 }
@@ -137,8 +171,13 @@ export function renderIncludedUserIdModulesExport(moduleNames) {
  * list, while the module-name list is retained separately for audit output.
  */
 export function readAdapterBidderCodes(adapterNames) {
+  return readAdapterMetadata(adapterNames).bidderCodes;
+}
+
+export function readAdapterMetadata(adapterNames) {
   const metadataDir = path.join(PREBID_PACKAGE_DIR, 'metadata', 'modules');
   const bidderCodes = new Set();
+  const bidderAliases = [];
 
   for (const name of adapterNames) {
     const metadataPath = path.join(metadataDir, `${name}BidAdapter.json`);
@@ -159,10 +198,20 @@ export function readAdapterBidderCodes(adapterNames) {
     }
     for (const component of bidderComponents) {
       bidderCodes.add(component.componentName);
+      if (typeof component.aliasOf === 'string' && component.aliasOf.length > 0) {
+        bidderAliases.push({ code: component.componentName, moduleStem: name });
+      }
     }
   }
 
-  return [...bidderCodes].sort();
+  return {
+    bidderCodes: [...bidderCodes].sort(),
+    bidderAliases: bidderAliases.sort(
+      (left, right) =>
+        (left.code < right.code ? -1 : left.code > right.code ? 1 : 0) ||
+        (left.moduleStem < right.moduleStem ? -1 : left.moduleStem > right.moduleStem ? 1 : 0)
+    ),
+  };
 }
 
 function generateAdapterImports(adapterNames, adaptersFile) {
@@ -212,7 +261,15 @@ function generateUserIdImports(requestedModules, userIdsFile) {
     imports,
     [renderIncludedUserIdModulesExport(moduleNames)]
   );
-  return moduleNames;
+  return selectedEntries
+    .map((entry) => ({
+      moduleName: entry.moduleName,
+      configNames: [...new Set(entry.configNames)].sort(),
+      eidSources: [...new Set(entry.eidSources.map((source) => source.toLowerCase()))].sort(),
+    }))
+    .sort((left, right) =>
+      left.moduleName < right.moduleName ? -1 : left.moduleName > right.moduleName ? 1 : 0
+    );
 }
 
 function createTemporaryModulePaths() {
@@ -227,50 +284,20 @@ function createTemporaryModulePaths() {
 
 const SHIM_WATCHDOG_DELAY_MS = 5000;
 
-function generateExternalEntry(entryFile, adapters, bidderCodes) {
+function generateExternalEntry(entryFile) {
   const content = [
     '// Auto-generated by build-prebid-external.mjs.',
     '//',
     '// Pure Prebid.js external bundle: core, consent modules, user ID modules,',
-    '// and client-side bid adapters. The Trusted Server prebid shim',
-    '// (tsjs-prebid, served by the server) installs the trustedServer adapter',
-    '// onto the `window.pbjs` global this bundle populates and drives queue',
-    '// processing — this bundle intentionally does NOT call processQueue()',
-    '// itself, except through the watchdog below.',
+    '// and client-side bid adapters. Trusted Server auction, admission, render,',
+    '// targeting, and refresh behavior intentionally live outside this artifact.',
     "import 'prebid.js';",
     "import 'prebid.js/modules/consentManagementTcf.js';",
     "import 'prebid.js/modules/consentManagementGpp.js';",
     "import 'prebid.js/modules/consentManagementUsp.js';",
     "import 'prebid.js/modules/userId.js';",
     "import './_adapters.generated';",
-    "import { INCLUDED_PREBID_USER_ID_MODULES } from './_user_ids.generated';",
-    '',
-    '// Manifest consumed by the tsjs prebid shim to validate that every',
-    '// configured client_side_bidder has its adapter compiled in. adapters',
-    '// lists the module file stems for audit output; bidderCodes lists the',
-    '// registered runtime bidder codes, including aliases.',
-    'const bundleWindow = window as unknown as {',
-    '  __tsjs_prebid_bundle?: unknown;',
-    '  __tsjsPrebidShimInstalled?: boolean;',
-    '  pbjs?: { processQueue?: () => void };',
-    '};',
-    'bundleWindow.__tsjs_prebid_bundle = Object.freeze({',
-    `  adapters: ${JSON.stringify(adapters)},`,
-    `  bidderCodes: ${JSON.stringify(bidderCodes)},`,
-    '  userIdModules: INCLUDED_PREBID_USER_ID_MODULES,',
-    '});',
-    '',
-    '// Watchdog: the shim owns processQueue(), but it is a separate artifact',
-    '// that can fail to load independently (adblock filters, CSP, a',
-    '// /static/tsjs= error). If it has not installed within the grace period,',
-    '// drain the queue anyway so publisher pbjs.que callbacks still run',
-    '// against plain Prebid.js. processQueue() is safe to call again when the',
-    '// shim arrives late.',
-    'setTimeout(() => {',
-    '  if (!bundleWindow.__tsjsPrebidShimInstalled) {',
-    '    bundleWindow.pbjs?.processQueue?.();',
-    '  }',
-    `}, ${SHIM_WATCHDOG_DELAY_MS});`,
+    "import './_user_ids.generated';",
     '',
   ].join('\n');
 
@@ -285,7 +312,43 @@ export function deriveBundleMetadata(bundleBytes) {
   return { filename, sha256, sri };
 }
 
-async function buildExternalBundle(outDir, generatedModules) {
+function sha256Hex(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+function renderExternalWrapper(bundleCode, stamp) {
+  const stampJson = JSON.stringify(stamp);
+  return [
+    '(function(){',
+    `var __tsWatchdog=setTimeout(function(){if(__tsWatchdogFired)return;__tsWatchdogFired=true;try{var p=window.pbjs;var f=p&&p.processQueue;if(typeof f==="function")Reflect.apply(f,p,[]);}catch(_){}},${SHIM_WATCHDOG_DELAY_MS});`,
+    'var __tsWatchdogFired=false;',
+    'void __tsWatchdog;',
+    'var __tsMissing={};',
+    'var __tsWarned=false;',
+    'function __tsWarn(){if(__tsWarned)return;__tsWarned=true;try{console.warn("[tsjs-prebid] external Prebid artifact stamp conflict");}catch(_){}}',
+    'function __tsData(value,key){try{var descriptor=Object.getOwnPropertyDescriptor(value,key);return descriptor&&Object.prototype.hasOwnProperty.call(descriptor,"value")&&descriptor.enumerable===true&&descriptor.writable===false&&descriptor.configurable===false?descriptor.value:__tsMissing;}catch(_){return __tsMissing;}}',
+    'function __tsRecord(value,keys){if(!value||typeof value!=="object"||Object.getPrototypeOf(value)!==Object.prototype||!Object.isFrozen(value))return false;var own;try{own=Reflect.ownKeys(value);}catch(_){return false;}if(own.length!==keys.length)return false;for(var i=0;i<keys.length;i+=1){if(__tsData(value,keys[i])===__tsMissing)return false;}return true;}',
+    'function __tsArray(value,max){if(!Array.isArray(value)||Object.getPrototypeOf(value)!==Array.prototype||!Object.isFrozen(value)||value.length>max)return false;var own;try{own=Reflect.ownKeys(value);}catch(_){return false;}if(own.length!==value.length+1)return false;for(var i=0;i<value.length;i+=1){if(__tsData(value,String(i))===__tsMissing)return false;}return true;}',
+    'function __tsArrayLength(value){try{if(!Array.isArray(value)||Object.getPrototypeOf(value)!==Array.prototype||!Object.isFrozen(value))return __tsMissing;var descriptor=Object.getOwnPropertyDescriptor(value,"length");return descriptor&&Object.prototype.hasOwnProperty.call(descriptor,"value")&&descriptor.enumerable===false&&descriptor.writable===false&&descriptor.configurable===false?descriptor.value:__tsMissing;}catch(_){return __tsMissing;}}',
+    'function __tsString(value,max,lowercase){if(typeof value!=="string"||value.length===0||(lowercase&&value!==value.toLowerCase()))return false;var bytes=0;for(var i=0;i<value.length;i+=1){var code=value.charCodeAt(i);if(code>=55296&&code<=56319){var next=value.charCodeAt(i+1);if(next<56320||next>57343)return false;bytes+=4;i+=1;}else if(code>=56320&&code<=57343)return false;else if(code<=127)bytes+=1;else if(code<=2047)bytes+=2;else bytes+=3;if(bytes>max)return false;}return true;}',
+    'function __tsSortedStrings(value,max,maxBytes,lowercase){if(!__tsArray(value,max))return false;var previous;for(var i=0;i<value.length;i+=1){var current=value[i];if(!__tsString(current,maxBytes,lowercase)||(previous!==undefined&&previous>=current))return false;previous=current;}return true;}',
+    'function __tsContains(values,expected){for(var i=0;i<values.length;i+=1){if(values[i]===expected)return true;}return false;}',
+    'function __tsValidStamp(value){try{var keys=["abi","artifactReleaseId","prebidVersion","moduleStems","bidderCodes","bidderAliases","userIdModules"];if(!__tsRecord(value,keys)||__tsData(value,"abi")!==1||__tsData(value,"prebidVersion")!=="10.26.0"||!/^[0-9a-f]{64}$/.test(__tsData(value,"artifactReleaseId")))return false;var modules=__tsData(value,"moduleStems");var bidders=__tsData(value,"bidderCodes");var aliases=__tsData(value,"bidderAliases");var userIds=__tsData(value,"userIdModules");if(!__tsSortedStrings(modules,256,128,false)||!__tsSortedStrings(bidders,512,128,false)||!__tsArray(aliases,512)||!__tsArray(userIds,128))return false;var previous="";for(var i=0;i<aliases.length;i+=1){var alias=aliases[i];if(!__tsRecord(alias,["code","moduleStem"]))return false;var code=__tsData(alias,"code");var stem=__tsData(alias,"moduleStem");var identity=code+"\\u0000"+stem;if(!__tsString(code,128,false)||!__tsString(stem,128,false)||(previous&&previous>=identity)||!__tsContains(bidders,code)||!__tsContains(modules,stem))return false;previous=identity;}previous="";for(var j=0;j<userIds.length;j+=1){var row=userIds[j];if(!__tsRecord(row,["moduleName","configNames","eidSources"]))return false;var name=__tsData(row,"moduleName");var configs=__tsData(row,"configNames");var sources=__tsData(row,"eidSources");if(!__tsString(name,128,false)||(previous&&previous>=name)||!__tsContains(modules,name)||!__tsSortedStrings(configs,64,128,false)||!__tsSortedStrings(sources,64,256,true))return false;previous=name;}return true;}catch(_){return false;}}',
+    'function __tsEqual(left,right){if(left===right)return true;if(!left||!right||typeof left!=="object"||typeof right!=="object")return false;var leftKeys=Reflect.ownKeys(left);var rightKeys=Reflect.ownKeys(right);if(leftKeys.length!==rightKeys.length)return false;for(var i=0;i<leftKeys.length;i+=1){if(leftKeys[i]!==rightKeys[i])return false;if(leftKeys[i]==="length"&&(Array.isArray(left)||Array.isArray(right))){var leftLength=__tsArrayLength(left);var rightLength=__tsArrayLength(right);if(leftLength===__tsMissing||rightLength===__tsMissing||leftLength!==rightLength)return false;continue;}var leftValue=__tsData(left,leftKeys[i]);var rightValue=__tsData(right,rightKeys[i]);if(leftValue===__tsMissing||rightValue===__tsMissing||!__tsEqual(leftValue,rightValue))return false;}return true;}',
+    'function __tsDeepFreeze(value){if(value&&typeof value==="object"){var names=Object.getOwnPropertyNames(value);for(var i=0;i<names.length;i+=1)__tsDeepFreeze(value[names[i]]);Object.freeze(value);}return value;}',
+    'var __tsRequired=["addAdUnits","getBidResponsesForAdUnitCode","getHighestCpmBids","offEvent","onEvent","processQueue","registerBidAdapter","renderAd","requestBids","setTargetingForGPTAsync"];',
+    'function __tsRealApi(value){try{if(!value||typeof value!=="object"&&typeof value!=="function"||!value.que||typeof value.que.push!=="function")return false;for(var i=0;i<__tsRequired.length;i+=1){if(typeof value[__tsRequired[i]]!=="function")return false;}return true;}catch(_){return false;}}',
+    `var __tsStamp=__tsDeepFreeze(${stampJson});`,
+    `var __tsExistingWindow=window;var __tsExisting=__tsExistingWindow.pbjs;var __tsExistingDescriptor;try{__tsExistingDescriptor=__tsExisting&&Object.getOwnPropertyDescriptor(__tsExisting,"${ARTIFACT_PROPERTY}");}catch(_){__tsExistingDescriptor=undefined;}`,
+    'if(__tsRealApi(__tsExisting)&&__tsExistingDescriptor&&Object.prototype.hasOwnProperty.call(__tsExistingDescriptor,"value")&&__tsExistingDescriptor.enumerable===false&&__tsExistingDescriptor.writable===false&&__tsExistingDescriptor.configurable===false&&__tsValidStamp(__tsExistingDescriptor.value)){if(__tsEqual(__tsExistingDescriptor.value,__tsStamp))return;__tsWarn();return;}',
+    bundleCode,
+    `var __tsPbjs=window.pbjs;var __tsReady=__tsRealApi(__tsPbjs);if(__tsReady){var __tsAfter;var __tsInherited=false;try{__tsAfter=Object.getOwnPropertyDescriptor(__tsPbjs,"${ARTIFACT_PROPERTY}");__tsInherited=!__tsAfter&&Reflect.has(__tsPbjs,"${ARTIFACT_PROPERTY}");}catch(_){__tsAfter=undefined;__tsInherited=true;}if(!__tsAfter&&!__tsInherited){try{Object.defineProperty(__tsPbjs,"${ARTIFACT_PROPERTY}",{value:__tsStamp,enumerable:false,writable:false,configurable:false});}catch(_){__tsWarn();}}else if(__tsInherited||!Object.prototype.hasOwnProperty.call(__tsAfter,"value")||!__tsEqual(__tsAfter.value,__tsStamp)){__tsWarn();}}`,
+    '})();',
+    '',
+  ].join('\n');
+}
+
+async function buildExternalBundle(outDir, generatedModules, stamp) {
   fs.mkdirSync(outDir, { recursive: true });
 
   const temporaryFile = `trusted-prebid-${process.pid}-${crypto.randomUUID()}.tmp.js`;
@@ -337,7 +400,6 @@ async function buildExternalBundle(outDir, generatedModules) {
             format: 'iife',
             dir: outDir,
             entryFileNames: temporaryFile,
-            inlineDynamicImports: true,
             extend: false,
             name: 'tsjs_prebid_external',
           },
@@ -346,15 +408,31 @@ async function buildExternalBundle(outDir, generatedModules) {
       logLevel: 'warn',
     });
 
-    const bundleBytes = fs.readFileSync(temporaryPath);
+    const unwrappedBundle = fs.readFileSync(temporaryPath, 'utf8');
+    const normalizedBundle = renderExternalWrapper(unwrappedBundle, stamp);
+    const sentinelCount = normalizedBundle.split(ARTIFACT_RELEASE_SENTINEL).length - 1;
+    if (sentinelCount !== 1) {
+      throw new Error(
+        `[build-prebid-external] Expected one artifact release sentinel, found ${sentinelCount}`
+      );
+    }
+    const artifactReleaseId = sha256Hex(Buffer.from(normalizedBundle, 'utf8'));
+    const finalBundle = normalizedBundle.replace(ARTIFACT_RELEASE_SENTINEL, artifactReleaseId);
+    if (finalBundle.includes(ARTIFACT_RELEASE_SENTINEL)) {
+      throw new Error('[build-prebid-external] Artifact release sentinel remained after stamping');
+    }
+    assertNoLegacyRuntimeFlags(finalBundle);
+    assertPurePrebidArtifact(finalBundle);
+    const bundleBytes = Buffer.from(finalBundle, 'utf8');
     const metadata = deriveBundleMetadata(bundleBytes);
     const finalPath = path.join(outDir, metadata.filename);
 
     fs.rmSync(finalPath, { force: true });
-    fs.renameSync(temporaryPath, finalPath);
+    fs.writeFileSync(finalPath, bundleBytes);
+    fs.rmSync(temporaryPath, { force: true });
     renamedTemporaryFile = true;
 
-    return metadata;
+    return { ...metadata, artifactReleaseId };
   } finally {
     if (!renamedTemporaryFile) {
       fs.rmSync(temporaryPath, { force: true });
@@ -368,15 +446,31 @@ export async function main(argv = process.argv.slice(2)) {
 
   try {
     const adapters = generateAdapterImports(args.adapters, generatedModules.adaptersFile);
-    const bidderCodes = readAdapterBidderCodes(adapters);
+    const adapterMetadata = readAdapterMetadata(adapters);
     const userIdModules = generateUserIdImports(args.userIdModules, generatedModules.userIdsFile);
-    generateExternalEntry(generatedModules.entryFile, adapters, bidderCodes);
-    const bundle = await buildExternalBundle(args.outDir, generatedModules);
-    const manifest = {
-      prebidVersion: prebidPackageVersion(),
-      adapters,
-      bidderCodes,
+    generateExternalEntry(generatedModules.entryFile);
+    const version = prebidPackageVersion();
+    if (version !== EXPECTED_PREBID_VERSION) {
+      throw new Error(
+        `[build-prebid-external] Expected Prebid.js ${EXPECTED_PREBID_VERSION}, found ${version}`
+      );
+    }
+    const moduleStems = [
+      ...new Set([...adapters, ...userIdModules.map(({ moduleName }) => moduleName)]),
+    ].sort();
+    const stamp = {
+      abi: 1,
+      artifactReleaseId: ARTIFACT_RELEASE_SENTINEL,
+      prebidVersion: EXPECTED_PREBID_VERSION,
+      moduleStems,
+      bidderCodes: adapterMetadata.bidderCodes,
+      bidderAliases: adapterMetadata.bidderAliases,
       userIdModules,
+    };
+    const bundle = await buildExternalBundle(args.outDir, generatedModules, stamp);
+    const manifest = {
+      ...stamp,
+      artifactReleaseId: bundle.artifactReleaseId,
       sha256: bundle.sha256,
       sri: bundle.sri,
       filename: bundle.filename,
diff --git a/crates/trusted-server-js/lib/eslint-rules/no-adtech-globals.js b/crates/trusted-server-js/lib/eslint-rules/no-adtech-globals.js
new file mode 100644
index 000000000..07de1d026
--- /dev/null
+++ b/crates/trusted-server-js/lib/eslint-rules/no-adtech-globals.js
@@ -0,0 +1,533 @@
+const ADTECH_GLOBALS = new Set(['googletag', 'pbjs']);
+const GLOBAL_ROOTS = new Set(['globalThis', 'self', 'window']);
+
+// Known blind spots include computed composition (`globalThis['goog' + 'letag']`)
+// and function-returned roots (`getWin().googletag`). Exact adapter boundaries,
+// restricted imports, bundle/source scans, and browser ownership tests remain the
+// defense-in-depth layers for those exotic forms.
+
+function normalizeFilename(filename, rootDirectory) {
+  const normalized = filename.replaceAll('\\', '/');
+  if (!rootDirectory) return normalized.startsWith('./') ? normalized.slice(2) : normalized;
+
+  const normalizedRoot = rootDirectory.replaceAll('\\', '/').replace(/\/$/, '');
+  const rootPrefix = `${normalizedRoot}/`;
+  return normalized.startsWith(rootPrefix) ? normalized.slice(rootPrefix.length) : normalized;
+}
+
+function staticPropertyName(node) {
+  if (!node.computed && node.property.type === 'Identifier') {
+    return node.property.name;
+  }
+  if (!node.computed && node.property.type === 'PrivateIdentifier') {
+    return `#${node.property.name}`;
+  }
+  if (
+    node.computed &&
+    node.property.type === 'Literal' &&
+    typeof node.property.value === 'string'
+  ) {
+    return node.property.value;
+  }
+  if (
+    node.computed &&
+    node.property.type === 'TemplateLiteral' &&
+    node.property.expressions.length === 0
+  ) {
+    return node.property.quasis[0]?.value.cooked;
+  }
+  return undefined;
+}
+
+function staticPatternPropertyName(property) {
+  if (!property.computed && property.key.type === 'Identifier') return property.key.name;
+  if (property.key.type === 'Literal' && typeof property.key.value === 'string') {
+    return property.key.value;
+  }
+  if (
+    property.computed &&
+    property.key.type === 'TemplateLiteral' &&
+    property.key.expressions.length === 0
+  ) {
+    return property.key.quasis[0]?.value.cooked;
+  }
+  return undefined;
+}
+
+function staticClassElementName(element) {
+  if (!element.computed && element.key.type === 'Identifier') return element.key.name;
+  if (!element.computed && element.key.type === 'PrivateIdentifier') {
+    return `#${element.key.name}`;
+  }
+  if (element.key.type === 'Literal' && typeof element.key.value === 'string') {
+    return element.key.value;
+  }
+  return undefined;
+}
+
+function unwrapExpression(node) {
+  let current = node;
+  while (
+    current &&
+    [
+      'ChainExpression',
+      'TSAsExpression',
+      'TSInstantiationExpression',
+      'TSNonNullExpression',
+      'TSTypeAssertion',
+    ].includes(current.type)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function strongerOrigin(left, right) {
+  if (left === 'adtech' || right === 'adtech') return 'adtech';
+  if (left === 'root' || right === 'root') return 'root';
+  return 'unknown';
+}
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Keep GPT and Prebid globals behind TSJS adapter interfaces.',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          rootDirectory: { type: 'string' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      externalGlobalOwnedByAdapter:
+        'Access to "{{name}}" is owned by an exact adapter directory; inject an adapter interface instead.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const relativeFilename = normalizeFilename(context.filename, context.options[0]?.rootDirectory);
+    const isAdapter =
+      relativeFilename.startsWith('src/adapters/') ||
+      relativeFilename.startsWith('src/first_display/adapters/');
+
+    if (isAdapter) return {};
+
+    const assignments = new Map();
+    const patternAssignments = new Map();
+    const loopAssignments = new Map();
+    const loopPatternAssignments = new Map();
+    const thisPropertyAssignments = new Map();
+    const classOwnerTokens = new WeakMap();
+    const candidateMembers = [];
+    const candidateIdentifiers = [];
+    const candidatePatterns = [];
+    const reported = new Set();
+
+    function classOwnerToken(classNode, isStatic) {
+      let tokens = classOwnerTokens.get(classNode);
+      if (!tokens) {
+        tokens = { instance: {}, static: {} };
+        classOwnerTokens.set(classNode, tokens);
+      }
+      return isStatic ? tokens.static : tokens.instance;
+    }
+
+    function thisOwner(thisExpression) {
+      let current = thisExpression.parent;
+      let staticClassContext = false;
+
+      while (current) {
+        if (current.type === 'MethodDefinition' || current.type === 'PropertyDefinition') {
+          staticClassContext = current.static;
+        } else if (current.type === 'StaticBlock') {
+          staticClassContext = true;
+        } else if (current.type === 'ClassDeclaration' || current.type === 'ClassExpression') {
+          return classOwnerToken(current, staticClassContext);
+        } else if (
+          current.type === 'FunctionDeclaration' ||
+          current.type === 'FunctionExpression'
+        ) {
+          const parent = current.parent;
+          if (parent?.type === 'MethodDefinition') {
+            current = parent;
+            continue;
+          }
+          if (
+            parent?.type === 'Property' &&
+            parent.method &&
+            parent.parent?.type === 'ObjectExpression'
+          ) {
+            return parent.parent;
+          }
+          return current;
+        }
+        current = current.parent;
+      }
+
+      return sourceCode.ast;
+    }
+
+    function thisPropertyEntry(owner, propertyName, create) {
+      let properties = thisPropertyAssignments.get(owner);
+      if (!properties && create) {
+        properties = new Map();
+        thisPropertyAssignments.set(owner, properties);
+      }
+      if (!properties) return undefined;
+
+      let entry = properties.get(propertyName);
+      if (!entry && create) {
+        entry = { expressions: [] };
+        properties.set(propertyName, entry);
+      }
+      return entry;
+    }
+
+    function recordThisProperty(owner, propertyName, expression) {
+      thisPropertyEntry(owner, propertyName, true).expressions.push(expression);
+    }
+
+    function findVariable(identifier) {
+      let scope = sourceCode.getScope(identifier);
+      while (scope) {
+        const variable = scope.set.get(identifier.name);
+        if (variable) return variable;
+        scope = scope.upper;
+      }
+      return undefined;
+    }
+
+    function isUnshadowedGlobal(identifier, names) {
+      if (!names.has(identifier.name)) return false;
+      const variable = findVariable(identifier);
+      return !variable || variable.defs.length === 0;
+    }
+
+    function isReference(identifier) {
+      let scope = sourceCode.getScope(identifier);
+      while (scope) {
+        if (scope.references.some((reference) => reference.identifier === identifier)) return true;
+        scope = scope.upper;
+      }
+      return false;
+    }
+
+    function patternOriginFromBase(pattern, initializerOrigin, variableName) {
+      if (pattern.type !== 'ObjectPattern') return 'unknown';
+      if (initializerOrigin !== 'root' && initializerOrigin !== 'adtech') return 'unknown';
+
+      for (const property of pattern.properties) {
+        if (property.type === 'RestElement') {
+          if (property.argument.type === 'Identifier' && property.argument.name === variableName) {
+            return initializerOrigin;
+          }
+          continue;
+        }
+        const value =
+          property.value.type === 'AssignmentPattern' ? property.value.left : property.value;
+        if (value.type !== 'Identifier' || value.name !== variableName) continue;
+
+        const propertyName = staticPatternPropertyName(property);
+
+        if (initializerOrigin === 'root' && ADTECH_GLOBALS.has(propertyName)) return 'adtech';
+        if (initializerOrigin === 'root' && propertyName === 'window') return 'root';
+        return initializerOrigin === 'adtech' ? 'adtech' : 'unknown';
+      }
+      return 'unknown';
+    }
+
+    function patternOrigin(pattern, initializer, variableName, seen) {
+      return patternOriginFromBase(pattern, expressionOrigin(initializer, seen), variableName);
+    }
+
+    function variableOrigin(variable, seen) {
+      if (seen.has(variable)) return 'unknown';
+      const nextSeen = new Set(seen).add(variable);
+      let result = 'unknown';
+
+      for (const definition of variable.defs) {
+        if (definition.type === 'Variable') {
+          const declaration = definition.node;
+          if (!declaration.init) continue;
+
+          if (declaration.id.type === 'Identifier') {
+            result = strongerOrigin(result, expressionOrigin(declaration.init, nextSeen));
+          } else {
+            result = strongerOrigin(
+              result,
+              patternOrigin(declaration.id, declaration.init, variable.name, nextSeen)
+            );
+          }
+        } else if (definition.type === 'Parameter') {
+          let parameter = definition.node.params?.[definition.index];
+          if (parameter?.type === 'TSParameterProperty') parameter = parameter.parameter;
+          if (parameter?.type !== 'AssignmentPattern') continue;
+
+          if (parameter.left.type === 'Identifier') {
+            result = strongerOrigin(result, expressionOrigin(parameter.right, nextSeen));
+          } else {
+            result = strongerOrigin(
+              result,
+              patternOrigin(parameter.left, parameter.right, variable.name, nextSeen)
+            );
+          }
+        }
+      }
+
+      for (const expression of assignments.get(variable) ?? []) {
+        result = strongerOrigin(result, expressionOrigin(expression, nextSeen));
+      }
+      for (const { pattern, initializer } of patternAssignments.get(variable) ?? []) {
+        result = strongerOrigin(
+          result,
+          patternOrigin(pattern, initializer, variable.name, nextSeen)
+        );
+      }
+      for (const iterable of loopAssignments.get(variable) ?? []) {
+        result = strongerOrigin(result, iterableElementOrigin(iterable, nextSeen));
+      }
+      for (const { pattern, iterable } of loopPatternAssignments.get(variable) ?? []) {
+        result = strongerOrigin(
+          result,
+          patternOriginFromBase(pattern, iterableElementOrigin(iterable, nextSeen), variable.name)
+        );
+      }
+      return result;
+    }
+
+    function iterableElementOrigin(rawNode, seen = new Set()) {
+      const node = unwrapExpression(rawNode);
+      if (!node) return 'unknown';
+
+      if (node.type === 'ArrayExpression') {
+        return node.elements.reduce((result, element) => {
+          if (!element) return result;
+          const origin =
+            element.type === 'SpreadElement'
+              ? iterableElementOrigin(element.argument, seen)
+              : expressionOrigin(element, seen);
+          return strongerOrigin(result, origin);
+        }, 'unknown');
+      }
+
+      if (node.type === 'Identifier') {
+        const variable = findVariable(node);
+        if (!variable || seen.has(variable)) return 'unknown';
+        const nextSeen = new Set(seen).add(variable);
+        let result = 'unknown';
+        for (const definition of variable.defs) {
+          if (definition.type !== 'Variable' || !definition.node.init) continue;
+          result = strongerOrigin(result, iterableElementOrigin(definition.node.init, nextSeen));
+        }
+        for (const expression of assignments.get(variable) ?? []) {
+          result = strongerOrigin(result, iterableElementOrigin(expression, nextSeen));
+        }
+        return result;
+      }
+
+      if (node.type === 'SequenceExpression') {
+        return iterableElementOrigin(node.expressions.at(-1), seen);
+      }
+      if (node.type === 'LogicalExpression' || node.type === 'ConditionalExpression') {
+        const branches =
+          node.type === 'ConditionalExpression'
+            ? [node.consequent, node.alternate]
+            : [node.left, node.right];
+        return branches.reduce(
+          (result, branch) => strongerOrigin(result, iterableElementOrigin(branch, seen)),
+          'unknown'
+        );
+      }
+      return 'unknown';
+    }
+
+    function expressionOrigin(rawNode, seen = new Set()) {
+      const node = unwrapExpression(rawNode);
+      if (!node) return 'unknown';
+
+      if (node.type === 'Identifier') {
+        if (isUnshadowedGlobal(node, GLOBAL_ROOTS)) return 'root';
+        if (isUnshadowedGlobal(node, ADTECH_GLOBALS)) return 'adtech';
+        const variable = findVariable(node);
+        return variable ? variableOrigin(variable, seen) : 'unknown';
+      }
+
+      if (node.type === 'MemberExpression') {
+        const propertyName = staticPropertyName(node);
+        if (node.object.type === 'ThisExpression') {
+          const entry = thisPropertyEntry(thisOwner(node.object), propertyName, false);
+          if (!entry || seen.has(entry)) return 'unknown';
+          const nextSeen = new Set(seen).add(entry);
+          return entry.expressions.reduce(
+            (result, expression) => strongerOrigin(result, expressionOrigin(expression, nextSeen)),
+            'unknown'
+          );
+        }
+
+        const objectOrigin = expressionOrigin(node.object, seen);
+        if (objectOrigin === 'root' && ADTECH_GLOBALS.has(propertyName)) return 'adtech';
+        if (objectOrigin === 'root' && propertyName === 'window') return 'root';
+        if (objectOrigin === 'adtech') return 'adtech';
+        return 'unknown';
+      }
+
+      if (node.type === 'AssignmentExpression') return expressionOrigin(node.right, seen);
+      if (node.type === 'SequenceExpression') {
+        return expressionOrigin(node.expressions.at(-1), seen);
+      }
+      if (node.type === 'LogicalExpression' || node.type === 'ConditionalExpression') {
+        const branches =
+          node.type === 'ConditionalExpression'
+            ? [node.consequent, node.alternate]
+            : [node.left, node.right];
+        return branches.reduce(
+          (result, branch) => strongerOrigin(result, expressionOrigin(branch, seen)),
+          'unknown'
+        );
+      }
+      return 'unknown';
+    }
+
+    function report(node, name) {
+      const key = `${node.range?.[0] ?? node.loc.start.line}:${node.range?.[1] ?? node.loc.end.column}`;
+      if (reported.has(key)) return;
+      reported.add(key);
+      context.report({
+        node,
+        messageId: 'externalGlobalOwnedByAdapter',
+        data: { name },
+      });
+    }
+
+    function recordPatternAssignments(pattern, initializer) {
+      for (const property of pattern.properties) {
+        const value = property.type === 'RestElement' ? property.argument : property.value;
+        const target = value.type === 'AssignmentPattern' ? value.left : value;
+        if (target.type !== 'Identifier') continue;
+        const variable = findVariable(target);
+        if (!variable) continue;
+        const entries = patternAssignments.get(variable) ?? [];
+        entries.push({ pattern, initializer });
+        patternAssignments.set(variable, entries);
+      }
+    }
+
+    function recordVariableAssignment(identifier, expression) {
+      const variable = findVariable(identifier);
+      if (!variable) return;
+      const values = assignments.get(variable) ?? [];
+      values.push(expression);
+      assignments.set(variable, values);
+    }
+
+    function recordLoopBinding(rawBinding, iterable) {
+      const binding = rawBinding.type === 'AssignmentPattern' ? rawBinding.left : rawBinding;
+      if (binding.type === 'Identifier') {
+        const variable = findVariable(binding);
+        if (!variable) return;
+        const values = loopAssignments.get(variable) ?? [];
+        values.push(iterable);
+        loopAssignments.set(variable, values);
+      } else if (binding.type === 'ObjectPattern') {
+        candidatePatterns.push({ pattern: binding, initializer: iterable, iterable: true });
+        for (const property of binding.properties) {
+          const value = property.type === 'RestElement' ? property.argument : property.value;
+          const target = value.type === 'AssignmentPattern' ? value.left : value;
+          if (target.type !== 'Identifier') continue;
+          const variable = findVariable(target);
+          if (!variable) continue;
+          const entries = loopPatternAssignments.get(variable) ?? [];
+          entries.push({ pattern: binding, iterable });
+          loopPatternAssignments.set(variable, entries);
+        }
+      }
+    }
+
+    return {
+      AssignmentExpression(node) {
+        const left = unwrapExpression(node.left);
+        if (left.type === 'ObjectPattern') {
+          candidatePatterns.push({ pattern: left, initializer: node.right });
+          recordPatternAssignments(left, node.right);
+          return;
+        }
+        if (left.type === 'MemberExpression' && left.object.type === 'ThisExpression') {
+          const propertyName = staticPropertyName(left);
+          if (!propertyName) return;
+          recordThisProperty(thisOwner(left.object), propertyName, node.right);
+          return;
+        }
+        if (left.type !== 'Identifier') return;
+        recordVariableAssignment(left, node.right);
+      },
+
+      ForOfStatement(node) {
+        if (node.left.type === 'VariableDeclaration') {
+          for (const declaration of node.left.declarations) {
+            recordLoopBinding(declaration.id, node.right);
+          }
+        } else {
+          recordLoopBinding(node.left, node.right);
+        }
+      },
+
+      MemberExpression(node) {
+        candidateMembers.push(node);
+      },
+
+      Identifier(node) {
+        candidateIdentifiers.push(node);
+      },
+
+      PropertyDefinition(node) {
+        if (!node.value) return;
+        const propertyName = staticClassElementName(node);
+        const classNode = node.parent?.parent;
+        if (
+          !propertyName ||
+          (classNode?.type !== 'ClassDeclaration' && classNode?.type !== 'ClassExpression')
+        ) {
+          return;
+        }
+        recordThisProperty(classOwnerToken(classNode, node.static), propertyName, node.value);
+      },
+
+      VariableDeclarator(node) {
+        if (node.id.type === 'ObjectPattern' && node.init) {
+          candidatePatterns.push({ pattern: node.id, initializer: node.init });
+        }
+      },
+
+      'Program:exit'() {
+        for (const { pattern, initializer, iterable } of candidatePatterns) {
+          const origin = iterable
+            ? iterableElementOrigin(initializer)
+            : expressionOrigin(initializer);
+          if (origin !== 'root') continue;
+          for (const property of pattern.properties) {
+            if (property.type !== 'Property') continue;
+            const propertyName = staticPatternPropertyName(property);
+            if (ADTECH_GLOBALS.has(propertyName)) report(property, propertyName);
+          }
+        }
+
+        for (const node of candidateMembers) {
+          const propertyName = staticPropertyName(node);
+          if (!ADTECH_GLOBALS.has(propertyName)) continue;
+          if (expressionOrigin(node.object) === 'root') report(node, propertyName);
+        }
+
+        for (const node of candidateIdentifiers) {
+          if (!isReference(node) || expressionOrigin(node) !== 'adtech') continue;
+          report(node, node.name);
+        }
+      },
+    };
+  },
+};
diff --git a/crates/trusted-server-js/lib/eslint.config.js b/crates/trusted-server-js/lib/eslint.config.js
index 2720ba3a0..8efffdb78 100644
--- a/crates/trusted-server-js/lib/eslint.config.js
+++ b/crates/trusted-server-js/lib/eslint.config.js
@@ -1,11 +1,78 @@
-// ESLint v9 flat config
+// ESLint v10 flat config
 import js from '@eslint/js';
+import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript';
+import importX from 'eslint-plugin-import-x';
 import globals from 'globals';
 import tseslint from 'typescript-eslint';
-import importPlugin from 'eslint-plugin-import';
 import jsdoc from 'eslint-plugin-jsdoc';
 import unicorn from 'eslint-plugin-unicorn';
 
+import noAdtechGlobals from './eslint-rules/no-adtech-globals.js';
+
+export const ARCHITECTURE_INTEGRATION_DIRECTORIES = Object.freeze([
+  'aps',
+  'creative',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'gpt_diagnostics',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'render_runtime',
+  'sourcepoint',
+  'testlight',
+]);
+
+const integrationIsolationZones = ARCHITECTURE_INTEGRATION_DIRECTORIES.map((integration) => ({
+  target: `./src/integrations/${integration}`,
+  from: './src/integrations',
+  except: [`./${integration}`],
+  message: 'Integrations must compose through injected services, not import another integration.',
+}));
+
+export const ARCHITECTURE_RESTRICTED_LAYER_ZONES = Object.freeze([
+  {
+    target: './src/core',
+    from: ['./src/adapters', './src/services', './src/integrations', './src/composition'],
+    message: 'Core must not construct or import downstream architecture layers.',
+  },
+  {
+    target: './src/kernel',
+    from: ['./src/adapters', './src/services', './src/integrations', './src/composition'],
+    message: 'Kernel may depend only on kernel contracts.',
+  },
+  {
+    target: './src/adapters',
+    from: [
+      './src/core',
+      './src/shared',
+      './src/services',
+      './src/integrations',
+      './src/composition',
+    ],
+    message: 'Adapters may depend only on kernel contracts.',
+  },
+  {
+    target: './src/services',
+    from: ['./src/core', './src/shared', './src/integrations', './src/composition'],
+    message: 'Services may depend only on kernel and adapter contracts.',
+  },
+  {
+    target: './src/integrations',
+    from: './src/composition',
+    message: 'Integrations must not depend on the composition root.',
+  },
+  {
+    target: ['./src/kernel', './src/adapters', './src/services', './src/integrations'],
+    from: './src/index.ts',
+    message: 'Lower architecture layers must not bypass boundaries through the root barrel.',
+  },
+  ...integrationIsolationZones,
+]);
+
 export default [
   // Files/folders to ignore
   {
@@ -18,6 +85,13 @@ export default [
   // Project rules
   {
     files: ['**/*.ts', '**/*.tsx'],
+    settings: {
+      'import-x/resolver-next': [
+        createTypeScriptImportResolver({
+          project: './tsconfig.json',
+        }),
+      ],
+    },
     languageOptions: {
       parser: tseslint.parser,
       parserOptions: {
@@ -26,15 +100,43 @@ export default [
       },
     },
     plugins: {
-      import: importPlugin,
+      'import-x': importX,
       jsdoc,
+      tsjs: {
+        rules: {
+          'no-adtech-globals': noAdtechGlobals,
+        },
+      },
       unicorn,
       '@typescript-eslint': tseslint.plugin,
     },
     rules: {
       'unicorn/prevent-abbreviations': 'off',
       'unicorn/filename-case': 'off',
-      'import/order': ['error', { 'newlines-between': 'always' }],
+      'import-x/order': ['error', { 'newlines-between': 'always' }],
+    },
+  },
+  {
+    files: ['src/**/*.ts', 'src/**/*.tsx'],
+    rules: {
+      'tsjs/no-adtech-globals': [
+        'error',
+        {
+          rootDirectory: import.meta.dirname,
+        },
+      ],
+    },
+  },
+  {
+    files: ['src/**/*.ts', 'src/**/*.tsx'],
+    rules: {
+      'import-x/no-restricted-paths': [
+        'error',
+        {
+          basePath: import.meta.dirname,
+          zones: ARCHITECTURE_RESTRICTED_LAYER_ZONES,
+        },
+      ],
     },
   },
   // Honor the `_`-prefix convention for intentionally unused bindings in every
@@ -52,7 +154,7 @@ export default [
   // so CommonJS-only names (__dirname, require, module) still fail no-undef
   // in these ES modules
   {
-    files: ['*.mjs', 'test/**/*.mjs'],
+    files: ['*.mjs', 'scripts/**/*.mjs', 'test/**/*.mjs'],
     languageOptions: {
       globals: globals.nodeBuiltin,
     },
diff --git a/crates/trusted-server-js/lib/package-lock.json b/crates/trusted-server-js/lib/package-lock.json
index 588ccd6be..c2d0e76d1 100644
--- a/crates/trusted-server-js/lib/package-lock.json
+++ b/crates/trusted-server-js/lib/package-lock.json
@@ -8,61 +8,70 @@
       "name": "tsjs",
       "version": "0.1.0",
       "dependencies": {
-        "prebid.js": "^10.26.0"
+        "prebid.js": "10.26.0"
       },
       "devDependencies": {
-        "@eslint/js": "^9.13.0",
-        "@types/jsdom": "^27.0.0",
-        "@types/node": "^24.10.0",
-        "@typescript-eslint/eslint-plugin": "^8.6.0",
-        "@typescript-eslint/parser": "^8.6.0",
-        "eslint": "^9.10.0",
+        "@eslint/js": "^10.0.1",
+        "@types/jsdom": "^28.0.3",
+        "@types/node": "^24.13.3",
+        "esbuild": "^0.28.2",
+        "eslint": "^10.8.1",
         "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-import": "^2.29.1",
-        "eslint-plugin-jsdoc": "^62.5.4",
-        "eslint-plugin-unicorn": "^62.0.0",
-        "globals": "^16.0.0",
-        "jsdom": "^28.0.0",
-        "prettier": "^3.2.5",
-        "typescript": "^5.5.4",
-        "typescript-eslint": "^8.56.1",
-        "vite": "^7.3.1",
-        "vitest": "^4.0.8"
-      }
-    },
-    "node_modules/@acemir/cssom": {
-      "version": "0.9.31",
-      "resolved": "https://registry.npmjs.org/@acemir/cssom/-/cssom-0.9.31.tgz",
-      "integrity": "sha512-ZnR3GSaH+/vJ0YlHau21FjfLYjMpYVIzTD8M8vIEQvIGxeOXyXdzCI140rrCY862p/C/BbzWsjc1dgnM9mkoTA==",
-      "dev": true,
-      "license": "MIT"
+        "eslint-import-resolver-typescript": "^4.4.5",
+        "eslint-plugin-import-x": "^4.17.1",
+        "eslint-plugin-jsdoc": "^63.3.3",
+        "eslint-plugin-unicorn": "^73.0.0",
+        "globals": "^17.11.0",
+        "jsdom": "^29.1.1",
+        "prettier": "^3.9.6",
+        "typescript": "~6.0.3",
+        "typescript-eslint": "^8.67.0",
+        "vite": "^8.2.1",
+        "vitest": "^4.1.10"
+      }
     },
     "node_modules/@asamuzakjp/css-color": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-4.1.2.tgz",
-      "integrity": "sha512-NfBUvBaYgKIuq6E/RBLY1m0IohzNHAYyaJGuTK79Z23uNwmz2jl1mPsC5ZxCCxylinKhT1Amn5oNTlx1wN8cQg==",
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+      "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@csstools/css-calc": "^3.0.0",
-        "@csstools/css-color-parser": "^4.0.1",
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@csstools/css-calc": "^3.2.0",
+        "@csstools/css-color-parser": "^4.1.0",
         "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0",
-        "lru-cache": "^11.2.5"
+        "@csstools/css-tokenizer": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
     "node_modules/@asamuzakjp/dom-selector": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-6.8.1.tgz",
-      "integrity": "sha512-MvRz1nCqW0fsy8Qz4dnLIvhOlMzqDVBabZx6lH+YywFDdjXhMY37SmpV1XFX3JzG5GWHn63j6HX6QPr3lZXHvQ==",
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+      "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
         "@asamuzakjp/nwsapi": "^2.3.9",
         "bidi-js": "^1.0.3",
-        "css-tree": "^3.1.0",
-        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.2.6"
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/generational-cache": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+      "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
     "node_modules/@asamuzakjp/nwsapi": {
@@ -73,12 +82,12 @@
       "license": "MIT"
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
-      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/helper-validator-identifier": "^7.29.7",
         "js-tokens": "^4.0.0",
         "picocolors": "^1.1.1"
       },
@@ -87,30 +96,29 @@
       }
     },
     "node_modules/@babel/compat-data": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
-      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/core": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
-      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helpers": "^7.28.6",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/traverse": "^7.29.0",
-        "@babel/types": "^7.29.0",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
         "@jridgewell/remapping": "^2.3.5",
         "convert-source-map": "^2.0.0",
         "debug": "^4.1.0",
@@ -136,13 +144,13 @@
       }
     },
     "node_modules/@babel/generator": {
-      "version": "7.29.1",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
-      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz",
+      "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/parser": "^7.29.0",
-        "@babel/types": "^7.29.0",
+        "@babel/parser": "^7.29.8",
+        "@babel/types": "^7.29.8",
         "@jridgewell/gen-mapping": "^0.3.12",
         "@jridgewell/trace-mapping": "^0.3.28",
         "jsesc": "^3.0.2"
@@ -152,25 +160,25 @@
       }
     },
     "node_modules/@babel/helper-annotate-as-pure": {
-      "version": "7.27.3",
-      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz",
-      "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.29.7.tgz",
+      "integrity": "sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.27.3"
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-compilation-targets": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
-      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/compat-data": "^7.28.6",
-        "@babel/helper-validator-option": "^7.27.1",
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
         "browserslist": "^4.24.0",
         "lru-cache": "^5.1.1",
         "semver": "^6.3.1"
@@ -198,17 +206,17 @@
       }
     },
     "node_modules/@babel/helper-create-class-features-plugin": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz",
-      "integrity": "sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.3",
-        "@babel/helper-member-expression-to-functions": "^7.28.5",
-        "@babel/helper-optimise-call-expression": "^7.27.1",
-        "@babel/helper-replace-supers": "^7.28.6",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
-        "@babel/traverse": "^7.28.6",
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
         "semver": "^6.3.1"
       },
       "engines": {
@@ -228,12 +236,12 @@
       }
     },
     "node_modules/@babel/helper-create-regexp-features-plugin": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.28.5.tgz",
-      "integrity": "sha512-N1EhvLtHzOvj7QQOUCCS3NrPJP8c5W6ZXCHDn7Yialuy1iu4r5EmIYkXlKNqT99Ciw+W0mDqWoR6HWMZlFP3hw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.29.7.tgz",
+      "integrity": "sha512-907Uymvqgg1dwUA+7IGwFAOSYzQOuzPXKNJ1yxzwPffzkYFg2q2eHi1fIOs6sXkG9NbIUMunnUlkYsfRFNvomg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.3",
+        "@babel/helper-annotate-as-pure": "^7.29.7",
         "regexpu-core": "^6.3.1",
         "semver": "^6.3.1"
       },
@@ -254,9 +262,9 @@
       }
     },
     "node_modules/@babel/helper-define-polyfill-provider": {
-      "version": "0.6.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.6.tgz",
-      "integrity": "sha512-mOAsxeeKkUKayvZR3HeTYD/fICpCPLJrU5ZjelT/PA6WHtNDBOE436YiaEUvHN454bRM3CebhDsIpieCc4texA==",
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.8.tgz",
+      "integrity": "sha512-47UwBLPpQi1NoWzLuHNjRoHlYXMwIJoBf7MFou6viC/sIHWYygpvr0B6IAyh5sBdA2nr2LPIRww8lfaUVQINBA==",
       "license": "MIT",
       "dependencies": {
         "@babel/helper-compilation-targets": "^7.28.6",
@@ -270,49 +278,49 @@
       }
     },
     "node_modules/@babel/helper-globals": {
-      "version": "7.28.0",
-      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
-      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-member-expression-to-functions": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz",
-      "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.29.7.tgz",
+      "integrity": "sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.28.5",
-        "@babel/types": "^7.28.5"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-imports": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
-      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-module-transforms": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
-      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -322,35 +330,35 @@
       }
     },
     "node_modules/@babel/helper-optimise-call-expression": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz",
-      "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.29.7.tgz",
+      "integrity": "sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.27.1"
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-plugin-utils": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
-      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.29.7.tgz",
+      "integrity": "sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-remap-async-to-generator": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz",
-      "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-16AMiW26DbXWBbr3B8wNozKM0ydMLB892vaOaJW/fPJdnT8vJk5sdkQcU/isqUxyCE0cEoa8wZOcbgDuC4b6Og==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.1",
-        "@babel/helper-wrap-function": "^7.27.1",
-        "@babel/traverse": "^7.27.1"
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-wrap-function": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -360,14 +368,14 @@
       }
     },
     "node_modules/@babel/helper-replace-supers": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz",
-      "integrity": "sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.29.7.tgz",
+      "integrity": "sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-member-expression-to-functions": "^7.28.5",
-        "@babel/helper-optimise-call-expression": "^7.27.1",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-member-expression-to-functions": "^7.29.7",
+        "@babel/helper-optimise-call-expression": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -377,79 +385,79 @@
       }
     },
     "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz",
-      "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.29.7.tgz",
+      "integrity": "sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/traverse": "^7.27.1",
-        "@babel/types": "^7.27.1"
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
-      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
-      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-option": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
-      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-wrap-function": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz",
-      "integrity": "sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.29.7.tgz",
+      "integrity": "sha512-iES0Skag9ERIF68aXadpO6dbXa03mNWK3sEqJaMnLNs/eC3l0lkImdfoy6Y09/SfkpawdAB4RjQ7PVA7TcVGdw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.28.6",
-        "@babel/traverse": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helpers": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
-      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/parser": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
-      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",
+      "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/types": "^7.29.0"
+        "@babel/types": "^7.29.8"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -459,13 +467,13 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.28.5.tgz",
-      "integrity": "sha512-87GDMS3tsmMSi/3bWOte1UblL+YUTFMV8SZPZ2eSEL17s74Cw/l63rR6NmGVKMYW2GYi85nE+/d6Hw5N0bEk2Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.29.7.tgz",
+      "integrity": "sha512-j8SrR0zLZrRsC09DlszEx8FpMiwukKffYXMK0d5LmOglO7vGG6sz/BR/20yHqWH+Lnn31JTt2PE3hIWNgM2J6w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/traverse": "^7.28.5"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -475,12 +483,12 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz",
-      "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.29.7.tgz",
+      "integrity": "sha512-r8j8escF+U2FUHo0KOhPUdMzUO+jp9fInva6+ACVAF3Y97Ev+5iNZwiqTghmzNeWwDkOPlYuTcfb1vDaoZKmAQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -490,12 +498,28 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz",
-      "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.29.7.tgz",
+      "integrity": "sha512-GE1TFSiuFeGsCxmYXZl8HwoPrVlwe4rHPFE8weieGKZqnDORK+Ar3vgWMgW+AOxQ6/2TgLSKx9p6W7O4rC6qgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-rest-destructuring-rhs-array/-/plugin-bugfix-safari-rest-destructuring-rhs-array-7.29.7.tgz",
+      "integrity": "sha512-oBNVCvnO5tND+xSopWvV8WNGfpTfgP4Zr/YXXSj8zfmcPktp5Ku/aZlsIowgSD4fjmgHn6sGmB9APVsU5zOdhA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -505,14 +529,14 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz",
-      "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-QQt9qKHZ2sg/kivaLr7lnQr8HVrQDdBNSfCsTjiDxRuX/K5ORyKq+Bu8Xr0cDE3Dfkv0cw28Ve0EKyKMvulkOw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
-        "@babel/plugin-transform-optional-chaining": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -522,13 +546,13 @@
       }
     },
     "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz",
-      "integrity": "sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.29.7.tgz",
+      "integrity": "sha512-pn6QacGLgvCcwc+syUhKE/qSjV2D1IHDB84RNxWYSt1mW3K/SCtjinZ2p0cETJxAWBjPy3K/1lHwG5BjjPxNlw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -550,12 +574,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-import-assertions": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz",
-      "integrity": "sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.29.7.tgz",
+      "integrity": "sha512-/An1OCBN93thpBAGyfsK2pcf0jvju1SAtKkL2Ny++B5Sy6sqgzXDQH1cZxWbF96Wuk+bn41MDA9bLd4VVAw6rw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -565,12 +589,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-import-attributes": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz",
-      "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.29.7.tgz",
+      "integrity": "sha512-zGYcYfq/WmZ4V+kBIXQon9dSSc8ircGZqw9ZaNhhGj9nZkeBu1jHLBDQqYYi5WA9uawvA2sIMbry2nCFhf5Djg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -580,12 +604,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-jsx": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz",
-      "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.29.7.tgz",
+      "integrity": "sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -595,12 +619,12 @@
       }
     },
     "node_modules/@babel/plugin-syntax-typescript": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz",
-      "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.29.7.tgz",
+      "integrity": "sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -626,12 +650,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-arrow-functions": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz",
-      "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.29.7.tgz",
+      "integrity": "sha512-N7zArUXWzAMzm+/N0uPBeVB3Fam5lMxtUwMmDK5f/IBBS7a7p1qeUoxd/6CckXoxUdgsntq1Dh8xNW06maZbDQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -641,14 +665,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-async-generator-functions": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz",
-      "integrity": "sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.7.tgz",
+      "integrity": "sha512-d98gXZkgswvkyohMBABkhm3GeXhYj8psWfwQ2C7gtfrKGTykQa/iOIi+JJhwMjPlZ6Vm2XN+DCf3Es1EoG4ZLA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-remap-async-to-generator": "^7.27.1",
-        "@babel/traverse": "^7.29.0"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -658,14 +682,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-async-to-generator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz",
-      "integrity": "sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.29.7.tgz",
+      "integrity": "sha512-pcUb2SS+RMo9TWVBwKGI5ShtoG7R+zBsFmCKDa6fe8c+hPr3XJlZgoE5j6i8W7gDjhyvy+85vmYexanvXh3d1w==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-imports": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-remap-async-to-generator": "^7.27.1"
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-remap-async-to-generator": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -675,12 +699,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-block-scoped-functions": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz",
-      "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.29.7.tgz",
+      "integrity": "sha512-cUSmjh72N+rN4PrkFlN1dJwNCwjVp5d38/CQrEsFggkD10UiFlBFgdH3tv5dNsLuHY+3S8db2xCHjhZcv5WgvA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -690,12 +714,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-block-scoping": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz",
-      "integrity": "sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.29.7.tgz",
+      "integrity": "sha512-ONyr4+AZhKh8yKWInVxU9AXA9EbsyeLcL6V0dJy6M2/62vuvpGm29zzuymbTpdc451GEpDIdAyPLP3r+P61yKQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -705,13 +729,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-class-properties": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz",
-      "integrity": "sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.29.7.tgz",
+      "integrity": "sha512-GtcpjFvanPfzNQi3eTitsCqtRRmmqzpy/A+yhTR1HaZo1Ly3EA8ZXxlPyHdR8/IuRMYc3E4wdGBewB2QKQjAaA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -721,13 +745,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-class-static-block": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz",
-      "integrity": "sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.29.7.tgz",
+      "integrity": "sha512-kibJgmEdX2iMwsHY2tSZNDgj8PwIlCQz7FK9KuGKO8zsuoUwSEhoNnNVp/emKWrbY4HeO6kkXfdMqRKKKXBm2A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -737,17 +761,17 @@
       }
     },
     "node_modules/@babel/plugin-transform-classes": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz",
-      "integrity": "sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.29.7.tgz",
+      "integrity": "sha512-qV0OGGBVacduzQHE649JyCneOFI/maT+YKsO+K4Yi3xv2wTPNjM/W2o2gdzMwEAZz7fXNTHAe0NcSg30bIN69g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.3",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-replace-supers": "^7.28.6",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -757,13 +781,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-computed-properties": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz",
-      "integrity": "sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.29.7.tgz",
+      "integrity": "sha512-RK7/IyU5phpuCdBAuig5VkzG/EnbDaui5SQGdU9BFrHdV+mV4cUjLMQ9lJDjLNtWHsqtiefpGZUXQP2BiTYMsA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/template": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/template": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -773,13 +797,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-destructuring": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.5.tgz",
-      "integrity": "sha512-Kl9Bc6D0zTUcFUvkNuQh4eGXPKKNDOJQXVyyM4ZAQPMveniJdxi8XMJwLo+xSoW3MIq81bD33lcUe9kZpl0MCw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.29.7.tgz",
+      "integrity": "sha512-iPX8aD6H9zV5s7ZsqTdNocPN/MGQ5sSMnElKrktxjJRMnB2jN/1p2+R7GkfD6CAYoVFqy5A4XnSIUeGgJzIWpg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/traverse": "^7.28.5"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -789,13 +813,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-dotall-regex": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz",
-      "integrity": "sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.29.7.tgz",
+      "integrity": "sha512-3qc18hsD2RdZiyJNDNc7HQpv6xbncwh8FYtxNFFzclSyh/trPD9KkVR9BDECUjDLvb7yJVF15GfYUuC+LMkkiQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -805,12 +829,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-duplicate-keys": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz",
-      "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.29.7.tgz",
+      "integrity": "sha512-6IvRRriEMqnBwD6chtxdLpMYCHWEzN+oL5cyQtjykya19UgzbmKhxmhZgKC/LHxS2nYr9Q/qYPZ5Lr6jOL9+yQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -820,13 +844,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz",
-      "integrity": "sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-2wiIyo2BjtgU7HufSeDnL9L2O7zr8jmhFKuSr65VpRkUiRKRNpb0mdlk56+XPPKoIrfHqzbMuglDvZun0RISsA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -836,12 +860,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-dynamic-import": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz",
-      "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.29.7.tgz",
+      "integrity": "sha512-giOlEm/EFjfjr+te9NsdjkUo2v4f8rS/SXPumRVHAtbNcyNlvtREkU1dZzaIDclNpnaVhlCqRdFKhJBjBikzLg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -851,13 +875,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-explicit-resource-management": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz",
-      "integrity": "sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.29.7.tgz",
+      "integrity": "sha512-Rstj7coNz8sE+7Ju7ihpHLI564lsK5pUpNNlvptCIC/16E/S5hbl6n3kESPKdNRmqEWlpn5xpS5Q2dvXBsySLw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/plugin-transform-destructuring": "^7.28.5"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -867,12 +891,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-exponentiation-operator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz",
-      "integrity": "sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.29.7.tgz",
+      "integrity": "sha512-zFpMOTLZBdW5LfObqcSbL6kefg4R4eLdmvS0wbN9M6D5Mym/sKm9toOoWyVOa+xDjvCnuWcHls2YonXwHvH3CQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -882,12 +906,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-export-namespace-from": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz",
-      "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.29.7.tgz",
+      "integrity": "sha512-24B2nOy2TeJSMheqwPD4DDQOV/elLSIlKxjZt4i05H5AgdPdWR3n18HnNrcJ+j76WJd9gbwb9jPjNYUy6RautA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -897,13 +921,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-for-of": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz",
-      "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.29.7.tgz",
+      "integrity": "sha512-zeSIHh0+E1Um1WJRXCFlHQYu2ieJNdivLLjlBEp+dIBu3S51n+SZZmIXjxnItw6pz56Cn+KvK68BIBVsxq2JiQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -913,14 +937,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-function-name": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz",
-      "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.29.7.tgz",
+      "integrity": "sha512-otRWaHXE6fbAGkePvaj/kvs3HsqXfPhlnzwSOlnFgbqCPMd975dW+4wZ00WFBt+/YlBGcJwNrARQTOJOb4ZrIg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-compilation-targets": "^7.27.1",
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/traverse": "^7.27.1"
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -930,12 +954,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-json-strings": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz",
-      "integrity": "sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.29.7.tgz",
+      "integrity": "sha512-RRnE2+eon1rJAq8MnoF1b5kTpY1vU88twHcvcKMrsqP/jxIRqDVs9iJB5fqPuqyeFAW0wJo4MlUIPpQCq/aRsg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -945,12 +969,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-literals": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz",
-      "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.29.7.tgz",
+      "integrity": "sha512-DZ/oLP21ZuWx1vKqnoNv6/tvEK48AQOBRai40CX9dTjGluvT/YZCyY3rryDtyUqCEoyNroy5KKPwX2iQCiRvyw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -960,12 +984,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-logical-assignment-operators": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz",
-      "integrity": "sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.29.7.tgz",
+      "integrity": "sha512-A0H91hh6W8MFRkp5TqJmMr39jzGD1A1E1Ysiv2O06Sfbhkapm+XyIzxWCEh5kqwOZ1/8QZ0dY3SeQ7XBqfJd5Q==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -975,12 +999,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-member-expression-literals": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz",
-      "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.29.7.tgz",
+      "integrity": "sha512-hl1kwFZCCiDyfH25Xmco9jTrkPgnS9pmOzSG7W5I4SaGbLeqKv417hcU2RKmaxoPEgsoJh7ZPOrnPGq99bHoUg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -990,13 +1014,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-amd": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz",
-      "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.29.7.tgz",
+      "integrity": "sha512-fxtQoH3m5ywUSIfaH0FGCzWu4McsYon5bD3K4XnskC7f+OyQMj7rsOMi4NvvmJ83WwBAg4UCe+ov4VZlqEvyew==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.27.1",
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1006,13 +1030,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-commonjs": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz",
-      "integrity": "sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.29.7.tgz",
+      "integrity": "sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1022,15 +1046,15 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-systemjs": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz",
-      "integrity": "sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.8.tgz",
+      "integrity": "sha512-6iSnEK0zlkLKU4heofK/AdmRD4e2SHVpJMtrwnTCzhnaM98ria4rTrOXBBi45BTTYnJtO8txnPsX4fChYXkmeA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@babel/traverse": "^7.29.0"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.8"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1040,13 +1064,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-modules-umd": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz",
-      "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.29.7.tgz",
+      "integrity": "sha512-B4UkaTK3QpgCwJnrxKfMPKdo92CN7OKXAlpAAnM3UPu0Q0lCCk57ylA9AJbRy2v8dDKOPAAWcoR6CMyeoHwRCA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-module-transforms": "^7.27.1",
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1056,13 +1080,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-named-capturing-groups-regex": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz",
-      "integrity": "sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.7.tgz",
+      "integrity": "sha512-vuFoLwr4qnv2xbZ16SQd6uPcH5FNrLHhk/Jzo++0XJFcaDsr4gjJVg6j398oMHiC+83k/GiBzviwF5KBJkPUtQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1072,12 +1096,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-new-target": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz",
-      "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.29.7.tgz",
+      "integrity": "sha512-fEo41GmsOUhOBlw8ioo6zvjX5Xc2Lqkzlyfqbpsk3eB6TReV18uhxZ0esfEokVbY2+PVJAQHNKxER6lGrzNd3A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1087,12 +1111,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-nullish-coalescing-operator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz",
-      "integrity": "sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.29.7.tgz",
+      "integrity": "sha512-idmp1dFaekP9GbcMvG24Kvw2BfhFZjHnNJCkV4WuIY4PskJzwI3f1N5OdgYke38T7rftO6ERulFRn2cFeZwRkg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1102,12 +1126,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-numeric-separator": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz",
-      "integrity": "sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.29.7.tgz",
+      "integrity": "sha512-zR7fv/z14OjgHl4AgRtkDBvBMhIzCxqV/qN/2BCRC7LjFwvuzjYe7gDWxC4Wl/SNsLM6SE1IWvRPYMgSJaUvNw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1117,16 +1141,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-object-rest-spread": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz",
-      "integrity": "sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.29.7.tgz",
+      "integrity": "sha512-Ld98jn4c0smUywL57m7SgsHq3OpThOa6LqZJif3G6jYOovPleoFhVrBJ1WegRApSFB2wu4+RelAj9AC9G08Z4A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/plugin-transform-destructuring": "^7.28.5",
-        "@babel/plugin-transform-parameters": "^7.27.7",
-        "@babel/traverse": "^7.28.6"
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1136,13 +1160,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-object-super": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz",
-      "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.29.7.tgz",
+      "integrity": "sha512-Ea/diGcw0twB5IlZPO5sgET6fJsLJqPABqTuFWIR+iMPGPZJkATEIWx0wa+aEQ5UY1CBQyP/gkAiLEqn1vBiQA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/helper-replace-supers": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-replace-supers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1152,12 +1176,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-optional-catch-binding": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz",
-      "integrity": "sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.29.7.tgz",
+      "integrity": "sha512-sLsyndxK2VwX6yNUOakMb7Sh553ZTe/vVM1XJ+9Z5aW1ytsc8xOIwmyk05NNjN60vkc5/KqoTH6hB4V41LJhng==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1167,13 +1191,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-optional-chaining": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz",
-      "integrity": "sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.29.7.tgz",
+      "integrity": "sha512-6GM1dhvK3gNODkXcEcMCOLEDCLSoZ/sBbro2Ax8HURyasQ4NshagQixkRFdh5niI6E4gmA/jYI/4aT7rRos3ZQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1183,12 +1207,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-parameters": {
-      "version": "7.27.7",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz",
-      "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.29.7.tgz",
+      "integrity": "sha512-ZDOBqV/qLYJI0YElr8DcENEyARsFQeESqWXH6gZlghYXuPPjvweuDhP4VyEi4BlUBlLRFZVjxoZDMjxhLW766g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1198,13 +1222,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-private-methods": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz",
-      "integrity": "sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.29.7.tgz",
+      "integrity": "sha512-/6Rz4DK1ETDEM/bWHsPHcaEe7ZaT1EqSXjtSP/L0DijOYuaUhiRiOKcwpZ8P7zR4xXEHc2ITdiCgBm9Tpyv9ug==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-class-features-plugin": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1214,14 +1238,14 @@
       }
     },
     "node_modules/@babel/plugin-transform-private-property-in-object": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz",
-      "integrity": "sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.29.7.tgz",
+      "integrity": "sha512-+BNo06dnrzdNNqCm1X6YUaVv0DKk8Q+JYcoZfOkLhYWNCXzlwTSRq8zGWayT1csjcpNXV9CQTBRRbmTLZac5cA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.3",
-        "@babel/helper-create-class-features-plugin": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1231,12 +1255,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-property-literals": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz",
-      "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.29.7.tgz",
+      "integrity": "sha512-bOMRLQuI0A5ZqHq3OWJ89/rXpJ/NJrbVhXiP4zwPGMs6kpcVsuTUNjwoE30K0Qm3mf48a/TnRYYD6vPNqcg6jA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1246,12 +1270,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-regenerator": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz",
-      "integrity": "sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.8.tgz",
+      "integrity": "sha512-0UpIXPtdDtMXfnV2OJAVMLpj3H/92vmkA6lpSRakmycJvj3VUy6Xs1dM8tXRugupykr5WB+LpiVl0J8LMVg2mg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1261,13 +1285,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-regexp-modifiers": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz",
-      "integrity": "sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.29.7.tgz",
+      "integrity": "sha512-mB5Fs0VWrJ42ZCmc8114v60qetdaUVNkj9PmSZRmanCZM3S9hm0CFRLjRmYIsuXav14l2jvZ+4T8iiCGnhj3nQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1277,12 +1301,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-reserved-words": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz",
-      "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.29.7.tgz",
+      "integrity": "sha512-5+YhdpVgmfSmwZyLMftfaiffLRMHjzIRHFHHLdibcSyJm2pasMrKHrO3Ptrt2DRshjvpgjEJJ1zVW14WPq/6QA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1292,12 +1316,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-shorthand-properties": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz",
-      "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.29.7.tgz",
+      "integrity": "sha512-I+WYbGBAiCn7nA6xBrlgPH+MB7HWb4u8pv5S0Pv7OtwNvIFvCCb24YlttKEeUFVurfBCEaOTnuhlqsb7f0Z5Dg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1307,13 +1331,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-spread": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz",
-      "integrity": "sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.29.8.tgz",
+      "integrity": "sha512-4S9ksMGVWUshvgK0mKfvZky7leuG5/uoFVwMpAomJ8bMoDJiNHRVmc1EglwW/CmGVSqqWpEbXm9FmbRit22qoA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1323,12 +1347,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-sticky-regex": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz",
-      "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.29.7.tgz",
+      "integrity": "sha512-BCHzNYJGe9l7EpwwDBN/ztlL2NYFFq8hp9ddjtUEM9f2O7S7kKV/lL6Fwo7IF7NSkYhPK2vO+86nIGltA90MsA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1338,12 +1362,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-template-literals": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz",
-      "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.29.7.tgz",
+      "integrity": "sha512-NCSEJ4sLFU2gqAub45HYh4fus2yQ36rr6ei6vpU7NdoJqCpxvEG8E6eJpscGyXP3VHD2Ny+fSXr04k1hoUrFqA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1353,12 +1377,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-typeof-symbol": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz",
-      "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.29.7.tgz",
+      "integrity": "sha512-223mNGoTkBiTEWFoK+Q6Go3tueMRclO8vxxxxquNCYuNI4jWOofFKJRRDu6SDrB8Sgo1UEGW9T4GAQ8ZyRso1A==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1368,16 +1392,16 @@
       }
     },
     "node_modules/@babel/plugin-transform-typescript": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz",
-      "integrity": "sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.29.7.tgz",
+      "integrity": "sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-annotate-as-pure": "^7.27.3",
-        "@babel/helper-create-class-features-plugin": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1",
-        "@babel/plugin-syntax-typescript": "^7.28.6"
+        "@babel/helper-annotate-as-pure": "^7.29.7",
+        "@babel/helper-create-class-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.29.7",
+        "@babel/plugin-syntax-typescript": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1387,12 +1411,12 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-escapes": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz",
-      "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.29.7.tgz",
+      "integrity": "sha512-jCfXxSjf94lf4E0hKE0AByxF6F3/pVFqRdUUNkDJhsY0m1ZKjnN6ZYyMeHNpzflxb/0q5b7t3p+BE+SLF1WOtA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1402,13 +1426,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-property-regex": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz",
-      "integrity": "sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.29.7.tgz",
+      "integrity": "sha512-OgZ+zoAJgZLUCunsTRQ5LAjOywDv5zzZ2/hQ5aMw1pGXyY2rtE8/chXYUmu3AlVHKpm10KEdG9aMwbI/K76ZGw==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1418,13 +1442,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-regex": {
-      "version": "7.27.1",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz",
-      "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.29.7.tgz",
+      "integrity": "sha512-7D/x/23/d/3VqZ0QA+LGbZMlGwZjztBygSWWWsfTPoQ1oQ6Q1P6Mr3d0kk42XabyUVw+fha3LqdRsFqeKqvCyA==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.27.1",
-        "@babel/helper-plugin-utils": "^7.27.1"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1434,13 +1458,13 @@
       }
     },
     "node_modules/@babel/plugin-transform-unicode-sets-regex": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz",
-      "integrity": "sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.29.7.tgz",
+      "integrity": "sha512-BLOhLht9DOJwIxlmp91wHvkXv1lguuHS3/FwUO8HL1H0u8s4hR1gASVFyilu9iGtcTRYqjTZmlsFFeQletntEg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-create-regexp-features-plugin": "^7.28.5",
-        "@babel/helper-plugin-utils": "^7.28.6"
+        "@babel/helper-create-regexp-features-plugin": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1450,75 +1474,76 @@
       }
     },
     "node_modules/@babel/preset-env": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.0.tgz",
-      "integrity": "sha512-fNEdfc0yi16lt6IZo2Qxk3knHVdfMYX33czNb4v8yWhemoBhibCpQK/uYHtSKIiO+p/zd3+8fYVXhQdOVV608w==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/compat-data": "^7.29.0",
-        "@babel/helper-compilation-targets": "^7.28.6",
-        "@babel/helper-plugin-utils": "^7.28.6",
-        "@babel/helper-validator-option": "^7.27.1",
-        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.28.5",
-        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1",
-        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1",
-        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1",
-        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.6",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.7.tgz",
+      "integrity": "sha512-GYzX36n1nsciIb0uyH0GHwxwtNwPQIcpxSeiVLDtG/B7jB5xXgchnmL1f/jCX5o+pwnaDBtO60ONSJhEBJfxYA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.29.7",
+        "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.29.7",
+        "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.29.7",
+        "@babel/plugin-bugfix-safari-rest-destructuring-rhs-array": "^7.29.7",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.29.7",
+        "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.29.7",
         "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2",
-        "@babel/plugin-syntax-import-assertions": "^7.28.6",
-        "@babel/plugin-syntax-import-attributes": "^7.28.6",
+        "@babel/plugin-syntax-import-assertions": "^7.29.7",
+        "@babel/plugin-syntax-import-attributes": "^7.29.7",
         "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6",
-        "@babel/plugin-transform-arrow-functions": "^7.27.1",
-        "@babel/plugin-transform-async-generator-functions": "^7.29.0",
-        "@babel/plugin-transform-async-to-generator": "^7.28.6",
-        "@babel/plugin-transform-block-scoped-functions": "^7.27.1",
-        "@babel/plugin-transform-block-scoping": "^7.28.6",
-        "@babel/plugin-transform-class-properties": "^7.28.6",
-        "@babel/plugin-transform-class-static-block": "^7.28.6",
-        "@babel/plugin-transform-classes": "^7.28.6",
-        "@babel/plugin-transform-computed-properties": "^7.28.6",
-        "@babel/plugin-transform-destructuring": "^7.28.5",
-        "@babel/plugin-transform-dotall-regex": "^7.28.6",
-        "@babel/plugin-transform-duplicate-keys": "^7.27.1",
-        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.0",
-        "@babel/plugin-transform-dynamic-import": "^7.27.1",
-        "@babel/plugin-transform-explicit-resource-management": "^7.28.6",
-        "@babel/plugin-transform-exponentiation-operator": "^7.28.6",
-        "@babel/plugin-transform-export-namespace-from": "^7.27.1",
-        "@babel/plugin-transform-for-of": "^7.27.1",
-        "@babel/plugin-transform-function-name": "^7.27.1",
-        "@babel/plugin-transform-json-strings": "^7.28.6",
-        "@babel/plugin-transform-literals": "^7.27.1",
-        "@babel/plugin-transform-logical-assignment-operators": "^7.28.6",
-        "@babel/plugin-transform-member-expression-literals": "^7.27.1",
-        "@babel/plugin-transform-modules-amd": "^7.27.1",
-        "@babel/plugin-transform-modules-commonjs": "^7.28.6",
-        "@babel/plugin-transform-modules-systemjs": "^7.29.0",
-        "@babel/plugin-transform-modules-umd": "^7.27.1",
-        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.0",
-        "@babel/plugin-transform-new-target": "^7.27.1",
-        "@babel/plugin-transform-nullish-coalescing-operator": "^7.28.6",
-        "@babel/plugin-transform-numeric-separator": "^7.28.6",
-        "@babel/plugin-transform-object-rest-spread": "^7.28.6",
-        "@babel/plugin-transform-object-super": "^7.27.1",
-        "@babel/plugin-transform-optional-catch-binding": "^7.28.6",
-        "@babel/plugin-transform-optional-chaining": "^7.28.6",
-        "@babel/plugin-transform-parameters": "^7.27.7",
-        "@babel/plugin-transform-private-methods": "^7.28.6",
-        "@babel/plugin-transform-private-property-in-object": "^7.28.6",
-        "@babel/plugin-transform-property-literals": "^7.27.1",
-        "@babel/plugin-transform-regenerator": "^7.29.0",
-        "@babel/plugin-transform-regexp-modifiers": "^7.28.6",
-        "@babel/plugin-transform-reserved-words": "^7.27.1",
-        "@babel/plugin-transform-shorthand-properties": "^7.27.1",
-        "@babel/plugin-transform-spread": "^7.28.6",
-        "@babel/plugin-transform-sticky-regex": "^7.27.1",
-        "@babel/plugin-transform-template-literals": "^7.27.1",
-        "@babel/plugin-transform-typeof-symbol": "^7.27.1",
-        "@babel/plugin-transform-unicode-escapes": "^7.27.1",
-        "@babel/plugin-transform-unicode-property-regex": "^7.28.6",
-        "@babel/plugin-transform-unicode-regex": "^7.27.1",
-        "@babel/plugin-transform-unicode-sets-regex": "^7.28.6",
+        "@babel/plugin-transform-arrow-functions": "^7.29.7",
+        "@babel/plugin-transform-async-generator-functions": "^7.29.7",
+        "@babel/plugin-transform-async-to-generator": "^7.29.7",
+        "@babel/plugin-transform-block-scoped-functions": "^7.29.7",
+        "@babel/plugin-transform-block-scoping": "^7.29.7",
+        "@babel/plugin-transform-class-properties": "^7.29.7",
+        "@babel/plugin-transform-class-static-block": "^7.29.7",
+        "@babel/plugin-transform-classes": "^7.29.7",
+        "@babel/plugin-transform-computed-properties": "^7.29.7",
+        "@babel/plugin-transform-destructuring": "^7.29.7",
+        "@babel/plugin-transform-dotall-regex": "^7.29.7",
+        "@babel/plugin-transform-duplicate-keys": "^7.29.7",
+        "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-dynamic-import": "^7.29.7",
+        "@babel/plugin-transform-explicit-resource-management": "^7.29.7",
+        "@babel/plugin-transform-exponentiation-operator": "^7.29.7",
+        "@babel/plugin-transform-export-namespace-from": "^7.29.7",
+        "@babel/plugin-transform-for-of": "^7.29.7",
+        "@babel/plugin-transform-function-name": "^7.29.7",
+        "@babel/plugin-transform-json-strings": "^7.29.7",
+        "@babel/plugin-transform-literals": "^7.29.7",
+        "@babel/plugin-transform-logical-assignment-operators": "^7.29.7",
+        "@babel/plugin-transform-member-expression-literals": "^7.29.7",
+        "@babel/plugin-transform-modules-amd": "^7.29.7",
+        "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+        "@babel/plugin-transform-modules-systemjs": "^7.29.7",
+        "@babel/plugin-transform-modules-umd": "^7.29.7",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.7",
+        "@babel/plugin-transform-new-target": "^7.29.7",
+        "@babel/plugin-transform-nullish-coalescing-operator": "^7.29.7",
+        "@babel/plugin-transform-numeric-separator": "^7.29.7",
+        "@babel/plugin-transform-object-rest-spread": "^7.29.7",
+        "@babel/plugin-transform-object-super": "^7.29.7",
+        "@babel/plugin-transform-optional-catch-binding": "^7.29.7",
+        "@babel/plugin-transform-optional-chaining": "^7.29.7",
+        "@babel/plugin-transform-parameters": "^7.29.7",
+        "@babel/plugin-transform-private-methods": "^7.29.7",
+        "@babel/plugin-transform-private-property-in-object": "^7.29.7",
+        "@babel/plugin-transform-property-literals": "^7.29.7",
+        "@babel/plugin-transform-regenerator": "^7.29.7",
+        "@babel/plugin-transform-regexp-modifiers": "^7.29.7",
+        "@babel/plugin-transform-reserved-words": "^7.29.7",
+        "@babel/plugin-transform-shorthand-properties": "^7.29.7",
+        "@babel/plugin-transform-spread": "^7.29.7",
+        "@babel/plugin-transform-sticky-regex": "^7.29.7",
+        "@babel/plugin-transform-template-literals": "^7.29.7",
+        "@babel/plugin-transform-typeof-symbol": "^7.29.7",
+        "@babel/plugin-transform-unicode-escapes": "^7.29.7",
+        "@babel/plugin-transform-unicode-property-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-regex": "^7.29.7",
+        "@babel/plugin-transform-unicode-sets-regex": "^7.29.7",
         "@babel/preset-modules": "0.1.6-no-external-plugins",
         "babel-plugin-polyfill-corejs2": "^0.4.15",
         "babel-plugin-polyfill-corejs3": "^0.14.0",
@@ -1557,16 +1582,16 @@
       }
     },
     "node_modules/@babel/preset-typescript": {
-      "version": "7.28.5",
-      "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.28.5.tgz",
-      "integrity": "sha512-+bQy5WOI2V6LJZpPVxY+yp66XdZ2yifu0Mc1aP5CQKgjn4QM5IN2i5fAZ4xKop47pr8rpVhiAeu+nDQa12C8+g==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.29.7.tgz",
+      "integrity": "sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-plugin-utils": "^7.27.1",
-        "@babel/helper-validator-option": "^7.27.1",
-        "@babel/plugin-syntax-jsx": "^7.27.1",
-        "@babel/plugin-transform-modules-commonjs": "^7.27.1",
-        "@babel/plugin-transform-typescript": "^7.28.5"
+        "@babel/helper-plugin-utils": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "@babel/plugin-syntax-jsx": "^7.29.7",
+        "@babel/plugin-transform-modules-commonjs": "^7.29.7",
+        "@babel/plugin-transform-typescript": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1576,40 +1601,40 @@
       }
     },
     "node_modules/@babel/runtime": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz",
-      "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
       "license": "MIT",
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.28.6",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
-      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.28.6",
-        "@babel/parser": "^7.28.6",
-        "@babel/types": "^7.28.6"
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/traverse": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
-      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz",
+      "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/code-frame": "^7.29.0",
-        "@babel/generator": "^7.29.0",
-        "@babel/helper-globals": "^7.28.0",
-        "@babel/parser": "^7.29.0",
-        "@babel/template": "^7.28.6",
-        "@babel/types": "^7.29.0",
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.8",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.8",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.8",
         "debug": "^4.3.1"
       },
       "engines": {
@@ -1617,13 +1642,13 @@
       }
     },
     "node_modules/@babel/types": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
-      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "version": "7.29.8",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
+      "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-string-parser": "^7.27.1",
-        "@babel/helper-validator-identifier": "^7.28.5"
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -1643,9 +1668,9 @@
       }
     },
     "node_modules/@csstools/color-helpers": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.1.tgz",
-      "integrity": "sha512-NmXRccUJMk2AWA5A7e5a//3bCIMyOu2hAtdRYrhPPHjDxINuCwX1w6rnIZ4xjLcp0ayv6h8Pc3X0eJUGiAAXHQ==",
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.1.0.tgz",
+      "integrity": "sha512-064IFJdjTfUqnjpCVpMOdbr8FLQBhinbZj6yRv2An2E41O/pLEXqfFRWqGq/SxlE5PEUYTlvWsG2r8MswAVvkg==",
       "dev": true,
       "funding": [
         {
@@ -1663,9 +1688,9 @@
       }
     },
     "node_modules/@csstools/css-calc": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.1.1.tgz",
-      "integrity": "sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==",
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.3.0.tgz",
+      "integrity": "sha512-c5ihYsPkdG6JCkU2zTMm4+k6r7RXuGxtWYhu5DHMIiF1FHzrfmHL5so11AoFpUv/tu61xfcmT4AmKoFfMPoqdQ==",
       "dev": true,
       "funding": [
         {
@@ -1687,9 +1712,9 @@
       }
     },
     "node_modules/@csstools/css-color-parser": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.0.1.tgz",
-      "integrity": "sha512-vYwO15eRBEkeF6xjAno/KQ61HacNhfQuuU/eGwH67DplL0zD5ZixUa563phQvUelA07yDczIXdtmYojCphKJcw==",
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.10.tgz",
+      "integrity": "sha512-UZhQLIUyJaaMepqehrCODwCg2KW25vFvLWBmqYFaPclYvvxzj/sG8LBOhBFCp11i9uE7t1EyS+RAoV9tztPFyw==",
       "dev": true,
       "funding": [
         {
@@ -1703,8 +1728,8 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@csstools/color-helpers": "^6.0.1",
-        "@csstools/css-calc": "^3.0.0"
+        "@csstools/color-helpers": "^6.1.0",
+        "@csstools/css-calc": "^3.3.0"
       },
       "engines": {
         "node": ">=20.19.0"
@@ -1730,7 +1755,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=20.19.0"
       },
@@ -1739,9 +1763,9 @@
       }
     },
     "node_modules/@csstools/css-syntax-patches-for-csstree": {
-      "version": "1.0.27",
-      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.0.27.tgz",
-      "integrity": "sha512-sxP33Jwg1bviSUXAV43cVYdmjt2TLnLXNqCWl9xmxHawWVjGz/kEbdkr7F9pxJNBN2Mh+dq0crgItbW6tQvyow==",
+      "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.7.tgz",
+      "integrity": "sha512-fQ+05118eQS1cofO3aJpB5efgpBZMvIzwr/sbC8kDLVA5XLG8q1kJV5yzrUAI1f7lvhPnm8fgIjzFB8/O/5Dig==",
       "dev": true,
       "funding": [
         {
@@ -1753,7 +1777,15 @@
           "url": "https://opencollective.com/csstools"
         }
       ],
-      "license": "MIT-0"
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
     },
     "node_modules/@csstools/css-tokenizer": {
       "version": "4.0.0",
@@ -1771,23 +1803,56 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=20.19.0"
       }
     },
+    "node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+      "integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@es-joy/jsdoccomment": {
-      "version": "0.84.0",
-      "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.84.0.tgz",
-      "integrity": "sha512-0xew1CxOam0gV5OMjh2KjFQZsKL2bByX1+q4j3E73MpYIdyUxcZb/xQct9ccUb+ve5KGUYbCUxyPnYB7RbuP+w==",
+      "version": "0.91.0",
+      "resolved": "https://registry.npmjs.org/@es-joy/jsdoccomment/-/jsdoccomment-0.91.0.tgz",
+      "integrity": "sha512-vgqlMGNNhZxwDYbUNIHj3Hskb4R28iqdXx90ufHyt/NeuTQkeqjTDslAs9I0/GCAfbxP5BpH5WsL1R1fht5Lxg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "^1.0.8",
-        "@typescript-eslint/types": "^8.54.0",
-        "comment-parser": "1.4.5",
+        "@types/estree": "^1.0.9",
+        "@typescript-eslint/types": "^8.65.0",
+        "comment-parser": "1.4.7",
         "esquery": "^1.7.0",
-        "jsdoc-type-pratt-parser": "~7.1.1"
+        "jsdoc-type-pratt-parser": "~8.0.0"
       },
       "engines": {
         "node": "^20.19.0 || ^22.13.0 || >=24"
@@ -1804,9 +1869,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
-      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
       "cpu": [
         "ppc64"
       ],
@@ -1821,9 +1886,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
-      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
       "cpu": [
         "arm"
       ],
@@ -1838,9 +1903,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
-      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
       "cpu": [
         "arm64"
       ],
@@ -1855,9 +1920,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
-      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
       "cpu": [
         "x64"
       ],
@@ -1872,9 +1937,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
-      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
       "cpu": [
         "arm64"
       ],
@@ -1889,9 +1954,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
-      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
       "cpu": [
         "x64"
       ],
@@ -1906,9 +1971,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
       "cpu": [
         "arm64"
       ],
@@ -1923,9 +1988,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
-      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
       "cpu": [
         "x64"
       ],
@@ -1940,9 +2005,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
-      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
       "cpu": [
         "arm"
       ],
@@ -1957,9 +2022,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
-      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
       "cpu": [
         "arm64"
       ],
@@ -1974,9 +2039,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
-      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
       "cpu": [
         "ia32"
       ],
@@ -1991,9 +2056,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
-      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
       "cpu": [
         "loong64"
       ],
@@ -2008,9 +2073,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
-      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
       "cpu": [
         "mips64el"
       ],
@@ -2025,9 +2090,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
-      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
       "cpu": [
         "ppc64"
       ],
@@ -2042,9 +2107,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
-      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
       "cpu": [
         "riscv64"
       ],
@@ -2059,9 +2124,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
-      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
       "cpu": [
         "s390x"
       ],
@@ -2076,9 +2141,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
-      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
       "cpu": [
         "x64"
       ],
@@ -2093,9 +2158,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
       "cpu": [
         "arm64"
       ],
@@ -2110,9 +2175,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
       "cpu": [
         "x64"
       ],
@@ -2127,9 +2192,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
       "cpu": [
         "arm64"
       ],
@@ -2144,9 +2209,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
       "cpu": [
         "x64"
       ],
@@ -2161,9 +2226,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
-      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
       "cpu": [
         "arm64"
       ],
@@ -2178,9 +2243,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
-      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
       "cpu": [
         "x64"
       ],
@@ -2195,9 +2260,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
       "cpu": [
         "arm64"
       ],
@@ -2212,9 +2277,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
       "cpu": [
         "ia32"
       ],
@@ -2229,9 +2294,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
       "cpu": [
         "x64"
       ],
@@ -2246,9 +2311,9 @@
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
-      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.10.1.tgz",
+      "integrity": "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2264,6 +2329,19 @@
         "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
       }
     },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
     "node_modules/@eslint-community/regexpp": {
       "version": "4.12.2",
       "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
@@ -2275,182 +2353,109 @@
       }
     },
     "node_modules/@eslint/config-array": {
-      "version": "0.21.1",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
-      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
+      "version": "0.23.5",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz",
+      "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@eslint/object-schema": "^2.1.7",
+        "@eslint/object-schema": "^3.0.5",
         "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/config-array/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "minimatch": "^10.2.4"
       },
       "engines": {
-        "node": "*"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/config-helpers": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
-      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "version": "0.7.0",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.7.0.tgz",
+      "integrity": "sha512-DObd/KKUsU+FaFv4PLxSRenpXfQWmPXXP3pPZ6/K1PCrMu2vQpMDMuQe/BqYeoLcz8ro0bVDF1RxOJgfVEdhUw==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@eslint/core": "^0.17.0"
+        "@eslint/core": "^1.2.1"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/core": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
-      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz",
+      "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "@types/json-schema": "^7.0.15"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      }
-    },
-    "node_modules/@eslint/eslintrc": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.3.tgz",
-      "integrity": "sha512-Kr+LPIUVKz2qkx1HAMH8q1q6azbqBAsXJUxBl/ODDuVPX45Z9DfwB8tPjTi6nNZ8BuM3nbJxC5zCAg5elnBUTQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ajv": "^6.12.4",
-        "debug": "^4.3.2",
-        "espree": "^10.0.1",
-        "globals": "^14.0.0",
-        "ignore": "^5.2.0",
-        "import-fresh": "^3.2.1",
-        "js-yaml": "^4.1.1",
-        "minimatch": "^3.1.2",
-        "strip-json-comments": "^3.1.1"
-      },
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/globals": {
-      "version": "14.0.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
-      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
-    "node_modules/@eslint/eslintrc/node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+    "node_modules/@eslint/css-tree": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/@eslint/css-tree/-/css-tree-4.0.5.tgz",
+      "integrity": "sha512-iPmijIAq4hlIJB86PYmY/fcZORHtjphSqICDbwuw32A/JmkhZQ/K/6TjHE03zqf3n5yABpVcbRAMG8Mi9ojy8g==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "mdn-data": "2.29.0",
+        "source-map-js": "^1.2.1"
       },
       "engines": {
-        "node": "*"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/js": {
-      "version": "9.39.2",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.2.tgz",
-      "integrity": "sha512-q1mjIoW1VX4IvSocvM/vbTiveKC4k9eLrajNEuSsmjymSDEbpGddtpfOoN7YGAqBK3NG+uqo8ia4PDTt8buCYA==",
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-10.0.1.tgz",
+      "integrity": "sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "eslint": "^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "eslint": {
+          "optional": true
+        }
       }
     },
     "node_modules/@eslint/object-schema": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
-      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz",
+      "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@eslint/plugin-kit": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
-      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.2.tgz",
+      "integrity": "sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@eslint/core": "^0.17.0",
+        "@eslint/core": "^1.2.1",
         "levn": "^0.4.1"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       }
     },
     "node_modules/@exodus/bytes": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.14.1.tgz",
-      "integrity": "sha512-OhkBFWI6GcRMUroChZiopRiSp2iAMvEBK47NhJooDqz1RERO4QuZIZnjP63TXX8GAiLABkYmX+fuQsdJ1dd2QQ==",
+      "version": "1.15.1",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+      "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2466,29 +2471,43 @@
       }
     },
     "node_modules/@humanfs/core": {
-      "version": "0.19.1",
-      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
-      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
+      "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==",
       "dev": true,
       "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/types": "^0.15.0"
+      },
       "engines": {
         "node": ">=18.18.0"
       }
     },
     "node_modules/@humanfs/node": {
-      "version": "0.16.7",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
-      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "version": "0.16.8",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz",
+      "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@humanfs/core": "^0.19.1",
+        "@humanfs/core": "^0.19.2",
+        "@humanfs/types": "^0.15.0",
         "@humanwhocodes/retry": "^0.4.0"
       },
       "engines": {
         "node": ">=18.18.0"
       }
     },
+    "node_modules/@humanfs/types": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz",
+      "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
     "node_modules/@humanwhocodes/module-importer": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
@@ -2562,24 +2581,42 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
-    "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.57.1.tgz",
-      "integrity": "sha512-A6ehUVSiSaaliTxai040ZpZ2zTevHYbvu/lDoeAteHI8QnaosIzm4qwtezfRg1jOYaUmnzLX1AOD6Z+UJjtifg==",
-      "cpu": [
-        "arm"
-      ],
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.2.2.tgz",
+      "integrity": "sha512-JfB4kuJQjaoHuCTseIINHtHWeJnvgEcxjwA5t/Y00ZgaOO1Crz3fjT/p8kT28zA/Caz7oiUMn3d6H2yOVCVwuw==",
       "dev": true,
       "license": "MIT",
       "optional": true,
-      "os": [
-        "android"
-      ]
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.3"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=23.5.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1 || ^2.0.0-alpha.3",
+        "@emnapi/runtime": "^1.7.1 || ^2.0.0-alpha.3"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.143.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.143.0.tgz",
+      "integrity": "sha512-u6JZdLBTLotrNC9Vd6vPssINdzcCzleKAH6EJKImQb7GtYvX5keN2dxkoK44stCc4tffE6QQRtZTXVSzsLUlWA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
     },
-    "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.57.1.tgz",
-      "integrity": "sha512-dQaAddCY9YgkFHZcFNS/606Exo8vcLHwArFZ7vxXq4rigo2bb494/xKMMwRRQW6ug7Js6yXmBZhSBRuBvCCQ3w==",
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.3.tgz",
+      "integrity": "sha512-zrJtHDcaZJ1Fp7xf4hNl+7seH9Cn/N5TwLYkhgXREtBwAd/jaqW3uqeHxpDugJLVICWg4eW44kOQEGJ1r6jCGw==",
       "cpu": [
         "arm64"
       ],
@@ -2588,12 +2625,15 @@
       "optional": true,
       "os": [
         "android"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.57.1.tgz",
-      "integrity": "sha512-crNPrwJOrRxagUYeMn/DZwqN88SDmwaJ8Cvi/TN1HnWBU7GwknckyosC2gd0IqYRsHDEnXf328o9/HC6OkPgOg==",
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.3.tgz",
+      "integrity": "sha512-ieIiibVCp0tX7TLu2cafoNPv8wJyYi01ekXpbf8q2j7F4rGAhhXb/eQh7ge9DRBY78GwmRQtvjZDux7EDbA8kA==",
       "cpu": [
         "arm64"
       ],
@@ -2602,12 +2642,15 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.57.1.tgz",
-      "integrity": "sha512-Ji8g8ChVbKrhFtig5QBV7iMaJrGtpHelkB3lsaKzadFBe58gmjfGXAOfI5FV0lYMH8wiqsxKQ1C9B0YTRXVy4w==",
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.3.tgz",
+      "integrity": "sha512-Zh9tCon19eDXJoihx0rqKhMUlMYqzwj3aPsSuHmI4RWZh62dWUL+DJN4C5YQya5TcQBJU/Fe8+rY0jhXTQITqA==",
       "cpu": [
         "x64"
       ],
@@ -2616,82 +2659,66 @@
       "optional": true,
       "os": [
         "darwin"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.57.1.tgz",
-      "integrity": "sha512-R+/WwhsjmwodAcz65guCGFRkMb4gKWTcIeLy60JJQbXrJ97BOXHxnkPFrP+YwFlaS0m+uWJTstrUA9o+UchFug==",
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.3.tgz",
+      "integrity": "sha512-nGbJWewA1wrXXZiQhjAT5rhibGfns5ZNkDVqxsO6zJ3f3YvpoDNNmGMSbbhLuXKjNScaBJVOAboztAWVespQMg==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "freebsd"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.57.1.tgz",
-      "integrity": "sha512-IEQTCHeiTOnAUC3IDQdzRAGj3jOAYNr9kBguI7MQAAZK3caezRrg0GxAb6Hchg4lxdZEI5Oq3iov/w/hnFWY9Q==",
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.3.tgz",
+      "integrity": "sha512-QNniJr5Kml0kDEB98jiDOJjXNroxIIi0IXIbdYzY26Xt1pVbeP62+KnoIZLwirOymX/0jDk/2gI/bNUv7A7OIw==",
       "cpu": [
-        "x64"
+        "arm"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
-        "freebsd"
-      ]
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.57.1.tgz",
-      "integrity": "sha512-F8sWbhZ7tyuEfsmOxwc2giKDQzN3+kuBLPwwZGyVkLlKGdV1nvnNwYD0fKQ8+XS6hp9nY7B+ZeK01EBUE7aHaw==",
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.3.tgz",
+      "integrity": "sha512-TkqEAcmmvH3I/q4114NB4RVt6241Dao48pF45uLcFGrwAaIn0iITgTAKP/dLjbN0R4buJjGb91+UHSoFmpgIWw==",
       "cpu": [
-        "arm"
+        "arm64"
       ],
       "dev": true,
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.57.1.tgz",
-      "integrity": "sha512-rGfNUfn0GIeXtBP1wL5MnzSj98+PZe/AXaGBCRmT0ts80lU5CATYGxXukeTX39XBKsxzFpEeK+Mrp9faXOlmrw==",
-      "cpu": [
-        "arm"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.57.1.tgz",
-      "integrity": "sha512-MMtej3YHWeg/0klK2Qodf3yrNzz6CGjo2UntLvk2RSPlhzgLvYEB3frRvbEF2wRKh1Z2fDIg9KRPe1fawv7C+g==",
-      "cpu": [
-        "arm64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.57.1.tgz",
-      "integrity": "sha512-1a/qhaaOXhqXGpMFMET9VqwZakkljWHLmZOX48R0I/YLbhdxr1m4gtG1Hq7++VhVUmf+L3sTAf9op4JlhQ5u1Q==",
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.3.tgz",
+      "integrity": "sha512-NHqjnxpsndf4MPymxteFAWHHfkTL8HjWh1KB7z23ofZ6QO2euONuxDXjat69dKZRALnGypg8k8SsK8vZJoXv1Q==",
       "cpu": [
         "arm64"
       ],
@@ -2700,54 +2727,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.57.1.tgz",
-      "integrity": "sha512-QWO6RQTZ/cqYtJMtxhkRkidoNGXc7ERPbZN7dVW5SdURuLeVU7lwKMpo18XdcmpWYd0qsP1bwKPf7DNSUinhvA==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.57.1.tgz",
-      "integrity": "sha512-xpObYIf+8gprgWaPP32xiN5RVTi/s5FCR+XMXSKmhfoJjrpRAjCuuqQXyxUa/eJTdAE6eJ+KDKaoEqjZQxh3Gw==",
-      "cpu": [
-        "loong64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.57.1.tgz",
-      "integrity": "sha512-4BrCgrpZo4hvzMDKRqEaW1zeecScDCR+2nZ86ATLhAoJ5FQ+lbHVD3ttKe74/c7tNT9c6F2viwB3ufwp01Oh2w==",
-      "cpu": [
-        "ppc64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.57.1.tgz",
-      "integrity": "sha512-NOlUuzesGauESAyEYFSe3QTUguL+lvrN1HtwEEsU2rOwdUDeTMJdO5dUYl/2hKf9jWydJrO9OL/XSSf65R5+Xw==",
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.3.tgz",
+      "integrity": "sha512-6tbrbwfz5GB9DQ4Jwo6hy9v+vR31xZlvzZ6n5Xut6Hhx5PvrA9q/HsK8KMaYQp063iqZGXwNvZtYNLD7EM/x0w==",
       "cpu": [
         "ppc64"
       ],
@@ -2756,40 +2744,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.57.1.tgz",
-      "integrity": "sha512-ptA88htVp0AwUUqhVghwDIKlvJMD/fmL/wrQj99PRHFRAG6Z5nbWoWG4o81Nt9FT+IuqUQi+L31ZKAFeJ5Is+A==",
-      "cpu": [
-        "riscv64"
-      ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.57.1.tgz",
-      "integrity": "sha512-S51t7aMMTNdmAMPpBg7OOsTdn4tySRQvklmL3RpDRyknk87+Sp3xaumlatU+ppQ+5raY7sSTcC2beGgvhENfuw==",
-      "cpu": [
-        "riscv64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.57.1.tgz",
-      "integrity": "sha512-Bl00OFnVFkL82FHbEqy3k5CUCKH6OEJL54KCyx2oqsmZnFTR8IoNqBF+mjQVcRCT5sB6yOvK8A37LNm/kPJiZg==",
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.3.tgz",
+      "integrity": "sha512-oyuXxXmoZHjXC917IAPFAAv4wWAa0cM9afk8nx1+9/jNNOX1uPf8yDA6p7G0RypOfw/X0PQt5IfoquY1um+zSg==",
       "cpu": [
         "s390x"
       ],
@@ -2798,12 +2761,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.57.1.tgz",
-      "integrity": "sha512-ABca4ceT4N+Tv/GtotnWAeXZUZuM/9AQyCyKYyKnpk4yoA7QIAuBt6Hkgpw8kActYlew2mvckXkvx0FfoInnLg==",
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.3.tgz",
+      "integrity": "sha512-TytMwF2KVGqP2tgd0I1OY0PAv78dZRAYcF5ssDzjM34SUXCED3uXvSd5+lHoC0bTD6eEdFz7LdQNCO1y0oVk9w==",
       "cpu": [
         "x64"
       ],
@@ -2812,12 +2778,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.57.1.tgz",
-      "integrity": "sha512-HFps0JeGtuOR2convgRRkHCekD7j+gdAuXM+/i6kGzQtFhlCtQkpwtNzkNj6QhCDp7DRJ7+qC/1Vg2jt5iSOFw==",
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.3.tgz",
+      "integrity": "sha512-/E9m3qstrJFVPoULV25mVQblSNExY2+kBsYe4sy0Tn0yOOgJ8wZbZt3KnRbF/XeU2Gl1STKUQnDNTqhIE5MD4A==",
       "cpu": [
         "x64"
       ],
@@ -2826,26 +2795,15 @@
       "optional": true,
       "os": [
         "linux"
-      ]
-    },
-    "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.57.1.tgz",
-      "integrity": "sha512-H+hXEv9gdVQuDTgnqD+SQffoWoc0Of59AStSzTEj/feWTBAnSfSD3+Dql1ZruJQxmykT/JVY0dE8Ka7z0DH1hw==",
-      "cpu": [
-        "x64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "openbsd"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.57.1.tgz",
-      "integrity": "sha512-4wYoDpNg6o/oPximyc/NG+mYUejZrCU2q+2w6YZqrAs2UcNUChIZXjtafAiiZSUc7On8v5NyNj34Kzj/Ltk6dQ==",
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.3.tgz",
+      "integrity": "sha512-Kr0OcsoQI816i6HOl3vFHpd1K0eZyh76zgfj4c1nTyaTsd5r2Mj1lwM4R90y/qaCfmTn9eHy0SKwi98eitRxug==",
       "cpu": [
         "arm64"
       ],
@@ -2854,12 +2812,15 @@
       "optional": true,
       "os": [
         "openharmony"
-      ]
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.57.1.tgz",
-      "integrity": "sha512-O54mtsV/6LW3P8qdTcamQmuC990HDfR71lo44oZMZlXU4tzLrbvTii87Ni9opq60ds0YzuAlEr/GNwuNluZyMQ==",
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.3.tgz",
+      "integrity": "sha512-hOtMwTqnME+/gJcH/PCZ0wn0zPUjiWOgkHpxbSJpfGKMezHltx1S7/k1SitzVa7Ww2cqrDDaFbZEhcJZO8o+Jw==",
       "cpu": [
         "arm64"
       ],
@@ -2868,26 +2829,15 @@
       "optional": true,
       "os": [
         "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.57.1.tgz",
-      "integrity": "sha512-P3dLS+IerxCT/7D2q2FYcRdWRl22dNbrbBEtxdWhXrfIMPP9lQhb5h4Du04mdl5Woq05jVCDPCMF7Ub0NAjIew==",
-      "cpu": [
-        "ia32"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.57.1.tgz",
-      "integrity": "sha512-VMBH2eOOaKGtIJYleXsi2B8CPVADrh+TyNxJ4mWPnKfLB/DBUmzW+5m1xUrcwWoMfSLagIRpjUFeW5CO5hyciQ==",
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.3.tgz",
+      "integrity": "sha512-ekcqMMkI2PlhYnfzQnB/cEdYUVVJViWvoUyLrbzgDoi3Snfc1mVBwdnc306ufA5ejy8JSPjT2RlW1nQSjW7efg==",
       "cpu": [
         "x64"
       ],
@@ -2896,26 +2846,15 @@
       "optional": true,
       "os": [
         "win32"
-      ]
-    },
-    "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.57.1.tgz",
-      "integrity": "sha512-mxRFDdHIWRxg3UfIIAwCm6NzvxG0jDX/wBN6KsQFTvKFqqg9vTrWUE68qEjHt19A5wwx5X5aUi2zuZT7YR0jrA==",
-      "cpu": [
-        "x64"
       ],
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
     },
-    "node_modules/@rtsao/scc": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz",
-      "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==",
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
       "dev": true,
       "license": "MIT"
     },
@@ -2939,6 +2878,17 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.3",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
+      "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
     "node_modules/@types/chai": {
       "version": "5.2.3",
       "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
@@ -2957,23 +2907,31 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/esrecurse": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz",
+      "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
-      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/jsdom": {
-      "version": "27.0.0",
-      "resolved": "https://registry.npmjs.org/@types/jsdom/-/jsdom-27.0.0.tgz",
-      "integrity": "sha512-NZyFl/PViwKzdEkQg96gtnB8wm+1ljhdDay9ahn4hgb+SfVtPCbm3TlmDUFXTA+MGN3CijicnMhG18SI5H3rFw==",
+      "version": "28.0.3",
+      "resolved": "https://registry.npmjs.org/@types/jsdom/-/jsdom-28.0.3.tgz",
+      "integrity": "sha512-/HQ2uFoetFTXuye8vzIcHw2z6Fwi7Hi/qcgC+RoS9NCyewiqxhVGqlG+ViGB6lkax481R6dmhf1I7lIGlzJStQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@types/node": "*",
         "@types/tough-cookie": "*",
-        "parse5": "^7.0.0"
+        "parse5": "^8.0.0",
+        "undici-types": "^7.21.0"
       }
     },
     "node_modules/@types/json-schema": {
@@ -2982,23 +2940,23 @@
       "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
       "license": "MIT"
     },
-    "node_modules/@types/json5": {
-      "version": "0.0.29",
-      "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz",
-      "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@types/node": {
-      "version": "24.10.13",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.13.tgz",
-      "integrity": "sha512-oH72nZRfDv9lADUBSo104Aq7gPHpQZc4BTx38r9xf9pg5LfP6EzSyH2n7qFmmxRQXh7YlUXODcYsg6PuTDSxGg==",
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.3.tgz",
+      "integrity": "sha512-Dh8vAsV36ig5wa9OX4pXvMc9D3Veibfw2wix0CUwYODLD8nkj9UsLjASr49nPg+2eKzxhBV+v7L8pXvT4e639Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~7.16.0"
+        "undici-types": "~7.18.0"
       }
     },
+    "node_modules/@types/node/node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/tough-cookie": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/@types/tough-cookie/-/tough-cookie-4.0.5.tgz",
@@ -3007,20 +2965,20 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.56.1.tgz",
-      "integrity": "sha512-Jz9ZztpB37dNC+HU2HI28Bs9QXpzCz+y/twHOwhyrIRdbuVDxSytJNDl6z/aAKlaRIwC7y8wJdkBv7FxYGgi0A==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.67.0.tgz",
+      "integrity": "sha512-Un7Heoyj65NREbKAyIrFxeM143NZpExWmy1Nep4DLeQOeLlTeumPjoNKnBrU5D5moWXbPJgRa5Uwcdu0faVNGQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.56.1",
-        "@typescript-eslint/type-utils": "8.56.1",
-        "@typescript-eslint/utils": "8.56.1",
-        "@typescript-eslint/visitor-keys": "8.56.1",
+        "@typescript-eslint/scope-manager": "8.67.0",
+        "@typescript-eslint/type-utils": "8.67.0",
+        "@typescript-eslint/utils": "8.67.0",
+        "@typescript-eslint/visitor-keys": "8.67.0",
         "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
-        "ts-api-utils": "^2.4.0"
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3030,23 +2988,32 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.56.1",
+        "@typescript-eslint/parser": "^8.67.0",
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.6.tgz",
+      "integrity": "sha512-BAg6QkE8W+TuQLrrw0Ugr7HegXduRuuj8/ti2kSOc+jz1dmx8/WNcjr6XGnq5YpDWxFwwaavqD0+jIUOKelTsw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.56.1.tgz",
-      "integrity": "sha512-klQbnPAAiGYFyI02+znpBRLyjL4/BrBd0nyWkdC0s/6xFLkXYQ8OoRrSkqacS1ddVxf/LDyODIKbQ5TgKAf/Fg==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.67.0.tgz",
+      "integrity": "sha512-fUBfTuuEulWqX6V8+O3PtScV01tzYYRUDTAirHFKoRAt7nOzoGiPt0M/bB47wWNy0coOOcgEwAMUtBpykMxl6w==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.56.1",
-        "@typescript-eslint/types": "8.56.1",
-        "@typescript-eslint/typescript-estree": "8.56.1",
-        "@typescript-eslint/visitor-keys": "8.56.1",
+        "@typescript-eslint/scope-manager": "8.67.0",
+        "@typescript-eslint/types": "8.67.0",
+        "@typescript-eslint/typescript-estree": "8.67.0",
+        "@typescript-eslint/visitor-keys": "8.67.0",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -3058,18 +3025,18 @@
       },
       "peerDependencies": {
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.56.1.tgz",
-      "integrity": "sha512-TAdqQTzHNNvlVFfR+hu2PDJrURiwKsUvxFn1M0h95BB8ah5jejas08jUWG4dBA68jDMI988IvtfdAI53JzEHOQ==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.67.0.tgz",
+      "integrity": "sha512-cvE8c7ulYeXN9fYuszhCeCsbzyVEXuhrRCybnBre7TUmqb5nRmBfQAwCj0O3WJFDeyAZt4VYv51vMCC9LHSdYw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.56.1",
-        "@typescript-eslint/types": "^8.56.1",
+        "@typescript-eslint/tsconfig-utils": "^8.67.0",
+        "@typescript-eslint/types": "^8.67.0",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -3080,18 +3047,18 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.56.1.tgz",
-      "integrity": "sha512-YAi4VDKcIZp0O4tz/haYKhmIDZFEUPOreKbfdAN3SzUDMcPhJ8QI99xQXqX+HoUVq8cs85eRKnD+rne2UAnj2w==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.67.0.tgz",
+      "integrity": "sha512-EgvsleTwS4E+WzzSvem8fAUubLwatMNF1B5hHSLQxcvs7q2dtRhGyujHwLJSYlG41niJ7GP24Aha2+0mb1b2kg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.56.1",
-        "@typescript-eslint/visitor-keys": "8.56.1"
+        "@typescript-eslint/types": "8.67.0",
+        "@typescript-eslint/visitor-keys": "8.67.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3102,9 +3069,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.56.1.tgz",
-      "integrity": "sha512-qOtCYzKEeyr3aR9f28mPJqBty7+DBqsdd63eO0yyDwc6vgThj2UjWfJIcsFeSucYydqcuudMOprZ+x1SpF3ZuQ==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.67.0.tgz",
+      "integrity": "sha512-vV+LUSv5njUWsknE71fqKTlXUva+R76SaeORd6Zojcunk/6DvKFXONU3BrAs2H49mbygUXt6gbYunzwqNwlhdg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3115,21 +3082,21 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.56.1.tgz",
-      "integrity": "sha512-yB/7dxi7MgTtGhZdaHCemf7PuwrHMenHjmzgUW1aJpO+bBU43OycnM3Wn+DdvDO/8zzA9HlhaJ0AUGuvri4oGg==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.67.0.tgz",
+      "integrity": "sha512-aVWDXbRmdXO9siTfX4ditQI1T9+zVcNazT48EJCD0v40/9RIFoUgZ05CmGEq9H2gixRpjUn/iplwvlcvutJW/Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.56.1",
-        "@typescript-eslint/typescript-estree": "8.56.1",
-        "@typescript-eslint/utils": "8.56.1",
+        "@typescript-eslint/types": "8.67.0",
+        "@typescript-eslint/typescript-estree": "8.67.0",
+        "@typescript-eslint/utils": "8.67.0",
         "debug": "^4.4.3",
-        "ts-api-utils": "^2.4.0"
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3140,13 +3107,13 @@
       },
       "peerDependencies": {
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.56.1.tgz",
-      "integrity": "sha512-dbMkdIUkIkchgGDIv7KLUpa0Mda4IYjo4IAMJUZ+3xNoUXxMsk9YtKpTHSChRS85o+H9ftm51gsK1dZReY9CVw==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.67.0.tgz",
+      "integrity": "sha512-sBtgslww8nsMYUjhdPBiSyUqSzT8uR6g93A2QXnQC8+cGdjz0CyaOdqHDRJb1AtORbZCNUJBBeFA/tNR2uQmww==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3158,21 +3125,21 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.56.1.tgz",
-      "integrity": "sha512-qzUL1qgalIvKWAf9C1HpvBjif+Vm6rcT5wZd4VoMb9+Km3iS3Cv9DY6dMRMDtPnwRAFyAi7YXJpTIEXLvdfPxg==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.67.0.tgz",
+      "integrity": "sha512-EKQBCE9yNlRJYm7jdTW5AhDacDUmSwQb0FAJAmK2EKYrNXIsa2vxcSZx6PvJ/dEdI6lS+Y9W+EXckLj0iPFGcw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.56.1",
-        "@typescript-eslint/tsconfig-utils": "8.56.1",
-        "@typescript-eslint/types": "8.56.1",
-        "@typescript-eslint/visitor-keys": "8.56.1",
+        "@typescript-eslint/project-service": "8.67.0",
+        "@typescript-eslint/tsconfig-utils": "8.67.0",
+        "@typescript-eslint/types": "8.67.0",
+        "@typescript-eslint/visitor-keys": "8.67.0",
         "debug": "^4.4.3",
         "minimatch": "^10.2.2",
         "semver": "^7.7.3",
         "tinyglobby": "^0.2.15",
-        "ts-api-utils": "^2.4.0"
+        "ts-api-utils": "^2.5.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3182,20 +3149,20 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.56.1.tgz",
-      "integrity": "sha512-HPAVNIME3tABJ61siYlHzSWCGtOoeP2RTIaHXFMPqjrQKCGB9OgUVdiNgH7TJS2JNIQ5qQ4RsAUDuGaGme/KOA==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.67.0.tgz",
+      "integrity": "sha512-U9D1FdwEWBwok3hxxSdhclMb0twvt9QnjIQ0VfQ1AiX2epnpSgv2ubVDsayOFyY8K6FX+AQ7E0FKWVG3iKsj1A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.56.1",
-        "@typescript-eslint/types": "8.56.1",
-        "@typescript-eslint/typescript-estree": "8.56.1"
+        "@typescript-eslint/scope-manager": "8.67.0",
+        "@typescript-eslint/types": "8.67.0",
+        "@typescript-eslint/typescript-estree": "8.67.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -3206,17 +3173,17 @@
       },
       "peerDependencies": {
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.56.1.tgz",
-      "integrity": "sha512-KiROIzYdEV85YygXw6BI/Dx4fnBlFQu6Mq4QE4MOH9fFnhohw6wX/OAvDY2/C+ut0I3RSPKenvZJIVYqJNkhEw==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.67.0.tgz",
+      "integrity": "sha512-fkv8dHRDqfGtTHuJeebdrQ7cX6Ad4WAS00rgHh9UGvMycF1mjBfsxry1XsLIFhWZ6Judlh6UdzK+TYlbpCXgnA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.56.1",
+        "@typescript-eslint/types": "8.67.0",
         "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
@@ -3227,99 +3194,400 @@
         "url": "https://opencollective.com/typescript-eslint"
       }
     },
-    "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
-      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+    "node_modules/@unrs/resolver-binding-android-arm-eabi": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.12.2.tgz",
+      "integrity": "sha512-g5T90pqg1bo/7mytQx6F4iBNC0Wsh9cu+z9veDbFjc7HjpesJFWD7QMS0NGStXM075+7dJPPVvBbpZlnrdpi/w==",
+      "cpu": [
+        "arm"
+      ],
       "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^20.19.0 || ^22.13.0 || >=24"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/@vitest/expect": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz",
-      "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==",
+    "node_modules/@unrs/resolver-binding-android-arm64": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm64/-/resolver-binding-android-arm64-1.12.2.tgz",
+      "integrity": "sha512-YGCRZv/9GLhwmz6mYDeTsm/92BAyR28l6c2ReweVW5pWgfsitWLY8upvfRlGdoyD8HjeTHSYJWyZGD4KJA/nFQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
-        "@types/chai": "^5.2.2",
-        "@vitest/spy": "4.0.18",
-        "@vitest/utils": "4.0.18",
-        "chai": "^6.2.1",
-        "tinyrainbow": "^3.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/@vitest/mocker": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz",
-      "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==",
+    "node_modules/@unrs/resolver-binding-darwin-arm64": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-arm64/-/resolver-binding-darwin-arm64-1.12.2.tgz",
+      "integrity": "sha512-u9DiNT1auQMO20A9SyTuG3wUgQWB9Z7KjAg0uFuCDR1FsAY8A0CG2S6JpHS1xwm/w1G08bjXZDcyOCjv1WAm2w==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@vitest/spy": "4.0.18",
-        "estree-walker": "^3.0.3",
-        "magic-string": "^0.30.21"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      },
-      "peerDependencies": {
-        "msw": "^2.4.9",
-        "vite": "^6.0.0 || ^7.0.0-0"
-      },
-      "peerDependenciesMeta": {
-        "msw": {
-          "optional": true
-        },
-        "vite": {
-          "optional": true
-        }
-      }
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
     },
-    "node_modules/@vitest/pretty-format": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz",
-      "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==",
+    "node_modules/@unrs/resolver-binding-darwin-x64": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-darwin-x64/-/resolver-binding-darwin-x64-1.12.2.tgz",
+      "integrity": "sha512-f7rPLi/T1HVKZu/u6t87lroib16n8vrSzcyxI7lg4BGO9UF26KhQL44sd9eOUgrTYhvRXtWOIZT5PejdPyJfUA==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "tinyrainbow": "^3.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
     },
-    "node_modules/@vitest/runner": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz",
-      "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==",
+    "node_modules/@unrs/resolver-binding-freebsd-x64": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-freebsd-x64/-/resolver-binding-freebsd-x64-1.12.2.tgz",
+      "integrity": "sha512-BpcOjWCJub6nRZUS2zA20pmLvjtqAtGejETaIyRLiZiQf++cbrjltLA5NN/xaXfqeOBOSlMFbemIl5/S5tljmg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@vitest/utils": "4.0.18",
-        "pathe": "^2.0.3"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
     },
-    "node_modules/@vitest/snapshot": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz",
-      "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==",
+    "node_modules/@unrs/resolver-binding-linux-arm-gnueabihf": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-gnueabihf/-/resolver-binding-linux-arm-gnueabihf-1.12.2.tgz",
+      "integrity": "sha512-vZTDvdSISZjJx66OzJqtsOhzifbqRjbmI1Mnu49fQDwog5GtDI4QidRiEAYbZCRj9C8YZEW+3ZjqsyS9GR4k2A==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm-musleabihf": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm-musleabihf/-/resolver-binding-linux-arm-musleabihf-1.12.2.tgz",
+      "integrity": "sha512-BiPI+IrIlwcW4nLLMM21+B1dFPzd55yAVgVGrdgDjNef+ch03GdxrcyaIz8X9SsQirh/kCQ7mviyWlMxdh2D7g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-gnu/-/resolver-binding-linux-arm64-gnu-1.12.2.tgz",
+      "integrity": "sha512-zJc0H99FEPoFfSrNpa91HYfxzfAJCr502oxNK1cfdC9hlaFI43RT+JFCann9JUgZmLzzntChHyn13Sgn9ljHNg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-arm64-musl": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-arm64-musl/-/resolver-binding-linux-arm64-musl-1.12.2.tgz",
+      "integrity": "sha512-KQ3Lki6l+Pz1k/eBipN41ES+YUK30beLGb9YqcB1O542cyLCNE6GaxrfcY3T6EezmGGk84wb5XyO9loTM9tkcA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-loong64-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-loong64-gnu/-/resolver-binding-linux-loong64-gnu-1.12.2.tgz",
+      "integrity": "sha512-3SJGEh1DborhG6pyxvhPzCT4bbSIVihsvgJc13P1bHG7KLdNDaF9T3gsTwFc7Jw/5Y5/iWOjkEx7Zy0NvCGX3Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-loong64-musl": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-loong64-musl/-/resolver-binding-linux-loong64-musl-1.12.2.tgz",
+      "integrity": "sha512-jiuG/Obbel7uw1PwHNFfrkiKhLAF6mnyZ6aWlOAVN9WqKm8v0OFGnciJIHu8+CMvXLQ8AD51LPzAoUfT21D5Ew==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-ppc64-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-ppc64-gnu/-/resolver-binding-linux-ppc64-gnu-1.12.2.tgz",
+      "integrity": "sha512-q7xRvVpmcfeL+LlZg8Pbbo6QaTZwDU5BaGZbwfhkEsXJn3Was8xYfE0RBH266xZt0rM6B7i8xAYIvjthuUIWHg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-gnu/-/resolver-binding-linux-riscv64-gnu-1.12.2.tgz",
+      "integrity": "sha512-0CVdx6lcnT3Q9inOH8tsMIOJ6ImndllMjqJHg8RLVdB7Vq4SfkEXl9mCSsVNuNA4MCYycRicCUxPCabVHJRr6A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-riscv64-musl": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-riscv64-musl/-/resolver-binding-linux-riscv64-musl-1.12.2.tgz",
+      "integrity": "sha512-iOwlRo9vnp6R6ohHQS11n0NnfdXx/omhkocmIfaPRpQhKZ+3BDMkkdRVh53qjkFkpPddf+FETA28NwGN7l5l+w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-s390x-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-s390x-gnu/-/resolver-binding-linux-s390x-gnu-1.12.2.tgz",
+      "integrity": "sha512-HYJtLfXq94q8iZNFT1lknx258wlkkWhZeUXJRqzKBBUJ00CvZ+N33zgbCqimLjsyw5Va6uUxhVa12mI+kaveEw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-gnu": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-gnu/-/resolver-binding-linux-x64-gnu-1.12.2.tgz",
+      "integrity": "sha512-mPsUhunKKDih5O96Y6enDQyHc1SqBPlY1E/SfMWDM3EdJ95Z9CArPeCVwCCqbP45ljvivdEk8Fxn+SIb1rDAJQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-linux-x64-musl": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-linux-x64-musl/-/resolver-binding-linux-x64-musl-1.12.2.tgz",
+      "integrity": "sha512-azrt6+5ydLd8Vt210AAFis/lZevSfPw93EJRIJG+xPu4WCJ8K0kppCTpMyLPcKT7H15M4Jnt2tMp5bOvCkRC6A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-openharmony-arm64": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-openharmony-arm64/-/resolver-binding-openharmony-arm64-1.12.2.tgz",
+      "integrity": "sha512-YZ9hP4O0X9PQb8eO980qmLNGH4zT3I9+SZTdt0Pr0YyuGQhYKoOZkV02VzrzyOZJ5xIJ3UFIenKkUkGg8GjgWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-wasm32-wasi": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-wasm32-wasi/-/resolver-binding-wasm32-wasi-1.12.2.tgz",
+      "integrity": "sha512-tYFDIkMxSflfEc/h92ZWNsZlHSwgimbNHSO3PL2JWQHfCuC2q316jMyYU9TIWZsFK2bQwyK5VAdYgn8ygPj69A==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.10.0",
+        "@emnapi/runtime": "1.10.0",
+        "@napi-rs/wasm-runtime": "^1.1.4"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@unrs/resolver-binding-win32-arm64-msvc": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-arm64-msvc/-/resolver-binding-win32-arm64-msvc-1.12.2.tgz",
+      "integrity": "sha512-qzNyg3xL0VPQmCaUh+N5jSitce6k+uCBfMDesWRnlULOZaqUkaJ0ybdT+UqlAWJoQjuqfIU/0Ptx9bteN4D82g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-ia32-msvc": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-ia32-msvc/-/resolver-binding-win32-ia32-msvc-1.12.2.tgz",
+      "integrity": "sha512-WD9sY00OfpHVGfsnHZoA8jVT+esS/Bg8z8jzxp5BnDCjjwsuKsPQrzswwpFy4J1AUJbXPRfkpcX0mXrzeXW79g==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@unrs/resolver-binding-win32-x64-msvc": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-win32-x64-msvc/-/resolver-binding-win32-x64-msvc-1.12.2.tgz",
+      "integrity": "sha512-nAB74NfSNKknqQ1RrYj6uz8FcXEomu/MATJZxh/x+BArzN2U3JbOYC0APYzUIGhVY3m5hRxA8VPNdPBoG8txlA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",
+      "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+      "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.10",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
+      "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",
+      "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.10",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",
+      "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "4.0.18",
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/utils": "4.1.10",
         "magic-string": "^0.30.21",
         "pathe": "^2.0.3"
       },
@@ -3328,9 +3596,9 @@
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz",
-      "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==",
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",
+      "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==",
       "dev": true,
       "license": "MIT",
       "funding": {
@@ -3338,14 +3606,15 @@
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz",
-      "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==",
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
+      "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/pretty-format": "4.0.18",
-        "tinyrainbow": "^3.0.3"
+        "@vitest/pretty-format": "4.1.10",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -3365,12 +3634,11 @@
       }
     },
     "node_modules/acorn": {
-      "version": "8.16.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
-      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "version": "8.18.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.18.0.tgz",
+      "integrity": "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -3388,20 +3656,10 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
-    "node_modules/agent-base": {
-      "version": "7.1.4",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
-      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
     "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "6.15.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -3420,6 +3678,7 @@
       "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
       "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "ajv": "^8.0.0"
       },
@@ -3433,10 +3692,11 @@
       }
     },
     "node_modules/ajv-formats/node_modules/ajv": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
-      "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3",
         "fast-uri": "^3.0.1",
@@ -3452,7 +3712,8 @@
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
       "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/ansi-colors": {
       "version": "1.1.0",
@@ -3466,22 +3727,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
     "node_modules/ansi-wrap": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/ansi-wrap/-/ansi-wrap-0.1.0.tgz",
@@ -3502,11 +3747,13 @@
       }
     },
     "node_modules/argparse": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
-      "dev": true,
-      "license": "Python-2.0"
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "license": "MIT",
+      "dependencies": {
+        "sprintf-js": "~1.0.2"
+      }
     },
     "node_modules/arr-diff": {
       "version": "4.0.0",
@@ -3526,134 +3773,12 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/array-buffer-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
-      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "is-array-buffer": "^3.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/array-flatten": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
       "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
       "license": "MIT"
     },
-    "node_modules/array-includes": {
-      "version": "3.1.9",
-      "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz",
-      "integrity": "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.24.0",
-        "es-object-atoms": "^1.1.1",
-        "get-intrinsic": "^1.3.0",
-        "is-string": "^1.1.1",
-        "math-intrinsics": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.findlastindex": {
-      "version": "1.2.6",
-      "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz",
-      "integrity": "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.9",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "es-shim-unscopables": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.flat": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz",
-      "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-shim-unscopables": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/array.prototype.flatmap": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz",
-      "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-shim-unscopables": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/arraybuffer.prototype.slice": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz",
-      "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.1",
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "is-array-buffer": "^3.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/assertion-error": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -3673,40 +3798,14 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/async-function": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",
-      "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/babel-plugin-polyfill-corejs2": {
-      "version": "0.4.15",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.15.tgz",
-      "integrity": "sha512-hR3GwrRwHUfYwGfrisXPIDP3JcYfBrW7wKE7+Au6wDYl7fm/ka1NEII6kORzxNU556JjfidZeBsO10kYvtV1aw==",
+      "version": "0.4.17",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.17.tgz",
+      "integrity": "sha512-aTyf30K/rqAsNwN76zYrdtx8obu0E4KoUME29B1xj+B3WxgvWkp943vYQ+z8Mv3lw9xHXMHpvSPOBxzAkIa94w==",
       "license": "MIT",
       "dependencies": {
         "@babel/compat-data": "^7.28.6",
-        "@babel/helper-define-polyfill-provider": "^0.6.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
         "semver": "^6.3.1"
       },
       "peerDependencies": {
@@ -3723,12 +3822,12 @@
       }
     },
     "node_modules/babel-plugin-polyfill-corejs3": {
-      "version": "0.14.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.0.tgz",
-      "integrity": "sha512-AvDcMxJ34W4Wgy4KBIIePQTAOP1Ie2WFwkQp3dB7FQ/f0lI5+nM96zUnYEOE1P9sEg0es5VCP0HxiWu5fUHZAQ==",
+      "version": "0.14.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.2.tgz",
+      "integrity": "sha512-coWpDLJ410R781Npmn/SIBZEsAetR4xVi0SxLMXPaMO4lSf1MwnkGYMtkFxew0Dn8B3/CpbpYxN0JCgg8mn67g==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-define-polyfill-provider": "^0.6.6",
+        "@babel/helper-define-polyfill-provider": "^0.6.8",
         "core-js-compat": "^3.48.0"
       },
       "peerDependencies": {
@@ -3736,28 +3835,31 @@
       }
     },
     "node_modules/babel-plugin-polyfill-regenerator": {
-      "version": "0.6.6",
-      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.6.tgz",
-      "integrity": "sha512-hYm+XLYRMvupxiQzrvXUj7YyvFFVfv5gI0R71AJzudg1g2AI2vyCPPIFEBjk162/wFzti3inBHo7isWFuEVS/A==",
+      "version": "0.6.8",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.8.tgz",
+      "integrity": "sha512-M762rNHfSF1EV3SLtnCJXFoQbbIIz0OyRwnCmV0KPC7qosSfCO0QLTSuJX3ayAebubhE6oYBAYPrBA5ljowaZg==",
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-define-polyfill-provider": "^0.6.6"
+        "@babel/helper-define-polyfill-provider": "^0.6.8"
       },
       "peerDependencies": {
         "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
       }
     },
     "node_modules/balanced-match": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
       "dev": true,
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.10.0",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz",
-      "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==",
+      "version": "2.11.12",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.12.tgz",
+      "integrity": "sha512-r7WnVImvVCeFpf2DOXfy41aPWzeNg3H/A2X4dKmy1QL0MSyyk/e7z8ihJ3N6Nn2PsdhkVlqnEfnUE4a05P2aTA==",
       "license": "Apache-2.0",
       "bin": {
         "baseline-browser-mapping": "dist/cli.cjs"
@@ -3783,9 +3885,9 @@
       "license": "MIT"
     },
     "node_modules/body-parser": {
-      "version": "1.20.4",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz",
-      "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==",
+      "version": "1.20.6",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.6.tgz",
+      "integrity": "sha512-p5tAzS57i5MV9fZFDj9LeIiTZEufbSe2eDozP+ElheSUq1m74CRq1jI4mYNDdVs9vQztXFLuk/Gd6BWTdwRJ5g==",
       "license": "MIT",
       "dependencies": {
         "bytes": "~3.1.2",
@@ -3796,7 +3898,7 @@
         "http-errors": "~2.0.1",
         "iconv-lite": "~0.4.24",
         "on-finished": "~2.4.1",
-        "qs": "~6.14.0",
+        "qs": "~6.15.1",
         "raw-body": "~2.5.3",
         "type-is": "~1.6.18",
         "unpipe": "~1.0.0"
@@ -3822,32 +3924,22 @@
       "license": "MIT"
     },
     "node_modules/brace-expansion": {
-      "version": "5.0.3",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.3.tgz",
-      "integrity": "sha512-fy6KJm2RawA5RcHkLa1z/ScpBeA762UF9KmZQxwIbDtRJrgLzM10depAiEQ+CXYcoiqW1/m96OAAoke2nE9EeA==",
+      "version": "5.0.9",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
+      "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
       },
       "engines": {
-        "node": "18 || 20 || >=22"
-      }
-    },
-    "node_modules/brace-expansion/node_modules/balanced-match": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
-      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "18 || 20 || >=22"
+        "node": "20 || >=22"
       }
     },
     "node_modules/browserslist": {
-      "version": "4.28.1",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
-      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "version": "4.28.7",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.7.tgz",
+      "integrity": "sha512-JxV13hNrFxqjOc8alRbq9dK1MM79NEXYpma2B2J4wAtpWS5zIEIKqWPGCl7N4o7Uc7B7itylh7SuDujATRyyTw==",
       "funding": [
         {
           "type": "opencollective",
@@ -3863,13 +3955,12 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "baseline-browser-mapping": "^2.9.0",
-        "caniuse-lite": "^1.0.30001759",
-        "electron-to-chromium": "^1.5.263",
-        "node-releases": "^2.0.27",
-        "update-browserslist-db": "^1.2.0"
+        "baseline-browser-mapping": "^2.10.44",
+        "caniuse-lite": "^1.0.30001806",
+        "electron-to-chromium": "^1.5.393",
+        "node-releases": "^2.0.51",
+        "update-browserslist-db": "^1.2.3"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -3889,12 +3980,6 @@
         "node": ">= 0.10.0"
       }
     },
-    "node_modules/bufferstreams/node_modules/isarray": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
-      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==",
-      "license": "MIT"
-    },
     "node_modules/bufferstreams/node_modules/readable-stream": {
       "version": "1.1.14",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
@@ -3914,9 +3999,9 @@
       "license": "MIT"
     },
     "node_modules/builtin-modules": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-5.0.0.tgz",
-      "integrity": "sha512-bkXY9WsVpY7CvMhKSR6pZilZu9Ln5WDrKVBUXf2S443etkmEO4V58heTecXcUIsNsi4Rx8JUO4NfX1IcQl4deg==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-5.3.0.tgz",
+      "integrity": "sha512-hMQUl2bUFG339QygPM97E+mc8OY1IAchORZxm4a/frcYwKzozMzRVDBwHW0NjOqGElLm2O37AVQE8ikxlZHrMQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -3935,25 +4020,6 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -3983,20 +4049,10 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/callsites": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
-      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001770",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001770.tgz",
-      "integrity": "sha512-x/2CLQ1jHENRbHg5PSId2sXq1CIO1CISvwWAj027ltMVG2UNgW+w9oH2+HzgEIRFembL8bUlXtfbBHR1fCg2xw==",
+      "version": "1.0.30001807",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001807.tgz",
+      "integrity": "sha512-daRXJ9EB/rdRgu7kV+TTl1YUKtlsMWblPl2sLnpg9DZae16QCegol6A1SmCE31Lm9mXC1sRWGt/krouH+/dl7Q==",
       "funding": [
         {
           "type": "opencollective",
@@ -4023,23 +4079,6 @@
         "node": ">=18"
       }
     },
-    "node_modules/chalk": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.1.0",
-        "supports-color": "^7.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/chalk?sponsor=1"
-      }
-    },
     "node_modules/change-case": {
       "version": "5.4.4",
       "resolved": "https://registry.npmjs.org/change-case/-/change-case-5.4.4.tgz",
@@ -4063,66 +4102,16 @@
         "node": ">=8"
       }
     },
-    "node_modules/clean-regexp": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/clean-regexp/-/clean-regexp-1.0.0.tgz",
-      "integrity": "sha512-GfisEZEJvzKrmGWkvfhgzcz/BllN1USeqD2V6tg14OAOgaCD2Z/PUEuxnAZ/nPvmaHRG7a8y77p1T/IRQ4D1Hw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "escape-string-regexp": "^1.0.5"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/clean-regexp/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/comment-parser": {
-      "version": "1.4.5",
-      "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.5.tgz",
-      "integrity": "sha512-aRDkn3uyIlCFfk5NUA+VdwMmMsh8JGhc4hapfV4yxymHGQ3BVskMQfoXGpCo5IoBuQ9tS5iiVKhCpTcB4pW4qw==",
+      "version": "1.4.7",
+      "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.7.tgz",
+      "integrity": "sha512-0h+uSNtQGW3D98eQt3jJ8L06Fves8hncB4V/PKdw/Qb8Hnk19VaKuTr55UNRYiSoVa7WwrFls+rh3ux9agmkeQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">= 12.0.0"
       }
     },
-    "node_modules/concat-map": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/consolidate": {
       "version": "0.15.1",
       "resolved": "https://registry.npmjs.org/consolidate/-/consolidate-0.15.1.tgz",
@@ -4157,6 +4146,19 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/convert-hrtime": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/convert-hrtime/-/convert-hrtime-5.0.0.tgz",
+      "integrity": "sha512-lOETlkIeYSJWcbbcvjRKGxVMXJR+8+OQb/mTPbA4ObPMytYIsUbuOE0Jzy60hjARYszq1id0j8KgVhC+WGZVTg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/convert-source-map": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
@@ -4179,23 +4181,29 @@
       "license": "MIT"
     },
     "node_modules/core-js": {
-      "version": "3.48.0",
-      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.48.0.tgz",
-      "integrity": "sha512-zpEHTy1fjTMZCKLHUZoVeylt9XrzaIN2rbPXEt0k+q7JE5CkCZdo6bNq55bn24a69CH7ErAVLKijxJja4fw+UQ==",
+      "version": "3.50.0",
+      "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.50.0.tgz",
+      "integrity": "sha512-BRWgOLKkFeCgRudR6zrs8p9XJZcE14grzKMMssoYrk6krtuEZ7MTKPIY5RzOnqsEKIR9kst7wNzphttraT+Yqw==",
       "hasInstallScript": true,
       "license": "MIT",
+      "engines": {
+        "node": "*"
+      },
       "funding": {
         "type": "opencollective",
         "url": "https://opencollective.com/core-js"
       }
     },
     "node_modules/core-js-compat": {
-      "version": "3.48.0",
-      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.48.0.tgz",
-      "integrity": "sha512-OM4cAF3D6VtH/WkLtWvyNC56EZVXsZdU3iqaMG2B4WvYrlqU831pc4UtG5yp0sE9z8Y02wVN7PjW5Zf9Gt0f1Q==",
+      "version": "3.50.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.50.0.tgz",
+      "integrity": "sha512-XGpFGbMLHwSt74YLTKho7Ib242qi6O8MSX+sRokV4oz7iKXvQWGYZthjIhjRGMxjzVkAubBO512dKGYcefmX3Q==",
       "license": "MIT",
       "dependencies": {
-        "browserslist": "^4.28.1"
+        "browserslist": "^4.28.7"
+      },
+      "engines": {
+        "node": ">=6.4.0"
       },
       "funding": {
         "type": "opencollective",
@@ -4227,37 +4235,29 @@
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.2.0.tgz",
       "integrity": "sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==",
+      "deprecated": "Active development of CryptoJS has been discontinued. This library is no longer maintained.",
       "license": "MIT"
     },
     "node_modules/css-tree": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.1.0.tgz",
-      "integrity": "sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==",
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "mdn-data": "2.12.2",
-        "source-map-js": "^1.0.1"
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
       },
       "engines": {
         "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
       }
     },
-    "node_modules/cssstyle": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-6.0.1.tgz",
-      "integrity": "sha512-IoJs7La+oFp/AB033wBStxNOJt4+9hHMxsXUPANcoXL2b3W4DZKghlJ2cI/eyeRZIQ9ysvYEorVhjrcYctWbog==",
+    "node_modules/css-tree/node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@asamuzakjp/css-color": "^4.1.2",
-        "@csstools/css-syntax-patches-for-csstree": "^1.0.26",
-        "css-tree": "^3.1.0",
-        "lru-cache": "^11.2.5"
-      },
-      "engines": {
-        "node": ">=20"
-      }
+      "license": "CC0-1.0"
     },
     "node_modules/data-urls": {
       "version": "7.0.0",
@@ -4273,60 +4273,6 @@
         "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
-    "node_modules/data-view-buffer": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz",
-      "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/data-view-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz",
-      "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/inspect-js"
-      }
-    },
-    "node_modules/data-view-byte-offset": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz",
-      "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-data-view": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -4358,59 +4304,46 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "dev": true,
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
       "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
-      "dev": true,
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
       "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
       }
     },
-    "node_modules/depd": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
-      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+    "node_modules/detect-indent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-7.0.2.tgz",
+      "integrity": "sha512-y+8xyqdGLL+6sh0tVeHcfP/QDd8gUgbasolJJpY7NgeQGSZ739bDtSiaiDgtoicy+mtYB81dKLxO9xRhCyIB3A==",
+      "dev": true,
       "license": "MIT",
       "engines": {
-        "node": ">= 0.8"
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/destroy": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
-      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
-      "license": "MIT",
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">= 0.8",
-        "npm": "1.2.8000 || >= 1.4.16"
+        "node": ">=8"
       }
     },
     "node_modules/dlv": {
@@ -4419,19 +4352,6 @@
       "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
       "license": "MIT"
     },
-    "node_modules/doctrine": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
-      "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "esutils": "^2.0.2"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
     "node_modules/dset": {
       "version": "3.1.4",
       "resolved": "https://registry.npmjs.org/dset/-/dset-3.1.4.tgz",
@@ -4462,9 +4382,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.286",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.286.tgz",
-      "integrity": "sha512-9tfDXhJ4RKFNerfjdCcZfufu49vg620741MNs26a9+bhLThdB+plgMeou98CAaHu/WATj2iHOOHTp1hWtABj2A==",
+      "version": "1.5.402",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.402.tgz",
+      "integrity": "sha512-/oOpMaPT6Yg+6/1XQhyIPlzgj7Ye9zf+nNM2Uh6OcE2G2oNptWazFa+qB2Pdqqbsc9KnIDzgAntoYN0dbwOXwA==",
       "license": "ISC"
     },
     "node_modules/encodeurl": {
@@ -4477,9 +4397,9 @@
       }
     },
     "node_modules/entities": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
-      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
       "dev": true,
       "license": "BSD-2-Clause",
       "engines": {
@@ -4489,75 +4409,6 @@
         "url": "https://github.com/fb55/entities?sponsor=1"
       }
     },
-    "node_modules/es-abstract": {
-      "version": "1.24.1",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.1.tgz",
-      "integrity": "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.2",
-        "arraybuffer.prototype.slice": "^1.0.4",
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "data-view-buffer": "^1.0.2",
-        "data-view-byte-length": "^1.0.2",
-        "data-view-byte-offset": "^1.0.1",
-        "es-define-property": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.1.1",
-        "es-set-tostringtag": "^2.1.0",
-        "es-to-primitive": "^1.3.0",
-        "function.prototype.name": "^1.1.8",
-        "get-intrinsic": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "get-symbol-description": "^1.1.0",
-        "globalthis": "^1.0.4",
-        "gopd": "^1.2.0",
-        "has-property-descriptors": "^1.0.2",
-        "has-proto": "^1.2.0",
-        "has-symbols": "^1.1.0",
-        "hasown": "^2.0.2",
-        "internal-slot": "^1.1.0",
-        "is-array-buffer": "^3.0.5",
-        "is-callable": "^1.2.7",
-        "is-data-view": "^1.0.2",
-        "is-negative-zero": "^2.0.3",
-        "is-regex": "^1.2.1",
-        "is-set": "^2.0.3",
-        "is-shared-array-buffer": "^1.0.4",
-        "is-string": "^1.1.1",
-        "is-typed-array": "^1.1.15",
-        "is-weakref": "^1.1.1",
-        "math-intrinsics": "^1.1.0",
-        "object-inspect": "^1.13.4",
-        "object-keys": "^1.1.1",
-        "object.assign": "^4.1.7",
-        "own-keys": "^1.0.1",
-        "regexp.prototype.flags": "^1.5.4",
-        "safe-array-concat": "^1.1.3",
-        "safe-push-apply": "^1.0.0",
-        "safe-regex-test": "^1.1.0",
-        "set-proto": "^1.0.0",
-        "stop-iteration-iterator": "^1.1.0",
-        "string.prototype.trim": "^1.2.10",
-        "string.prototype.trimend": "^1.0.9",
-        "string.prototype.trimstart": "^1.0.8",
-        "typed-array-buffer": "^1.0.3",
-        "typed-array-byte-length": "^1.0.3",
-        "typed-array-byte-offset": "^1.0.4",
-        "typed-array-length": "^1.0.7",
-        "unbox-primitive": "^1.1.0",
-        "which-typed-array": "^1.1.19"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/es-define-property": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -4577,16 +4428,16 @@
       }
     },
     "node_modules/es-module-lexer": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
-      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",
+      "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0"
@@ -4595,53 +4446,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/es-set-tostringtag": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
-      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-shim-unscopables": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz",
-      "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/es-to-primitive": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz",
-      "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7",
-        "is-date-object": "^1.0.5",
-        "is-symbol": "^1.0.4"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/es6-promise": {
       "version": "4.2.8",
       "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz",
@@ -4649,9 +4453,9 @@
       "license": "MIT"
     },
     "node_modules/esbuild": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
-      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -4662,32 +4466,32 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.3",
-        "@esbuild/android-arm": "0.27.3",
-        "@esbuild/android-arm64": "0.27.3",
-        "@esbuild/android-x64": "0.27.3",
-        "@esbuild/darwin-arm64": "0.27.3",
-        "@esbuild/darwin-x64": "0.27.3",
-        "@esbuild/freebsd-arm64": "0.27.3",
-        "@esbuild/freebsd-x64": "0.27.3",
-        "@esbuild/linux-arm": "0.27.3",
-        "@esbuild/linux-arm64": "0.27.3",
-        "@esbuild/linux-ia32": "0.27.3",
-        "@esbuild/linux-loong64": "0.27.3",
-        "@esbuild/linux-mips64el": "0.27.3",
-        "@esbuild/linux-ppc64": "0.27.3",
-        "@esbuild/linux-riscv64": "0.27.3",
-        "@esbuild/linux-s390x": "0.27.3",
-        "@esbuild/linux-x64": "0.27.3",
-        "@esbuild/netbsd-arm64": "0.27.3",
-        "@esbuild/netbsd-x64": "0.27.3",
-        "@esbuild/openbsd-arm64": "0.27.3",
-        "@esbuild/openbsd-x64": "0.27.3",
-        "@esbuild/openharmony-arm64": "0.27.3",
-        "@esbuild/sunos-x64": "0.27.3",
-        "@esbuild/win32-arm64": "0.27.3",
-        "@esbuild/win32-ia32": "0.27.3",
-        "@esbuild/win32-x64": "0.27.3"
+        "@esbuild/aix-ppc64": "0.28.2",
+        "@esbuild/android-arm": "0.28.2",
+        "@esbuild/android-arm64": "0.28.2",
+        "@esbuild/android-x64": "0.28.2",
+        "@esbuild/darwin-arm64": "0.28.2",
+        "@esbuild/darwin-x64": "0.28.2",
+        "@esbuild/freebsd-arm64": "0.28.2",
+        "@esbuild/freebsd-x64": "0.28.2",
+        "@esbuild/linux-arm": "0.28.2",
+        "@esbuild/linux-arm64": "0.28.2",
+        "@esbuild/linux-ia32": "0.28.2",
+        "@esbuild/linux-loong64": "0.28.2",
+        "@esbuild/linux-mips64el": "0.28.2",
+        "@esbuild/linux-ppc64": "0.28.2",
+        "@esbuild/linux-riscv64": "0.28.2",
+        "@esbuild/linux-s390x": "0.28.2",
+        "@esbuild/linux-x64": "0.28.2",
+        "@esbuild/netbsd-arm64": "0.28.2",
+        "@esbuild/netbsd-x64": "0.28.2",
+        "@esbuild/openbsd-arm64": "0.28.2",
+        "@esbuild/openbsd-x64": "0.28.2",
+        "@esbuild/openharmony-arm64": "0.28.2",
+        "@esbuild/sunos-x64": "0.28.2",
+        "@esbuild/win32-arm64": "0.28.2",
+        "@esbuild/win32-ia32": "0.28.2",
+        "@esbuild/win32-x64": "0.28.2"
       }
     },
     "node_modules/escalade": {
@@ -4719,34 +4523,33 @@
       }
     },
     "node_modules/eslint": {
-      "version": "9.39.2",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.2.tgz",
-      "integrity": "sha512-LEyamqS7W5HB3ujJyvi0HQK/dtVINZvd5mAAp9eT5S/ujByGjiZLCzPcHVzuXbpJDJF/cxwHlfceVUDZ2lnSTw==",
+      "version": "10.8.1",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.8.1.tgz",
+      "integrity": "sha512-wqA7W2jbsC/BnV9Iv1UZpKVFkO1AdNoSmYW8NWG4HNOBbkAMvIqDZ27pI2f07dqn583NcIC44ckjAcOXDL1QbQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
+      "workspaces": [
+        "packages/*"
+      ],
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.8.0",
-        "@eslint-community/regexpp": "^4.12.1",
-        "@eslint/config-array": "^0.21.1",
-        "@eslint/config-helpers": "^0.4.2",
-        "@eslint/core": "^0.17.0",
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "9.39.2",
-        "@eslint/plugin-kit": "^0.4.1",
+        "@eslint-community/regexpp": "^4.12.2",
+        "@eslint/config-array": "^0.23.5",
+        "@eslint/config-helpers": "^0.7.0",
+        "@eslint/core": "^1.2.1",
+        "@eslint/plugin-kit": "^0.7.2",
         "@humanfs/node": "^0.16.6",
         "@humanwhocodes/module-importer": "^1.0.1",
         "@humanwhocodes/retry": "^0.4.2",
         "@types/estree": "^1.0.6",
-        "ajv": "^6.12.4",
-        "chalk": "^4.0.0",
+        "ajv": "^6.14.0",
         "cross-spawn": "^7.0.6",
         "debug": "^4.3.2",
         "escape-string-regexp": "^4.0.0",
-        "eslint-scope": "^8.4.0",
-        "eslint-visitor-keys": "^4.2.1",
-        "espree": "^10.4.0",
-        "esquery": "^1.5.0",
+        "eslint-scope": "^9.1.2",
+        "eslint-visitor-keys": "^5.0.1",
+        "espree": "^11.2.0",
+        "esquery": "^1.7.0",
         "esutils": "^2.0.2",
         "fast-deep-equal": "^3.1.3",
         "file-entry-cache": "^8.0.0",
@@ -4756,8 +4559,7 @@
         "imurmurhash": "^0.1.4",
         "is-glob": "^4.0.0",
         "json-stable-stringify-without-jsonify": "^1.0.1",
-        "lodash.merge": "^4.6.2",
-        "minimatch": "^3.1.2",
+        "minimatch": "^10.2.5",
         "natural-compare": "^1.4.0",
         "optionator": "^0.9.3"
       },
@@ -4765,7 +4567,7 @@
         "eslint": "bin/eslint.js"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://eslint.org/donate"
@@ -4795,333 +4597,215 @@
         "eslint": ">=7.0.0"
       }
     },
-    "node_modules/eslint-import-resolver-node": {
-      "version": "0.3.9",
-      "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz",
-      "integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "debug": "^3.2.7",
-        "is-core-module": "^2.13.0",
-        "resolve": "^1.22.4"
-      }
-    },
-    "node_modules/eslint-import-resolver-node/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-module-utils": {
-      "version": "2.12.1",
-      "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz",
-      "integrity": "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==",
+    "node_modules/eslint-import-context": {
+      "version": "0.1.9",
+      "resolved": "https://registry.npmjs.org/eslint-import-context/-/eslint-import-context-0.1.9.tgz",
+      "integrity": "sha512-K9Hb+yRaGAGUbwjhFNHvSmmkZs9+zbuoe3kFQ4V1wYjrepUFYM2dZAfNtjbbj3qsPfUfsA68Bx/ICWQMi+C8Eg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "debug": "^3.2.7"
+        "get-tsconfig": "^4.10.1",
+        "stable-hash-x": "^0.2.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-import-context"
+      },
+      "peerDependencies": {
+        "unrs-resolver": "^1.0.0"
       },
       "peerDependenciesMeta": {
-        "eslint": {
+        "unrs-resolver": {
           "optional": true
         }
       }
     },
-    "node_modules/eslint-module-utils/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+    "node_modules/eslint-import-resolver-typescript": {
+      "version": "4.4.5",
+      "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-4.4.5.tgz",
+      "integrity": "sha512-nbE5XLph6TLtGYcu/U6e6ZVXyKBhbDWK5cLGk76eJ7NdZpwf1P9EFkpt1Z01mNZNrrilsAYWKH6zUkL4reoXbw==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-plugin-import": {
-      "version": "2.32.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz",
-      "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==",
-      "dev": true,
-      "license": "MIT",
+      "license": "ISC",
       "dependencies": {
-        "@rtsao/scc": "^1.1.0",
-        "array-includes": "^3.1.9",
-        "array.prototype.findlastindex": "^1.2.6",
-        "array.prototype.flat": "^1.3.3",
-        "array.prototype.flatmap": "^1.3.3",
-        "debug": "^3.2.7",
-        "doctrine": "^2.1.0",
-        "eslint-import-resolver-node": "^0.3.9",
-        "eslint-module-utils": "^2.12.1",
-        "hasown": "^2.0.2",
-        "is-core-module": "^2.16.1",
-        "is-glob": "^4.0.3",
-        "minimatch": "^3.1.2",
-        "object.fromentries": "^2.0.8",
-        "object.groupby": "^1.0.3",
-        "object.values": "^1.2.1",
-        "semver": "^6.3.1",
-        "string.prototype.trimend": "^1.0.9",
-        "tsconfig-paths": "^3.15.0"
+        "debug": "^4.4.1",
+        "eslint-import-context": "^0.1.8",
+        "get-tsconfig": "^4.10.1",
+        "is-bun-module": "^2.0.0",
+        "stable-hash-x": "^0.2.0",
+        "tinyglobby": "^0.2.14",
+        "unrs-resolver": "^1.7.11"
       },
       "engines": {
-        "node": ">=4"
+        "node": "^16.17.0 || >=18.6.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-import-resolver-typescript"
       },
       "peerDependencies": {
-        "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9"
-      }
-    },
-    "node_modules/eslint-plugin-import/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
+        "eslint": "*",
+        "eslint-plugin-import": "*",
+        "eslint-plugin-import-x": "*"
+      },
+      "peerDependenciesMeta": {
+        "eslint-plugin-import": {
+          "optional": true
+        },
+        "eslint-plugin-import-x": {
+          "optional": true
+        }
       }
     },
-    "node_modules/eslint-plugin-import/node_modules/debug": {
-      "version": "3.2.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
-      "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+    "node_modules/eslint-plugin-import-x": {
+      "version": "4.17.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-import-x/-/eslint-plugin-import-x-4.17.1.tgz",
+      "integrity": "sha512-4cdstYkKCyjumM2Q9NSI03K8D2a9F4Ssz33K2lv2hQa4KmR9jPLwk3uWGtNvclfqBrPGfGuMBwsGMbe6dMRbfg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "ms": "^2.1.1"
-      }
-    },
-    "node_modules/eslint-plugin-import/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "@typescript-eslint/types": "^8.56.0",
+        "comment-parser": "^1.4.1",
+        "debug": "^4.4.1",
+        "eslint-import-context": "^0.1.9",
+        "is-glob": "^4.0.3",
+        "minimatch": "^9.0.3 || ^10.1.2",
+        "semver": "^7.7.2",
+        "stable-hash-x": "^0.2.0",
+        "unrs-resolver": "^1.9.2"
       },
       "engines": {
-        "node": "*"
-      }
-    },
-    "node_modules/eslint-plugin-import/node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-plugin-import-x"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/utils": "^8.56.0",
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "eslint-import-resolver-node": "*"
+      },
+      "peerDependenciesMeta": {
+        "@typescript-eslint/utils": {
+          "optional": true
+        },
+        "eslint-import-resolver-node": {
+          "optional": true
+        }
       }
     },
     "node_modules/eslint-plugin-jsdoc": {
-      "version": "62.6.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-62.6.1.tgz",
-      "integrity": "sha512-zfz4lMIKDkidkqZniIieZujwZAtpaSNM0WXwilToKoR2UWEw0JE/QevQI2k6YN4ZSy3YhXB3Vs1ab62GZu8Wug==",
+      "version": "63.3.3",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-jsdoc/-/eslint-plugin-jsdoc-63.3.3.tgz",
+      "integrity": "sha512-xI4IeVRzRFA2DGHrPLIxF3U+oJHU3FE+P9Zb27fVs5dPHgfcpoAs0PyCbznVhK7pwR+9BPUztFeXSgpw/CL4Yg==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
-        "@es-joy/jsdoccomment": "~0.84.0",
+        "@es-joy/jsdoccomment": "~0.91.0",
         "@es-joy/resolve.exports": "1.2.0",
         "are-docs-informative": "^0.0.2",
-        "comment-parser": "1.4.5",
+        "comment-parser": "1.4.7",
         "debug": "^4.4.3",
         "escape-string-regexp": "^4.0.0",
-        "espree": "^11.1.0",
+        "espree": "^11.2.0",
         "esquery": "^1.7.0",
         "html-entities": "^2.6.0",
-        "object-deep-merge": "^2.0.0",
+        "object-deep-merge": "^2.0.1",
         "parse-imports-exports": "^0.2.4",
-        "semver": "^7.7.3",
-        "spdx-expression-parse": "^4.0.0",
+        "semver": "^7.8.5",
+        "spdx-expression-parse": "^5.0.0",
         "to-valid-identifier": "^1.0.0"
       },
       "engines": {
-        "node": "^20.19.0 || ^22.13.0 || >=24"
+        "node": "^22.13.0 || >=24"
       },
       "peerDependencies": {
-        "eslint": "^7.0.0 || ^8.0.0 || ^9.0.0"
-      }
-    },
-    "node_modules/eslint-plugin-jsdoc/node_modules/eslint-visitor-keys": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.0.tgz",
-      "integrity": "sha512-A0XeIi7CXU7nPlfHS9loMYEKxUaONu/hTEzHTGba9Huu94Cq1hPivf+DE5erJozZOky0LfvXAyrV/tcswpLI0Q==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^20.19.0 || ^22.13.0 || >=24"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-plugin-jsdoc/node_modules/espree": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-11.1.0.tgz",
-      "integrity": "sha512-WFWYhO1fV4iYkqOOvq8FbqIhr2pYfoDY0kCotMkDeNtGpiGGkZ1iov2u8ydjtgM8yF8rzK7oaTbw2NAzbAbehw==",
-      "dev": true,
-      "license": "BSD-2-Clause",
-      "dependencies": {
-        "acorn": "^8.15.0",
-        "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^5.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.13.0 || >=24"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "eslint": "^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0"
       }
     },
     "node_modules/eslint-plugin-unicorn": {
-      "version": "62.0.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-unicorn/-/eslint-plugin-unicorn-62.0.0.tgz",
-      "integrity": "sha512-HIlIkGLkvf29YEiS/ImuDZQbP12gWyx5i3C6XrRxMvVdqMroCI9qoVYCoIl17ChN+U89pn9sVwLxhIWj5nEc7g==",
+      "version": "73.0.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-unicorn/-/eslint-plugin-unicorn-73.0.0.tgz",
+      "integrity": "sha512-V0YatLe9nkGhXEXKe2Qljb1EY0sJHwDV0HUF1NKFwtsHh/fU7qGHDgv+6fchzZcgU2/7noHo2gdjnmo0P2uDPw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@babel/helper-validator-identifier": "^7.28.5",
-        "@eslint-community/eslint-utils": "^4.9.0",
-        "@eslint/plugin-kit": "^0.4.0",
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@eslint/css-tree": "^4.0.4",
+        "browserslist": "^4.28.4",
         "change-case": "^5.4.4",
-        "ci-info": "^4.3.1",
-        "clean-regexp": "^1.0.0",
-        "core-js-compat": "^3.46.0",
-        "esquery": "^1.6.0",
+        "ci-info": "^4.4.0",
+        "core-js-compat": "^3.49.0",
+        "detect-indent": "^7.0.2",
+        "entities": "^4.5.0",
         "find-up-simple": "^1.0.1",
-        "globals": "^16.4.0",
+        "globals": "^17.7.0",
         "indent-string": "^5.0.0",
         "is-builtin-module": "^5.0.0",
-        "jsesc": "^3.1.0",
+        "is-identifier": "^1.1.0",
         "pluralize": "^8.0.0",
-        "regexp-tree": "^0.1.27",
-        "regjsparser": "^0.13.0",
-        "semver": "^7.7.3",
-        "strip-indent": "^4.1.1"
+        "quote-js-string": "^0.1.0",
+        "regjsparser": "^0.13.2",
+        "reserved-identifiers": "^1.2.0",
+        "semver": "^7.8.5",
+        "strip-indent": "^4.1.1",
+        "yaml": "^2.9.0"
       },
       "engines": {
-        "node": "^20.10.0 || >=21.0.0"
+        "node": ">=22"
       },
       "funding": {
         "url": "https://github.com/sindresorhus/eslint-plugin-unicorn?sponsor=1"
       },
       "peerDependencies": {
-        "eslint": ">=9.38.0"
+        "eslint": ">=10.4"
       }
     },
     "node_modules/eslint-scope": {
-      "version": "8.4.0",
-      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
-      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz",
+      "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
+        "@types/esrecurse": "^4.3.1",
+        "@types/estree": "^1.0.8",
         "esrecurse": "^4.3.0",
         "estraverse": "^5.2.0"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://opencollective.com/eslint"
       }
     },
     "node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/brace-expansion": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
-    "node_modules/eslint/node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://opencollective.com/eslint"
       }
     },
-    "node_modules/eslint/node_modules/ignore": {
-      "version": "5.3.2",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
-      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/eslint/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "brace-expansion": "^1.1.7"
-      },
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/espree": {
-      "version": "10.4.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
-      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "version": "11.2.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz",
+      "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==",
       "dev": true,
       "license": "BSD-2-Clause",
       "dependencies": {
-        "acorn": "^8.15.0",
+        "acorn": "^8.16.0",
         "acorn-jsx": "^5.3.2",
-        "eslint-visitor-keys": "^4.2.1"
+        "eslint-visitor-keys": "^5.0.1"
       },
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/espree/node_modules/eslint-visitor-keys": {
-      "version": "4.2.1",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
-      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": "^20.19.0 || ^22.13.0 || >=24"
       },
       "funding": {
         "url": "https://opencollective.com/eslint"
@@ -5205,9 +4889,9 @@
       }
     },
     "node_modules/expect-type": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
-      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+      "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
       "dev": true,
       "license": "Apache-2.0",
       "engines": {
@@ -5215,14 +4899,14 @@
       }
     },
     "node_modules/express": {
-      "version": "4.22.1",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
-      "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
+      "version": "4.22.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
+      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
       "license": "MIT",
       "dependencies": {
         "accepts": "~1.3.8",
         "array-flatten": "1.1.1",
-        "body-parser": "~1.20.3",
+        "body-parser": "~1.20.5",
         "content-disposition": "~0.5.4",
         "content-type": "~1.0.4",
         "cookie": "~0.7.1",
@@ -5241,7 +4925,7 @@
         "parseurl": "~1.3.3",
         "path-to-regexp": "~0.1.12",
         "proxy-addr": "~2.0.7",
-        "qs": "~6.14.0",
+        "qs": "~6.15.1",
         "range-parser": "~1.2.1",
         "safe-buffer": "5.2.1",
         "send": "~0.19.0",
@@ -5309,9 +4993,9 @@
       "license": "MIT"
     },
     "node_modules/fast-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
-      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz",
+      "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==",
       "funding": [
         {
           "type": "github",
@@ -5322,7 +5006,8 @@
           "url": "https://opencollective.com/fastify"
         }
       ],
-      "license": "BSD-3-Clause"
+      "license": "BSD-3-Clause",
+      "peer": true
     },
     "node_modules/fdir": {
       "version": "6.5.0",
@@ -5433,28 +5118,12 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.3.3",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
-      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "version": "3.4.4",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.4.tgz",
+      "integrity": "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q==",
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/forwarded": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -5514,45 +5183,17 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/function.prototype.name": {
-      "version": "1.1.8",
-      "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz",
-      "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==",
+    "node_modules/function-timeout": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/function-timeout/-/function-timeout-1.0.2.tgz",
+      "integrity": "sha512-939eZS4gJ3htTHAldmyyuzlrD58P03fHG49v2JfFXbV6OhvZKRC9j2yAtdHw/zrp2zXHuv05zMIy40F0ge7spA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "functions-have-names": "^1.2.3",
-        "hasown": "^2.0.2",
-        "is-callable": "^1.2.7"
-      },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=18"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/functions-have-names": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
-      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/generator-function": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
-      "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/gensync": {
@@ -5601,22 +5242,17 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/get-symbol-description": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",
-      "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==",
+    "node_modules/get-tsconfig": {
+      "version": "4.14.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.14.1.tgz",
+      "integrity": "sha512-Dz/6HxkrxgNehhxLVeyv8sad9UzF2xBVeaKBQNDfJ5XiSXmp2gTR0eO0RWiT2NCKS5aGP9jjkOMggTN90qU50A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
+        "resolve-pkg-maps": "^1.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
       }
     },
     "node_modules/glob-parent": {
@@ -5633,9 +5269,9 @@
       }
     },
     "node_modules/globals": {
-      "version": "16.5.0",
-      "resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",
-      "integrity": "sha512-c/c15i26VrJ4IRt5Z89DnIzCGDn9EcebibhAOjw5ibqEHsE1wLUgkPn9RDmNcUKyU87GeaL633nyJ+pplFR2ZQ==",
+      "version": "17.11.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.11.0.tgz",
+      "integrity": "sha512-Z2I8hM+PbJDXQDq3Icgpzv+mPdwr68iZUU9d5WW4FuXfDUQfkZaZuvjMv42/5crNyw154+9+VWXbYrUgDXbxNw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -5645,23 +5281,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/globalthis": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
-      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-properties": "^1.2.1",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/gopd": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
@@ -5681,21 +5300,21 @@
       "license": "ISC"
     },
     "node_modules/gulp-babel": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/gulp-babel/-/gulp-babel-8.0.0.tgz",
-      "integrity": "sha512-oomaIqDXxFkg7lbpBou/gnUkX51/Y/M2ZfSjL2hdqXTAlSWZcgZtd2o0cOH0r/eE8LWD0+Q/PsLsr2DKOoqToQ==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/gulp-babel/-/gulp-babel-8.1.0.tgz",
+      "integrity": "sha512-QtFF9+h3xrVjfo79h7HCY4S8k4qNEcOz7ffpfavlscv0F0glfTQyv4kEYvX+YykTm4qllMF4aZfjeqLjzddTYA==",
       "license": "MIT",
       "dependencies": {
         "plugin-error": "^1.0.1",
         "replace-ext": "^1.0.0",
-        "through2": "^2.0.0",
+        "through2": "^3.0.0",
         "vinyl-sourcemaps-apply": "^0.2.0"
       },
       "engines": {
         "node": ">=6"
       },
       "peerDependencies": {
-        "@babel/core": "^7.0.0"
+        "@babel/core": "^7.0.0 || ^8.0.0"
       }
     },
     "node_modules/gulp-wrap": {
@@ -5719,38 +5338,6 @@
         "npm": ">=1.4.3"
       }
     },
-    "node_modules/gulp-wrap/node_modules/argparse": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
-      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
-      "license": "MIT",
-      "dependencies": {
-        "sprintf-js": "~1.0.2"
-      }
-    },
-    "node_modules/gulp-wrap/node_modules/js-yaml": {
-      "version": "3.14.2",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.2.tgz",
-      "integrity": "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==",
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^1.0.7",
-        "esprima": "^4.0.0"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/gulp-wrap/node_modules/through2": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/through2/-/through2-3.0.2.tgz",
-      "integrity": "sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==",
-      "license": "MIT",
-      "dependencies": {
-        "inherits": "^2.0.4",
-        "readable-stream": "2 || 3"
-      }
-    },
     "node_modules/has": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/has/-/has-1.0.4.tgz",
@@ -5760,58 +5347,6 @@
         "node": ">= 0.4.0"
       }
     },
-    "node_modules/has-bigints": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
-      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-flag": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-proto": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz",
-      "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/has-symbols": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
@@ -5824,26 +5359,10 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-tostringtag": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
-      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-symbols": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/hasown": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
-      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
       "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
@@ -5902,34 +5421,6 @@
         "url": "https://opencollective.com/express"
       }
     },
-    "node_modules/http-proxy-agent": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
-      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.0",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/https-proxy-agent": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
-      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
     "node_modules/iab-adcom": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/iab-adcom/-/iab-adcom-1.0.6.tgz",
@@ -5940,9 +5431,9 @@
       }
     },
     "node_modules/iab-native": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/iab-native/-/iab-native-1.0.0.tgz",
-      "integrity": "sha512-AxGYpKGRcyG5pbEAqj+ssxNwZAfxC0pRwyKc0MYoKjm0UeOoUNCWrZV0HGimcQii6ebe6MRqBQEeENyHM4qTdQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/iab-native/-/iab-native-1.0.1.tgz",
+      "integrity": "sha512-CrutbUqcP1h4ZKeCO1cOzYmcPRs4MqMSLz4hCUvU3wRlPoOVm6ErKJUifwomke9L9SQazKZx4NXcoiSNR2fXWw==",
       "license": "MIT",
       "engines": {
         "node": ">=14.0.0"
@@ -5972,33 +5463,32 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/ignore": {
-      "version": "7.0.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
-      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 4"
-      }
-    },
-    "node_modules/import-fresh": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
-      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+    "node_modules/identifier-regex": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/identifier-regex/-/identifier-regex-1.1.0.tgz",
+      "integrity": "sha512-SLX4H/vtcYlYnL7XqnuJKHU7Z8517TgsW9nmQiGOgMCjQ8V/deLYu6bEmbGoXe7WMMhc9+EUGyFFneHja8KabA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "parent-module": "^1.0.0",
-        "resolve-from": "^4.0.0"
+        "reserved-identifiers": "^1.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
     "node_modules/imurmurhash": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
@@ -6028,21 +5518,6 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
-    "node_modules/internal-slot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
-      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "hasown": "^2.0.2",
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/ipaddr.js": {
       "version": "1.9.1",
       "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
@@ -6061,36 +5536,39 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/is-array-buffer": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
-      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
+    "node_modules/is-builtin-module": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-5.0.0.tgz",
+      "integrity": "sha512-f4RqJKBUe5rQkJ2eJEJBXSticB3hGbN9j0yxxMQFqIW89Jp9WYFtzfTcRlstDKVUTRzSOTLKRfO9vIztenwtxA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
+        "builtin-modules": "^5.0.0"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=18.20"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-async-function": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz",
-      "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==",
+    "node_modules/is-bun-module": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-bun-module/-/is-bun-module-2.0.0.tgz",
+      "integrity": "sha512-gNCGbnnnnFAUGKeZ9PdbyeGYJqewpmc2aKHUEMO5nQPWU9lOmv7jcmQIv+qHD8fXW6W7qfuCwX4rY9LNRjXrkQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "async-function": "^1.0.0",
-        "call-bound": "^1.0.3",
-        "get-proto": "^1.0.1",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
+        "semver": "^7.7.1"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.2",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
+      "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
+      "license": "MIT",
+      "dependencies": {
+        "hasown": "^2.0.3"
       },
       "engines": {
         "node": ">= 0.4"
@@ -6099,578 +5577,506 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/is-bigint": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
-      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
-      "dev": true,
+    "node_modules/is-extendable": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
+      "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
       "license": "MIT",
       "dependencies": {
-        "has-bigints": "^1.0.2"
+        "is-plain-object": "^2.0.4"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-boolean-object": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
-      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-builtin-module": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-5.0.0.tgz",
-      "integrity": "sha512-f4RqJKBUe5rQkJ2eJEJBXSticB3hGbN9j0yxxMQFqIW89Jp9WYFtzfTcRlstDKVUTRzSOTLKRfO9vIztenwtxA==",
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "builtin-modules": "^5.0.0"
+        "is-extglob": "^2.1.1"
       },
       "engines": {
-        "node": ">=18.20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
+    "node_modules/is-identifier": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-identifier/-/is-identifier-1.1.0.tgz",
+      "integrity": "sha512-NhOds0mDx9lJu+1lBRO0xbwFo5nobA7GCk/0e5xjr6+6XugX985+0OyGX35BNrTkPAsdLcIKg02HUQJOK8D8kw==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "identifier-regex": "^1.1.0",
+        "super-regex": "^1.1.0"
+      },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=18"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/is-core-module": {
-      "version": "2.16.1",
-      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
-      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+    "node_modules/is-plain-object": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
+      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
       "license": "MIT",
       "dependencies": {
-        "hasown": "^2.0.2"
+        "isobject": "^3.0.1"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-data-view": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz",
-      "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==",
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "is-typed-array": "^1.1.13"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "license": "MIT"
     },
-    "node_modules/is-date-object": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
-      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
+    "node_modules/isarray": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
+      "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==",
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "license": "ISC"
     },
-    "node_modules/is-extendable": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-      "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
+    "node_modules/isobject": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
       "license": "MIT",
-      "dependencies": {
-        "is-plain-object": "^2.0.4"
-      },
       "engines": {
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
     },
-    "node_modules/is-finalizationregistry": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz",
-      "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==",
-      "dev": true,
+    "node_modules/js-yaml": {
+      "version": "3.15.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.15.1.tgz",
+      "integrity": "sha512-S99WuO3HlhO3XN41EtYUNl9zzXjoJx7QvmipxsJVxtCBT0YHEFy+iOJhjSvrmV12nYhWpZaM8lPHkJm0yUMbag==",
       "license": "MIT",
       "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
       }
     },
-    "node_modules/is-generator-function": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz",
-      "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==",
+    "node_modules/jsdoc-type-pratt-parser": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-8.0.0.tgz",
+      "integrity": "sha512-uQu/fXVqVaMg6gM8/E5G5+eygVcZ1NV0Z51CvqhNa2bDWxvHMl484ETr6vph4oPyC+KUcbP/w2W2pewfCiR9aQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.4",
-        "generator-function": "^2.0.0",
-        "get-proto": "^1.0.1",
-        "has-tostringtag": "^1.0.2",
-        "safe-regex-test": "^1.1.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=20.0.0"
       }
     },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+    "node_modules/jsdom": {
+      "version": "29.1.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+      "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-map": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
-      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
+        "@asamuzakjp/css-color": "^5.1.11",
+        "@asamuzakjp/dom-selector": "^7.1.1",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.3.5",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.25.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-negative-zero": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz",
-      "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==",
-      "dev": true,
-      "license": "MIT",
       "engines": {
-        "node": ">= 0.4"
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-number-object": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
-      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
+      "peerDependencies": {
+        "canvas": "^3.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
       }
     },
-    "node_modules/is-plain-object": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
-      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
       "license": "MIT",
-      "dependencies": {
-        "isobject": "^3.0.1"
+      "bin": {
+        "jsesc": "bin/jsesc"
       },
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=6"
       }
     },
-    "node_modules/is-potential-custom-element-name": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
-      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/is-regex": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
-      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "license": "MIT"
     },
-    "node_modules/is-set": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
-      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "license": "MIT"
     },
-    "node_modules/is-shared-array-buffer": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
-      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
-      "dev": true,
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
+      "bin": {
+        "json5": "lib/cli.js"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=6"
       }
     },
-    "node_modules/is-string": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
-      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "json-buffer": "3.0.1"
       }
     },
-    "node_modules/is-symbol": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
-      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
-      "dev": true,
+    "node_modules/klona": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/klona/-/klona-2.0.6.tgz",
+      "integrity": "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==",
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "safe-regex-test": "^1.1.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 8"
       }
     },
-    "node_modules/is-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
-      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "which-typed-array": "^1.1.16"
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakmap": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
-      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 0.8.0"
       }
     },
-    "node_modules/is-weakref": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz",
-      "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==",
+    "node_modules/lightningcss": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz",
+      "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==",
       "dev": true,
-      "license": "MIT",
+      "license": "MPL-2.0",
       "dependencies": {
-        "call-bound": "^1.0.3"
+        "detect-libc": "^2.0.3"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">= 12.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-weakset": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
-      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.33.0",
+        "lightningcss-darwin-arm64": "1.33.0",
+        "lightningcss-darwin-x64": "1.33.0",
+        "lightningcss-freebsd-x64": "1.33.0",
+        "lightningcss-linux-arm-gnueabihf": "1.33.0",
+        "lightningcss-linux-arm64-gnu": "1.33.0",
+        "lightningcss-linux-arm64-musl": "1.33.0",
+        "lightningcss-linux-x64-gnu": "1.33.0",
+        "lightningcss-linux-x64-musl": "1.33.0",
+        "lightningcss-win32-arm64-msvc": "1.33.0",
+        "lightningcss-win32-x64-msvc": "1.33.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz",
+      "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
       "engines": {
-        "node": ">= 0.4"
+        "node": ">= 12.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/isexe": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
-      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz",
+      "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "ISC"
-    },
-    "node_modules/isobject": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
-      "license": "MIT",
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/js-tokens": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
-      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "license": "MIT"
-    },
-    "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
+        "node": ">= 12.0.0"
       },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
-      }
-    },
-    "node_modules/jsdoc-type-pratt-parser": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/jsdoc-type-pratt-parser/-/jsdoc-type-pratt-parser-7.1.1.tgz",
-      "integrity": "sha512-/2uqY7x6bsrpi3i9LVU6J89352C0rpMk0as8trXxCtvd4kPk1ke/Eyif6wqfSLvoNJqcDG9Vk4UsXgygzCt2xA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.0.0"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jsdom": {
-      "version": "28.1.0",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-28.1.0.tgz",
-      "integrity": "sha512-0+MoQNYyr2rBHqO1xilltfDjV9G7ymYGlAUazgcDLQaUf8JDHbuGwsxN6U9qWaElZ4w1B2r7yEGIL3GdeW3Rug==",
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz",
+      "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@acemir/cssom": "^0.9.31",
-        "@asamuzakjp/dom-selector": "^6.8.1",
-        "@bramus/specificity": "^2.4.2",
-        "@exodus/bytes": "^1.11.0",
-        "cssstyle": "^6.0.1",
-        "data-urls": "^7.0.0",
-        "decimal.js": "^10.6.0",
-        "html-encoding-sniffer": "^6.0.0",
-        "http-proxy-agent": "^7.0.2",
-        "https-proxy-agent": "^7.0.6",
-        "is-potential-custom-element-name": "^1.0.1",
-        "parse5": "^8.0.0",
-        "saxes": "^6.0.0",
-        "symbol-tree": "^3.2.4",
-        "tough-cookie": "^6.0.0",
-        "undici": "^7.21.0",
-        "w3c-xmlserializer": "^5.0.0",
-        "webidl-conversions": "^8.0.1",
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^16.0.0",
-        "xml-name-validator": "^5.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "canvas": "^3.0.0"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
       },
-      "peerDependenciesMeta": {
-        "canvas": {
-          "optional": true
-        }
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jsdom/node_modules/parse5": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.0.tgz",
-      "integrity": "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==",
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz",
+      "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^6.0.0"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
       },
       "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/jsesc": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
-      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
-      "license": "MIT",
-      "bin": {
-        "jsesc": "bin/jsesc"
-      },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz",
+      "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/json-buffer": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
-      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz",
+      "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz",
+      "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==",
+      "cpu": [
+        "arm64"
+      ],
       "dev": true,
-      "license": "MIT"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
     },
-    "node_modules/json-stable-stringify-without-jsonify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
-      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz",
+      "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/json5": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
-      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
-      "license": "MIT",
-      "bin": {
-        "json5": "lib/cli.js"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/keyv": {
-      "version": "4.5.4",
-      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
-      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz",
+      "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "json-buffer": "3.0.1"
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/klona": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/klona/-/klona-2.0.6.tgz",
-      "integrity": "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==",
-      "license": "MIT",
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz",
+      "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">= 8"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
-    "node_modules/levn": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
-      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.33.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz",
+      "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==",
+      "cpu": [
+        "x64"
+      ],
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "prelude-ls": "^1.2.1",
-        "type-check": "~0.4.0"
-      },
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">= 0.8.0"
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
       }
     },
     "node_modules/live-connect-common": {
@@ -6712,9 +6118,9 @@
       }
     },
     "node_modules/lodash": {
-      "version": "4.17.23",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
-      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
       "license": "MIT"
     },
     "node_modules/lodash.debounce": {
@@ -6723,17 +6129,10 @@
       "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==",
       "license": "MIT"
     },
-    "node_modules/lodash.merge": {
-      "version": "4.6.2",
-      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
-      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lru-cache": {
-      "version": "11.2.6",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.6.tgz",
-      "integrity": "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ==",
+      "version": "11.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz",
+      "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==",
       "dev": true,
       "license": "BlueOak-1.0.0",
       "engines": {
@@ -6750,6 +6149,24 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/make-asynchronous": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/make-asynchronous/-/make-asynchronous-1.1.0.tgz",
+      "integrity": "sha512-ayF7iT+44LXdxJLTrTd3TLQpFDDvPCBxXxbv+pMUSuHA5Q8zyAfwkRP6aHHwNVFBUFWtxAHqwNJxF8vMZLAbVg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-event": "^6.0.0",
+        "type-fest": "^4.6.0",
+        "web-worker": "^1.5.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -6760,9 +6177,9 @@
       }
     },
     "node_modules/mdn-data": {
-      "version": "2.12.2",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
-      "integrity": "sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==",
+      "version": "2.29.0",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.29.0.tgz",
+      "integrity": "sha512-pVxQFCcaYUEAH853+v7yoI/qzhxXSq1bTb9obMYGYAN1c3Hen+XDCEvr296XhstrwlSTNgOR7mCSD4JPjbJe5A==",
       "dev": true,
       "license": "CC0-1.0"
     },
@@ -6827,13 +6244,13 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "10.2.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.2.tgz",
-      "integrity": "sha512-+G4CpNBxa5MprY+04MbgOw1v7So6n5JY166pFi9KfYwT78fxScCeSNQSNzp6dpPSW2rONOps6Ocam1wFhCgoVw==",
+      "version": "10.2.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
+      "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==",
       "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
-        "brace-expansion": "^5.0.2"
+        "brace-expansion": "^5.0.8"
       },
       "engines": {
         "node": "18 || 20 || >=22"
@@ -6842,16 +6259,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/minimist": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -6859,9 +6266,9 @@
       "license": "MIT"
     },
     "node_modules/nanoid": {
-      "version": "3.3.11",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
-      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "version": "3.3.18",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",
+      "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",
       "dev": true,
       "funding": [
         {
@@ -6877,6 +6284,22 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/napi-postinstall": {
+      "version": "0.3.4",
+      "resolved": "https://registry.npmjs.org/napi-postinstall/-/napi-postinstall-0.3.4.tgz",
+      "integrity": "sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "napi-postinstall": "lib/cli.js"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/napi-postinstall"
+      }
+    },
     "node_modules/natural-compare": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
@@ -6894,120 +6317,39 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.27",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
-      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
-      "license": "MIT"
-    },
-    "node_modules/node.extend": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/node.extend/-/node.extend-2.0.2.tgz",
-      "integrity": "sha512-pDT4Dchl94/+kkgdwyS2PauDFjZG0Hk0IcHIB+LkW27HLDtdoeMxHTxZh39DYbPP8UflWXWj9JcdDozF+YDOpQ==",
-      "license": "(MIT OR GPL-2.0)",
-      "dependencies": {
-        "has": "^1.0.3",
-        "is": "^3.2.1"
-      },
-      "engines": {
-        "node": ">=0.4.0"
-      }
-    },
-    "node_modules/object-deep-merge": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/object-deep-merge/-/object-deep-merge-2.0.0.tgz",
-      "integrity": "sha512-3DC3UMpeffLTHiuXSy/UG4NOIYTLlY9u3V82+djSCLYClWobZiS4ivYzpIUWrRY/nfsJ8cWsKyG3QfyLePmhvg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.assign": {
-      "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
-      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0",
-        "has-symbols": "^1.1.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object.fromentries": {
-      "version": "2.0.8",
-      "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz",
-      "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==",
-      "dev": true,
+      "version": "2.0.53",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.53.tgz",
+      "integrity": "sha512-D9UOmYG3UH1V+ENW56t5QXBwJw1YEY18ruVeus89Rw+SyIgjPkCO84bRzO3uNIYosJbNwiabWVn48o3uJLjxFQ==",
       "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.2",
-        "es-object-atoms": "^1.0.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=18"
       }
     },
-    "node_modules/object.groupby": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz",
-      "integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==",
-      "dev": true,
-      "license": "MIT",
+    "node_modules/node.extend": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/node.extend/-/node.extend-2.0.2.tgz",
+      "integrity": "sha512-pDT4Dchl94/+kkgdwyS2PauDFjZG0Hk0IcHIB+LkW27HLDtdoeMxHTxZh39DYbPP8UflWXWj9JcdDozF+YDOpQ==",
+      "license": "(MIT OR GPL-2.0)",
       "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.2"
+        "has": "^1.0.3",
+        "is": "^3.2.1"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=0.4.0"
       }
     },
-    "node_modules/object.values": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz",
-      "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==",
+    "node_modules/object-deep-merge": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/object-deep-merge/-/object-deep-merge-2.0.1.tgz",
+      "integrity": "sha512-aKttDKcU3pyZqKcCkDhsMn70WmZFG2JGDQLP9EcLyTSIFQRCPWLAmBZRLJnrVUrhPG1jETEEbfdgbNtJf1LyMg==",
       "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
       "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
       "engines": {
         "node": ">= 0.4"
       },
@@ -7016,15 +6358,18 @@
       }
     },
     "node_modules/obug": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
-      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.4.tgz",
+      "integrity": "sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==",
       "dev": true,
       "funding": [
         "https://github.com/sponsors/sxzz",
         "https://opencollective.com/debug"
       ],
-      "license": "MIT"
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
     },
     "node_modules/on-finished": {
       "version": "2.4.1",
@@ -7056,22 +6401,20 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/own-keys": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz",
-      "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==",
+    "node_modules/p-event": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/p-event/-/p-event-6.0.1.tgz",
+      "integrity": "sha512-Q6Bekk5wpzW5qIyUP4gdMEujObYstZl6DMMOSenwBvV0BlE5LkDwkjs5yHbZmdCEq2o4RJx4tE1vwxFVf2FG1w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "get-intrinsic": "^1.2.6",
-        "object-keys": "^1.1.1",
-        "safe-push-apply": "^1.0.0"
+        "p-timeout": "^6.1.2"
       },
       "engines": {
-        "node": ">= 0.4"
+        "node": ">=16.17"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/p-limit": {
@@ -7106,17 +6449,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/parent-module": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
-      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+    "node_modules/p-timeout": {
+      "version": "6.1.4",
+      "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-6.1.4.tgz",
+      "integrity": "sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "callsites": "^3.0.0"
-      },
       "engines": {
-        "node": ">=6"
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/parse-imports-exports": {
@@ -7137,18 +6480,31 @@
       "license": "MIT"
     },
     "node_modules/parse5": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
-      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "entities": "^6.0.0"
+        "entities": "^8.0.0"
       },
       "funding": {
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/parse5/node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/parseurl": {
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
@@ -7185,9 +6541,9 @@
       "license": "MIT"
     },
     "node_modules/path-to-regexp": {
-      "version": "0.1.12",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
-      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
       "license": "MIT"
     },
     "node_modules/pathe": {
@@ -7204,12 +6560,11 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
-      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+      "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "engines": {
         "node": ">=12"
       },
@@ -7242,20 +6597,10 @@
         "node": ">=4"
       }
     },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/postcss": {
-      "version": "8.5.6",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
-      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "version": "8.5.26",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz",
+      "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==",
       "dev": true,
       "funding": [
         {
@@ -7273,7 +6618,7 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
+        "nanoid": "^3.3.17",
         "picocolors": "^1.1.1",
         "source-map-js": "^1.2.1"
       },
@@ -7326,9 +6671,9 @@
       }
     },
     "node_modules/prettier": {
-      "version": "3.8.1",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.1.tgz",
-      "integrity": "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==",
+      "version": "3.9.6",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.9.6.tgz",
+      "integrity": "sha512-OpN0zzVdiaiAhxpuuj5efpIS4sY9j7bY6uR5mnj5yPzGkdkjNKSJeUThPb60Jw29QuAZgA4o+/iB49kFiaBX6g==",
       "dev": true,
       "license": "MIT",
       "bin": {
@@ -7341,12 +6686,6 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
-    "node_modules/process-nextick-args": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
-      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
-      "license": "MIT"
-    },
     "node_modules/proxy-addr": {
       "version": "2.0.7",
       "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
@@ -7371,12 +6710,13 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.14.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz",
-      "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==",
+      "version": "6.15.3",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz",
+      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.1.0"
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
       },
       "engines": {
         "node": ">=0.6"
@@ -7385,6 +6725,19 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/quote-js-string": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/quote-js-string/-/quote-js-string-0.1.0.tgz",
+      "integrity": "sha512-Y3NoRtprEEZQD8RfxMCfS0ZTqc4e+i18OrXEXAvpM6TfC/3y+0L5rNbZiSnbBBEkDfFzbpd8o+cE8q3/anjMGA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=22"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/quote-js-string?sponsor=1"
+      }
+    },
     "node_modules/range-parser": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
@@ -7410,53 +6763,17 @@
       }
     },
     "node_modules/readable-stream": {
-      "version": "2.3.8",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
-      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
-      "license": "MIT",
-      "dependencies": {
-        "core-util-is": "~1.0.0",
-        "inherits": "~2.0.3",
-        "isarray": "~1.0.0",
-        "process-nextick-args": "~2.0.0",
-        "safe-buffer": "~5.1.1",
-        "string_decoder": "~1.1.1",
-        "util-deprecate": "~1.0.1"
-      }
-    },
-    "node_modules/readable-stream/node_modules/isarray": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
-      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
-      "license": "MIT"
-    },
-    "node_modules/readable-stream/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "license": "MIT"
-    },
-    "node_modules/reflect.getprototypeof": {
-      "version": "1.0.10",
-      "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
-      "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==",
-      "dev": true,
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
       "license": "MIT",
       "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.9",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0",
-        "get-intrinsic": "^1.2.7",
-        "get-proto": "^1.0.1",
-        "which-builtin-type": "^1.2.1"
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 6"
       }
     },
     "node_modules/regenerate": {
@@ -7477,37 +6794,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/regexp-tree": {
-      "version": "0.1.27",
-      "resolved": "https://registry.npmjs.org/regexp-tree/-/regexp-tree-0.1.27.tgz",
-      "integrity": "sha512-iETxpjK6YoRWJG5o6hXLwvjYAoW+FEZn9os0PD/b6AP6xQwsa/Y7lCVgIixBbUPMfhu+i2LtdeAqVTgGlQarfA==",
-      "dev": true,
-      "license": "MIT",
-      "bin": {
-        "regexp-tree": "bin/regexp-tree"
-      }
-    },
-    "node_modules/regexp.prototype.flags": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
-      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-errors": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "set-function-name": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/regexpu-core": {
       "version": "6.4.0",
       "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz",
@@ -7532,9 +6818,9 @@
       "license": "MIT"
     },
     "node_modules/regjsparser": {
-      "version": "0.13.0",
-      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.0.tgz",
-      "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==",
+      "version": "0.13.2",
+      "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.2.tgz",
+      "integrity": "sha512-NgRBy2Nx/bE+9F27nVHnqcN5HjyLmecqsqx2PJHu3/IEtADD4WuxuXIVExD5PoSDFVrl78dOonfcOe5O+5nbzQ==",
       "license": "BSD-2-Clause",
       "dependencies": {
         "jsesc": "~3.1.0"
@@ -7575,11 +6861,12 @@
       }
     },
     "node_modules/resolve": {
-      "version": "1.22.11",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
-      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
       "license": "MIT",
       "dependencies": {
+        "es-errors": "^1.3.0",
         "is-core-module": "^2.16.1",
         "path-parse": "^1.0.7",
         "supports-preserve-symlinks-flag": "^1.0.0"
@@ -7594,79 +6881,47 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=4"
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
-    "node_modules/rollup": {
-      "version": "4.57.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.57.1.tgz",
-      "integrity": "sha512-oQL6lgK3e2QZeQ7gcgIkS2YZPg5slw37hYufJ3edKlfQSGGm8ICoxswK15ntSzF/a8+h7ekRy7k7oWc3BQ7y8A==",
+    "node_modules/rolldown": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.3.tgz",
+      "integrity": "sha512-rn9wpmxplLf7NLNyCk9FyWh3FM43DbY8jOzCdEPzH7uflhTftRbCEpqi6Ly2osgoU8OwObtmavMbWLaWy4LX7A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@types/estree": "1.0.8"
+        "@oxc-project/types": "=0.143.0",
+        "@rolldown/pluginutils": "^1.0.0"
       },
       "bin": {
-        "rollup": "dist/bin/rollup"
+        "rolldown": "bin/cli.mjs"
       },
       "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.57.1",
-        "@rollup/rollup-android-arm64": "4.57.1",
-        "@rollup/rollup-darwin-arm64": "4.57.1",
-        "@rollup/rollup-darwin-x64": "4.57.1",
-        "@rollup/rollup-freebsd-arm64": "4.57.1",
-        "@rollup/rollup-freebsd-x64": "4.57.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.57.1",
-        "@rollup/rollup-linux-arm-musleabihf": "4.57.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.57.1",
-        "@rollup/rollup-linux-arm64-musl": "4.57.1",
-        "@rollup/rollup-linux-loong64-gnu": "4.57.1",
-        "@rollup/rollup-linux-loong64-musl": "4.57.1",
-        "@rollup/rollup-linux-ppc64-gnu": "4.57.1",
-        "@rollup/rollup-linux-ppc64-musl": "4.57.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.57.1",
-        "@rollup/rollup-linux-riscv64-musl": "4.57.1",
-        "@rollup/rollup-linux-s390x-gnu": "4.57.1",
-        "@rollup/rollup-linux-x64-gnu": "4.57.1",
-        "@rollup/rollup-linux-x64-musl": "4.57.1",
-        "@rollup/rollup-openbsd-x64": "4.57.1",
-        "@rollup/rollup-openharmony-arm64": "4.57.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.57.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.57.1",
-        "@rollup/rollup-win32-x64-gnu": "4.57.1",
-        "@rollup/rollup-win32-x64-msvc": "4.57.1",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/safe-array-concat": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz",
-      "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "get-intrinsic": "^1.2.6",
-        "has-symbols": "^1.1.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">=0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "@rolldown/binding-android-arm64": "1.2.3",
+        "@rolldown/binding-darwin-arm64": "1.2.3",
+        "@rolldown/binding-darwin-x64": "1.2.3",
+        "@rolldown/binding-freebsd-x64": "1.2.3",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.2.3",
+        "@rolldown/binding-linux-arm64-gnu": "1.2.3",
+        "@rolldown/binding-linux-arm64-musl": "1.2.3",
+        "@rolldown/binding-linux-ppc64-gnu": "1.2.3",
+        "@rolldown/binding-linux-s390x-gnu": "1.2.3",
+        "@rolldown/binding-linux-x64-gnu": "1.2.3",
+        "@rolldown/binding-linux-x64-musl": "1.2.3",
+        "@rolldown/binding-openharmony-arm64": "1.2.3",
+        "@rolldown/binding-win32-arm64-msvc": "1.2.3",
+        "@rolldown/binding-win32-x64-msvc": "1.2.3"
       }
     },
     "node_modules/safe-buffer": {
@@ -7689,41 +6944,6 @@
       ],
       "license": "MIT"
     },
-    "node_modules/safe-push-apply": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
-      "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "isarray": "^2.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/safe-regex-test": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
-      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-regex": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
@@ -7748,6 +6968,7 @@
       "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz",
       "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@types/json-schema": "^7.0.9",
         "ajv": "^8.9.0",
@@ -7763,9 +6984,9 @@
       }
     },
     "node_modules/schema-utils/node_modules/ajv": {
-      "version": "8.18.0",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
-      "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
       "license": "MIT",
       "peer": true,
       "dependencies": {
@@ -7784,6 +7005,7 @@
       "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
       "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "fast-deep-equal": "^3.1.3"
       },
@@ -7795,12 +7017,13 @@
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
       "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "license": "MIT"
+      "license": "MIT",
+      "peer": true
     },
     "node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
       "dev": true,
       "license": "ISC",
       "bin": {
@@ -7864,55 +7087,6 @@
         "node": ">= 0.8.0"
       }
     },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-function-name": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
-      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "functions-have-names": "^1.2.3",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-proto": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz",
-      "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "dunder-proto": "^1.0.1",
-        "es-errors": "^1.3.0",
-        "es-object-atoms": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/setprototypeof": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
@@ -7943,14 +7117,14 @@
       }
     },
     "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
         "side-channel-map": "^1.0.1",
         "side-channel-weakmap": "^1.0.2"
       },
@@ -7962,13 +7136,13 @@
       }
     },
     "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
+        "object-inspect": "^1.13.4"
       },
       "engines": {
         "node": ">= 0.4"
@@ -8048,9 +7222,9 @@
       "license": "CC-BY-3.0"
     },
     "node_modules/spdx-expression-parse": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-4.0.0.tgz",
-      "integrity": "sha512-Clya5JIij/7C6bRR22+tnGXbc4VKlibKSVj2iHvVeX5iMW7s1SIQlqu699JkODJJIhh/pUu8L0/VLh8xflD+LQ==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-5.0.0.tgz",
+      "integrity": "sha512-vngmw3Rgn+o2arXNbnZaj5UtOEBuWBfvaI+Wc8GFfykIhA5/vdK9/Sp/XkLv63dykz2rxKDvKEHupF5P0FORcQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -8059,137 +7233,58 @@
       }
     },
     "node_modules/spdx-license-ids": {
-      "version": "3.0.22",
-      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.22.tgz",
-      "integrity": "sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==",
+      "version": "3.0.23",
+      "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.23.tgz",
+      "integrity": "sha512-CWLcCCH7VLu13TgOH+r8p1O/Znwhqv/dbb6lqWy67G+pT1kHmeD/+V36AVb/vq8QMIQwVShJ6Ssl5FPh0fuSdw==",
       "dev": true,
       "license": "CC0-1.0"
     },
     "node_modules/sprintf-js": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
-      "license": "BSD-3-Clause"
-    },
-    "node_modules/stackback": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
-      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/statuses": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
-      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.8"
-      }
-    },
-    "node_modules/std-env": {
-      "version": "3.10.0",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
-      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/stop-iteration-iterator": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
-      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "internal-slot": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/string_decoder": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
-      "license": "MIT",
-      "dependencies": {
-        "safe-buffer": "~5.1.0"
-      }
-    },
-    "node_modules/string_decoder/node_modules/safe-buffer": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "license": "MIT"
-    },
-    "node_modules/string.prototype.trim": {
-      "version": "1.2.10",
-      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz",
-      "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-data-property": "^1.1.4",
-        "define-properties": "^1.2.1",
-        "es-abstract": "^1.23.5",
-        "es-object-atoms": "^1.0.0",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+      "license": "BSD-3-Clause"
     },
-    "node_modules/string.prototype.trimend": {
-      "version": "1.0.9",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz",
-      "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==",
+    "node_modules/stable-hash-x": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/stable-hash-x/-/stable-hash-x-0.2.0.tgz",
+      "integrity": "sha512-o3yWv49B/o4QZk5ZcsALc6t0+eCelPc44zZsLtCQnZPDwFpDYSWcDnrv2TtMmMbQ7uKo3J0HTURCqckw23czNQ==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.2",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=12.0.0"
       }
     },
-    "node_modules/string.prototype.trimstart": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz",
-      "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==",
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
       "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
       "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">= 0.8"
       }
     },
-    "node_modules/strip-bom": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
-      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+    "node_modules/std-env": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+      "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
       "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
       "license": "MIT",
-      "engines": {
-        "node": ">=4"
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
       }
     },
     "node_modules/strip-indent": {
@@ -8205,32 +7300,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/strip-json-comments": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
-      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+    "node_modules/super-regex": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/super-regex/-/super-regex-1.1.0.tgz",
+      "integrity": "sha512-WHkws2ZflZe41zj6AolvvmaTrWds/VuyeYr9iPVv/oQeaIoVxMKaushfFWpOGDT+GuBrM/sVqF8KUCYQlSSTdQ==",
       "dev": true,
       "license": "MIT",
+      "dependencies": {
+        "function-timeout": "^1.0.1",
+        "make-asynchronous": "^1.0.1",
+        "time-span": "^5.1.0"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/supports-color": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-flag": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/supports-preserve-symlinks-flag": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
@@ -8251,13 +7338,29 @@
       "license": "MIT"
     },
     "node_modules/through2": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz",
-      "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/through2/-/through2-3.0.2.tgz",
+      "integrity": "sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.4",
+        "readable-stream": "2 || 3"
+      }
+    },
+    "node_modules/time-span": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/time-span/-/time-span-5.1.0.tgz",
+      "integrity": "sha512-75voc/9G4rDIJleOo4jPvN4/YC4GRZrY8yy1uU4lwrB3XEQbWve8zXoO5No4eFrGcTAMYyoY67p8jRQdtA1HbA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
-        "readable-stream": "~2.3.6",
-        "xtend": "~4.0.1"
+        "convert-hrtime": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/tiny-hashes": {
@@ -8274,9 +7377,9 @@
       "license": "MIT"
     },
     "node_modules/tinyexec": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
-      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.3.0.tgz",
+      "integrity": "sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -8284,14 +7387,14 @@
       }
     },
     "node_modules/tinyglobby": {
-      "version": "0.2.15",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
-      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "fdir": "^6.5.0",
-        "picomatch": "^4.0.3"
+        "picomatch": "^4.0.4"
       },
       "engines": {
         "node": ">=12.0.0"
@@ -8301,9 +7404,9 @@
       }
     },
     "node_modules/tinyrainbow": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
-      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.1.tgz",
+      "integrity": "sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -8311,22 +7414,22 @@
       }
     },
     "node_modules/tldts": {
-      "version": "7.0.23",
-      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.23.tgz",
-      "integrity": "sha512-ASdhgQIBSay0R/eXggAkQ53G4nTJqTXqC2kbaBbdDwM7SkjyZyO0OaaN1/FH7U/yCeqOHDwFO5j8+Os/IS1dXw==",
+      "version": "7.4.10",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.10.tgz",
+      "integrity": "sha512-GgouD1B+sWwvkaEq8vXC15DjQitxbvs12oIXELpconwm+Tg3zfcEv4jgzq3vtKverDXsg3VI8aRgNL2Nra0Iog==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tldts-core": "^7.0.23"
+        "tldts-core": "^7.4.10"
       },
       "bin": {
         "tldts": "bin/cli.js"
       }
     },
     "node_modules/tldts-core": {
-      "version": "7.0.23",
-      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.23.tgz",
-      "integrity": "sha512-0g9vrtDQLrNIiCj22HSe9d4mLVG3g5ph5DZ8zCKBr4OtrspmNB6ss7hVyzArAeE88ceZocIEGkyW1Ime7fxPtQ==",
+      "version": "7.4.10",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.10.tgz",
+      "integrity": "sha512-KnQjp53ZekKgm/r3l+u8kJGGzYgrWdP8+Mql7a4vijh2WE0IrZWspQj/TpTxDho/YxO+AnOZnIjQcCD+q6iJsw==",
       "dev": true,
       "license": "MIT"
     },
@@ -8357,9 +7460,9 @@
       }
     },
     "node_modules/tough-cookie": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.0.tgz",
-      "integrity": "sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==",
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+      "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
       "dev": true,
       "license": "BSD-3-Clause",
       "dependencies": {
@@ -8389,9 +7492,9 @@
       "license": "MIT"
     },
     "node_modules/ts-api-utils": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.4.0.tgz",
-      "integrity": "sha512-3TaVTaAv2gTiMB35i3FiGJaRfwb3Pyn/j3m/bfAvGe8FB7CF6u+LMYqYlDh7reQf7UNvoTvdfAqHGmPGOSsPmA==",
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
+      "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -8401,31 +7504,13 @@
         "typescript": ">=4.8.4"
       }
     },
-    "node_modules/tsconfig-paths": {
-      "version": "3.15.0",
-      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz",
-      "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==",
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@types/json5": "^0.0.29",
-        "json5": "^1.0.2",
-        "minimist": "^1.2.6",
-        "strip-bom": "^3.0.0"
-      }
-    },
-    "node_modules/tsconfig-paths/node_modules/json5": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz",
-      "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "minimist": "^1.2.0"
-      },
-      "bin": {
-        "json5": "lib/cli.js"
-      }
+      "license": "0BSD",
+      "optional": true
     },
     "node_modules/type-check": {
       "version": "0.4.0",
@@ -8440,6 +7525,19 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/type-fest": {
+      "version": "4.41.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-4.41.0.tgz",
+      "integrity": "sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/type-is": {
       "version": "1.6.18",
       "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
@@ -8453,91 +7551,12 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/typed-array-buffer": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz",
-      "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "es-errors": "^1.3.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/typed-array-byte-length": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz",
-      "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.14"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-byte-offset": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz",
-      "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "for-each": "^0.3.3",
-        "gopd": "^1.2.0",
-        "has-proto": "^1.2.0",
-        "is-typed-array": "^1.1.15",
-        "reflect.getprototypeof": "^1.0.9"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/typed-array-length": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz",
-      "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "for-each": "^0.3.3",
-        "gopd": "^1.0.1",
-        "is-typed-array": "^1.1.13",
-        "possible-typed-array-names": "^1.0.0",
-        "reflect.getprototypeof": "^1.0.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/typescript": {
-      "version": "5.9.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
-      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -8556,16 +7575,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.56.1",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.56.1.tgz",
-      "integrity": "sha512-U4lM6pjmBX7J5wk4szltF7I1cGBHXZopnAXCMXb3+fZ3B/0Z3hq3wS/CCUB2NZBNAExK92mCU2tEohWuwVMsDQ==",
+      "version": "8.67.0",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.67.0.tgz",
+      "integrity": "sha512-S2udFs8tCKEKffuJ4TB1idGUZiXdCPGi3IPBGWXarbLQ5UPXORV8QEVzJ4gCRduURMb5EkpNCdjbk0eDIuI8Yg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.56.1",
-        "@typescript-eslint/parser": "8.56.1",
-        "@typescript-eslint/typescript-estree": "8.56.1",
-        "@typescript-eslint/utils": "8.56.1"
+        "@typescript-eslint/eslint-plugin": "8.67.0",
+        "@typescript-eslint/parser": "8.67.0",
+        "@typescript-eslint/typescript-estree": "8.67.0",
+        "@typescript-eslint/utils": "8.67.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -8576,7 +7595,7 @@
       },
       "peerDependencies": {
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-        "typescript": ">=4.8.4 <6.0.0"
+        "typescript": ">=4.8.4 <6.1.0"
       }
     },
     "node_modules/typescript-logic": {
@@ -8594,29 +7613,10 @@
         "typescript-compare": "^0.0.2"
       }
     },
-    "node_modules/unbox-primitive": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
-      "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-bigints": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "which-boxed-primitive": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/undici": {
-      "version": "7.22.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.22.0.tgz",
-      "integrity": "sha512-RqslV2Us5BrllB+JeiZnK4peryVTndy9Dnqq62S3yYRRTj0tFQCwEniUy2167skdGOy3vqRzEvl1Dm4sV2ReDg==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
+      "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -8624,9 +7624,9 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "7.16.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
-      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.29.0.tgz",
+      "integrity": "sha512-vamA8dGlzMwhpyYpQp9d8vka3o4D/yn5I7ez7Or+msDA4bZ8Uh+Zy91WvWf3I73gDAkFha9JcYRqm2li0Npfgg==",
       "dev": true,
       "license": "MIT"
     },
@@ -8679,6 +7679,44 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/unrs-resolver": {
+      "version": "1.12.2",
+      "resolved": "https://registry.npmjs.org/unrs-resolver/-/unrs-resolver-1.12.2.tgz",
+      "integrity": "sha512-dmlRxBJJayXjqTwC+JtF1HhJmgf3ftQ3YejFcZrf4+KKtJv0qDsK1pjqaaVjG7wJ5NJ6UVP1OqRMQ71Z4C3rxQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "napi-postinstall": "^0.3.4"
+      },
+      "funding": {
+        "url": "https://opencollective.com/unrs-resolver"
+      },
+      "optionalDependencies": {
+        "@unrs/resolver-binding-android-arm-eabi": "1.12.2",
+        "@unrs/resolver-binding-android-arm64": "1.12.2",
+        "@unrs/resolver-binding-darwin-arm64": "1.12.2",
+        "@unrs/resolver-binding-darwin-x64": "1.12.2",
+        "@unrs/resolver-binding-freebsd-x64": "1.12.2",
+        "@unrs/resolver-binding-linux-arm-gnueabihf": "1.12.2",
+        "@unrs/resolver-binding-linux-arm-musleabihf": "1.12.2",
+        "@unrs/resolver-binding-linux-arm64-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-arm64-musl": "1.12.2",
+        "@unrs/resolver-binding-linux-loong64-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-loong64-musl": "1.12.2",
+        "@unrs/resolver-binding-linux-ppc64-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-riscv64-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-riscv64-musl": "1.12.2",
+        "@unrs/resolver-binding-linux-s390x-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-x64-gnu": "1.12.2",
+        "@unrs/resolver-binding-linux-x64-musl": "1.12.2",
+        "@unrs/resolver-binding-openharmony-arm64": "1.12.2",
+        "@unrs/resolver-binding-wasm32-wasi": "1.12.2",
+        "@unrs/resolver-binding-win32-arm64-msvc": "1.12.2",
+        "@unrs/resolver-binding-win32-ia32-msvc": "1.12.2",
+        "@unrs/resolver-binding-win32-x64-msvc": "1.12.2"
+      }
+    },
     "node_modules/update-browserslist-db": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
@@ -8761,19 +7799,17 @@
       }
     },
     "node_modules/vite": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
-      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+      "version": "8.2.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.1.tgz",
+      "integrity": "sha512-EU/eS7BH3XROHh2YnBefjM6DBKA6ZeMZEYQbj7NLWg5wHYlhB8B/Mayd5XsgWq+NFYccDOTemRpdETWR6Ka/lw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
-        "esbuild": "^0.27.0",
-        "fdir": "^6.5.0",
-        "picomatch": "^4.0.3",
-        "postcss": "^8.5.6",
-        "rollup": "^4.43.0",
-        "tinyglobby": "^0.2.15"
+        "lightningcss": "^1.33.0",
+        "picomatch": "^4.0.5",
+        "postcss": "^8.5.25",
+        "rolldown": "~1.2.1",
+        "tinyglobby": "^0.2.17"
       },
       "bin": {
         "vite": "bin/vite.js"
@@ -8789,9 +7825,10 @@
       },
       "peerDependencies": {
         "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.4.0",
+        "esbuild": "^0.27.0 || ^0.28.0",
         "jiti": ">=1.21.0",
         "less": "^4.0.0",
-        "lightningcss": "^1.21.0",
         "sass": "^1.70.0",
         "sass-embedded": "^1.70.0",
         "stylus": ">=0.54.8",
@@ -8804,13 +7841,16 @@
         "@types/node": {
           "optional": true
         },
-        "jiti": {
+        "@vitejs/devtools": {
           "optional": true
         },
-        "less": {
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
           "optional": true
         },
-        "lightningcss": {
+        "less": {
           "optional": true
         },
         "sass": {
@@ -8837,31 +7877,31 @@
       }
     },
     "node_modules/vitest": {
-      "version": "4.0.18",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz",
-      "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==",
+      "version": "4.1.10",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",
+      "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/expect": "4.0.18",
-        "@vitest/mocker": "4.0.18",
-        "@vitest/pretty-format": "4.0.18",
-        "@vitest/runner": "4.0.18",
-        "@vitest/snapshot": "4.0.18",
-        "@vitest/spy": "4.0.18",
-        "@vitest/utils": "4.0.18",
-        "es-module-lexer": "^1.7.0",
-        "expect-type": "^1.2.2",
+        "@vitest/expect": "4.1.10",
+        "@vitest/mocker": "4.1.10",
+        "@vitest/pretty-format": "4.1.10",
+        "@vitest/runner": "4.1.10",
+        "@vitest/snapshot": "4.1.10",
+        "@vitest/spy": "4.1.10",
+        "@vitest/utils": "4.1.10",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
         "magic-string": "^0.30.21",
         "obug": "^2.1.1",
         "pathe": "^2.0.3",
         "picomatch": "^4.0.3",
-        "std-env": "^3.10.0",
+        "std-env": "^4.0.0-rc.1",
         "tinybench": "^2.9.0",
         "tinyexec": "^1.0.2",
         "tinyglobby": "^0.2.15",
-        "tinyrainbow": "^3.0.3",
-        "vite": "^6.0.0 || ^7.0.0",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
         "why-is-node-running": "^2.3.0"
       },
       "bin": {
@@ -8877,12 +7917,15 @@
         "@edge-runtime/vm": "*",
         "@opentelemetry/api": "^1.9.0",
         "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
-        "@vitest/browser-playwright": "4.0.18",
-        "@vitest/browser-preview": "4.0.18",
-        "@vitest/browser-webdriverio": "4.0.18",
-        "@vitest/ui": "4.0.18",
+        "@vitest/browser-playwright": "4.1.10",
+        "@vitest/browser-preview": "4.1.10",
+        "@vitest/browser-webdriverio": "4.1.10",
+        "@vitest/coverage-istanbul": "4.1.10",
+        "@vitest/coverage-v8": "4.1.10",
+        "@vitest/ui": "4.1.10",
         "happy-dom": "*",
-        "jsdom": "*"
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
       },
       "peerDependenciesMeta": {
         "@edge-runtime/vm": {
@@ -8903,6 +7946,12 @@
         "@vitest/browser-webdriverio": {
           "optional": true
         },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
         "@vitest/ui": {
           "optional": true
         },
@@ -8911,6 +7960,9 @@
         },
         "jsdom": {
           "optional": true
+        },
+        "vite": {
+          "optional": false
         }
       }
     },
@@ -8927,6 +7979,13 @@
         "node": ">=18"
       }
     },
+    "node_modules/web-worker": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/web-worker/-/web-worker-1.5.0.tgz",
+      "integrity": "sha512-RiMReJrTAiA+mBjGONMnjVDP2u3p9R1vkcGz6gDIrOMT3oGuYwX2WRMYI9ipkphSuE5XKEhydbhNEJh4NY9mlw==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
     "node_modules/webidl-conversions": {
       "version": "8.0.1",
       "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
@@ -8978,95 +8037,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/which-boxed-primitive": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
-      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-bigint": "^1.1.0",
-        "is-boolean-object": "^1.2.1",
-        "is-number-object": "^1.1.1",
-        "is-string": "^1.1.1",
-        "is-symbol": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-builtin-type": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz",
-      "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "function.prototype.name": "^1.1.6",
-        "has-tostringtag": "^1.0.2",
-        "is-async-function": "^2.0.0",
-        "is-date-object": "^1.1.0",
-        "is-finalizationregistry": "^1.1.0",
-        "is-generator-function": "^1.0.10",
-        "is-regex": "^1.2.1",
-        "is-weakref": "^1.0.2",
-        "isarray": "^2.0.5",
-        "which-boxed-primitive": "^1.1.0",
-        "which-collection": "^1.0.2",
-        "which-typed-array": "^1.1.16"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-collection": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
-      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-map": "^2.0.3",
-        "is-set": "^2.0.3",
-        "is-weakmap": "^2.0.2",
-        "is-weakset": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.20",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.20.tgz",
-      "integrity": "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "for-each": "^0.3.5",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/why-is-node-running": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
@@ -9111,21 +8081,28 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/xtend": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
-      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.4"
-      }
-    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
       "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
       "license": "ISC"
     },
+    "node_modules/yaml": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/eemeli"
+      }
+    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
diff --git a/crates/trusted-server-js/lib/package.json b/crates/trusted-server-js/lib/package.json
index 427fef1e1..bd964d5c3 100644
--- a/crates/trusted-server-js/lib/package.json
+++ b/crates/trusted-server-js/lib/package.json
@@ -6,35 +6,46 @@
   "description": "Trusted Server tsjs TypeScript library with queue and simple banner rendering.",
   "scripts": {
     "build": "node build-all.mjs",
+    "print:release-id": "node scripts/print-release-id.mjs",
     "build:prebid-external": "node build-prebid-external.mjs",
+    "generate:aps-contract": "node ../../../scripts/generate-aps-renderer-contract.mjs",
+    "check:aps-contract": "node ../../../scripts/generate-aps-renderer-contract.mjs --check",
+    "check:architecture": "node scripts/check-hard-cutover-absence.mjs",
+    "check:hard-cutover-absence": "node scripts/check-hard-cutover-absence.mjs",
+    "check:bundle": "node scripts/check-bundle-budgets.mjs",
+    "check:concept-audit": "node scripts/check-retired-concept-audit.mjs",
     "dev": "vite build --watch",
     "test": "vitest run",
+    "posttest": "npm run build && npm run test:release",
     "test:watch": "vitest",
-    "lint": "eslint . --max-warnings=0",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:architecture": "node --test test/eslint/no-adtech-globals.test.mjs",
+    "test:release": "node --test test/build/release-v1.test.mjs test/build/generated-fallback.test.mjs",
+    "lint": "npm run test:architecture && eslint . --max-warnings=0",
     "lint:fix": "eslint --fix . --max-warnings=0",
-    "format": "prettier --check \"**/*.{ts,tsx,js,json,css,md}\"",
-    "format:write": "prettier --write \"**/*.{ts,tsx,js,json,css,md}\""
+    "format": "prettier --check \"**/*.{ts,tsx,js,json,css,md}\" \"build-all.mjs\" \"scripts/**/*.mjs\" \"test/build/**/*.mjs\"",
+    "format:write": "prettier --write \"**/*.{ts,tsx,js,json,css,md}\" \"build-all.mjs\" \"scripts/**/*.mjs\" \"test/build/**/*.mjs\""
   },
   "dependencies": {
-    "prebid.js": "^10.26.0"
+    "prebid.js": "10.26.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.13.0",
-    "@types/jsdom": "^27.0.0",
-    "@types/node": "^24.10.0",
-    "@typescript-eslint/eslint-plugin": "^8.6.0",
-    "@typescript-eslint/parser": "^8.6.0",
-    "eslint": "^9.10.0",
+    "@eslint/js": "^10.0.1",
+    "@types/jsdom": "^28.0.3",
+    "@types/node": "^24.13.3",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.8.1",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsdoc": "^62.5.4",
-    "eslint-plugin-unicorn": "^62.0.0",
-    "globals": "^16.0.0",
-    "jsdom": "^28.0.0",
-    "prettier": "^3.2.5",
-    "typescript": "^5.5.4",
-    "typescript-eslint": "^8.56.1",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.8"
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-jsdoc": "^63.3.3",
+    "eslint-plugin-unicorn": "^73.0.0",
+    "globals": "^17.11.0",
+    "jsdom": "^29.1.1",
+    "prettier": "^3.9.6",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.67.0",
+    "vite": "^8.2.1",
+    "vitest": "^4.1.10"
   }
 }
diff --git a/crates/trusted-server-js/lib/scripts/bundle-metrics.d.mts b/crates/trusted-server-js/lib/scripts/bundle-metrics.d.mts
new file mode 100644
index 000000000..e195be978
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/bundle-metrics.d.mts
@@ -0,0 +1,8 @@
+export interface BundleByteMeasurement {
+  readonly rawBytes: number;
+  readonly gzipBytes: number;
+  readonly brotliBytes: number;
+  readonly sha256: string;
+}
+
+export function measureBytes(value: Uint8Array): BundleByteMeasurement;
diff --git a/crates/trusted-server-js/lib/scripts/bundle-metrics.mjs b/crates/trusted-server-js/lib/scripts/bundle-metrics.mjs
new file mode 100644
index 000000000..ea4236efc
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/bundle-metrics.mjs
@@ -0,0 +1,269 @@
+/** Pure deterministic measurement primitives for frozen TSJS transfer budgets. */
+
+import { createHash } from 'node:crypto';
+import {
+  brotliCompress,
+  brotliCompressSync,
+  constants as zlibConstants,
+  gzip,
+  gzipSync,
+} from 'node:zlib';
+
+export const BUNDLE_SET_NAMES = Object.freeze(['minimal', 'reference', 'maximal']);
+export const BUNDLE_SIZE_NAMES = Object.freeze(['rawBytes', 'gzipBytes', 'brotliBytes']);
+export const BUNDLE_SEPARATOR = Buffer.from(';\n', 'utf8');
+export const FIRST_DISPLAY_AGENT_SIZE_CEILING = Object.freeze({
+  rawBytes: 90_000,
+  gzipBytes: 30_000,
+  brotliBytes: 26_000,
+});
+
+/** Return whether one exact first-display composition satisfies every transport ceiling. */
+export function firstDisplayMaskIsPermitted(measurement) {
+  return BUNDLE_SIZE_NAMES.every(
+    (sizeName) =>
+      Number.isSafeInteger(measurement?.[sizeName]) &&
+      measurement[sizeName] >= 0 &&
+      measurement[sizeName] <= FIRST_DISPLAY_AGENT_SIZE_CEILING[sizeName]
+  );
+}
+
+const GZIP_OPTIONS = Object.freeze({ level: 9, mtime: 0 });
+
+function brotliOptions(bytes) {
+  return {
+    params: {
+      [zlibConstants.BROTLI_PARAM_MODE]: zlibConstants.BROTLI_MODE_TEXT,
+      [zlibConstants.BROTLI_PARAM_QUALITY]: 11,
+      [zlibConstants.BROTLI_PARAM_SIZE_HINT]: bytes.byteLength,
+    },
+  };
+}
+
+const REFERENCE_INCLUDE_ORDER = Object.freeze([
+  'always',
+  'creative_guard',
+  'integration:gpt',
+  'integration:prebid',
+  'integration:datadome',
+]);
+
+function fail(message) {
+  throw new Error(`[bundle-metrics] ${message}`);
+}
+
+function isCatalogModule(module) {
+  return (
+    module !== null &&
+    typeof module === 'object' &&
+    typeof module.id === 'string' &&
+    ['takeover', 'deferred'].includes(module.phase) &&
+    (module.trigger === null || module.trigger === 'first_display_or_idle') &&
+    typeof module.include === 'string'
+  );
+}
+
+/** Derive the three semantic transfer sets from catalog phase and inclusion semantics. */
+export function deriveSemanticBundleSetIds(modules) {
+  if (!Array.isArray(modules) || modules.length === 0 || !modules.every(isCatalogModule)) {
+    fail('catalog modules must be a non-empty semantic release catalog');
+  }
+  const catalogIds = modules.map(({ id }) => id);
+  if (new Set(catalogIds).size !== catalogIds.length || catalogIds.includes('core')) {
+    fail('catalog modules contain a duplicate or reserved id');
+  }
+  const takeover = modules.filter(({ phase }) => phase === 'takeover');
+  const reference = REFERENCE_INCLUDE_ORDER.map((include) =>
+    takeover.filter((module) => module.include === include)
+  );
+  if (reference.some((matches) => matches.length !== 1)) {
+    fail('catalog must define every reference predicate exactly once');
+  }
+  return {
+    minimal: [
+      'core',
+      ...takeover.filter(({ include }) => include === 'always').map(({ id }) => id),
+    ],
+    reference: ['core', ...reference.map(([module]) => module.id)],
+    maximal: ['core', ...catalogIds],
+  };
+}
+
+function artifactFileById(artifacts) {
+  if (!Array.isArray(artifacts) || artifacts.length === 0) {
+    fail('release artifacts must be a non-empty array');
+  }
+  const files = new Map();
+  for (const artifact of artifacts) {
+    if (
+      !artifact ||
+      typeof artifact.id !== 'string' ||
+      typeof artifact.file !== 'string' ||
+      files.has(artifact.id)
+    ) {
+      fail('release artifacts contain an invalid or duplicate id');
+    }
+    files.set(artifact.id, artifact.file);
+  }
+  return files;
+}
+
+/** Derive the frozen semantic transfer sets from canonical inventory and catalog data. */
+export function deriveInventorySetFiles(artifacts, modules) {
+  const files = artifactFileById(artifacts);
+  const ids = deriveSemanticBundleSetIds(modules);
+  return Object.fromEntries(
+    BUNDLE_SET_NAMES.map((setName) => [
+      setName,
+      ids[setName].map((id) => {
+        const file = files.get(id);
+        if (!file) fail(`${setName} references missing artifact ${id}`);
+        return file;
+      }),
+    ])
+  );
+}
+
+/** Measure one byte sequence with the frozen raw, gzip, Brotli, and digest algorithms. */
+export function measureBytes(value) {
+  if (!(value instanceof Uint8Array)) fail('measurement input must be bytes');
+  const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  return {
+    rawBytes: bytes.byteLength,
+    gzipBytes: gzipSync(bytes, GZIP_OPTIONS).byteLength,
+    brotliBytes: brotliCompressSync(bytes, brotliOptions(bytes)).byteLength,
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+function compress(compressor, bytes, options) {
+  return new Promise((resolve, reject) => {
+    compressor(bytes, options, (error, compressed) => {
+      if (error) reject(error);
+      else resolve(compressed);
+    });
+  });
+}
+
+/** Measure bytes through the same frozen algorithms without blocking mask generation. */
+export async function measureBytesAsync(value) {
+  if (!(value instanceof Uint8Array)) fail('measurement input must be bytes');
+  const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+  const [gzipBytes, brotliBytes] = await Promise.all([
+    compress(gzip, bytes, GZIP_OPTIONS),
+    compress(brotliCompress, bytes, brotliOptions(bytes)),
+  ]);
+  return {
+    rawBytes: bytes.byteLength,
+    gzipBytes: gzipBytes.byteLength,
+    brotliBytes: brotliBytes.byteLength,
+    sha256: createHash('sha256').update(bytes).digest('hex'),
+  };
+}
+
+/** Concatenate and measure a named inventory set without filesystem or process state. */
+export function measureBundleSet(files, contents) {
+  if (!Array.isArray(files) || files.length === 0 || new Set(files).size !== files.length) {
+    fail('bundle set files must be a non-empty unique array');
+  }
+  if (!(contents instanceof Map)) fail('bundle contents must be a Map');
+  const parts = files.flatMap((file, index) => {
+    const bytes = contents.get(file);
+    if (!(bytes instanceof Uint8Array)) fail(`bundle contents are missing ${file}`);
+    return index === files.length - 1 ? [bytes] : [bytes, BUNDLE_SEPARATOR];
+  });
+  return { files: [...files], ...measureBytes(Buffer.concat(parts)) };
+}
+
+function concatenateBundleSet(files, contents) {
+  if (!Array.isArray(files) || files.length === 0 || new Set(files).size !== files.length) {
+    fail('bundle set files must be a non-empty unique array');
+  }
+  if (!(contents instanceof Map)) fail('bundle contents must be a Map');
+  const parts = files.flatMap((file, index) => {
+    const bytes = contents.get(file);
+    if (!(bytes instanceof Uint8Array)) fail(`bundle contents are missing ${file}`);
+    return index === files.length - 1 ? [bytes] : [bytes, BUNDLE_SEPARATOR];
+  });
+  return Buffer.concat(parts);
+}
+
+/** Enumerate every reachable base mask; APS and Prebid participation require GPT. */
+export function enumerateReachableFirstDisplayMasks(catalog) {
+  if (!Array.isArray(catalog) || catalog.length !== 14) {
+    fail('first-display catalog must contain exactly fourteen rows');
+  }
+  const ids = new Set();
+  const files = new Set();
+  for (const [index, row] of catalog.entries()) {
+    if (
+      !row ||
+      typeof row.id !== 'string' ||
+      row.maskBit !== index ||
+      typeof row.file !== 'string' ||
+      ids.has(row.id) ||
+      files.has(row.file)
+    ) {
+      fail(`first-display catalog row ${index} is invalid`);
+    }
+    ids.add(row.id);
+    files.add(row.file);
+  }
+  if (catalog[0].id !== 'first_display') {
+    fail('first-display catalog bit zero must be the base');
+  }
+  const gpt = catalog.find(({ id }) => id === 'gpt_initial');
+  const renderOwner = catalog.find(({ id }) => id === 'render_owner_initial');
+  const aps = catalog.find(({ id }) => id === 'aps_initial');
+  const prebid = catalog.find(({ id }) => id === 'prebid_initial');
+  if (!gpt) fail('first-display catalog must contain gpt_initial');
+  if (!renderOwner || !aps || !prebid) {
+    fail('first-display catalog must contain render-owner, APS, and Prebid participation');
+  }
+  const required = 1 << catalog[0].maskBit;
+  const maximumMask = 1 << catalog.length;
+  const result = [];
+  for (let mask = 0; mask < maximumMask; mask += 1) {
+    if ((mask & required) !== required) continue;
+    const hasGpt = (mask & (1 << gpt.maskBit)) !== 0;
+    const hasRenderOwner = (mask & (1 << renderOwner.maskBit)) !== 0;
+    const hasAps = (mask & (1 << aps.maskBit)) !== 0;
+    const hasPrebid = (mask & (1 << prebid.maskBit)) !== 0;
+    if ((!hasGpt && (hasRenderOwner || hasAps || hasPrebid)) || (hasAps && !hasRenderOwner)) {
+      continue;
+    }
+    const selected = catalog.filter(({ maskBit }) => (mask & (1 << maskBit)) !== 0);
+    result.push({
+      mask: mask.toString(16).padStart(4, '0'),
+      ids: selected.map(({ id }) => id),
+      files: selected.filter(({ id }) => id !== 'first_display').map(({ file }) => file),
+    });
+  }
+  return result;
+}
+
+/** Measure and hash every reachable first-display mask with bounded async compression work. */
+export async function measureReachableFirstDisplayMasks(catalog, contents, concurrency = 8) {
+  if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > 64) {
+    fail('first-display mask measurement concurrency must be between 1 and 64');
+  }
+  const masks = enumerateReachableFirstDisplayMasks(catalog);
+  const measured = new Array(masks.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < masks.length) {
+      const index = next;
+      next += 1;
+      const mask = masks[index];
+      measured[index] = {
+        ...mask,
+        ...(await measureBytesAsync(
+          mask.files.length === 0 ? Buffer.alloc(0) : concatenateBundleSet(mask.files, contents)
+        )),
+      };
+      measured[index].permitted = firstDisplayMaskIsPermitted(measured[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, masks.length) }, worker));
+  return measured;
+}
diff --git a/crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs b/crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs
new file mode 100644
index 000000000..aacf85a84
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs
@@ -0,0 +1,1667 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+import {
+  BUNDLE_SEPARATOR,
+  BUNDLE_SET_NAMES,
+  BUNDLE_SIZE_NAMES,
+  FIRST_DISPLAY_AGENT_SIZE_CEILING,
+  deriveInventorySetFiles,
+  deriveSemanticBundleSetIds,
+  enumerateReachableFirstDisplayMasks,
+  firstDisplayMaskIsPermitted,
+  measureBundleSet,
+  measureBytes,
+} from './bundle-metrics.mjs';
+import { computeReleaseId, RELEASE_SENTINEL } from './release-v1.mjs';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const libDir = path.resolve(scriptDir, '..');
+const repositoryRoot = path.resolve(libDir, '../../..');
+const defaultBaselinePath = path.join(
+  libDir,
+  'test',
+  'fixtures',
+  'performance',
+  'aps-tsjs-prechange.json'
+);
+const metricsPath = path.resolve(libDir, '..', 'dist', 'tsjs-build-metrics-v1.json');
+const catalogPath = path.resolve(libDir, '..', 'dist', 'tsjs-catalog-v1.json');
+const releasePath = path.resolve(libDir, '..', 'dist', 'tsjs-release-v1.json');
+const releaseCatalogSourcePath = path.join(libDir, 'src', 'kernel', 'release_catalog.ts');
+const repositoryReleaseCatalogPath = 'crates/trusted-server-js/lib/src/kernel/release_catalog.ts';
+const SET_NAMES = BUNDLE_SET_NAMES;
+const SIZE_NAMES = BUNDLE_SIZE_NAMES;
+const TRANSFER_SET_NAMES = Object.freeze(['bootstrap', ...SET_NAMES]);
+const HISTORICAL_EVIDENCE_SHA256 =
+  '53f762603ad49239f1756171440be422e190cc231efafc56cf37a11e1a38ddf4';
+const ROLE_CORRECT_CAPTURE_SHA256 =
+  'f1d73d517e4888ef4dc3a84b34166e9aeb6a2bde99dec1c835f151f4e070f64a';
+const REVIEW_REMEDIATION_CAPTURE_SHA256 =
+  '25ca3892167bac91ae18f4927fce47b49dcdb107814985e354924cec8392572f';
+const BOOTSTRAP_BASELINE = Object.freeze({
+  rawBytes: 19_101,
+  gzipBytes: 5_468,
+  brotliBytes: 4_632,
+});
+export const CANDIDATE_ARCHITECTURE_SIZE_CEILINGS = Object.freeze({
+  bootstrap: Object.freeze({ rawBytes: 48_000, gzipBytes: 16_000, brotliBytes: 14_000 }),
+  firstDisplayAgent: Object.freeze({
+    ...FIRST_DISPLAY_AGENT_SIZE_CEILING,
+  }),
+  referencePersistent: Object.freeze({
+    rawBytes: 524_288,
+    gzipBytes: 163_840,
+    brotliBytes: 131_072,
+  }),
+  maximalTotal: Object.freeze({
+    rawBytes: 1_048_576,
+    gzipBytes: 327_680,
+    brotliBytes: 262_144,
+  }),
+});
+const PRODUCTION_SEAM_PATTERN =
+  /(?:^|\/)(?:tests?|fixtures?|fakes?|no-?op)(?:\/|$)|(?:^|[/_.-])(?:test|fake|no-?op)(?=[/_.-]|$)|ForTest/u;
+const CAPTURE_PACKAGE_LOCK_PATH = 'crates/trusted-server-js/lib/package-lock.json';
+const CAPTURE_TOOL_VERSIONS_PATH = '.tool-versions';
+const CAPTURE_PERFORMANCE_WORKFLOW_PATH = '.github/workflows/tsjs-performance-gate.yml';
+const CAPTURE_BUILD_INPUTS = Object.freeze([
+  CAPTURE_TOOL_VERSIONS_PATH,
+  CAPTURE_PERFORMANCE_WORKFLOW_PATH,
+  'crates/trusted-server-js/lib/src',
+  'crates/trusted-server-js/lib/build-all.mjs',
+  'crates/trusted-server-js/lib/package-lock.json',
+  'crates/trusted-server-js/lib/package.json',
+  'crates/trusted-server-js/lib/tsconfig.json',
+  'crates/trusted-server-js/lib/vite.config.ts',
+]);
+const ROLE_CORRECT_CAPTURE_BUILD_INPUTS = Object.freeze(
+  CAPTURE_BUILD_INPUTS.filter((input) => input !== CAPTURE_PERFORMANCE_WORKFLOW_PATH)
+);
+const CAPTURE_TOOL_PACKAGES = Object.freeze({
+  typescript: 'typescript',
+  vite: 'vite',
+  esbuild: 'esbuild',
+});
+const CURRENT_PROVIDER_SOURCE_OWNERS = Object.freeze({
+  'src/kernel/runtime.ts': 'core',
+  'src/integrations/render_runtime/module.ts': 'core',
+  'src/services/render.ts': 'core',
+  'src/integrations/gpt/module.ts': 'gpt',
+  'src/integrations/gpt/startup.ts': 'gpt',
+  'src/integrations/gpt_diagnostics/store.ts': 'gpt_diagnostics',
+  'src/integrations/osano/consent.ts': 'osano_consent',
+  'src/adapters/prebid.ts': 'prebid',
+  'src/integrations/prebid/module.ts': 'prebid',
+  'src/integrations/prebid/startup.ts': 'prebid',
+  'src/integrations/render_runtime/prebid_selection.ts': 'core',
+  'src/integrations/sourcepoint/consent.ts': 'sourcepoint_consent',
+});
+const CURRENT_EXACT_SOURCE_OWNERS = Object.freeze({
+  'src/first_display/agent.ts': 'bootstrap',
+  'src/first_display/base_marker.ts': 'first_display',
+  'src/first_display/leaf/browser_route_owner.ts': 'bootstrap',
+  'src/first_display/leaf/projection.ts': 'bootstrap',
+  'src/first_display/render_journal.ts': 'render_owner_initial',
+  'src/first_display/render_bridge.ts': 'aps_initial',
+  'src/core/bootstrap.ts': 'bootstrap',
+  'src/core/contracts/server_boot_transport.ts': 'bootstrap',
+  'src/core/contracts/boot.ts': 'core',
+  'src/core/contracts/integration_configs.ts': 'core',
+  'src/core/contracts/sha256.ts': 'core',
+  'src/core/types.ts': 'core',
+  'src/adapters/googletag.ts': 'gpt',
+  'src/adapters/messaging.ts': 'core',
+  'src/composition/runtime_transport.ts': 'core',
+  'src/services/auction_batch.ts': 'core',
+  'src/services/context.ts': 'core',
+  'src/services/projections.ts': 'core',
+  'src/services/puc_bridge.ts': 'gpt',
+  'src/services/reservations.ts': 'core',
+  'src/services/slots.ts': 'gpt',
+  'src/services/targeting.ts': 'gpt',
+  'src/integrations/aps/index.ts': 'aps',
+  'src/integrations/aps/documents.ts': 'aps',
+  'src/integrations/aps/module.ts': 'aps',
+  'src/integrations/aps/render.ts': 'aps',
+  'src/integrations/creative/index.ts': 'creative',
+  'src/integrations/creative/module.ts': 'creative',
+  'src/integrations/datadome/index.ts': 'datadome',
+  'src/integrations/datadome/module.ts': 'datadome',
+  'src/integrations/datadome/script_guard.ts': 'datadome',
+  'src/integrations/didomi/index.ts': 'didomi',
+  'src/integrations/didomi/module.ts': 'didomi',
+  'src/integrations/google_tag_manager/index.ts': 'google_tag_manager',
+  'src/integrations/google_tag_manager/module.ts': 'google_tag_manager',
+  'src/integrations/google_tag_manager/script_guard.ts': 'google_tag_manager',
+  'src/integrations/gpt/diagnostics_facts.ts': 'gpt',
+  'src/integrations/gpt/index.ts': 'gpt',
+  'src/integrations/gpt/later.ts': 'gpt_later',
+  'src/integrations/gpt/script_guard.ts': 'gpt',
+  'src/integrations/gpt_diagnostics/badges.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/binding.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/data_api.ts': 'gpt_diagnostics',
+  'src/integrations/gpt_diagnostics/exhaustive.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/index.ts': 'gpt_diagnostics',
+  'src/integrations/gpt_diagnostics/module.ts': 'gpt_diagnostics',
+  'src/integrations/gpt_diagnostics/observer.ts': 'gpt_diagnostics',
+  'src/integrations/gpt_diagnostics/overlay.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/presentation.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/presentation_helpers.ts': 'diagnostics_presentation',
+  'src/integrations/gpt_diagnostics/slot_size_observer.ts': 'diagnostics_presentation',
+  'src/integrations/lockr/index.ts': 'lockr',
+  'src/integrations/lockr/module.ts': 'lockr',
+  'src/integrations/lockr/script_guard.ts': 'lockr',
+  'src/integrations/osano/consent_mirror.ts': 'osano_consent',
+  'src/integrations/osano/lifecycle.ts': 'osano_lifecycle',
+  'src/integrations/osano/module.ts': 'osano_consent',
+  'src/integrations/permutive/context.ts': 'permutive_context',
+  'src/integrations/permutive/lifecycle.ts': 'permutive_lifecycle',
+  'src/integrations/permutive/module.ts': 'permutive_context',
+  'src/integrations/permutive/script_guard.ts': 'permutive_context',
+  'src/integrations/permutive/segments.ts': 'permutive_context',
+  'src/integrations/prebid/index.ts': 'prebid',
+  'src/integrations/prebid/later.ts': 'prebid_later',
+  'src/integrations/prebid/refresh.ts': 'prebid_later',
+  'src/integrations/render_runtime/transport_marker.ts': 'render_runtime',
+  'src/integrations/sourcepoint/consent_mirror.ts': 'sourcepoint_consent',
+  'src/integrations/sourcepoint/lifecycle.ts': 'sourcepoint_lifecycle',
+  'src/integrations/sourcepoint/module.ts': 'sourcepoint_consent',
+  'src/integrations/sourcepoint/script_guard.ts': 'sourcepoint_consent',
+  'src/integrations/testlight/index.ts': 'testlight',
+  'src/integrations/testlight/module.ts': 'testlight',
+});
+const CURRENT_SHARED_SOURCE_OWNER_POLICIES = Object.freeze({
+  'src/core/auction.ts': Object.freeze(['core']),
+  'src/core/config.ts': Object.freeze(['bootstrap', 'core']),
+  'src/core/contracts/aps_renderer.ts': Object.freeze(['bootstrap', 'core', 'aps']),
+  'src/core/contracts/bounded_string.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'prebid',
+    'prebid_later',
+  ]),
+  'src/core/contracts/fallback_ad_units.ts': Object.freeze(['bootstrap']),
+  'src/core/contracts/auction_projection.ts': Object.freeze(['core', 'prebid', 'prebid_later']),
+  'src/core/contracts/generated/renderer_validator_v1.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'aps',
+  ]),
+  'src/core/contracts/request_ads.ts': Object.freeze(['bootstrap', 'core']),
+  'src/core/index.ts': Object.freeze(['core']),
+  'src/core/log.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'creative_initial',
+    'creative',
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'gpt',
+    'gpt_diagnostics',
+    'lockr',
+    'osano_consent',
+    'permutive_context',
+    'sourcepoint_consent',
+    'testlight',
+    'diagnostics_presentation',
+  ]),
+  'src/core/puc_shell.ts': Object.freeze(['gpt']),
+  'src/core/queue.ts': Object.freeze(['bootstrap', 'core']),
+  'src/core/release_id.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'aps',
+    'creative',
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'gpt',
+    'gpt_diagnostics',
+    'lockr',
+    'osano_consent',
+    'permutive_context',
+    'sourcepoint_consent',
+    'prebid',
+    'testlight',
+    'diagnostics_presentation',
+    'gpt_later',
+    'osano_lifecycle',
+    'permutive_lifecycle',
+    'prebid_later',
+    'sourcepoint_lifecycle',
+  ]),
+  'src/core/registry.ts': Object.freeze(['bootstrap', 'core']),
+  'src/core/release.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'aps',
+    'creative',
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'gpt',
+    'gpt_diagnostics',
+    'lockr',
+    'osano_consent',
+    'permutive_context',
+    'sourcepoint_consent',
+    'prebid',
+    'testlight',
+    'diagnostics_presentation',
+    'gpt_later',
+    'osano_lifecycle',
+    'permutive_lifecycle',
+    'prebid_later',
+    'sourcepoint_lifecycle',
+  ]),
+  'src/core/render.ts': Object.freeze(['core']),
+  'src/core/styles/normalize.css?inline': Object.freeze(['core']),
+  'src/core/templates/iframe.html?raw': Object.freeze(['core']),
+  'src/core/trace.ts': Object.freeze(['core', 'gpt_diagnostics']),
+  'src/integrations/creative/click.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/integrations/creative/dynamic_src_guard.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/integrations/creative/iframe.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/integrations/creative/image.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/integrations/creative/proxy_sign.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/integrations/creative/startup.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/kernel/contracts/message_protocol.ts': Object.freeze(['core', 'gpt']),
+  'src/kernel/contracts/release_capacity.ts': Object.freeze(['core']),
+  'src/kernel/contracts/puc_dynamic_owner.ts': Object.freeze(['render_owner_initial', 'gpt']),
+  'src/kernel/diagnostics.ts': Object.freeze(['core']),
+  'src/kernel/disposable.ts': Object.freeze(['core', 'gpt']),
+  'src/kernel/fallback.ts': Object.freeze(['bootstrap', 'core']),
+  'src/kernel/fallback_surface.ts': Object.freeze(['bootstrap', 'core']),
+  'src/kernel/identity.ts': Object.freeze(['first_display', 'core']),
+  'src/kernel/integration_registry.ts': Object.freeze(['core']),
+  'src/kernel/lifecycle_module.ts': Object.freeze([
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'lockr',
+    'testlight',
+  ]),
+  'src/kernel/phase_loader.ts': Object.freeze(['core']),
+  'src/kernel/release_catalog.ts': Object.freeze([
+    'bootstrap',
+    'core',
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'lockr',
+    'testlight',
+  ]),
+  'src/kernel/sessions.ts': Object.freeze(['core']),
+  'src/shared/async.ts': Object.freeze(['creative_initial', 'creative', 'datadome']),
+  'src/shared/first_display_contracts.ts': Object.freeze(['bootstrap', 'core']),
+  'src/shared/first_display_handoff.ts': Object.freeze(['bootstrap', 'first_display', 'core']),
+  'src/shared/first_display_registration.ts': Object.freeze(['bootstrap', 'first_display']),
+  'src/shared/first_display_transaction.ts': Object.freeze(['bootstrap']),
+  'src/shared/integration_config_validators.ts': Object.freeze([
+    'first_display',
+    'aps',
+    'datadome',
+    'google_tag_manager',
+    'gpt',
+    'lockr',
+    'osano_consent',
+    'permutive_context',
+    'sourcepoint_consent',
+    'prebid',
+    'testlight',
+    'gpt_later',
+    'osano_lifecycle',
+    'permutive_lifecycle',
+    'prebid_later',
+    'sourcepoint_lifecycle',
+  ]),
+  'src/shared/beacon_guard.ts': Object.freeze(['google_tag_manager']),
+  'src/shared/dom_insertion_dispatcher.ts': Object.freeze([
+    'datadome',
+    'google_tag_manager',
+    'gpt',
+    'lockr',
+    'permutive_context',
+    'sourcepoint_consent',
+  ]),
+  'src/shared/globals.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/shared/gpt_diagnostics.ts': Object.freeze(['gpt', 'gpt_diagnostics']),
+  'src/shared/origin.ts': Object.freeze(['core', 'creative_initial', 'creative']),
+  'src/shared/realm.ts': Object.freeze(['gpt_diagnostics', 'diagnostics_presentation']),
+  'src/shared/scheduler.ts': Object.freeze(['creative_initial', 'creative']),
+  'src/shared/script_guard.ts': Object.freeze([
+    'datadome',
+    'google_tag_manager',
+    'gpt',
+    'lockr',
+    'permutive_context',
+    'sourcepoint_consent',
+  ]),
+  'src/shared/takeover.ts': Object.freeze([
+    'bootstrap',
+    'first_display',
+    'core',
+    'aps',
+    'creative',
+    'datadome',
+    'didomi',
+    'google_tag_manager',
+    'gpt',
+    'lockr',
+    'osano_consent',
+    'permutive_context',
+    'sourcepoint_consent',
+    'prebid',
+    'testlight',
+  ]),
+});
+const CAPABILITY_PATTERN = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*\.v[1-9][0-9]*$/u;
+const CAPABILITY_PREDICATE_PATTERN = /^[a-z][a-z0-9_]{0,63}$/u;
+
+function fail(message) {
+  throw new Error(`[bundle-budgets] ${message}`);
+}
+
+function readJson(file, label) {
+  if (!fs.existsSync(file)) fail(`${label} does not exist: ${file}`);
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (error) {
+    fail(`${label} is not valid JSON (${file}): ${error instanceof Error ? error.message : error}`);
+  }
+}
+
+function assertPositiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) fail(`${label} must be a positive integer`);
+}
+
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  if (value !== null && typeof value === 'object') {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+/** Hash JSON with recursive key ordering while preserving array order and values. */
+export function canonicalJsonSha256(value) {
+  return createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+
+/** Evaluate the authored catalog source without importing production TS at runtime. */
+function loadAuthoredCatalogModule(source) {
+  const transpiled = ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2022,
+    },
+    fileName: releaseCatalogSourcePath,
+  }).outputText;
+  const module = { exports: {} };
+  vm.runInNewContext(
+    transpiled,
+    { module, exports: module.exports, Object, Set, TypeError },
+    {
+      filename: releaseCatalogSourcePath,
+    }
+  );
+  return module.exports;
+}
+
+export function loadAuthoredReleaseCatalog(
+  source = fs.readFileSync(releaseCatalogSourcePath, 'utf8')
+) {
+  const authored = loadAuthoredCatalogModule(source);
+  const catalog = authored.RELEASE_CATALOG;
+  const validateCatalog = authored.validateReleaseCatalog;
+  if (!Array.isArray(catalog) || typeof validateCatalog !== 'function') {
+    fail('authored release catalog did not export its catalog and validator');
+  }
+  try {
+    validateCatalog(catalog);
+  } catch (error) {
+    fail(
+      `authored release catalog failed self-validation: ${error instanceof Error ? error.message : error}`
+    );
+  }
+  return JSON.parse(JSON.stringify(catalog));
+}
+
+/** Load the complete authored first-display catalog from the same source authority. */
+export function loadAuthoredFirstDisplayCatalog(
+  source = fs.readFileSync(releaseCatalogSourcePath, 'utf8')
+) {
+  const catalog = loadAuthoredCatalogModule(source).FIRST_DISPLAY_CATALOG;
+  if (!Array.isArray(catalog)) {
+    fail('authored release catalog did not export its first-display catalog');
+  }
+  return JSON.parse(JSON.stringify(catalog));
+}
+
+function loadHistoricalReleaseCatalog(capture, label) {
+  const sha = capture?.source?.sha;
+  let source;
+  try {
+    source = execFileSync('git', ['show', `${sha}:${repositoryReleaseCatalogPath}`], {
+      cwd: repositoryRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    fail(`${label} authored release catalog is missing at its captured source SHA`);
+  }
+  return loadAuthoredReleaseCatalog(source).map((entry) => ({
+    ...entry,
+    phase: entry.phase === 'critical' ? 'takeover' : entry.phase,
+  }));
+}
+
+/** Authenticate the immutable inputs and tool versions recorded by a historical capture. */
+export function validateCaptureSourceProvenance(
+  capture,
+  { buildInputs = CAPTURE_BUILD_INPUTS, npmAuthorityCapture = capture } = {}
+) {
+  const sha = capture?.source?.sha;
+  if (typeof sha !== 'string' || !/^[0-9a-f]{40}$/u.test(sha)) {
+    fail('capture source SHA is invalid');
+  }
+
+  try {
+    if (
+      execFileSync('git', ['cat-file', '-t', sha], {
+        cwd: repositoryRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim() !== 'commit'
+    ) {
+      fail('capture source SHA does not identify a commit');
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('[bundle-budgets]')) throw error;
+    fail('capture source SHA does not identify a commit');
+  }
+
+  for (const input of buildInputs) {
+    try {
+      execFileSync('git', ['cat-file', '-e', `${sha}:${input}`], {
+        cwd: repositoryRoot,
+        stdio: 'ignore',
+      });
+    } catch {
+      fail(`captured build input does not exist at source SHA: ${input}`);
+    }
+  }
+
+  let packageLockBytes;
+  try {
+    packageLockBytes = execFileSync('git', ['show', `${sha}:${CAPTURE_PACKAGE_LOCK_PATH}`], {
+      cwd: repositoryRoot,
+    });
+  } catch {
+    fail('captured package-lock does not exist at source SHA');
+  }
+
+  const packageLockSha256 = createHash('sha256').update(packageLockBytes).digest('hex');
+  if (capture?.tools?.packageLockSha256 !== packageLockSha256) {
+    fail('captured packageLockSha256 does not match package-lock bytes at source SHA');
+  }
+
+  let packageLock;
+  try {
+    packageLock = JSON.parse(packageLockBytes.toString('utf8'));
+  } catch {
+    fail('captured package-lock is not valid JSON');
+  }
+
+  for (const [tool, packageName] of Object.entries(CAPTURE_TOOL_PACKAGES)) {
+    const resolvedVersion = packageLock.packages?.[`node_modules/${packageName}`]?.version;
+    if (capture?.tools?.[tool] !== resolvedVersion) {
+      fail(`captured ${tool} version does not match the resolved package-lock version`);
+    }
+  }
+
+  let toolVersions;
+  try {
+    toolVersions = execFileSync('git', ['show', `${sha}:${CAPTURE_TOOL_VERSIONS_PATH}`], {
+      cwd: repositoryRoot,
+      encoding: 'utf8',
+    });
+  } catch {
+    fail('captured .tool-versions does not exist at source SHA');
+  }
+
+  const nodejsEntries = toolVersions
+    .split(/\r?\n/u)
+    .filter((line) => /^\s*nodejs(?:\s|$)/u.test(line));
+  const nodejsMatch = nodejsEntries[0]?.match(/^\s*nodejs\s+(\S+)\s*$/u);
+  if (
+    nodejsEntries.length !== 1 ||
+    nodejsMatch === null ||
+    capture?.tools?.node !== `v${nodejsMatch[1]}`
+  ) {
+    fail('captured node version does not match the exact .tool-versions nodejs pin');
+  }
+
+  if (capture?.tools?.npm !== npmAuthorityCapture?.tools?.npm) {
+    fail('captured npm version does not match its authenticated npm authority');
+  }
+  const npmAuthoritySha = npmAuthorityCapture?.source?.sha;
+  if (typeof npmAuthoritySha !== 'string' || !/^[0-9a-f]{40}$/u.test(npmAuthoritySha)) {
+    fail('captured npm authority source SHA is invalid');
+  }
+  let performanceWorkflow;
+  try {
+    performanceWorkflow = execFileSync(
+      'git',
+      ['show', `${npmAuthoritySha}:${CAPTURE_PERFORMANCE_WORKFLOW_PATH}`],
+      {
+        cwd: repositoryRoot,
+        encoding: 'utf8',
+      }
+    );
+  } catch {
+    fail('captured TSJS performance workflow does not exist at source SHA');
+  }
+
+  const npmVersionAssertions = performanceWorkflow
+    .split(/\r?\n/u)
+    .filter((line) => line.includes('npm --version'));
+  const npmVersionMatch = npmVersionAssertions[0]?.match(
+    /^\s*test "\$\(npm --version\)" = "([^"\s]+)"\s*$/u
+  );
+  if (
+    npmVersionAssertions.length !== 1 ||
+    npmVersionMatch === null ||
+    capture?.tools?.npm !== npmVersionMatch[1]
+  ) {
+    fail('captured npm version does not match the exact single workflow assertion');
+  }
+}
+
+/** Authenticate both linked frozen transfer captures at their recorded source commits. */
+export function validateFrozenCaptureProvenance(intermediate, capture) {
+  validateCaptureSourceProvenance(intermediate, {
+    buildInputs: ROLE_CORRECT_CAPTURE_BUILD_INPUTS,
+    npmAuthorityCapture: capture,
+  });
+  validateCaptureSourceProvenance(capture);
+}
+
+function validateBudgetSets(sets, label) {
+  if (!sets || typeof sets !== 'object' || Array.isArray(sets)) {
+    fail(`${label} must be an object`);
+  }
+  for (const setName of SET_NAMES) {
+    const set = sets[setName];
+    if (!set || typeof set !== 'object' || Array.isArray(set)) {
+      fail(`${label}.${setName} must be an object`);
+    }
+    for (const sizeName of SIZE_NAMES) {
+      assertPositiveInteger(set[sizeName], `${label}.${setName}.${sizeName}`);
+    }
+  }
+}
+
+function validateMetricSets(sets, label) {
+  validateBudgetSets(sets, label);
+  for (const setName of SET_NAMES) {
+    const set = sets[setName];
+    if (!Array.isArray(set.files) || set.files.length === 0) {
+      fail(`${label}.${setName}.files must be a non-empty array`);
+    }
+    for (const [index, file] of set.files.entries()) {
+      if (typeof file !== 'string' || !/^tsjs-[a-z0-9_]+\.js$/.test(file)) {
+        fail(`${label}.${setName}.files[${index}] is not a canonical TSJS bundle filename`);
+      }
+    }
+    if (new Set(set.files).size !== set.files.length) {
+      fail(`${label}.${setName}.files contains a duplicate`);
+    }
+    if (typeof set.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(set.sha256)) {
+      fail(`${label}.${setName}.sha256 must be 64 lowercase hexadecimal characters`);
+    }
+  }
+}
+
+/** Validate semantic set membership against exact release artifact ownership. */
+export function validateSemanticBundleSets(metrics, release, catalog) {
+  if (catalog?.version !== 1) fail('catalog.version must equal 1');
+  if (!Array.isArray(catalog.firstDisplay) || catalog.firstDisplay.length !== 14) {
+    fail('catalog.firstDisplay must contain the closed fourteen-row inventory');
+  }
+  if (release?.version !== 1 || !Array.isArray(release.artifacts)) {
+    fail('release inventory is invalid');
+  }
+  if (!metrics?.sets) fail('build metrics sets are missing');
+  validateMetricSets(metrics.sets, 'buildMetrics.sets');
+  if (
+    !metrics.bootstrap ||
+    metrics.bootstrap.file !== 'tsjs-bootstrap.js' ||
+    typeof metrics.bootstrap.sha256 !== 'string' ||
+    !/^[0-9a-f]{64}$/.test(metrics.bootstrap.sha256)
+  ) {
+    fail('buildMetrics.bootstrap must identify the generated bootstrap exactly once');
+  }
+  for (const sizeName of SIZE_NAMES) {
+    assertPositiveInteger(metrics.bootstrap[sizeName], `buildMetrics.bootstrap.${sizeName}`);
+  }
+  const expected = deriveSemanticBundleSetIds(catalog.modules);
+  const files = new Map();
+  const ids = new Set();
+  for (const artifact of release.artifacts) {
+    if (
+      !artifact ||
+      typeof artifact !== 'object' ||
+      typeof artifact.id !== 'string' ||
+      typeof artifact.file !== 'string' ||
+      !['bootstrap', 'first_display_base', 'first_display_slice', 'core', 'integration'].includes(
+        artifact.role
+      ) ||
+      ids.has(artifact.id) ||
+      files.has(artifact.file)
+    ) {
+      fail('release inventory contains an invalid or duplicate artifact');
+    }
+    ids.add(artifact.id);
+    files.set(artifact.file, artifact);
+  }
+  const expectedArtifacts = [
+    { id: 'bootstrap', role: 'bootstrap', file: 'tsjs-bootstrap.js' },
+    ...catalog.firstDisplay.map(({ id }, index) => ({
+      id,
+      role: index === 0 ? 'first_display_base' : 'first_display_slice',
+      file: `tsjs-${id}.js`,
+    })),
+    { id: 'core', role: 'core', file: 'tsjs-core.js' },
+    ...catalog.modules.map(({ id }) => ({
+      id,
+      role: 'integration',
+      file: `tsjs-${id}.js`,
+    })),
+  ];
+  if (release.artifacts.length !== expectedArtifacts.length) {
+    fail('release inventory does not contain the exact catalog artifact count');
+  }
+  for (const [index, expectedArtifact] of expectedArtifacts.entries()) {
+    const artifact = release.artifacts[index];
+    if (
+      artifact.id !== expectedArtifact.id ||
+      artifact.role !== expectedArtifact.role ||
+      artifact.file !== expectedArtifact.file
+    ) {
+      fail(
+        `release inventory artifact ${index} must be ${expectedArtifact.role}/${expectedArtifact.id}/${expectedArtifact.file}`
+      );
+    }
+  }
+
+  const actual = {};
+  for (const setName of SET_NAMES) {
+    const setIds = metrics.sets[setName].files.map((file) => {
+      const artifact = files.get(file);
+      if (!artifact || !['core', 'integration'].includes(artifact.role)) {
+        fail(`buildMetrics.sets.${setName} contains an unknown or non-persistent artifact`);
+      }
+      return artifact.id;
+    });
+    if (new Set(setIds).size !== setIds.length) {
+      fail(`buildMetrics.sets.${setName} contains a multiply counted artifact`);
+    }
+    if (JSON.stringify(setIds) !== JSON.stringify(expected[setName])) {
+      fail(
+        `buildMetrics.sets.${setName} has semantic ids ${JSON.stringify(setIds)}; expected ${JSON.stringify(expected[setName])}`
+      );
+    }
+    actual[setName] = setIds;
+  }
+  return actual;
+}
+
+function canonicalSourcePath(file) {
+  return typeof file === 'string' ? file.replaceAll('\\', '/') : '';
+}
+
+function currentExactSourceOwner(source) {
+  if (Object.hasOwn(CURRENT_PROVIDER_SOURCE_OWNERS, source)) {
+    return { kind: 'provider', owner: CURRENT_PROVIDER_SOURCE_OWNERS[source] };
+  }
+  if (Object.hasOwn(CURRENT_EXACT_SOURCE_OWNERS, source)) {
+    return { kind: 'phase', owner: CURRENT_EXACT_SOURCE_OWNERS[source] };
+  }
+  if (source.startsWith('src/integrations/gpt_diagnostics/presentation/')) {
+    return { kind: 'phase', owner: 'diagnostics_presentation' };
+  }
+  if (source.startsWith('src/integrations/gpt/later/')) {
+    return { kind: 'phase', owner: 'gpt_later' };
+  }
+  if (source.startsWith('src/integrations/prebid/later/')) {
+    return { kind: 'phase', owner: 'prebid_later' };
+  }
+  return undefined;
+}
+
+function readCurrentSourceGraph(metrics, release) {
+  if (!Array.isArray(metrics?.modules) || !Array.isArray(release?.artifacts)) {
+    fail('build metrics module graph or release inventory is missing');
+  }
+  const productionArtifacts = release.artifacts.filter(({ role }) => role !== 'bootstrap');
+  if (metrics.modules.length !== productionArtifacts.length) {
+    fail('build metrics module graph does not classify every production artifact exactly once');
+  }
+  const rawEntries = [
+    {
+      artifact: release.artifacts.find(({ role }) => role === 'bootstrap'),
+      module: metrics.bootstrap,
+    },
+    ...metrics.modules.map((module, index) => ({
+      artifact: productionArtifacts[index],
+      module,
+    })),
+  ];
+  const graphEntries = [];
+  const ownersBySource = new Map();
+  const contributions = [];
+  for (const [index, { artifact, module }] of rawEntries.entries()) {
+    if (
+      !artifact ||
+      !module ||
+      typeof module !== 'object' ||
+      module.file !== artifact.file ||
+      typeof module.entry !== 'string' ||
+      !Array.isArray(module.sources)
+    ) {
+      fail(`build metrics module graph entry ${index} is invalid or out of release order`);
+    }
+    const entry = canonicalSourcePath(module.entry);
+    const sources = new Set();
+    for (const [sourceIndex, source] of module.sources.entries()) {
+      const sourceFile = canonicalSourcePath(source?.file);
+      if (
+        !sourceFile.startsWith('src/') ||
+        !Number.isSafeInteger(source?.renderedBytes) ||
+        source.renderedBytes < 0 ||
+        sources.has(sourceFile)
+      ) {
+        fail(`build metrics module graph ${module.file}.sources[${sourceIndex}] is invalid`);
+      }
+      sources.add(sourceFile);
+      const owners = ownersBySource.get(sourceFile) ?? [];
+      if (owners.includes(artifact.id)) {
+        fail(`build metrics source ${sourceFile} repeats owner ${artifact.id}`);
+      }
+      owners.push(artifact.id);
+      ownersBySource.set(sourceFile, owners);
+      contributions.push({
+        artifact: artifact.id,
+        source: sourceFile,
+        renderedBytes: source.renderedBytes,
+      });
+    }
+    if (sources.size === 0 || !sources.has(entry)) {
+      fail(`build metrics module graph ${module.file} does not contain its entry source`);
+    }
+    graphEntries.push({ artifact, module, entry, sources });
+  }
+  return {
+    graphEntries,
+    sourceOwners: Object.fromEntries(ownersBySource),
+    contributions,
+  };
+}
+
+/** Build the frozen attribution report used to review production bundle growth. */
+export function buildProductionGraphReport(metrics, release) {
+  const currentGraph = readCurrentSourceGraph(metrics, release);
+  const largestContributions = [...currentGraph.contributions]
+    .sort(
+      (left, right) =>
+        right.renderedBytes - left.renderedBytes ||
+        left.source.localeCompare(right.source) ||
+        left.artifact.localeCompare(right.artifact)
+    )
+    .slice(0, 20);
+  const repeatedAttributions = Object.entries(currentGraph.sourceOwners)
+    .filter(([, owners]) => owners.length > 1)
+    .map(([source, owners]) => ({ source, owners }))
+    .sort((left, right) => left.source.localeCompare(right.source));
+  return { largestContributions, repeatedAttributions };
+}
+
+function findTakeoverDeferredViolations(currentGraph, release) {
+  const artifactsById = new Map(release.artifacts.map((artifact) => [artifact.id, artifact]));
+  const violations = [];
+  for (const [source, owners] of Object.entries(currentGraph.sourceOwners)) {
+    const policy = currentExactSourceOwner(source);
+    if (policy && artifactsById.get(policy.owner)?.phase === 'deferred') {
+      for (const owner of owners) {
+        const artifact = artifactsById.get(owner);
+        if (artifact?.role === 'core' || artifact?.phase === 'takeover') {
+          violations.push(`${owner} reaches deferred-owned source ${source}`);
+        }
+      }
+    }
+  }
+  return violations;
+}
+
+function validateCurrentSourceOwnership(currentGraph, release) {
+  const artifactsById = new Map(release.artifacts.map((artifact) => [artifact.id, artifact]));
+  const artifactIds = new Set(artifactsById.keys());
+  const violations = findTakeoverDeferredViolations(currentGraph, release);
+  for (const source of Object.keys(CURRENT_PROVIDER_SOURCE_OWNERS)) {
+    if (!Object.hasOwn(currentGraph.sourceOwners, source)) {
+      violations.push(`current provider source is missing: ${source}`);
+    }
+  }
+  for (const [source, owners] of Object.entries(currentGraph.sourceOwners)) {
+    const firstDisplaySource = source.startsWith('src/first_display/');
+    const firstDisplayOwners = owners.filter((owner) =>
+      ['first_display_base', 'first_display_slice'].includes(artifactsById.get(owner)?.role)
+    );
+    if (firstDisplaySource) {
+      const policy = currentExactSourceOwner(source);
+      for (const owner of owners) {
+        if (!firstDisplayOwners.includes(owner) && owner !== policy?.owner) {
+          violations.push(`${owner} reaches first-display source ${source}`);
+        }
+      }
+      if (policy) {
+        if (!artifactIds.has(policy.owner)) {
+          violations.push(`${source} requires missing current owner ${policy.owner}`);
+        } else {
+          for (const owner of owners) {
+            if (owner !== policy.owner) {
+              violations.push(`${owner} reaches ${policy.owner}-owned source ${source}`);
+            }
+          }
+          if (!owners.includes(policy.owner)) {
+            violations.push(`${source} is not reached by required owner ${policy.owner}`);
+          }
+        }
+      }
+      continue;
+    }
+    const sharedOwners = CURRENT_SHARED_SOURCE_OWNER_POLICIES[source];
+    for (const owner of firstDisplayOwners) {
+      if (!sharedOwners?.includes(owner)) {
+        violations.push(`${owner} reaches persistent source ${source}`);
+      }
+    }
+    const policy = currentExactSourceOwner(source);
+    if (policy) {
+      if (!artifactIds.has(policy.owner)) {
+        violations.push(`${source} requires missing current owner ${policy.owner}`);
+        continue;
+      }
+      for (const owner of owners) {
+        if (owner !== policy.owner) {
+          if (policy.kind === 'provider') {
+            violations.push(`${owner} inlines provider ${policy.owner} implementation ${source}`);
+          } else {
+            violations.push(
+              `${source} must have exact current owner ${policy.owner}, not ${owner}`
+            );
+          }
+        }
+      }
+      if (!owners.includes(policy.owner)) {
+        violations.push(`${source} must have exact current owner ${policy.owner}`);
+      }
+    } else if (Object.hasOwn(CURRENT_SHARED_SOURCE_OWNER_POLICIES, source)) {
+      const allowedOwners = CURRENT_SHARED_SOURCE_OWNER_POLICIES[source];
+      for (const owner of owners) {
+        if (!allowedOwners.includes(owner)) {
+          violations.push(`${owner} reaches forbidden shared source ${source}`);
+        }
+      }
+    } else {
+      violations.push(`unclassified current production source ${source}`);
+    }
+  }
+  return violations;
+}
+
+/** Return takeover artifacts that transitively bundle explicit deferred-phase source. */
+export function findTakeoverDeferredSourceViolations(metrics, release) {
+  return findTakeoverDeferredViolations(readCurrentSourceGraph(metrics, release), release);
+}
+
+/** Return all current production graph ownership and seam violations. */
+export function findProductionGraphViolations(metrics, release) {
+  const currentGraph = readCurrentSourceGraph(metrics, release);
+  const violations = validateCurrentSourceOwnership(currentGraph, release);
+  for (const { artifact, sources } of currentGraph.graphEntries) {
+    for (const source of sources) {
+      if (PRODUCTION_SEAM_PATTERN.test(source)) {
+        violations.push(`${artifact.id} reaches production test/fake/no-op seam ${source}`);
+      }
+    }
+  }
+  return violations;
+}
+
+function validateArtifactContents(release, contents) {
+  if (!(contents instanceof Map)) fail('current artifact contents must be a Map');
+  const releaseArtifacts = [];
+  for (const artifact of release.artifacts) {
+    const bytes = contents.get(artifact.file);
+    if (!(bytes instanceof Uint8Array))
+      fail(`current artifact bytes are missing: ${artifact.file}`);
+    const digest = createHash('sha256').update(bytes).digest('hex');
+    if (bytes.byteLength !== artifact.bytes || digest !== artifact.hash) {
+      fail(`current artifact bytes do not match release inventory: ${artifact.file}`);
+    }
+    const source = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('utf8');
+    if (source.includes(RELEASE_SENTINEL) || source.split(release.releaseId).length - 1 !== 1) {
+      fail(`current artifact bytes do not contain exactly one release id: ${artifact.file}`);
+    }
+    releaseArtifacts.push({
+      id: artifact.id,
+      role: artifact.role,
+      phase: artifact.phase ?? '',
+      trigger: artifact.trigger ?? '',
+      bytes: Buffer.from(source.replace(release.releaseId, RELEASE_SENTINEL)),
+    });
+  }
+  if (computeReleaseId(releaseArtifacts) !== release.releaseId) {
+    fail('current artifact bytes do not reproduce release id');
+  }
+}
+
+function firstDisplayCompositionBytes(files, contents) {
+  const parts = files.flatMap((file, index) => {
+    const bytes = contents.get(file);
+    if (!(bytes instanceof Uint8Array)) fail(`current artifact bytes are missing: ${file}`);
+    return index === files.length - 1 ? [bytes] : [bytes, BUNDLE_SEPARATOR];
+  });
+  return Buffer.concat(parts);
+}
+
+function validateFirstDisplayMaskMeasurements(metrics, contents) {
+  const catalog = metrics?.firstDisplay?.catalog;
+  const masks = metrics?.firstDisplay?.masks;
+  const expected = enumerateReachableFirstDisplayMasks(catalog);
+  if (!Array.isArray(masks) || masks.length !== expected.length) {
+    fail(`build metrics must contain all ${expected.length} reachable first-display masks`);
+  }
+  const hashes = new Set();
+  for (const [index, canonical] of expected.entries()) {
+    const measured = masks[index];
+    if (
+      !hasExactKeys(measured, [
+        'mask',
+        'ids',
+        'files',
+        'rawBytes',
+        'gzipBytes',
+        'brotliBytes',
+        'sha256',
+        'permitted',
+      ]) ||
+      measured.mask !== canonical.mask ||
+      canonicalJson(measured.ids) !== canonicalJson(canonical.ids) ||
+      canonicalJson(measured.files) !== canonicalJson(canonical.files)
+    ) {
+      fail(`build metrics first-display mask ${index} is not canonical`);
+    }
+    if (!Number.isSafeInteger(measured.rawBytes) || measured.rawBytes < 0) {
+      fail(`firstDisplay.masks.${index}.rawBytes must be a non-negative integer`);
+    }
+    for (const sizeName of ['gzipBytes', 'brotliBytes']) {
+      assertPositiveInteger(measured[sizeName], `firstDisplay.masks.${index}.${sizeName}`);
+    }
+    const bytes = firstDisplayCompositionBytes(canonical.files, contents);
+    const sha256 = createHash('sha256').update(bytes).digest('hex');
+    if (
+      measured.rawBytes !== bytes.byteLength ||
+      measured.sha256 !== sha256 ||
+      measured.permitted !== firstDisplayMaskIsPermitted(measured) ||
+      hashes.has(sha256)
+    ) {
+      fail(`build metrics first-display mask ${canonical.mask} bytes or digest are invalid`);
+    }
+    hashes.add(sha256);
+  }
+  return masks;
+}
+
+function largestMask(masks, sizeName) {
+  return masks.reduce((largest, candidate) =>
+    candidate[sizeName] > largest[sizeName] ? candidate : largest
+  );
+}
+
+function namedFirstDisplayMask(masks, ids, name) {
+  const key = JSON.stringify(ids);
+  const matches = masks.filter((mask) => JSON.stringify(mask.ids) === key);
+  if (matches.length !== 1) fail(`first-display ${name} mask is unavailable or ambiguous`);
+  return matches[0];
+}
+
+/** Build the four independent absolute-size measurements from one canonical release. */
+export function buildCandidateArchitectureSizeReport({
+  metrics,
+  release,
+  catalog,
+  currentArtifactContents,
+}) {
+  validateSemanticBundleSets(metrics, release, catalog);
+  if (!(currentArtifactContents instanceof Map)) fail('current artifact contents must be a Map');
+  const masks = validateFirstDisplayMaskMeasurements(metrics, currentArtifactContents);
+  const permittedMasks = masks.filter(({ permitted }) => permitted === true);
+  if (permittedMasks.length === 0) fail('release has no permitted first-display masks');
+  const generatedPermittedMasks = catalog?.permittedFirstDisplayMasks;
+  if (
+    !Array.isArray(generatedPermittedMasks) ||
+    canonicalJson(generatedPermittedMasks) !== canonicalJson(permittedMasks.map(({ mask }) => mask))
+  ) {
+    fail('generated permitted first-display masks do not match measured size admission');
+  }
+  const largestRaw = largestMask(permittedMasks, 'rawBytes');
+  const largestGzip = largestMask(permittedMasks, 'gzipBytes');
+  const largestBrotli = largestMask(permittedMasks, 'brotliBytes');
+  const maximalFiles = release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .map(({ file }) => file);
+  const maximalTotal = measureBundleSet(maximalFiles, currentArtifactContents);
+  const named = {
+    minimal: namedFirstDisplayMask(masks, ['first_display'], 'minimal'),
+    reference: namedFirstDisplayMask(
+      masks,
+      ['first_display', 'creative_initial', 'datadome_initial', 'gpt_initial', 'prebid_initial'],
+      'reference'
+    ),
+    aps: namedFirstDisplayMask(
+      masks,
+      ['first_display', 'render_owner_initial', 'aps_initial', 'creative_initial', 'gpt_initial'],
+      'APS'
+    ),
+    largestRaw,
+    largestGzip,
+    largestBrotli,
+  };
+  for (const name of ['minimal', 'reference', 'aps']) {
+    if (!named[name].permitted) fail(`required first-display ${name} mask exceeds its ceiling`);
+  }
+  return {
+    ceilings: CANDIDATE_ARCHITECTURE_SIZE_CEILINGS,
+    bootstrap: Object.fromEntries(
+      SIZE_NAMES.map((sizeName) => [sizeName, metrics.bootstrap[sizeName]])
+    ),
+    firstDisplayAgent: {
+      rawBytes: largestRaw.rawBytes,
+      gzipBytes: largestGzip.gzipBytes,
+      brotliBytes: largestBrotli.brotliBytes,
+    },
+    referencePersistent: Object.fromEntries(
+      SIZE_NAMES.map((sizeName) => [sizeName, metrics.sets.reference[sizeName]])
+    ),
+    maximalTotal: Object.fromEntries(
+      SIZE_NAMES.map((sizeName) => [sizeName, maximalTotal[sizeName]])
+    ),
+    firstDisplay: { masks, permittedMasks, named },
+  };
+}
+
+/** Reject any semantic set that exceeds one reviewed independent ceiling. */
+export function enforceCandidateArchitectureSizeCeilings(report) {
+  for (const [semanticSet, limits] of Object.entries(CANDIDATE_ARCHITECTURE_SIZE_CEILINGS)) {
+    const measured = report?.[semanticSet];
+    for (const sizeName of SIZE_NAMES) {
+      if (!Number.isSafeInteger(measured?.[sizeName]) || measured[sizeName] < 1) {
+        fail(`${semanticSet}.${sizeName} is not a positive integer measurement`);
+      }
+      if (measured[sizeName] > limits[sizeName]) {
+        fail(`${semanticSet}.${sizeName} exceeds ${limits[sizeName]} bytes: ${measured[sizeName]}`);
+      }
+    }
+  }
+  return report;
+}
+
+function validateCurrentMeasurements(metrics, release, catalog, contents) {
+  const expectedSets = deriveInventorySetFiles(release.artifacts, catalog.modules);
+  for (const setName of SET_NAMES) {
+    const measured = measureBundleSet(expectedSets[setName], contents);
+    if (canonicalJson(measured) !== canonicalJson(metrics.sets[setName])) {
+      fail(`build metrics do not match current artifact bytes: ${setName}`);
+    }
+  }
+  const bootstrapBytes = contents.get('tsjs-bootstrap.js');
+  if (!(bootstrapBytes instanceof Uint8Array)) {
+    fail('current artifact bytes are missing: tsjs-bootstrap.js');
+  }
+  const measuredBootstrap = measureBytes(bootstrapBytes);
+  for (const key of [...SIZE_NAMES, 'sha256']) {
+    if (metrics.bootstrap[key] !== measuredBootstrap[key]) {
+      fail('build metrics do not match current artifact bytes: bootstrap');
+    }
+  }
+  for (const [index, module] of metrics.modules.entries()) {
+    const artifact = release.artifacts.filter(({ role }) => role !== 'bootstrap')[index];
+    if (module.rawBytes !== artifact.bytes || module.sha256 !== artifact.hash) {
+      fail(`build metrics do not match current artifact bytes: ${artifact.id}`);
+    }
+  }
+}
+
+function hasExactKeys(value, keys) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const actual = Object.keys(value);
+  const expected = new Set(keys);
+  return actual.length === expected.size && actual.every((key) => expected.has(key));
+}
+
+function validateReleaseInventoryShape(release, label, allowHistoricalPhase = false) {
+  if (!hasExactKeys(release, ['version', 'releaseId', 'artifacts'])) {
+    fail(`${label} release inventory must have exact keys version,releaseId,artifacts`);
+  }
+  if (
+    release.version !== 1 ||
+    !/^[0-9a-f]{64}$/u.test(release.releaseId) ||
+    !Array.isArray(release.artifacts)
+  ) {
+    fail(`${label} release inventory has invalid version, releaseId, or artifacts`);
+  }
+  const artifactKeys = [
+    'id',
+    'role',
+    'phase',
+    'trigger',
+    'inputs',
+    'outputs',
+    'file',
+    'bytes',
+    'hash',
+  ];
+  const ids = new Set();
+  const files = new Set();
+  for (const [index, artifact] of release.artifacts.entries()) {
+    if (!hasExactKeys(artifact, artifactKeys)) {
+      fail(`${label} release artifact ${index} must have exact keys ${artifactKeys.join(',')}`);
+    }
+    const stringArray = (value) =>
+      Array.isArray(value) &&
+      value.every((entry) => typeof entry === 'string') &&
+      new Set(value).size === value.length;
+    const phaseAndTriggerAreValid =
+      artifact.role === 'bootstrap' || artifact.role === 'core'
+        ? artifact.phase === null && artifact.trigger === null
+        : artifact.role === 'first_display_base' || artifact.role === 'first_display_slice'
+          ? artifact.phase === 'first_display' && artifact.trigger === null
+          : artifact.role === 'integration' &&
+            (artifact.phase === 'takeover' ||
+            (allowHistoricalPhase && artifact.phase === 'critical')
+              ? artifact.trigger === null
+              : artifact.phase === 'deferred' && artifact.trigger === 'first_display_or_idle');
+    if (
+      !/^[a-z0-9][a-z0-9_-]{0,63}$/u.test(artifact.id) ||
+      ids.has(artifact.id) ||
+      !phaseAndTriggerAreValid ||
+      !stringArray(artifact.inputs) ||
+      !stringArray(artifact.outputs) ||
+      typeof artifact.file !== 'string' ||
+      !(
+        /^tsjs-[a-z0-9_]+\.js$/u.test(artifact.file) ||
+        (allowHistoricalPhase && artifact.file === 'gpt-bootstrap-fallback.js')
+      ) ||
+      files.has(artifact.file) ||
+      !Number.isSafeInteger(artifact.bytes) ||
+      artifact.bytes <= 0 ||
+      !/^[0-9a-f]{64}$/u.test(artifact.hash)
+    ) {
+      fail(`${label} release artifact ${index} has an invalid shape`);
+    }
+    ids.add(artifact.id);
+    files.add(artifact.file);
+  }
+}
+
+function validateCurrentReleaseSemantics(
+  current,
+  generatedCatalog,
+  authoredCatalog,
+  authoredFirstDisplayCatalog
+) {
+  if (
+    generatedCatalog?.version !== 1 ||
+    !Array.isArray(generatedCatalog.modules) ||
+    !Array.isArray(generatedCatalog.firstDisplay) ||
+    !Array.isArray(authoredCatalog) ||
+    !Array.isArray(authoredFirstDisplayCatalog) ||
+    generatedCatalog.modules.length !== authoredCatalog.length ||
+    canonicalJson(generatedCatalog.firstDisplay) !== canonicalJson(authoredFirstDisplayCatalog)
+  ) {
+    fail('current generated/authored catalog inventory is invalid');
+  }
+  const expectedArtifacts = [
+    {
+      id: 'bootstrap',
+      role: 'bootstrap',
+      phase: null,
+      trigger: null,
+      inputs: [],
+      outputs: [],
+      file: 'tsjs-bootstrap.js',
+    },
+    ...authoredFirstDisplayCatalog.map((entry, index) => ({
+      id: entry.id,
+      role: index === 0 ? 'first_display_base' : 'first_display_slice',
+      phase: 'first_display',
+      trigger: null,
+      inputs: entry.inputs,
+      outputs: entry.outputs,
+      file: `tsjs-${entry.id}.js`,
+    })),
+    {
+      id: 'core',
+      role: 'core',
+      phase: null,
+      trigger: null,
+      inputs: [],
+      outputs: ['runtime.v1'],
+      file: 'tsjs-core.js',
+    },
+    ...authoredCatalog.map((entry, index) => {
+      const generated = generatedCatalog.modules[index];
+      if (
+        !generated ||
+        generated.id !== entry.id ||
+        generated.phase !== entry.phase ||
+        generated.trigger !== entry.trigger ||
+        generated.include !== entry.include
+      ) {
+        fail(`generated catalog entry ${index} differs from current authored catalog`);
+      }
+      return {
+        id: entry.id,
+        role: 'integration',
+        phase: entry.phase,
+        trigger: entry.trigger,
+        inputs: entry.consumes,
+        outputs: entry.provides,
+        file: `tsjs-${entry.id}.js`,
+      };
+    }),
+  ];
+  if (current.artifacts.length !== expectedArtifacts.length) {
+    fail('current release does not match the live catalog artifact count');
+  }
+
+  const coreIndex = current.artifacts.findIndex(({ role }) => role === 'core');
+  const providers = new Map([['runtime.v1', coreIndex]]);
+  for (const [index, artifact] of current.artifacts.entries()) {
+    if (artifact.role !== 'integration') continue;
+    for (const capability of artifact.outputs) {
+      if (!CAPABILITY_PATTERN.test(capability)) {
+        fail(`current release has invalid output capability: ${capability}`);
+      }
+      if (providers.has(capability)) {
+        fail(`current capability has multiple providers: ${capability}`);
+      }
+      providers.set(capability, index);
+    }
+  }
+  let sawDeferred = false;
+  for (const [index, artifact] of current.artifacts.entries()) {
+    const expected = expectedArtifacts[index];
+    for (const field of ['id', 'role', 'phase', 'trigger', 'file']) {
+      if (artifact[field] !== expected[field]) {
+        fail(`current release artifact ${index} ${field} differs from the live catalog`);
+      }
+    }
+    if (
+      artifact.role === 'bootstrap' &&
+      (artifact.inputs.length !== 0 || artifact.outputs.length !== 0)
+    ) {
+      fail('current bootstrap invariant requires no inputs or outputs');
+    }
+    if (
+      artifact.role === 'core' &&
+      (artifact.inputs.length !== 0 || canonicalJson(artifact.outputs) !== '["runtime.v1"]')
+    ) {
+      fail('current core invariant requires only the runtime.v1 output');
+    }
+    if (artifact.role !== 'integration') continue;
+    if (!artifact.inputs.includes('runtime.v1')) {
+      fail(`current integration ${artifact.id} must consume runtime.v1`);
+    }
+    if (artifact.phase === 'deferred') {
+      sawDeferred = true;
+      if (artifact.outputs.length !== 0) {
+        fail(`current deferred integration cannot provide capabilities: ${artifact.id}`);
+      }
+    } else if (sawDeferred) {
+      fail('current takeover integration cannot follow a deferred integration');
+    }
+    for (const edge of artifact.inputs) {
+      const parts = edge.split('?');
+      if (
+        parts.length > 2 ||
+        !CAPABILITY_PATTERN.test(parts[0]) ||
+        (parts.length === 2 && !CAPABILITY_PREDICATE_PATTERN.test(parts[1]))
+      ) {
+        fail(`current release has invalid input capability: ${edge}`);
+      }
+      const providerIndex = providers.get(parts[0]);
+      if (providerIndex === undefined) fail(`current release has unknown capability: ${parts[0]}`);
+      if (providerIndex >= index) {
+        fail(`current capability provider must precede consumer: ${parts[0]}`);
+      }
+    }
+    if (
+      canonicalJson(artifact.inputs) !== canonicalJson(expected.inputs) ||
+      canonicalJson(artifact.outputs) !== canonicalJson(expected.outputs)
+    ) {
+      fail(`current release artifact ${index} capabilities differ from authored catalog`);
+    }
+  }
+}
+
+function validateCapturedMembership(capture, historicalCatalog, label = 'capturedTransfer') {
+  const artifactsById = new Map(
+    capture.release.artifacts.map((artifact) => [artifact.id, artifact])
+  );
+  const idsByFile = new Map(capture.release.artifacts.map(({ id, file }) => [file, id]));
+  const expectedFiles = deriveInventorySetFiles(capture.release.artifacts, historicalCatalog);
+  const bootstrapFile = artifactsById.get('bootstrap')?.file;
+  if (typeof bootstrapFile !== 'string') {
+    fail(`${label} bootstrap release artifact is missing`);
+  }
+  const expected = {
+    bootstrap: { artifactIds: ['bootstrap'], files: [bootstrapFile] },
+    ...Object.fromEntries(
+      SET_NAMES.map((setName) => [
+        setName,
+        {
+          artifactIds: expectedFiles[setName].map((file) => idsByFile.get(file)),
+          files: expectedFiles[setName],
+        },
+      ])
+    ),
+  };
+  for (const setName of TRANSFER_SET_NAMES) {
+    const set = capture.sets?.[setName];
+    if (
+      !set ||
+      !Array.isArray(set.artifactIds) ||
+      !Array.isArray(set.files) ||
+      set.artifactIds.length !== set.files.length ||
+      set.artifactIds.length === 0 ||
+      new Set(set.artifactIds).size !== set.artifactIds.length ||
+      new Set(set.files).size !== set.files.length ||
+      canonicalJson(set.artifactIds) !== canonicalJson(expected[setName].artifactIds) ||
+      canonicalJson(set.files) !== canonicalJson(expected[setName].files)
+    ) {
+      fail(`${label} ${setName} semantic membership is invalid`);
+    }
+    for (const [index, artifactId] of set.artifactIds.entries()) {
+      const artifact = artifactsById.get(artifactId);
+      if (!artifact || artifact.file !== set.files[index]) {
+        fail(`${label} ${setName} release/set membership pair is invalid`);
+      }
+      if (setName === 'bootstrap' ? artifact.role !== 'bootstrap' : artifact.role === 'bootstrap') {
+        fail(`${label} ${setName} release/set role membership is invalid`);
+      }
+    }
+    if (
+      setName === 'bootstrap' &&
+      (set.artifactIds[0] !== 'bootstrap' || set.files[0] !== bootstrapFile)
+    ) {
+      fail(`${label} bootstrap semantic membership is invalid`);
+    }
+    for (const sizeName of SIZE_NAMES) {
+      assertPositiveInteger(set[sizeName], `${label}.sets.${setName}.${sizeName}`);
+    }
+    if (!/^[0-9a-f]{64}$/.test(set.sha256)) {
+      fail(`${label}.sets.${setName}.sha256 is invalid`);
+    }
+  }
+}
+
+function validateReductionCheckpoint(capture, intermediate) {
+  const minimal = capture.sets.minimal;
+  if (minimal.rawBytes > 220_000) {
+    fail(`review remediation minimal.rawBytes exceeds 220000: ${minimal.rawBytes}`);
+  }
+  if (minimal.gzipBytes > 59_000) {
+    fail(`review remediation minimal.gzipBytes exceeds 59000: ${minimal.gzipBytes}`);
+  }
+  if (minimal.brotliBytes >= intermediate.sets.minimal.brotliBytes) {
+    fail('review remediation minimal.brotliBytes must improve on the intermediate capture');
+  }
+  for (const sizeName of SIZE_NAMES) {
+    if (capture.sets.reference[sizeName] >= intermediate.sets.reference[sizeName]) {
+      fail(`review remediation reference.${sizeName} must improve on the intermediate capture`);
+    }
+    if (capture.sets.maximal[sizeName] > intermediate.sets.maximal[sizeName]) {
+      fail(`review remediation maximal.${sizeName} must not grow from the intermediate capture`);
+    }
+  }
+}
+
+/** Report current transfer sizes against an authenticated historical capture. */
+export function buildTransferCaptureReport(captured, current) {
+  const reports = {};
+  for (const setName of TRANSFER_SET_NAMES) {
+    reports[setName] = {};
+    for (const sizeName of SIZE_NAMES) {
+      const capturedBytes = captured?.[setName]?.[sizeName];
+      const currentBytes = current?.[setName]?.[sizeName];
+      assertPositiveInteger(capturedBytes, `captured.${setName}.${sizeName}`);
+      assertPositiveInteger(currentBytes, `current.${setName}.${sizeName}`);
+      reports[setName][sizeName] = {
+        capturedBytes,
+        currentBytes,
+        deltaBytes: currentBytes - capturedBytes,
+      };
+    }
+  }
+  return reports;
+}
+
+/** Authenticate frozen evidence, then independently validate and report the current release. */
+export function validateRoleCorrectTransfer({
+  baseline,
+  metrics,
+  catalog,
+  release,
+  currentArtifactContents,
+  verifyGitProvenance = false,
+  authoredCatalog = loadAuthoredReleaseCatalog(),
+  authoredFirstDisplayCatalog = loadAuthoredFirstDisplayCatalog(),
+}) {
+  const intermediate = baseline?.roleCorrectTransfer;
+  if (!intermediate || typeof intermediate !== 'object') fail('role-correct capture is missing');
+  const capture = baseline?.reviewRemediationTransfer;
+  if (!capture || typeof capture !== 'object') fail('review-remediation capture is missing');
+  const historical = Object.fromEntries(
+    Object.entries(baseline).filter(
+      ([key]) => key !== 'roleCorrectTransfer' && key !== 'reviewRemediationTransfer'
+    )
+  );
+  const historicalDigest = canonicalJsonSha256(historical);
+  if (historicalDigest !== HISTORICAL_EVIDENCE_SHA256) {
+    fail('historical evidence digest does not match the immutable original top-level fields');
+  }
+  if (canonicalJsonSha256(intermediate) !== ROLE_CORRECT_CAPTURE_SHA256) {
+    fail('role-correct capture digest does not match the immutable capture');
+  }
+  if (canonicalJsonSha256(capture) !== REVIEW_REMEDIATION_CAPTURE_SHA256) {
+    fail('review-remediation capture digest does not match the immutable capture');
+  }
+  if (
+    capture.originalTopLevelSha256 !== HISTORICAL_EVIDENCE_SHA256 ||
+    intermediate.originalTopLevelSha256 !== HISTORICAL_EVIDENCE_SHA256
+  ) {
+    fail('historical evidence digest linkage is invalid');
+  }
+  if (capture.roleCorrectTransferSha256 !== ROLE_CORRECT_CAPTURE_SHA256) {
+    fail('review-remediation linkage to the immutable intermediate capture is invalid');
+  }
+  if (verifyGitProvenance) {
+    validateFrozenCaptureProvenance(intermediate, capture);
+  }
+
+  validateReleaseInventoryShape(intermediate.release, 'role-correct intermediate', true);
+  validateReleaseInventoryShape(capture.release, 'captured', true);
+  validateReleaseInventoryShape(release, 'current');
+  validateCapturedMembership(
+    intermediate,
+    loadHistoricalReleaseCatalog(intermediate, 'roleCorrectTransfer'),
+    'roleCorrectTransfer'
+  );
+  validateCapturedMembership(
+    capture,
+    loadHistoricalReleaseCatalog(capture, 'reviewRemediationTransfer'),
+    'reviewRemediationTransfer'
+  );
+  validateReductionCheckpoint(capture, intermediate);
+  validateCurrentReleaseSemantics(release, catalog, authoredCatalog, authoredFirstDisplayCatalog);
+  validateSemanticBundleSets(metrics, release, catalog);
+  const graphViolations = findProductionGraphViolations(metrics, release);
+  if (graphViolations.length > 0)
+    fail(`production graph failed:\n- ${graphViolations.join('\n- ')}`);
+  if (currentArtifactContents !== undefined) {
+    validateArtifactContents(release, currentArtifactContents);
+    validateCurrentMeasurements(metrics, release, catalog, currentArtifactContents);
+  }
+  const currentSets = { bootstrap: metrics.bootstrap, ...metrics.sets };
+  return {
+    captureReports: {
+      roleCorrectTransfer: buildTransferCaptureReport(intermediate.sets, currentSets),
+      reviewRemediationTransfer: buildTransferCaptureReport(capture.sets, currentSets),
+    },
+    capture,
+  };
+}
+
+function parseArgs(argv) {
+  const options = { baselinePath: defaultBaselinePath };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--baseline') {
+      const value = argv[index + 1];
+      if (!value) fail('--baseline requires a path');
+      options.baselinePath = path.resolve(value);
+      index += 1;
+    } else {
+      fail(`unknown argument: ${argument}`);
+    }
+  }
+  return options;
+}
+
+export function checkBundleBudgets({ baselinePath = defaultBaselinePath } = {}) {
+  const baseline = readJson(baselinePath, 'baseline');
+  const metrics = readJson(metricsPath, 'build metrics');
+  const catalog = readJson(catalogPath, 'release catalog');
+  const release = readJson(releasePath, 'release inventory');
+  if (baseline.schemaVersion !== 1) fail('baseline.schemaVersion must equal 1');
+  if (metrics.schemaVersion !== 1) fail('build metrics schemaVersion must equal 1');
+  validateBudgetSets(baseline.bundles, 'baseline.bundles');
+  validateSemanticBundleSets(metrics, release, catalog);
+
+  const historicalDeltas = {};
+  const historicalSets = {
+    bootstrap: BOOTSTRAP_BASELINE,
+    ...Object.fromEntries(SET_NAMES.map((setName) => [setName, baseline.bundles[setName]])),
+  };
+  const currentSets = { bootstrap: metrics.bootstrap, ...metrics.sets };
+  for (const [setName, historical] of Object.entries(historicalSets)) {
+    const current = currentSets[setName];
+    historicalDeltas[setName] = Object.fromEntries(
+      SIZE_NAMES.map((sizeName) => [
+        sizeName,
+        {
+          historicalBytes: historical[sizeName],
+          currentBytes: current[sizeName],
+          deltaBytes: current[sizeName] - historical[sizeName],
+        },
+      ])
+    );
+  }
+
+  const currentArtifactContents = new Map(
+    release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.join(path.dirname(releasePath), file)),
+    ])
+  );
+  const roleCorrect = validateRoleCorrectTransfer({
+    baseline,
+    metrics,
+    catalog,
+    release,
+    currentArtifactContents,
+    verifyGitProvenance: true,
+  });
+  const candidateArchitecture = buildCandidateArchitectureSizeReport({
+    metrics,
+    release,
+    catalog,
+    currentArtifactContents,
+  });
+  enforceCandidateArchitectureSizeCeilings(candidateArchitecture);
+
+  return {
+    baselinePath,
+    roleCorrectStatus: 'immutable-intermediate',
+    reviewRemediationStatus: 'immutable-report-only',
+    transferCapturesEnforced: false,
+    historicalDeltas,
+    frozenTransferReports: roleCorrect.captureReports,
+    candidateArchitecture,
+    productionGraphReport: buildProductionGraphReport(metrics, release),
+    sets: metrics.sets,
+  };
+}
+
+/** Keep the blocking CLI report reviewable while full mask evidence stays in build metrics. */
+export function summarizeBundleBudgetCommandReport(result) {
+  const architecture = result?.candidateArchitecture;
+  const firstDisplay = architecture?.firstDisplay;
+  if (
+    !architecture ||
+    !firstDisplay ||
+    !Array.isArray(firstDisplay.masks) ||
+    !Array.isArray(firstDisplay.permittedMasks)
+  ) {
+    fail('candidate architecture report is missing first-display mask evidence');
+  }
+  return {
+    ...result,
+    candidateArchitecture: {
+      ...architecture,
+      firstDisplay: {
+        reachableMaskCount: firstDisplay.masks.length,
+        permittedMaskCount: firstDisplay.permittedMasks.length,
+        named: firstDisplay.named,
+      },
+    },
+  };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const result = checkBundleBudgets(parseArgs(process.argv.slice(2)));
+    process.stdout.write(
+      `${JSON.stringify(summarizeBundleBudgetCommandReport(result), null, 2)}\n`
+    );
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
+    process.exitCode = 1;
+  }
+}
diff --git a/crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs b/crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs
new file mode 100644
index 000000000..74c9edcf7
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs
@@ -0,0 +1,435 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const packageRoot = path.resolve(import.meta.dirname, '..');
+const repositoryRoot = path.resolve(packageRoot, '../../..');
+const extensions = new Set([
+  '.css',
+  '.html',
+  '.integrity',
+  '.js',
+  '.json',
+  '.log',
+  '.map',
+  '.md',
+  '.mjs',
+  '.rs',
+  '.sh',
+  '.sha256',
+  '.sri',
+  '.toml',
+  '.ts',
+  '.tsx',
+  '.txt',
+  '.yaml',
+  '.yml',
+]);
+const ignoredDirectories = new Set(['.git', 'coverage', 'dist', 'node_modules', 'target']);
+
+function relative(file) {
+  return path.relative(repositoryRoot, file).replaceAll(path.sep, '/');
+}
+
+function collect(directory, files = []) {
+  if (!fs.existsSync(directory)) return files;
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (entry.isDirectory() && ignoredDirectories.has(entry.name)) continue;
+    const target = path.join(directory, entry.name);
+    if (entry.isDirectory()) collect(target, files);
+    else if (extensions.has(path.extname(entry.name))) files.push(target);
+  }
+  return files;
+}
+
+function lineNumber(source, offset) {
+  let line = 1;
+  for (let index = 0; index < offset; index += 1) {
+    if (source.charCodeAt(index) === 10) line += 1;
+  }
+  return line;
+}
+
+const jsPackageFiles = collect(packageRoot);
+const shippedTsjsFiles = collect(path.join(packageRoot, 'src'));
+const productionTsjsFiles = shippedTsjsFiles.filter(
+  (file) => !/(?:_test|\.test)\.[cm]?[jt]sx?$/u.test(file)
+);
+export function generatedTsjsArtifactFiles(root = packageRoot) {
+  return collect(path.resolve(root, '../dist'));
+}
+
+const generatedTsjsFiles = generatedTsjsArtifactFiles();
+const currentGuideFiles = collect(path.join(repositoryRoot, 'docs/guide'));
+const browserTestFiles = collect(
+  path.join(repositoryRoot, 'crates/trusted-server-integration-tests/browser')
+);
+const productionRustFiles = [
+  'crates/trusted-server-core/src',
+  'crates/trusted-server-adapter-fastly/src',
+  'crates/trusted-server-adapter-axum/src',
+  'crates/trusted-server-adapter-cloudflare/src',
+  'crates/trusted-server-adapter-spin/src',
+].flatMap((directory) => collect(path.join(repositoryRoot, directory)));
+const thisScript = path.resolve(import.meta.filename);
+const auxiliaryFiles = [
+  ...jsPackageFiles,
+  ...collect(path.join(repositoryRoot, 'crates/trusted-server-integration-tests')),
+  ...collect(path.join(repositoryRoot, 'scripts')),
+  ...collect(path.join(repositoryRoot, '.github/workflows')),
+].filter((file) => path.resolve(file) !== thisScript);
+const legacySurfaceFiles = [...shippedTsjsFiles, ...generatedTsjsFiles, ...currentGuideFiles];
+const uniqueFiles = (files) => [...new Set(files)];
+const violations = [];
+
+function forbidSource(file, source, label, expression) {
+  expression.lastIndex = 0;
+  for (let match = expression.exec(source); match; match = expression.exec(source)) {
+    violations.push(`${relative(file)}:${lineNumber(source, match.index)}: ${label}`);
+    if (match[0].length === 0) expression.lastIndex += 1;
+  }
+}
+
+function forbid(files, label, expression) {
+  for (const file of uniqueFiles(files)) {
+    const source = fs.readFileSync(file, 'utf8');
+    forbidSource(file, source, label, expression);
+  }
+}
+
+function token(...parts) {
+  return parts.join('');
+}
+
+const retiredRuntimeFiles = new Set([
+  'src/composition/browser.ts',
+  'src/composition/critical_transport.ts',
+  'src/composition/index.ts',
+  'src/core/bootstrap_controller.ts',
+]);
+const retiredCutoverExpressions = [
+  [
+    'non-canonical APS renderer route',
+    /\/integrations\/aps\/renderer(?!\/v2(?![A-Za-z0-9_./-]))/gu,
+  ],
+  [
+    'rendererUrl in a v4 Prebid response',
+    /(?:message\s*:\s*['"]Prebid Response['"]|\[['"]message['"]\]\s*=\s*[^;\n]*prebidResponse)[\s\S]{0,512}(?:rendererVersion\s*:\s*['"]4['"]|\[['"]rendererVersion['"]\]\s*=)[\s\S]{0,512}\brendererUrl\b/gu,
+  ],
+  ['retired APS owner start payload', /['"]TS APS Start['"]/gu],
+  ['raw TSJS integration global', /__tsjs_[A-Za-z0-9_]+/gu],
+  ['retired bundle activation attribute', /data-ts-gam-attribution/gu],
+  [
+    'retired TSJS public surface',
+    /\b(?:LegacyTsjsApi|TsjsApiV1|apsPrebidRenderers|renderAllAdUnits|renderAdUnit|renderLog|renderSeq|registerContextProvider|collectContext|installGuards)\b|tsjs:adRendered/gu,
+  ],
+  [
+    'retired TSJS namespace member',
+    /\btsjs(?:\.|\?\.)(?:adSlots|bids|getConfig|gptDiagnostics|renders|setConfig)\b/gu,
+  ],
+  ['retired TSJS public version', /\btsjs(?:\.|\?\.)version\s*=\s*['"]0\.1\.0['"]/gu],
+  ['retired creative global', /\b(?:tscreative|tsCreativeConfig)\b/gu],
+];
+
+export function findCutoverTextViolations(file, source) {
+  const normalized = file
+    .replaceAll('\\', '/')
+    .replace(/^.*\/crates\/trusted-server-js\/lib\//u, '');
+  const found = [];
+  if (retiredRuntimeFiles.has(normalized)) found.push('retired second runtime file');
+  for (const [label, expression] of retiredCutoverExpressions) {
+    expression.lastIndex = 0;
+    if (expression.test(source)) found.push(label);
+  }
+  return found;
+}
+
+const forbiddenVendorBasename =
+  /^(?:gpt|pubads_impl|prebid-creative|prebid-universal-creative(?:[._-].*)?)\.(?:[cm]?js|html)(?:\.(?:integrity|map|sha256|sri))?$/iu;
+const vendorBodyExpressions = [
+  /\/[*!]\s*(?:@license\s+)?[^\n]{0,160}\bPrebid Universal Creative\b/giu,
+  /\/[*!][^\n]{0,160}@license[^\n]{0,160}\bGoogle Publisher Tag\b/giu,
+  /\/[*!][^\n]{0,160}(?:Copyright|@license)[^\n]{0,160}\bAmazon Publisher Services\b/giu,
+  /\b(?:apsRunner|gpt|puc)(?:Digest|Integrity|Sha(?:256|384|512)|Sri|Checksum|Version)\b/giu,
+  /\b(?:digest|integrity|sha(?:256|384|512)|sri|checksum)\b[^\n]{0,160}\b(?:prebid-creative\.js|Google Publisher Tag|Prebid Universal Creative|Amazon Publisher Services)\b/giu,
+  /\b(?:prebid-creative\.js|Google Publisher Tag|Prebid Universal Creative|Amazon Publisher Services)\b[^\n]{0,160}\b(?:digest|integrity|sha(?:256|384|512)|sri|checksum)\b/giu,
+];
+
+export function findVendorBoundaryViolations(file, source) {
+  const normalized = file.replaceAll('\\', '/');
+  const basename = path.posix.basename(normalized);
+  const found = [];
+  if (forbiddenVendorBasename.test(basename)) found.push('vendor distributable filename');
+  for (const expression of vendorBodyExpressions) {
+    expression.lastIndex = 0;
+    if (expression.test(source)) found.push('stored vendor body, checksum, or version metadata');
+  }
+  return found;
+}
+
+for (const file of uniqueFiles([
+  ...productionTsjsFiles,
+  ...generatedTsjsFiles,
+  ...currentGuideFiles,
+  ...productionRustFiles,
+])) {
+  const source = fs.readFileSync(file, 'utf8');
+  const productionSource = file.endsWith('.rs')
+    ? (source.split('\n#[cfg(test)]')[0] ?? source)
+    : source;
+  for (const label of findCutoverTextViolations(relative(file), productionSource)) {
+    violations.push(`${relative(file)}:1: ${label}`);
+  }
+}
+
+const vendorBoundaryFiles = [
+  ...productionTsjsFiles,
+  ...generatedTsjsFiles,
+  ...productionRustFiles,
+  ...collect(path.join(repositoryRoot, 'crates/trusted-server-integration-tests/browser/fixtures')),
+  ...collect(path.join(repositoryRoot, 'crates/trusted-server-integration-tests/fixtures')),
+  ...collect(path.join(repositoryRoot, 'target/aps-tsjs-quality-evidence')),
+  ...collect(path.join(repositoryRoot, 'target/aps-tsjs-cutover-evidence')),
+  ...collect(
+    path.join(repositoryRoot, 'crates/trusted-server-integration-tests/browser/real-gam-evidence')
+  ),
+  ...collect(
+    path.join(repositoryRoot, 'crates/trusted-server-integration-tests/browser/playwright-report')
+  ),
+  ...collect(
+    path.join(repositoryRoot, 'crates/trusted-server-integration-tests/browser/test-results')
+  ),
+];
+for (const file of uniqueFiles(vendorBoundaryFiles)) {
+  const source = fs.readFileSync(file, 'utf8');
+  const productionSource = file.endsWith('.rs')
+    ? (source.split('\n#[cfg(test)]')[0] ?? source)
+    : source;
+  for (const label of findVendorBoundaryViolations(relative(file), productionSource)) {
+    violations.push(`${relative(file)}:1: ${label}`);
+  }
+}
+
+const oldRuntimePrefix = token('__', 'tsjs', '_');
+const oldCreativeGlobal = token('ts', 'creative');
+const oldIntegrationConfigTransport = token('_', 'integration', 'Config');
+const legacyPublicTokens = [
+  token('Legacy', 'TsjsApi'),
+  token('TsjsApi', 'V1'),
+  token('apsPrebid', 'Renderers'),
+  token('render', 'AllAdUnits'),
+  token('render', 'AdUnit'),
+  token('render', 'Log'),
+  token('render', 'Seq'),
+  token('tsjs:', 'adRendered'),
+  token('__tsRender', 'Generation'),
+  token('__tsRender', 'Bid'),
+  token('registerContext', 'Provider'),
+  token('collect', 'Context'),
+  token('install', 'Guards'),
+];
+
+forbid(legacySurfaceFiles, 'legacy window runtime flag', new RegExp(oldRuntimePrefix, 'g'));
+forbid(
+  legacySurfaceFiles,
+  'legacy creative global',
+  new RegExp(`(?:globalThis\\.)?${oldCreativeGlobal}|tsCreativeConfig`, 'g')
+);
+forbid(
+  [...legacySurfaceFiles, ...productionRustFiles],
+  'legacy mutable integration config transport',
+  new RegExp(oldIntegrationConfigTransport, 'g')
+);
+for (const name of legacyPublicTokens) {
+  forbid(
+    legacySurfaceFiles,
+    `legacy TSJS surface ${name}`,
+    new RegExp(name.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')
+  );
+}
+forbid(
+  legacySurfaceFiles,
+  'legacy public GPT diagnostics surface',
+  /\b(?:window\.)?tsjs(?:\?\.|\.)gptDiagnostics\b/g
+);
+
+forbid(
+  shippedTsjsFiles,
+  'legacy mutable core configuration API',
+  /export\s+function\s+(?:setConfig|getConfig)\b/g
+);
+forbid(
+  shippedTsjsFiles,
+  'temporary architecture lint allowlist',
+  /LEGACY_(?:ADTECH_GLOBAL|RESTRICTED_IMPORT)_ALLOWLIST/g
+);
+forbid(
+  shippedTsjsFiles,
+  'integration-owned function sentinel',
+  /__(?:tsInitialLoadConfigHooked|tsInitialLoadHooked|tsPushed|tsSlotHandoffPatched|tsApsBidResponseListenerInstalled|tsRefreshWrapped|tsRemoveAdUnitWrapped|tsRenderTraceInstalled|tsjsPrebidShimInstalled)\b/g
+);
+forbid(
+  shippedTsjsFiles,
+  'empty catch in migrated TSJS source',
+  /catch\s*(?:\([^)]*\))?\s*\{\s*\}/g
+);
+const coreTraceFile = path.join(packageRoot, 'src/core/trace.ts');
+forbidSource(
+  coreTraceFile,
+  fs.readFileSync(coreTraceFile, 'utf8'),
+  'core render trace presentation leakage',
+  /\b(?:Document|HTMLElement|MutationObserver)\b|createElement|getElementById|querySelector|clipboard|data-ts-/g
+);
+forbid(
+  [...currentGuideFiles, ...browserTestFiles],
+  'legacy mutable TSJS configuration call',
+  /\btsjs(?:\?\.)?\.setConfig\s*\(/g
+);
+forbid(
+  browserTestFiles,
+  'legacy TSJS render function invocation',
+  /\.tsjs(?:\?\.)?\.(?:renderAdUnit|renderAllAdUnits)\s*\(/g
+);
+forbid(
+  productionRustFiles,
+  'legacy window runtime flag in production documentation',
+  /\/\/\/.*window\.__tsjs_.*/g
+);
+
+const routeAndConfigFiles = [...shippedTsjsFiles, ...currentGuideFiles];
+forbid(routeAndConfigFiles, 'deprecated page-bids route', /\/__ts\/page-bids/g);
+forbid(
+  routeAndConfigFiles,
+  'non-canonical APS renderer route',
+  /\/integrations\/aps\/renderer(?!\/v2(?![A-Za-z0-9_./-]))/g
+);
+const apsIntegrationFile = path.join(
+  repositoryRoot,
+  'crates/trusted-server-core/src/integrations/aps.rs'
+);
+const apsIntegrationSource = fs.readFileSync(apsIntegrationFile, 'utf8');
+forbidSource(
+  apsIntegrationFile,
+  apsIntegrationSource.split('\n#[cfg(test)]')[0] ?? apsIntegrationSource,
+  'non-canonical APS renderer route',
+  /\/integrations\/aps\/renderer(?!\/v2(?![A-Za-z0-9_./-]))/g
+);
+if (
+  !apsIntegrationSource.includes(
+    'pub const APS_RUNNER_ROUTE: &str = "/integrations/aps/runner.js";'
+  )
+) {
+  violations.push(`${relative(apsIntegrationFile)}:1: missing canonical APS runner route`);
+}
+if (
+  /APS_RUNNER_ROUTE:\s*&str\s*=\s*"\/integrations\/aps\/runner\/v1\.js"/.test(apsIntegrationSource)
+) {
+  violations.push(`${relative(apsIntegrationFile)}:1: versioned APS runner route is served`);
+}
+forbid(currentGuideFiles, 'APS pub_id compatibility alias', /\bpub_id\b/g);
+forbidSource(
+  apsIntegrationFile,
+  apsIntegrationSource.split('\n#[cfg(test)]')[0] ?? apsIntegrationSource,
+  'APS pub_id compatibility alias',
+  /\bpub_id\b/g
+);
+forbid(
+  [...shippedTsjsFiles, ...productionRustFiles, ...currentGuideFiles],
+  'vendored or pinned APS runner asset',
+  /include_(?:bytes|str)!?[^\n]*runner|APS_RUNNER_(?:ASSET|DIGEST|SRI|VERSION)|runner[_-]cache|offline[_ -]runner|prebid-creative\.js[^\n]*(?:digest|integrity|version)/gi
+);
+forbid(
+  auxiliaryFiles,
+  'APS runner downloader, updater, or pinned artifact metadata',
+  /APS_RUNNER_(?:ASSET|DIGEST|SRI|VERSION)|runner[_-]cache|offline[_ -]runner|prebid-creative\.js[^\n]*(?:digest|integrity|version)|(?:download|update)[^\n]*prebid-creative\.js/gi
+);
+const browserPackageManifests = [
+  'crates/trusted-server-integration-tests/browser/package.json',
+  'crates/trusted-server-integration-tests/browser/package-lock.json',
+];
+for (const manifest of browserPackageManifests) {
+  const source = fs.readFileSync(path.join(repositoryRoot, manifest), 'utf8');
+  if (source.includes('prebid-universal-creative')) {
+    violations.push(`${manifest}:1: PUC package is vendored into the local harness`);
+  }
+}
+const realGamNetworkFile = path.join(
+  repositoryRoot,
+  'crates/trusted-server-integration-tests/browser/helpers/gam-test-network.ts'
+);
+const realGamNetworkSource = fs.readFileSync(realGamNetworkFile, 'utf8');
+if (!/export const REAL_GAM_PUC_RELEASE = ['"]1\.17\.2['"];/u.test(realGamNetworkSource)) {
+  violations.push(
+    `${relative(realGamNetworkFile)}:1: protected conformance metadata must pin PUC 1.17.2`
+  );
+}
+forbidSource(
+  realGamNetworkFile,
+  realGamNetworkSource,
+  'PUC conformance metadata must not carry vendor bytes, URLs, or checksums',
+  /\bPUC_(?:ASSET|BODY|DIGEST|INTEGRITY|SCRIPT|SRI|URL|VERSION)\b/gu
+);
+
+for (const manifest of [
+  'crates/trusted-server-adapter-fastly/Cargo.toml',
+  'crates/trusted-server-adapter-axum/Cargo.toml',
+  'crates/trusted-server-adapter-cloudflare/Cargo.toml',
+  'crates/trusted-server-adapter-spin/Cargo.toml',
+]) {
+  const source = fs.readFileSync(path.join(repositoryRoot, manifest), 'utf8');
+  const defaultFeatures = source.match(/^default\s*=\s*\[([^\]]*)\]/m)?.[1] ?? '';
+  if (defaultFeatures.includes('aps-runner-proxy-integration-test')) {
+    violations.push(`${manifest}:1: APS proxy test hook is enabled in a production feature set`);
+  }
+}
+
+const forbiddenFiles = [
+  'crates/trusted-server-integration-tests/src/bin/generate-tsjs-prospective-fixture.rs',
+  'crates/trusted-server-js/lib/src/composition/browser.ts',
+  'crates/trusted-server-js/lib/src/composition/critical_transport.ts',
+  'crates/trusted-server-js/lib/src/composition/index.ts',
+  'crates/trusted-server-js/lib/src/core/bootstrap_controller.ts',
+  'crates/trusted-server-js/lib/src/core/context.ts',
+  'crates/trusted-server-js/lib/src/core/request.ts',
+  'crates/trusted-server-js/lib/src/first_display/contracts.ts',
+  'crates/trusted-server-js/lib/src/first_display/handoff.ts',
+  'crates/trusted-server-js/lib/src/first_display/registration.ts',
+  'crates/trusted-server-js/lib/src/first_display/transaction.ts',
+  'crates/trusted-server-js/lib/src/integrations/gpt/bootstrap_fallback.ts',
+  'crates/trusted-server-js/lib/test/core/context.test.ts',
+  'crates/trusted-server-js/lib/test/core/bootstrap_controller.test.ts',
+  'crates/trusted-server-js/lib/test/core/trace.test.ts',
+];
+for (const file of forbiddenFiles) {
+  if (fs.existsSync(path.join(repositoryRoot, file))) {
+    violations.push(`${file}:1: unreachable legacy file remains`);
+  }
+}
+
+const requiredReplacements = [
+  ['crates/trusted-server-core/src/tsjs.rs', 'IntegrationConfigsV1'],
+  ['crates/trusted-server-js/lib/src/core/index.ts', '_claimRuntimeV1'],
+  ['crates/trusted-server-js/lib/src/integrations/didomi/module.ts', 'proxyPath'],
+  ['crates/trusted-server-js/lib/src/integrations/prebid/module.ts', 'clientSideBidders'],
+  ['crates/trusted-server-js/lib/src/integrations/sourcepoint/module.ts', 'rewriteSdk'],
+  [
+    'crates/trusted-server-js/lib/build-prebid-external.mjs',
+    'assertNoLegacyRuntimeFlags(finalBundle)',
+  ],
+];
+for (const [file, required] of requiredReplacements) {
+  const source = fs.readFileSync(path.join(repositoryRoot, file), 'utf8');
+  if (!source.includes(required)) {
+    violations.push(`${file}:1: missing immutable boot replacement ${required}`);
+  }
+}
+
+const executedAsMain =
+  process.argv[1] !== undefined &&
+  path.resolve(process.argv[1]) === path.resolve(import.meta.filename);
+if (violations.length > 0) {
+  console.error(`Hard-cutover absence check failed (${violations.length} violations):`);
+  for (const violation of violations.sort()) console.error(`- ${violation}`);
+  process.exitCode = 1;
+} else if (executedAsMain) {
+  console.log('Hard-cutover absence check passed.');
+}
diff --git a/crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs b/crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs
new file mode 100644
index 000000000..549fef2bc
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs
@@ -0,0 +1,613 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const MANIFEST_FENCE = /```json retired-rcjuly-tsjs-concept-manifest-v1\n([\s\S]*?)\n```/g;
+const LEDGER_ID = /\| `(RCJ-[A-Z]+-[0-9]+)`/g;
+const QUALITY_ID = 'RCJ-QUAL-01';
+const SOURCE_ROOT = 'crates/trusted-server-js/lib/src/';
+const SHA_40 = /^[0-9a-f]{40}$/;
+const SHA_256 = /^[0-9a-f]{64}$/;
+const RECORDED_RETIRED_SNAPSHOT = '905984e62a0858c53d9f0ff6dd3a1bf190cf311d';
+const RECORDED_INVENTORY_SHA256 =
+  'b1e28c8b30f0b8d95e38c0f8f57394df4ad43f760ae7abf5631e2054228aef08';
+const RECORDED_MAIN_AUDIT_SHA = 'f6a2fb85ce623bf8a574e3941e1ee349acc3412d';
+const RECORDED_RC_BASELINE_SHA = '07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf';
+const RECORDED_HISTORICAL_MAIN_ROWS_SHA256 =
+  'c9cd93ee97e61a5765a7a569b2ea5693cbbb671484120afe4726d3b05fdced68';
+const HISTORICAL_PERFORMANCE_SHA256 =
+  'fe5d7f52dc47dc9608ca6b92b036c6b971845e6424b157768dc9403a62d2d6b4';
+const HISTORICAL_CLASSIFICATIONS = new Set(['main-owned', 'implementation-gap']);
+const RC_CLASSIFICATIONS = new Set(['baseline-owned', 'implementation-gap']);
+const RESULTS = new Set(['pass', 'fail']);
+const HISTORICAL_IMPLEMENTATION_GAP_IDS = new Set([
+  'RCJ-APS-03',
+  'RCJ-APS-04',
+  'RCJ-GPT-04',
+  'RCJ-QUAL-01',
+  'RCJ-TRACE-01',
+]);
+const RC_IMPLEMENTATION_GAP_IDS = new Set([
+  'RCJ-APS-03',
+  'RCJ-APS-04',
+  'RCJ-QUAL-01',
+  'RCJ-TRACE-01',
+]);
+const DISPOSITIONS = new Set(['preserve', 'rebuild', 'supersede', 'exclude']);
+const HISTORICAL_CLASSIFICATION_KEYS = [
+  'classification',
+  'command',
+  'disposition',
+  'id',
+  'mainSha',
+  'ownerPaths',
+  'result',
+  'testPath',
+];
+const RC_CLASSIFICATION_KEYS = [
+  'baselineSha',
+  'classification',
+  'command',
+  'disposition',
+  'id',
+  'ownerPaths',
+  'result',
+  'testPath',
+];
+const AUDIT_FIXTURE_KEYS = ['historicalMain', 'rcBaseline', 'version'];
+const HISTORICAL_MAIN_LAYER_KEYS = ['mainSha', 'rows'];
+const RC_BASELINE_LAYER_KEYS = ['baselineSha', 'rows'];
+const RETIRED_SOURCE_REFERENCE = /(?:rc[/-]july|905984e62a0858c53d9f0ff6dd3a1bf190cf311d)/i;
+const EXECUTABLE_SHELL_FENCE =
+  /^ {0,3}```(?:bash|sh|shell)(?:[ \t][^\n]*)?\r?\n([\s\S]*?)^ {0,3}```[ \t]*$/gim;
+const ALLOWED_RETIRED_RENAMES = new Set([
+  'git mv crates/trusted-server-js/lib/scripts/check-rc-july-adoption.mjs crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs',
+  'git mv crates/trusted-server-js/lib/test/contract/rc-july-adoption.test.mjs crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs',
+]);
+
+function codePointCompare(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+function sorted(values) {
+  return [...values].sort(codePointCompare);
+}
+
+function inventorySha256(inventory) {
+  const source = inventory.map((entry) => `${entry}\n`).join('');
+  return createHash('sha256').update(source, 'utf8').digest('hex');
+}
+
+function isAllowedRetiredRename(command) {
+  return ALLOWED_RETIRED_RENAMES.has(command.trim().replace(/\s+/g, ' '));
+}
+
+/** Return shell-fence logical lines containing a retired source reference. */
+export function auditRetiredPlanCommands(planSource) {
+  const violations = [];
+  for (const [fenceIndex, match] of [...planSource.matchAll(EXECUTABLE_SHELL_FENCE)].entries()) {
+    const executable = match[1].replace(/\\\r?\n/g, ' ');
+    for (const command of executable.split(/\r?\n/)) {
+      const trimmed = command.trim();
+      if (
+        trimmed.length === 0 ||
+        !RETIRED_SOURCE_REFERENCE.test(trimmed) ||
+        isAllowedRetiredRename(trimmed)
+      ) {
+        continue;
+      }
+      violations.push({ fence: fenceIndex + 1, command: trimmed });
+    }
+  }
+  return violations;
+}
+
+/** Return the number of executable shell fences examined by the plan-integrity scanner. */
+export function countExecutableShellFences(planSource) {
+  return [...planSource.matchAll(EXECUTABLE_SHELL_FENCE)].length;
+}
+
+function extractManifest(specSource) {
+  const matches = [...specSource.matchAll(MANIFEST_FENCE)];
+  if (matches.length !== 1 || typeof matches[0]?.[1] !== 'string') {
+    throw new Error(
+      `expected exactly one retired-rcjuly-tsjs-concept-manifest-v1 block, found ${matches.length}`
+    );
+  }
+
+  const manifest = JSON.parse(matches[0][1]);
+  if (manifest === null || typeof manifest !== 'object' || manifest.version !== 1) {
+    throw new Error('retired concept manifest must be a version 1 object');
+  }
+  if (manifest.authority !== 'concept-audit-only') {
+    throw new Error('retired concept manifest authority must be concept-audit-only');
+  }
+  if (!SHA_40.test(manifest.retiredSnapshot ?? '')) {
+    throw new Error(
+      'retired concept manifest retiredSnapshot must be a lowercase 40-character SHA'
+    );
+  }
+  if (manifest.retiredSnapshot !== RECORDED_RETIRED_SNAPSHOT) {
+    throw new Error(`retired concept manifest must name recorded retired snapshot`);
+  }
+  if (!Number.isInteger(manifest.inventoryCount) || !Array.isArray(manifest.inventory)) {
+    throw new Error('retired concept manifest inventoryCount/inventory has an invalid shape');
+  }
+  if (!SHA_256.test(manifest.inventorySha256 ?? '')) {
+    throw new Error('retired concept manifest inventorySha256 must be a lowercase SHA-256');
+  }
+  if (!Array.isArray(manifest.mappings)) {
+    throw new Error('retired concept manifest mappings must be an array');
+  }
+
+  const inventory = manifest.inventory;
+  if (inventory.some((entry) => typeof entry !== 'string' || entry.length === 0)) {
+    throw new Error('retired concept inventory entries must be non-empty strings');
+  }
+  if (manifest.inventoryCount !== inventory.length) {
+    throw new Error(
+      `inventoryCount ${manifest.inventoryCount} does not match ${inventory.length} inventory paths`
+    );
+  }
+  if (inventory.length !== 144) {
+    throw new Error(
+      `retired concept inventory must contain exactly 144 paths, found ${inventory.length}`
+    );
+  }
+  const uniqueInventory = new Set(inventory);
+  if (uniqueInventory.size !== inventory.length) {
+    throw new Error('retired concept inventory paths must be unique');
+  }
+  if (inventory.some((entry, index) => entry !== sorted(inventory)[index])) {
+    throw new Error('retired concept inventory paths must be code-point sorted');
+  }
+  const computedInventorySha256 = inventorySha256(inventory);
+  if (computedInventorySha256 !== manifest.inventorySha256) {
+    throw new Error(
+      `retired concept inventory SHA-256 mismatch: expected ${manifest.inventorySha256}, computed ${computedInventorySha256}`
+    );
+  }
+  if (manifest.inventorySha256 !== RECORDED_INVENTORY_SHA256) {
+    throw new Error('retired concept manifest must preserve the recorded inventory SHA-256');
+  }
+
+  for (const [index, mapping] of manifest.mappings.entries()) {
+    if (mapping === null || typeof mapping !== 'object') {
+      throw new Error(`mapping ${index} must be an object`);
+    }
+    if (!Array.isArray(mapping.ids) || mapping.ids.length === 0) {
+      throw new Error(`mapping ${index} must declare at least one id`);
+    }
+    if (mapping.ids.some((id) => typeof id !== 'string' || !/^RCJ-[A-Z]+-[0-9]+$/.test(id))) {
+      throw new Error(`mapping ${index} contains an invalid id`);
+    }
+    if (
+      mapping.exact !== undefined &&
+      (!Array.isArray(mapping.exact) ||
+        mapping.exact.length === 0 ||
+        mapping.exact.some((entry) => typeof entry !== 'string' || entry.length === 0))
+    ) {
+      throw new Error(`mapping ${index} has invalid exact paths`);
+    }
+    if (
+      mapping.prefix !== undefined &&
+      (typeof mapping.prefix !== 'string' || mapping.prefix.length === 0)
+    ) {
+      throw new Error(`mapping ${index} has an invalid prefix`);
+    }
+    if (
+      mapping.prefixes !== undefined &&
+      (!Array.isArray(mapping.prefixes) ||
+        mapping.prefixes.length === 0 ||
+        mapping.prefixes.some((entry) => typeof entry !== 'string' || entry.length === 0))
+    ) {
+      throw new Error(`mapping ${index} has invalid prefixes`);
+    }
+    if (
+      mapping.exact === undefined &&
+      mapping.prefix === undefined &&
+      mapping.prefixes === undefined
+    ) {
+      throw new Error(`mapping ${index} must declare exact, prefix, or prefixes`);
+    }
+  }
+
+  return manifest;
+}
+
+function mappingMatches(file, mapping) {
+  return (
+    (Array.isArray(mapping.exact) && mapping.exact.includes(file)) ||
+    (typeof mapping.prefix === 'string' && file.startsWith(mapping.prefix)) ||
+    (Array.isArray(mapping.prefixes) && mapping.prefixes.some((prefix) => file.startsWith(prefix)))
+  );
+}
+
+function mappingIdsForFile(file, mappings) {
+  const ids = new Set();
+  for (const mapping of mappings) {
+    if (!mappingMatches(file, mapping)) continue;
+    for (const id of mapping.ids) ids.add(id);
+  }
+  return ids;
+}
+
+function hasExactKeys(value, expectedKeys) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const keys = Object.keys(value).sort(codePointCompare);
+  return (
+    keys.length === expectedKeys.length && keys.every((key, index) => key === expectedKeys[index])
+  );
+}
+
+function auditEvidenceRows({
+  rows,
+  ledgerIds,
+  layerLabel,
+  shaKey,
+  expectedSha,
+  exactKeys,
+  classifications,
+  ownedClassification,
+  implementationGapIds,
+}) {
+  const failures = [];
+  if (!Array.isArray(rows)) {
+    return {
+      classifications: [],
+      classificationCounts: { implementationGap: 0, owned: 0 },
+      classificationFailures: [`${layerLabel} rows must be an array`],
+    };
+  }
+  if (rows.length !== 23) {
+    failures.push(`${layerLabel} expected exactly 23 classification rows, found ${rows.length}`);
+  }
+  const ids = rows.map((row) => row?.id).filter((id) => typeof id === 'string');
+  const seen = new Set();
+  const duplicateClassificationIds = sorted([
+    ...new Set(ids.filter((id) => (seen.has(id) ? true : !seen.add(id)))),
+  ]);
+  const fixtureIds = new Set(ids);
+  const missingClassificationIds = sorted([...ledgerIds].filter((id) => !fixtureIds.has(id)));
+  const extraClassificationIds = sorted([...fixtureIds].filter((id) => !ledgerIds.has(id)));
+  if (duplicateClassificationIds.length > 0) {
+    failures.push(`duplicateClassificationIds: ${JSON.stringify(duplicateClassificationIds)}`);
+  }
+  if (missingClassificationIds.length > 0) {
+    failures.push(`missingClassificationIds: ${JSON.stringify(missingClassificationIds)}`);
+  }
+  if (extraClassificationIds.length > 0) {
+    failures.push(`extraClassificationIds: ${JSON.stringify(extraClassificationIds)}`);
+  }
+
+  for (const [index, row] of rows.entries()) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row)) {
+      failures.push(`${layerLabel} classification row ${index} must be an object`);
+      continue;
+    }
+    const keys = Object.keys(row).sort(codePointCompare);
+    if (
+      keys.length !== exactKeys.length ||
+      keys.some((key, keyIndex) => key !== exactKeys[keyIndex])
+    ) {
+      failures.push(
+        `${layerLabel} classification row ${index} must contain the exact required fields`
+      );
+    }
+    const label = typeof row.id === 'string' ? row.id : `row ${index}`;
+    if (typeof row.id !== 'string' || !/^RCJ-[A-Z]+-[0-9]+$/.test(row.id)) {
+      failures.push(`${layerLabel} classification row ${index} must contain a valid RCJ id`);
+    }
+    if (row[shaKey] !== expectedSha) {
+      failures.push(`${label} ${shaKey} must equal ${expectedSha}`);
+    }
+    if (!classifications.has(row.classification)) {
+      failures.push(
+        `${label} classification must be ${[...classifications].join(' or ')}, not ${JSON.stringify(row.classification)}`
+      );
+    }
+    if (!Array.isArray(row.ownerPaths) || row.ownerPaths.length === 0) {
+      failures.push(`${label} ownerPaths must be a non-empty array`);
+    } else if (
+      row.ownerPaths.some(
+        (ownerPath) =>
+          typeof ownerPath !== 'string' ||
+          ownerPath.length === 0 ||
+          path.isAbsolute(ownerPath) ||
+          RETIRED_SOURCE_REFERENCE.test(ownerPath)
+      )
+    ) {
+      failures.push(
+        `${label} ownerPaths must name exact ${layerLabel} paths without historical source`
+      );
+    }
+    if (
+      typeof row.testPath !== 'string' ||
+      row.testPath.length === 0 ||
+      path.isAbsolute(row.testPath) ||
+      RETIRED_SOURCE_REFERENCE.test(row.testPath)
+    ) {
+      failures.push(`${label} testPath must name an exact focused ${layerLabel} test path`);
+    }
+    if (
+      typeof row.command !== 'string' ||
+      row.command.trim().length === 0 ||
+      RETIRED_SOURCE_REFERENCE.test(row.command)
+    ) {
+      failures.push(`${label} command must be reproducible and must not resolve historical source`);
+    }
+    if (!RESULTS.has(row.result)) {
+      failures.push(`${label} result must be pass or fail, not ${JSON.stringify(row.result)}`);
+    }
+    const expectedClassification = implementationGapIds.has(row.id)
+      ? 'implementation-gap'
+      : ownedClassification;
+    const expectedResult = implementationGapIds.has(row.id) ? 'fail' : 'pass';
+    if (row.classification !== expectedClassification || row.result !== expectedResult) {
+      failures.push(
+        `${label} authoritative classification/result for ${layerLabel} must be ${expectedClassification}/${expectedResult}`
+      );
+    }
+    if (!DISPOSITIONS.has(row.disposition)) {
+      failures.push(`${label} disposition is invalid`);
+    }
+    if (row.classification === ownedClassification && row.result !== 'pass') {
+      failures.push(`${label} ${ownedClassification} classification must record result pass`);
+    }
+    if (row.classification === 'implementation-gap' && row.result !== 'fail') {
+      failures.push(`${label} implementation-gap classification must record result fail`);
+    }
+    if (
+      row.classification === 'proof-pending' ||
+      row.classification === 'coverage-gap' ||
+      row.result === 'proof-pending' ||
+      row.result === 'coverage-gap'
+    ) {
+      failures.push(`${label} proof-pending and coverage-gap are not final classifications`);
+    }
+  }
+
+  const classificationCounts = {
+    implementationGap: rows.filter((row) => row?.classification === 'implementation-gap').length,
+    owned: rows.filter((row) => row?.classification === ownedClassification).length,
+  };
+  const expectedImplementationGapCount = implementationGapIds.size;
+  const expectedOwnedCount = 23 - expectedImplementationGapCount;
+  if (
+    classificationCounts.owned !== expectedOwnedCount ||
+    classificationCounts.implementationGap !== expectedImplementationGapCount
+  ) {
+    failures.push(
+      `authoritative classification counts for ${layerLabel} must be ${ownedClassification}=${expectedOwnedCount} and implementation-gap=${expectedImplementationGapCount}, found ${classificationCounts.owned}/${classificationCounts.implementationGap}`
+    );
+  }
+
+  return { classifications: rows, classificationCounts, classificationFailures: failures };
+}
+
+function auditClassifications({ auditFixturePath, ledgerIds, mainAuditSha, rcBaselineSha }) {
+  if (mainAuditSha !== RECORDED_MAIN_AUDIT_SHA) {
+    throw new Error(`MAIN_AUDIT_SHA must equal the recorded current-main SHA`);
+  }
+  if (!SHA_40.test(mainAuditSha ?? '')) {
+    throw new Error('MAIN_AUDIT_SHA must be the recorded lowercase 40-character current-main SHA');
+  }
+  if (rcBaselineSha !== RECORDED_RC_BASELINE_SHA) {
+    throw new Error(`RC_BASELINE_SHA must equal the recorded rc baseline SHA`);
+  }
+  if (!SHA_40.test(rcBaselineSha ?? '')) {
+    throw new Error('RC_BASELINE_SHA must be the recorded lowercase 40-character rc baseline SHA');
+  }
+
+  const fixture = JSON.parse(fs.readFileSync(auditFixturePath, 'utf8'));
+  if (!hasExactKeys(fixture, AUDIT_FIXTURE_KEYS) || fixture.version !== 2) {
+    throw new Error('concept audit fixture must be an exact version 2 object');
+  }
+  if (!hasExactKeys(fixture.historicalMain, HISTORICAL_MAIN_LAYER_KEYS)) {
+    throw new Error('concept audit fixture historicalMain must contain exact mainSha and rows');
+  }
+  if (!hasExactKeys(fixture.rcBaseline, RC_BASELINE_LAYER_KEYS)) {
+    throw new Error('concept audit fixture rcBaseline must contain exact baselineSha and rows');
+  }
+  if (fixture.historicalMain.mainSha !== mainAuditSha) {
+    throw new Error(`historicalMain mainSha must equal ${mainAuditSha}`);
+  }
+  if (fixture.rcBaseline.baselineSha !== rcBaselineSha) {
+    throw new Error(`rcBaseline baselineSha must equal ${rcBaselineSha}`);
+  }
+
+  const historicalMain = auditEvidenceRows({
+    rows: fixture.historicalMain.rows,
+    ledgerIds,
+    layerLabel: 'historical-main',
+    shaKey: 'mainSha',
+    expectedSha: mainAuditSha,
+    exactKeys: HISTORICAL_CLASSIFICATION_KEYS,
+    classifications: HISTORICAL_CLASSIFICATIONS,
+    ownedClassification: 'main-owned',
+    implementationGapIds: HISTORICAL_IMPLEMENTATION_GAP_IDS,
+  });
+  const historicalRowsSha256 = createHash('sha256')
+    .update(JSON.stringify(fixture.historicalMain.rows))
+    .digest('hex');
+  if (historicalRowsSha256 !== RECORDED_HISTORICAL_MAIN_ROWS_SHA256) {
+    historicalMain.classificationFailures.push(
+      `immutable historical-main evidence must remain ${RECORDED_HISTORICAL_MAIN_ROWS_SHA256}`
+    );
+  }
+
+  const rcBaseline = auditEvidenceRows({
+    rows: fixture.rcBaseline.rows,
+    ledgerIds,
+    layerLabel: 'rc-baseline',
+    shaKey: 'baselineSha',
+    expectedSha: rcBaselineSha,
+    exactKeys: RC_CLASSIFICATION_KEYS,
+    classifications: RC_CLASSIFICATIONS,
+    ownedClassification: 'baseline-owned',
+    implementationGapIds: RC_IMPLEMENTATION_GAP_IDS,
+  });
+  historicalMain.classificationCounts = {
+    implementationGap: historicalMain.classificationCounts.implementationGap,
+    mainOwned: historicalMain.classificationCounts.owned,
+  };
+  rcBaseline.classificationCounts = {
+    baselineOwned: rcBaseline.classificationCounts.owned,
+    implementationGap: rcBaseline.classificationCounts.implementationGap,
+  };
+
+  return {
+    fixtureVersion: fixture.version,
+    historicalMain: {
+      mainSha: mainAuditSha,
+      rowsSha256: historicalRowsSha256,
+      ...historicalMain,
+    },
+    rcBaseline: {
+      baselineSha: rcBaselineSha,
+      ...rcBaseline,
+    },
+  };
+}
+
+export function auditRetiredConceptAudit({
+  specPath,
+  auditFixturePath,
+  historicalPerformanceFixturePath,
+  mainAuditSha = RECORDED_MAIN_AUDIT_SHA,
+  rcBaselineSha = RECORDED_RC_BASELINE_SHA,
+  planPath,
+}) {
+  const specSource = fs.readFileSync(specPath, 'utf8');
+  const manifest = extractManifest(specSource);
+  const orderedFiles = [...manifest.inventory];
+  const unmappedFiles = orderedFiles.filter(
+    (file) => !manifest.mappings.some((mapping) => mappingMatches(file, mapping))
+  );
+  const qualityOnlySourceFiles = orderedFiles.filter((file) => {
+    if (!file.startsWith(SOURCE_ROOT)) return false;
+    const ids = mappingIdsForFile(file, manifest.mappings);
+    return ![...ids].some((id) => id !== QUALITY_ID);
+  });
+  const deadMappings = manifest.mappings
+    .map((mapping, index) => ({ index, mapping }))
+    .filter(({ mapping }) => !orderedFiles.some((file) => mappingMatches(file, mapping)))
+    .map(({ index }) => index);
+
+  const manifestIds = new Set(manifest.mappings.flatMap((mapping) => mapping.ids));
+  const ledgerIds = new Set([...specSource.matchAll(LEDGER_ID)].map((match) => match[1]));
+  const manifestOnlyIds = sorted([...manifestIds].filter((id) => !ledgerIds.has(id)));
+  const ledgerOnlyIds = sorted([...ledgerIds].filter((id) => !manifestIds.has(id)));
+
+  const result = {
+    authority: manifest.authority,
+    retiredSnapshot: manifest.retiredSnapshot,
+    inventorySha256: manifest.inventorySha256,
+    fileCount: orderedFiles.length,
+    mappingCount: manifest.mappings.length,
+    manifestIdCount: manifestIds.size,
+    ledgerIdCount: ledgerIds.size,
+    ledgerIds: sorted(ledgerIds),
+    unmappedFiles,
+    qualityOnlySourceFiles,
+    deadMappings,
+    manifestOnlyIds,
+    ledgerOnlyIds,
+  };
+  if (auditFixturePath !== undefined) {
+    Object.assign(
+      result,
+      auditClassifications({ auditFixturePath, ledgerIds, mainAuditSha, rcBaselineSha })
+    );
+  }
+  if (planPath !== undefined) {
+    result.retiredPlanCommandViolations = auditRetiredPlanCommands(
+      fs.readFileSync(planPath, 'utf8')
+    );
+  }
+  if (historicalPerformanceFixturePath !== undefined) {
+    result.historicalPerformanceEvidence = {
+      authority: 'report-only',
+      sha256: createHash('sha256')
+        .update(fs.readFileSync(historicalPerformanceFixturePath))
+        .digest('hex'),
+    };
+  }
+  return result;
+}
+
+export function assertRetiredConceptAudit(result) {
+  const failures = [];
+  if (result.fileCount !== 144) failures.push(`expected 144 files, found ${result.fileCount}`);
+  if (result.mappingCount !== 38) {
+    failures.push(`expected 38 mappings, found ${result.mappingCount}`);
+  }
+  if (result.manifestIdCount !== 23 || result.ledgerIdCount !== 23) {
+    failures.push(
+      `expected 23 manifest/ledger ids, found ${result.manifestIdCount}/${result.ledgerIdCount}`
+    );
+  }
+  for (const key of [
+    'unmappedFiles',
+    'qualityOnlySourceFiles',
+    'deadMappings',
+    'manifestOnlyIds',
+    'ledgerOnlyIds',
+  ]) {
+    if (result[key].length > 0) failures.push(`${key}: ${JSON.stringify(result[key])}`);
+  }
+  failures.push(...(result.historicalMain?.classificationFailures ?? []));
+  failures.push(...(result.rcBaseline?.classificationFailures ?? []));
+  if ((result.retiredPlanCommandViolations ?? []).length > 0) {
+    failures.push(
+      `retiredPlanCommandViolations: ${JSON.stringify(result.retiredPlanCommandViolations)}`
+    );
+  }
+  if (
+    result.historicalPerformanceEvidence !== undefined &&
+    (result.historicalPerformanceEvidence.authority !== 'report-only' ||
+      result.historicalPerformanceEvidence.sha256 !== HISTORICAL_PERFORMANCE_SHA256)
+  ) {
+    failures.push(
+      `historicalPerformanceEvidence must remain report-only at ${HISTORICAL_PERFORMANCE_SHA256}`
+    );
+  }
+  if (failures.length > 0) throw new Error(failures.join('\n'));
+}
+
+const scriptPath = fileURLToPath(import.meta.url);
+if (process.argv[1] && path.resolve(process.argv[1]) === scriptPath) {
+  const repositoryRoot = path.resolve(path.dirname(scriptPath), '../../../..');
+  const specPath = path.join(
+    repositoryRoot,
+    'docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md'
+  );
+  const auditFixturePath = path.join(
+    repositoryRoot,
+    'crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json'
+  );
+  const planPath = path.join(
+    repositoryRoot,
+    'docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md'
+  );
+  const historicalPerformanceFixturePath = path.join(
+    repositoryRoot,
+    'crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json'
+  );
+  const configuredMainAuditSha = process.env.MAIN_AUDIT_SHA ?? RECORDED_MAIN_AUDIT_SHA;
+  const configuredRcBaselineSha = process.env.RC_BASELINE_SHA ?? RECORDED_RC_BASELINE_SHA;
+  const result = auditRetiredConceptAudit({
+    specPath,
+    auditFixturePath,
+    historicalPerformanceFixturePath,
+    mainAuditSha: configuredMainAuditSha,
+    rcBaselineSha: configuredRcBaselineSha,
+    planPath,
+  });
+  assertRetiredConceptAudit(result);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
diff --git a/crates/trusted-server-js/lib/scripts/integration-inventory-v1.d.mts b/crates/trusted-server-js/lib/scripts/integration-inventory-v1.d.mts
new file mode 100644
index 000000000..ce0f9ebe6
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/integration-inventory-v1.d.mts
@@ -0,0 +1 @@
+export function discoverIntegrationModules(integrationsDirectory: string): string[];
diff --git a/crates/trusted-server-js/lib/scripts/integration-inventory-v1.mjs b/crates/trusted-server-js/lib/scripts/integration-inventory-v1.mjs
new file mode 100644
index 000000000..8737f37c0
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/integration-inventory-v1.mjs
@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** Discover the canonical integration bundle inventory used by build and runtime tests. */
+export function discoverIntegrationModules(integrationsDirectory) {
+  if (!fs.existsSync(integrationsDirectory)) return [];
+  return fs
+    .readdirSync(integrationsDirectory)
+    .filter((name) => {
+      const fullPath = path.join(integrationsDirectory, name);
+      return fs.statSync(fullPath).isDirectory() && fs.existsSync(path.join(fullPath, 'index.ts'));
+    })
+    .sort();
+}
diff --git a/crates/trusted-server-js/lib/scripts/print-release-id.mjs b/crates/trusted-server-js/lib/scripts/print-release-id.mjs
new file mode 100644
index 000000000..13d37b845
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/print-release-id.mjs
@@ -0,0 +1,89 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { computeReleaseId, RELEASE_SENTINEL } from './release-v1.mjs';
+
+const directory = path.dirname(fileURLToPath(import.meta.url));
+const distDirectory = path.resolve(directory, '..', '..', 'dist');
+const FIRST_DISPLAY_ARTIFACT_COUNT = 14;
+const CORE_ARTIFACT_INDEX = 1 + FIRST_DISPLAY_ARTIFACT_COUNT;
+const INTEGRATION_ARTIFACT_COUNT = 20;
+const RELEASE_ARTIFACT_COUNT = CORE_ARTIFACT_INDEX + 1 + INTEGRATION_ARTIFACT_COUNT;
+const value = JSON.parse(fs.readFileSync(path.join(distDirectory, 'tsjs-release-v1.json'), 'utf8'));
+if (
+  typeof value !== 'object' ||
+  value === null ||
+  Array.isArray(value) ||
+  Object.keys(value).join(',') !== 'version,releaseId,artifacts' ||
+  value.version !== 1 ||
+  !/^[0-9a-f]{64}$/.test(value.releaseId) ||
+  !Array.isArray(value.artifacts) ||
+  value.artifacts.length !== RELEASE_ARTIFACT_COUNT
+) {
+  throw new Error('Invalid tsjs-release-v1.json');
+}
+
+const normalized = [];
+const files = new Set();
+for (const [index, artifact] of value.artifacts.entries()) {
+  if (
+    typeof artifact !== 'object' ||
+    artifact === null ||
+    Array.isArray(artifact) ||
+    Object.keys(artifact).join(',') !== 'id,role,phase,trigger,inputs,outputs,file,bytes,hash' ||
+    !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(artifact.id) ||
+    !['bootstrap', 'first_display_base', 'first_display_slice', 'core', 'integration'].includes(
+      artifact.role
+    ) ||
+    !Array.isArray(artifact.inputs) ||
+    !Array.isArray(artifact.outputs) ||
+    !Number.isSafeInteger(artifact.bytes) ||
+    artifact.bytes <= 0 ||
+    !/^[0-9a-f]{64}$/.test(artifact.hash) ||
+    files.has(artifact.file)
+  ) {
+    throw new Error('Invalid canonical artifact inventory');
+  }
+  if (
+    (index === 0 &&
+      (artifact.id !== 'bootstrap' || artifact.role !== 'bootstrap' || artifact.phase !== null)) ||
+    (index === 1 &&
+      (artifact.id !== 'first_display' ||
+        artifact.role !== 'first_display_base' ||
+        artifact.phase !== 'first_display')) ||
+    (index > 1 &&
+      index < CORE_ARTIFACT_INDEX &&
+      (artifact.role !== 'first_display_slice' || artifact.phase !== 'first_display')) ||
+    (index === CORE_ARTIFACT_INDEX &&
+      (artifact.id !== 'core' || artifact.role !== 'core' || artifact.phase !== null)) ||
+    (index > CORE_ARTIFACT_INDEX &&
+      (artifact.role !== 'integration' || !['takeover', 'deferred'].includes(artifact.phase)))
+  ) {
+    throw new Error('Invalid canonical artifact role/order');
+  }
+  files.add(artifact.file);
+  const bytes = fs.readFileSync(path.join(distDirectory, artifact.file));
+  const source = bytes.toString('utf8');
+  if (
+    bytes.byteLength !== artifact.bytes ||
+    createHash('sha256').update(bytes).digest('hex') !== artifact.hash ||
+    source.includes(RELEASE_SENTINEL) ||
+    source.split(value.releaseId).length - 1 !== 1
+  ) {
+    throw new Error(`Artifact release mismatch: ${artifact.file}`);
+  }
+  normalized.push({
+    id: artifact.id,
+    role: artifact.role,
+    phase: artifact.phase ?? '',
+    trigger: artifact.trigger ?? '',
+    bytes: Buffer.from(source.replace(value.releaseId, RELEASE_SENTINEL)),
+  });
+}
+if (computeReleaseId(normalized) !== value.releaseId) {
+  throw new Error('Release manifest does not match canonical artifact bytes');
+}
+
+process.stdout.write(`${value.releaseId}\n`);
diff --git a/crates/trusted-server-js/lib/scripts/release-v1.mjs b/crates/trusted-server-js/lib/scripts/release-v1.mjs
new file mode 100644
index 000000000..324ae4db3
--- /dev/null
+++ b/crates/trusted-server-js/lib/scripts/release-v1.mjs
@@ -0,0 +1,74 @@
+import { createHash } from 'node:crypto';
+
+export const RELEASE_SENTINEL = '__TSJS_RELEASE_ID_SENTINEL_V1__';
+
+const RELEASE_PREFIX = Buffer.from('tsjs-release-v1\0', 'ascii');
+
+function u64(value) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new Error('Invalid release frame length');
+  const bytes = Buffer.alloc(8);
+  bytes.writeBigUInt64BE(BigInt(value));
+  return bytes;
+}
+
+function framed(value) {
+  const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value, 'utf8');
+  return Buffer.concat([u64(bytes.byteLength), bytes]);
+}
+
+function validateArtifact(artifact, seen) {
+  if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(artifact.id) || seen.has(artifact.id)) {
+    throw new Error('Invalid release bundle id');
+  }
+  for (const field of ['role', 'phase', 'trigger']) {
+    if (typeof artifact[field] !== 'string') {
+      throw new Error(`Invalid release artifact ${field}: ${artifact.id}`);
+    }
+  }
+  seen.add(artifact.id);
+}
+
+export function computeReleaseId(artifacts) {
+  const hasher = createHash('sha256');
+  hasher.update(RELEASE_PREFIX);
+  hasher.update(u64(artifacts.length));
+  const seen = new Set();
+  for (const artifact of artifacts) {
+    validateArtifact(artifact, seen);
+    const bytes = Buffer.isBuffer(artifact.bytes)
+      ? artifact.bytes
+      : Buffer.from(artifact.bytes, 'utf8');
+    if (bytes.toString('utf8').split(RELEASE_SENTINEL).length - 1 !== 1) {
+      throw new Error(`Expected exactly one release sentinel: ${artifact.id}`);
+    }
+    hasher.update(framed(artifact.id));
+    hasher.update(framed(artifact.role));
+    hasher.update(framed(artifact.phase));
+    hasher.update(framed(artifact.trigger));
+    hasher.update(framed(bytes));
+  }
+  return hasher.digest('hex');
+}
+
+export function stampRelease(bytes, releaseId) {
+  if (!/^[0-9a-f]{64}$/.test(releaseId)) throw new Error('Invalid release id');
+  const source = Buffer.isBuffer(bytes) ? bytes.toString('utf8') : String(bytes);
+  if (source.split(RELEASE_SENTINEL).length - 1 !== 1) {
+    throw new Error('Expected exactly one release sentinel');
+  }
+  const stamped = source.replace(RELEASE_SENTINEL, releaseId);
+  if (stamped.includes(RELEASE_SENTINEL)) throw new Error('Release sentinel remains');
+  return stamped;
+}
+
+export function validateStampedRelease(bundles, releaseId, requiredIds) {
+  const byId = new Map(bundles.map((bundle) => [bundle.id, bundle.bytes]));
+  for (const id of requiredIds) {
+    const bytes = byId.get(id);
+    if (bytes === undefined) throw new Error(`Missing release bundle: ${id}`);
+    const source = Buffer.isBuffer(bytes) ? bytes.toString('utf8') : String(bytes);
+    if (source.includes(RELEASE_SENTINEL) || source.split(releaseId).length - 1 !== 1) {
+      throw new Error(`Bundle release mismatch: ${id}`);
+    }
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/adapters/googletag.ts b/crates/trusted-server-js/lib/src/adapters/googletag.ts
new file mode 100644
index 000000000..e6f8a9a56
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/adapters/googletag.ts
@@ -0,0 +1,3154 @@
+const EXTERNAL_READY_TIMEOUT_MS = 10_000;
+const MAX_PENDING_OPERATIONS = 64;
+
+/** The live state of the publisher-owned `window.googletag` binding. */
+export type GoogletagBindingStatus = 'present' | 'pending' | 'incompatible';
+
+/** The readiness state owned by one GPT operation. */
+export type GoogletagOperationStatus = GoogletagBindingStatus | 'timed_out';
+
+/** Failure codes produced at the GPT adapter boundary. */
+export type GoogletagAdapterErrorCode =
+  | 'caller_aborted'
+  | 'external_artifact_incompatible'
+  | 'external_queue_full'
+  | 'external_ready_timeout'
+  | 'operation_disposed';
+
+/** A typed failure contained by the GPT adapter. */
+export class GoogletagAdapterError extends Error {
+  public readonly code: GoogletagAdapterErrorCode;
+
+  public constructor(code: GoogletagAdapterErrorCode) {
+    super(code);
+    this.name = 'GoogletagAdapterError';
+    this.code = code;
+  }
+}
+
+/** Immutable GPT definition used by the adapter-owned replacement transaction. */
+export interface GoogletagReplacementDefinition {
+  readonly adUnitPath: string;
+  readonly elementId: string;
+  readonly sizes: unknown;
+}
+
+/** Reversible synchronous admission for one newly defined GPT identity. */
+export interface GoogletagReplacementCommitAdmission {
+  commit(): boolean;
+  rollback(): void;
+}
+
+/** Outcome of one adapter-owned initial GPT slot-definition transaction. */
+export type GoogletagDefinitionResult = Readonly<
+  { status: 'discarded' } | { status: 'defined'; slot: object }
+>;
+
+/** Failure to define or synchronously retire one adapter-owned GPT slot. */
+export class GoogletagDefinitionError extends Error {
+  public readonly code = 'gpt_definition_failed';
+  public readonly cause: unknown;
+  public readonly orphanedSlot: object | undefined;
+
+  public constructor(orphanedSlot?: object, cause?: unknown) {
+    super('gpt_definition_failed');
+    this.name = 'GoogletagDefinitionError';
+    this.orphanedSlot = orphanedSlot;
+    this.cause = cause;
+  }
+}
+
+/** Successful outcome of one GPT destroy/redefine transaction. */
+export type GoogletagReplacementResult = Readonly<
+  { status: 'destroyed' } | { status: 'replaced'; slot: object }
+>;
+
+/** Failure from a replacement transaction, including any candidate GPT could not destroy. */
+export class GoogletagReplacementError extends Error {
+  public readonly code = 'gpt_replacement_failed';
+  public readonly cause: unknown;
+  public readonly oldSlotDestroyed: boolean;
+  public readonly orphanedSlot: object | undefined;
+  public readonly preserveOldQuarantine: boolean;
+
+  public constructor(
+    orphanedSlot?: object,
+    oldSlotDestroyed = false,
+    cause?: unknown,
+    preserveOldQuarantine = false
+  ) {
+    super('gpt_replacement_failed');
+    this.name = 'GoogletagReplacementError';
+    this.orphanedSlot = orphanedSlot;
+    this.oldSlotDestroyed = oldSlotDestroyed;
+    this.cause = cause;
+    this.preserveOldQuarantine = preserveOldQuarantine;
+  }
+}
+
+/** Internal signal that a defineSlot result is already owned by another live record. */
+export class GoogletagReplacementCandidateCollisionError extends Error {
+  public readonly candidate: object;
+
+  public constructor(candidate: object) {
+    super('gpt_replacement_candidate_collision');
+    this.name = 'GoogletagReplacementCandidateCollisionError';
+    this.candidate = candidate;
+  }
+}
+
+/** Observer called before a publisher-originated targeting mutation is forwarded. */
+export interface GoogletagTargetingObserver {
+  readonly beforePublisherMutation: (slot: object, key?: string) => void;
+}
+
+/** Callable targeting observation release with an exact wrapper-identity latch. */
+export interface GoogletagTargetingObservation {
+  (): void;
+  readonly isCurrent: () => boolean;
+}
+
+/** Reversible bookkeeping prepared before one publisher GPT call. */
+export interface GoogletagPublisherCallAdmission {
+  readonly commit: () => void;
+  readonly rollback: () => void;
+}
+
+/** One publisher-originated GPT call observed outside Trusted Server operations. */
+export interface GoogletagPublisherCallObserver {
+  readonly defineSlot?: (
+    call: Readonly<GoogletagPublisherDefineSlotCall>
+  ) => Readonly<{ action: 'forward' }> | Readonly<{ action: 'handoff'; slot: object }>;
+  readonly destroySlots?: (call: Readonly<GoogletagPublisherDestroySlotsCall>) => void;
+  readonly display?: (
+    call: Readonly<GoogletagPublisherDisplayCall>
+  ) =>
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{ action: 'suppress' }>;
+  readonly refresh?: (call: Readonly<GoogletagPublisherRefreshCall>) =>
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{
+        action: 'replace';
+        slots: readonly object[];
+        admission?: GoogletagPublisherCallAdmission;
+      }>
+    | Readonly<{
+        action: 'defer';
+        slots: readonly object[];
+        completion: PromiseLike<unknown>;
+        admission?: GoogletagPublisherCallAdmission;
+      }>
+    | Readonly<{ action: 'suppress' }>;
+}
+
+/** Narrow data supplied before one publisher `defineSlot` call. */
+export interface GoogletagPublisherDefineSlotCall {
+  readonly adUnitPath: unknown;
+  readonly elementId: unknown;
+  readonly initialLoadDisabled: boolean;
+  readonly sizes: unknown;
+}
+
+/** Narrow data supplied after one successful publisher `destroySlots` call. */
+export interface GoogletagPublisherDestroySlotsCall {
+  readonly slots: readonly object[];
+}
+
+/** Narrow data supplied before one publisher `display` call. */
+export interface GoogletagPublisherDisplayCall {
+  readonly initialLoadDisabled: boolean;
+  readonly target: unknown;
+}
+
+/** Narrow data supplied before one publisher `refresh` call. */
+export interface GoogletagPublisherRefreshCall {
+  readonly requestedSlots: readonly object[] | undefined;
+  readonly slots: readonly object[];
+  readonly options?: unknown;
+}
+
+/** The small GPT surface exposed to an accepted operation. */
+export interface GoogletagFacade {
+  adUnitPath?(slot: object): unknown;
+  bindingToken(): object;
+  clearTargeting(slot: object, key?: string): unknown;
+  /** Enable SRA and GPT services exactly once before the first TS-owned request. */
+  enableServices(): void;
+  transactionalDefine(
+    definition: GoogletagReplacementDefinition,
+    isGenerationCurrent: () => boolean,
+    prepareCommit: (slot: object) => GoogletagReplacementCommitAdmission
+  ): GoogletagDefinitionResult;
+  display(slot: string | object): unknown;
+  getTargeting(slot: object, key: string): readonly string[];
+  observeTargeting(
+    slot: object,
+    observer: GoogletagTargetingObserver
+  ): GoogletagTargetingObservation;
+  refresh(slots?: readonly object[], options?: Readonly<{ changeCorrelator: boolean }>): unknown;
+  serviceState(): Readonly<{
+    apiReady: boolean;
+    initialLoadDisabled: boolean;
+    pubadsReady: boolean;
+  }>;
+  setTargeting(slot: object, key: string, value: string | readonly string[]): unknown;
+  slotElementId?(slot: object): unknown;
+  slots(): readonly object[];
+  subscribe(
+    eventType: string,
+    listener: (event: unknown) => Readonly<GoogletagTraceCycleHandle> | void,
+    diagnosticsOwner?: boolean
+  ): () => void;
+  transactionalReplace(
+    oldSlot: object,
+    definition: GoogletagReplacementDefinition | undefined,
+    isGenerationCurrent: () => boolean,
+    prepareCommit: (replacement: object) => GoogletagReplacementCommitAdmission
+  ): GoogletagReplacementResult;
+}
+
+/** Options owned by one GPT operation. */
+export interface GoogletagOperationOptions {
+  readonly signal?: AbortSignal;
+}
+
+/** A disposable GPT operation and its readiness-scoped result. */
+export interface GoogletagOperation<T> {
+  readonly status: GoogletagOperationStatus;
+  readonly result: Promise<T>;
+  dispose(): void;
+}
+
+/** Narrow GPT boundary consumed by kernel sessions and services. */
+export interface GoogletagAdapter {
+  bindingStatus(): GoogletagBindingStatus;
+  enqueueGamAttribution(): boolean;
+  adoptDiagnosticsState?(input: GoogletagDiagnosticsAdoptionV1): boolean;
+  diagnosticsIdentity(slot: object): Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined;
+  traceToken(slot: object): GptSlotTokenV1 | undefined;
+  observeDiagnostics(observer: GoogletagDiagnosticsObserver): (() => void) | undefined;
+  observePublisherCalls(observer: GoogletagPublisherCallObserver): () => void;
+  run<T>(
+    command: (googletag: Readonly<GoogletagFacade>) => T,
+    options?: GoogletagOperationOptions
+  ): GoogletagOperation<T>;
+  notifyReady(): void;
+  dispose(): void;
+}
+
+export interface GoogletagDiagnosticsAdoptionV1 {
+  readonly nextTraceTokenOrdinal: number;
+  readonly slots: readonly Readonly<{
+    readonly nextCycleOrdinal: number;
+    readonly physicalSlot: object;
+    readonly records: readonly Readonly<{
+      readonly ordinal: number;
+      readonly responseIdentifier: string | null;
+      readonly seen: readonly GoogletagDiagnosticsEventName[];
+      readonly state: 'open' | 'completed' | 'retired';
+    }>[];
+    readonly traceToken: string;
+    readonly unknownPriorCycle: boolean;
+  }>[];
+}
+
+export type GoogletagDiagnosticsEventName =
+  | 'slotRequested'
+  | 'slotResponseReceived'
+  | 'slotRenderEnded'
+  | 'slotOnload'
+  | 'impressionViewable'
+  | 'slotVisibilityChanged';
+
+/** Safe Ad Manager identifiers copied from one GPT render callback. */
+export interface GoogletagDiagnosticsAdManagerIdentity {
+  readonly lineItemId?: number;
+  readonly creativeId?: number;
+  readonly campaignId?: number;
+  readonly advertiserId?: number;
+  readonly sourceAgnosticLineItemId?: number;
+  readonly sourceAgnosticCreativeId?: number;
+  readonly yieldGroupIds?: readonly number[];
+  readonly companyIds?: readonly number[];
+}
+
+export interface GoogletagDiagnosticsFact {
+  readonly kind: GoogletagDiagnosticsEventName;
+  readonly observedAtMs: number;
+  readonly slot: GoogletagDiagnosticsSlotSnapshot;
+  readonly isEmpty?: boolean;
+  readonly size?: readonly [number, number];
+  readonly isBackfill?: boolean;
+  readonly slotContentChanged?: boolean;
+  readonly inViewPercentage?: number;
+  readonly responseIdentifier?: string;
+  readonly adManager?: GoogletagDiagnosticsAdManagerIdentity;
+}
+
+export type GptSlotTokenV1 = string & { readonly __brand: 'GptSlotTokenV1' };
+export type GptTraceCycleOrdinalV1 = number & {
+  readonly __brand: 'GptTraceCycleOrdinalV1';
+};
+
+/** Exact lifecycle-owned attribution accepted by the GPT diagnostics producer. */
+export interface GoogletagTraceCycleHandle {
+  readonly isRetired: () => boolean;
+}
+
+const googletagTraceCycleHandles = new WeakSet<object>();
+
+/** Create one opaque adapter-branded handle for an accepted physical request cycle. */
+export function createGoogletagTraceCycleHandle(
+  isRetired: () => boolean
+): Readonly<GoogletagTraceCycleHandle> {
+  if (typeof isRetired !== 'function') throw new TypeError('invalid GPT trace cycle retirement');
+  const handle = Object.freeze({ isRetired });
+  googletagTraceCycleHandles.add(handle);
+  return handle;
+}
+
+function acceptedTraceCycleHandle(value: unknown): value is Readonly<GoogletagTraceCycleHandle> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Object.isFrozen(value) &&
+    googletagTraceCycleHandles.has(value)
+  );
+}
+
+/** Frozen, non-authoritative identity and metadata captured from one physical GPT slot. */
+export interface GoogletagDiagnosticsSlotSnapshot {
+  readonly token: object;
+  readonly traceToken?: GptSlotTokenV1;
+  readonly runtimeSlotNumber?: number;
+  readonly cycleOrdinal?: GptTraceCycleOrdinalV1;
+  readonly elementId?: string;
+  readonly adUnitPath?: string;
+}
+
+export type GoogletagDiagnosticsObserver = (fact: Readonly<GoogletagDiagnosticsFact>) => void;
+
+/** Browser surface owned by the concrete GPT adapter. */
+export interface GoogletagGlobalTarget {
+  googletag?: unknown;
+  performance?: unknown;
+}
+
+export type GoogletagDiagnosticsFailureCode =
+  | 'trace_cycle_ambiguity'
+  | 'trace_cycle_collision'
+  | 'trace_cycle_exhausted'
+  | 'trace_cycle_invalid'
+  | 'trace_token_collision'
+  | 'trace_token_exhausted'
+  | 'trace_token_invalid';
+
+/** Test seams and local reporting for diagnostics-only identity construction. */
+export interface GoogletagDiagnosticsIdentityOptions {
+  readonly initialTraceCycleOrdinal?: number;
+  readonly initialTraceTokenOrdinal?: number;
+  readonly mintTraceToken?: (ordinal: number) => unknown;
+  readonly reportDiagnosticsFailure?: (code: GoogletagDiagnosticsFailureCode) => void;
+}
+
+interface CommandQueue {
+  readonly binding: object;
+  readonly push: (...arguments_: unknown[]) => unknown;
+}
+
+interface PresentGoogletag {
+  readonly binding: object;
+  readonly commandQueue: CommandQueue;
+  readonly display: (...arguments_: unknown[]) => unknown;
+  readonly pubads: (...arguments_: unknown[]) => unknown;
+}
+
+interface ProvisionalEffect {
+  promote(): void;
+  release(): void;
+}
+
+interface AbortRegistration {
+  readonly binding: object;
+  readonly listener: () => void;
+  readonly remove: (...arguments_: unknown[]) => unknown;
+  attempted: boolean;
+  cleanupRequested: boolean;
+  installing: boolean;
+}
+
+interface PendingOperation<T> {
+  state: GoogletagOperationStatus;
+  settled: boolean;
+  pendingReservation: boolean;
+  timeout: ReturnType<typeof setTimeout> | undefined;
+  readonly command: (googletag: Readonly<GoogletagFacade>) => T;
+  readonly resolve: (value: T | PromiseLike<T>) => void;
+  readonly reject: (reason: unknown) => void;
+  abortRegistration: AbortRegistration | undefined;
+  readinessBinding: object | undefined;
+  readonly provisionalEffects: ProvisionalEffect[];
+}
+
+interface SharedInitialLoadTracker {
+  disabled: boolean;
+  rootWrapped: boolean;
+  readonly owners: Set<object>;
+  readonly restorers: Set<() => void>;
+  readonly services: WeakMap<object, () => void>;
+}
+
+interface TargetingObservation {
+  readonly isCurrent: () => boolean;
+  readonly observers: Set<GoogletagTargetingObserver>;
+  readonly restore: () => void;
+}
+
+const sharedInitialLoadTrackers = new WeakMap<object, SharedInitialLoadTracker>();
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapGetIntrinsic = Map.prototype.get;
+const mapKeysIntrinsic = Map.prototype.keys;
+const setDeleteIntrinsic = Set.prototype.delete;
+const setAddIntrinsic = Set.prototype.add;
+const setHasIntrinsic = Set.prototype.has;
+const setSizeGetter = Object.getOwnPropertyDescriptor(Set.prototype, 'size')?.get as (
+  this: Set<unknown>
+) => number;
+const setValuesIntrinsic = Set.prototype.values;
+const setIteratorNextIntrinsic = Object.getPrototypeOf(new Set().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const weakMapDeleteIntrinsic = WeakMap.prototype.delete;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+const weakSetDeleteIntrinsic = WeakSet.prototype.delete;
+
+function mapValue<K, V>(map: Map<K, V>, key: K): V | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as V | undefined;
+}
+
+function mapKeys<K, V>(map: Map<K, V>): IterableIterator<K> {
+  return Reflect.apply(mapKeysIntrinsic, map, []) as IterableIterator<K>;
+}
+
+function deleteMapValue<K, V>(map: Map<K, V>, key: K): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function deleteSetValue<T>(set: Set<T>, value: T): boolean {
+  return Reflect.apply(setDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function addSetValue<T>(set: Set<T>, value: T): void {
+  Reflect.apply(setAddIntrinsic, set, [value]);
+}
+
+function setHasValue<T>(set: Set<T>, value: T): boolean {
+  return Reflect.apply(setHasIntrinsic, set, [value]) as boolean;
+}
+
+function setValues<T>(set: Set<T>): IterableIterator<T> {
+  return Reflect.apply(setValuesIntrinsic, set, []) as IterableIterator<T>;
+}
+
+function setValueSnapshot<T>(set: Set<T>): T[] {
+  const iterator = setValues(set);
+  const values: T[] = [];
+  while (true) {
+    const step = Reflect.apply(setIteratorNextIntrinsic, iterator, []) as IteratorResult<T>;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function setSize(set: Set<unknown>): number {
+  return Reflect.apply(setSizeGetter, set, []) as number;
+}
+
+function weakMapValue<K extends object, V>(map: WeakMap<K, V>, key: K): V | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, map, [key]) as V | undefined;
+}
+
+function setWeakMapValue<K extends object, V>(map: WeakMap<K, V>, key: K, value: V): void {
+  Reflect.apply(weakMapSetIntrinsic, map, [key, value]);
+}
+
+function deleteWeakMapValue<K extends object, V>(map: WeakMap<K, V>, key: K): boolean {
+  return Reflect.apply(weakMapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function deleteWeakSetValue<T extends object>(set: WeakSet<T>, value: T): boolean {
+  return Reflect.apply(weakSetDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function safeMember(binding: object, key: PropertyKey): unknown {
+  try {
+    return Reflect.get(binding, key);
+  } catch {
+    return undefined;
+  }
+}
+
+function commandQueue(binding: object): CommandQueue | undefined {
+  const candidate = safeMember(binding, 'cmd');
+  if ((typeof candidate !== 'object' || candidate === null) && typeof candidate !== 'function') {
+    return undefined;
+  }
+  const push = safeMember(candidate, 'push');
+  return typeof push === 'function'
+    ? {
+        binding: candidate as object,
+        push: push as (...arguments_: unknown[]) => unknown,
+      }
+    : undefined;
+}
+
+function inspectBinding(
+  value: unknown
+):
+  | { readonly status: 'pending'; readonly binding?: object; readonly commandQueue?: CommandQueue }
+  | { readonly status: 'incompatible'; readonly binding?: object }
+  | { readonly status: 'present'; readonly value: PresentGoogletag } {
+  if (value === undefined || value === null) return { status: 'pending' };
+  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') {
+    return { status: 'incompatible' };
+  }
+  const binding = value as object;
+  const queue = commandQueue(binding);
+  if (!queue) return { status: 'incompatible', binding };
+  if (safeMember(binding, 'apiReady') !== true) {
+    return { status: 'pending', binding, commandQueue: queue };
+  }
+  const display = safeMember(binding, 'display');
+  const pubads = safeMember(binding, 'pubads');
+  if (typeof display !== 'function' || typeof pubads !== 'function') {
+    return { status: 'incompatible', binding };
+  }
+  return {
+    status: 'present',
+    value: {
+      binding,
+      commandQueue: queue,
+      display: display as (...arguments_: unknown[]) => unknown,
+      pubads: pubads as (...arguments_: unknown[]) => unknown,
+    },
+  };
+}
+
+function readTarget(target: GoogletagGlobalTarget): unknown {
+  try {
+    return target.googletag;
+  } catch {
+    return false;
+  }
+}
+
+function queueCommand(queue: CommandQueue, command: () => void, guard?: () => boolean): void {
+  if (guard && !guard()) throw new GoogletagAdapterError('external_artifact_incompatible');
+  Reflect.apply(queue.push, queue.binding, [command]);
+  if (guard && !guard()) throw new GoogletagAdapterError('external_artifact_incompatible');
+}
+
+function asObject(value: unknown): object {
+  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') {
+    throw new GoogletagAdapterError('external_artifact_incompatible');
+  }
+  return value;
+}
+
+function createFacade(
+  binding: PresentGoogletag,
+  registerEffect: (dispose: () => void) => () => void,
+  isOperationCurrent: () => boolean,
+  isBindingCurrent: () => boolean,
+  initialLoadDisabled: (service: object) => boolean,
+  targetingObservations: WeakMap<object, TargetingObservation>,
+  bindingToken: object,
+  markFirstDisplay: () => void,
+  invokeFacadeCall: (
+    callable: (...arguments_: unknown[]) => unknown,
+    receiver: unknown,
+    arguments_: readonly unknown[]
+  ) => unknown,
+  consumeFacadeCall: (callable: (...arguments_: unknown[]) => unknown) => boolean,
+  publishDiagnostics: (
+    eventType: string,
+    event: unknown,
+    handle: Readonly<GoogletagTraceCycleHandle> | undefined
+  ) => void
+): Readonly<GoogletagFacade> {
+  const member = (external: object, key: PropertyKey): ((...args: unknown[]) => unknown) => {
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    const candidate = safeMember(external, key);
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    if (typeof candidate !== 'function') {
+      throw new GoogletagAdapterError('external_artifact_incompatible');
+    }
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    return candidate as (...args: unknown[]) => unknown;
+  };
+  const call = (external: object, key: PropertyKey, argumentsList: readonly unknown[]): unknown => {
+    const callable = member(external, key);
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    const result = invokeFacadeCall(callable, external, argumentsList);
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    return result;
+  };
+  const value = (external: object, key: PropertyKey): unknown => {
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    const result = safeMember(external, key);
+    if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+    return result;
+  };
+  const service = (): object => asObject(call(binding.binding, 'pubads', []));
+  const replaceObservedMethod = (
+    slot: object,
+    key: 'clearTargeting' | 'setTargeting',
+    observer: GoogletagTargetingObserver
+  ): Readonly<{ isCurrent: () => boolean; restore: () => void }> | undefined => {
+    if (!isOperationCurrent()) return undefined;
+    const original = member(slot, key);
+    let descriptor: PropertyDescriptor | undefined;
+    let defineAttempted = false;
+    const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+      if (consumeFacadeCall(wrapper)) {
+        return Reflect.apply(original, this, arguments_);
+      }
+      try {
+        const mutationKey = typeof arguments_[0] === 'string' ? arguments_[0] : undefined;
+        observer.beforePublisherMutation(slot, mutationKey);
+      } catch {
+        // Bookkeeping must not change publisher call arguments, order, return, or throw.
+      }
+      return Reflect.apply(original, this, arguments_);
+    };
+    const restore = (): void => {
+      if (!defineAttempted) return;
+      defineAttempted = false;
+      try {
+        const current = Object.getOwnPropertyDescriptor(slot, key);
+        if (!current || current.value !== wrapper) return;
+        if (descriptor) Reflect.defineProperty(slot, key, descriptor);
+        else Reflect.deleteProperty(slot, key);
+      } catch {
+        // Publisher replacement wins once the installed method no longer matches.
+      }
+    };
+    const wrapperIsCurrent = (): boolean => {
+      try {
+        if (!defineAttempted) return false;
+        const current = Object.getOwnPropertyDescriptor(slot, key);
+        return current !== undefined && current.value === wrapper;
+      } catch {
+        return false;
+      }
+    };
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(slot, key);
+      if (
+        descriptor &&
+        (!Object.prototype.hasOwnProperty.call(descriptor, 'value') ||
+          (descriptor.configurable !== true && descriptor.writable !== true))
+      ) {
+        return undefined;
+      }
+      const replacement = descriptor
+        ? { ...descriptor, value: wrapper }
+        : { configurable: true, enumerable: true, value: wrapper, writable: true };
+      if (!isOperationCurrent()) {
+        return undefined;
+      }
+      defineAttempted = true;
+      if (!Reflect.defineProperty(slot, key, replacement)) {
+        restore();
+        return undefined;
+      }
+      if (!isOperationCurrent() || safeMember(slot, key) !== wrapper) {
+        restore();
+        return undefined;
+      }
+      return Object.freeze({ isCurrent: wrapperIsCurrent, restore });
+    } catch {
+      restore();
+      return undefined;
+    }
+  };
+  return Object.freeze({
+    adUnitPath: (slot: object): unknown => call(slot, 'getAdUnitPath', []),
+    bindingToken: (): object => bindingToken,
+    clearTargeting: (slot: object, key?: string): unknown =>
+      call(slot, 'clearTargeting', key === undefined ? [] : [key]),
+    enableServices: (): void => {
+      const currentService = service();
+      if (value(binding.binding, 'pubadsReady') === true) return;
+      call(currentService, 'enableSingleRequest', []);
+      call(binding.binding, 'enableServices', []);
+    },
+    transactionalDefine: (
+      definition: GoogletagReplacementDefinition,
+      isGenerationCurrent: () => boolean,
+      prepareCommit: (slot: object) => GoogletagReplacementCommitAdmission
+    ): GoogletagDefinitionResult => {
+      if (
+        typeof isGenerationCurrent !== 'function' ||
+        typeof prepareCommit !== 'function' ||
+        !isOperationCurrent()
+      ) {
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      const destroy = (slot: object): boolean => {
+        try {
+          return call(binding.binding, 'destroySlots', [[slot]]) === true;
+        } catch {
+          return false;
+        }
+      };
+      const discarded = Object.freeze({ status: 'discarded' as const });
+      let candidate: object | undefined;
+      let admission: GoogletagReplacementCommitAdmission | undefined;
+      let commitAttempted = false;
+      const discard = (slot: object, cause?: unknown): GoogletagDefinitionResult => {
+        if (!destroy(slot)) throw new GoogletagDefinitionError(slot, cause);
+        return discarded;
+      };
+      try {
+        if (!isGenerationCurrent() || !isOperationCurrent()) return discarded;
+        const defined = call(binding.binding, 'defineSlot', [
+          definition.adUnitPath,
+          definition.sizes,
+          definition.elementId,
+        ]);
+        if ((typeof defined !== 'object' || defined === null) && typeof defined !== 'function') {
+          throw new GoogletagDefinitionError();
+        }
+        candidate = defined as object;
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          const stale = candidate;
+          candidate = undefined;
+          return discard(stale);
+        }
+        admission = prepareCommit(candidate);
+        if (
+          !admission ||
+          typeof admission.commit !== 'function' ||
+          typeof admission.rollback !== 'function'
+        ) {
+          throw new GoogletagDefinitionError();
+        }
+        call(candidate, 'addService', [service()]);
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          const stale = candidate;
+          candidate = undefined;
+          return discard(stale);
+        }
+        commitAttempted = true;
+        if (!admission.commit()) throw new GoogletagDefinitionError();
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          try {
+            admission.rollback();
+          } finally {
+            commitAttempted = false;
+          }
+          const stale = candidate;
+          candidate = undefined;
+          return discard(stale);
+        }
+        return Object.freeze({ status: 'defined' as const, slot: candidate });
+      } catch (error) {
+        if (commitAttempted) {
+          try {
+            admission?.rollback();
+          } catch {
+            // Candidate retirement remains mandatory after bookkeeping rollback failure.
+          }
+        }
+        if (candidate) {
+          const failed = candidate;
+          if (!destroy(failed)) throw new GoogletagDefinitionError(failed, error);
+        }
+        if (error instanceof GoogletagDefinitionError) throw error;
+        throw new GoogletagDefinitionError(undefined, error);
+      }
+    },
+    display: (slot: string | object): unknown => {
+      const display = member(binding.binding, 'display');
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      markFirstDisplay();
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      const result = invokeFacadeCall(display, binding.binding, [slot]);
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      return result;
+    },
+    getTargeting: (slot: object, key: string): readonly string[] => {
+      const targeting = call(slot, 'getTargeting', [key]);
+      if (!Array.isArray(targeting) || targeting.some((entry) => typeof entry !== 'string')) {
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      return Object.freeze([...targeting]);
+    },
+    observeTargeting: (
+      slot: object,
+      observer: GoogletagTargetingObserver
+    ): GoogletagTargetingObservation => {
+      if (
+        typeof observer !== 'object' ||
+        observer === null ||
+        typeof observer.beforePublisherMutation !== 'function'
+      ) {
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      let observation = weakMapValue(targetingObservations, slot);
+      if (!observation) {
+        const observers = new Set<GoogletagTargetingObserver>();
+        const dispatcher: GoogletagTargetingObserver = Object.freeze({
+          beforePublisherMutation: (mutatedSlot: object, key?: string): void => {
+            const currentObservers = setValueSnapshot(observers);
+            for (let index = 0; index < currentObservers.length; index += 1) {
+              const current = currentObservers[index];
+              if (!current) continue;
+              try {
+                current.beforePublisherMutation(mutatedSlot, key);
+              } catch {
+                // One observer cannot prevent another or alter the publisher mutation.
+              }
+            }
+          },
+        });
+        const restoreSet = replaceObservedMethod(slot, 'setTargeting', dispatcher);
+        if (!restoreSet) throw new GoogletagAdapterError('external_artifact_incompatible');
+        const restoreClear = replaceObservedMethod(slot, 'clearTargeting', dispatcher);
+        if (!restoreClear) {
+          restoreSet.restore();
+          throw new GoogletagAdapterError('external_artifact_incompatible');
+        }
+        let restored = false;
+        observation = {
+          isCurrent: (): boolean => restoreSet.isCurrent() && restoreClear.isCurrent(),
+          observers,
+          restore: (): void => {
+            if (restored) return;
+            restored = true;
+            try {
+              restoreClear.restore();
+            } finally {
+              restoreSet.restore();
+            }
+          },
+        };
+        try {
+          setWeakMapValue(targetingObservations, slot, observation);
+        } catch (error) {
+          observation.restore();
+          throw error;
+        }
+      }
+      try {
+        addSetValue(observation.observers, observer);
+      } catch (error) {
+        if (setSize(observation.observers) === 0) {
+          if (weakMapValue(targetingObservations, slot) === observation) {
+            deleteWeakMapValue(targetingObservations, slot);
+          }
+          observation.restore();
+        }
+        throw error;
+      }
+      let active = true;
+      const releaseEffect = registerEffect(() => {
+        if (!active) return;
+        active = false;
+        deleteSetValue(observation!.observers, observer);
+        if (setSize(observation!.observers) === 0) {
+          if (weakMapValue(targetingObservations, slot) === observation) {
+            deleteWeakMapValue(targetingObservations, slot);
+          }
+          observation!.restore();
+        }
+      });
+      const release = (() => releaseEffect()) as GoogletagTargetingObservation;
+      Object.defineProperty(release, 'isCurrent', {
+        configurable: false,
+        enumerable: true,
+        value: (): boolean => {
+          try {
+            return active && observation?.isCurrent() === true;
+          } catch {
+            return false;
+          }
+        },
+        writable: false,
+      });
+      return Object.freeze(release);
+    },
+    refresh: (
+      slots?: readonly object[],
+      options?: Readonly<{ changeCorrelator: boolean }>
+    ): unknown =>
+      call(
+        service(),
+        'refresh',
+        slots === undefined
+          ? options === undefined
+            ? []
+            : [undefined, options]
+          : options === undefined
+            ? [[...slots]]
+            : [[...slots], options]
+      ),
+    serviceState: () => {
+      const currentService = service();
+      const initialLoadDisabledValue = initialLoadDisabled(currentService);
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      return Object.freeze({
+        apiReady: value(binding.binding, 'apiReady') === true,
+        initialLoadDisabled: initialLoadDisabledValue,
+        pubadsReady: value(binding.binding, 'pubadsReady') === true,
+      });
+    },
+    setTargeting: (slot: object, key: string, value: string | readonly string[]): unknown =>
+      call(slot, 'setTargeting', [key, Array.isArray(value) ? [...value] : value]),
+    slotElementId: (slot: object): unknown => call(slot, 'getSlotElementId', []),
+    slots: (): readonly object[] => {
+      const currentSlots = call(service(), 'getSlots', []);
+      if (
+        !Array.isArray(currentSlots) ||
+        currentSlots.some((slot) => typeof slot !== 'object' || slot === null)
+      ) {
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      if (!isOperationCurrent()) throw new GoogletagAdapterError('external_artifact_incompatible');
+      return Object.freeze([...currentSlots]);
+    },
+    subscribe: (
+      eventType: string,
+      listener: (event: unknown) => Readonly<GoogletagTraceCycleHandle> | void,
+      diagnosticsOwner = false
+    ): (() => void) => {
+      const currentService = service();
+      const add = member(currentService, 'addEventListener');
+      const remove = member(currentService, 'removeEventListener');
+      const wrapped = (event: unknown): void => {
+        if (!isBindingCurrent()) return;
+        let handle: Readonly<GoogletagTraceCycleHandle> | void = undefined;
+        try {
+          handle = listener(event);
+        } catch {
+          // Publisher and service callbacks cannot escape the GPT boundary.
+        }
+        if (diagnosticsOwner) {
+          publishDiagnostics(eventType, event, undefined);
+        } else if (eventType === 'slotRequested' || eventType === 'slotRenderEnded') {
+          publishDiagnostics(
+            eventType,
+            event,
+            acceptedTraceCycleHandle(handle) ? handle : undefined
+          );
+        }
+      };
+      let attempted = false;
+      const rollback = (): void => {
+        if (!attempted) return;
+        attempted = false;
+        try {
+          Reflect.apply(remove, currentService, [eventType, wrapped]);
+        } catch {
+          // Transaction rollback remains best-effort and cannot replace the original failure.
+        }
+      };
+      try {
+        if (!isOperationCurrent())
+          throw new GoogletagAdapterError('external_artifact_incompatible');
+        attempted = true;
+        Reflect.apply(add, currentService, [eventType, wrapped]);
+        if (!isOperationCurrent())
+          throw new GoogletagAdapterError('external_artifact_incompatible');
+      } catch (error) {
+        rollback();
+        throw error;
+      }
+      let active = true;
+      return registerEffect(() => {
+        if (!active) return;
+        active = false;
+        rollback();
+      });
+    },
+    transactionalReplace: (
+      oldSlot: object,
+      definition: GoogletagReplacementDefinition | undefined,
+      isGenerationCurrent: () => boolean,
+      prepareCommit: (replacement: object) => GoogletagReplacementCommitAdmission
+    ): GoogletagReplacementResult => {
+      if (
+        typeof isGenerationCurrent !== 'function' ||
+        typeof prepareCommit !== 'function' ||
+        !isOperationCurrent()
+      ) {
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      const destroy = (slot: object): boolean => {
+        try {
+          return call(binding.binding, 'destroySlots', [[slot]]) === true;
+        } catch {
+          return false;
+        }
+      };
+      const destroyed = Object.freeze({ status: 'destroyed' as const });
+      const cleanup = (candidate: object, cause?: unknown): never => {
+        if (!destroy(candidate)) {
+          throw new GoogletagReplacementError(candidate, true, cause);
+        }
+        throw new GoogletagReplacementError(undefined, true, cause);
+      };
+      if (!destroy(oldSlot)) throw new GoogletagReplacementError(oldSlot);
+      let replacement: object | undefined;
+      let admission: GoogletagReplacementCommitAdmission | undefined;
+      let commitAttempted = false;
+      try {
+        if (definition === undefined || !isGenerationCurrent() || !isOperationCurrent()) {
+          return destroyed;
+        }
+        const candidate = call(binding.binding, 'defineSlot', [
+          definition.adUnitPath,
+          definition.sizes,
+          definition.elementId,
+        ]);
+        if (
+          (typeof candidate !== 'object' || candidate === null) &&
+          typeof candidate !== 'function'
+        ) {
+          throw new GoogletagReplacementError(undefined, true);
+        }
+        replacement = candidate as object;
+        if (replacement === oldSlot) {
+          const invalid = replacement;
+          replacement = undefined;
+          cleanup(invalid);
+        }
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          const stale = replacement as object;
+          replacement = undefined;
+          if (!destroy(stale)) throw new GoogletagReplacementError(stale, true);
+          return destroyed;
+        }
+        admission = prepareCommit(replacement as object);
+        if (
+          !admission ||
+          typeof admission.commit !== 'function' ||
+          typeof admission.rollback !== 'function'
+        ) {
+          throw new GoogletagReplacementError(undefined, true);
+        }
+        call(replacement as object, 'addService', [service()]);
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          const stale = replacement as object;
+          replacement = undefined;
+          if (!destroy(stale)) throw new GoogletagReplacementError(stale, true);
+          return destroyed;
+        }
+        commitAttempted = true;
+        if (!admission.commit()) throw new GoogletagReplacementError(undefined, true);
+        if (!isGenerationCurrent() || !isOperationCurrent()) {
+          let rollbackFailed = false;
+          let rollbackFailure: unknown;
+          try {
+            admission.rollback();
+          } catch (error) {
+            rollbackFailed = true;
+            rollbackFailure = error;
+          }
+          commitAttempted = false;
+          const stale = replacement as object;
+          replacement = undefined;
+          if (!destroy(stale)) {
+            throw new GoogletagReplacementError(stale, true, rollbackFailure);
+          }
+          if (rollbackFailed) {
+            throw new GoogletagReplacementError(undefined, true, rollbackFailure);
+          }
+          return destroyed;
+        }
+        return Object.freeze({ status: 'replaced' as const, slot: replacement as object });
+      } catch (error) {
+        if (commitAttempted) {
+          try {
+            admission?.rollback();
+          } catch {
+            // Candidate cleanup remains mandatory even when service rollback is hostile.
+          }
+        }
+        if (error instanceof GoogletagReplacementCandidateCollisionError) {
+          throw new GoogletagReplacementError(undefined, true, error, true);
+        }
+        if (replacement) cleanup(replacement, error);
+        if (error instanceof GoogletagReplacementError) throw error;
+        throw new GoogletagReplacementError(undefined, true, error);
+      }
+    },
+  });
+}
+
+/** Create the sole production reader/writer boundary for `window.googletag`. */
+export function createBrowserGoogletagAdapter(
+  target: GoogletagGlobalTarget = window as unknown as GoogletagGlobalTarget,
+  diagnosticsOptions: GoogletagDiagnosticsIdentityOptions = {}
+): GoogletagAdapter {
+  const pending: PendingOperation<unknown>[] = [];
+  const live = new Set<PendingOperation<unknown>>();
+  const effects = new Set<() => void>();
+  let armedBindings = new WeakSet<object>();
+  const targetingObservations = new WeakMap<object, TargetingObservation>();
+  const facadeCalls = new WeakMap<(...arguments_: unknown[]) => unknown, number>();
+  const adapterMethodOrigins = new WeakMap<
+    (...arguments_: unknown[]) => unknown,
+    (...arguments_: unknown[]) => unknown
+  >();
+  const bindingTokens = new WeakMap<object, object>();
+  interface TraceCycle {
+    readonly handle: Readonly<GoogletagTraceCycleHandle>;
+    readonly ordinal: GptTraceCycleOrdinalV1;
+    readonly seen: Set<GoogletagDiagnosticsEventName>;
+    responseIdentifier?: string;
+    state: 'open' | 'completed' | 'retired';
+  }
+  interface DiagnosticsSlotState {
+    readonly adUnitPath?: string;
+    readonly cycles: TraceCycle[];
+    readonly elementId?: string;
+    nextCycleOrdinal: number;
+    readonly token: object;
+    readonly traceToken?: GptSlotTokenV1;
+    unknownPriorCycle: boolean;
+  }
+  const diagnosticsSlots = new WeakMap<object, DiagnosticsSlotState>();
+  const traceCycleHandleOwners = new WeakMap<
+    Readonly<GoogletagTraceCycleHandle>,
+    DiagnosticsSlotState
+  >();
+  const mintTraceToken =
+    typeof diagnosticsOptions.mintTraceToken === 'function'
+      ? diagnosticsOptions.mintTraceToken
+      : undefined;
+  const mintedTraceTokens = mintTraceToken ? new Set<string>() : undefined;
+  const reportedDiagnosticsFailures = new Set<GoogletagDiagnosticsFailureCode>();
+  const initialLoadReleases = new Map<object, () => void>();
+  const initialLoadOwner = Object.freeze({});
+  let diagnosticsObserver: GoogletagDiagnosticsObserver | undefined;
+  let nextTraceTokenOrdinal = diagnosticsOptions.initialTraceTokenOrdinal ?? 1;
+  let diagnosticsAdoptionOpen = true;
+  let pendingReservations = 0;
+  let disposed = false;
+  let firstDisplayObserved = false;
+  let gamAttributionEnqueued = false;
+
+  const enqueueGamAttribution = (): boolean => {
+    if (disposed) return false;
+    if (gamAttributionEnqueued) return true;
+    let binding = readTarget(target);
+    if (binding === undefined || binding === null) {
+      const created = { cmd: [] };
+      try {
+        if (
+          !Reflect.defineProperty(target, 'googletag', {
+            configurable: true,
+            enumerable: true,
+            value: created,
+            writable: true,
+          }) ||
+          readTarget(target) !== created
+        ) {
+          return false;
+        }
+      } catch {
+        return false;
+      }
+      binding = created;
+    }
+    if ((typeof binding !== 'object' || binding === null) && typeof binding !== 'function') {
+      return false;
+    }
+    const queue = commandQueue(binding as object);
+    if (!queue) return false;
+    gamAttributionEnqueued = true;
+    try {
+      queueCommand(queue, () => {
+        try {
+          const current = readTarget(target);
+          const root =
+            (typeof current === 'object' && current !== null) || typeof current === 'function'
+              ? (current as object)
+              : (binding as object);
+          const setConfig = safeMember(root, 'setConfig');
+          if (typeof setConfig === 'function') {
+            Reflect.apply(setConfig, root, [{ targeting: { ts: 'true' } }]);
+          }
+        } catch {
+          // Missing or hostile GPT targeting cannot block later queue work.
+        }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const reportDiagnosticsFailure = (code: GoogletagDiagnosticsFailureCode): void => {
+    try {
+      if (setHasValue(reportedDiagnosticsFailures, code)) return;
+      addSetValue(reportedDiagnosticsFailures, code);
+    } catch {
+      return;
+    }
+    try {
+      diagnosticsOptions.reportDiagnosticsFailure?.(code);
+    } catch {
+      // Local diagnostics reporting cannot affect GPT lifecycle behavior.
+    }
+  };
+
+  const createDiagnosticsSlotState = (physicalSlot: object): DiagnosticsSlotState => {
+    const optionalStringCall = (key: 'getSlotElementId' | 'getAdUnitPath'): string | undefined => {
+      const method = safeMember(physicalSlot, key);
+      if (typeof method !== 'function') return undefined;
+      try {
+        const value = Reflect.apply(method, physicalSlot, []);
+        return typeof value === 'string' && value.length > 0 ? value : undefined;
+      } catch {
+        return undefined;
+      }
+    };
+    const ordinal = nextTraceTokenOrdinal;
+    let traceToken: GptSlotTokenV1 | undefined;
+    if (Number.isInteger(ordinal) && ordinal >= 1 && ordinal <= 4_294_967_295) {
+      let candidate: unknown;
+      try {
+        candidate = mintTraceToken ? mintTraceToken(ordinal) : `gt1_${ordinal.toString(36)}`;
+      } catch {
+        reportDiagnosticsFailure('trace_token_invalid');
+      }
+      if (
+        typeof candidate === 'string' &&
+        /^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(candidate) &&
+        candidate.length <= 11 &&
+        Number.parseInt(candidate.slice(4), 36) <= 4_294_967_295
+      ) {
+        if (mintedTraceTokens && setHasValue(mintedTraceTokens, candidate)) {
+          reportDiagnosticsFailure('trace_token_collision');
+        } else {
+          try {
+            if (mintedTraceTokens) addSetValue(mintedTraceTokens, candidate);
+            traceToken = candidate as GptSlotTokenV1;
+            nextTraceTokenOrdinal += 1;
+          } catch {
+            if (mintedTraceTokens) deleteSetValue(mintedTraceTokens, candidate);
+            reportDiagnosticsFailure('trace_token_invalid');
+          }
+        }
+      } else if (candidate !== undefined) {
+        reportDiagnosticsFailure('trace_token_invalid');
+      }
+    } else {
+      reportDiagnosticsFailure(
+        Number.isInteger(ordinal) && ordinal > 4_294_967_295
+          ? 'trace_token_exhausted'
+          : 'trace_token_invalid'
+      );
+    }
+    const elementId = optionalStringCall('getSlotElementId');
+    const adUnitPath = optionalStringCall('getAdUnitPath');
+    return {
+      ...(adUnitPath === undefined ? {} : { adUnitPath }),
+      cycles: [],
+      ...(elementId === undefined ? {} : { elementId }),
+      nextCycleOrdinal: diagnosticsOptions.initialTraceCycleOrdinal ?? 1,
+      token: Object.freeze(Object.create(null) as object),
+      ...(traceToken === undefined ? {} : { traceToken }),
+      unknownPriorCycle: false,
+    };
+  };
+
+  const diagnosticsSlotState = (physicalSlot: object): DiagnosticsSlotState | undefined => {
+    if (disposed) return undefined;
+    diagnosticsAdoptionOpen = false;
+    try {
+      let state = weakMapValue(diagnosticsSlots, physicalSlot);
+      if (!state) {
+        state = createDiagnosticsSlotState(physicalSlot);
+        setWeakMapValue(diagnosticsSlots, physicalSlot, state);
+        if (weakMapValue(diagnosticsSlots, physicalSlot) !== state) return undefined;
+      }
+      return state;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const adoptDiagnosticsState = (input: GoogletagDiagnosticsAdoptionV1): boolean => {
+    if (
+      disposed ||
+      !diagnosticsAdoptionOpen ||
+      typeof input !== 'object' ||
+      input === null ||
+      !Number.isInteger(input.nextTraceTokenOrdinal) ||
+      input.nextTraceTokenOrdinal < 1 ||
+      input.nextTraceTokenOrdinal > 4_294_967_295 ||
+      !Array.isArray(input.slots) ||
+      input.slots.length > 256
+    ) {
+      return false;
+    }
+    const physicalSlots = new Set<object>();
+    const traceTokens = new Set<string>();
+    const prepared: Array<Readonly<{ physicalSlot: object; state: DiagnosticsSlotState }>> = [];
+    let maximumTokenOrdinal = 0;
+    for (const adopted of input.slots) {
+      const tokenOrdinal =
+        typeof adopted?.traceToken === 'string' &&
+        /^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(adopted.traceToken)
+          ? Number.parseInt(adopted.traceToken.slice(4), 36)
+          : Number.NaN;
+      if (
+        typeof adopted !== 'object' ||
+        adopted === null ||
+        (typeof adopted.physicalSlot !== 'object' && typeof adopted.physicalSlot !== 'function') ||
+        adopted.physicalSlot === null ||
+        physicalSlots.has(adopted.physicalSlot) ||
+        !Number.isInteger(tokenOrdinal) ||
+        tokenOrdinal < 1 ||
+        tokenOrdinal > 4_294_967_295 ||
+        traceTokens.has(adopted.traceToken) ||
+        !Number.isInteger(adopted.nextCycleOrdinal) ||
+        adopted.nextCycleOrdinal < 1 ||
+        adopted.nextCycleOrdinal > 4_294_967_295 ||
+        typeof adopted.unknownPriorCycle !== 'boolean' ||
+        !Array.isArray(adopted.records) ||
+        adopted.records.length > 10
+      ) {
+        return false;
+      }
+      const ordinals = new Set<number>();
+      const cycles: TraceCycle[] = [];
+      let maximumCycleOrdinal = 0;
+      for (const record of adopted.records) {
+        const seen = Array.isArray(record?.seen) ? (record.seen as readonly unknown[]) : undefined;
+        const responseIdentifier = record?.responseIdentifier;
+        if (
+          typeof record !== 'object' ||
+          record === null ||
+          !Number.isInteger(record.ordinal) ||
+          record.ordinal < 1 ||
+          record.ordinal > 4_294_967_295 ||
+          ordinals.has(record.ordinal) ||
+          (record.state !== 'open' && record.state !== 'completed' && record.state !== 'retired') ||
+          !seen ||
+          seen.length === 0 ||
+          seen.length > 6 ||
+          new Set(seen).size !== seen.length ||
+          seen.some(
+            (event: unknown) =>
+              event !== 'slotRequested' &&
+              event !== 'slotResponseReceived' &&
+              event !== 'slotRenderEnded' &&
+              event !== 'slotOnload' &&
+              event !== 'impressionViewable' &&
+              event !== 'slotVisibilityChanged'
+          ) ||
+          !seen.includes('slotRequested') ||
+          (record.state === 'open' && seen.includes('slotRenderEnded')) ||
+          (record.state === 'completed' && !seen.includes('slotRenderEnded')) ||
+          (responseIdentifier !== null &&
+            (typeof responseIdentifier !== 'string' ||
+              responseIdentifier.length === 0 ||
+              new TextEncoder().encode(responseIdentifier).byteLength > 256 ||
+              [...responseIdentifier].some((character) => {
+                const code = character.charCodeAt(0);
+                return code <= 0x1f || code === 0x7f;
+              })))
+        ) {
+          return false;
+        }
+        const retired = record.state === 'retired';
+        const handle = createGoogletagTraceCycleHandle(() => retired);
+        cycles.push({
+          handle,
+          ordinal: record.ordinal as GptTraceCycleOrdinalV1,
+          ...(responseIdentifier === null ? {} : { responseIdentifier }),
+          seen: new Set(seen as readonly GoogletagDiagnosticsEventName[]),
+          state: record.state,
+        });
+        ordinals.add(record.ordinal);
+        maximumCycleOrdinal = Math.max(maximumCycleOrdinal, record.ordinal);
+      }
+      if (adopted.nextCycleOrdinal <= maximumCycleOrdinal) return false;
+      physicalSlots.add(adopted.physicalSlot);
+      traceTokens.add(adopted.traceToken);
+      maximumTokenOrdinal = Math.max(maximumTokenOrdinal, tokenOrdinal);
+      prepared.push({
+        physicalSlot: adopted.physicalSlot,
+        state: {
+          cycles,
+          nextCycleOrdinal: adopted.nextCycleOrdinal,
+          token: Object.freeze(Object.create(null) as object),
+          traceToken: adopted.traceToken as GptSlotTokenV1,
+          unknownPriorCycle: adopted.unknownPriorCycle,
+        },
+      });
+    }
+    if (input.nextTraceTokenOrdinal <= maximumTokenOrdinal) return false;
+    try {
+      for (const adopted of prepared) {
+        setWeakMapValue(diagnosticsSlots, adopted.physicalSlot, adopted.state);
+        for (const cycle of adopted.state.cycles) {
+          setWeakMapValue(traceCycleHandleOwners, cycle.handle, adopted.state);
+        }
+        if (mintedTraceTokens) addSetValue(mintedTraceTokens, adopted.state.traceToken!);
+      }
+      nextTraceTokenOrdinal = input.nextTraceTokenOrdinal;
+      diagnosticsAdoptionOpen = false;
+      return true;
+    } catch {
+      reportDiagnosticsFailure('trace_cycle_invalid');
+      return false;
+    }
+  };
+
+  const traceCycle = (
+    state: DiagnosticsSlotState,
+    eventType: GoogletagDiagnosticsEventName,
+    responseIdentifier: string | undefined,
+    acceptedHandle: Readonly<GoogletagTraceCycleHandle> | undefined
+  ): GptTraceCycleOrdinalV1 | undefined => {
+    if (!state.traceToken) return undefined;
+    const isRetired = (handle: Readonly<GoogletagTraceCycleHandle>): boolean => {
+      try {
+        return handle.isRetired() === true;
+      } catch {
+        return true;
+      }
+    };
+    for (let index = 0; index < state.cycles.length; index += 1) {
+      const cycle = state.cycles[index];
+      if (cycle && cycle.state !== 'retired' && isRetired(cycle.handle)) {
+        cycle.state = 'retired';
+      }
+    }
+    if (eventType === 'slotRequested') {
+      if (!acceptedHandle || isRetired(acceptedHandle)) return undefined;
+      if (
+        weakMapValue(traceCycleHandleOwners, acceptedHandle) !== undefined ||
+        state.cycles.some((cycle) => cycle.handle === acceptedHandle) ||
+        state.cycles.some((cycle) => cycle.state === 'open')
+      ) {
+        reportDiagnosticsFailure('trace_cycle_collision');
+        return undefined;
+      }
+      const ordinal = state.nextCycleOrdinal;
+      if (!Number.isInteger(ordinal) || ordinal < 1 || ordinal > 4_294_967_295) {
+        reportDiagnosticsFailure(
+          Number.isInteger(ordinal) && ordinal > 4_294_967_295
+            ? 'trace_cycle_exhausted'
+            : 'trace_cycle_invalid'
+        );
+        return undefined;
+      }
+      if (state.cycles.length >= 10) {
+        const pruneIndex = state.cycles.findIndex((cycle) => cycle.state !== 'open');
+        if (pruneIndex < 0) {
+          reportDiagnosticsFailure('trace_cycle_collision');
+          return undefined;
+        }
+        state.cycles.splice(pruneIndex, 1);
+        state.unknownPriorCycle = true;
+      }
+      const cycle: TraceCycle = {
+        handle: acceptedHandle,
+        ordinal: ordinal as GptTraceCycleOrdinalV1,
+        seen: new Set([eventType]),
+        state: 'open',
+      };
+      try {
+        setWeakMapValue(traceCycleHandleOwners, acceptedHandle, state);
+      } catch {
+        reportDiagnosticsFailure('trace_cycle_invalid');
+        return undefined;
+      }
+      state.cycles.push(cycle);
+      state.nextCycleOrdinal += 1;
+      return cycle.ordinal;
+    }
+
+    let candidates: TraceCycle[] = [];
+    if (acceptedHandle !== undefined) {
+      candidates = state.cycles.filter(
+        (cycle) => cycle.handle === acceptedHandle && !cycle.seen.has(eventType)
+      );
+    } else if (responseIdentifier !== undefined) {
+      candidates = state.cycles.filter(
+        (cycle) => cycle.responseIdentifier === responseIdentifier && !cycle.seen.has(eventType)
+      );
+      if (candidates.length === 0) {
+        const open = state.cycles.filter(
+          (cycle) =>
+            cycle.state === 'open' &&
+            cycle.responseIdentifier === undefined &&
+            !cycle.seen.has(eventType)
+        );
+        if (open.length === 1) candidates = open;
+      }
+    } else if (!state.unknownPriorCycle) {
+      candidates = state.cycles.filter((cycle) => !cycle.seen.has(eventType));
+    }
+    if (candidates.length !== 1) {
+      if (candidates.length > 1) reportDiagnosticsFailure('trace_cycle_ambiguity');
+      return undefined;
+    }
+    const cycle = candidates[0]!;
+    cycle.seen.add(eventType);
+    if (responseIdentifier !== undefined && cycle.responseIdentifier === undefined) {
+      cycle.responseIdentifier = responseIdentifier;
+    }
+    if (eventType === 'slotRenderEnded') cycle.state = 'completed';
+    return cycle.ordinal;
+  };
+
+  const diagnosticFact = (
+    eventType: string,
+    event: unknown,
+    observedAtMs: number,
+    acceptedHandle: Readonly<GoogletagTraceCycleHandle> | undefined
+  ): Readonly<GoogletagDiagnosticsFact> | undefined => {
+    try {
+      if ((typeof event !== 'object' || event === null) && typeof event !== 'function') {
+        return undefined;
+      }
+      const slot = safeMember(event as object, 'slot');
+      if ((typeof slot !== 'object' || slot === null) && typeof slot !== 'function') {
+        return undefined;
+      }
+      const physicalSlot = slot as object;
+      const state = diagnosticsSlotState(physicalSlot);
+      if (!state) return undefined;
+      const responseIdentifierValue = safeMember(event as object, 'responseIdentifier');
+      const responseIdentifier =
+        typeof responseIdentifierValue === 'string' && responseIdentifierValue.length > 0
+          ? responseIdentifierValue
+          : undefined;
+      const kind = eventType as GoogletagDiagnosticsEventName;
+      const cycleOrdinal = traceCycle(state, kind, responseIdentifier, acceptedHandle);
+      const safeSlot = Object.freeze({
+        token: state.token,
+        ...(state.traceToken === undefined ? {} : { traceToken: state.traceToken }),
+        ...(state.traceToken === undefined
+          ? {}
+          : { runtimeSlotNumber: Number.parseInt(state.traceToken.slice(4), 36) }),
+        ...(cycleOrdinal === undefined ? {} : { cycleOrdinal }),
+        ...(state.elementId === undefined ? {} : { elementId: state.elementId }),
+        ...(state.adUnitPath === undefined ? {} : { adUnitPath: state.adUnitPath }),
+      });
+      const base = {
+        kind,
+        observedAtMs,
+        slot: safeSlot,
+        ...(responseIdentifier === undefined ? {} : { responseIdentifier }),
+      };
+      switch (eventType) {
+        case 'slotRequested':
+        case 'slotResponseReceived':
+        case 'slotOnload':
+        case 'impressionViewable':
+          return Object.freeze({ ...base, kind: eventType });
+        case 'slotVisibilityChanged': {
+          const percentage = safeMember(event as object, 'inViewPercentage');
+          return typeof percentage === 'number' && Number.isFinite(percentage)
+            ? Object.freeze({ ...base, kind: eventType, inViewPercentage: percentage })
+            : Object.freeze({ ...base, kind: eventType });
+        }
+        case 'slotRenderEnded': {
+          const isEmpty = safeMember(event as object, 'isEmpty');
+          const isBackfill = safeMember(event as object, 'isBackfill');
+          const slotContentChanged = safeMember(event as object, 'slotContentChanged');
+          const sizeCandidate = safeMember(event as object, 'size');
+          let size: readonly [number, number] | undefined;
+          if (Array.isArray(sizeCandidate) && sizeCandidate.length === 2) {
+            const width = safeMember(sizeCandidate, '0');
+            const height = safeMember(sizeCandidate, '1');
+            if (
+              typeof width === 'number' &&
+              Number.isFinite(width) &&
+              typeof height === 'number' &&
+              Number.isFinite(height)
+            ) {
+              size = Object.freeze([width, height]);
+            }
+          }
+          const positiveInteger = (name: string): number | undefined => {
+            const value = safeMember(event as object, name);
+            return typeof value === 'number' && Number.isSafeInteger(value) && value > 0
+              ? value
+              : undefined;
+          };
+          const positiveIntegerList = (name: string): readonly number[] | undefined => {
+            const value = safeMember(event as object, name);
+            if (!Array.isArray(value)) return undefined;
+            const result = value
+              .map((entry) =>
+                typeof entry === 'number' && Number.isSafeInteger(entry) && entry > 0
+                  ? entry
+                  : undefined
+              )
+              .filter((entry): entry is number => entry !== undefined)
+              .slice(0, 8);
+            return result.length === 0 ? undefined : Object.freeze(result);
+          };
+          const adManagerCandidate = {
+            lineItemId: positiveInteger('lineItemId'),
+            creativeId: positiveInteger('creativeId'),
+            campaignId: positiveInteger('campaignId'),
+            advertiserId: positiveInteger('advertiserId'),
+            sourceAgnosticLineItemId: positiveInteger('sourceAgnosticLineItemId'),
+            sourceAgnosticCreativeId: positiveInteger('sourceAgnosticCreativeId'),
+            yieldGroupIds: positiveIntegerList('yieldGroupIds'),
+            companyIds: positiveIntegerList('companyIds'),
+          };
+          const adManager = Object.fromEntries(
+            Object.entries(adManagerCandidate).filter(([, value]) => value !== undefined)
+          ) as GoogletagDiagnosticsAdManagerIdentity;
+          return Object.freeze({
+            ...base,
+            kind: eventType,
+            ...(typeof isEmpty === 'boolean' ? { isEmpty } : {}),
+            ...(size ? { size } : {}),
+            ...(typeof isBackfill === 'boolean' ? { isBackfill } : {}),
+            ...(typeof slotContentChanged === 'boolean' ? { slotContentChanged } : {}),
+            ...(Object.keys(adManager).length === 0 ? {} : { adManager: Object.freeze(adManager) }),
+          });
+        }
+        default:
+          return undefined;
+      }
+    } catch {
+      return undefined;
+    }
+  };
+
+  const publishDiagnostics = (
+    eventType: string,
+    event: unknown,
+    acceptedHandle: Readonly<GoogletagTraceCycleHandle> | undefined
+  ): void => {
+    const observer = diagnosticsObserver;
+    if (!observer || disposed) return;
+    let observedAtMs = 0;
+    try {
+      const performance = safeMember(target, 'performance');
+      if (
+        (typeof performance === 'object' && performance !== null) ||
+        typeof performance === 'function'
+      ) {
+        const now = safeMember(performance as object, 'now');
+        if (typeof now === 'function') {
+          const value = Reflect.apply(now, performance, []);
+          if (typeof value === 'number' && Number.isFinite(value)) observedAtMs = value;
+        }
+      }
+    } catch {
+      // A missing or hostile clock cannot suppress the observed GPT fact.
+    }
+    const fact = diagnosticFact(eventType, event, observedAtMs, acceptedHandle);
+    if (!fact) return;
+    try {
+      observer(fact);
+    } catch {
+      // Diagnostics observation cannot escape the GPT correctness callback.
+    }
+  };
+
+  const invokeFacadeCall = (
+    callable: (...arguments_: unknown[]) => unknown,
+    receiver: unknown,
+    arguments_: readonly unknown[]
+  ): unknown => {
+    const depth = weakMapValue(facadeCalls, callable) ?? 0;
+    setWeakMapValue(facadeCalls, callable, depth + 1);
+    try {
+      return Reflect.apply(callable, receiver, arguments_);
+    } finally {
+      if (depth === 0) deleteWeakMapValue(facadeCalls, callable);
+      else setWeakMapValue(facadeCalls, callable, depth);
+    }
+  };
+  const consumeFacadeCall = (callable: (...arguments_: unknown[]) => unknown): boolean => {
+    const depth = weakMapValue(facadeCalls, callable) ?? 0;
+    if (depth === 0) return false;
+    if (depth === 1) deleteWeakMapValue(facadeCalls, callable);
+    else setWeakMapValue(facadeCalls, callable, depth - 1);
+    return true;
+  };
+
+  const markFirstDisplay = (): void => {
+    if (firstDisplayObserved) return;
+    firstDisplayObserved = true;
+    try {
+      const performance = safeMember(target, 'performance');
+      if (
+        (typeof performance !== 'object' || performance === null) &&
+        typeof performance !== 'function'
+      ) {
+        return;
+      }
+      const mark = safeMember(performance as object, 'mark');
+      if (typeof mark !== 'function') return;
+      Reflect.apply(mark, performance, ['tsjs:first-display']);
+      const measure = safeMember(performance as object, 'measure');
+      if (typeof measure !== 'function') return;
+      Reflect.apply(measure, performance, [
+        'tsjs:boot-to-first-display',
+        'tsjs:bids-script',
+        'tsjs:first-display',
+      ]);
+    } catch {
+      // Performance instrumentation cannot change GPT display behavior.
+    }
+  };
+
+  const registerAdapterEffect = (disposeEffect: () => void): void => {
+    const rollback = (): void => {
+      try {
+        deleteSetValue(effects, disposeEffect);
+      } catch {
+        // A hostile registry cannot retain the effect being rolled back.
+      }
+      try {
+        disposeEffect();
+      } catch {
+        // Cleanup cannot replace the publication failure or escape disposal.
+      }
+    };
+    if (disposed) {
+      rollback();
+      return;
+    }
+    try {
+      effects.add(disposeEffect);
+    } catch (error) {
+      rollback();
+      throw error;
+    }
+    if (disposed) rollback();
+  };
+
+  const replaceMethod = (
+    binding: object,
+    key: PropertyKey,
+    wrapper: (...arguments_: unknown[]) => unknown,
+    isCurrent: () => boolean
+  ): (() => void) | undefined => {
+    let descriptor: PropertyDescriptor | undefined;
+    let installed = false;
+    const restore = (): void => {
+      if (!installed) return;
+      installed = false;
+      try {
+        const current = Object.getOwnPropertyDescriptor(binding, key);
+        if (!current || current.value !== wrapper) return;
+        if (descriptor) Reflect.defineProperty(binding, key, descriptor);
+        else Reflect.deleteProperty(binding, key);
+      } catch {
+        // Publisher replacement wins over best-effort adapter restoration.
+      }
+    };
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(binding, key);
+      if (!isCurrent()) return undefined;
+      if (
+        descriptor &&
+        (!Object.prototype.hasOwnProperty.call(descriptor, 'value') ||
+          (descriptor.configurable !== true && descriptor.writable !== true))
+      ) {
+        return undefined;
+      }
+      const replacement = descriptor
+        ? { ...descriptor, value: wrapper }
+        : { configurable: true, enumerable: true, value: wrapper, writable: true };
+      if (!isCurrent()) return undefined;
+      if (!Reflect.defineProperty(binding, key, replacement)) return undefined;
+      installed = true;
+      if (!isCurrent() || safeMember(binding, key) !== wrapper || !isCurrent()) {
+        restore();
+        return undefined;
+      }
+    } catch {
+      restore();
+      return undefined;
+    }
+    return restore;
+  };
+
+  const syncInitialLoadDisabled = (
+    binding: object,
+    tracker: { disabled: boolean },
+    isCurrent?: () => boolean
+  ): boolean => {
+    const getConfig = safeMember(binding, 'getConfig');
+    if (isCurrent && !isCurrent()) return false;
+    if (typeof getConfig !== 'function') return false;
+    try {
+      const config = Reflect.apply(getConfig, binding, ['disableInitialLoad']);
+      if (isCurrent && !isCurrent()) return false;
+      if ((typeof config !== 'object' || config === null) && typeof config !== 'function') {
+        return false;
+      }
+      const value = safeMember(config, 'disableInitialLoad');
+      if (isCurrent && !isCurrent()) return false;
+      if (value === undefined) return false;
+      tracker.disabled = value === true;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const syncExplicitInitialLoad = (candidate: unknown, tracker: { disabled: boolean }): boolean => {
+    try {
+      if (
+        (typeof candidate !== 'object' || candidate === null) &&
+        typeof candidate !== 'function'
+      ) {
+        return false;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, 'disableInitialLoad');
+      if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) return false;
+      tracker.disabled = descriptor.value === true;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const releaseInitialLoadBinding = (binding: object): void => {
+    const release = mapValue(initialLoadReleases, binding);
+    if (!release) return;
+    try {
+      deleteMapValue(initialLoadReleases, binding);
+    } finally {
+      try {
+        deleteSetValue(effects, release);
+      } catch {
+        // A hostile registry cannot retain adapter ownership of an old binding.
+      } finally {
+        try {
+          release();
+        } catch {
+          // One historical binding cannot interrupt release of later bindings.
+        }
+      }
+    }
+  };
+
+  const releaseHistoricalInitialLoadBindings = (current?: object): void => {
+    for (const binding of [...mapKeys(initialLoadReleases)]) {
+      if (binding === current) continue;
+      try {
+        releaseInitialLoadBinding(binding);
+      } catch {
+        // One historical binding cannot interrupt release of later bindings.
+      }
+    }
+  };
+
+  const rollbackNotificationArming = (binding: object): void => {
+    let released = false;
+    try {
+      deleteWeakSetValue(armedBindings, binding);
+      released = !armedBindings.has(binding);
+    } catch {
+      // A poisoned registry cannot prove that the exact marker was removed.
+    }
+    if (!released) armedBindings = new WeakSet<object>();
+  };
+
+  const ensureInitialLoadTracking = (
+    expected: PresentGoogletag,
+    knownService?: object
+  ): SharedInitialLoadTracker | undefined => {
+    const expectedCurrent = (): boolean => {
+      if (disposed) return false;
+      const current = sameBinding(expected);
+      return !disposed && current;
+    };
+    if (!expectedCurrent()) return undefined;
+
+    let tracker = weakMapValue(sharedInitialLoadTrackers, expected.binding);
+    if (!tracker) {
+      tracker = {
+        disabled: false,
+        rootWrapped: false,
+        owners: new Set<object>(),
+        restorers: new Set<() => void>(),
+        services: new WeakMap<object, () => void>(),
+      };
+      try {
+        sharedInitialLoadTrackers.set(expected.binding, tracker);
+      } catch (error) {
+        if (weakMapValue(sharedInitialLoadTrackers, expected.binding) === tracker) {
+          deleteWeakMapValue(sharedInitialLoadTrackers, expected.binding);
+        }
+        throw error;
+      }
+    }
+    const ownsInitialLoad = (): boolean => {
+      try {
+        return tracker!.owners.has(initialLoadOwner);
+      } catch {
+        return false;
+      }
+    };
+    const trackingCurrent = (): boolean => {
+      if (
+        disposed ||
+        weakMapValue(sharedInitialLoadTrackers, expected.binding) !== tracker ||
+        !ownsInitialLoad()
+      ) {
+        return false;
+      }
+      const current = sameBinding(expected);
+      return (
+        !disposed &&
+        current &&
+        weakMapValue(sharedInitialLoadTrackers, expected.binding) === tracker &&
+        ownsInitialLoad()
+      );
+    };
+    let adoptedHere = false;
+    let alreadyAdopted: boolean;
+    try {
+      alreadyAdopted = initialLoadReleases.has(expected.binding);
+    } catch {
+      if (
+        tracker.owners.size === 0 &&
+        weakMapValue(sharedInitialLoadTrackers, expected.binding) === tracker
+      ) {
+        deleteWeakMapValue(sharedInitialLoadTrackers, expected.binding);
+      }
+      return undefined;
+    }
+    if (!alreadyAdopted) {
+      if (!expectedCurrent()) {
+        if (
+          tracker.owners.size === 0 &&
+          weakMapValue(sharedInitialLoadTrackers, expected.binding) === tracker
+        ) {
+          deleteWeakMapValue(sharedInitialLoadTrackers, expected.binding);
+        }
+        return undefined;
+      }
+      try {
+        tracker.owners.add(initialLoadOwner);
+      } catch (error) {
+        try {
+          deleteSetValue(tracker.owners, initialLoadOwner);
+        } finally {
+          if (
+            tracker.owners.size === 0 &&
+            weakMapValue(sharedInitialLoadTrackers, expected.binding) === tracker
+          ) {
+            deleteWeakMapValue(sharedInitialLoadTrackers, expected.binding);
+          }
+        }
+        throw error;
+      }
+      const adoptedTracker = tracker;
+      const release = (): void => {
+        try {
+          if (mapValue(initialLoadReleases, expected.binding) === release) {
+            deleteMapValue(initialLoadReleases, expected.binding);
+          }
+        } finally {
+          const removedLastOwner =
+            deleteSetValue(adoptedTracker.owners, initialLoadOwner) &&
+            adoptedTracker.owners.size === 0;
+          if (removedLastOwner) {
+            if (weakMapValue(sharedInitialLoadTrackers, expected.binding) === adoptedTracker) {
+              deleteWeakMapValue(sharedInitialLoadTrackers, expected.binding);
+            }
+            for (const restore of [...adoptedTracker.restorers].reverse()) {
+              try {
+                restore();
+              } catch {
+                // One restoration cannot interrupt cleanup of the shared tracker.
+              }
+            }
+          }
+        }
+      };
+      try {
+        initialLoadReleases.set(expected.binding, release);
+      } catch (error) {
+        try {
+          if (mapValue(initialLoadReleases, expected.binding) === release) {
+            deleteMapValue(initialLoadReleases, expected.binding);
+          }
+        } finally {
+          release();
+        }
+        throw error;
+      }
+      registerAdapterEffect(release);
+      adoptedHere = true;
+    }
+    const installedHere: Array<() => void> = [];
+    const rollback = (): undefined => {
+      for (const restore of [...installedHere].reverse()) restore();
+      if (adoptedHere) {
+        releaseInitialLoadBinding(expected.binding);
+      }
+      return undefined;
+    };
+    if (!trackingCurrent()) return rollback();
+    syncInitialLoadDisabled(expected.binding, tracker, trackingCurrent);
+    if (!trackingCurrent()) return rollback();
+    if (!tracker.rootWrapped) {
+      const originalSetConfig = safeMember(expected.binding, 'setConfig');
+      if (!trackingCurrent()) return rollback();
+      if (typeof originalSetConfig === 'function') {
+        const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+          const result = Reflect.apply(originalSetConfig, this, arguments_);
+          if (!syncInitialLoadDisabled(expected.binding, tracker!)) {
+            syncExplicitInitialLoad(arguments_[0], tracker!);
+          }
+          return result;
+        };
+        const restore = replaceMethod(expected.binding, 'setConfig', wrapper, trackingCurrent);
+        if (restore) {
+          let active = true;
+          const cleanup = (): void => {
+            if (!active) return;
+            active = false;
+            try {
+              deleteSetValue(tracker!.restorers, cleanup);
+            } finally {
+              tracker!.rootWrapped = false;
+              restore();
+            }
+          };
+          tracker.rootWrapped = true;
+          try {
+            tracker.restorers.add(cleanup);
+          } catch (error) {
+            cleanup();
+            rollback();
+            throw error;
+          }
+          installedHere.push(cleanup);
+        }
+        if (!trackingCurrent()) return rollback();
+      }
+    }
+
+    const trackService = (service: object): boolean => {
+      try {
+        if (tracker!.services.has(service)) return true;
+      } catch {
+        return false;
+      }
+      if (!trackingCurrent()) return false;
+      const originalDisable = safeMember(service, 'disableInitialLoad');
+      if (!trackingCurrent()) return false;
+      if (typeof originalDisable !== 'function') return true;
+      const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+        const result = Reflect.apply(originalDisable, this, arguments_);
+        if (!syncInitialLoadDisabled(expected.binding, tracker!)) tracker!.disabled = true;
+        return result;
+      };
+      const restore = replaceMethod(service, 'disableInitialLoad', wrapper, trackingCurrent);
+      if (restore) {
+        let active = true;
+        const cleanup = (): void => {
+          if (!active) return;
+          active = false;
+          try {
+            deleteSetValue(tracker!.restorers, cleanup);
+          } finally {
+            try {
+              if (weakMapValue(tracker!.services, service) === cleanup) {
+                deleteWeakMapValue(tracker!.services, service);
+              }
+            } finally {
+              restore();
+            }
+          }
+        };
+        try {
+          tracker!.services.set(service, cleanup);
+        } catch (error) {
+          try {
+            cleanup();
+          } finally {
+            rollback();
+          }
+          throw error;
+        }
+        try {
+          tracker!.restorers.add(cleanup);
+        } catch (error) {
+          cleanup();
+          rollback();
+          throw error;
+        }
+        installedHere.push(cleanup);
+      }
+      if (!trackingCurrent()) return false;
+      return true;
+    };
+
+    if (knownService) {
+      if (!trackService(knownService)) return rollback();
+    } else {
+      if (!trackingCurrent()) return rollback();
+      let service: unknown;
+      try {
+        service = Reflect.apply(expected.pubads, expected.binding, []);
+      } catch {
+        return rollback();
+      }
+      if (!trackingCurrent()) return rollback();
+      if ((typeof service === 'object' && service !== null) || typeof service === 'function') {
+        if (!trackService(service as object)) return rollback();
+      }
+    }
+    if (!trackingCurrent()) return rollback();
+    return tracker;
+  };
+
+  const currentBinding = (): ReturnType<typeof inspectBinding> => {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const value = readTarget(target);
+      const inspected = inspectBinding(value);
+      if (readTarget(target) === value) {
+        const current =
+          inspected.status === 'present' ? inspected.value.binding : inspected.binding;
+        releaseHistoricalInitialLoadBindings(current);
+        return inspected;
+      }
+    }
+    releaseHistoricalInitialLoadBindings();
+    return { status: 'incompatible' };
+  };
+
+  const sameBinding = (expected: PresentGoogletag): boolean => {
+    const canonicalAdapterMethod = (
+      candidate: (...arguments_: unknown[]) => unknown
+    ): ((...arguments_: unknown[]) => unknown) | undefined => {
+      let current = candidate;
+      for (let depth = 0; depth < 16; depth += 1) {
+        const origin = weakMapValue(adapterMethodOrigins, current);
+        if (!origin) return current;
+        if (origin === current) return undefined;
+        current = origin;
+      }
+      return undefined;
+    };
+    const sameAdapterMethod = (
+      left: (...arguments_: unknown[]) => unknown,
+      right: (...arguments_: unknown[]) => unknown
+    ): boolean => {
+      if (left === right) return true;
+      const canonicalLeft = canonicalAdapterMethod(left);
+      return canonicalLeft !== undefined && canonicalLeft === canonicalAdapterMethod(right);
+    };
+    const matchesCapturedBinding = (): boolean => {
+      const inspected = inspectBinding(expected.binding);
+      return (
+        inspected.status === 'present' &&
+        inspected.value.commandQueue.binding === expected.commandQueue.binding &&
+        inspected.value.commandQueue.push === expected.commandQueue.push &&
+        sameAdapterMethod(inspected.value.display, expected.display) &&
+        inspected.value.pubads === expected.pubads
+      );
+    };
+    if (readTarget(target) !== expected.binding) {
+      releaseInitialLoadBinding(expected.binding);
+      return false;
+    }
+    const firstMatch = matchesCapturedBinding();
+    if (readTarget(target) !== expected.binding) {
+      releaseInitialLoadBinding(expected.binding);
+      return false;
+    }
+    const secondMatch = matchesCapturedBinding();
+    if (readTarget(target) !== expected.binding) {
+      releaseInitialLoadBinding(expected.binding);
+      return false;
+    }
+    return firstMatch && secondMatch;
+  };
+
+  const removePending = (operation: PendingOperation<unknown>): void => {
+    const index = pending.indexOf(operation);
+    if (index >= 0) pending.splice(index, 1);
+  };
+
+  const releasePendingReservation = (operation: PendingOperation<unknown>): void => {
+    if (!operation.pendingReservation) return;
+    operation.pendingReservation = false;
+    if (pendingReservations > 0) pendingReservations -= 1;
+  };
+
+  const clearReadiness = (operation: PendingOperation<unknown>): void => {
+    try {
+      if (operation.timeout !== undefined) {
+        clearTimeout(operation.timeout);
+        operation.timeout = undefined;
+      }
+      removePending(operation);
+    } finally {
+      releasePendingReservation(operation);
+    }
+  };
+
+  const detachAbort = (operation: PendingOperation<unknown>): void => {
+    const registration = operation.abortRegistration;
+    if (!registration || !registration.attempted) return;
+    if (registration.installing) {
+      registration.cleanupRequested = true;
+      return;
+    }
+    registration.attempted = false;
+    operation.abortRegistration = undefined;
+    try {
+      Reflect.apply(registration.remove, registration.binding, ['abort', registration.listener]);
+    } catch {
+      // Hostile signal cleanup cannot strand operation settlement.
+    }
+  };
+
+  const clearOperation = (operation: PendingOperation<unknown>): void => {
+    try {
+      clearReadiness(operation);
+    } finally {
+      try {
+        detachAbort(operation);
+      } finally {
+        deleteSetValue(live, operation);
+      }
+    }
+  };
+
+  const rollbackOperationEffects = (operation: PendingOperation<unknown>): void => {
+    for (let index = operation.provisionalEffects.length - 1; index >= 0; index -= 1) {
+      operation.provisionalEffects[index]?.release();
+    }
+    operation.provisionalEffects.length = 0;
+  };
+
+  const rejectOperation = (operation: PendingOperation<unknown>, error: unknown): void => {
+    if (operation.settled) return;
+    operation.settled = true;
+    if (error instanceof GoogletagAdapterError && error.code === 'external_artifact_incompatible') {
+      operation.state = 'incompatible';
+    }
+    try {
+      rollbackOperationEffects(operation);
+    } finally {
+      try {
+        clearOperation(operation);
+      } finally {
+        operation.reject(error);
+      }
+    }
+  };
+
+  const fail = (operation: PendingOperation<unknown>, code: GoogletagAdapterErrorCode): void => {
+    if (operation.settled) return;
+    if (code === 'external_ready_timeout') operation.state = 'timed_out';
+    if (code === 'external_artifact_incompatible') operation.state = 'incompatible';
+    rejectOperation(operation, new GoogletagAdapterError(code));
+  };
+
+  const dispatch = (operation: PendingOperation<unknown>, binding: PresentGoogletag): void => {
+    if (operation.settled) return;
+    if (disposed) {
+      fail(operation, 'operation_disposed');
+      return;
+    }
+    operation.state = 'present';
+    clearReadiness(operation);
+    const isDispatchCurrent = (): boolean => {
+      if (disposed || operation.settled) return false;
+      const current = sameBinding(binding);
+      return !disposed && !operation.settled && current;
+    };
+    const registerOperationEffect = (disposeEffect: () => void): (() => void) => {
+      let released = false;
+      let promoted = false;
+      const release = (): void => {
+        if (promoted) {
+          try {
+            deleteSetValue(effects, release);
+          } catch {
+            // A hostile registry cannot prevent exact external cleanup.
+          }
+        }
+        if (released) return;
+        released = true;
+        try {
+          disposeEffect();
+        } catch {
+          // One effect cleanup cannot escape the adapter boundary.
+        }
+      };
+      const promote = (): void => {
+        if (released || promoted) return;
+        promoted = true;
+        try {
+          effects.add(release);
+        } catch (error) {
+          release();
+          throw error;
+        }
+        if (!isDispatchCurrent()) {
+          release();
+          throw new GoogletagAdapterError(
+            disposed ? 'operation_disposed' : 'external_artifact_incompatible'
+          );
+        }
+      };
+      const provisional = { promote, release };
+      operation.provisionalEffects[operation.provisionalEffects.length] = provisional;
+      if (!isDispatchCurrent()) {
+        release();
+        throw new GoogletagAdapterError(
+          disposed ? 'operation_disposed' : 'external_artifact_incompatible'
+        );
+      }
+      return release;
+    };
+    const promoteOperationEffects = (): void => {
+      for (const provisional of operation.provisionalEffects) provisional.promote();
+      operation.provisionalEffects.length = 0;
+    };
+    const completeOperation = (value: unknown): void => {
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (!isDispatchCurrent()) {
+        fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      try {
+        promoteOperationEffects();
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation, error);
+        return;
+      }
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (!isDispatchCurrent()) {
+        fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      operation.settled = true;
+      try {
+        clearOperation(operation);
+      } finally {
+        operation.resolve(value);
+      }
+    };
+    const settleCommandValue = (value: unknown): void => {
+      let then: unknown;
+      try {
+        if ((typeof value === 'object' && value !== null) || typeof value === 'function') {
+          then = Reflect.get(value, 'then');
+        }
+      } catch (error) {
+        rejectOperation(operation, error);
+        return;
+      }
+      if (typeof then !== 'function') {
+        completeOperation(value);
+        return;
+      }
+      Promise.resolve(value).then(
+        (resolved) => completeOperation(resolved),
+        (error: unknown) => rejectOperation(operation, error)
+      );
+    };
+    let bindingToken = weakMapValue(bindingTokens, binding.binding);
+    if (!bindingToken) {
+      bindingToken = Object.freeze({});
+      setWeakMapValue(bindingTokens, binding.binding, bindingToken);
+    }
+    const facade = createFacade(
+      binding,
+      registerOperationEffect,
+      isDispatchCurrent,
+      () => !disposed && sameBinding(binding),
+      (service) => {
+        const tracker = ensureInitialLoadTracking(binding, service);
+        return tracker?.disabled === true;
+      },
+      targetingObservations,
+      bindingToken,
+      markFirstDisplay,
+      invokeFacadeCall,
+      consumeFacadeCall,
+      publishDiagnostics
+    );
+    try {
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (operation.settled) return;
+      ensureInitialLoadTracking(binding);
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (operation.settled) return;
+      if (!isDispatchCurrent()) {
+        if (disposed) fail(operation, 'operation_disposed');
+        else fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (operation.settled) {
+        return;
+      }
+      queueCommand(
+        binding.commandQueue,
+        () => {
+          if (operation.settled) return;
+          if (disposed) {
+            fail(operation, 'operation_disposed');
+            return;
+          }
+          if (!isDispatchCurrent()) {
+            if (disposed) fail(operation, 'operation_disposed');
+            else fail(operation, 'external_artifact_incompatible');
+            return;
+          }
+          try {
+            const value = operation.command(facade);
+            if (operation.settled) return;
+            if (disposed) {
+              fail(operation, 'operation_disposed');
+              return;
+            }
+            if (!isDispatchCurrent()) {
+              if (disposed) fail(operation, 'operation_disposed');
+              else fail(operation, 'external_artifact_incompatible');
+              return;
+            }
+            settleCommandValue(value);
+          } catch (error) {
+            if (operation.settled) return;
+            if (disposed) {
+              fail(operation, 'operation_disposed');
+              return;
+            }
+            rejectOperation(operation, error);
+          }
+        },
+        isDispatchCurrent
+      );
+    } catch (error) {
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      rejectOperation(operation, error);
+    }
+  };
+
+  const notifyReady = (expectedBinding?: object): void => {
+    if (disposed) return;
+    const current = currentBinding();
+    if (disposed) return;
+    if (current.status === 'present') {
+      for (const operation of [...pending]) dispatch(operation, current.value);
+      return;
+    }
+    if (current.status === 'pending') {
+      armNotification();
+      return;
+    }
+    if (expectedBinding !== undefined && current.binding !== expectedBinding) {
+      return;
+    }
+    for (const operation of [...pending]) {
+      if (
+        expectedBinding === undefined ||
+        operation.readinessBinding === undefined ||
+        operation.readinessBinding === expectedBinding
+      ) {
+        fail(operation, 'external_artifact_incompatible');
+      }
+    }
+  };
+
+  const armNotification = (): void => {
+    const current = currentBinding();
+    if (disposed) return;
+    if (current.status !== 'pending' || !current.binding || !current.commandQueue) {
+      return;
+    }
+    let alreadyArmed = false;
+    try {
+      alreadyArmed = armedBindings.has(current.binding);
+    } catch {
+      armedBindings = new WeakSet<object>();
+    }
+    if (alreadyArmed) return;
+    for (const operation of pending) operation.readinessBinding = current.binding;
+    try {
+      armedBindings.add(current.binding);
+    } catch {
+      rollbackNotificationArming(current.binding);
+      return;
+    }
+    let notificationActive = true;
+    const notify = (): void => {
+      if (!notificationActive) return;
+      notificationActive = false;
+      notifyReady(current.binding);
+    };
+    try {
+      queueCommand(current.commandQueue, notify);
+    } catch {
+      notificationActive = false;
+      rollbackNotificationArming(current.binding);
+    }
+  };
+
+  const run = <T>(
+    command: (googletag: Readonly<GoogletagFacade>) => T,
+    options: GoogletagOperationOptions = {}
+  ): GoogletagOperation<T> => {
+    if (disposed) throw new GoogletagAdapterError('operation_disposed');
+    const current = currentBinding();
+    if (disposed) throw new GoogletagAdapterError('operation_disposed');
+    if (current.status === 'pending') {
+      if (pendingReservations >= MAX_PENDING_OPERATIONS) {
+        throw new GoogletagAdapterError('external_queue_full');
+      }
+      pendingReservations += 1;
+    }
+
+    let resolve!: (value: T | PromiseLike<T>) => void;
+    let reject!: (reason: unknown) => void;
+    const result = new Promise<T>((resolveResult, rejectResult) => {
+      resolve = resolveResult;
+      reject = rejectResult;
+    });
+    const operation: PendingOperation<T> = {
+      state: current.status,
+      settled: false,
+      pendingReservation: current.status === 'pending',
+      timeout: undefined,
+      command,
+      resolve,
+      reject,
+      abortRegistration: undefined,
+      readinessBinding: current.status === 'pending' ? current.binding : undefined,
+      provisionalEffects: [],
+    };
+    const handle = Object.freeze({
+      get status(): GoogletagOperationStatus {
+        return operation.state;
+      },
+      result,
+      dispose: (): void => fail(operation as PendingOperation<unknown>, 'operation_disposed'),
+    });
+
+    try {
+      live.add(operation as PendingOperation<unknown>);
+    } catch (error) {
+      try {
+        deleteSetValue(live, operation as PendingOperation<unknown>);
+      } catch {
+        // Publication rollback preserves the original registry failure.
+      }
+      releasePendingReservation(operation as PendingOperation<unknown>);
+      throw error;
+    }
+    if (current.status === 'pending') {
+      pending[pending.length] = operation as PendingOperation<unknown>;
+      operation.timeout = setTimeout(
+        () => fail(operation as PendingOperation<unknown>, 'external_ready_timeout'),
+        EXTERNAL_READY_TIMEOUT_MS
+      );
+    }
+
+    if (disposed) {
+      fail(operation as PendingOperation<unknown>, 'operation_disposed');
+      return handle;
+    }
+    if (operation.settled) return handle;
+
+    let signal: unknown;
+    try {
+      signal = options.signal;
+    } catch (error) {
+      rejectOperation(operation as PendingOperation<unknown>, error);
+      return handle;
+    }
+    if (operation.settled) return handle;
+    if (disposed) {
+      fail(operation as PendingOperation<unknown>, 'operation_disposed');
+      return handle;
+    }
+    if (signal !== undefined) {
+      if ((typeof signal !== 'object' || signal === null) && typeof signal !== 'function') {
+        rejectOperation(
+          operation as PendingOperation<unknown>,
+          new TypeError('Invalid AbortSignal')
+        );
+        return handle;
+      }
+      let aborted: unknown;
+      let add: unknown;
+      let remove: unknown;
+      try {
+        aborted = Reflect.get(signal, 'aborted');
+        if (operation.settled) return handle;
+        add = Reflect.get(signal, 'addEventListener');
+        if (operation.settled) return handle;
+        remove = Reflect.get(signal, 'removeEventListener');
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      if (aborted === true) {
+        fail(operation as PendingOperation<unknown>, 'caller_aborted');
+        return handle;
+      }
+      if (typeof add !== 'function' || typeof remove !== 'function') {
+        rejectOperation(
+          operation as PendingOperation<unknown>,
+          new TypeError('Invalid AbortSignal')
+        );
+        return handle;
+      }
+      const registration: AbortRegistration = {
+        binding: signal,
+        listener: () => fail(operation as PendingOperation<unknown>, 'caller_aborted'),
+        remove: remove as (...arguments_: unknown[]) => unknown,
+        attempted: true,
+        cleanupRequested: false,
+        installing: true,
+      };
+      operation.abortRegistration = registration;
+      try {
+        Reflect.apply(add, signal, ['abort', registration.listener, { once: true }]);
+      } catch (error) {
+        registration.installing = false;
+        detachAbort(operation as PendingOperation<unknown>);
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      registration.installing = false;
+      if (registration.cleanupRequested || operation.settled || disposed) {
+        detachAbort(operation as PendingOperation<unknown>);
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      let abortedAfterRegistration: unknown;
+      try {
+        abortedAfterRegistration = Reflect.get(signal, 'aborted');
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      if (abortedAfterRegistration === true) {
+        fail(operation as PendingOperation<unknown>, 'caller_aborted');
+        return handle;
+      }
+    }
+
+    if (current.status === 'incompatible') {
+      operation.settled = true;
+      clearOperation(operation as PendingOperation<unknown>);
+      operation.reject(new GoogletagAdapterError('external_artifact_incompatible'));
+    } else if (current.status === 'present') {
+      dispatch(operation as PendingOperation<unknown>, current.value);
+    } else {
+      armNotification();
+    }
+    return handle;
+  };
+
+  const observePublisherCalls = (observer: GoogletagPublisherCallObserver): (() => void) => {
+    if (disposed) throw new GoogletagAdapterError('operation_disposed');
+    if (typeof observer !== 'object' || observer === null) {
+      throw new TypeError('GPT publisher observer must be an object');
+    }
+    const observerMethod = <Key extends keyof GoogletagPublisherCallObserver>(
+      key: Key
+    ): GoogletagPublisherCallObserver[Key] | undefined => {
+      const descriptor = Object.getOwnPropertyDescriptor(observer, key);
+      if (!descriptor) return undefined;
+      if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+        throw new TypeError('GPT publisher observer methods must be own data properties');
+      }
+      if (descriptor.value !== undefined && typeof descriptor.value !== 'function') {
+        throw new TypeError('GPT publisher observer methods must be functions');
+      }
+      return descriptor.value as GoogletagPublisherCallObserver[Key] | undefined;
+    };
+    const defineObserver = observerMethod('defineSlot');
+    const destroyObserver = observerMethod('destroySlots');
+    const displayObserver = observerMethod('display');
+    const refreshObserver = observerMethod('refresh');
+    const current = currentBinding();
+    if (current.status === 'pending' && current.commandQueue) {
+      const normalizedObserver: GoogletagPublisherCallObserver = Object.freeze({
+        ...(defineObserver ? { defineSlot: defineObserver } : {}),
+        ...(destroyObserver ? { destroySlots: destroyObserver } : {}),
+        ...(displayObserver ? { display: displayObserver } : {}),
+        ...(refreshObserver ? { refresh: refreshObserver } : {}),
+      });
+      let released = false;
+      let notificationActive = true;
+      let installedRelease: (() => void) | undefined;
+      const release = (): void => {
+        if (released) return;
+        released = true;
+        notificationActive = false;
+        try {
+          deleteSetValue(effects, release);
+        } catch {
+          // Exact deferred restoration still runs when bookkeeping is hostile.
+        }
+        installedRelease?.();
+      };
+      try {
+        queueCommand(current.commandQueue, () => {
+          if (!notificationActive || released || disposed) return;
+          notificationActive = false;
+          const ready = currentBinding();
+          if (ready.status !== 'present') return;
+          try {
+            installedRelease = observePublisherCalls(normalizedObserver);
+            if (released) installedRelease();
+          } catch {
+            // Readiness mediation cannot escape the publisher-owned command queue.
+          }
+        });
+      } catch (error) {
+        notificationActive = false;
+        released = true;
+        throw error;
+      }
+      registerAdapterEffect(release);
+      return release;
+    }
+    if (current.status !== 'present') return (): void => undefined;
+    const service = Reflect.apply(current.value.pubads, current.value.binding, []);
+    if ((typeof service !== 'object' || service === null) && typeof service !== 'function') {
+      throw new GoogletagAdapterError('external_artifact_incompatible');
+    }
+    const serviceObject = service as object;
+    const currentBindingObject = current.value.binding;
+    const tracker = ensureInitialLoadTracking(current.value, serviceObject);
+    const stillCurrent = (): boolean =>
+      !disposed &&
+      readTarget(target) === currentBindingObject &&
+      Reflect.apply(current.value.pubads, currentBindingObject, []) === serviceObject;
+    const safelyCurrent = (): boolean => {
+      try {
+        return stillCurrent();
+      } catch {
+        return false;
+      }
+    };
+    const publisherAdmission = (decision: unknown): GoogletagPublisherCallAdmission | undefined => {
+      if ((typeof decision !== 'object' || decision === null) && typeof decision !== 'function') {
+        return undefined;
+      }
+      const candidate = safeMember(decision as object, 'admission');
+      if (
+        (typeof candidate !== 'object' || candidate === null) &&
+        typeof candidate !== 'function'
+      ) {
+        return undefined;
+      }
+      const commit = safeMember(candidate as object, 'commit');
+      const rollback = safeMember(candidate as object, 'rollback');
+      if (typeof commit !== 'function' || typeof rollback !== 'function') return undefined;
+      return Object.freeze({
+        commit: (): void => {
+          Reflect.apply(commit, candidate, []);
+        },
+        rollback: (): void => {
+          Reflect.apply(rollback, candidate, []);
+        },
+      });
+    };
+    const commitAdmission = (admission: GoogletagPublisherCallAdmission | undefined): void => {
+      try {
+        admission?.commit();
+      } catch {
+        // Post-native bookkeeping cannot alter the publisher return value.
+      }
+    };
+    const rollbackAdmission = (admission: GoogletagPublisherCallAdmission | undefined): void => {
+      try {
+        admission?.rollback();
+      } catch {
+        // Rollback cannot replace the exact publisher-native failure.
+      }
+    };
+    const callWithAdmission = (
+      original: (...arguments_: unknown[]) => unknown,
+      receiver: unknown,
+      arguments_: readonly unknown[],
+      admission: GoogletagPublisherCallAdmission | undefined
+    ): unknown => {
+      let result: unknown;
+      try {
+        result = Reflect.apply(original, receiver, arguments_);
+      } catch (error) {
+        rollbackAdmission(admission);
+        throw error;
+      }
+      commitAdmission(admission);
+      return result;
+    };
+    const objectSlots = (candidate: unknown): readonly object[] | undefined => {
+      if (
+        !Array.isArray(candidate) ||
+        candidate.some(
+          (slot) => (typeof slot !== 'object' || slot === null) && typeof slot !== 'function'
+        )
+      ) {
+        return undefined;
+      }
+      return Object.freeze([...candidate]) as readonly object[];
+    };
+    const allSlots = (): readonly object[] | undefined => {
+      const getSlots = safeMember(serviceObject, 'getSlots');
+      if (typeof getSlots !== 'function') return undefined;
+      try {
+        return objectSlots(Reflect.apply(getSlots, serviceObject, []));
+      } catch {
+        return undefined;
+      }
+    };
+    const deferredRefreshes = new Set<() => void>();
+    const restorers: Array<() => void> = [];
+    const install = (
+      external: object,
+      key: PropertyKey,
+      mediate: (
+        original: (...arguments_: unknown[]) => unknown,
+        receiver: unknown,
+        arguments_: readonly unknown[]
+      ) => unknown
+    ): void => {
+      const original = safeMember(external, key);
+      if (typeof original !== 'function') return;
+      const callable = original as (...arguments_: unknown[]) => unknown;
+      const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+        if (consumeFacadeCall(wrapper)) {
+          return Reflect.apply(callable, this, arguments_);
+        }
+        if (!safelyCurrent()) {
+          return Reflect.apply(callable, this, arguments_);
+        }
+        return mediate(callable, this, arguments_);
+      };
+      setWeakMapValue(adapterMethodOrigins, wrapper, callable);
+      const restoreMethod = replaceMethod(external, key, wrapper, stillCurrent);
+      if (!restoreMethod) {
+        deleteWeakMapValue(adapterMethodOrigins, wrapper);
+        throw new GoogletagAdapterError('external_artifact_incompatible');
+      }
+      restorers[restorers.length] = (): void => {
+        try {
+          restoreMethod();
+        } finally {
+          deleteWeakMapValue(adapterMethodOrigins, wrapper);
+        }
+      };
+    };
+    try {
+      install(currentBindingObject, 'defineSlot', (original, receiver, arguments_) => {
+        if (!defineObserver || arguments_.length !== 3) {
+          return Reflect.apply(original, receiver, arguments_);
+        }
+        try {
+          const decision = defineObserver(
+            Object.freeze({
+              adUnitPath: arguments_[0],
+              sizes: arguments_[1],
+              elementId: arguments_[2],
+              initialLoadDisabled: tracker?.disabled === true,
+            })
+          );
+          if (
+            decision?.action === 'handoff' &&
+            ((typeof decision.slot === 'object' && decision.slot !== null) ||
+              typeof decision.slot === 'function')
+          ) {
+            return decision.slot;
+          }
+        } catch {
+          // Observer failure must leave the publisher call native.
+        }
+        return Reflect.apply(original, receiver, arguments_);
+      });
+      install(currentBindingObject, 'display', (original, receiver, arguments_) => {
+        if (displayObserver && arguments_.length === 1) {
+          let decision: ReturnType<NonNullable<GoogletagPublisherCallObserver['display']>>;
+          try {
+            decision = displayObserver(
+              Object.freeze({
+                target: arguments_[0],
+                initialLoadDisabled: tracker?.disabled === true,
+              })
+            );
+          } catch {
+            // Observer failure must leave the publisher call native.
+            return Reflect.apply(original, receiver, arguments_);
+          }
+          const admission = publisherAdmission(decision);
+          if (decision?.action === 'suppress') {
+            rollbackAdmission(admission);
+            return undefined;
+          }
+          return callWithAdmission(original, receiver, arguments_, admission);
+        }
+        return Reflect.apply(original, receiver, arguments_);
+      });
+      install(serviceObject, 'refresh', (original, receiver, arguments_) => {
+        if (refreshObserver && arguments_.length <= 2) {
+          const requested = arguments_[0] === undefined ? undefined : objectSlots(arguments_[0]);
+          const effective = requested ?? (arguments_[0] === undefined ? allSlots() : undefined);
+          if (effective) {
+            let decision: ReturnType<NonNullable<GoogletagPublisherCallObserver['refresh']>>;
+            try {
+              decision = refreshObserver(
+                Object.freeze({
+                  requestedSlots: requested,
+                  slots: effective,
+                  options: arguments_[1],
+                })
+              );
+            } catch {
+              // Observer failure must leave the publisher call native.
+              return Reflect.apply(original, receiver, arguments_);
+            }
+            const admission = publisherAdmission(decision);
+            if (decision?.action === 'suppress') {
+              rollbackAdmission(admission);
+              return undefined;
+            }
+            if (decision?.action === 'replace') {
+              const replacement = objectSlots(decision.slots);
+              if (replacement) {
+                return callWithAdmission(
+                  original,
+                  receiver,
+                  [replacement, ...arguments_.slice(1)],
+                  admission
+                );
+              }
+              rollbackAdmission(admission);
+              return Reflect.apply(original, receiver, arguments_);
+            }
+            if (decision?.action === 'defer') {
+              const replacement = objectSlots(decision.slots);
+              const completion = safeMember(decision, 'completion');
+              const then =
+                (typeof completion === 'object' && completion !== null) ||
+                typeof completion === 'function'
+                  ? safeMember(completion as object, 'then')
+                  : undefined;
+              if (!replacement || typeof then !== 'function') {
+                rollbackAdmission(admission);
+                return Reflect.apply(original, receiver, arguments_);
+              }
+              let forwarded = false;
+              const forward = (): void => {
+                if (forwarded) return;
+                forwarded = true;
+                try {
+                  deleteSetValue(deferredRefreshes, forward);
+                } catch {
+                  // The exact-once latch remains authoritative under hostile bookkeeping.
+                }
+                try {
+                  callWithAdmission(original, receiver, [replacement, arguments_[1]], admission);
+                } catch {
+                  // A deferred native throw has no synchronous publisher frame to receive it.
+                }
+              };
+              try {
+                addSetValue(deferredRefreshes, forward);
+                Promise.resolve(completion).then(forward, forward);
+              } catch {
+                try {
+                  deleteSetValue(deferredRefreshes, forward);
+                } catch {
+                  // Synchronous fail-open still owns the only native forward.
+                }
+                return callWithAdmission(
+                  original,
+                  receiver,
+                  [replacement, arguments_[1]],
+                  admission
+                );
+              }
+              return undefined;
+            }
+            return callWithAdmission(original, receiver, arguments_, admission);
+          }
+        }
+        return Reflect.apply(original, receiver, arguments_);
+      });
+      install(currentBindingObject, 'destroySlots', (original, receiver, arguments_) => {
+        let destroyedSlots: readonly object[] | undefined;
+        if (arguments_.length === 0 || (arguments_.length === 1 && arguments_[0] === undefined)) {
+          destroyedSlots = allSlots();
+        } else if (arguments_.length === 1) {
+          destroyedSlots = objectSlots(arguments_[0]);
+        }
+        const result = Reflect.apply(original, receiver, arguments_);
+        if (result === true && destroyedSlots && destroyObserver) {
+          try {
+            destroyObserver(Object.freeze({ slots: destroyedSlots }));
+          } catch {
+            // Post-call bookkeeping cannot alter the publisher return value.
+          }
+        }
+        return result;
+      });
+    } catch (error) {
+      for (let index = restorers.length - 1; index >= 0; index -= 1) restorers[index]?.();
+      throw error;
+    }
+    let released = false;
+    const release = (): void => {
+      if (released) return;
+      released = true;
+      try {
+        deleteSetValue(effects, release);
+      } catch {
+        // Exact wrapper restoration still runs when bookkeeping is hostile.
+      }
+      const deferred = setValueSnapshot(deferredRefreshes);
+      for (let index = 0; index < deferred.length; index += 1) deferred[index]?.();
+      for (let index = restorers.length - 1; index >= 0; index -= 1) restorers[index]?.();
+    };
+    registerAdapterEffect(release);
+    return release;
+  };
+
+  const observeDiagnostics = (observer: GoogletagDiagnosticsObserver): (() => void) | undefined => {
+    if (disposed || typeof observer !== 'function' || diagnosticsObserver) return undefined;
+    diagnosticsObserver = observer;
+    let active = true;
+    const release = (): void => {
+      if (!active) return;
+      active = false;
+      if (diagnosticsObserver === observer) diagnosticsObserver = undefined;
+      try {
+        deleteSetValue(effects, release);
+      } catch {
+        // Exact observer release remains authoritative under registry failure.
+      }
+    };
+    try {
+      registerAdapterEffect(release);
+    } catch (error) {
+      release();
+      throw error;
+    }
+    return release;
+  };
+
+  return Object.freeze({
+    bindingStatus: (): GoogletagBindingStatus => currentBinding().status,
+    enqueueGamAttribution,
+    adoptDiagnosticsState,
+    diagnosticsIdentity: (slot: object): Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined => {
+      const state = diagnosticsSlotState(slot);
+      if (!state?.traceToken) return undefined;
+      const currentCycle = state.cycles.reduce<TraceCycle | undefined>(
+        (latest, cycle) => (!latest || cycle.ordinal > latest.ordinal ? cycle : latest),
+        undefined
+      );
+      return Object.freeze({
+        token: state.token,
+        traceToken: state.traceToken,
+        runtimeSlotNumber: Number.parseInt(state.traceToken.slice(4), 36),
+        ...(currentCycle === undefined ? {} : { cycleOrdinal: currentCycle.ordinal }),
+        ...(state.elementId === undefined ? {} : { elementId: state.elementId }),
+        ...(state.adUnitPath === undefined ? {} : { adUnitPath: state.adUnitPath }),
+      });
+    },
+    traceToken: (slot: object): GptSlotTokenV1 | undefined =>
+      diagnosticsSlotState(slot)?.traceToken,
+    observeDiagnostics,
+    observePublisherCalls,
+    run,
+    notifyReady,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      try {
+        mintedTraceTokens?.clear();
+      } catch {
+        // Diagnostics identity cleanup cannot interrupt independent adapter disposal.
+      }
+      for (const operation of [...live]) fail(operation, 'operation_disposed');
+      try {
+        releaseHistoricalInitialLoadBindings();
+      } catch {
+        // Initial-load registry failure cannot interrupt independent adapter effects.
+      } finally {
+        for (const disposeEffect of [...effects]) {
+          try {
+            deleteSetValue(effects, disposeEffect);
+          } catch {
+            // A hostile registry cannot interrupt cleanup of remaining effects.
+          }
+          try {
+            disposeEffect();
+          } catch {
+            // One cleanup cannot interrupt the remaining adapter disposers.
+          }
+        }
+      }
+    },
+  });
+}
+
+/** Create a side-effect-free GPT boundary for tests and unavailable environments. */
+export function createNoopGoogletagAdapter(): GoogletagAdapter {
+  return createBrowserGoogletagAdapter({});
+}
diff --git a/crates/trusted-server-js/lib/src/adapters/messaging.ts b/crates/trusted-server-js/lib/src/adapters/messaging.ts
new file mode 100644
index 000000000..8cc141cfb
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/adapters/messaging.ts
@@ -0,0 +1,1407 @@
+import { TSJS_MESSAGE_PROTOCOL_V1 } from '../kernel/contracts/message_protocol';
+
+const MAX_GLOBAL_MESSAGE_BYTES = 4_096;
+const setDeleteIntrinsic = Set.prototype.delete;
+const setValuesIntrinsic = Set.prototype.values;
+const setIteratorNextIntrinsic = Reflect.get(
+  Object.getPrototypeOf(Reflect.apply(setValuesIntrinsic, new Set(), [])),
+  'next'
+) as (...arguments_: unknown[]) => unknown;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+const weakSetAddIntrinsic = WeakSet.prototype.add;
+const weakSetHasIntrinsic = WeakSet.prototype.has;
+
+function deleteSetValue<T>(set: Set<T>, value: T): boolean {
+  return Reflect.apply(setDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function snapshotSetValues<T>(set: Set<T>): readonly T[] {
+  const iterator = Reflect.apply(setValuesIntrinsic, set, []) as object;
+  const values: T[] = [];
+  let index = 0;
+  while (true) {
+    const step = Reflect.apply(setIteratorNextIntrinsic, iterator, []) as IteratorResult<T>;
+    if (step.done) return values;
+    values[index] = step.value;
+    index += 1;
+  }
+}
+
+export { TSJS_MESSAGE_PROTOCOL_V1 };
+
+interface ProtocolMessageSchema {
+  readonly transport: 'global-json' | 'structured';
+  readonly keys: readonly string[];
+  readonly literals: Readonly<Record<string, unknown>>;
+  readonly maximumBytes?: number;
+}
+
+function schema(
+  transport: ProtocolMessageSchema['transport'],
+  keys: readonly string[],
+  literals: Readonly<Record<string, unknown>>,
+  maximumBytes?: number
+): ProtocolMessageSchema {
+  return Object.freeze({
+    transport,
+    keys: Object.freeze([...keys]),
+    literals: Object.freeze({ ...literals }),
+    ...(maximumBytes === undefined ? {} : { maximumBytes }),
+  });
+}
+
+/** Exact top-level shapes for every protocol message and nested protocol record. */
+export const PROTOCOL_MESSAGE_SCHEMAS_V1 = Object.freeze({
+  prebidRequest: schema('global-json', ['message', 'adId', 'adServerDomain'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.prebidRequest,
+  }),
+  ownerRegister: schema('global-json', ['message', 'adId', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerRegister,
+    version: 1,
+  }),
+  prebidResponse: schema(
+    'structured',
+    ['message', 'adId', 'renderer', 'rendererVersion', 'tsOwner'],
+    { message: TSJS_MESSAGE_PROTOCOL_V1.message.prebidResponse, rendererVersion: '4' }
+  ),
+  prebidResponseRefused: schema('structured', ['message', 'adId', 'rendererVersion', 'tsOwner'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.prebidResponse,
+    rendererVersion: '4',
+  }),
+  tsOwnerReady: schema('structured', ['version', 'status', 'kind', 'lifecycleTicket'], {
+    version: 1,
+    status: TSJS_MESSAGE_PROTOCOL_V1.status.ready,
+  }),
+  tsOwnerRefused: schema('structured', ['version', 'status'], {
+    version: 1,
+    status: TSJS_MESSAGE_PROTOCOL_V1.status.refused,
+  }),
+  ownerRegistered: schema('structured', ['message', 'adId', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerRegistered,
+    version: 1,
+  }),
+  ownerRefused: schema('structured', ['message', 'adId', 'version'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerRefused,
+    version: 1,
+  }),
+  apsTopMountStarted: schema('structured', ['message', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsTopMountStarted,
+    version: 1,
+  }),
+  apsEnvelope: schema('structured', ['version', 'nonce', 'publisherOrigin', 'renderer'], {
+    version: 1,
+  }),
+  admStart: schema('structured', ['message', 'version', 'lifecycleTicket', 'source'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.admStart,
+    version: 1,
+  }),
+  ownerInserted: schema('structured', ['message', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerInserted,
+    version: 1,
+  }),
+  admLoaded: schema('structured', ['message', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.admLoaded,
+    version: 1,
+  }),
+  admFailed: schema('structured', ['message', 'version', 'lifecycleTicket'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.admFailed,
+    version: 1,
+  }),
+  ownerSettledAccepted: schema('structured', ['message', 'version', 'lifecycleTicket', 'outcome'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerSettled,
+    version: 1,
+    outcome: TSJS_MESSAGE_PROTOCOL_V1.outcome.accepted,
+  }),
+  ownerSettledFailed: schema(
+    'structured',
+    ['message', 'version', 'lifecycleTicket', 'outcome', 'reason'],
+    {
+      message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerSettled,
+      version: 1,
+      outcome: TSJS_MESSAGE_PROTOCOL_V1.outcome.failed,
+    }
+  ),
+  ownerSettledCancelled: schema(
+    'structured',
+    ['message', 'version', 'lifecycleTicket', 'outcome', 'reason'],
+    {
+      message: TSJS_MESSAGE_PROTOCOL_V1.message.ownerSettled,
+      version: 1,
+      outcome: TSJS_MESSAGE_PROTOCOL_V1.outcome.cancelled,
+    }
+  ),
+  apsBootstrapReady: schema('global-json', ['message', 'version', 'bootstrapNonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsBootstrapReady,
+    version: 1,
+  }),
+  apsBootstrapConfigure: schema(
+    'global-json',
+    ['message', 'version', 'bootstrapNonce', 'rendererNonce', 'creativeOrigin', 'tagType'],
+    { message: TSJS_MESSAGE_PROTOCOL_V1.message.apsBootstrapConfigure, version: 2 },
+    16_384
+  ),
+  apsInnerReady: schema('global-json', ['message', 'version', 'rendererNonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsInnerReady,
+    version: 1,
+  }),
+  apsInnerBind: schema('global-json', ['message', 'version', 'rendererNonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsInnerBind,
+    version: 1,
+  }),
+  apsContainerReady: schema(
+    'global-json',
+    ['message', 'version', 'bootstrapNonce', 'rendererNonce'],
+    { message: TSJS_MESSAGE_PROTOCOL_V1.message.apsContainerReady, version: 1 }
+  ),
+  apsDocumentAccepted: schema('structured', ['message', 'version', 'nonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsDocumentAccepted,
+    version: 1,
+  }),
+  apsRunnerLoaded: schema('structured', ['message', 'version', 'nonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsRunnerLoaded,
+    version: 1,
+  }),
+  apsRenderCompleted: schema('structured', ['message', 'version', 'nonce'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsRenderCompleted,
+    version: 1,
+  }),
+  apsRenderFailed: schema('structured', ['message', 'version', 'nonce', 'reason'], {
+    message: TSJS_MESSAGE_PROTOCOL_V1.message.apsRenderFailed,
+    version: 1,
+  }),
+});
+
+export type ProtocolMessageKind = keyof typeof PROTOCOL_MESSAGE_SCHEMAS_V1;
+export type CaptureMessageListener = (event: MessageEvent) => void;
+
+/** Exact browser event surface owned by the cross-window messaging adapter. */
+export interface MessageEventTarget {
+  addEventListener(type: 'message', listener: CaptureMessageListener, capture: true): void;
+  removeEventListener(type: 'message', listener: CaptureMessageListener, capture: true): void;
+  readonly MessageChannel?: new () => { readonly port1: unknown; readonly port2: unknown };
+}
+
+/** A narrow owned endpoint for one transferred browser message port. */
+export interface MessagingPort {
+  post(message: unknown, transferred: readonly unknown[]): boolean;
+  listen(
+    messageListener: (event: unknown) => void,
+    messageErrorListener: (event: unknown) => void
+  ): () => void;
+  close(): void;
+}
+
+/** One locally retained endpoint and one endpoint eligible for exact transfer. */
+export interface MessagingChannel {
+  readonly retained: MessagingPort;
+  readonly transferred: MessagingPort;
+}
+
+/** Cross-window boundary consumed by the kernel's capability recognizer. */
+export interface MessagingAdapter {
+  createChannel(): MessagingChannel | undefined;
+  postWindow(
+    target: unknown,
+    message: unknown,
+    targetOrigin: string,
+    transferred: readonly MessagingPort[]
+  ): boolean;
+  installCaptureListener(listener: CaptureMessageListener): (() => void) | undefined;
+  inspectGlobalMessage(candidate: unknown):
+    | Readonly<{
+        message: string;
+        adId?: string;
+        lifecycleTicket?: string;
+      }>
+    | undefined;
+  parseProtocolMessage(
+    kind: ProtocolMessageKind,
+    candidate: unknown
+  ): Readonly<Record<string, unknown>> | undefined;
+  extractTransferredPorts(
+    event: unknown,
+    expectedCount: 0 | 1 | 2
+  ): readonly MessagingPort[] | undefined;
+  inspectTransferredPorts(event: unknown):
+    | Readonly<{
+        exactShape: boolean;
+        originalCount: number;
+        ports: readonly MessagingPort[];
+      }>
+    | undefined;
+}
+
+/** Semantic validators injected by composition without reversing adapter layering. */
+export interface MessagingValidationOptions {
+  readonly validateApsRenderer?: (candidate: unknown) => boolean;
+  readonly expectedPublisherOrigin?: string;
+  readonly expectedRendererUrl?: string;
+}
+
+const capabilityPatterns = Object.freeze({
+  reservation: /^r1_[A-Za-z0-9_-]{22}$/,
+  ticket: /^t1_[A-Za-z0-9_-]{22}$/,
+  bootstrapNonce: /^b1_[A-Za-z0-9_-]{22}$/,
+  nonce: /^n1_[A-Za-z0-9_-]{22}$/,
+});
+const apsRendererKeys = Object.freeze([
+  'type',
+  'version',
+  'accountId',
+  'bidId',
+  'tagType',
+  'creativeUrl',
+  'width',
+  'height',
+  'aaxResponse',
+]);
+const apsRendererKeysWithCreativeId = Object.freeze([...apsRendererKeys, 'creativeId']);
+const encoder = new TextEncoder();
+const cancellationReasons = new Set<string>(Object.values(TSJS_MESSAGE_PROTOCOL_V1.cancellation));
+const runnerFailureReasons = new Set<string>(Object.values(TSJS_MESSAGE_PROTOCOL_V1.runnerFailure));
+const renderFailureReasons = new Set<string>([
+  'auction_timeout',
+  'auction_disabled',
+  'consent_denied',
+  'slot_not_eligible',
+  'provider_timeout',
+  'provider_error',
+  'invalid_provider_response',
+  'mediation_failed',
+  'winner_not_renderable',
+  'internal_error',
+  'network_error',
+  'http_error',
+  'invalid_response',
+  'slot_unresolved',
+  'descriptor_invalid',
+  'invalid_dimensions',
+  'dimensions_out_of_range',
+  'no_render_source',
+  'registry_full',
+  'capability_registry_full',
+  'external_queue_full',
+  'external_ready_timeout',
+  'external_artifact_incompatible',
+  'prebid_admission_failed',
+  'prebid_contract_violation',
+  'prebid_selection_timeout',
+  'reservation_collision',
+  'identity_generation_failed',
+  'cycle_unattributable',
+  'slot_quarantined',
+  'gpt_request_failed',
+  'gpt_request_timeout',
+  'gpt_completion_timeout',
+  'reconciliation_capacity',
+  'gam_empty',
+  'bridge_claim_timeout',
+  'bridge_id_mismatch',
+  'owner_registration_timeout',
+  'owner_insertion_timeout',
+  'renderer_document_no_load',
+  'runner_no_load',
+  'runner_failed',
+  'adm_document_no_load',
+  'abi_mismatch',
+  'bundle_partial',
+]);
+
+function validUnicodeScalars(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!Number.isInteger(next) || next < 0xdc00 || next > 0xdfff) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function boundedString(
+  value: unknown,
+  maximumBytes: number,
+  options: { readonly controls?: boolean; readonly empty?: boolean } = {}
+): value is string {
+  let hasControl = false;
+  if (typeof value === 'string' && options.controls !== true) {
+    for (let index = 0; index < value.length; index += 1) {
+      const code = value.charCodeAt(index);
+      if (code <= 0x1f || code === 0x7f) {
+        hasControl = true;
+        break;
+      }
+    }
+  }
+  return (
+    typeof value === 'string' &&
+    (options.empty === true || value.length > 0) &&
+    validUnicodeScalars(value) &&
+    !hasControl &&
+    encoder.encode(value).byteLength <= maximumBytes
+  );
+}
+
+function capability(value: unknown, kind: keyof typeof capabilityPatterns): value is string {
+  return typeof value === 'string' && capabilityPatterns[kind].test(value);
+}
+
+function dimension(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= 1 &&
+    value <= 4096
+  );
+}
+
+function exactHttpOrigin(value: unknown): value is string {
+  if (!boundedString(value, 2_048)) return false;
+  try {
+    const parsed = new URL(value);
+    return (
+      (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      parsed.username === '' &&
+      parsed.password === '' &&
+      parsed.origin === value &&
+      parsed.pathname === '/' &&
+      parsed.search === '' &&
+      parsed.hash === ''
+    );
+  } catch {
+    return false;
+  }
+}
+
+function skipWhitespace(source: string, start: number): number {
+  let index = start;
+  while (index < source.length && /\s/.test(source[index] ?? '')) index += 1;
+  return index;
+}
+
+function scanString(source: string, start: number): number | undefined {
+  if (source[start] !== '"') return undefined;
+  let index = start + 1;
+  while (index < source.length) {
+    const character = source[index];
+    if (character === '"') return index + 1;
+    if (character === '\\') {
+      index += 1;
+      if (index >= source.length) return undefined;
+      if (source[index] === 'u') {
+        if (!/^[0-9a-fA-F]{4}$/.test(source.slice(index + 1, index + 5))) return undefined;
+        index += 4;
+      }
+    } else if (character !== undefined && character.charCodeAt(0) < 0x20) {
+      return undefined;
+    }
+    index += 1;
+  }
+  return undefined;
+}
+
+function scanJsonValue(source: string, start: number): number | undefined {
+  let index = skipWhitespace(source, start);
+  if (source[index] === '"') return scanString(source, index);
+  if (source[index] === '[') {
+    index = skipWhitespace(source, index + 1);
+    if (source[index] === ']') return index + 1;
+    while (index < source.length) {
+      const end = scanJsonValue(source, index);
+      if (end === undefined) return undefined;
+      index = skipWhitespace(source, end);
+      if (source[index] === ']') return index + 1;
+      if (source[index] !== ',') return undefined;
+      index = skipWhitespace(source, index + 1);
+    }
+    return undefined;
+  }
+  if (source[index] === '{') {
+    const keys = new Set<string>();
+    index = skipWhitespace(source, index + 1);
+    if (source[index] === '}') return index + 1;
+    while (index < source.length) {
+      const keyEnd = scanString(source, index);
+      if (keyEnd === undefined) return undefined;
+      let key: string;
+      try {
+        key = JSON.parse(source.slice(index, keyEnd)) as string;
+      } catch {
+        return undefined;
+      }
+      if (keys.has(key)) return undefined;
+      keys.add(key);
+      index = skipWhitespace(source, keyEnd);
+      if (source[index] !== ':') return undefined;
+      const valueEnd = scanJsonValue(source, index + 1);
+      if (valueEnd === undefined) return undefined;
+      index = skipWhitespace(source, valueEnd);
+      if (source[index] === '}') return index + 1;
+      if (source[index] !== ',') return undefined;
+      index = skipWhitespace(source, index + 1);
+    }
+    return undefined;
+  }
+  const match = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(
+    source.slice(index)
+  );
+  return match ? index + match[0].length : undefined;
+}
+
+function parseGlobalJson(candidate: unknown, maximumBytes = MAX_GLOBAL_MESSAGE_BYTES): unknown {
+  if (
+    typeof candidate !== 'string' ||
+    new TextEncoder().encode(candidate).byteLength > maximumBytes
+  ) {
+    return undefined;
+  }
+  const end = scanJsonValue(candidate, 0);
+  if (end === undefined || skipWhitespace(candidate, end) !== candidate.length) return undefined;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    return undefined;
+  }
+}
+
+function inspectGlobalMessage(
+  candidate: unknown
+): Readonly<{ message: string; adId?: string; lifecycleTicket?: string }> | undefined {
+  try {
+    const decoded = typeof candidate === 'string' ? parseGlobalJson(candidate) : candidate;
+    if (typeof decoded !== 'object' || decoded === null) return undefined;
+    const prototype = Object.getPrototypeOf(decoded);
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const descriptors = Object.getOwnPropertyDescriptors(decoded);
+    const message = descriptors['message'];
+    if (!message || !Object.prototype.hasOwnProperty.call(message, 'value')) return undefined;
+    if (typeof message.value !== 'string') return undefined;
+    const adId = descriptors['adId'];
+    const lifecycleTicket = descriptors['lifecycleTicket'];
+    if (adId && !Object.prototype.hasOwnProperty.call(adId, 'value')) return undefined;
+    if (lifecycleTicket && !Object.prototype.hasOwnProperty.call(lifecycleTicket, 'value')) {
+      return undefined;
+    }
+    return Object.freeze({
+      message: message.value,
+      ...(adId && typeof adId.value === 'string' ? { adId: adId.value } : {}),
+      ...(lifecycleTicket && typeof lifecycleTicket.value === 'string'
+        ? { lifecycleTicket: lifecycleTicket.value }
+        : {}),
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function exactRecord(
+  candidate: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    if (typeof candidate !== 'object' || candidate === null) {
+      return undefined;
+    }
+    const prototype = Object.getPrototypeOf(candidate);
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const ownKeys = Reflect.ownKeys(candidate);
+    const descriptors = Object.getOwnPropertyDescriptors(candidate);
+    if (
+      ownKeys.length !== keys.length ||
+      ownKeys.some((key) => typeof key !== 'string') ||
+      keys.some((key) => !ownKeys.includes(key))
+    ) {
+      return undefined;
+    }
+    const accepted: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const key of keys) {
+      const descriptor = descriptors[key];
+      if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+        return undefined;
+      }
+      accepted[key] = descriptor.value;
+    }
+    return Object.freeze(accepted);
+  } catch {
+    return undefined;
+  }
+}
+
+function admSource(candidate: unknown): boolean {
+  const source = exactRecord(candidate, ['type', 'version', 'adm', 'width', 'height']);
+  return (
+    source !== undefined &&
+    source['type'] === 'adm' &&
+    source['version'] === 1 &&
+    boundedString(source['adm'], 512 * 1024, { controls: true }) &&
+    dimension(source['width']) &&
+    dimension(source['height'])
+  );
+}
+
+function canonicalApsRenderer(candidate: unknown): Readonly<Record<string, unknown>> | undefined {
+  const renderer =
+    exactRecord(candidate, apsRendererKeys) ??
+    exactRecord(candidate, apsRendererKeysWithCreativeId);
+  if (!renderer) return undefined;
+  for (const value of Object.values(renderer)) {
+    if (!['string', 'number'].includes(typeof value)) return undefined;
+  }
+  return renderer;
+}
+
+function canonicalApsEnvelope(
+  candidate: unknown,
+  options: MessagingValidationOptions
+): Readonly<Record<string, unknown>> | undefined {
+  const envelope = exactRecord(candidate, ['version', 'nonce', 'publisherOrigin', 'renderer']);
+  if (
+    envelope === undefined ||
+    envelope['version'] !== 1 ||
+    !capability(envelope['nonce'], 'nonce') ||
+    !exactHttpOrigin(envelope['publisherOrigin']) ||
+    options.expectedPublisherOrigin === undefined ||
+    envelope['publisherOrigin'] !== options.expectedPublisherOrigin
+  ) {
+    return undefined;
+  }
+  const renderer = canonicalApsRenderer(envelope['renderer']);
+  if (!renderer || options.validateApsRenderer?.(renderer) !== true) return undefined;
+  return replaceNested(envelope, ['version', 'nonce', 'publisherOrigin', 'renderer'], { renderer });
+}
+
+function parseTsOwner(candidate: unknown): Readonly<Record<string, unknown>> | undefined {
+  const ready = exactRecord(candidate, ['version', 'status', 'kind', 'lifecycleTicket']);
+  if (ready) {
+    return ready['version'] === 1 &&
+      ready['status'] === TSJS_MESSAGE_PROTOCOL_V1.status.ready &&
+      (ready['kind'] === TSJS_MESSAGE_PROTOCOL_V1.kind.aps ||
+        ready['kind'] === TSJS_MESSAGE_PROTOCOL_V1.kind.adm) &&
+      capability(ready['lifecycleTicket'], 'ticket')
+      ? ready
+      : undefined;
+  }
+  const refused = exactRecord(candidate, ['version', 'status']);
+  return refused !== undefined &&
+    refused['version'] === 1 &&
+    refused['status'] === TSJS_MESSAGE_PROTOCOL_V1.status.refused
+    ? refused
+    : undefined;
+}
+
+function validProtocolFields(
+  kind: ProtocolMessageKind,
+  record: Readonly<Record<string, unknown>>,
+  _options: MessagingValidationOptions
+): boolean {
+  const ticket = (): boolean => capability(record['lifecycleTicket'], 'ticket');
+  const nonce = (): boolean => capability(record['nonce'], 'nonce');
+  switch (kind) {
+    case 'prebidRequest':
+      return (
+        capability(record['adId'], 'reservation') && boundedString(record['adServerDomain'], 2_048)
+      );
+    case 'ownerRegister':
+      return capability(record['adId'], 'reservation') && ticket();
+    case 'prebidResponse': {
+      const owner = parseTsOwner(record['tsOwner']);
+      return (
+        capability(record['adId'], 'reservation') &&
+        boundedString(record['renderer'], 64 * 1024, { controls: true }) &&
+        owner?.['status'] === TSJS_MESSAGE_PROTOCOL_V1.status.ready
+      );
+    }
+    case 'prebidResponseRefused': {
+      const owner = parseTsOwner(record['tsOwner']);
+      return (
+        capability(record['adId'], 'reservation') &&
+        owner?.['status'] === TSJS_MESSAGE_PROTOCOL_V1.status.refused
+      );
+    }
+    case 'tsOwnerReady':
+      return (
+        (record['kind'] === TSJS_MESSAGE_PROTOCOL_V1.kind.aps ||
+          record['kind'] === TSJS_MESSAGE_PROTOCOL_V1.kind.adm) &&
+        ticket()
+      );
+    case 'tsOwnerRefused':
+      return true;
+    case 'ownerRegistered':
+      return capability(record['adId'], 'reservation') && ticket();
+    case 'ownerRefused':
+      return capability(record['adId'], 'reservation');
+    case 'apsTopMountStarted':
+      return ticket();
+    case 'apsEnvelope':
+      return true;
+    case 'admStart':
+      return ticket() && admSource(record['source']);
+    case 'ownerInserted':
+    case 'admLoaded':
+    case 'admFailed':
+      return ticket();
+    case 'ownerSettledAccepted':
+      return ticket();
+    case 'ownerSettledFailed':
+      return (
+        ticket() &&
+        typeof record['reason'] === 'string' &&
+        renderFailureReasons.has(record['reason'])
+      );
+    case 'ownerSettledCancelled':
+      return (
+        ticket() &&
+        typeof record['reason'] === 'string' &&
+        cancellationReasons.has(record['reason'])
+      );
+    case 'apsBootstrapReady':
+      return capability(record['bootstrapNonce'], 'bootstrapNonce');
+    case 'apsBootstrapConfigure':
+      return (
+        capability(record['bootstrapNonce'], 'bootstrapNonce') &&
+        capability(record['rendererNonce'], 'nonce') &&
+        exactHttpOrigin(record['creativeOrigin']) &&
+        (record['creativeOrigin'] as string).startsWith('https://') &&
+        (record['tagType'] === 'iframe' || record['tagType'] === 'script')
+      );
+    case 'apsInnerReady':
+    case 'apsInnerBind':
+      return capability(record['rendererNonce'], 'nonce');
+    case 'apsContainerReady':
+      return (
+        capability(record['bootstrapNonce'], 'bootstrapNonce') &&
+        capability(record['rendererNonce'], 'nonce')
+      );
+    case 'apsDocumentAccepted':
+    case 'apsRunnerLoaded':
+    case 'apsRenderCompleted':
+      return nonce();
+    case 'apsRenderFailed':
+      return (
+        nonce() &&
+        typeof record['reason'] === 'string' &&
+        runnerFailureReasons.has(record['reason'])
+      );
+  }
+}
+
+function replaceNested(
+  record: Readonly<Record<string, unknown>>,
+  keys: readonly string[],
+  replacements: Readonly<Record<string, unknown>>
+): Readonly<Record<string, unknown>> {
+  const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const key of keys) {
+    output[key] = Object.prototype.hasOwnProperty.call(replacements, key)
+      ? replacements[key]
+      : record[key];
+  }
+  return Object.freeze(output);
+}
+
+function canonicalProtocolRecord(
+  kind: ProtocolMessageKind,
+  record: Readonly<Record<string, unknown>>,
+  keys: readonly string[],
+  options: MessagingValidationOptions
+): Readonly<Record<string, unknown>> | undefined {
+  if (kind === 'prebidResponse' || kind === 'prebidResponseRefused') {
+    const owner = parseTsOwner(record['tsOwner']);
+    return owner ? replaceNested(record, keys, { tsOwner: owner }) : undefined;
+  }
+  if (kind === 'apsEnvelope') return canonicalApsEnvelope(record, options);
+  if (kind === 'admStart') {
+    const source = exactRecord(record['source'], ['type', 'version', 'adm', 'width', 'height']);
+    return source ? replaceNested(record, keys, { source }) : undefined;
+  }
+  return record;
+}
+
+function parseProtocolMessage(
+  kind: ProtocolMessageKind,
+  candidate: unknown,
+  options: MessagingValidationOptions
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const messageSchema = (
+      PROTOCOL_MESSAGE_SCHEMAS_V1 as Readonly<Record<string, ProtocolMessageSchema>>
+    )[kind];
+    if (!messageSchema) return undefined;
+    const decoded =
+      messageSchema.transport === 'global-json'
+        ? parseGlobalJson(candidate, messageSchema.maximumBytes)
+        : candidate;
+    const accepted = exactRecord(decoded, messageSchema.keys);
+    if (!accepted) return undefined;
+    for (const [key, literal] of Object.entries(messageSchema.literals)) {
+      if (accepted[key] !== literal) return undefined;
+    }
+    const canonical = canonicalProtocolRecord(kind, accepted, messageSchema.keys, options);
+    if (!canonical) return undefined;
+    if (!validProtocolFields(kind, canonical, options)) return undefined;
+    if (
+      kind === 'prebidResponse' &&
+      encoder.encode(JSON.stringify(canonical)).byteLength > 72 * 1024
+    ) {
+      return undefined;
+    }
+    return canonical;
+  } catch {
+    return undefined;
+  }
+}
+
+interface CapturedPortClose {
+  readonly binding: object;
+  readonly closePort: (...arguments_: unknown[]) => unknown;
+}
+
+interface RawPort extends CapturedPortClose {
+  readonly add: (...arguments_: unknown[]) => unknown;
+  readonly postMessage: (...arguments_: unknown[]) => unknown;
+  readonly remove: (...arguments_: unknown[]) => unknown;
+  readonly start?: (...arguments_: unknown[]) => unknown;
+}
+
+interface RawPortInspection {
+  readonly close: CapturedPortClose | undefined;
+  readonly raw: RawPort | undefined;
+}
+
+interface WrappedPortState {
+  readonly raw: RawPort;
+  readonly transferable: boolean;
+  closed: boolean;
+  transferred: boolean;
+  transferring: boolean;
+}
+
+interface TransferReservation {
+  readonly rawTransfers: readonly object[];
+  readonly states: readonly WrappedPortState[];
+}
+
+const wrappedPortStates = new WeakMap<MessagingPort, WrappedPortState>();
+const ownedPortBindings = new WeakSet<object>();
+
+function getWrappedPortState(port: MessagingPort): WrappedPortState | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, wrappedPortStates, [port]) as
+    WrappedPortState | undefined;
+}
+
+function setWrappedPortState(port: MessagingPort, state: WrappedPortState): void {
+  Reflect.apply(weakMapSetIntrinsic, wrappedPortStates, [port, state]);
+}
+
+function ownsPortBinding(binding: object): boolean {
+  return Reflect.apply(weakSetHasIntrinsic, ownedPortBindings, [binding]) as boolean;
+}
+
+function claimPortBinding(binding: object): void {
+  Reflect.apply(weakSetAddIntrinsic, ownedPortBindings, [binding]);
+}
+
+function portCandidateBinding(candidate: unknown): object | undefined {
+  return (typeof candidate === 'object' && candidate !== null) || typeof candidate === 'function'
+    ? (candidate as object)
+    : undefined;
+}
+
+function claimPortCandidate(candidate: unknown): boolean {
+  const binding = portCandidateBinding(candidate);
+  if (!binding || ownsPortBinding(binding)) return false;
+  claimPortBinding(binding);
+  return true;
+}
+
+function inspectRawPort(candidate: unknown): RawPortInspection {
+  const binding = portCandidateBinding(candidate);
+  if (!binding) return { close: undefined, raw: undefined };
+  let closePort: unknown;
+  try {
+    closePort = Reflect.get(binding, 'close');
+  } catch {
+    return { close: undefined, raw: undefined };
+  }
+  if (typeof closePort !== 'function') return { close: undefined, raw: undefined };
+  const callableClose = closePort as (...arguments_: unknown[]) => unknown;
+  const close: CapturedPortClose = { binding, closePort: callableClose };
+  try {
+    const add = Reflect.get(binding, 'addEventListener');
+    const postMessage = Reflect.get(binding, 'postMessage');
+    const remove = Reflect.get(binding, 'removeEventListener');
+    const start = Reflect.get(binding, 'start');
+    if (
+      typeof add !== 'function' ||
+      typeof postMessage !== 'function' ||
+      typeof remove !== 'function' ||
+      (start !== undefined && typeof start !== 'function')
+    ) {
+      return { close, raw: undefined };
+    }
+    return {
+      close,
+      raw: { binding, add, closePort: callableClose, postMessage, remove, start },
+    };
+  } catch {
+    return { close, raw: undefined };
+  }
+}
+
+function closeRawPort(candidate: unknown): void {
+  try {
+    if ((typeof candidate !== 'object' || candidate === null) && typeof candidate !== 'function') {
+      return;
+    }
+    const close = Reflect.get(candidate, 'close');
+    if (typeof close === 'function') Reflect.apply(close, candidate, []);
+  } catch {
+    // Closing one invalid port cannot interrupt cleanup of the remaining ports.
+  }
+}
+
+function closeCapturedRawPort(raw: CapturedPortClose): void {
+  try {
+    Reflect.apply(raw.closePort, raw.binding, []);
+  } catch {
+    // A captured endpoint close cannot interrupt channel-construction cleanup.
+  }
+}
+
+function wrapPort(raw: RawPort, transferable = false): MessagingPort {
+  const listeners = new Set<() => void>();
+  const state: WrappedPortState = {
+    raw,
+    transferable,
+    closed: false,
+    transferred: false,
+    transferring: false,
+  };
+  const port: MessagingPort = Object.freeze({
+    post: (message: unknown, transferred: readonly unknown[]): boolean => {
+      if (state.transferable || state.closed || state.transferred || state.transferring) {
+        return false;
+      }
+      const reservation = reserveTransferPorts(transferred);
+      if (!reservation) return false;
+      try {
+        Reflect.apply(raw.postMessage, raw.binding, [message, reservation.rawTransfers]);
+      } catch {
+        rollbackTransferReservation(reservation);
+        return false;
+      }
+      commitTransferReservation(reservation);
+      return true;
+    },
+    listen: (
+      messageListener: (event: unknown) => void,
+      messageErrorListener: (event: unknown) => void
+    ): (() => void) => {
+      if (state.transferable || state.closed || state.transferred || state.transferring) {
+        return () => undefined;
+      }
+      const wrappedMessage = (event: unknown): void => {
+        if (state.closed || state.transferred) return;
+        try {
+          messageListener(event);
+        } catch {
+          // Channel callbacks cannot escape the messaging boundary.
+        }
+      };
+      const wrappedMessageError = (event: unknown): void => {
+        if (state.closed || state.transferred) return;
+        try {
+          messageErrorListener(event);
+        } catch {
+          // Message deserialization failures remain contained by the channel boundary.
+        }
+      };
+      let messageAttempted = false;
+      let messageErrorAttempted = false;
+      let setupInProgress = true;
+      const rollback = (): void => {
+        if (messageErrorAttempted) {
+          messageErrorAttempted = false;
+          try {
+            Reflect.apply(raw.remove, raw.binding, ['messageerror', wrappedMessageError]);
+          } catch {
+            // One listener cleanup cannot interrupt rollback of the other listener.
+          }
+        }
+        if (messageAttempted) {
+          messageAttempted = false;
+          try {
+            Reflect.apply(raw.remove, raw.binding, ['message', wrappedMessage]);
+          } catch {
+            // Listener cleanup remains best-effort during terminal port disposal.
+          }
+        }
+      };
+      let active = true;
+      const dispose = (): void => {
+        if (!active) return;
+        active = false;
+        try {
+          deleteSetValue(listeners, dispose);
+        } finally {
+          if (!setupInProgress) rollback();
+        }
+      };
+      const stopClosedSetup = (): boolean => {
+        if (!state.closed && !state.transferred && !state.transferring && active) return false;
+        setupInProgress = false;
+        rollback();
+        return true;
+      };
+      try {
+        listeners.add(dispose);
+      } catch {
+        setupInProgress = false;
+        active = false;
+        try {
+          deleteSetValue(listeners, dispose);
+        } catch {
+          // Failed bookkeeping cannot retain listener ownership.
+        } finally {
+          rollback();
+        }
+        return dispose;
+      }
+      try {
+        messageAttempted = true;
+        Reflect.apply(raw.add, raw.binding, ['message', wrappedMessage]);
+        if (stopClosedSetup()) return dispose;
+        messageErrorAttempted = true;
+        Reflect.apply(raw.add, raw.binding, ['messageerror', wrappedMessageError]);
+        if (stopClosedSetup()) return dispose;
+        if (raw.start) {
+          Reflect.apply(raw.start, raw.binding, []);
+          if (stopClosedSetup()) return dispose;
+        }
+      } catch {
+        setupInProgress = false;
+        active = false;
+        try {
+          deleteSetValue(listeners, dispose);
+        } catch {
+          // Failed bookkeeping cannot interrupt exact listener rollback.
+        } finally {
+          rollback();
+        }
+        return dispose;
+      }
+      setupInProgress = false;
+      return dispose;
+    },
+    close: (): void => {
+      if (state.closed || state.transferred || state.transferring) return;
+      state.closed = true;
+      let disposers: readonly (() => void)[] = [];
+      try {
+        disposers = snapshotSetValues(listeners);
+      } catch {
+        // The captured native iterator should be total for the private native Set.
+      }
+      for (let index = 0; index < disposers.length; index += 1) {
+        try {
+          disposers[index]?.();
+        } catch {
+          // One listener cleanup cannot skip the remaining listeners or raw close.
+        }
+      }
+      try {
+        Reflect.apply(raw.closePort, raw.binding, []);
+      } catch {
+        // Closing remains best-effort and idempotent.
+      }
+    },
+  });
+  setWrappedPortState(port, state);
+  return port;
+}
+
+function snapshotPortArray(candidate: unknown):
+  | {
+      readonly exactShape: boolean;
+      readonly originalCount: number;
+      readonly valid: boolean;
+      readonly values: readonly unknown[];
+    }
+  | undefined {
+  try {
+    if (!Array.isArray(candidate) || Object.getPrototypeOf(candidate) !== Array.prototype) {
+      return undefined;
+    }
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(candidate, 'length');
+    if (
+      !lengthDescriptor ||
+      !Object.prototype.hasOwnProperty.call(lengthDescriptor, 'value') ||
+      typeof lengthDescriptor.value !== 'number' ||
+      !Number.isSafeInteger(lengthDescriptor.value) ||
+      lengthDescriptor.value < 0
+    ) {
+      return undefined;
+    }
+    const length = lengthDescriptor.value;
+    const ownKeys = Reflect.ownKeys(candidate);
+    const values: unknown[] = [];
+    let exactShape = ownKeys.length === length + 1;
+    let valid = length <= 2 && exactShape;
+    if (length <= 2) {
+      for (let keyIndex = 0; keyIndex < ownKeys.length; keyIndex += 1) {
+        const key = ownKeys[keyIndex];
+        if (key === 'length') continue;
+        let expected = false;
+        for (let valueIndex = 0; valueIndex < length; valueIndex += 1) {
+          if (key === String(valueIndex)) {
+            expected = true;
+            break;
+          }
+        }
+        if (!expected) {
+          exactShape = false;
+          valid = false;
+        }
+      }
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+        if (!descriptor || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+          exactShape = false;
+          valid = false;
+          continue;
+        }
+        values[values.length] = descriptor.value;
+      }
+    } else {
+      for (let keyIndex = 0; keyIndex < ownKeys.length; keyIndex += 1) {
+        const key = ownKeys[keyIndex];
+        if (key === 'length') continue;
+        if (typeof key !== 'string') {
+          exactShape = false;
+          continue;
+        }
+        const index = Number(key);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= length || String(index) !== key) {
+          exactShape = false;
+          continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+        if (descriptor && Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+          values[values.length] = descriptor.value;
+        } else {
+          exactShape = false;
+        }
+      }
+    }
+    return { exactShape, originalCount: length, valid, values };
+  } catch {
+    return undefined;
+  }
+}
+
+function reserveTransferPorts(transferred: readonly unknown[]): TransferReservation | undefined {
+  const snapshot = snapshotPortArray(transferred);
+  if (!snapshot?.valid) return undefined;
+  const states: WrappedPortState[] = [];
+  const rawTransfers: object[] = [];
+  for (let index = 0; index < snapshot.values.length; index += 1) {
+    const port = snapshot.values[index];
+    const state = getWrappedPortState(port as MessagingPort);
+    if (!state || !state.transferable || state.closed || state.transferred || state.transferring) {
+      return undefined;
+    }
+    for (let prior = 0; prior < states.length; prior += 1) {
+      if (states[prior] === state) return undefined;
+    }
+    states[index] = state;
+    rawTransfers[index] = state.raw.binding;
+  }
+  for (let index = 0; index < states.length; index += 1) {
+    const state = states[index];
+    if (state) state.transferring = true;
+  }
+  return { rawTransfers, states };
+}
+
+function rollbackTransferReservation(reservation: TransferReservation): void {
+  for (let index = 0; index < reservation.states.length; index += 1) {
+    const state = reservation.states[index];
+    if (state) state.transferring = false;
+  }
+}
+
+function commitTransferReservation(reservation: TransferReservation): void {
+  for (let index = 0; index < reservation.states.length; index += 1) {
+    const state = reservation.states[index];
+    if (!state) continue;
+    state.transferring = false;
+    state.transferred = true;
+  }
+}
+
+function extractTransferredPortsInRange(
+  event: unknown,
+  minimumCount: 0 | 1 | 2,
+  maximumCount: 0 | 1 | 2
+): readonly MessagingPort[] | undefined {
+  let candidates: unknown;
+  try {
+    if (typeof event !== 'object' || event === null) return undefined;
+    candidates = Reflect.get(event, 'ports');
+  } catch {
+    return undefined;
+  }
+  const snapshot = snapshotPortArray(candidates);
+  if (!snapshot) return undefined;
+  const inspections: Array<RawPortInspection | undefined> = [];
+  const claimed: boolean[] = [];
+  let accepted =
+    snapshot.valid &&
+    snapshot.values.length >= minimumCount &&
+    snapshot.values.length <= maximumCount;
+  for (let index = 0; index < snapshot.values.length; index += 1) {
+    const candidate = snapshot.values[index];
+    const candidateClaimed = claimPortCandidate(candidate);
+    claimed[index] = candidateClaimed;
+    if (!candidateClaimed) {
+      accepted = false;
+      continue;
+    }
+    const inspection = inspectRawPort(candidate);
+    inspections[index] = inspection;
+    if (!inspection.raw) accepted = false;
+  }
+  if (!accepted) {
+    for (let index = 0; index < snapshot.values.length; index += 1) {
+      if (!claimed[index]) continue;
+      const captured = inspections[index]?.close;
+      if (captured) closeCapturedRawPort(captured);
+      else closeRawPort(snapshot.values[index]);
+    }
+    return undefined;
+  }
+  const wrapped: MessagingPort[] = [];
+  try {
+    for (let index = 0; index < inspections.length; index += 1) {
+      const raw = inspections[index]?.raw;
+      if (!raw) throw new Error('Accepted raw port inspection is unavailable');
+      wrapped[index] = wrapPort(raw);
+    }
+    return Object.freeze(wrapped);
+  } catch {
+    for (let index = 0; index < inspections.length; index += 1) {
+      const captured = inspections[index]?.close;
+      if (claimed[index] && captured) closeCapturedRawPort(captured);
+    }
+    return undefined;
+  }
+}
+
+function extractTransferredPorts(
+  event: unknown,
+  expectedCount: 0 | 1 | 2
+): readonly MessagingPort[] | undefined {
+  return extractTransferredPortsInRange(event, expectedCount, expectedCount);
+}
+
+function inspectTransferredPorts(event: unknown):
+  | Readonly<{
+      exactShape: boolean;
+      originalCount: number;
+      ports: readonly MessagingPort[];
+    }>
+  | undefined {
+  let candidates: unknown;
+  try {
+    if (typeof event !== 'object' || event === null) return undefined;
+    candidates = Reflect.get(event, 'ports');
+  } catch {
+    return undefined;
+  }
+  const snapshot = snapshotPortArray(candidates);
+  if (!snapshot) return undefined;
+  const wrapped: MessagingPort[] = [];
+  try {
+    for (let index = 0; index < snapshot.values.length; index += 1) {
+      const candidate = snapshot.values[index];
+      if (!claimPortCandidate(candidate)) continue;
+      const inspection = inspectRawPort(candidate);
+      if (!inspection.raw) {
+        if (inspection.close) closeCapturedRawPort(inspection.close);
+        else closeRawPort(candidate);
+        continue;
+      }
+      wrapped[wrapped.length] = wrapPort(inspection.raw);
+    }
+    return Object.freeze({
+      exactShape: snapshot.exactShape,
+      originalCount: snapshot.originalCount,
+      ports: Object.freeze(wrapped),
+    });
+  } catch {
+    for (let index = 0; index < wrapped.length; index += 1) wrapped[index]?.close();
+    return undefined;
+  }
+}
+
+function createChannel(target: MessageEventTarget): MessagingChannel | undefined {
+  let first: unknown;
+  let second: unknown;
+  let retainedInspection: RawPortInspection | undefined;
+  let transferredInspection: RawPortInspection | undefined;
+  let claimedRetained = false;
+  let claimedTransferred = false;
+  const cleanup = (): void => {
+    if (claimedRetained) {
+      const captured = retainedInspection?.close;
+      if (captured) closeCapturedRawPort(captured);
+      else closeRawPort(first);
+    }
+    if (claimedTransferred) {
+      const captured = transferredInspection?.close;
+      if (captured) closeCapturedRawPort(captured);
+      else closeRawPort(second);
+    }
+  };
+  try {
+    const constructor = Reflect.get(target, 'MessageChannel');
+    if (typeof constructor !== 'function') return undefined;
+    const channel = Reflect.construct(constructor, [] as never[]) as object;
+    first = Reflect.get(channel, 'port1');
+    claimedRetained = claimPortCandidate(first);
+    if (claimedRetained) retainedInspection = inspectRawPort(first);
+    second = Reflect.get(channel, 'port2');
+    if (second !== first) claimedTransferred = claimPortCandidate(second);
+    if (claimedTransferred) transferredInspection = inspectRawPort(second);
+    if (first === second) {
+      if (claimedRetained) {
+        cleanup();
+      }
+      return undefined;
+    }
+    const retainedRaw = retainedInspection?.raw;
+    const transferredRaw = transferredInspection?.raw;
+    if (!claimedRetained || !claimedTransferred || !retainedRaw || !transferredRaw) {
+      cleanup();
+      return undefined;
+    }
+    return Object.freeze({
+      retained: wrapPort(retainedRaw),
+      transferred: wrapPort(transferredRaw, true),
+    });
+  } catch {
+    cleanup();
+    return undefined;
+  }
+}
+
+function postWindow(
+  target: unknown,
+  message: unknown,
+  targetOrigin: string,
+  transferred: readonly MessagingPort[]
+): boolean {
+  let postMessage: unknown;
+  try {
+    if (
+      ((typeof target !== 'object' || target === null) && typeof target !== 'function') ||
+      typeof targetOrigin !== 'string' ||
+      targetOrigin.length === 0 ||
+      targetOrigin.length > 2_048
+    ) {
+      return false;
+    }
+    postMessage = Reflect.get(target, 'postMessage');
+    if (typeof postMessage !== 'function') return false;
+  } catch {
+    return false;
+  }
+  const reservation = reserveTransferPorts(transferred);
+  if (!reservation) return false;
+  try {
+    Reflect.apply(postMessage, target, [message, targetOrigin, reservation.rawTransfers]);
+  } catch {
+    rollbackTransferReservation(reservation);
+    return false;
+  }
+  commitTransferReservation(reservation);
+  return true;
+}
+
+/**
+ * Create the production messaging boundary.
+ *
+ * Listener installation is deliberately synchronous so core can reserve a
+ * capability message before any integration activation or TS-owned injection.
+ */
+export function createBrowserMessagingAdapter(
+  target: MessageEventTarget = window as unknown as MessageEventTarget,
+  validation: MessagingValidationOptions = {}
+): MessagingAdapter {
+  return Object.freeze({
+    createChannel: () => createChannel(target),
+    postWindow,
+    installCaptureListener(listener: CaptureMessageListener): (() => void) | undefined {
+      let add: unknown;
+      let remove: unknown;
+      try {
+        add = Reflect.get(target, 'addEventListener');
+        remove = Reflect.get(target, 'removeEventListener');
+      } catch {
+        return undefined;
+      }
+      if (typeof add !== 'function' || typeof remove !== 'function') return undefined;
+      const wrapped: CaptureMessageListener = (event): void => {
+        try {
+          listener(event);
+        } catch {
+          // Capture listener failures cannot escape the global dispatcher boundary.
+        }
+      };
+      let attempted = false;
+      const rollback = (): void => {
+        if (!attempted) return;
+        attempted = false;
+        try {
+          Reflect.apply(remove, target, ['message', wrapped, true]);
+        } catch {
+          // Capture listener cleanup remains best-effort.
+        }
+      };
+      try {
+        attempted = true;
+        Reflect.apply(add, target, ['message', wrapped, true]);
+      } catch {
+        rollback();
+        return undefined;
+      }
+      return () => {
+        rollback();
+      };
+    },
+    inspectGlobalMessage,
+    parseProtocolMessage: (kind: ProtocolMessageKind, candidate: unknown) =>
+      parseProtocolMessage(kind, candidate, validation),
+    extractTransferredPorts,
+    inspectTransferredPorts,
+  });
+}
+
+/** Create a side-effect-free messaging boundary for tests and non-DOM runtimes. */
+export function createNoopMessagingAdapter(): MessagingAdapter {
+  return Object.freeze({
+    createChannel: () => undefined,
+    postWindow: () => false,
+    installCaptureListener: () => undefined,
+    inspectGlobalMessage,
+    parseProtocolMessage: (kind: ProtocolMessageKind, candidate: unknown) =>
+      parseProtocolMessage(kind, candidate, {}),
+    extractTransferredPorts,
+    inspectTransferredPorts,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/adapters/prebid.ts b/crates/trusted-server-js/lib/src/adapters/prebid.ts
new file mode 100644
index 000000000..99bca22fd
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/adapters/prebid.ts
@@ -0,0 +1,1687 @@
+const ARTIFACT_PROPERTY = '__trustedServerArtifactV1';
+const EXTERNAL_READY_TIMEOUT_MS = 10_000;
+const MAX_PENDING_OPERATIONS = 64;
+const MAX_NAME_BYTES = 128;
+const MAX_EID_SOURCE_BYTES = 256;
+const setDeleteIntrinsic = Set.prototype.delete;
+const weakSetDeleteIntrinsic = WeakSet.prototype.delete;
+
+function deleteSetValue<T>(set: Set<T>, value: T): boolean {
+  return Reflect.apply(setDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function deleteWeakSetValue<T extends object>(set: WeakSet<T>, value: T): boolean {
+  return Reflect.apply(weakSetDeleteIntrinsic, set, [value]) as boolean;
+}
+
+/** The live state of the publisher-owned `window.pbjs` binding. */
+export type PrebidBindingStatus = 'present' | 'pending' | 'incompatible';
+
+/** The readiness state owned by one Prebid operation. */
+export type PrebidOperationStatus = PrebidBindingStatus | 'timed_out';
+
+/** Failure codes produced at the Prebid adapter boundary. */
+export type PrebidAdapterErrorCode =
+  | 'caller_aborted'
+  | 'external_artifact_incompatible'
+  | 'external_queue_full'
+  | 'external_ready_timeout'
+  | 'operation_disposed';
+
+/** A typed failure contained by the Prebid adapter. */
+export class PrebidAdapterError extends Error {
+  public readonly code: PrebidAdapterErrorCode;
+
+  public constructor(code: PrebidAdapterErrorCode) {
+    super(code);
+    this.name = 'PrebidAdapterError';
+    this.code = code;
+  }
+}
+
+/** A version-pinned response callback exposed some, but not all, bid state. */
+export class PrebidAdmissionContractError extends Error {
+  public readonly code = 'prebid_partial_publication';
+  public readonly cause: unknown;
+
+  public constructor(cause?: unknown) {
+    super('prebid_partial_publication');
+    this.name = 'PrebidAdmissionContractError';
+    this.cause = cause;
+  }
+}
+
+/** Exact capability-free TS bid accepted by the version-pinned adapter boundary. */
+export interface PreparedTrustedBidV1 {
+  readonly auctionId: string;
+  readonly adUnitCode: string;
+  readonly bid: Readonly<{
+    readonly requestId: string;
+    readonly adId: string;
+    readonly cpm: number;
+    readonly width: number;
+    readonly height: number;
+    readonly ad: '';
+    readonly ttl: 300;
+    readonly creativeId: string;
+    readonly netRevenue: true;
+    readonly currency: 'USD';
+    readonly bidderCode: 'trustedServer';
+    readonly meta: Readonly<{
+      readonly advertiserDomains: readonly string[];
+      readonly tsAuctionId: string;
+      readonly tsBidId: string;
+      readonly tsAdmHash?: string;
+    }>;
+  }>;
+}
+
+export type PrebidTrustedBidAdmissionResult = 'admitted' | 'not_admitted';
+
+/** One exact bidder request owned by a captured Prebid auction callback. */
+export interface PrebidTrustedServerBidRequestV1 {
+  readonly adUnitCode: string;
+  readonly requestId: string;
+}
+
+/** Private request delivered by the custom TS bidder adapter. */
+export interface PrebidTrustedServerAuctionV1 {
+  readonly auctionId: string;
+  readonly bids: readonly PrebidTrustedServerBidRequestV1[];
+  complete(): void;
+}
+
+/** The exact recursively frozen external Prebid artifact stamp. */
+export interface ExternalPrebidArtifactV1 {
+  readonly abi: 1;
+  readonly artifactReleaseId: string;
+  readonly prebidVersion: '10.26.0';
+  readonly moduleStems: readonly string[];
+  readonly bidderCodes: readonly string[];
+  readonly bidderAliases: readonly Readonly<{ code: string; moduleStem: string }>[];
+  readonly userIdModules: readonly Readonly<{
+    moduleName: string;
+    configNames: readonly string[];
+    eidSources: readonly string[];
+  }>[];
+}
+
+/** Required configured behavior that the artifact stamp must cover. */
+export interface PrebidArtifactRequirements {
+  readonly configuredClientSideBidders?: readonly string[];
+  readonly requiredUserIdModules?: readonly Readonly<{
+    moduleName: string;
+    configNames?: readonly string[];
+    eidSources?: readonly string[];
+  }>[];
+}
+
+/** Read-only Prebid queries valid only while one subscribed event callback is active. */
+export interface PrebidEventFacade {
+  highestBids(adUnitCode?: string): readonly object[];
+}
+
+/** The small Prebid surface exposed to an accepted operation. */
+export interface PrebidFacade {
+  addAdUnits(adUnits: readonly unknown[]): unknown;
+  highestBids(adUnitCode?: string): readonly object[];
+  processQueue(): unknown;
+  registerBidAdapter(adapter: unknown, bidderCode: string, spec?: object): unknown;
+  registerTrustedServerBidder(
+    listener: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void
+  ): () => void;
+  renderAd(targetDocument: object, adId: string): unknown;
+  requestBids(options: object): unknown;
+  setTargetingForGpt(adUnitCodes: readonly string[]): unknown;
+  subscribe(
+    eventType: string,
+    listener: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void
+  ): () => void;
+}
+
+/** Options owned by one Prebid operation. */
+export interface PrebidOperationOptions {
+  readonly signal?: AbortSignal;
+}
+
+/** A disposable Prebid operation and its readiness-scoped result. */
+export interface PrebidOperation<T> {
+  readonly status: PrebidOperationStatus;
+  readonly result: Promise<T>;
+  dispose(): void;
+}
+
+/** Narrow Prebid boundary consumed by kernel sessions and services. */
+export interface PrebidAdapter {
+  bindingStatus(): PrebidBindingStatus;
+  admitTrustedBid(preparedBid: Readonly<PreparedTrustedBidV1>): PrebidTrustedBidAdmissionResult;
+  run<T>(
+    command: (prebid: Readonly<PrebidFacade>) => T,
+    options?: PrebidOperationOptions
+  ): PrebidOperation<T>;
+  notifyReady(): void;
+  dispose(): void;
+}
+
+/** Browser surface owned by the concrete Prebid adapter. */
+export interface PrebidGlobalTarget {
+  pbjs?: unknown;
+}
+
+interface CommandQueue {
+  push(command: () => void): unknown;
+}
+
+interface PresentPrebid {
+  readonly binding: object;
+  readonly commandQueue: CommandQueue;
+  readonly stamp: ExternalPrebidArtifactV1;
+}
+
+interface ProvisionalEffect {
+  promote(): void;
+  release(): void;
+}
+
+interface AbortRegistration {
+  readonly binding: object;
+  readonly listener: () => void;
+  readonly remove: (...arguments_: unknown[]) => unknown;
+  attempted: boolean;
+  cleanupRequested: boolean;
+  installing: boolean;
+}
+
+interface PendingOperation<T> {
+  state: PrebidOperationStatus;
+  settled: boolean;
+  pendingReservation: boolean;
+  timeout: ReturnType<typeof setTimeout> | undefined;
+  readonly command: (prebid: Readonly<PrebidFacade>) => T;
+  readonly resolve: (value: T | PromiseLike<T>) => void;
+  readonly reject: (reason: unknown) => void;
+  abortRegistration: AbortRegistration | undefined;
+  readinessBinding: object | undefined;
+  readonly provisionalEffects: ProvisionalEffect[];
+}
+
+interface ActiveTrustedServerAdmission {
+  readonly addBidResponse: (...arguments_: unknown[]) => unknown;
+  readonly binding: PresentPrebid;
+  readonly requests: readonly CapturedTrustedServerBidRequest[];
+  readonly admittedIds: Set<string>;
+  readonly admittedRequests: Set<string>;
+  readonly attemptedRequests: Set<string>;
+  readonly registration: object;
+  readonly violatedRequests: Set<string>;
+  complete(): void;
+}
+
+interface CapturedTrustedServerBidRequest extends PrebidTrustedServerBidRequestV1 {
+  readonly adUnitId: string;
+  readonly transactionId: string;
+}
+
+const encoder = new TextEncoder();
+
+function validUnicodeScalars(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!Number.isInteger(next) || next < 0xdc00 || next > 0xdfff) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function safeMember(binding: object, key: PropertyKey): unknown {
+  try {
+    return Reflect.get(binding, key);
+  } catch {
+    return undefined;
+  }
+}
+
+function safeOwnDescriptor(binding: object, key: PropertyKey): PropertyDescriptor | undefined {
+  try {
+    return Object.getOwnPropertyDescriptor(binding, key);
+  } catch {
+    return undefined;
+  }
+}
+
+function frozenRecordValues(
+  value: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  if (typeof value !== 'object' || value === null) {
+    return undefined;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && Object.getPrototypeOf(prototype) !== null) return undefined;
+  if (!Object.isFrozen(value)) return undefined;
+  let ownKeys: PropertyKey[];
+  let descriptors: Record<PropertyKey, PropertyDescriptor>;
+  try {
+    ownKeys = Reflect.ownKeys(value);
+    descriptors = Object.getOwnPropertyDescriptors(value);
+  } catch {
+    return undefined;
+  }
+  if (ownKeys.length !== keys.length || ownKeys.some((key) => typeof key !== 'string')) {
+    return undefined;
+  }
+  if (keys.some((key) => !ownKeys.includes(key))) return undefined;
+  const values: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = descriptors[key];
+    if (
+      descriptor === undefined ||
+      !Object.prototype.hasOwnProperty.call(descriptor, 'value') ||
+      descriptor.enumerable !== true ||
+      descriptor.writable !== false ||
+      descriptor.configurable !== false
+    ) {
+      return undefined;
+    }
+    values[key] = descriptor.value;
+  }
+  return values;
+}
+
+function validString(value: unknown, maximumBytes: number, lowercase = false): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length > 0 &&
+    validUnicodeScalars(value) &&
+    encoder.encode(value).byteLength <= maximumBytes &&
+    (!lowercase || value === value.toLowerCase())
+  );
+}
+
+function frozenArrayValues(value: unknown, maximumLength: number): readonly unknown[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  if (!Object.isFrozen(value)) return undefined;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+  if (
+    !lengthDescriptor ||
+    !Object.prototype.hasOwnProperty.call(lengthDescriptor, 'value') ||
+    typeof lengthDescriptor.value !== 'number' ||
+    lengthDescriptor.value > maximumLength ||
+    lengthDescriptor.enumerable !== false ||
+    lengthDescriptor.writable !== false ||
+    lengthDescriptor.configurable !== false
+  ) {
+    return undefined;
+  }
+  const length = lengthDescriptor.value;
+  const ownKeys = Reflect.ownKeys(value);
+  if (ownKeys.length !== length + 1 || ownKeys.some((key) => typeof key !== 'string')) {
+    return undefined;
+  }
+  const values: unknown[] = [];
+  for (let index = 0; index < length; index += 1) {
+    const descriptor = descriptors[String(index)];
+    if (
+      !descriptor ||
+      !Object.prototype.hasOwnProperty.call(descriptor, 'value') ||
+      descriptor.enumerable !== true ||
+      descriptor.writable !== false ||
+      descriptor.configurable !== false
+    ) {
+      return undefined;
+    }
+    values.push(descriptor.value);
+  }
+  return values;
+}
+
+function frozenSortedStrings(
+  value: unknown,
+  maximumLength: number,
+  maximumBytes: number,
+  lowercase = false
+): value is readonly string[] {
+  const values = frozenArrayValues(value, maximumLength);
+  if (!values) return false;
+  let previous: string | undefined;
+  for (const entry of values) {
+    if (!validString(entry, maximumBytes, lowercase)) return false;
+    if (previous !== undefined && previous >= entry) return false;
+    previous = entry;
+  }
+  return true;
+}
+
+/**
+ * Validate the exact supported artifact version without embedding Prebid's core
+ * marker in the TS-owned shim. The external artifact remains the sole artifact
+ * that carries the human-readable Prebid version string.
+ */
+function isExpectedPrebidVersion(
+  value: unknown
+): value is ExternalPrebidArtifactV1['prebidVersion'] {
+  return (
+    typeof value === 'string' &&
+    value.length === 7 &&
+    value.charCodeAt(0) === 49 &&
+    value.charCodeAt(1) === 48 &&
+    value.charCodeAt(2) === 46 &&
+    value.charCodeAt(3) === 50 &&
+    value.charCodeAt(4) === 54 &&
+    value.charCodeAt(5) === 46 &&
+    value.charCodeAt(6) === 48
+  );
+}
+
+function validateStamp(
+  candidate: unknown,
+  requirements: PrebidArtifactRequirements
+): candidate is ExternalPrebidArtifactV1 {
+  try {
+    const stamp = frozenRecordValues(candidate, [
+      'abi',
+      'artifactReleaseId',
+      'prebidVersion',
+      'moduleStems',
+      'bidderCodes',
+      'bidderAliases',
+      'userIdModules',
+    ]);
+    if (!stamp) return false;
+    if (
+      stamp.abi !== 1 ||
+      !isExpectedPrebidVersion(stamp.prebidVersion) ||
+      typeof stamp.artifactReleaseId !== 'string' ||
+      !/^[0-9a-f]{64}$/.test(stamp.artifactReleaseId) ||
+      !frozenSortedStrings(stamp.moduleStems, 256, MAX_NAME_BYTES) ||
+      !frozenSortedStrings(stamp.bidderCodes, 512, MAX_NAME_BYTES)
+    ) {
+      return false;
+    }
+    const moduleStems = frozenArrayValues(stamp.moduleStems, 256) as readonly string[];
+    const bidderCodes = frozenArrayValues(stamp.bidderCodes, 512) as readonly string[];
+    const bidderAliases = frozenArrayValues(stamp.bidderAliases, 512);
+    const userIdModules = frozenArrayValues(stamp.userIdModules, 128);
+    if (!bidderAliases || !userIdModules) return false;
+
+    let previousAlias = '';
+    for (const aliasCandidate of bidderAliases) {
+      const alias = frozenRecordValues(aliasCandidate, ['code', 'moduleStem']);
+      if (!alias) return false;
+      if (
+        !validString(alias.code, MAX_NAME_BYTES) ||
+        !validString(alias.moduleStem, MAX_NAME_BYTES)
+      ) {
+        return false;
+      }
+      const identity = `${alias.code}\u0000${alias.moduleStem}`;
+      if (previousAlias !== '' && previousAlias >= identity) return false;
+      previousAlias = identity;
+      if (!bidderCodes.includes(alias.code) || !moduleStems.includes(alias.moduleStem)) {
+        return false;
+      }
+    }
+
+    let previousModule = '';
+    const admittedUserIdModules: Array<{
+      moduleName: string;
+      configNames: readonly string[];
+      eidSources: readonly string[];
+    }> = [];
+    for (const moduleCandidate of userIdModules) {
+      const userIdModule = frozenRecordValues(moduleCandidate, [
+        'moduleName',
+        'configNames',
+        'eidSources',
+      ]);
+      if (!userIdModule) return false;
+      if (
+        !validString(userIdModule.moduleName, MAX_NAME_BYTES) ||
+        (previousModule !== '' && previousModule >= userIdModule.moduleName) ||
+        !moduleStems.includes(userIdModule.moduleName) ||
+        !frozenSortedStrings(userIdModule.configNames, 64, MAX_NAME_BYTES) ||
+        !frozenSortedStrings(userIdModule.eidSources, 64, MAX_EID_SOURCE_BYTES, true)
+      ) {
+        return false;
+      }
+      previousModule = userIdModule.moduleName;
+      admittedUserIdModules.push({
+        moduleName: userIdModule.moduleName,
+        configNames: frozenArrayValues(userIdModule.configNames, 64) as readonly string[],
+        eidSources: frozenArrayValues(userIdModule.eidSources, 64) as readonly string[],
+      });
+    }
+
+    for (const bidder of requirements.configuredClientSideBidders ?? []) {
+      if (!bidderCodes.includes(bidder)) return false;
+    }
+    for (const required of requirements.requiredUserIdModules ?? []) {
+      const included = admittedUserIdModules.find(
+        (module) => module.moduleName === required.moduleName
+      );
+      if (
+        !included ||
+        (required.configNames ?? []).some((name) => !included.configNames.includes(name)) ||
+        (required.eidSources ?? []).some((source) => !included.eidSources.includes(source))
+      ) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function validatePreparedBid(candidate: unknown): Readonly<PreparedTrustedBidV1> | undefined {
+  try {
+    const prepared = frozenRecordValues(candidate, ['auctionId', 'adUnitCode', 'bid']);
+    if (
+      !prepared ||
+      !validString(prepared.auctionId, 128) ||
+      !validString(prepared.adUnitCode, 256)
+    ) {
+      return undefined;
+    }
+    const bid = frozenRecordValues(prepared.bid, [
+      'requestId',
+      'adId',
+      'cpm',
+      'width',
+      'height',
+      'ad',
+      'ttl',
+      'creativeId',
+      'netRevenue',
+      'currency',
+      'bidderCode',
+      'meta',
+    ]);
+    if (
+      !bid ||
+      !validString(bid.requestId, 128) ||
+      typeof bid.adId !== 'string' ||
+      !/^r1_[A-Za-z0-9_-]{22}$/u.test(bid.adId) ||
+      typeof bid.cpm !== 'number' ||
+      !Number.isFinite(bid.cpm) ||
+      bid.cpm < 0 ||
+      typeof bid.width !== 'number' ||
+      !Number.isInteger(bid.width) ||
+      bid.width < 1 ||
+      bid.width > 4096 ||
+      typeof bid.height !== 'number' ||
+      !Number.isInteger(bid.height) ||
+      bid.height < 1 ||
+      bid.height > 4096 ||
+      bid.ad !== '' ||
+      bid.ttl !== 300 ||
+      !validString(bid.creativeId, 256) ||
+      bid.netRevenue !== true ||
+      bid.currency !== 'USD' ||
+      !validString(bid.bidderCode, MAX_NAME_BYTES)
+    ) {
+      return undefined;
+    }
+    const metaKeys = Object.prototype.hasOwnProperty.call(bid.meta, 'tsAdmHash')
+      ? ['advertiserDomains', 'tsAuctionId', 'tsBidId', 'tsAdmHash']
+      : ['advertiserDomains', 'tsAuctionId', 'tsBidId'];
+    const meta = frozenRecordValues(bid.meta, metaKeys);
+    const advertiserDomains = meta && frozenArrayValues(meta.advertiserDomains, 16);
+    if (
+      !meta ||
+      !advertiserDomains ||
+      advertiserDomains.some((domain) => !validString(domain, 256)) ||
+      meta.tsAuctionId !== prepared.auctionId ||
+      !validString(meta.tsBidId, 256) ||
+      (meta.tsAdmHash !== undefined && !validString(meta.tsAdmHash, 128))
+    ) {
+      return undefined;
+    }
+    return candidate as Readonly<PreparedTrustedBidV1>;
+  } catch {
+    return undefined;
+  }
+}
+
+const REQUIRED_API_METHODS = [
+  'addAdUnits',
+  'getBidResponsesForAdUnitCode',
+  'getHighestCpmBids',
+  'offEvent',
+  'onEvent',
+  'processQueue',
+  'registerBidAdapter',
+  'renderAd',
+  'requestBids',
+  'setTargetingForGPTAsync',
+] as const;
+
+function commandQueue(binding: object): CommandQueue | undefined {
+  const candidate = safeMember(binding, 'que');
+  if ((typeof candidate !== 'object' || candidate === null) && typeof candidate !== 'function') {
+    return undefined;
+  }
+  return typeof safeMember(candidate, 'push') === 'function'
+    ? (candidate as CommandQueue)
+    : undefined;
+}
+
+function inspectBinding(
+  value: unknown,
+  requirements: PrebidArtifactRequirements
+):
+  | { readonly status: 'pending'; readonly binding?: object; readonly commandQueue?: CommandQueue }
+  | { readonly status: 'incompatible'; readonly binding?: object }
+  | { readonly status: 'present'; readonly value: PresentPrebid } {
+  if (value === undefined || value === null) return { status: 'pending' };
+  if (typeof value !== 'object' && typeof value !== 'function') {
+    return { status: 'incompatible' };
+  }
+  const binding = value as object;
+  const queue = commandQueue(binding);
+  if (!queue) return { status: 'incompatible', binding };
+  const descriptor = safeOwnDescriptor(binding, ARTIFACT_PROPERTY);
+  if (!descriptor) {
+    const hasRealApi = REQUIRED_API_METHODS.some(
+      (method) => safeMember(binding, method) !== undefined
+    );
+    return hasRealApi
+      ? { status: 'incompatible', binding }
+      : { status: 'pending', binding, commandQueue: queue };
+  }
+  if (
+    !Object.prototype.hasOwnProperty.call(descriptor, 'value') ||
+    descriptor.enumerable !== false ||
+    descriptor.writable !== false ||
+    descriptor.configurable !== false ||
+    !validateStamp(descriptor.value, requirements) ||
+    REQUIRED_API_METHODS.some((method) => typeof safeMember(binding, method) !== 'function')
+  ) {
+    return { status: 'incompatible', binding };
+  }
+  return {
+    status: 'present',
+    value: { binding, commandQueue: queue, stamp: descriptor.value },
+  };
+}
+
+function readTarget(target: PrebidGlobalTarget): unknown {
+  try {
+    return target.pbjs;
+  } catch {
+    return false;
+  }
+}
+
+function queueCommand(queue: CommandQueue, command: () => void, guard?: () => boolean): void {
+  const push = safeMember(queue as object, 'push');
+  if (guard && !guard()) throw new PrebidAdapterError('external_artifact_incompatible');
+  if (typeof push !== 'function') throw new PrebidAdapterError('external_artifact_incompatible');
+  if (guard && !guard()) throw new PrebidAdapterError('external_artifact_incompatible');
+  Reflect.apply(push, queue, [command]);
+  if (guard && !guard()) throw new PrebidAdapterError('external_artifact_incompatible');
+}
+
+/** Create the sole production reader/writer boundary for `window.pbjs`. */
+export function createBrowserPrebidAdapter(
+  target: PrebidGlobalTarget = window as unknown as PrebidGlobalTarget,
+  requirements: PrebidArtifactRequirements = {}
+): PrebidAdapter {
+  const pending: PendingOperation<unknown>[] = [];
+  const live = new Set<PendingOperation<unknown>>();
+  const effects = new Set<() => void>();
+  const activeAdmissions = new Map<string, ActiveTrustedServerAdmission>();
+  const trustedBidderRegistrations = new Map<object, object>();
+  let armedBindings = new WeakSet<object>();
+  let diagnosedBindings = new WeakSet<object>();
+  let diagnosedUnbound = false;
+  let pendingReservations = 0;
+  let disposed = false;
+
+  const rollbackDiagnosticOwnership = (binding: object): void => {
+    let released = false;
+    try {
+      deleteWeakSetValue(diagnosedBindings, binding);
+      released = !diagnosedBindings.has(binding);
+    } catch {
+      // A poisoned registry cannot prove that the exact marker was removed.
+    }
+    if (!released) diagnosedBindings = new WeakSet<object>();
+  };
+
+  const currentBinding = (): ReturnType<typeof inspectBinding> => {
+    const inspected = inspectBinding(readTarget(target), requirements);
+    if (inspected.status === 'incompatible') {
+      let shouldDiagnose = !diagnosedUnbound;
+      if (inspected.binding) {
+        try {
+          shouldDiagnose = !diagnosedBindings.has(inspected.binding);
+        } catch {
+          shouldDiagnose = false;
+        }
+      }
+      if (shouldDiagnose) {
+        let diagnosticOwned = false;
+        if (inspected.binding) {
+          try {
+            diagnosedBindings.add(inspected.binding);
+          } catch {
+            // A stateful add may still have published diagnostic ownership.
+          }
+          try {
+            diagnosticOwned = diagnosedBindings.has(inspected.binding);
+          } catch {
+            rollbackDiagnosticOwnership(inspected.binding);
+          }
+        } else {
+          diagnosedUnbound = true;
+          diagnosticOwned = diagnosedUnbound;
+        }
+        if (diagnosticOwned) {
+          try {
+            console.warn('[tsjs-prebid] external Prebid artifact is incompatible');
+          } catch {
+            // Diagnostics cannot change readiness behavior.
+          }
+        }
+      }
+    }
+    return inspected;
+  };
+
+  const sameBinding = (expected: PresentPrebid): boolean => {
+    if (readTarget(target) !== expected.binding) return false;
+    const descriptor = safeOwnDescriptor(expected.binding, ARTIFACT_PROPERTY);
+    return (
+      descriptor !== undefined &&
+      Object.prototype.hasOwnProperty.call(descriptor, 'value') &&
+      descriptor.value === expected.stamp &&
+      descriptor.enumerable === false &&
+      descriptor.writable === false &&
+      descriptor.configurable === false
+    );
+  };
+
+  const callBound = (
+    expected: PresentPrebid,
+    key: PropertyKey,
+    argumentsList: readonly unknown[],
+    isCurrent: () => boolean
+  ): unknown => {
+    if (!isCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+    const member = safeMember(expected.binding, key);
+    if (!isCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+    if (typeof member !== 'function')
+      throw new PrebidAdapterError('external_artifact_incompatible');
+    if (!isCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+    const result = Reflect.apply(member, expected.binding, argumentsList);
+    if (!isCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+    return result;
+  };
+
+  const bidderRequestSnapshot = (
+    candidate: unknown
+  ):
+    | Readonly<{
+        auctionId: string;
+        bids: readonly PrebidTrustedServerBidRequestV1[];
+        requests: readonly CapturedTrustedServerBidRequest[];
+      }>
+    | undefined => {
+    try {
+      if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+        return undefined;
+      }
+      const auctionId = safeOwnDescriptor(candidate, 'auctionId');
+      const bidsDescriptor = safeOwnDescriptor(candidate, 'bids');
+      if (
+        !auctionId ||
+        !Object.prototype.hasOwnProperty.call(auctionId, 'value') ||
+        !validString(auctionId.value, 128) ||
+        !bidsDescriptor ||
+        !Object.prototype.hasOwnProperty.call(bidsDescriptor, 'value') ||
+        !Array.isArray(bidsDescriptor.value) ||
+        bidsDescriptor.value.length === 0 ||
+        bidsDescriptor.value.length > 256
+      ) {
+        return undefined;
+      }
+      const bids: PrebidTrustedServerBidRequestV1[] = [];
+      const requests: CapturedTrustedServerBidRequest[] = [];
+      const identities = new Set<string>();
+      for (const rawBid of bidsDescriptor.value as unknown[]) {
+        if (typeof rawBid !== 'object' || rawBid === null || Array.isArray(rawBid))
+          return undefined;
+        const adUnitCode = safeOwnDescriptor(rawBid, 'adUnitCode');
+        const adUnitId = safeOwnDescriptor(rawBid, 'adUnitId');
+        const bidAuctionId = safeOwnDescriptor(rawBid, 'auctionId');
+        const requestId = safeOwnDescriptor(rawBid, 'bidId');
+        const source = safeOwnDescriptor(rawBid, 'src');
+        const transactionId = safeOwnDescriptor(rawBid, 'transactionId');
+        if (
+          !adUnitCode ||
+          !Object.prototype.hasOwnProperty.call(adUnitCode, 'value') ||
+          !validString(adUnitCode.value, 256) ||
+          !adUnitId ||
+          !Object.prototype.hasOwnProperty.call(adUnitId, 'value') ||
+          !validString(adUnitId.value, 128) ||
+          !bidAuctionId ||
+          !Object.prototype.hasOwnProperty.call(bidAuctionId, 'value') ||
+          bidAuctionId.value !== auctionId.value ||
+          !requestId ||
+          !Object.prototype.hasOwnProperty.call(requestId, 'value') ||
+          !validString(requestId.value, 128) ||
+          !source ||
+          !Object.prototype.hasOwnProperty.call(source, 'value') ||
+          source.value !== 'client' ||
+          !transactionId ||
+          !Object.prototype.hasOwnProperty.call(transactionId, 'value') ||
+          !validString(transactionId.value, 128)
+        ) {
+          return undefined;
+        }
+        const identity = `${adUnitCode.value}\u0000${requestId.value}`;
+        if (identities.has(identity)) return undefined;
+        identities.add(identity);
+        bids.push(Object.freeze({ adUnitCode: adUnitCode.value, requestId: requestId.value }));
+        requests.push(
+          Object.freeze({
+            adUnitCode: adUnitCode.value,
+            adUnitId: adUnitId.value,
+            requestId: requestId.value,
+            transactionId: transactionId.value,
+          })
+        );
+      }
+      return Object.freeze({
+        auctionId: auctionId.value,
+        bids: Object.freeze(bids),
+        requests: Object.freeze(requests),
+      });
+    } catch {
+      return undefined;
+    }
+  };
+
+  const responseCount = (
+    binding: PresentPrebid,
+    auctionId: string,
+    adUnitCode: string,
+    adId: string,
+    requestId: string,
+    isCurrent: () => boolean
+  ): number => {
+    const response = callBound(binding, 'getBidResponsesForAdUnitCode', [adUnitCode], isCurrent);
+    if (!Array.isArray(response)) {
+      throw new PrebidAdapterError('external_artifact_incompatible');
+    }
+    const bids = safeMember(response, 'bids');
+    if (bids !== response) throw new PrebidAdapterError('external_artifact_incompatible');
+    let matches = 0;
+    for (const bid of response) {
+      if (typeof bid !== 'object' || bid === null) {
+        throw new PrebidAdapterError('external_artifact_incompatible');
+      }
+      if (
+        safeMember(bid, 'auctionId') === auctionId &&
+        safeMember(bid, 'adId') === adId &&
+        safeMember(bid, 'requestId') === requestId &&
+        safeMember(bid, 'adUnitCode') === adUnitCode
+      ) {
+        matches += 1;
+      }
+    }
+    return matches;
+  };
+
+  const admitTrustedBid = (
+    candidate: Readonly<PreparedTrustedBidV1>
+  ): PrebidTrustedBidAdmissionResult => {
+    if (disposed) throw new PrebidAdapterError('operation_disposed');
+    const prepared = validatePreparedBid(candidate);
+    if (!prepared) return 'not_admitted';
+    const context = activeAdmissions.get(prepared.auctionId);
+    if (!context) return 'not_admitted';
+    if (!sameBinding(context.binding)) {
+      throw new PrebidAdapterError('external_artifact_incompatible');
+    }
+    const requestIdentity = `${prepared.adUnitCode}\u0000${prepared.bid.requestId}`;
+    const request = context.requests.find(
+      (candidateRequest) =>
+        candidateRequest.adUnitCode === prepared.adUnitCode &&
+        candidateRequest.requestId === prepared.bid.requestId
+    );
+    if (!request) {
+      return 'not_admitted';
+    }
+    if (
+      context.admittedIds.has(prepared.bid.adId) ||
+      context.admittedRequests.has(requestIdentity) ||
+      context.violatedRequests.has(requestIdentity)
+    ) {
+      throw new PrebidAdmissionContractError();
+    }
+    if (context.attemptedRequests.has(requestIdentity)) return 'not_admitted';
+    const isCurrent = (): boolean => !disposed && sameBinding(context.binding);
+    const before = responseCount(
+      context.binding,
+      prepared.auctionId,
+      prepared.adUnitCode,
+      prepared.bid.adId,
+      prepared.bid.requestId,
+      isCurrent
+    );
+    if (before !== 0) {
+      context.violatedRequests.add(requestIdentity);
+      throw new PrebidAdmissionContractError();
+    }
+    context.attemptedRequests.add(requestIdentity);
+
+    let responseEvents = 0;
+    const responseListener = (event: unknown): void => {
+      if (
+        typeof event === 'object' &&
+        event !== null &&
+        safeMember(event, 'auctionId') === prepared.auctionId &&
+        safeMember(event, 'adId') === prepared.bid.adId &&
+        safeMember(event, 'requestId') === prepared.bid.requestId &&
+        safeMember(event, 'adUnitCode') === prepared.adUnitCode
+      ) {
+        responseEvents += 1;
+      }
+    };
+    callBound(context.binding, 'onEvent', ['bidResponse', responseListener], isCurrent);
+    let callbackFailure: unknown;
+    try {
+      const mutableBid = {
+        ...prepared.bid,
+        adUnitId: request.adUnitId,
+        auctionId: prepared.auctionId,
+        getSize: (): string => `${prepared.bid.width}x${prepared.bid.height}`,
+        mediaType: 'banner',
+        meta: {
+          ...prepared.bid.meta,
+          advertiserDomains: [...prepared.bid.meta.advertiserDomains],
+        },
+        source: 'client',
+        transactionId: request.transactionId,
+      };
+      Reflect.apply(context.addBidResponse, undefined, [prepared.adUnitCode, mutableBid]);
+    } catch (error) {
+      callbackFailure = error;
+    }
+    let cleanupFailure: unknown;
+    try {
+      callBound(context.binding, 'offEvent', ['bidResponse', responseListener], isCurrent);
+    } catch (error) {
+      cleanupFailure = error;
+    }
+    let after: number;
+    try {
+      after = responseCount(
+        context.binding,
+        prepared.auctionId,
+        prepared.adUnitCode,
+        prepared.bid.adId,
+        prepared.bid.requestId,
+        isCurrent
+      );
+    } catch (error) {
+      context.violatedRequests.add(requestIdentity);
+      throw new PrebidAdmissionContractError(error);
+    }
+    if (cleanupFailure !== undefined) {
+      context.violatedRequests.add(requestIdentity);
+      throw new PrebidAdmissionContractError(cleanupFailure);
+    }
+    if (callbackFailure !== undefined) {
+      if (responseEvents !== 0 || after !== 0) {
+        context.violatedRequests.add(requestIdentity);
+        throw new PrebidAdmissionContractError(callbackFailure);
+      }
+      throw callbackFailure;
+    }
+    if (responseEvents === 0 && after === 0) return 'not_admitted';
+    if (responseEvents !== 1 || after !== 1) {
+      context.violatedRequests.add(requestIdentity);
+      throw new PrebidAdmissionContractError();
+    }
+    context.admittedIds.add(prepared.bid.adId);
+    context.admittedRequests.add(requestIdentity);
+    return 'admitted';
+  };
+
+  const highestBids = (
+    binding: PresentPrebid,
+    adUnitCode: string | undefined,
+    isCurrent: () => boolean
+  ): readonly object[] => {
+    const value = callBound(
+      binding,
+      'getHighestCpmBids',
+      adUnitCode === undefined ? [] : [adUnitCode],
+      isCurrent
+    );
+    if (!Array.isArray(value) || value.some((bid) => typeof bid !== 'object' || bid === null)) {
+      throw new PrebidAdapterError('external_artifact_incompatible');
+    }
+    if (!isCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+    return Object.freeze([...value]);
+  };
+
+  const registerTrustedServerBidder = (
+    binding: PresentPrebid,
+    listener: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void,
+    registerOperationEffect: (disposeEffect: () => void) => () => void,
+    isOperationCurrent: () => boolean
+  ): (() => void) => {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Trusted Server bidder listener must be a function');
+    }
+    if (trustedBidderRegistrations.has(binding.binding)) {
+      throw new PrebidAdapterError('external_artifact_incompatible');
+    }
+    const registration = Object.freeze({});
+    trustedBidderRegistrations.set(binding.binding, registration);
+    let active = true;
+    const completeRegistrationAuctions = (): void => {
+      for (const context of [...activeAdmissions.values()]) {
+        if (context.registration !== registration) continue;
+        context.complete();
+      }
+    };
+    let release: () => void;
+    try {
+      release = registerOperationEffect(() => {
+        active = false;
+        if (trustedBidderRegistrations.get(binding.binding) === registration) {
+          trustedBidderRegistrations.delete(binding.binding);
+        }
+        completeRegistrationAuctions();
+      });
+    } catch (error) {
+      if (trustedBidderRegistrations.get(binding.binding) === registration) {
+        trustedBidderRegistrations.delete(binding.binding);
+      }
+      throw error;
+    }
+    const bidder = Object.freeze({
+      callBids: (rawRequest: unknown, rawAddBidResponse: unknown, rawDone: unknown): void => {
+        const done = typeof rawDone === 'function' ? rawDone : undefined;
+        let completed = false;
+        const finish = (): void => {
+          if (completed) return;
+          completed = true;
+          try {
+            Reflect.apply(done ?? (() => undefined), undefined, []);
+          } catch {
+            // Prebid completion cannot escape the registered adapter boundary.
+          }
+        };
+        const request = bidderRequestSnapshot(rawRequest);
+        if (
+          !active ||
+          !sameBinding(binding) ||
+          !request ||
+          typeof rawAddBidResponse !== 'function' ||
+          !done ||
+          activeAdmissions.has(request.auctionId)
+        ) {
+          finish();
+          return;
+        }
+        const context: ActiveTrustedServerAdmission = {
+          addBidResponse: rawAddBidResponse as (...arguments_: unknown[]) => unknown,
+          binding,
+          requests: request.requests,
+          admittedIds: new Set<string>(),
+          admittedRequests: new Set<string>(),
+          attemptedRequests: new Set<string>(),
+          registration,
+          violatedRequests: new Set<string>(),
+          complete: (): void => {
+            if (activeAdmissions.get(request.auctionId) !== context) return;
+            activeAdmissions.delete(request.auctionId);
+            finish();
+          },
+        };
+        activeAdmissions.set(request.auctionId, context);
+        const auction = Object.freeze({
+          auctionId: request.auctionId,
+          bids: request.bids,
+          complete: context.complete,
+        });
+        try {
+          listener(auction);
+        } catch {
+          context.complete();
+        }
+      },
+    });
+    const bidderFactory = (): Readonly<typeof bidder> => bidder;
+    try {
+      callBound(
+        binding,
+        'registerBidAdapter',
+        [bidderFactory, 'trustedServer'],
+        isOperationCurrent
+      );
+      return release;
+    } catch (error) {
+      release();
+      throw error;
+    }
+  };
+
+  const createFacade = (
+    binding: PresentPrebid,
+    registerOperationEffect: (disposeEffect: () => void) => () => void,
+    isOperationCurrent: () => boolean,
+    isBindingCurrent: () => boolean
+  ): Readonly<PrebidFacade> =>
+    Object.freeze({
+      addAdUnits: (adUnits: readonly unknown[]): unknown =>
+        callBound(binding, 'addAdUnits', [[...adUnits]], isOperationCurrent),
+      highestBids: (adUnitCode?: string): readonly object[] =>
+        highestBids(binding, adUnitCode, isOperationCurrent),
+      processQueue: (): unknown => callBound(binding, 'processQueue', [], isOperationCurrent),
+      registerBidAdapter: (adapter: unknown, bidderCode: string, spec?: object): unknown =>
+        callBound(
+          binding,
+          'registerBidAdapter',
+          spec === undefined ? [adapter, bidderCode] : [adapter, bidderCode, spec],
+          isOperationCurrent
+        ),
+      registerTrustedServerBidder: (
+        listener: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void
+      ): (() => void) =>
+        registerTrustedServerBidder(binding, listener, registerOperationEffect, isOperationCurrent),
+      renderAd: (targetDocument: object, adId: string): unknown =>
+        callBound(binding, 'renderAd', [targetDocument, adId], isOperationCurrent),
+      requestBids: (options: object): unknown =>
+        callBound(binding, 'requestBids', [options], isOperationCurrent),
+      setTargetingForGpt: (adUnitCodes: readonly string[]): unknown =>
+        callBound(binding, 'setTargetingForGPTAsync', [[...adUnitCodes]], isOperationCurrent),
+      subscribe: (
+        eventType: string,
+        listener: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void
+      ): (() => void) => {
+        if (!isOperationCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+        const add = safeMember(binding.binding, 'onEvent');
+        if (!isOperationCurrent() || typeof add !== 'function')
+          throw new PrebidAdapterError('external_artifact_incompatible');
+        const remove = safeMember(binding.binding, 'offEvent');
+        if (!isOperationCurrent() || typeof remove !== 'function')
+          throw new PrebidAdapterError('external_artifact_incompatible');
+        const wrapped = (event: unknown): void => {
+          if (!isBindingCurrent()) return;
+          let callbackActive = true;
+          const isEventCurrent = (): boolean => callbackActive && isBindingCurrent();
+          const eventFacade: Readonly<PrebidEventFacade> = Object.freeze({
+            highestBids: (adUnitCode?: string): readonly object[] =>
+              highestBids(binding, adUnitCode, isEventCurrent),
+          });
+          try {
+            listener(event, eventFacade);
+          } catch {
+            // Publisher callbacks cannot escape the Prebid boundary.
+          } finally {
+            callbackActive = false;
+          }
+        };
+        let attempted = false;
+        const rollback = (): void => {
+          if (!attempted) return;
+          attempted = false;
+          try {
+            Reflect.apply(remove, binding.binding, [eventType, wrapped]);
+          } catch {
+            // Transaction rollback remains best-effort and cannot replace the original failure.
+          }
+        };
+        try {
+          if (!isOperationCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+          attempted = true;
+          Reflect.apply(add, binding.binding, [eventType, wrapped]);
+          if (!isOperationCurrent()) throw new PrebidAdapterError('external_artifact_incompatible');
+        } catch (error) {
+          rollback();
+          throw error;
+        }
+        let active = true;
+        return registerOperationEffect(() => {
+          if (!active) return;
+          active = false;
+          rollback();
+        });
+      },
+    });
+
+  const removePending = (operation: PendingOperation<unknown>): void => {
+    const index = pending.indexOf(operation);
+    if (index >= 0) pending.splice(index, 1);
+  };
+
+  const releasePendingReservation = (operation: PendingOperation<unknown>): void => {
+    if (!operation.pendingReservation) return;
+    operation.pendingReservation = false;
+    if (pendingReservations > 0) pendingReservations -= 1;
+  };
+
+  const clearReadiness = (operation: PendingOperation<unknown>): void => {
+    try {
+      if (operation.timeout !== undefined) {
+        clearTimeout(operation.timeout);
+        operation.timeout = undefined;
+      }
+      removePending(operation);
+    } finally {
+      releasePendingReservation(operation);
+    }
+  };
+
+  const detachAbort = (operation: PendingOperation<unknown>): void => {
+    const registration = operation.abortRegistration;
+    if (!registration || !registration.attempted) return;
+    if (registration.installing) {
+      registration.cleanupRequested = true;
+      return;
+    }
+    registration.attempted = false;
+    operation.abortRegistration = undefined;
+    try {
+      Reflect.apply(registration.remove, registration.binding, ['abort', registration.listener]);
+    } catch {
+      // Hostile signal cleanup cannot strand operation settlement.
+    }
+  };
+
+  const rollbackNotificationArming = (binding: object): void => {
+    let released = false;
+    try {
+      deleteWeakSetValue(armedBindings, binding);
+      released = !armedBindings.has(binding);
+    } catch {
+      // A poisoned registry cannot prove that the exact marker was removed.
+    }
+    if (!released) armedBindings = new WeakSet<object>();
+  };
+
+  const clearOperation = (operation: PendingOperation<unknown>): void => {
+    try {
+      clearReadiness(operation);
+    } finally {
+      try {
+        detachAbort(operation);
+      } finally {
+        deleteSetValue(live, operation);
+      }
+    }
+  };
+
+  const rollbackOperationEffects = (operation: PendingOperation<unknown>): void => {
+    for (let index = operation.provisionalEffects.length - 1; index >= 0; index -= 1) {
+      operation.provisionalEffects[index]?.release();
+    }
+    operation.provisionalEffects.length = 0;
+  };
+
+  const rejectOperation = (operation: PendingOperation<unknown>, error: unknown): void => {
+    if (operation.settled) return;
+    operation.settled = true;
+    if (error instanceof PrebidAdapterError && error.code === 'external_artifact_incompatible') {
+      operation.state = 'incompatible';
+    }
+    try {
+      rollbackOperationEffects(operation);
+    } finally {
+      try {
+        clearOperation(operation);
+      } finally {
+        operation.reject(error);
+      }
+    }
+  };
+
+  const fail = (operation: PendingOperation<unknown>, code: PrebidAdapterErrorCode): void => {
+    if (operation.settled) return;
+    if (code === 'external_ready_timeout') operation.state = 'timed_out';
+    if (code === 'external_artifact_incompatible') operation.state = 'incompatible';
+    rejectOperation(operation, new PrebidAdapterError(code));
+  };
+
+  const dispatch = (operation: PendingOperation<unknown>, binding: PresentPrebid): void => {
+    if (operation.settled) return;
+    if (disposed) {
+      fail(operation, 'operation_disposed');
+      return;
+    }
+    operation.state = 'present';
+    clearReadiness(operation);
+    const isDispatchCurrent = (): boolean => {
+      if (disposed || operation.settled) return false;
+      const current = sameBinding(binding);
+      return !disposed && !operation.settled && current;
+    };
+    const registerOperationEffect = (disposeEffect: () => void): (() => void) => {
+      let released = false;
+      let promoted = false;
+      const release = (): void => {
+        if (promoted) {
+          try {
+            deleteSetValue(effects, release);
+          } catch {
+            // A hostile registry cannot prevent exact external cleanup.
+          }
+        }
+        if (released) return;
+        released = true;
+        try {
+          disposeEffect();
+        } catch {
+          // One effect cleanup cannot escape the adapter boundary.
+        }
+      };
+      const promote = (): void => {
+        if (released || promoted) return;
+        promoted = true;
+        try {
+          effects.add(release);
+        } catch (error) {
+          release();
+          throw error;
+        }
+        if (!isDispatchCurrent()) {
+          release();
+          throw new PrebidAdapterError(
+            disposed ? 'operation_disposed' : 'external_artifact_incompatible'
+          );
+        }
+      };
+      const provisional = { promote, release };
+      operation.provisionalEffects[operation.provisionalEffects.length] = provisional;
+      if (!isDispatchCurrent()) {
+        release();
+        throw new PrebidAdapterError(
+          disposed ? 'operation_disposed' : 'external_artifact_incompatible'
+        );
+      }
+      return release;
+    };
+    const promoteOperationEffects = (): void => {
+      for (const provisional of operation.provisionalEffects) provisional.promote();
+      operation.provisionalEffects.length = 0;
+    };
+    const completeOperation = (value: unknown): void => {
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (!isDispatchCurrent()) {
+        fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      try {
+        promoteOperationEffects();
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation, error);
+        return;
+      }
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      if (!isDispatchCurrent()) {
+        fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      operation.settled = true;
+      try {
+        clearOperation(operation);
+      } finally {
+        operation.resolve(value);
+      }
+    };
+    const settleCommandValue = (value: unknown): void => {
+      let then: unknown;
+      try {
+        if ((typeof value === 'object' && value !== null) || typeof value === 'function') {
+          then = Reflect.get(value, 'then');
+        }
+      } catch (error) {
+        rejectOperation(operation, error);
+        return;
+      }
+      if (typeof then !== 'function') {
+        completeOperation(value);
+        return;
+      }
+      Promise.resolve(value).then(
+        (resolved) => completeOperation(resolved),
+        (error: unknown) => rejectOperation(operation, error)
+      );
+    };
+    const facade = createFacade(
+      binding,
+      registerOperationEffect,
+      isDispatchCurrent,
+      () => !disposed && sameBinding(binding)
+    );
+    try {
+      if (!isDispatchCurrent()) {
+        if (disposed) fail(operation, 'operation_disposed');
+        else fail(operation, 'external_artifact_incompatible');
+        return;
+      }
+      queueCommand(
+        binding.commandQueue,
+        () => {
+          if (operation.settled) return;
+          if (disposed) {
+            fail(operation, 'operation_disposed');
+            return;
+          }
+          if (!isDispatchCurrent()) {
+            if (disposed) fail(operation, 'operation_disposed');
+            else fail(operation, 'external_artifact_incompatible');
+            return;
+          }
+          try {
+            const value = operation.command(facade);
+            if (operation.settled) return;
+            if (disposed) {
+              fail(operation, 'operation_disposed');
+              return;
+            }
+            if (!isDispatchCurrent()) {
+              if (disposed) fail(operation, 'operation_disposed');
+              else fail(operation, 'external_artifact_incompatible');
+              return;
+            }
+            settleCommandValue(value);
+          } catch (error) {
+            if (operation.settled) return;
+            if (disposed) {
+              fail(operation, 'operation_disposed');
+              return;
+            }
+            rejectOperation(operation, error);
+          }
+        },
+        isDispatchCurrent
+      );
+      if (!operation.settled && !isDispatchCurrent()) {
+        if (disposed) fail(operation, 'operation_disposed');
+        else fail(operation, 'external_artifact_incompatible');
+      }
+    } catch (error) {
+      if (operation.settled) return;
+      if (disposed) {
+        fail(operation, 'operation_disposed');
+        return;
+      }
+      rejectOperation(operation, error);
+    }
+  };
+
+  const notifyReady = (expectedBinding?: object): void => {
+    if (disposed) return;
+    const current = currentBinding();
+    if (disposed) return;
+    if (current.status === 'present') {
+      for (const operation of [...pending]) dispatch(operation, current.value);
+      return;
+    }
+    if (current.status === 'pending') {
+      armNotification();
+      return;
+    }
+    if (expectedBinding !== undefined && current.binding !== expectedBinding) {
+      return;
+    }
+    for (const operation of [...pending]) {
+      if (
+        expectedBinding === undefined ||
+        operation.readinessBinding === undefined ||
+        operation.readinessBinding === expectedBinding
+      ) {
+        fail(operation, 'external_artifact_incompatible');
+      }
+    }
+  };
+
+  const armNotification = (): void => {
+    const current = currentBinding();
+    if (disposed) return;
+    if (current.status !== 'pending' || !current.binding || !current.commandQueue) {
+      return;
+    }
+    let alreadyArmed = false;
+    try {
+      alreadyArmed = armedBindings.has(current.binding);
+    } catch {
+      armedBindings = new WeakSet<object>();
+    }
+    if (alreadyArmed) return;
+    for (const operation of pending) operation.readinessBinding = current.binding;
+    try {
+      armedBindings.add(current.binding);
+    } catch {
+      rollbackNotificationArming(current.binding);
+      return;
+    }
+    let notificationActive = true;
+    const notify = (): void => {
+      if (!notificationActive) return;
+      notificationActive = false;
+      notifyReady(current.binding);
+    };
+    try {
+      queueCommand(current.commandQueue, notify);
+    } catch {
+      notificationActive = false;
+      rollbackNotificationArming(current.binding);
+    }
+  };
+
+  const run = <T>(
+    command: (prebid: Readonly<PrebidFacade>) => T,
+    options: PrebidOperationOptions = {}
+  ): PrebidOperation<T> => {
+    if (disposed) throw new PrebidAdapterError('operation_disposed');
+    const current = currentBinding();
+    if (disposed) throw new PrebidAdapterError('operation_disposed');
+    if (current.status === 'pending') {
+      if (pendingReservations >= MAX_PENDING_OPERATIONS) {
+        throw new PrebidAdapterError('external_queue_full');
+      }
+      pendingReservations += 1;
+    }
+
+    let resolve!: (value: T | PromiseLike<T>) => void;
+    let reject!: (reason: unknown) => void;
+    const result = new Promise<T>((resolveResult, rejectResult) => {
+      resolve = resolveResult;
+      reject = rejectResult;
+    });
+    const operation: PendingOperation<T> = {
+      state: current.status,
+      settled: false,
+      pendingReservation: current.status === 'pending',
+      timeout: undefined,
+      command,
+      resolve,
+      reject,
+      abortRegistration: undefined,
+      readinessBinding: current.status === 'pending' ? current.binding : undefined,
+      provisionalEffects: [],
+    };
+    const handle = Object.freeze({
+      get status(): PrebidOperationStatus {
+        return operation.state;
+      },
+      result,
+      dispose: (): void => fail(operation as PendingOperation<unknown>, 'operation_disposed'),
+    });
+
+    try {
+      live.add(operation as PendingOperation<unknown>);
+    } catch (error) {
+      try {
+        deleteSetValue(live, operation as PendingOperation<unknown>);
+      } catch {
+        // Publication rollback preserves the original registry failure.
+      }
+      releasePendingReservation(operation as PendingOperation<unknown>);
+      throw error;
+    }
+    if (current.status === 'pending') {
+      pending[pending.length] = operation as PendingOperation<unknown>;
+      operation.timeout = setTimeout(
+        () => fail(operation as PendingOperation<unknown>, 'external_ready_timeout'),
+        EXTERNAL_READY_TIMEOUT_MS
+      );
+    }
+
+    if (disposed) {
+      fail(operation as PendingOperation<unknown>, 'operation_disposed');
+      return handle;
+    }
+    if (operation.settled) return handle;
+
+    let signal: unknown;
+    try {
+      signal = options.signal;
+    } catch (error) {
+      rejectOperation(operation as PendingOperation<unknown>, error);
+      return handle;
+    }
+    if (operation.settled) return handle;
+    if (signal !== undefined) {
+      if ((typeof signal !== 'object' || signal === null) && typeof signal !== 'function') {
+        rejectOperation(
+          operation as PendingOperation<unknown>,
+          new TypeError('Invalid AbortSignal')
+        );
+        return handle;
+      }
+      let aborted: unknown;
+      let add: unknown;
+      let remove: unknown;
+      try {
+        aborted = Reflect.get(signal, 'aborted');
+        if (operation.settled) return handle;
+        add = Reflect.get(signal, 'addEventListener');
+        if (operation.settled) return handle;
+        remove = Reflect.get(signal, 'removeEventListener');
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      if (aborted === true) {
+        fail(operation as PendingOperation<unknown>, 'caller_aborted');
+        return handle;
+      }
+      if (typeof add !== 'function' || typeof remove !== 'function') {
+        rejectOperation(
+          operation as PendingOperation<unknown>,
+          new TypeError('Invalid AbortSignal')
+        );
+        return handle;
+      }
+      const registration: AbortRegistration = {
+        binding: signal,
+        listener: () => fail(operation as PendingOperation<unknown>, 'caller_aborted'),
+        remove: remove as (...arguments_: unknown[]) => unknown,
+        attempted: true,
+        cleanupRequested: false,
+        installing: true,
+      };
+      operation.abortRegistration = registration;
+      try {
+        Reflect.apply(add, signal, ['abort', registration.listener, { once: true }]);
+      } catch (error) {
+        registration.installing = false;
+        detachAbort(operation as PendingOperation<unknown>);
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      registration.installing = false;
+      if (registration.cleanupRequested || operation.settled || disposed) {
+        detachAbort(operation as PendingOperation<unknown>);
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      let abortedAfterRegistration: unknown;
+      try {
+        abortedAfterRegistration = Reflect.get(signal, 'aborted');
+      } catch (error) {
+        if (!operation.settled) rejectOperation(operation as PendingOperation<unknown>, error);
+        return handle;
+      }
+      if (operation.settled) return handle;
+      if (disposed) {
+        fail(operation as PendingOperation<unknown>, 'operation_disposed');
+        return handle;
+      }
+      if (abortedAfterRegistration === true) {
+        fail(operation as PendingOperation<unknown>, 'caller_aborted');
+        return handle;
+      }
+    }
+
+    if (current.status === 'incompatible') {
+      fail(operation as PendingOperation<unknown>, 'external_artifact_incompatible');
+    } else if (current.status === 'present') {
+      dispatch(operation as PendingOperation<unknown>, current.value);
+    } else {
+      armNotification();
+    }
+    return handle;
+  };
+
+  return Object.freeze({
+    admitTrustedBid,
+    bindingStatus: (): PrebidBindingStatus => currentBinding().status,
+    run,
+    notifyReady,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      for (const operation of [...live]) fail(operation, 'operation_disposed');
+      for (const disposeEffect of [...effects]) {
+        try {
+          deleteSetValue(effects, disposeEffect);
+        } catch {
+          // A hostile registry cannot interrupt cleanup of remaining effects.
+        }
+        try {
+          disposeEffect();
+        } catch {
+          // One cleanup cannot interrupt the remaining adapter disposers.
+        }
+      }
+    },
+  });
+}
+
+/** Create a side-effect-free Prebid boundary for tests and unavailable environments. */
+export function createNoopPrebidAdapter(): PrebidAdapter {
+  return createBrowserPrebidAdapter({});
+}
diff --git a/crates/trusted-server-js/lib/src/composition/browser_test.ts b/crates/trusted-server-js/lib/src/composition/browser_test.ts
new file mode 100644
index 000000000..a14697cfc
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/composition/browser_test.ts
@@ -0,0 +1,2018 @@
+import {
+  createBrowserGoogletagAdapter,
+  createNoopGoogletagAdapter,
+  type GoogletagAdapter,
+  type GoogletagDiagnosticsFact,
+  type GoogletagGlobalTarget,
+} from '../adapters/googletag';
+import {
+  createBrowserMessagingAdapter,
+  createNoopMessagingAdapter,
+  type MessageEventTarget,
+  type MessagingAdapter,
+  type MessagingValidationOptions,
+} from '../adapters/messaging';
+import {
+  createBrowserPrebidAdapter,
+  createNoopPrebidAdapter,
+  type PrebidAdapter,
+  type PrebidGlobalTarget,
+  type PrebidTrustedServerAuctionV1,
+} from '../adapters/prebid';
+import { parseTrustedServerAuctionResponseV1 } from '../core/auction';
+import { snapshotTsjsBootV1 } from '../core/contracts/boot';
+import type {
+  BootManifestV1,
+  BrowserAuctionProjectionV1,
+  BrowserAuctionSlotV1,
+  CreativeBootV1,
+  DiagnosticsBootV1,
+} from '../core/types';
+import {
+  createRenderTraceStore,
+  type RenderTraceGptFactV1,
+  type RenderTraceRuntimeOwner,
+} from '../core/trace';
+import {
+  parseBidRenderSourceV1,
+  parseBrowserAuctionProjectionV1,
+} from '../core/contracts/auction_projection';
+import { validateApsRenderer } from '../core/contracts/aps_renderer';
+import { validateRequestAdsOptions } from '../core/contracts/request_ads';
+import { log } from '../core/log';
+import {
+  AdUnitRegistrationError,
+  addAdUnitsResult,
+  prepareProgrammaticAdUnits,
+  serializeAuctionRequestBody,
+} from '../core/registry';
+import { prepareAdmIframe } from '../core/render';
+import {
+  APS_RENDERER_V2_PATH,
+  renderDirectApsAttempt,
+  renderPucApsAttempt,
+} from '../integrations/aps/render';
+import { installClickGuard } from '../integrations/creative/click';
+import { installDynamicIframeProxy } from '../integrations/creative/iframe';
+import { installDynamicImageProxy } from '../integrations/creative/image';
+import { createCreativeStartup } from '../integrations/creative/startup';
+import { createDataDomeRuntime } from '../integrations/datadome/module';
+import { createDidomiRuntime } from '../integrations/didomi/module';
+import { createGoogleTagManagerRuntime } from '../integrations/google_tag_manager/module';
+import {
+  publishGptWinner,
+  startGptSlotOperation,
+  type GptSlotOperationInput,
+  type GptWinnerPublicationInput,
+  type GptWinnerPublicationResult,
+} from '../integrations/gpt/module';
+import { createGptStartup } from '../integrations/gpt/startup';
+import {
+  activateGptDiagnosticsFactCapture,
+  createGptDiagnosticsFactBuffer,
+  projectGptTraceFact,
+  type GptDiagnosticsFactBuffer,
+} from '../integrations/gpt/diagnostics_facts';
+import {
+  createPrebidSelectionCoordinator,
+  publishPrebidBid,
+  type PrebidSelectionCoordinator,
+} from '../integrations/render_runtime/prebid_selection';
+import {
+  createPrebidRefreshPolicy,
+  createPrebidSyntheticRefreshRunner,
+  preparePrebidRegisteredRefreshAuction,
+} from '../integrations/prebid/refresh';
+import { createPrebidStartup } from '../integrations/prebid/startup';
+import { createLockrRuntime } from '../integrations/lockr/module';
+import { createOsanoRuntime } from '../integrations/osano/module';
+import { createPermutiveRuntime } from '../integrations/permutive/module';
+import { createSourcepointRuntime } from '../integrations/sourcepoint/module';
+import { createTestlightRuntime } from '../integrations/testlight/module';
+import {
+  createBrowserNavigationIdentityIssuer,
+  mintBrowserLifecycleTicket,
+} from '../kernel/identity';
+import {
+  createDiagnosticsIngress,
+  type DiagnosticsIngress,
+  type DiagnosticsObservation,
+} from '../kernel/diagnostics';
+import type {
+  NavigationIdentityIssuerFactory,
+  RenderAttemptScope,
+  RuntimeSession,
+} from '../kernel/sessions';
+import { createRuntimeSession } from '../kernel/sessions';
+import { trustedDocumentHttpOrigin } from '../shared/origin';
+import type {
+  CoreActivationContext,
+  IntegrationCatalogEntry,
+  IntegrationRegistration,
+} from '../kernel/integration_registry';
+import { RELEASE_CATALOG } from '../kernel/release_catalog';
+import { createRuntime, type Runtime, type RuntimeOptions } from '../kernel/runtime';
+import {
+  createAuctionContextRegistry,
+  type AuctionContextContributor,
+  type AuctionContextRegistry,
+  type ContextContributorOwner,
+} from '../services/context';
+import {
+  createAuctionBatchService,
+  type AuctionBatchFetcher,
+  type AuctionBatchService,
+} from '../services/auction_batch';
+import {
+  createPageBidsController,
+  type PageBidsController,
+  prepareInitialAuctionProjection,
+} from '../services/projections';
+import { createReservationService, type ReservationService } from '../services/reservations';
+import {
+  bindCommittedArtifactGuard,
+  bindCommittedArtifactRetirement,
+  createArtifactHostPositionLeaseRegistry,
+  createCommittedArtifactStore,
+  createBootstrapNonceRegistry,
+  createRenderAttempt,
+  createRendererNonceRegistry,
+  createSlotOperation,
+  renderDirectAdmAttempt,
+  type RenderAttempt,
+  type ArtifactHostPositionLeaseRegistry,
+  type CommittedArtifactStore,
+  type BootstrapNonceRegistry,
+  type RendererNonceRegistry,
+  type SlotOperationCreationResult,
+} from '../services/render';
+import { resizeCollapsedPucShell } from '../core/puc_shell';
+import { createPucBridge, type PucBridge, type PucBridgeOptions } from '../services/puc_bridge';
+import {
+  createBrowserSlotReconciliationBoundary,
+  createSlotService,
+  type SlotRecord,
+  type SlotRegistrationFailure,
+  type SlotService,
+} from '../services/slots';
+import { createTargetingService, type TargetingService } from '../services/targeting';
+
+function isEffectivelyVisible(element: Element | null): boolean {
+  try {
+    if (!element || !(element instanceof HTMLElement) || !element.isConnected) return false;
+    const rectangle = element.getBoundingClientRect();
+    if (rectangle.width <= 0 || rectangle.height <= 0) return false;
+    let current: HTMLElement | null = element;
+    while (current) {
+      const style = getComputedStyle(current);
+      if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        Number.parseFloat(style.opacity || '1') === 0
+      ) {
+        return false;
+      }
+      current = current.parentElement;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface BrowserAdapters {
+  readonly googletag: GoogletagAdapter;
+  readonly messaging: MessagingAdapter;
+  readonly prebid: PrebidAdapter;
+}
+
+export interface BrowserComposition {
+  readonly adapters: Readonly<BrowserAdapters>;
+}
+
+export const BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID = 'browser_test_diagnostics_provider';
+export const BROWSER_TEST_TRACE_PROVIDER_ID = 'browser_test_trace_provider';
+const TRUSTED_BROWSER_TEST_RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+function installBrowserTestRuntimeScript(runtimeDocument: Document): void {
+  if (runtimeDocument.currentScript) return;
+  const script = runtimeDocument.createElement('script');
+  script.id = 'trustedserver-js';
+  script.src = new URL(TRUSTED_BROWSER_TEST_RUNTIME_SRC, runtimeDocument.location.origin).href;
+  runtimeDocument.head.insertBefore(script, null);
+  Object.defineProperty(runtimeDocument, 'currentScript', {
+    configurable: true,
+    value: script,
+  });
+}
+
+export interface BrowserServices {
+  readonly artifacts: CommittedArtifactStore;
+  readonly hostPositions: ArtifactHostPositionLeaseRegistry;
+  readonly auctionBatches: AuctionBatchService;
+  readonly bootstrapNonces: BootstrapNonceRegistry;
+  readonly pucBridge: PucBridge;
+  readonly reservations: ReservationService;
+  readonly rendererNonces: RendererNonceRegistry;
+  readonly renderDirectAdm: (attempt: RenderAttempt, container: HTMLElement) => boolean;
+  readonly renderDirectAps: (attempt: RenderAttempt, container: HTMLElement) => boolean;
+  readonly slots: SlotService;
+  readonly targeting: TargetingService;
+}
+
+export type BrowserAdapterTarget = GoogletagGlobalTarget & PrebidGlobalTarget & MessageEventTarget;
+
+export interface BrowserCompositionOptions {
+  readonly adapters?: Partial<BrowserAdapters>;
+  readonly messagingValidation?: MessagingValidationOptions;
+  readonly target?: BrowserAdapterTarget;
+}
+
+export interface BrowserRuntimeComposition extends BrowserComposition {
+  readonly runtime: Runtime;
+  /** Build the explicit test-only provider for the diagnostics capability chain. */
+  readonly createDiagnosticsCapabilityProviderRegistrationForTest: () => IntegrationRegistration;
+  /** Build the explicit test-only provider for an overlay-only trace capability chain. */
+  readonly createTraceCapabilityProviderRegistrationForTest: () => IntegrationRegistration;
+  /** Return the lazily activated session for tests; this is not a `tsjs` field. */
+  readonly runtimeSessionForTest: () => RuntimeSession | undefined;
+  /** Construct a controller for the current navigation in coordinated-cutover tests. */
+  readonly pageBidsControllerForTest: () => PageBidsController | undefined;
+  /** Return one frozen slot-id inventory for coordinated-cutover tests. */
+  readonly projectionSlotsForTest: () => readonly string[] | undefined;
+  /** Return the lazily activated context registry for coordinated-cutover tests. */
+  readonly auctionContextRegistryForTest: () => AuctionContextRegistry | undefined;
+  /** Return runtime-owned slot operations only in coordinated-cutover tests. */
+  readonly slotServiceForTest: () => SlotService | undefined;
+  /** Return runtime-owned targeting operations only in coordinated-cutover tests. */
+  readonly targetingServiceForTest: () => TargetingService | undefined;
+  /** Return runtime-owned reservation operations only in coordinated-cutover tests. */
+  readonly reservationServiceForTest: () => ReservationService | undefined;
+  /** Return runtime-owned renderer nonces only in coordinated-cutover tests. */
+  readonly rendererNonceRegistryForTest: () => RendererNonceRegistry | undefined;
+  /** Return the single runtime-owned PUC bridge only in coordinated-cutover tests. */
+  readonly pucBridgeForTest: () => PucBridge | undefined;
+  /** Join one candidate GPT attempt through the runtime-owned services in tests. */
+  readonly startGptSlotOperationForTest: (
+    input: Omit<GptSlotOperationInput, 'createSlotOperation' | 'pucBridge' | 'slots'>
+  ) => SlotOperationCreationResult;
+  /** Publish one candidate server winner through the ordered GPT transaction in tests. */
+  readonly publishGptWinnerForTest: (
+    input: Omit<
+      GptWinnerPublicationInput,
+      | 'createSlotOperation'
+      | 'googletag'
+      | 'navigation'
+      | 'pucBridge'
+      | 'reservations'
+      | 'slots'
+      | 'targeting'
+    >
+  ) => Promise<GptWinnerPublicationResult>;
+}
+
+export interface BrowserCoreActivations {
+  readonly correctnessGptListeners: (
+    context: CoreActivationContext,
+    adapters: Readonly<BrowserAdapters>,
+    services: Readonly<BrowserServices>
+  ) => void;
+}
+
+export interface TestBrowserRuntimeCompositionOptions extends BrowserCompositionOptions {
+  readonly auctionFetcherForTest?: AuctionBatchFetcher;
+  readonly coreActivations?: BrowserCoreActivations;
+  readonly creativeActivationForTest?: (config: Readonly<CreativeBootV1>) => () => void;
+  readonly creativeStartupForTest?: (config: Readonly<CreativeBootV1>) => void;
+  readonly createIdentityIssuerForTest?: NavigationIdentityIssuerFactory;
+  readonly admittedProgrammaticSlotsForTest?: readonly string[];
+  readonly gptStartupForTest?: (config: unknown) => void;
+  readonly pageBidsFetcherForTest?: PageBidsFetcher;
+  readonly prebidStartupForTest?: (config: unknown) => void;
+  readonly pucSchedulerForTest?: PucBridgeOptions['scheduler'];
+}
+
+const TEST_CONFIG_ORDER = Object.freeze([
+  'aps',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'sourcepoint',
+  'testlight',
+]);
+
+function testConfigProduct(id: string): string | undefined {
+  if (id === 'gpt' || id === 'gpt_later') return 'gpt';
+  if (id === 'osano_consent' || id === 'osano_lifecycle') return 'osano';
+  if (id === 'permutive_context' || id === 'permutive_lifecycle') return 'permutive';
+  if (id === 'prebid' || id === 'prebid_later') return 'prebid';
+  if (id === 'sourcepoint_consent' || id === 'sourcepoint_lifecycle') return 'sourcepoint';
+  return TEST_CONFIG_ORDER.includes(id) ? id : undefined;
+}
+
+function defaultBrowserTestConfig(id: string): Readonly<Record<string, unknown>> {
+  if (id === 'didomi') return { proxyPath: '/integrations/didomi/consent/' };
+  if (id === 'gpt') return { gamAttributionEnabled: false, pageBidsEnabled: true };
+  if (id === 'prebid') {
+    return {
+      accountId: 'test',
+      timeout: 1_000,
+      debug: false,
+      bidders: [],
+      clientSideBidders: [],
+      excludedGamAdUnitPathSuffixes: [],
+    };
+  }
+  if (id === 'sourcepoint') return { rewriteSdk: true };
+  return {};
+}
+
+function testIntegrationConfigs(manifest: unknown): Readonly<Record<string, unknown>> {
+  const integrations =
+    typeof manifest === 'object' &&
+    manifest !== null &&
+    Array.isArray((manifest as { integrations?: unknown }).integrations)
+      ? (manifest as { integrations: Array<{ id?: unknown }> }).integrations
+      : [];
+  const selected = new Set(
+    integrations.flatMap(({ id }) => (typeof id === 'string' ? [testConfigProduct(id)] : []))
+  );
+  return {
+    version: 1,
+    entries: TEST_CONFIG_ORDER.filter((id) => selected.has(id)).map((id) => ({
+      id,
+      config: defaultBrowserTestConfig(id),
+    })),
+  };
+}
+
+function capturedBrowserTestRuntimeOptions(options: RuntimeOptions): RuntimeOptions {
+  try {
+    if (
+      typeof options.boot !== 'object' ||
+      options.boot === null ||
+      Array.isArray(options.boot) ||
+      Object.getPrototypeOf(options.boot) !== Object.prototype
+    ) {
+      return options;
+    }
+    const fields = options.boot as Readonly<Record<string, unknown>>;
+    const candidate = Object.prototype.hasOwnProperty.call(fields, 'abi')
+      ? fields
+      : {
+          abi: 1,
+          releaseId: options.releaseId,
+          manifest: options.manifest,
+          auctionProjection: fields['auctionProjection'],
+          integrations: Object.prototype.hasOwnProperty.call(fields, 'integrations')
+            ? fields['integrations']
+            : testIntegrationConfigs(options.manifest),
+          creative: fields['creative'],
+          diagnostics: fields['diagnostics'],
+        };
+    const boot = snapshotTsjsBootV1(candidate, options.releaseId);
+    if (!boot) return options;
+    const catalog = options.catalog?.map((entry): IntegrationCatalogEntry => {
+      const canonical = RELEASE_CATALOG.find(({ id }) => id === entry.id);
+      return Object.freeze({
+        ...entry,
+        config: canonical?.config ?? entry.config ?? null,
+      });
+    });
+    return {
+      ...options,
+      boot,
+      manifest: boot.manifest,
+      ...(catalog === undefined ? {} : { catalog: Object.freeze(catalog) }),
+    };
+  } catch {
+    return options;
+  }
+}
+
+interface AcceptedBrowserBoot {
+  readonly auctionProjection: object;
+  readonly creative: Readonly<CreativeBootV1>;
+  readonly diagnostics: Readonly<DiagnosticsBootV1>;
+  readonly manifest: Readonly<BootManifestV1>;
+}
+
+interface PreparedBrowserServices {
+  readonly createAttempt: (
+    owner: RenderAttemptScope,
+    parentAttemptId?: string
+  ) => ReturnType<typeof createRenderAttempt>;
+  readonly publisherOrigin: string;
+  readonly renderProjectedFallback: (attempt: RenderAttempt) => boolean;
+  readonly rendererUrl: string;
+  readonly services: Readonly<Omit<BrowserServices, 'pucBridge'>>;
+}
+
+interface PageBidsResponse {
+  readonly ok: boolean;
+  readonly json: () => Promise<unknown>;
+}
+
+type PageBidsFetcher = (
+  input: string,
+  init: Readonly<{
+    credentials: 'include';
+    headers: Readonly<{ 'X-TSJS-Page-Bids': '1' }>;
+    signal: AbortSignal;
+  }>
+) => PromiseLike<PageBidsResponse>;
+
+interface PageBidsNavigationLifecycle {
+  readonly activate: () => () => void;
+  readonly start: () => void;
+}
+
+type GptProjectionPublisher = (
+  navigation: NonNullable<RuntimeSession['currentNavigation']>,
+  projection: Readonly<BrowserAuctionProjectionV1>,
+  requestClass: string
+) => void;
+
+const noopGptProjectionPublisher: GptProjectionPublisher = () => undefined;
+
+function resolveProjectedSlotElement(
+  placement: Readonly<BrowserAuctionSlotV1>
+): HTMLElement | undefined {
+  try {
+    if (typeof document === 'undefined') return undefined;
+    const exact = document.getElementById(placement.divId);
+    if (exact instanceof HTMLElement) return exact;
+    const prefixMatches = [...document.querySelectorAll<HTMLElement>('[id]')].filter(
+      (element) => element.id.startsWith(placement.divId) && !element.id.endsWith('-container')
+    );
+    if (prefixMatches.length === 1) return prefixMatches[0];
+    const visible = prefixMatches.filter((element) => isEffectivelyVisible(element));
+    if (visible.length === 1) return visible[0];
+    const active = visible.filter((element) => {
+      const bounds = element.getBoundingClientRect();
+      return bounds.width > 0 && bounds.height > 0;
+    });
+    return active.length === 1 ? active[0] : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function currentBrowserPath(): string | undefined {
+  try {
+    return `${window.location.pathname}${window.location.search}`;
+  } catch {
+    return undefined;
+  }
+}
+
+function restoreHistoryMethod(
+  name: 'pushState' | 'replaceState',
+  previous: PropertyDescriptor | undefined,
+  installed: History['pushState']
+): void {
+  try {
+    const current = Object.getOwnPropertyDescriptor(window.history, name);
+    if (!current || !('value' in current) || current.value !== installed) return;
+    if (previous) Object.defineProperty(window.history, name, previous);
+    else Reflect.deleteProperty(window.history, name);
+  } catch {
+    // A publisher replacement remains authoritative; the disposed wrapper is inert.
+  }
+}
+
+/** Own the canonical page-bids fetch and one replacement session per SPA navigation. */
+function createPageBidsNavigationLifecycle(options: {
+  readonly fetcher?: PageBidsFetcher;
+  readonly onProjectionCommitted?: (
+    navigation: NonNullable<RuntimeSession['currentNavigation']>,
+    projection: Readonly<object>
+  ) => void;
+  readonly runtimeSession: () => RuntimeSession | undefined;
+  readonly services: () => Readonly<BrowserServices> | undefined;
+  readonly projectionParser: () => ((candidate: unknown) => object | undefined) | undefined;
+}): PageBidsNavigationLifecycle {
+  let active = false;
+  let disposed = false;
+  let started = false;
+  let appliedPath: string | undefined;
+  let currentPath: string | undefined;
+  let release: (() => void) | undefined;
+
+  const rollBackPath = (
+    path: string,
+    navigation?: NonNullable<RuntimeSession['currentNavigation']>
+  ): void => {
+    if (currentPath !== path || (navigation && !navigation.isCurrent())) return;
+    currentPath = appliedPath;
+  };
+
+  const requestProjection = async (path: string): Promise<void> => {
+    const session = options.runtimeSession();
+    const replacement = session?.replaceNavigation();
+    if (!replacement?.ok) {
+      rollBackPath(path);
+      return;
+    }
+    const navigation = replacement.value;
+    const services = options.services();
+    const parseProjection = options.projectionParser();
+    if (!services || !parseProjection) {
+      rollBackPath(path, navigation);
+      return;
+    }
+    const controller = createPageBidsController({
+      navigation,
+      parseProjection,
+      slotRegistry: services.slots.projectionRegistry(navigation),
+    });
+    const fetcher = options.fetcher ?? globalThis.fetch;
+    if (typeof fetcher !== 'function') {
+      rollBackPath(path, navigation);
+      return;
+    }
+    let committed = false;
+    try {
+      const response = await fetcher(`/_ts/page-bids?path=${encodeURIComponent(path)}`, {
+        credentials: 'include',
+        headers: { 'X-TSJS-Page-Bids': '1' },
+        signal: navigation.signal,
+      });
+      if (!navigation.isCurrent()) return;
+      if (!response.ok) {
+        rollBackPath(path, navigation);
+        return;
+      }
+      const candidate = await response.json();
+      if (!navigation.isCurrent()) return;
+      const result = controller.commit(candidate);
+      if (result.status === 'committed') {
+        committed = true;
+        appliedPath = path;
+        const projection = navigation.currentAuctionProjection;
+        if (projection) options.onProjectionCommitted?.(navigation, projection);
+      }
+      if (result.status === 'rejected' && result.reason !== 'stale') {
+        rollBackPath(path, navigation);
+        log.warn('page-bids: rejected navigation projection', result.reason);
+      }
+    } catch (error) {
+      if (!navigation.signal.aborted) {
+        if (!committed) rollBackPath(path, navigation);
+        log.warn('page-bids: projection request failed', error);
+      }
+    }
+  };
+
+  const navigateIfChanged = (): void => {
+    if (!active || !started || disposed) return;
+    const path = currentBrowserPath();
+    if (path === undefined || path === currentPath) return;
+    currentPath = path;
+    void requestProjection(path);
+  };
+
+  return Object.freeze({
+    activate: (): (() => void) => {
+      if (active || disposed) throw new Error('Page-bids navigation owner is unavailable');
+      const history = window.history;
+      const previousPushState = Object.getOwnPropertyDescriptor(history, 'pushState');
+      const previousReplaceState = Object.getOwnPropertyDescriptor(history, 'replaceState');
+      const pushState = history.pushState;
+      const replaceState = history.replaceState;
+      const wrap = (original: History['pushState']): History['pushState'] =>
+        function wrappedHistoryState(
+          this: History,
+          data: unknown,
+          unused: string,
+          url?: string | URL | null
+        ): void {
+          Reflect.apply(original, this, [data, unused, url]);
+          navigateIfChanged();
+        };
+      const wrappedPushState = wrap(pushState);
+      const wrappedReplaceState = wrap(replaceState);
+      const onPopState = (): void => navigateIfChanged();
+      try {
+        Object.defineProperty(history, 'pushState', {
+          configurable: true,
+          enumerable: previousPushState?.enumerable ?? false,
+          value: wrappedPushState,
+          writable: true,
+        });
+        Object.defineProperty(history, 'replaceState', {
+          configurable: true,
+          enumerable: previousReplaceState?.enumerable ?? false,
+          value: wrappedReplaceState,
+          writable: true,
+        });
+        window.addEventListener('popstate', onPopState);
+        active = true;
+      } catch (error) {
+        restoreHistoryMethod('replaceState', previousReplaceState, wrappedReplaceState);
+        restoreHistoryMethod('pushState', previousPushState, wrappedPushState);
+        throw error;
+      }
+      let released = false;
+      release = (): void => {
+        if (released) return;
+        released = true;
+        disposed = true;
+        active = false;
+        window.removeEventListener('popstate', onPopState);
+        restoreHistoryMethod('replaceState', previousReplaceState, wrappedReplaceState);
+        restoreHistoryMethod('pushState', previousPushState, wrappedPushState);
+      };
+      return release;
+    },
+    start: (): void => {
+      if (!active || disposed) return;
+      currentPath = currentBrowserPath();
+      appliedPath = currentPath;
+      started = true;
+    },
+  });
+}
+
+interface ComposedPrebidRefreshConfig {
+  readonly clientSideBidders: readonly string[];
+  readonly excludedGamAdUnitPathSuffixes: readonly string[];
+}
+
+const EMPTY_PREBID_REFRESH_CONFIG: ComposedPrebidRefreshConfig = Object.freeze({
+  clientSideBidders: Object.freeze([]),
+  excludedGamAdUnitPathSuffixes: Object.freeze([]),
+});
+
+function composedPrebidRefreshConfig(candidate: unknown): ComposedPrebidRefreshConfig {
+  try {
+    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+      return EMPTY_PREBID_REFRESH_CONFIG;
+    }
+    const strings = (name: string): readonly string[] => {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, name);
+      if (!descriptor || !('value' in descriptor) || !Array.isArray(descriptor.value)) {
+        return Object.freeze([]);
+      }
+      const values: string[] = [];
+      for (let index = 0; index < descriptor.value.length; index += 1) {
+        const value = descriptor.value[index];
+        if (typeof value !== 'string') return Object.freeze([]);
+        values.push(value);
+      }
+      return Object.freeze(values);
+    };
+    return Object.freeze({
+      clientSideBidders: strings('clientSideBidders'),
+      excludedGamAdUnitPathSuffixes: strings('excludedGamAdUnitPathSuffixes'),
+    });
+  } catch {
+    return EMPTY_PREBID_REFRESH_CONFIG;
+  }
+}
+
+function composedPrebidRefreshAuction(
+  physicalSlots: readonly object[],
+  navigation: RuntimeSession['currentNavigation'],
+  slots: SlotService,
+  config: ComposedPrebidRefreshConfig
+): unknown {
+  if (!navigation?.isCurrent()) return undefined;
+  const records = slots.snapshotRegisteredSlots(navigation);
+  if (!records) return undefined;
+  const resolved = new Map<object, Readonly<object>>();
+  for (let slotIndex = 0; slotIndex < physicalSlots.length; slotIndex += 1) {
+    const physicalSlot = physicalSlots[slotIndex];
+    if (!physicalSlot) return undefined;
+    let matched: SlotRecord | undefined;
+    for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+      const record = records[recordIndex];
+      if (
+        !record ||
+        !slots.isBoundGptSlot(navigation.generation, record.registeredSlotId, physicalSlot)
+      ) {
+        continue;
+      }
+      if (matched) return undefined;
+      matched = record;
+    }
+    const source = matched?.directAuctionUnit;
+    if (!source || !Object.isFrozen(source)) {
+      return undefined;
+    }
+    resolved.set(physicalSlot, source);
+  }
+  return preparePrebidRegisteredRefreshAuction({
+    clientSideBidders: config.clientSideBidders,
+    resolveAdUnit: (slot) => resolved.get(slot),
+    slots: physicalSlots,
+  });
+}
+
+function registerScopedContextContributor(
+  registry: AuctionContextRegistry,
+  runtimeOwner: RuntimeSession,
+  integrationId: string,
+  contributor: AuctionContextContributor
+): (() => void) | undefined {
+  let active = true;
+  let releaseRegistration: (() => void) | undefined;
+  const owner: ContextContributorOwner = Object.freeze({
+    generation: Object.freeze({}),
+    isCurrent: () => active && runtimeOwner.isCurrent(),
+    onDispose: (kind: string, callback: () => void) => {
+      if (kind !== 'auction-context-contributor' || !active || releaseRegistration) {
+        throw new Error('Auction context contributor disposer is unavailable');
+      }
+      releaseRegistration = callback;
+    },
+  });
+  if (!registry.register(integrationId, contributor, owner)) {
+    active = false;
+    releaseRegistration?.();
+    return undefined;
+  }
+  return (): void => {
+    if (!active) return;
+    active = false;
+    const release = releaseRegistration;
+    releaseRegistration = undefined;
+    release?.();
+  };
+}
+
+/**
+ * Construct concrete browser dependencies in one place.
+ *
+ * Task 6 keeps this test-only composition disconnected from the shipped core;
+ * the coordinated production switch occurs only after the runtime is complete.
+ */
+export function createBrowserComposition(
+  options: BrowserCompositionOptions = {}
+): BrowserComposition {
+  const defaultValidator = (candidate: unknown): boolean =>
+    validateApsRenderer(candidate) !== undefined;
+  const browserMessagingValidation = (): MessagingValidationOptions => {
+    try {
+      const expectedPublisherOrigin = window.location.origin;
+      return {
+        expectedPublisherOrigin,
+        expectedRendererUrl: new URL('/integrations/aps/renderer/v2', expectedPublisherOrigin).href,
+        validateApsRenderer: defaultValidator,
+        ...options.messagingValidation,
+      };
+    } catch {
+      return { validateApsRenderer: defaultValidator, ...options.messagingValidation };
+    }
+  };
+  const googletag =
+    options.adapters?.googletag ??
+    (options.target
+      ? createBrowserGoogletagAdapter(options.target, {
+          reportDiagnosticsFailure: (code) =>
+            log.warn('GPT diagnostics identity unavailable', code),
+        })
+      : createBrowserGoogletagAdapter(undefined, {
+          reportDiagnosticsFailure: (code) =>
+            log.warn('GPT diagnostics identity unavailable', code),
+        }));
+  const messaging =
+    options.adapters?.messaging ??
+    (options.target
+      ? createBrowserMessagingAdapter(options.target, {
+          validateApsRenderer: defaultValidator,
+          ...options.messagingValidation,
+        })
+      : createBrowserMessagingAdapter(undefined, browserMessagingValidation()));
+  const prebid =
+    options.adapters?.prebid ??
+    (options.target ? createBrowserPrebidAdapter(options.target) : createBrowserPrebidAdapter());
+
+  return Object.freeze({
+    adapters: Object.freeze({ googletag, messaging, prebid }),
+  });
+}
+
+/** Construct a side-effect-free dependency set for kernel and service tests. */
+export function createNoopBrowserComposition(): BrowserComposition {
+  return Object.freeze({
+    adapters: Object.freeze({
+      googletag: createNoopGoogletagAdapter(),
+      messaging: createNoopMessagingAdapter(),
+      prebid: createNoopPrebidAdapter(),
+    }),
+  });
+}
+
+/**
+ * Construct the sole browser runtime composition without claiming a global.
+ *
+ * The core entry point owns the one production claim; tests may construct the
+ * same composition against explicit targets and adapters.
+ */
+export function createTestBrowserRuntimeComposition(
+  providedRuntimeOptions: RuntimeOptions,
+  compositionOptions: TestBrowserRuntimeCompositionOptions
+): BrowserRuntimeComposition {
+  const runtimeOptions = capturedBrowserTestRuntimeOptions(providedRuntimeOptions);
+  const runtimeDocument =
+    runtimeOptions.document ?? (typeof document === 'undefined' ? undefined : document);
+  if (runtimeDocument) installBrowserTestRuntimeScript(runtimeDocument);
+  const composition = createBrowserComposition(compositionOptions);
+  const providedBindings = runtimeOptions.getBindings;
+  let browserServices: Readonly<BrowserServices> | undefined;
+  let gptProjectionPublisher = noopGptProjectionPublisher;
+  let projectionParser: ((candidate: unknown) => object | undefined) | undefined;
+  let runtimeSession: RuntimeSession | undefined;
+  let creativeBoot: Readonly<CreativeBootV1> | undefined;
+  let diagnosticsBoot: Readonly<DiagnosticsBootV1> | undefined;
+  let diagnosticsIngress: DiagnosticsIngress | undefined;
+  let gptDiagnosticsFacts: GptDiagnosticsFactBuffer | undefined;
+  let renderTrace: RenderTraceRuntimeOwner | undefined;
+  const renderTraceSlotsByNavigation = new Map<object, Set<string>>();
+  const consumeCoreObservation = (observation: DiagnosticsObservation): void => {
+    if (
+      observation['kind'] === 'slotRequested' ||
+      observation['kind'] === 'slotResponseReceived' ||
+      observation['kind'] === 'slotRenderEnded' ||
+      observation['kind'] === 'slotOnload' ||
+      observation['kind'] === 'impressionViewable' ||
+      observation['kind'] === 'slotVisibilityChanged'
+    ) {
+      try {
+        renderTrace?.observeGptFact(
+          observation as unknown as Readonly<RenderTraceGptFactV1>,
+          (elementId) => {
+            if (typeof elementId !== 'string' || elementId === '') return undefined;
+            const slots = browserServices?.slots;
+            const slot =
+              slots?.resolveDomAlias(elementId) ?? slots?.resolveRegisteredSlot(elementId);
+            if (!slot?.traceToken) return undefined;
+            let element: HTMLElement | undefined;
+            if (typeof document !== 'undefined') {
+              const matches = [...document.querySelectorAll<HTMLElement>('[id]')].filter(
+                (candidate) => candidate.id === elementId
+              );
+              if (matches.length === 1) element = matches[0];
+            }
+            return Object.freeze({
+              slotId: slot.registeredSlotId,
+              navigationGeneration: slot.navigationGeneration,
+              traceToken: slot.traceToken,
+              ...(element === undefined
+                ? {}
+                : { elementId: element.id, visible: isEffectivelyVisible(element) }),
+            });
+          }
+        );
+      } catch {
+        // Render tracing never affects an already-committed adapter observation.
+      }
+      return;
+    }
+    if (
+      observation['kind'] !== 'render_attempt' ||
+      typeof observation['slotId'] !== 'string' ||
+      (observation['path'] !== 'auction' && observation['path'] !== 'ssat') ||
+      typeof observation['rendered'] !== 'boolean' ||
+      typeof observation['injected'] !== 'boolean'
+    ) {
+      return;
+    }
+    const state = observation['state'];
+    const terminal = observation['outcome'];
+    const terminalRecord =
+      typeof terminal === 'object' && terminal !== null
+        ? (terminal as Readonly<Record<string, unknown>>)
+        : undefined;
+    const attributableEmpty =
+      state === 'failed' &&
+      terminalRecord?.['outcome'] === 'failed' &&
+      terminalRecord['reason'] === 'gam_empty';
+    if (state !== 'accepted' && !attributableEmpty) return;
+    if ((state === 'accepted') !== observation['rendered']) return;
+    const servedFrom = observation['servedFrom'];
+    if (servedFrom !== undefined && servedFrom !== 'inline' && servedFrom !== 'pbs-cache') return;
+    try {
+      const slotId = observation['slotId'];
+      const slot = browserServices?.slots.resolveRegisteredSlot(slotId);
+      const identifiers = slot
+        ? new Set([slot.registeredSlotId, ...slot.domAliases])
+        : new Set([slotId]);
+      const elements = new Set<HTMLElement>();
+      if (typeof document !== 'undefined') {
+        for (const identifier of identifiers) {
+          const element = document.getElementById(identifier);
+          if (element instanceof HTMLElement) elements.add(element);
+        }
+      }
+      const element = elements.size === 1 ? [...elements][0] : undefined;
+      const optionalString = (name: 'adId' | 'bidId' | 'creativeId'): string | undefined => {
+        const value = observation[name];
+        return typeof value === 'string' && value !== '' ? value : undefined;
+      };
+      const adId = optionalString('adId');
+      const bidId = optionalString('bidId');
+      const creativeId = optionalString('creativeId');
+      const navigation = runtimeSession?.currentNavigation;
+      if (navigation?.isCurrent()) {
+        const tracedSlots = renderTraceSlotsByNavigation.get(navigation.generation) ?? new Set();
+        tracedSlots.add(slotId);
+        renderTraceSlotsByNavigation.set(navigation.generation, tracedSlots);
+      }
+      renderTrace?.record({
+        slotId,
+        path: observation['path'],
+        rendered: observation['rendered'],
+        injected: observation['injected'],
+        ...(element === undefined
+          ? {}
+          : { elementId: element.id, visible: isEffectivelyVisible(element) }),
+        ...(adId === undefined ? {} : { adId }),
+        ...(bidId === undefined ? {} : { bidId }),
+        ...(creativeId === undefined ? {} : { creativeId }),
+        ...(servedFrom === undefined ? {} : { servedFrom }),
+      });
+    } catch {
+      // Render diagnostics never affect the already-committed attempt.
+    }
+  };
+  const diagnosticsForPublish = (): Readonly<object> => {
+    const trace = renderTrace;
+    if (!trace) throw new Error('Render diagnostics are unavailable');
+    return Object.freeze({ renderTrace: trace.diagnostics });
+  };
+  const defaultCreativeRuntime =
+    typeof document === 'undefined'
+      ? Object.freeze({
+          activate: (_config: Readonly<CreativeBootV1>) => () => undefined,
+          start: (_config: Readonly<CreativeBootV1>) => undefined,
+        })
+      : createCreativeStartup({
+          document,
+          installClickGuard: () => installClickGuard(false),
+          installDynamicIframeProxy: () => installDynamicIframeProxy(false),
+          installDynamicImageProxy: () => installDynamicImageProxy(false),
+        });
+  const creativeRuntime = Object.freeze({
+    activate: compositionOptions.creativeActivationForTest ?? defaultCreativeRuntime.activate,
+    start: compositionOptions.creativeStartupForTest ?? defaultCreativeRuntime.start,
+  });
+  const startGpt = compositionOptions.gptStartupForTest ?? (() => undefined);
+  const pageBidsNavigation = createPageBidsNavigationLifecycle({
+    ...(compositionOptions.pageBidsFetcherForTest
+      ? { fetcher: compositionOptions.pageBidsFetcherForTest }
+      : {}),
+    onProjectionCommitted: (navigation, projection) =>
+      gptProjectionPublisher(
+        navigation,
+        projection as Readonly<BrowserAuctionProjectionV1>,
+        'page-bids'
+      ),
+    projectionParser: () => projectionParser,
+    runtimeSession: () => runtimeSession,
+    services: () => browserServices,
+  });
+  const gptRuntime = createGptStartup({
+    googletag: composition.adapters.googletag,
+    slots: () => {
+      const slots = browserServices?.slots;
+      if (!slots) throw new Error('GPT slot service is unavailable');
+      return slots;
+    },
+    start: startGpt,
+  });
+  const gptIntegrationRuntime = Object.freeze({
+    activate: (): (() => void) => {
+      const releaseGpt = gptRuntime.activate();
+      let releaseNavigation: (() => void) | undefined;
+      try {
+        releaseNavigation = pageBidsNavigation.activate();
+      } catch (error) {
+        releaseGpt();
+        throw error;
+      }
+      return (): void => {
+        releaseNavigation?.();
+        releaseGpt();
+      };
+    },
+    start: (config: unknown): void => {
+      gptRuntime.start(config);
+      pageBidsNavigation.start();
+      const navigation = runtimeSession?.currentNavigation;
+      const projection = navigation?.currentAuctionProjection;
+      if (navigation && projection) {
+        gptProjectionPublisher(
+          navigation,
+          projection as Readonly<BrowserAuctionProjectionV1>,
+          'initial'
+        );
+      }
+    },
+  });
+  let prebidCoordinator: PrebidSelectionCoordinator | undefined;
+  let prebidRefreshConfig = EMPTY_PREBID_REFRESH_CONFIG;
+  const startPrebid = compositionOptions.prebidStartupForTest ?? (() => undefined);
+  const prebidRefreshRunner = createPrebidSyntheticRefreshRunner({
+    prebid: composition.adapters.prebid,
+    prepareAuction: (slots, navigation) => {
+      const slotService = browserServices?.slots;
+      if (!slotService) return undefined;
+      return composedPrebidRefreshAuction(slots, navigation, slotService, prebidRefreshConfig);
+    },
+  });
+  const prebidRefreshPolicy = createPrebidRefreshPolicy({
+    currentNavigation: () => runtimeSession?.currentNavigation,
+    excludedGamAdUnitPathSuffixes: () => prebidRefreshConfig.excludedGamAdUnitPathSuffixes,
+    googletag: composition.adapters.googletag,
+    runSyntheticAuction: prebidRefreshRunner,
+  });
+  const completePrebidAuction = (auction: Readonly<PrebidTrustedServerAuctionV1>): void => {
+    try {
+      auction.complete();
+    } catch {
+      // The private bidder completion boundary cannot escape into publisher code.
+    }
+  };
+  const publishPrebidAuction = (auction: Readonly<PrebidTrustedServerAuctionV1>): void => {
+    const navigation = runtimeSession?.currentNavigation;
+    const reservations = browserServices?.reservations;
+    const coordinator = prebidCoordinator;
+    if (!navigation || !reservations || !coordinator || !navigation.isCurrent()) {
+      completePrebidAuction(auction);
+      return;
+    }
+    try {
+      const projection = navigation.currentAuctionProjection as
+        Readonly<BrowserAuctionProjectionV1> | undefined;
+      if (!projection || projection.auction.auctionId !== auction.auctionId) return;
+      for (let index = 0; index < auction.bids.length; index += 1) {
+        const request = auction.bids[index];
+        if (!request) continue;
+        const winners = projection.auction.results.filter(
+          (result) => result.slot === request.adUnitCode && result.outcome === 'winner'
+        );
+        if (winners.length !== 1) continue;
+        const winner = winners[0];
+        if (!winner || winner.outcome !== 'winner') continue;
+        const bids = projection.bids.filter(
+          (bid) => bid.slot === request.adUnitCode && bid.candidateId === winner.candidateId
+        );
+        if (bids.length !== 1) continue;
+        const bid = bids[0];
+        if (!bid) continue;
+        const publication = publishPrebidBid({
+          admitTrustedBid: (preparedBid) =>
+            composition.adapters.prebid.admitTrustedBid(preparedBid),
+          auctionId: auction.auctionId,
+          adUnitCode: request.adUnitCode,
+          bid,
+          generatedBid: Object.freeze({
+            requestId: request.requestId,
+            adId: request.requestId,
+            cpm: bid.cpm,
+            width: bid.renderSource.width,
+            height: bid.renderSource.height,
+          }),
+          navigation,
+          reservations,
+          trackAdmittedBid: coordinator.track,
+        });
+        if (
+          !publication.ok &&
+          (publication.reason === 'prebid_admission_failed' ||
+            publication.reason === 'prebid_contract_violation')
+        ) {
+          coordinator.settlePublicationFailure(
+            navigation,
+            auction.auctionId,
+            request.adUnitCode,
+            publication.reason
+          );
+        }
+      }
+    } catch {
+      // Invalid/stale projection state publishes no Prebid bid.
+    } finally {
+      completePrebidAuction(auction);
+    }
+  };
+  const prebidRuntime = createPrebidStartup({
+    dispose: () => {
+      prebidCoordinator?.dispose();
+      prebidCoordinator = undefined;
+    },
+    onAuction: publishPrebidAuction,
+    onAuctionEnd: (event, prebid) => prebidCoordinator?.auctionEnded(event, prebid),
+    prebid: composition.adapters.prebid,
+    refresh: Object.freeze({
+      configure: (config: unknown): void => {
+        prebidRefreshConfig = composedPrebidRefreshConfig(config);
+      },
+      install: gptRuntime.installRefreshPolicy,
+      policy: prebidRefreshPolicy,
+    }),
+    start: startPrebid,
+  });
+  const getBindings: NonNullable<RuntimeOptions['getBindings']> = (id) => {
+    const provided = providedBindings?.(id);
+    let config: unknown;
+    if (provided !== undefined) {
+      const descriptor = Object.getOwnPropertyDescriptor(provided, 'config');
+      if (!descriptor || !('value' in descriptor)) return provided;
+      config = descriptor.value;
+    }
+    if (id === 'creative' && config === undefined) config = creativeBoot;
+    if (id === 'gpt_diagnostics' && config === undefined) config = diagnosticsBoot?.gpt;
+    const interfaces = runtimeSession?.interfaces;
+    if (!interfaces) throw new Error(`Integration interfaces are unavailable for ${id}`);
+    return Object.freeze({
+      config,
+      interfaces,
+    });
+  };
+  let preparedBrowserServices: PreparedBrowserServices | undefined;
+  let auctionContextRegistry: AuctionContextRegistry | undefined;
+  const dataDomeRuntime = createDataDomeRuntime();
+  const didomiRuntime = createDidomiRuntime();
+  const googleTagManagerRuntime = createGoogleTagManagerRuntime();
+  const lockrRuntime = createLockrRuntime();
+  const osanoConsentRuntime = createOsanoRuntime();
+  const osanoLifecycleRuntime = createOsanoRuntime();
+  const permutiveContextRuntime = createPermutiveRuntime({
+    registerContext: (contributor) => {
+      const registry = auctionContextRegistry;
+      const owner = runtimeSession;
+      return registry && owner
+        ? registerScopedContextContributor(registry, owner, 'permutive_context', contributor)
+        : undefined;
+    },
+  });
+  const permutiveLifecycleRuntime = createPermutiveRuntime({
+    registerContext: () => undefined,
+  });
+  const sourcepointConsentRuntime = createSourcepointRuntime();
+  const sourcepointLifecycleRuntime = createSourcepointRuntime();
+  const testlightRuntime = createTestlightRuntime({
+    enqueue: (callback) => {
+      const queue = (runtimeOptions.target as { readonly que?: unknown }).que;
+      if (!Array.isArray(queue) || typeof queue.push !== 'function') {
+        throw new Error('Testlight TSJS queue is unavailable');
+      }
+      queue.push(callback);
+    },
+    started: () => log.info('Testlight integration initialized'),
+    target: window as typeof window & { testlight?: { que?: unknown[] } },
+  });
+  let auctionBatchService: AuctionBatchService | undefined;
+  const publishProjectionThroughGpt = async (
+    navigation: NonNullable<RuntimeSession['currentNavigation']>,
+    projection: Readonly<BrowserAuctionProjectionV1>,
+    requestClass: string
+  ): Promise<void> => {
+    const prepared = preparedBrowserServices;
+    const services = browserServices;
+    if (!prepared || !services || !navigation.isCurrent() || projection.slots.length === 0) return;
+    const physicalBySlot = new Map<
+      string,
+      Readonly<{ operation: 'display' | 'refresh'; slot: object }>
+    >();
+    const operation = composition.adapters.googletag.run(
+      (gpt) => {
+        for (let index = 0; index < projection.slots.length; index += 1) {
+          const placement = projection.slots[index];
+          if (!placement || !navigation.isCurrent()) break;
+          const element = resolveProjectedSlotElement(placement);
+          if (!element) continue;
+          const definition = Object.freeze({
+            adUnitPath: placement.gamUnitPath,
+            elementId: element.id,
+            sizes: placement.formats,
+          });
+          const existing = gpt.slots().filter((slot) => gpt.slotElementId?.(slot) === element.id);
+          if (existing.length > 1) continue;
+          const publisherSlot = existing[0];
+          if (publisherSlot) {
+            const adopted = services.slots.adoptGptSlot(navigation.generation, placement.slot, {
+              definition,
+              elementIdPrefix: placement.divId,
+              ownership: 'publisher',
+              slot: publisherSlot,
+            });
+            if (adopted.ok) {
+              physicalBySlot.set(
+                placement.slot,
+                Object.freeze({ operation: 'refresh', slot: publisherSlot })
+              );
+            }
+            continue;
+          }
+          const defined = gpt.transactionalDefine(
+            definition,
+            () => navigation.isCurrent(),
+            (candidate) => {
+              let committed = false;
+              return Object.freeze({
+                commit: (): boolean => {
+                  const adopted = services.slots.adoptGptSlot(
+                    navigation.generation,
+                    placement.slot,
+                    {
+                      definition,
+                      elementIdPrefix: placement.divId,
+                      ownership: 'trusted_server',
+                      slot: candidate,
+                    }
+                  );
+                  committed = adopted.ok;
+                  return committed;
+                },
+                rollback: (): void => {
+                  if (!committed) return;
+                  committed = false;
+                  services.slots.recordPublisherDestruction(candidate);
+                },
+              });
+            }
+          );
+          if (defined.status === 'defined') {
+            physicalBySlot.set(
+              placement.slot,
+              Object.freeze({ operation: 'display', slot: defined.slot })
+            );
+          }
+        }
+      },
+      { signal: navigation.signal }
+    );
+    try {
+      await operation.result;
+    } catch (error) {
+      if (!navigation.signal.aborted) log.warn('GPT projection: slot binding failed', error);
+    }
+    if (!navigation.isCurrent()) return;
+    const batch = navigation.createAuctionBatch(`gpt:${projection.auction.auctionId}`);
+    if (!batch) return;
+    let winnerIndex = 0;
+    for (let index = 0; index < projection.auction.results.length; index += 1) {
+      const decision = projection.auction.results[index];
+      const placement = projection.slots[index];
+      if (!decision || !placement || decision.outcome !== 'winner') continue;
+      const bid = projection.bids[winnerIndex];
+      winnerIndex += 1;
+      if (!bid || !navigation.isCurrent()) continue;
+      if (!('rendererReservationId' in bid)) continue;
+      const owner = batch.createRenderAttempt(decision.slot);
+      if (!owner.ok) continue;
+      const created = prepared.createAttempt(owner.value);
+      if (!created.ok) continue;
+      const binding = physicalBySlot.get(decision.slot);
+      if (!binding) {
+        created.value.fail('slot_unresolved');
+        continue;
+      }
+      const artifact = Object.freeze({
+        kind: 'puc' as const,
+        attemptId: created.value.id,
+        slot: created.value.slot,
+        navigationGeneration: created.value.navigationGeneration,
+        dispose: () => undefined,
+      });
+      const published = await publishGptWinner({
+        artifact,
+        attempt: created.value,
+        bid,
+        createSlotOperation,
+        googletag: composition.adapters.googletag,
+        navigation,
+        operation: binding.operation,
+        owner: owner.value,
+        placement,
+        pucBridge: services.pucBridge,
+        requestClass,
+        reservations: services.reservations,
+        slot: binding.slot,
+        slots: services.slots,
+        targeting: services.targeting,
+        createFallback: (parentAttemptId) => {
+          const fallbackOwner = batch.createRenderAttempt(decision.slot);
+          if (!fallbackOwner.ok) {
+            return Object.freeze({
+              ok: false as const,
+              reason:
+                fallbackOwner.reason === 'identity_generation_failed'
+                  ? ('identity_generation_failed' as const)
+                  : fallbackOwner.reason === 'stale_owner'
+                    ? ('stale_owner' as const)
+                    : ('invalid_attempt' as const),
+            });
+          }
+          const fallback = prepared.createAttempt(fallbackOwner.value, parentAttemptId);
+          if (!fallback.ok) return fallback;
+          if (
+            !fallback.value.admitDirectWinner(
+              bid.renderSource,
+              Object.freeze({ selectedCpm: bid.cpm })
+            )
+          ) {
+            fallback.value.fail('winner_not_renderable');
+            return fallback;
+          }
+          if (!prepared.renderProjectedFallback(fallback.value)) {
+            fallback.value.fail('winner_not_renderable');
+          }
+          return fallback;
+        },
+      });
+      if (!published.ok && navigation.isCurrent()) {
+        log.warn('GPT projection: winner publication failed', published.reason);
+      }
+    }
+  };
+  const frozenSlotResult = (result: Record<string, unknown>): Readonly<Record<string, unknown>> =>
+    Object.freeze(result);
+  const combineRequestResults = (
+    requestedSlots: readonly string[],
+    records: readonly (SlotRecord | undefined)[],
+    validResults: readonly Readonly<Record<string, unknown>>[]
+  ): Readonly<{ slots: readonly Readonly<Record<string, unknown>>[] }> => {
+    let validIndex = 0;
+    return Object.freeze({
+      slots: Object.freeze(
+        requestedSlots.map((slot, index) => {
+          if (!records[index]) {
+            return frozenSlotResult({
+              slot,
+              path: 'primary',
+              outcome: 'failed',
+              reason: 'slot_unresolved',
+            });
+          }
+          const result = validResults[validIndex];
+          validIndex += 1;
+          return (
+            result ??
+            frozenSlotResult({
+              slot,
+              path: 'primary',
+              outcome: 'failed',
+              reason: 'internal_error',
+            })
+          );
+        })
+      ),
+    });
+  };
+  const registrationError = (reason: SlotRegistrationFailure): AdUnitRegistrationError => {
+    switch (reason) {
+      case 'invalid_slot_id':
+        return new AdUnitRegistrationError('invalid_code');
+      case 'registry_capacity':
+        return new AdUnitRegistrationError('registry_capacity');
+      case 'duplicate_slot':
+      case 'slot_quarantined':
+      case 'stale_owner':
+        return new AdUnitRegistrationError('slot_collision');
+    }
+  };
+  const addProgrammaticAdUnits = (candidate: unknown): unknown => {
+    const navigation = runtimeSession?.currentNavigation;
+    const slots = browserServices?.slots;
+    if (!navigation || !slots) throw new AdUnitRegistrationError('slot_collision');
+    let snapshot: readonly SlotRecord[] | undefined;
+    try {
+      snapshot = slots.snapshotRegisteredSlots(navigation);
+    } catch {
+      throw new AdUnitRegistrationError('slot_collision');
+    }
+    if (!snapshot) throw new AdUnitRegistrationError('slot_collision');
+    const knownSlots = new Set(snapshot.map(({ registeredSlotId }) => registeredSlotId));
+    const prepared = prepareProgrammaticAdUnits(candidate, knownSlots);
+    let registered: ReturnType<SlotService['register']>;
+    try {
+      registered = slots.register(
+        navigation,
+        prepared.map((unit) => ({
+          directAuctionUnit: unit,
+          registeredSlotId: unit.code,
+          source: 'programmatic' as const,
+        }))
+      );
+    } catch {
+      throw new AdUnitRegistrationError('slot_collision');
+    }
+    if (!registered.ok) throw registrationError(registered.reason);
+    return addAdUnitsResult(prepared);
+  };
+  const requestDirectAds = (candidate?: unknown): Promise<unknown> => {
+    let validated: ReturnType<typeof validateRequestAdsOptions>;
+    try {
+      validated = validateRequestAdsOptions(candidate);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const navigation = runtimeSession?.currentNavigation;
+    const slots = browserServices?.slots;
+    const snapshot = navigation && slots?.snapshotRegisteredSlots(navigation);
+    if (!navigation || !slots || !snapshot) {
+      const requested = validated.slots ?? Object.freeze([]);
+      return Promise.resolve(
+        Object.freeze({
+          slots: Object.freeze(
+            requested.map((slot) =>
+              frozenSlotResult({
+                slot,
+                path: 'primary',
+                outcome: 'cancelled',
+                reason: 'navigation_disposed',
+              })
+            )
+          ),
+        })
+      );
+    }
+
+    const recordsById = new Map(snapshot.map((record) => [record.registeredSlotId, record]));
+    const requestedSlots = Object.freeze(
+      validated.slots
+        ? Array.from(validated.slots)
+        : snapshot.map(({ registeredSlotId }) => registeredSlotId)
+    );
+    const selectedRecords = Object.freeze(requestedSlots.map((slot) => recordsById.get(slot)));
+    const validRecords = selectedRecords.filter(
+      (record): record is SlotRecord => record !== undefined
+    );
+    if (validRecords.length === 0) {
+      return Promise.resolve(combineRequestResults(requestedSlots, selectedRecords, []));
+    }
+
+    const context = auctionContextRegistry?.snapshot() ?? Object.freeze({});
+    const adUnits = validRecords.map((record) =>
+      record.directAuctionUnit
+        ? record.directAuctionUnit
+        : Object.freeze({
+            code: record.registeredSlotId,
+            mediaTypes: Object.freeze({}),
+            bids: Object.freeze([]),
+          })
+    );
+    let requestBody: string;
+    try {
+      const serialized = serializeAuctionRequestBody(adUnits, context);
+      if (!serialized) throw new Error('auction request body exceeds limit');
+      requestBody = serialized;
+    } catch {
+      return Promise.resolve(
+        combineRequestResults(
+          requestedSlots,
+          selectedRecords,
+          validRecords.map((record) =>
+            frozenSlotResult({
+              slot: record.registeredSlotId,
+              path: 'primary',
+              outcome: 'failed',
+              reason: 'internal_error',
+            })
+          )
+        )
+      );
+    }
+    const batches = auctionBatchService;
+    if (!batches) {
+      return Promise.resolve(
+        combineRequestResults(
+          requestedSlots,
+          selectedRecords,
+          validRecords.map((record) =>
+            frozenSlotResult({
+              slot: record.registeredSlotId,
+              path: 'primary',
+              outcome: 'cancelled',
+              reason: 'navigation_disposed',
+            })
+          )
+        )
+      );
+    }
+    const batch = batches.create({
+      navigation,
+      requestBody,
+      ...(validated.signal ? { signal: validated.signal } : {}),
+      slots: Object.freeze(validRecords.map(({ registeredSlotId }) => registeredSlotId)),
+      timeoutMs: validated.timeoutMs,
+    });
+    return batch.result.then((result) =>
+      combineRequestResults(requestedSlots, selectedRecords, result.slots)
+    );
+  };
+  const runtimeOwner = createRuntime({
+    ...runtimeOptions,
+    getBindings,
+    getDiagnosticsForPublish: diagnosticsForPublish,
+    kernel: {
+      addAdUnits: addProgrammaticAdUnits,
+      diagnostics: runtimeOptions.kernel.diagnostics,
+      requestAds: requestDirectAds,
+    },
+    prepareOwner: (context) => {
+      const boot = context.boot as unknown as AcceptedBrowserBoot;
+      creativeBoot = boot.creative;
+      diagnosticsBoot = boot.diagnostics;
+      const parseProjection = (candidate: unknown): object | undefined =>
+        parseBrowserAuctionProjectionV1(candidate);
+      const initialProjection = prepareInitialAuctionProjection(
+        boot.auctionProjection,
+        parseProjection
+      );
+      if (!initialProjection) throw new Error('Accepted boot projection is unavailable');
+      const preparedRenderTrace = createRenderTraceStore({
+        onPresentationError: (error) => log.warn('render diagnostics: presentation failed', error),
+        onSubscriberError: (error) => log.warn('render diagnostics: subscriber failed', error),
+      });
+      const preparedDiagnosticsIngress = createDiagnosticsIngress({
+        reduce: consumeCoreObservation,
+        reportError: (error) => log.warn('diagnostics ingress: reducer failed', error),
+      });
+      renderTrace = preparedRenderTrace;
+      diagnosticsIngress = preparedDiagnosticsIngress;
+      const preparedGptDiagnosticsFacts = boot.diagnostics.gpt.active
+        ? createGptDiagnosticsFactBuffer({
+            onConsumerError: (error) => log.warn('gpt diagnostics: fact consumer failed', error),
+          })
+        : undefined;
+      gptDiagnosticsFacts = preparedGptDiagnosticsFacts;
+      context.onDispose(() => {
+        preparedGptDiagnosticsFacts?.dispose();
+        preparedDiagnosticsIngress.dispose();
+        preparedRenderTrace.dispose();
+        if (gptDiagnosticsFacts === preparedGptDiagnosticsFacts) {
+          gptDiagnosticsFacts = undefined;
+        }
+        if (diagnosticsIngress === preparedDiagnosticsIngress) diagnosticsIngress = undefined;
+        if (renderTrace === preparedRenderTrace) renderTrace = undefined;
+      });
+      const reconciliation =
+        typeof document === 'undefined' || typeof MutationObserver === 'undefined'
+          ? undefined
+          : createBrowserSlotReconciliationBoundary(document, MutationObserver);
+      const artifacts = createCommittedArtifactStore();
+      const hostPositions = createArtifactHostPositionLeaseRegistry();
+      const slotService = createSlotService({
+        bindCommittedArtifactRetirement,
+        disposeCommittedArtifact: (navigationGeneration, registeredSlotId, expectedArtifact) => {
+          const artifact = artifacts.current(registeredSlotId);
+          if (
+            artifact === expectedArtifact &&
+            artifact.navigationGeneration === navigationGeneration
+          ) {
+            artifacts.release(artifact);
+          }
+        },
+        googletag: composition.adapters.googletag,
+        ...(reconciliation ? { reconciliation } : {}),
+        warnPublisherHandoffMismatch: (message, details) => log.warn(message, details),
+      });
+      const targetingService = createTargetingService();
+      const reservationService = createReservationService({
+        prepareRenderSource: (candidate) => {
+          const source = parseBidRenderSourceV1(candidate);
+          return source?.type === 'pbs_cache' ? undefined : source;
+        },
+      });
+      const bootstrapNonces = createBootstrapNonceRegistry();
+      const rendererNonces = createRendererNonceRegistry();
+      // A real document origin is authoritative. Only an opaque srcdoc may
+      // fall back to the server-stamped base; publisher script must not be able
+      // to redirect the APS endpoint by predefining that creative-only stamp.
+      const publisherOrigin = trustedDocumentHttpOrigin(window.location.origin);
+      if (!publisherOrigin) throw new Error('Trusted publisher origin is unavailable');
+      const rendererUrl = new URL(APS_RENDERER_V2_PATH, publisherOrigin).href;
+      const renderDirectAdm = Object.freeze(
+        (attempt: RenderAttempt, container: HTMLElement): boolean => {
+          try {
+            return renderDirectAdmAttempt({
+              attempt,
+              container,
+              prepareIframe: prepareAdmIframe,
+              publisherOrigin,
+            });
+          } catch {
+            return false;
+          }
+        }
+      );
+      const renderDirectAps = Object.freeze(
+        (attempt: RenderAttempt, container: HTMLElement): boolean => {
+          try {
+            return renderDirectApsAttempt({
+              attempt,
+              bindArtifactGuard: bindCommittedArtifactGuard,
+              bootstrapNonces,
+              container,
+              messaging: composition.adapters.messaging,
+              nonces: rendererNonces,
+              publisherOrigin,
+            });
+          } catch {
+            return false;
+          }
+        }
+      );
+      const resolveDirectContainer = (record: SlotRecord): HTMLElement | undefined => {
+        try {
+          if (typeof document === 'undefined') return undefined;
+          const identifiers =
+            record.source === 'programmatic'
+              ? new Set([record.registeredSlotId])
+              : new Set(record.domAliases);
+          if (identifiers.size === 0) return undefined;
+          const matches = new Set<HTMLElement>();
+          const elements = document.querySelectorAll('[id]');
+          for (let index = 0; index < elements.length; index += 1) {
+            const element = elements.item(index);
+            if (element instanceof HTMLElement && identifiers.has(element.id)) {
+              matches.add(element);
+            }
+          }
+          return matches.size === 1 ? Array.from(matches)[0] : undefined;
+        } catch {
+          return undefined;
+        }
+      };
+      const fetchAuction = compositionOptions.auctionFetcherForTest ?? globalThis.fetch;
+      const createOwnedAttempt = (owner: RenderAttemptScope, parentAttemptId?: string) =>
+        createRenderAttempt({
+          artifacts,
+          owner,
+          ...(parentAttemptId === undefined ? {} : { parentAttemptId }),
+          prepareRenderSource: (candidate) => {
+            const source = parseBidRenderSourceV1(candidate);
+            return source && source.type !== 'pbs_cache' ? Object.freeze(source) : undefined;
+          },
+          publishDiagnostics: preparedDiagnosticsIngress.publish,
+          reservations: reservationService,
+        });
+      const renderProjectedFallback = (attempt: RenderAttempt): boolean => {
+        const record = slotService.resolveRegisteredSlot(attempt.slot);
+        const container = record && resolveDirectContainer(record);
+        if (!container) {
+          attempt.fail('slot_unresolved');
+          return false;
+        }
+        if (attempt.renderSource?.type === 'aps') return renderDirectAps(attempt, container);
+        if (attempt.renderSource?.type === 'adm') return renderDirectAdm(attempt, container);
+        attempt.fail('winner_not_renderable');
+        return false;
+      };
+      const batchCoordinator = createAuctionBatchService({
+        createAttempt: createOwnedAttempt,
+        fetcher: (input, init) => {
+          if (typeof fetchAuction !== 'function') return Promise.reject(new Error('unavailable'));
+          return fetchAuction(input, init);
+        },
+        parseResponse: parseTrustedServerAuctionResponseV1,
+        renderWinner: renderProjectedFallback,
+      });
+      const services = Object.freeze({
+        artifacts,
+        auctionBatches: batchCoordinator,
+        bootstrapNonces,
+        hostPositions,
+        reservations: reservationService,
+        rendererNonces,
+        renderDirectAdm,
+        renderDirectAps,
+        slots: slotService,
+        targeting: targetingService,
+      });
+      preparedBrowserServices = Object.freeze({
+        createAttempt: createOwnedAttempt,
+        publisherOrigin,
+        renderProjectedFallback,
+        rendererUrl,
+        services,
+      });
+      const session = createRuntimeSession({
+        createIdentityIssuer:
+          compositionOptions.createIdentityIssuerForTest ?? createBrowserNavigationIdentityIssuer,
+        interfaces: Object.freeze({
+          adapters: composition.adapters,
+          creative: creativeRuntime,
+          datadome: dataDomeRuntime,
+          didomi: didomiRuntime,
+          google_tag_manager: googleTagManagerRuntime,
+          ...(preparedGptDiagnosticsFacts
+            ? {
+                'gpt.events.v1': Object.freeze({
+                  subscribe: preparedGptDiagnosticsFacts.activate,
+                }),
+              }
+            : {}),
+          'trace.v1': Object.freeze({
+            record: preparedRenderTrace.record,
+            enrich: preparedRenderTrace.enrich,
+            prune: preparedRenderTrace.prune,
+            diagnostics: preparedRenderTrace.diagnostics,
+            observations: Object.freeze({
+              publish: preparedDiagnosticsIngress.publish,
+            }),
+          }),
+          'trace.presentation.v1': Object.freeze({
+            attachPresentation: preparedRenderTrace.attachPresentation,
+          }),
+          gpt: gptIntegrationRuntime,
+          lockr: lockrRuntime,
+          osano_consent: osanoConsentRuntime,
+          osano_lifecycle: osanoLifecycleRuntime,
+          permutive_context: permutiveContextRuntime,
+          permutive_lifecycle: permutiveLifecycleRuntime,
+          prebid: prebidRuntime,
+          sourcepoint_consent: sourcepointConsentRuntime,
+          sourcepoint_lifecycle: sourcepointLifecycleRuntime,
+          testlight: testlightRuntime,
+          ...services,
+        }),
+        onNavigationDispose: (navigationGeneration) => {
+          artifacts.disposeNavigation(navigationGeneration);
+          preparedRenderTrace.pruneNavigation(navigationGeneration);
+          for (const registeredSlotId of renderTraceSlotsByNavigation.get(navigationGeneration) ??
+            []) {
+            preparedRenderTrace.prune(registeredSlotId);
+          }
+          renderTraceSlotsByNavigation.delete(navigationGeneration);
+        },
+      });
+      context.onDispose(() => {
+        batchCoordinator.dispose();
+        session.dispose();
+        artifacts.dispose();
+        reservationService.dispose();
+        bootstrapNonces.dispose();
+        rendererNonces.dispose();
+        slotService.dispose();
+        targetingService.dispose();
+        composition.adapters.googletag.dispose();
+        composition.adapters.prebid.dispose();
+        if (runtimeSession === session) {
+          runtimeSession = undefined;
+          preparedBrowserServices = undefined;
+          browserServices = undefined;
+          auctionBatchService = undefined;
+          auctionContextRegistry = undefined;
+          projectionParser = undefined;
+          creativeBoot = undefined;
+          diagnosticsBoot = undefined;
+          renderTraceSlotsByNavigation.clear();
+        }
+      });
+      const navigation = session.startInitialNavigation(initialProjection);
+      if (!navigation.ok) throw new Error(navigation.reason);
+
+      const acceptedInitialProjection = initialProjection as Readonly<BrowserAuctionProjectionV1>;
+      const initialRegistrations = [
+        ...acceptedInitialProjection.slots.map((placement) => ({
+          domAliases: Object.freeze([placement.divId]),
+          registeredSlotId: placement.slot,
+          source: 'server' as const,
+        })),
+        ...(compositionOptions.admittedProgrammaticSlotsForTest ?? []).map((registeredSlotId) => ({
+          registeredSlotId,
+          source: 'programmatic' as const,
+        })),
+      ];
+      if (!slotService.register(navigation.value, initialRegistrations).ok) {
+        throw new Error('Initial slots exceed the shared registry');
+      }
+      const contextRegistry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(boot.manifest.integrations.map(({ id }) => id)),
+        onContributorFailure: (failure) => log.warn('auction context: contributor failed', failure),
+        runtimeOwner: session,
+      });
+      runtimeSession = session;
+      auctionBatchService = batchCoordinator;
+      auctionContextRegistry = contextRegistry;
+      projectionParser = parseProjection;
+      return runtimeOptions.prepareOwner?.(context);
+    },
+    activateCore: (context) => {
+      const prepared = preparedBrowserServices;
+      if (!prepared) throw new Error('Browser services are unavailable');
+      const facts = gptDiagnosticsFacts;
+      const ingress = diagnosticsIngress;
+      const pucBridge = createPucBridge({
+        messaging: composition.adapters.messaging,
+        mintLifecycleTicket: mintBrowserLifecycleTicket,
+        mountAps: (input) =>
+          renderPucApsAttempt({
+            ...input,
+            bindArtifactGuard: bindCommittedArtifactGuard,
+            bootstrapNonces: prepared.services.bootstrapNonces,
+            hostPositions: prepared.services.hostPositions,
+            messaging: composition.adapters.messaging,
+            nonces: prepared.services.rendererNonces,
+            publisherOrigin: prepared.publisherOrigin,
+          }),
+        ...(compositionOptions.pucSchedulerForTest
+          ? { scheduler: compositionOptions.pucSchedulerForTest }
+          : {}),
+        reservations: prepared.services.reservations,
+        resizeCollapsedShell: resizeCollapsedPucShell,
+        slots: prepared.services.slots,
+      });
+      context.onDispose(() => pucBridge.dispose());
+      browserServices = Object.freeze({ ...prepared.services, pucBridge });
+      gptProjectionPublisher = (navigation, projection, requestClass): void => {
+        void publishProjectionThroughGpt(navigation, projection, requestClass).catch((error) => {
+          if (navigation.isCurrent()) log.warn('GPT projection: coordinator failed', error);
+        });
+      };
+      context.onDispose(() => {
+        gptProjectionPublisher = noopGptProjectionPublisher;
+      });
+      const coordinator = createPrebidSelectionCoordinator({
+        activateAttempt: ({ attempt, owner, preparedBid }): boolean => {
+          const artifact = Object.freeze({
+            kind: 'puc' as const,
+            attemptId: attempt.id,
+            slot: attempt.slot,
+            navigationGeneration: attempt.navigationGeneration,
+            dispose: () => undefined,
+          });
+          const input = Object.freeze({
+            artifact,
+            attempt,
+            owner,
+            reservationId: preparedBid.bid.adId,
+          });
+          return pucBridge.registerGamAttempt(input);
+        },
+        createAttempt: prepared.createAttempt,
+        reservations: prepared.services.reservations,
+      });
+      prebidCoordinator = coordinator;
+      context.onDispose(() => {
+        coordinator.dispose();
+        if (prebidCoordinator === coordinator) prebidCoordinator = undefined;
+      });
+      browserServices.slots.activate();
+      browserServices.slots.start();
+      if (facts && ingress) {
+        const releaseCapture = activateGptDiagnosticsFactCapture(
+          composition.adapters.googletag,
+          Object.freeze({
+            publish: (fact: Readonly<GoogletagDiagnosticsFact>): boolean => {
+              const projected = projectGptTraceFact(fact);
+              if (projected) ingress.publish(projected);
+              return facts.publish(fact);
+            },
+          })
+        );
+        if (!releaseCapture) throw new Error('GPT diagnostics capture is unavailable');
+        context.onDispose(releaseCapture);
+      }
+      compositionOptions.coreActivations?.correctnessGptListeners(
+        context,
+        composition.adapters,
+        browserServices
+      );
+      return runtimeOptions.activateCore?.(context);
+    },
+  });
+  return Object.freeze({
+    adapters: composition.adapters,
+    runtime: runtimeOwner,
+    createDiagnosticsCapabilityProviderRegistrationForTest: () => {
+      const prepare = () => {
+        const facts = gptDiagnosticsFacts;
+        const trace = renderTrace;
+        const observations = diagnosticsIngress;
+        if (!facts || !trace || !observations) {
+          throw new TypeError('Test diagnostics capabilities are unavailable');
+        }
+        return Object.freeze({
+          activate: () => undefined,
+          interfaces: Object.freeze({
+            'gpt.events.v1': Object.freeze({ subscribe: facts.activate }),
+            'trace.v1': Object.freeze({
+              record: trace.record,
+              enrich: trace.enrich,
+              prune: trace.prune,
+              diagnostics: trace.diagnostics,
+              observations: Object.freeze({
+                publish: observations.publish,
+              }),
+            }),
+            'trace.presentation.v1': Object.freeze({
+              attachPresentation: trace.attachPresentation,
+            }),
+          }),
+        });
+      };
+      return Object.freeze({
+        abi: 1,
+        id: BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID,
+        phase: 'takeover',
+        releaseId: runtimeOptions.releaseId,
+        prepareSync: prepare,
+        prepare,
+      });
+    },
+    createTraceCapabilityProviderRegistrationForTest: () => {
+      const prepare = () => {
+        const trace = renderTrace;
+        const observations = diagnosticsIngress;
+        if (!trace || !observations) {
+          throw new TypeError('Test trace capability is unavailable');
+        }
+        return Object.freeze({
+          activate: () => undefined,
+          interfaces: Object.freeze({
+            'trace.v1': Object.freeze({
+              record: trace.record,
+              enrich: trace.enrich,
+              prune: trace.prune,
+              diagnostics: trace.diagnostics,
+              observations: Object.freeze({
+                publish: observations.publish,
+              }),
+            }),
+            'trace.presentation.v1': Object.freeze({
+              attachPresentation: trace.attachPresentation,
+            }),
+          }),
+        });
+      };
+      return Object.freeze({
+        abi: 1,
+        id: BROWSER_TEST_TRACE_PROVIDER_ID,
+        phase: 'takeover',
+        releaseId: runtimeOptions.releaseId,
+        prepareSync: prepare,
+        prepare,
+      });
+    },
+    runtimeSessionForTest: () => runtimeSession,
+    pageBidsControllerForTest: (): PageBidsController | undefined => {
+      const navigation = runtimeSession?.currentNavigation;
+      if (!navigation || !browserServices || !projectionParser) return undefined;
+      return createPageBidsController({
+        navigation,
+        parseProjection: projectionParser,
+        slotRegistry: browserServices.slots.projectionRegistry(navigation),
+      });
+    },
+    projectionSlotsForTest: () => browserServices?.slots.registeredSlotIdsForTest(),
+    auctionContextRegistryForTest: () => auctionContextRegistry,
+    slotServiceForTest: () => browserServices?.slots,
+    targetingServiceForTest: () => browserServices?.targeting,
+    reservationServiceForTest: () => browserServices?.reservations,
+    rendererNonceRegistryForTest: () => browserServices?.rendererNonces,
+    pucBridgeForTest: () => browserServices?.pucBridge,
+    publishGptWinnerForTest: (
+      input: Omit<
+        GptWinnerPublicationInput,
+        | 'createSlotOperation'
+        | 'googletag'
+        | 'navigation'
+        | 'pucBridge'
+        | 'reservations'
+        | 'slots'
+        | 'targeting'
+      >
+    ): Promise<GptWinnerPublicationResult> => {
+      const services = browserServices;
+      const navigation = runtimeSession?.currentNavigation;
+      if (!services || !navigation) {
+        return Promise.resolve(Object.freeze({ ok: false, reason: 'gpt_request_failed' }));
+      }
+      return publishGptWinner({
+        ...input,
+        createSlotOperation,
+        googletag: composition.adapters.googletag,
+        navigation,
+        pucBridge: services.pucBridge,
+        reservations: services.reservations,
+        slots: services.slots,
+        targeting: services.targeting,
+      });
+    },
+    startGptSlotOperationForTest: (
+      input: Omit<GptSlotOperationInput, 'createSlotOperation' | 'pucBridge' | 'slots'>
+    ): SlotOperationCreationResult => {
+      const services = browserServices;
+      if (!services) return Object.freeze({ ok: false, reason: 'invalid_attempt' });
+      return startGptSlotOperation({
+        ...input,
+        createSlotOperation,
+        pucBridge: services.pucBridge,
+        slots: services.slots,
+      });
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/composition/browser_test_gpt_diagnostics.ts b/crates/trusted-server-js/lib/src/composition/browser_test_gpt_diagnostics.ts
new file mode 100644
index 000000000..e9e362bab
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/composition/browser_test_gpt_diagnostics.ts
@@ -0,0 +1,94 @@
+import type { GptDiagnosticsApi } from '../core/types';
+import { GptDiagnosticsApiController } from '../integrations/gpt_diagnostics/api';
+import { GptDiagnosticsBadgeManager } from '../integrations/gpt_diagnostics/badges';
+import { GptDiagnosticsBindingManager } from '../integrations/gpt_diagnostics/binding';
+import type { GptDiagnosticsFactBuffer } from '../integrations/gpt/diagnostics_facts';
+import { GptDiagnosticsObserver } from '../integrations/gpt_diagnostics/observer';
+import { GptDiagnosticsOverlay } from '../integrations/gpt_diagnostics/overlay';
+import { GptDiagnosticsStore } from '../integrations/gpt_diagnostics/store';
+
+type GptDiagnosticsWindow = Window & typeof globalThis;
+
+export interface GptDiagnosticsRuntimeOptions {
+  readonly document?: Document | undefined;
+  readonly window?: GptDiagnosticsWindow | undefined;
+}
+
+export interface GptDiagnosticsRuntime {
+  readonly activate: () => () => void;
+  readonly currentApi: () => GptDiagnosticsApi | undefined;
+}
+
+function isolate(callback: () => void): void {
+  try {
+    callback();
+  } catch {
+    // Test-composition cleanup cannot retain another independently owned resource.
+  }
+}
+
+/** Legacy-composition harness excluded from every production artifact entry. */
+export function createGptDiagnosticsRuntime(
+  facts: Pick<GptDiagnosticsFactBuffer, 'activate'>,
+  options: GptDiagnosticsRuntimeOptions = {}
+): GptDiagnosticsRuntime {
+  const targetWindow = options.window ?? (window as GptDiagnosticsWindow);
+  const targetDocument = options.document ?? document;
+  let active: Readonly<{ api: GptDiagnosticsApi; release: () => void }> | undefined;
+  return Object.freeze({
+    activate: (): (() => void) => {
+      if (active) throw new Error('GPT diagnostics runtime is already active');
+      const store = new GptDiagnosticsStore();
+      const observer = new GptDiagnosticsObserver(store);
+      let releaseFacts: (() => void) | undefined;
+      let bindings: GptDiagnosticsBindingManager | undefined;
+      let badges: GptDiagnosticsBadgeManager | undefined;
+      let overlay: GptDiagnosticsOverlay | undefined;
+      let apiController: GptDiagnosticsApiController | undefined;
+      const cleanup = (): void => {
+        isolate(() => releaseFacts?.());
+        isolate(() => apiController?.destroy());
+        isolate(() => overlay?.destroy());
+        isolate(() => badges?.destroy());
+        isolate(() => bindings?.destroy());
+      };
+      try {
+        observer.start();
+        releaseFacts = facts.activate((fact) => observer.consume(fact));
+        if (!releaseFacts) throw new Error('GPT diagnostics fact consumer is unavailable');
+        bindings = new GptDiagnosticsBindingManager(store, {
+          window: targetWindow,
+          document: targetDocument,
+        });
+        badges = new GptDiagnosticsBadgeManager(store, bindings, {
+          window: targetWindow,
+          document: targetDocument,
+        });
+        overlay = new GptDiagnosticsOverlay(store, bindings, {
+          window: targetWindow,
+          document: targetDocument,
+          onExport: () => apiController?.api.export(),
+          onBadgeLayerChange: (layer) => badges?.setLayer(layer),
+        });
+        apiController = new GptDiagnosticsApiController(store, bindings, overlay, {
+          window: targetWindow,
+          document: targetDocument,
+        });
+      } catch (error) {
+        cleanup();
+        throw error;
+      }
+      const api = apiController.api;
+      let released = false;
+      const release = (): void => {
+        if (released) return;
+        released = true;
+        if (active?.release === release) active = undefined;
+        cleanup();
+      };
+      active = Object.freeze({ api, release });
+      return release;
+    },
+    currentApi: (): GptDiagnosticsApi | undefined => active?.api,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/composition/runtime_transport.ts b/crates/trusted-server-js/lib/src/composition/runtime_transport.ts
new file mode 100644
index 000000000..baee20201
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/composition/runtime_transport.ts
@@ -0,0 +1,23 @@
+import { startProductionRuntime } from '../core/index';
+import { EMBEDDED_RELEASE_ID, EMBEDDED_RUNTIME_CATALOG } from '../core/release';
+import { createRenderRuntimeIntegrationRegistration } from '../integrations/render_runtime/module';
+import { createRuntime, type RuntimeOptions } from '../kernel/runtime';
+
+const createRuntimeComposition = (runtimeOptions: RuntimeOptions) =>
+  Object.freeze({
+    runtime: createRuntime({
+      ...runtimeOptions,
+      catalog: EMBEDDED_RUNTIME_CATALOG,
+    }),
+  });
+
+if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+  startProductionRuntime(createRuntimeComposition);
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createRenderRuntimeIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/auction.ts b/crates/trusted-server-js/lib/src/core/auction.ts
index a02684362..55ecf0d26 100644
--- a/crates/trusted-server-js/lib/src/core/auction.ts
+++ b/crates/trusted-server-js/lib/src/core/auction.ts
@@ -2,10 +2,35 @@
 // and parses OpenRTB seatbid responses. Used by both the core requestAds flow
 // and the Prebid.js trustedServer adapter.
 
-import { parseApsRendererDescriptor } from '../integrations/aps/render';
-
+import { parseApsRendererDescriptor } from './contracts/aps_renderer';
+import {
+  MAX_AUCTION_RESULTS,
+  MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+  isAuctionCandidateIdV1,
+  isAuctionProviderIdV1,
+  isRendererReservationIdV1,
+  jsonUtf8ByteLength,
+  ownDataArray,
+  ownDataObject,
+  parseAuctionDecisionSetV1 as parseDecisionSet,
+  parseBidRenderSourceV1 as parseRenderSource,
+  validBoundedString,
+  validDimension,
+} from './contracts/auction_projection';
 import { log } from './log';
-import type { ApsRendererV1 } from './types';
+import type {
+  ApsRendererV1,
+  AuctionDecisionSetV1,
+  BidRenderSourceV1,
+  BrowserAuctionProjectionV1,
+  SlotAuctionDecisionV1,
+} from './types';
+
+export {
+  MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+  isRendererReservationIdV1,
+  parseBrowserAuctionProjectionV1,
+} from './contracts/auction_projection';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -45,9 +70,9 @@ export interface AuctionBid {
   /** Matches the `impid` in the response — corresponds to adUnit `code`. */
   impid: string;
   /** Creative HTML (already rewritten with proxy URLs by the server). */
-  adm: string;
+  adm?: string | undefined;
   /** Typed APS renderer descriptor, when the bid does not carry `adm`. */
-  renderer?: ApsRendererV1;
+  renderer?: ApsRendererV1 | undefined;
   /** CPM price. */
   price: number;
   /** Creative width. */
@@ -60,6 +85,203 @@ export interface AuctionBid {
   creativeId: string;
   /** Advertiser domains. */
   adomain: string[];
+  /** Server-side auction ID used for render tracing. */
+  auctionId?: string | undefined;
+  /** Upstream OpenRTB bid ID used for render tracing. */
+  bidId?: string | undefined;
+  /** Trace hash of the delivered creative markup. */
+  admHash?: string | undefined;
+}
+
+interface TrustedServerAuctionBidBaseV1 {
+  candidateId: string;
+  impid: string;
+  provider: string;
+  price: number;
+  width: number;
+  height: number;
+}
+
+export type TrustedServerAuctionBidV1 =
+  | (TrustedServerAuctionBidBaseV1 & {
+      rendererReservationId: string;
+      renderSource: Exclude<BidRenderSourceV1, { type: 'pbs_cache' }>;
+      adm?: string | undefined;
+    })
+  | (TrustedServerAuctionBidBaseV1 & {
+      renderSource: Extract<BidRenderSourceV1, { type: 'pbs_cache' }>;
+    });
+
+export interface TrustedServerAuctionResponseV1 {
+  auction: AuctionDecisionSetV1;
+  bids: TrustedServerAuctionBidV1[];
+}
+
+/* Projection and render-source contracts live in core/contracts/auction_projection.ts. */
+
+/** Parse the coordinated-cutover `/auction` wire without activating it in production yet. */
+export function parseTrustedServerAuctionResponseV1(
+  value: unknown
+): TrustedServerAuctionResponseV1 | undefined {
+  const body = ownDataObject(value, ['id', 'seatbid', 'cur', 'ext']);
+  if (!body || typeof body.id !== 'string' || body.cur !== 'USD') return undefined;
+  const responseExt = ownDataObject(body.ext, ['trusted_server']);
+  const trustedResponseExt = ownDataObject(responseExt?.trusted_server, ['slot_results']);
+  const auction = parseDecisionSet(trustedResponseExt?.slot_results);
+  const seatbids = ownDataArray(body.seatbid, MAX_AUCTION_RESULTS);
+  if (!auction || body.id !== auction.auctionId || !seatbids) return undefined;
+
+  const bids: TrustedServerAuctionBidV1[] = [];
+  for (const rawSeat of seatbids) {
+    const seat = ownDataObject(rawSeat, ['seat', 'bid']);
+    if (!seat || !isAuctionProviderIdV1(seat.seat)) return undefined;
+    const rawBids = ownDataArray(seat.bid, MAX_AUCTION_RESULTS - bids.length);
+    if (!rawBids || rawBids.length === 0) return undefined;
+    for (const rawBid of rawBids) {
+      const rawBidRecord = ownDataObject(rawBid);
+      if (!rawBidRecord) return undefined;
+      const bid = ownDataObject(rawBid, [
+        'id',
+        'impid',
+        'price',
+        ...(Object.prototype.hasOwnProperty.call(rawBidRecord, 'adm') ? ['adm'] : []),
+        'w',
+        'h',
+        'ext',
+      ]);
+      const extension = ownDataObject(bid?.ext, ['trusted_server']);
+      const trusted = ownDataObject(extension?.trusted_server, [
+        'candidate_id',
+        'slot_id',
+        'render_source',
+      ]);
+      if (
+        !bid ||
+        !trusted ||
+        !validBoundedString(bid.impid, 256) ||
+        !isAuctionCandidateIdV1(trusted.candidate_id) ||
+        trusted.slot_id !== bid.impid ||
+        typeof bid.price !== 'number' ||
+        !Number.isFinite(bid.price) ||
+        bid.price < 0 ||
+        typeof bid.w !== 'number' ||
+        typeof bid.h !== 'number'
+      ) {
+        return undefined;
+      }
+      const renderSource = parseRenderSource(trusted.render_source);
+      if (!renderSource || renderSource.width !== bid.w || renderSource.height !== bid.h) {
+        return undefined;
+      }
+      if (
+        (renderSource.type === 'pbs_cache' && bid.id !== renderSource.cacheId) ||
+        (renderSource.type !== 'pbs_cache' &&
+          (!isRendererReservationIdV1(bid.id) || !validDimension(bid.w) || !validDimension(bid.h)))
+      ) {
+        return undefined;
+      }
+      if (
+        (renderSource.type === 'adm' &&
+          Object.prototype.hasOwnProperty.call(bid, 'adm') &&
+          bid.adm !== renderSource.adm) ||
+        (renderSource.type !== 'adm' && Object.prototype.hasOwnProperty.call(bid, 'adm'))
+      ) {
+        return undefined;
+      }
+      const base = {
+        candidateId: trusted.candidate_id,
+        impid: bid.impid,
+        provider: seat.seat,
+        price: bid.price,
+        width: bid.w,
+        height: bid.h,
+      };
+      if (renderSource.type === 'pbs_cache') {
+        bids.push({ ...base, renderSource });
+      } else {
+        bids.push({
+          ...base,
+          rendererReservationId: bid.id as string,
+          renderSource,
+          ...(renderSource.type === 'adm' ? { adm: renderSource.adm } : {}),
+        });
+      }
+    }
+  }
+
+  const winners = auction.results.filter(
+    (result): result is Extract<SlotAuctionDecisionV1, { outcome: 'winner' }> =>
+      result.outcome === 'winner'
+  );
+  const candidates = new Set<string>();
+  const reservations = new Set<string>();
+  if (
+    winners.length !== bids.length ||
+    bids.some((bid) => {
+      if (
+        candidates.has(bid.candidateId) ||
+        ('rendererReservationId' in bid && reservations.has(bid.rendererReservationId))
+      ) {
+        return true;
+      }
+      candidates.add(bid.candidateId);
+      if ('rendererReservationId' in bid) reservations.add(bid.rendererReservationId);
+      const winner = winners.find((entry) => entry.candidateId === bid.candidateId);
+      return !winner || winner.slot !== bid.impid;
+    }) ||
+    winners.some((winner) => !bids.some((bid) => bid.candidateId === winner.candidateId))
+  ) {
+    return undefined;
+  }
+
+  const bidsByCandidate = new Map(bids.map((bid) => [bid.candidateId, bid]));
+  const orderedBids: TrustedServerAuctionBidV1[] = [];
+  for (const winner of winners) {
+    const bid = bidsByCandidate.get(winner.candidateId);
+    if (!bid) return undefined;
+    orderedBids.push(bid);
+  }
+
+  const canonicalBids: BrowserAuctionProjectionV1['bids'] = [];
+  for (let index = 0; index < orderedBids.length; index += 1) {
+    const bid = orderedBids[index];
+    if (!bid) return undefined;
+    const base = {
+      candidateId: bid.candidateId,
+      slot: bid.impid,
+      provider: bid.provider,
+      cpm: bid.price,
+      currency: 'USD' as const,
+      targeting: {},
+    };
+    if (!('rendererReservationId' in bid)) {
+      canonicalBids.push({
+        ...base,
+        upstreamBidId: bid.renderSource.cacheId,
+        renderSource: bid.renderSource,
+      });
+    } else {
+      canonicalBids.push({
+        ...base,
+        upstreamBidId:
+          bid.renderSource.type === 'aps' ? bid.renderSource.bidId : bid.rendererReservationId,
+        rendererReservationId: bid.rendererReservationId,
+        renderSource: bid.renderSource,
+      });
+    }
+  }
+  const canonicalProjection: BrowserAuctionProjectionV1 = {
+    version: 1,
+    auction,
+    // Direct `/auction` units are programmatic DOM placements, not GAM slots.
+    slots: [],
+    bids: canonicalBids,
+  };
+  if (jsonUtf8ByteLength(canonicalProjection) > MAX_BROWSER_AUCTION_PROJECTION_BYTES) {
+    return undefined;
+  }
+
+  return { auction, bids: orderedBids };
 }
 
 // ---------------------------------------------------------------------------
@@ -69,7 +291,7 @@ export interface AuctionBid {
 /**
  * Build an {@link AdRequest} from an array of ad-unit-like objects.
  *
- * Accepts both plain tsjs `AdUnit` objects and Prebid-style `BidRequest`
+ * Accepts direct-auction programmatic units and Prebid-style `BidRequest`
  * objects (which carry `adUnitCode` instead of `code`).
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
diff --git a/crates/trusted-server-js/lib/src/core/bootstrap.ts b/crates/trusted-server-js/lib/src/core/bootstrap.ts
new file mode 100644
index 000000000..ff687b481
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/bootstrap.ts
@@ -0,0 +1,903 @@
+declare const __TSJS_SERVER_BOOT_TRANSPORT_V1__: unknown;
+
+import {
+  prepareFirstDisplayBase,
+  type FirstDisplayAgent,
+  type FirstDisplayAgentRegistrationHostV1,
+} from '../first_display/agent';
+import {
+  registerFirstDisplayBrowserRoute,
+  type FirstDisplayBrowserRouteRuleV1,
+} from '../first_display/leaf/browser_route_owner';
+import type { InitialSliceInstaller } from '../first_display/slices/definition';
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+import type { FirstDisplaySliceActivationContext } from '../shared/first_display_transaction';
+import type { FirstDisplayAgentCaptureFinalizerV1 } from '../shared/first_display_handoff';
+import type { ClaimedFirstDisplayTakeoverV1, FirstDisplayTakeoverClaim } from '../shared/takeover';
+
+import {
+  deepFreezeTransportV1,
+  snapshotServerBootTransportV1,
+  type ServerBootTransportSnapshotV1,
+} from './contracts/server_boot_transport';
+import { EMBEDDED_RELEASE_ID } from './release_id';
+
+const RELEASE = EMBEDDED_RELEASE_ID;
+
+interface ComponentRegistration {
+  readonly id: Exclude<FirstDisplaySliceId, 'first_display'>;
+  readonly install: InitialSliceInstaller;
+}
+
+type BootstrapTarget = object & { boot?: unknown; que?: unknown };
+
+interface BootstrapInputSnapshotV1 extends ServerBootTransportSnapshotV1 {
+  readonly target: BootstrapTarget;
+}
+
+type BootFailureReason = 'abi_mismatch' | 'bundle_partial';
+type BootClaimOutcome = 'kernel' | BootFailureReason;
+
+class RuntimeUnavailableError extends Error {
+  public readonly code = 'runtime_unavailable';
+
+  public constructor(
+    public readonly releaseId: string,
+    public readonly reason: BootFailureReason
+  ) {
+    super('TSJS runtime is unavailable');
+    this.name = 'TsjsUnavailableError';
+  }
+}
+
+function prepareIngress(target: BootstrapTarget): unknown[] {
+  const descriptor = Object.getOwnPropertyDescriptor(target, 'que');
+  const previous =
+    descriptor && 'value' in descriptor && Array.isArray(descriptor.value) ? descriptor.value : [];
+  const queue = Object.isExtensible(previous) ? previous : previous.slice();
+  Object.defineProperty(queue, 'push', {
+    configurable: true,
+    value: Array.prototype.push,
+    writable: true,
+  });
+  Object.defineProperty(target, 'que', {
+    configurable: true,
+    enumerable: true,
+    value: queue,
+    writable: false,
+  });
+  return queue;
+}
+
+function fallbackFields(
+  boot: BootstrapInputSnapshotV1['boot'],
+  reason: BootFailureReason,
+  initialDisplayCommitted: boolean
+): Readonly<Record<string, unknown>> {
+  const unavailable = (): never => {
+    throw new RuntimeUnavailableError(RELEASE, reason);
+  };
+  const safeBoot = {
+    abi: 1,
+    releaseId: RELEASE,
+    manifest: {
+      version: 1,
+      releaseId: RELEASE,
+      firstDisplay: boot.manifest.firstDisplay,
+      runtimeSrc: boot.manifest.runtimeSrc,
+      integrations: [],
+    },
+    auctionProjection: {
+      version: 1,
+      auction: { version: 1, auctionId: 'fallback', results: [] },
+      slots: [],
+      bids: [],
+    },
+    integrations: { version: 1, entries: [] },
+    creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+    diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+  };
+  deepFreezeTransportV1(safeBoot);
+  let level = 'warn';
+  const levels = ['silent', 'error', 'warn', 'info', 'debug'];
+  const observe = (..._values: readonly unknown[]): void => undefined;
+  const fields: Record<string, unknown> = {
+    version: '1.0.0',
+    releaseId: RELEASE,
+    boot: safeBoot,
+    log: Object.freeze({
+      setLevel: (value: string) => {
+        if (!levels.includes(value)) throw new TypeError('Invalid TSJS log level');
+        level = value;
+      },
+      getLevel: () => level,
+      error: observe,
+      warn: observe,
+      info: observe,
+      debug: observe,
+    }),
+    _registerIntegration: () => false,
+    addAdUnits: unavailable,
+    requestAds: async (): Promise<never> => unavailable(),
+  };
+  Object.defineProperty(fields, '_internal', {
+    value: Object.freeze({
+      state: 'fallback',
+      releaseId: RELEASE,
+      reason,
+      initialDisplayCommitted,
+    }),
+  });
+  return Object.freeze(fields);
+}
+
+function publishFallback(
+  target: BootstrapInputSnapshotV1['target'],
+  ingress: unknown[],
+  fields: Readonly<Record<string, unknown>>
+): boolean {
+  try {
+    const fieldNames = Object.getOwnPropertyNames(fields);
+    for (const name of Object.getOwnPropertyNames(target)) {
+      if (!Object.getOwnPropertyDescriptor(target, name)?.configurable) return false;
+    }
+    const callbacks: Array<() => void> = [];
+    for (let index = 0; index < ingress.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(ingress, String(index));
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
+        callbacks.push(descriptor.value as () => void);
+      }
+    }
+    const invoke = (callback: unknown): number => {
+      if (typeof callback === 'function') {
+        try {
+          Reflect.apply(callback, target, []);
+        } catch {
+          // One publisher callback cannot block the remaining queue.
+        }
+      }
+      return 0;
+    };
+    const queue: unknown[] = [];
+    Object.defineProperty(queue, 'push', { value: invoke });
+    Object.freeze(queue);
+    ingress.length = 0;
+    Object.defineProperty(ingress, 'push', { value: invoke });
+    Object.freeze(ingress);
+    for (const name of Object.getOwnPropertyNames(target)) Reflect.deleteProperty(target, name);
+    for (const name of fieldNames) {
+      const descriptor = Object.getOwnPropertyDescriptor(fields, name)!;
+      Object.defineProperty(target, name, {
+        enumerable: descriptor.enumerable ?? false,
+        value: descriptor.value,
+      });
+    }
+    Object.defineProperty(target, 'que', { enumerable: true, value: queue });
+    for (const callback of callbacks) queue.push(callback);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installBootstrap({ target, boot, integrity, outline }: BootstrapInputSnapshotV1): void {
+  const ingress = prepareIngress(target);
+  const firstDisplay = boot.manifest.firstDisplay;
+  const NativeHtmlScriptElement = window.HTMLScriptElement;
+  const nativeArrayIsArray = Array.isArray;
+  const nativeObjectDefineProperty = Object.defineProperty;
+  const nativeObjectFreeze = Object.freeze;
+  const nativeObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  const nativeObjectIsFrozen = Object.isFrozen;
+  const nativeReflectApply = Reflect.apply;
+  const nativeReflectOwnKeys = Reflect.ownKeys;
+  const nativeCurrentScriptGetter = (() => {
+    try {
+      const constructor = document.defaultView?.Document;
+      const descriptor = constructor
+        ? nativeObjectGetOwnPropertyDescriptor(constructor.prototype, 'currentScript')
+        : undefined;
+      return typeof descriptor?.get === 'function' ? descriptor.get : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+  const currentScript = (): HTMLScriptElement | null => {
+    if (!nativeCurrentScriptGetter) return null;
+    try {
+      const value = nativeReflectApply(nativeCurrentScriptGetter, document, []);
+      return value instanceof NativeHtmlScriptElement ? value : null;
+    } catch {
+      return null;
+    }
+  };
+  let runtimeReadSource: HTMLScriptElement | undefined;
+  let runtimeReadLive = false;
+  let runtimeNamespaceSealed = false;
+  const sealRuntimeNamespace = (): void => {
+    if (runtimeNamespaceSealed) return;
+    nativeObjectDefineProperty(window, 'tsjs', {
+      configurable: false,
+      enumerable: true,
+      get: () => {
+        if (!runtimeReadLive || currentScript() !== runtimeReadSource) return target;
+        runtimeReadLive = false;
+        return runtimeReadSource;
+      },
+    });
+    runtimeNamespaceSealed = true;
+  };
+  const trustedOrigin = (): string | undefined => {
+    try {
+      if (/^https?:\/\//.test(location.origin)) return location.origin;
+      if (location.origin !== 'null') return undefined;
+      const stamp = nativeObjectGetOwnPropertyDescriptor(window, '__tsCreativeOrigin');
+      if (
+        !stamp ||
+        stamp.configurable ||
+        stamp.enumerable ||
+        !('value' in stamp) ||
+        stamp.writable ||
+        typeof stamp.value !== 'string'
+      ) {
+        return undefined;
+      }
+      const parsed = new URL(stamp.value);
+      return (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+        parsed.username === '' &&
+        parsed.password === '' &&
+        parsed.origin === stamp.value
+        ? parsed.origin
+        : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  const authentic = (script: HTMLScriptElement, source: string, id: string): boolean => {
+    try {
+      const origin = trustedOrigin();
+      if (!origin) return false;
+      const expected = new URL(source, origin);
+      const matches = document.querySelectorAll(`script#${id}`);
+      return (
+        expected.origin === origin &&
+        expected.hash === '' &&
+        script.id === id &&
+        script.isConnected &&
+        script.ownerDocument === document &&
+        script.src === expected.href &&
+        matches.length === 1 &&
+        matches[0] === script
+      );
+    } catch {
+      return false;
+    }
+  };
+  let bootClaimState: 'available' | 'claiming' | 'claimed' = 'available';
+  let bootClaimCompleted = false;
+  let completeClaimedBoot: ((outcome: BootClaimOutcome) => void) | undefined;
+  const completeBootClaim = (outcome: BootClaimOutcome): void => {
+    const acceptedOutcome =
+      outcome === 'kernel' || outcome === 'abi_mismatch' || outcome === 'bundle_partial';
+    if (
+      bootClaimState !== 'claimed' ||
+      bootClaimCompleted ||
+      !completeClaimedBoot ||
+      !acceptedOutcome
+    ) {
+      return;
+    }
+    bootClaimCompleted = true;
+    const complete = completeClaimedBoot;
+    completeClaimedBoot = undefined;
+    complete(outcome);
+  };
+  const claimedBoot = nativeObjectFreeze({
+    boot,
+    integrity,
+    complete: completeBootClaim,
+    currentScript,
+  });
+  const claimBoot = (source: unknown): Readonly<typeof claimedBoot> | undefined => {
+    if (bootClaimState !== 'available') return undefined;
+    bootClaimState = 'claiming';
+    let accepted = false;
+    try {
+      const expectedId = firstDisplay === null ? 'trustedserver-js' : 'trustedserver-js-runtime';
+      accepted =
+        source instanceof NativeHtmlScriptElement &&
+        currentScript() === source &&
+        authentic(source, boot.manifest.runtimeSrc, expectedId);
+    } catch {
+      // The claim stays reserved only until this authentication attempt fails.
+    }
+    if (!accepted) {
+      bootClaimState = 'available';
+      return undefined;
+    }
+    bootClaimState = 'claimed';
+    return claimedBoot;
+  };
+  const installRuntimeClaim = (
+    script: HTMLScriptElement,
+    mode: 'direct' | 'takeover',
+    bind: (input: unknown) => unknown
+  ): boolean => {
+    if (nativeObjectGetOwnPropertyDescriptor(script, '_claimRuntimeV1')) return false;
+    let live = true;
+    const claim = (source: unknown): Readonly<Record<string, unknown>> | undefined => {
+      if (!live) return undefined;
+      live = false;
+      const claimed = claimBoot(source);
+      if (!claimed) {
+        live = true;
+        return undefined;
+      }
+      return nativeObjectFreeze({ ...claimed, target, source, mode, bind });
+    };
+    nativeObjectDefineProperty(script, '_claimRuntimeV1', {
+      configurable: false,
+      enumerable: false,
+      value: claim,
+      writable: false,
+    });
+    runtimeReadSource = script;
+    runtimeReadLive = true;
+    return true;
+  };
+  if (firstDisplay === null) {
+    let terminal = false;
+    let cancelRuntime: (() => void) | undefined;
+    let directClaimState: 'available' | 'claiming' | 'claimed' = 'available';
+    let claimObserver: MutationObserver | undefined;
+    let timer: number | undefined;
+    const fallback = (reason: BootFailureReason = 'bundle_partial'): void => {
+      if (terminal) return;
+      terminal = true;
+      runtimeReadLive = false;
+      if (timer !== undefined) window.clearTimeout(timer);
+      try {
+        cancelRuntime?.();
+      } catch {
+        // Continue to the terminal shell after releasing the persistent owner.
+      }
+      claimObserver?.disconnect();
+      claimObserver = undefined;
+      publishFallback(target, ingress, fallbackFields(boot, reason, false));
+    };
+    completeClaimedBoot = (outcome) => {
+      if (outcome === 'abi_mismatch') fallback(outcome);
+    };
+    const claim = (
+      source: unknown,
+      cancel: unknown
+    ): ((outcome: 'kernel' | 'runtime_fallback' | 'failed_start') => void) | undefined => {
+      if (terminal || directClaimState !== 'available') return undefined;
+      directClaimState = 'claiming';
+      let accepted = false;
+      try {
+        accepted =
+          source instanceof NativeHtmlScriptElement &&
+          currentScript() === source &&
+          authentic(source, boot.manifest.runtimeSrc, 'trustedserver-js') &&
+          typeof cancel === 'function';
+      } catch {
+        // The reservation rolls back only when this authentication attempt fails.
+      }
+      if (!accepted) {
+        directClaimState = 'available';
+        return undefined;
+      }
+      directClaimState = 'claimed';
+      cancelRuntime = cancel as () => void;
+      return (outcome): void => {
+        if (terminal) return;
+        if (outcome === 'failed_start') {
+          fallback();
+          return;
+        }
+        terminal = true;
+        if (timer !== undefined) window.clearTimeout(timer);
+        claimObserver?.disconnect();
+        claimObserver = undefined;
+      };
+    };
+    const installDirectClaims = (script: HTMLScriptElement): boolean => {
+      try {
+        if (
+          terminal ||
+          !authentic(script, boot.manifest.runtimeSrc, 'trustedserver-js') ||
+          !installRuntimeClaim(script, 'direct', (cancel) => claim(script, cancel))
+        ) {
+          return false;
+        }
+        claimObserver?.disconnect();
+        claimObserver = undefined;
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    try {
+      sealRuntimeNamespace();
+      nativeObjectDefineProperty(target, 'boot', {
+        configurable: true,
+        enumerable: true,
+        value: boot,
+        writable: false,
+      });
+      claimObserver = new MutationObserver((records) => {
+        for (const record of records) {
+          for (const node of record.addedNodes) {
+            if (
+              node instanceof NativeHtmlScriptElement &&
+              node.id === 'trustedserver-js' &&
+              installDirectClaims(node)
+            ) {
+              return;
+            }
+          }
+        }
+      });
+      claimObserver.observe(document.documentElement, { childList: true, subtree: true });
+      const existing = document.querySelectorAll('script#trustedserver-js');
+      if (existing.length === 1 && existing[0] instanceof NativeHtmlScriptElement) {
+        installDirectClaims(existing[0]);
+      }
+      performance.mark('tsjs:bids-script');
+      timer = window.setTimeout(fallback, 10_000);
+    } catch {
+      fallback();
+    }
+    return;
+  }
+  if (outline === null) {
+    publishFallback(target, ingress, fallbackFields(boot, 'abi_mismatch', false));
+    return;
+  }
+  const disposers: Array<() => void> = [];
+  const registrations: ComponentRegistration[] = [];
+  let current = true;
+  let terminal = false;
+  let agent: FirstDisplayAgent | undefined;
+  let agentScript: HTMLScriptElement | undefined;
+  let runtimeScript: HTMLScriptElement | undefined;
+  let takeoverClaim: FirstDisplayTakeoverClaim | undefined;
+  let bootstrapTimer: number | undefined;
+  let takeoverTimer: number | undefined;
+  let takeoverStartedAt = 0;
+
+  const clear = (handle: number | undefined): void => {
+    if (handle !== undefined) window.clearTimeout(handle);
+  };
+  const removePrivate = (key: string): void => {
+    try {
+      const descriptor = nativeObjectGetOwnPropertyDescriptor(target, key);
+      if (descriptor?.configurable) Reflect.deleteProperty(target, key);
+    } catch {
+      // Generation invalidation makes an unremovable private field inert.
+    }
+  };
+  const disposeAgent = (): void => {
+    removePrivate('_registerFirstDisplay');
+    while (disposers.length > 0) {
+      const dispose = disposers.pop();
+      try {
+        dispose?.();
+      } catch {
+        // Continue releasing every independently owned provisional effect.
+      }
+    }
+    registrations.length = 0;
+    agent = undefined;
+  };
+  const commitFallback = (reason: BootFailureReason): void => {
+    if (terminal) return;
+    const initialDisplayCommitted = agent?.initialDisplayCommitted ?? false;
+    terminal = true;
+    runtimeReadLive = false;
+    current = false;
+    clear(bootstrapTimer);
+    clear(takeoverTimer);
+    takeoverClaim = undefined;
+    if (runtimeScript) {
+      runtimeScript.onload = null;
+      runtimeScript.onerror = null;
+      runtimeScript.remove();
+    }
+    disposeAgent();
+    publishFallback(target, ingress, fallbackFields(boot, reason, initialDisplayCommitted));
+  };
+  completeClaimedBoot = (outcome) => {
+    if (outcome !== 'kernel') commitFallback(outcome);
+  };
+  const now = (): number => performance.now();
+  const startedAtMs = now();
+  let runtimeScriptPolicy:
+    Readonly<{ createScriptURL: (value: string) => unknown }> | null | undefined;
+  const admittedScriptUrls = new Set<string>([
+    new URL(boot.manifest.runtimeSrc, location.origin).href,
+    ...boot.manifest.integrations.flatMap((entry) =>
+      entry.phase === 'deferred' ? [new URL(entry.src, location.origin).href] : []
+    ),
+  ]);
+  const trustedRuntimeScriptUrl = (expectedUrl: string): unknown => {
+    if (runtimeScriptPolicy === undefined) {
+      runtimeScriptPolicy = null;
+      try {
+        const trustedTypes = (
+          window as Window & {
+            trustedTypes?: {
+              createPolicy: (
+                name: string,
+                rules: Readonly<{ createScriptURL: (value: string) => string }>
+              ) => Readonly<{ createScriptURL: (value: string) => unknown }>;
+            };
+          }
+        ).trustedTypes;
+        if (trustedTypes) {
+          runtimeScriptPolicy = trustedTypes.createPolicy('trusted-server#tsjs-v1', {
+            createScriptURL: (value: string) => {
+              if (!admittedScriptUrls.has(value)) throw new TypeError('tsjs');
+              return value;
+            },
+          });
+        }
+      } catch {
+        runtimeScriptPolicy = null;
+      }
+    }
+    return runtimeScriptPolicy ? runtimeScriptPolicy.createScriptURL(expectedUrl) : expectedUrl;
+  };
+  const bridge = (selected: FirstDisplayAgent): void => {
+    agent = selected;
+    let claimState: 'available' | 'claiming' | 'claimed' = 'available';
+    const claim: FirstDisplayTakeoverClaim = (
+      source,
+      finalize
+    ): ClaimedFirstDisplayTakeoverV1 | undefined => {
+      if (claimState !== 'available') return undefined;
+      claimState = 'claiming';
+      let accepted = false;
+      try {
+        accepted =
+          source === runtimeScript &&
+          currentScript() === source &&
+          source instanceof NativeHtmlScriptElement &&
+          authentic(source, boot.manifest.runtimeSrc, 'trustedserver-js-runtime');
+      } catch {
+        // The reservation rolls back only when this authentication attempt fails.
+      }
+      if (!accepted) {
+        claimState = 'available';
+        return undefined;
+      }
+      claimState = 'claimed';
+      try {
+        if (terminal || !current || selected.state !== 'painted') {
+          throw new TypeError('tsjs');
+        }
+        const finalized = selected.finalizeHandoff(finalize);
+        if (!finalized) throw new TypeError('tsjs');
+        return nativeObjectFreeze([
+          finalized,
+          outline,
+          () => current && !terminal && now() - takeoverStartedAt < 10_000,
+          () =>
+            Boolean(
+              runtimeScript &&
+              authentic(runtimeScript, boot.manifest.runtimeSrc, 'trustedserver-js-runtime')
+            ),
+          () => selected.mutationRevision,
+          () => selected.detachCommittedArtifacts(),
+          disposeAgent,
+          (reason) => commitFallback(reason),
+          () => {
+            terminal = true;
+            try {
+              clear(takeoverTimer);
+            } catch {
+              // The committed persistent owner remains terminal if timer cleanup fails.
+            }
+          },
+          trustedRuntimeScriptUrl,
+          currentScript,
+        ]);
+      } catch (error) {
+        commitFallback('bundle_partial');
+        throw error;
+      }
+    };
+    if (takeoverClaim) throw new TypeError('tsjs');
+    takeoverClaim = claim;
+  };
+  const protectedPaint = (): void => {
+    try {
+      if (terminal || !agent || agent.state !== 'painted' || runtimeScript) {
+        throw new TypeError('tsjs');
+      }
+      takeoverStartedAt = now();
+      takeoverTimer = window.setTimeout(() => commitFallback('bundle_partial'), 10_000);
+      sealRuntimeNamespace();
+      const script = document.createElement('script');
+      script.id = 'trustedserver-js-runtime';
+      script.async = true;
+      if (!takeoverClaim) throw new TypeError('tsjs');
+      if (
+        !installRuntimeClaim(script, 'takeover', (finalize) => {
+          const claim = takeoverClaim;
+          takeoverClaim = undefined;
+          return claim?.(script, finalize as FirstDisplayAgentCaptureFinalizerV1);
+        })
+      ) {
+        throw new TypeError('tsjs');
+      }
+      if (agentScript?.nonce) script.nonce = agentScript.nonce;
+      const expectedUrl = new URL(boot.manifest.runtimeSrc, location.origin).href;
+      script.src = trustedRuntimeScriptUrl(expectedUrl) as string;
+      if (script.src !== expectedUrl) throw new TypeError('tsjs');
+      script.onerror = () => commitFallback('bundle_partial');
+      runtimeScript = script;
+      (document.head ?? document.documentElement).append(script);
+      if (
+        !authentic(script, boot.manifest.runtimeSrc, script.id) ||
+        !agent.observeNativeMutation()
+      ) {
+        throw new TypeError('tsjs');
+      }
+    } catch {
+      commitFallback('bundle_partial');
+    }
+  };
+  const binding = (
+    id: string,
+    observe: (key: unknown, value: unknown) => void,
+    register: ((protocol: unknown) => () => void) | undefined
+  ): readonly [bindings: unknown, config: unknown] => {
+    let bindings: unknown;
+    if (id === 'gpt_initial') {
+      bindings = nativeObjectFreeze({ browser: window, observe, register });
+    } else if (id === 'render_owner_initial') {
+      bindings = nativeObjectFreeze({ observe, register });
+    } else if (id === 'aps_initial') {
+      bindings = nativeObjectFreeze({
+        observe,
+        publisherOrigin: location.origin,
+        register,
+      });
+    } else if (id === 'creative_initial') {
+      bindings = nativeObjectFreeze({ observe });
+    } else if (id === 'google_tag_manager_initial') {
+      bindings = nativeObjectFreeze({
+        observe,
+        register: (rule: FirstDisplayBrowserRouteRuleV1) =>
+          registerFirstDisplayBrowserRoute(rule, true),
+      });
+    } else if (
+      id === 'datadome_initial' ||
+      id === 'lockr_initial' ||
+      id === 'permutive_initial' ||
+      id === 'sourcepoint_initial'
+    ) {
+      bindings = nativeObjectFreeze({ observe, register: registerFirstDisplayBrowserRoute });
+    } else if (id === 'testlight_initial') {
+      bindings = nativeObjectFreeze({
+        enqueue: (callback: () => void) => {
+          ingress.push(callback);
+        },
+        observe,
+        target: window,
+      });
+    } else {
+      bindings = register
+        ? nativeObjectFreeze({ observe, register })
+        : nativeObjectFreeze({ observe });
+    }
+    const product = id.endsWith('_initial') ? id.slice(0, -'_initial'.length) : '';
+    let config: unknown =
+      id === 'creative_initial'
+        ? boot.creative
+        : id === 'render_owner_initial'
+          ? nativeObjectFreeze({})
+          : undefined;
+    if (config === undefined && product !== '') {
+      for (const entry of boot.integrations.entries) {
+        if (entry.id === product) {
+          config = entry.config;
+          break;
+        }
+      }
+    }
+    return nativeObjectFreeze([bindings, config]);
+  };
+  const host: FirstDisplayAgentRegistrationHostV1 = nativeObjectFreeze({
+    options: nativeObjectFreeze({
+      batch: nativeObjectFreeze({
+        version: 1,
+        projectionDigest: outline.projectionDigest,
+        projection: boot.auctionProjection,
+      }),
+      startedAtMs,
+      performance,
+      paint: nativeObjectFreeze({
+        hidden: () => document.visibilityState === 'hidden',
+        requestFrame: (callback: () => void) => window.requestAnimationFrame(() => callback()),
+        scheduleHidden: (callback: () => void) => window.setTimeout(callback, 0),
+      }),
+      onProtectedPaint: protectedPaint,
+      onSettled: () => clear(bootstrapTimer),
+      onFailure: commitFallback,
+      gptInput: nativeObjectFreeze([
+        window,
+        (handle: unknown) => window.clearTimeout(handle as number),
+        document,
+        (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+        boot.diagnostics.gpt.active,
+      ] as const),
+      handoff: nativeObjectFreeze({
+        releaseId: RELEASE,
+        generation: outline.generation,
+        integrationConfigDigest: outline.integrationConfigDigest,
+        slices: firstDisplay.slices as readonly FirstDisplaySliceId[],
+      }),
+      now,
+      onAgentReady: bridge,
+    }),
+    sliceBindings: binding,
+  });
+
+  const fail = (): false => {
+    commitFallback('abi_mismatch');
+    return false;
+  };
+  const activateComponents = (): boolean => {
+    removePrivate('_registerFirstDisplay');
+    const base = prepareFirstDisplayBase(host);
+    let afterActivate: (() => void) | undefined;
+    let ownershipOpen = true;
+    try {
+      const context: FirstDisplaySliceActivationContext = nativeObjectFreeze({
+        own: (dispose: () => void) => {
+          if (!ownershipOpen || terminal || typeof dispose !== 'function') {
+            throw new TypeError('tsjs');
+          }
+          disposers.push(dispose);
+        },
+        afterActivate: (callback: () => void) => {
+          if (!ownershipOpen || terminal || afterActivate || typeof callback !== 'function') {
+            throw new TypeError('tsjs');
+          }
+          afterActivate = callback;
+        },
+      });
+      base.activate(context);
+      for (const component of registrations) {
+        base.sliceHost.activate(component.id, context.own, component.install);
+        if (terminal || !current) return false;
+      }
+    } finally {
+      ownershipOpen = false;
+    }
+    afterActivate?.();
+    if (terminal || !current) return false;
+    return Boolean(agent && !terminal);
+  };
+  let registrationOpen = true;
+  let registrationClaiming = false;
+  const register = function (this: unknown, candidate: unknown, _source?: unknown): boolean {
+    if (!registrationOpen || registrationClaiming) return false;
+    registrationClaiming = true;
+    try {
+      const expectedId = firstDisplay.slices[registrations.length + 1];
+      const source = currentScript();
+      if (
+        terminal ||
+        this !== target ||
+        !(source instanceof NativeHtmlScriptElement) ||
+        (agentScript && source !== agentScript) ||
+        !authentic(source, firstDisplay.src, 'trustedserver-js') ||
+        !nativeArrayIsArray(candidate)
+      ) {
+        registrationClaiming = false;
+        return fail();
+      }
+      if (terminal || !current) return false;
+      const keys = nativeReflectOwnKeys(candidate);
+      const length = nativeObjectGetOwnPropertyDescriptor(candidate, 'length');
+      if (
+        keys.length !== 5 ||
+        keys[0] !== '0' ||
+        keys[1] !== '1' ||
+        keys[2] !== '2' ||
+        keys[3] !== '3' ||
+        keys[4] !== 'length' ||
+        !length ||
+        !('value' in length) ||
+        length.value !== 4
+      ) {
+        registrationClaiming = false;
+        return fail();
+      }
+      const fields: unknown[] = [];
+      for (let index = 0; index < 4; index += 1) {
+        const descriptor = nativeObjectGetOwnPropertyDescriptor(candidate, String(index));
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+          registrationClaiming = false;
+          return fail();
+        }
+        fields.push(descriptor.value);
+      }
+      if (
+        fields[0] !== 1 ||
+        fields[1] !== expectedId ||
+        fields[2] !== RELEASE ||
+        typeof fields[3] !== 'function'
+      ) {
+        registrationClaiming = false;
+        return fail();
+      }
+      nativeObjectFreeze(candidate);
+      if (!nativeObjectIsFrozen(candidate)) {
+        registrationClaiming = false;
+        return fail();
+      }
+      agentScript = source;
+      registrations.push({
+        id: fields[1] as Exclude<FirstDisplaySliceId, 'first_display'>,
+        install: fields[3] as InitialSliceInstaller,
+      });
+      registrationClaiming = false;
+      if (registrations.length !== firstDisplay.slices.length - 1) return true;
+      registrationOpen = false;
+      return activateComponents();
+    } catch {
+      registrationClaiming = false;
+      return fail();
+    }
+  };
+
+  try {
+    nativeObjectDefineProperty(target, 'boot', {
+      configurable: true,
+      enumerable: true,
+      value: boot,
+      writable: false,
+    });
+    nativeObjectDefineProperty(target, '_registerFirstDisplay', {
+      configurable: true,
+      enumerable: false,
+      value: register,
+      writable: false,
+    });
+    performance.mark('tsjs:bids-script');
+    bootstrapTimer = window.setTimeout(() => commitFallback('bundle_partial'), 10_000);
+    if (firstDisplay.slices.length === 1) activateComponents();
+  } catch {
+    commitFallback('abi_mismatch');
+  }
+}
+
+function bootstrapTarget(): BootstrapTarget | undefined {
+  try {
+    const namespace = window as unknown as { tsjs?: unknown };
+    const current = namespace.tsjs;
+    if ((typeof current === 'object' || typeof current === 'function') && current !== null) {
+      return current as BootstrapTarget;
+    }
+    if (current) return undefined;
+    const target: BootstrapTarget = {};
+    namespace.tsjs = target;
+    return target;
+  } catch {
+    return undefined;
+  }
+}
+
+const transport = snapshotServerBootTransportV1(
+  typeof __TSJS_SERVER_BOOT_TRANSPORT_V1__ === 'undefined'
+    ? undefined
+    : __TSJS_SERVER_BOOT_TRANSPORT_V1__,
+  RELEASE
+);
+const target = transport && bootstrapTarget();
+if (transport && target) installBootstrap(Object.freeze({ ...transport, target }));
diff --git a/crates/trusted-server-js/lib/src/core/config.ts b/crates/trusted-server-js/lib/src/core/config.ts
deleted file mode 100644
index c0bbe7428..000000000
--- a/crates/trusted-server-js/lib/src/core/config.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-// Global configuration storage for the tsjs runtime (logging, debug, etc.).
-import { log, LogLevel } from './log';
-
-export interface Config {
-  debug?: boolean;
-  logLevel?: 'silent' | 'error' | 'warn' | 'info' | 'debug';
-  [key: string]: unknown;
-}
-
-let CONFIG: Config = {};
-
-// Merge publisher-provided config and adjust the log level accordingly.
-export function setConfig(cfg: Config): void {
-  CONFIG = { ...CONFIG, ...cfg };
-  const debugFlag = cfg.debug;
-  const l = cfg.logLevel as LogLevel | undefined;
-  if (typeof l === 'string') log.setLevel(l);
-  else if (debugFlag === true) log.setLevel('debug');
-  log.info('setConfig:', cfg);
-}
-
-// Return a defensive copy so callers can't mutate shared state.
-export function getConfig(): Config {
-  return { ...CONFIG };
-}
diff --git a/crates/trusted-server-js/lib/src/core/context.ts b/crates/trusted-server-js/lib/src/core/context.ts
deleted file mode 100644
index 9ee4ddff5..000000000
--- a/crates/trusted-server-js/lib/src/core/context.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-// Context provider registry: lets integrations contribute data to auction requests
-// without core needing integration-specific knowledge.
-import { log } from './log';
-
-/**
- * A context provider returns key-value pairs to merge into the auction
- * request's `config` payload, or `undefined` to contribute nothing.
- */
-export type ContextProvider = () => Record<string, unknown> | undefined;
-
-const providers = new Map<string, ContextProvider>();
-
-/**
- * Register a context provider that will be called before every auction request.
- * Integrations call this at import time to inject their data (e.g. segments,
- * identifiers) into the auction payload without core needing to know about them.
- *
- * Re-registering with the same `id` replaces the previous provider, preventing
- * duplicate accumulation in SPA environments.
- */
-export function registerContextProvider(id: string, provider: ContextProvider): void {
-  providers.set(id, provider);
-  log.debug('context: registered provider', { id, total: providers.size });
-}
-
-/**
- * Collect context from all registered providers. Called by core's `requestAds`
- * to build the `config` object sent to `/auction`.
- *
- * Each provider's returned keys are merged (later providers win on collision).
- * Providers that throw or return `undefined` are silently skipped.
- */
-export function collectContext(): Record<string, unknown> {
-  const context: Record<string, unknown> = {};
-  for (const provider of providers.values()) {
-    try {
-      const data = provider();
-      if (data) Object.assign(context, data);
-    } catch {
-      log.debug('context: provider threw, skipping');
-    }
-  }
-  return context;
-}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts b/crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts
new file mode 100644
index 000000000..e4874e6fb
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts
@@ -0,0 +1,156 @@
+import type { ApsRendererV1 } from '../types';
+
+import {
+  classifyApsRendererDescriptorV1,
+  classifyApsRendererV1,
+} from './generated/renderer_validator_v1';
+
+type ValidatedRendererCacheEntry = {
+  publisherOrigin: string;
+  renderer: ApsRendererV1;
+};
+
+const validatedRendererCache = new WeakMap<object, ValidatedRendererCacheEntry>();
+const rendererNoncePattern = /^n1_[A-Za-z0-9_-]{22}$/;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  try {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+  } catch {
+    return false;
+  }
+}
+
+function exactDataRecord(
+  value: unknown,
+  expectedKeys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    const keys = Reflect.ownKeys(value);
+    if (
+      keys.length !== expectedKeys.length ||
+      keys.some((key) => typeof key !== 'string' || !expectedKeys.includes(key))
+    ) {
+      return undefined;
+    }
+    const record: Record<string, unknown> = {};
+    for (const key of expectedKeys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        !descriptor ||
+        descriptor.enumerable !== true ||
+        !Object.prototype.hasOwnProperty.call(descriptor, 'value')
+      ) {
+        return undefined;
+      }
+      record[key] = descriptor.value;
+    }
+    return Object.freeze(record);
+  } catch {
+    return undefined;
+  }
+}
+
+function exactHttpOrigin(value: unknown): value is string {
+  if (typeof value !== 'string' || new TextEncoder().encode(value).byteLength > 2_048) {
+    return false;
+  }
+  try {
+    const parsed = new URL(value);
+    return (
+      (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      parsed.hostname !== '' &&
+      parsed.username === '' &&
+      parsed.password === '' &&
+      parsed.origin === value &&
+      parsed.pathname === '/' &&
+      parsed.search === '' &&
+      parsed.hash === ''
+    );
+  } catch {
+    return false;
+  }
+}
+
+export interface ApsDocumentEnvelopeV1 {
+  readonly version: 1;
+  readonly nonce: string;
+  readonly publisherOrigin: string;
+  readonly renderer: Readonly<ApsRendererV1>;
+}
+
+/** Parse only the versioned descriptor shape; decoded-envelope trust checks happen separately. */
+export function parseApsRendererDescriptor(value: unknown): ApsRendererV1 | undefined {
+  try {
+    if (classifyApsRendererDescriptorV1(value) !== 'accepted') return undefined;
+    return value as unknown as ApsRendererV1;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Fully validate the exact APS envelope and cross-check every duplicated descriptor field. */
+export function validateApsRenderer(
+  value: unknown,
+  publisherOrigin = window.location.origin
+): ApsRendererV1 | undefined {
+  try {
+    if (isRecord(value)) {
+      const cached = validatedRendererCache.get(value);
+      if (cached?.publisherOrigin === publisherOrigin) return cached.renderer;
+    }
+
+    if (classifyApsRendererV1(value, publisherOrigin) !== 'accepted') return undefined;
+    const renderer = value as ApsRendererV1;
+    const validated = Object.freeze({ ...renderer }) as ApsRendererV1;
+    validatedRendererCache.set(value as object, { publisherOrigin, renderer: validated });
+    validatedRendererCache.set(validated, { publisherOrigin, renderer: validated });
+    return validated;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Parse, fully validate, copy, and freeze the one inner-document envelope. */
+export function parseApsDocumentEnvelopeV1(
+  candidate: unknown,
+  expectedNonce: string,
+  expectedPublisherOrigin: string
+): Readonly<ApsDocumentEnvelopeV1> | undefined {
+  try {
+    if (!rendererNoncePattern.test(expectedNonce) || !exactHttpOrigin(expectedPublisherOrigin)) {
+      return undefined;
+    }
+    const envelope = exactDataRecord(candidate, [
+      'version',
+      'nonce',
+      'publisherOrigin',
+      'renderer',
+    ]);
+    if (
+      envelope?.['version'] !== 1 ||
+      envelope['nonce'] !== expectedNonce ||
+      envelope['publisherOrigin'] !== expectedPublisherOrigin
+    ) {
+      return undefined;
+    }
+    const renderer = validateApsRenderer(envelope['renderer'], expectedPublisherOrigin);
+    if (!renderer) return undefined;
+    return Object.freeze({
+      version: 1,
+      nonce: expectedNonce,
+      publisherOrigin: expectedPublisherOrigin,
+      renderer,
+    });
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/auction_projection.ts b/crates/trusted-server-js/lib/src/core/contracts/auction_projection.ts
new file mode 100644
index 000000000..5a8676529
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/auction_projection.ts
@@ -0,0 +1,612 @@
+import type {
+  AdmRenderSourceV1,
+  AuctionDecisionSetV1,
+  AuctionSlotFailureReason,
+  BaselinePbsCacheSourceV1,
+  BidRenderSourceV1,
+  BrowserAuctionBidV1,
+  BrowserAuctionProjectionV1,
+  BrowserAuctionSlotV1,
+  SlotAuctionDecisionV1,
+} from '../types';
+
+import { validateApsRenderer } from './aps_renderer';
+import { validBoundedString } from './bounded_string';
+
+export { validBoundedString };
+
+export const MAX_BROWSER_AUCTION_PROJECTION_BYTES = 8 * 1024 * 1024;
+
+export const MAX_AUCTION_RESULTS = 256;
+const MAX_TARGETING_ENTRIES = 32;
+const MAX_SLOT_FORMATS = 64;
+const MAX_ADM_BYTES = 512 * 1024;
+const MAX_URL_BYTES = 4096;
+const reflectApplyIntrinsic = Reflect.apply;
+const objectGetOwnPropertyNamesIntrinsic = Object.getOwnPropertyNames;
+const objectKeysIntrinsic = Object.keys;
+const regExpTestIntrinsic = RegExp.prototype.test;
+const candidateIdPattern = /^[A-Za-z0-9_-]{12}$/;
+const reservationIdPattern = /^r1_[A-Za-z0-9_-]{22}$/;
+const auctionIdPattern = /^[A-Za-z0-9._:-]{1,128}$/;
+const providerPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const targetingKeyPattern = /^[A-Za-z0-9_]{1,20}$/;
+const auctionFailureReasons = new Set<AuctionSlotFailureReason>([
+  'auction_disabled',
+  'consent_denied',
+  'slot_not_eligible',
+  'provider_timeout',
+  'provider_error',
+  'invalid_provider_response',
+  'mediation_failed',
+  'winner_not_renderable',
+  'identity_generation_failed',
+  'internal_error',
+]);
+
+function hasString(values: readonly string[], expected: string): boolean {
+  for (let index = 0; index < values.length; index += 1) {
+    if (values[index] === expected) return true;
+  }
+  return false;
+}
+
+export function ownDataObject(
+  value: unknown,
+  expectedKeys?: readonly string[]
+): Record<string, unknown> | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+    if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [
+      value,
+    ]) as string[];
+    if (expectedKeys) {
+      if (names.length !== expectedKeys.length) return undefined;
+      for (let index = 0; index < expectedKeys.length; index += 1) {
+        const expected = expectedKeys[index];
+        if (expected === undefined || !hasString(names, expected)) return undefined;
+      }
+    }
+    const snapshot: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (let index = 0; index < names.length; index += 1) {
+      const name = names[index];
+      if (name === undefined) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      snapshot[name] = descriptor.value;
+    }
+    return snapshot;
+  } catch {
+    return undefined;
+  }
+}
+
+export function ownDataArray(value: unknown, maximum: number): unknown[] | undefined {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+    if (value.length > maximum || Object.getOwnPropertySymbols(value).length !== 0)
+      return undefined;
+    const names = reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [
+      value,
+    ]) as string[];
+    if (names.length !== value.length + 1 || !hasString(names, 'length')) return undefined;
+    const snapshot: unknown[] = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      snapshot.push(descriptor.value);
+    }
+    return snapshot;
+  } catch {
+    return undefined;
+  }
+}
+
+function matches(pattern: RegExp, value: string): boolean {
+  return reflectApplyIntrinsic(regExpTestIntrinsic, pattern, [value]) as boolean;
+}
+
+export function validDimension(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= 1 &&
+    value <= 4096
+  );
+}
+
+export function isAuctionCandidateIdV1(value: unknown): value is string {
+  return typeof value === 'string' && matches(candidateIdPattern, value);
+}
+
+export function isAuctionProviderIdV1(value: unknown): value is string {
+  return typeof value === 'string' && matches(providerPattern, value);
+}
+
+function boundedJsonBytes(left: number, right: number, maximum: number): number {
+  return left > maximum - right ? maximum + 1 : left + right;
+}
+
+function encodedJsonStringBytes(value: string, maximum: number): number {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    let encodedBytes: number;
+    if (code === 0x22 || code === 0x5c) encodedBytes = 2;
+    else if (code <= 0x1f) {
+      encodedBytes =
+        code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6;
+    } else if (code <= 0x7f) encodedBytes = 1;
+    else if (code <= 0x7ff) encodedBytes = 2;
+    else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        encodedBytes = 4;
+        index += 1;
+      } else encodedBytes = 6;
+    } else if (code >= 0xdc00 && code <= 0xdfff) encodedBytes = 6;
+    else encodedBytes = 3;
+    bytes = boundedJsonBytes(bytes, encodedBytes, maximum);
+    if (bytes > maximum) return bytes;
+  }
+  return bytes;
+}
+
+interface JsonMeasureSnapshot {
+  readonly array: boolean;
+  readonly entries: readonly Readonly<{ key: string; value: unknown }>[];
+}
+
+interface JsonMeasureFrame extends JsonMeasureSnapshot {
+  readonly source: object;
+  bytes: number;
+  index: number;
+}
+
+function jsonPrimitiveBytes(value: unknown): number | undefined {
+  if (value === null) return 4;
+  if (typeof value === 'boolean') return value ? 4 : 5;
+  if (typeof value === 'number' && Number.isFinite(value)) return `${value}`.length;
+  return typeof value === 'string'
+    ? encodedJsonStringBytes(value, MAX_BROWSER_AUCTION_PROJECTION_BYTES)
+    : undefined;
+}
+
+function snapshotJsonForMeasurement(value: object): JsonMeasureSnapshot | undefined {
+  const array = Array.isArray(value);
+  const values = array ? ownDataArray(value, MAX_AUCTION_RESULTS) : undefined;
+  if (array && !values) return undefined;
+  const record = array ? undefined : ownDataObject(value);
+  if (!array && !record) return undefined;
+  return {
+    array,
+    entries: array
+      ? values!.map((entry, index) => ({ key: String(index), value: entry }))
+      : (reflectApplyIntrinsic(objectKeysIntrinsic, Object, [record]) as string[]).map((key) => ({
+          key,
+          value: record![key],
+        })),
+  };
+}
+
+/** Measure exact own JSON data without consulting accessors or inherited `toJSON` hooks. */
+export function jsonUtf8ByteLength(value: unknown): number {
+  const primitive = jsonPrimitiveBytes(value);
+  if (primitive !== undefined) return primitive;
+  if (typeof value !== 'object' || value === null) return Number.POSITIVE_INFINITY;
+  const root = snapshotJsonForMeasurement(value);
+  if (!root) return Number.POSITIVE_INFINITY;
+  const memo = new WeakMap<object, number>();
+  const active = new Set<object>();
+  active.add(value);
+  const stack: JsonMeasureFrame[] = [{ ...root, bytes: 2, index: 0, source: value }];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (!frame) return Number.POSITIVE_INFINITY;
+    if (frame.index >= frame.entries.length) {
+      memo.set(frame.source, frame.bytes);
+      active.delete(frame.source);
+      stack.pop();
+      const parent = stack[stack.length - 1];
+      if (!parent) return frame.bytes;
+      parent.bytes = boundedJsonBytes(
+        parent.bytes,
+        frame.bytes,
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES
+      );
+      if (parent.bytes > MAX_BROWSER_AUCTION_PROJECTION_BYTES) return parent.bytes;
+      continue;
+    }
+    const entry = frame.entries[frame.index];
+    const entryIndex = frame.index;
+    frame.index += 1;
+    if (!entry) return Number.POSITIVE_INFINITY;
+    const keyBytes = frame.array ? 0 : jsonPrimitiveBytes(entry.key);
+    if (keyBytes === undefined) return Number.POSITIVE_INFINITY;
+    frame.bytes = boundedJsonBytes(
+      frame.bytes,
+      (entryIndex === 0 ? 0 : 1) + (frame.array ? 0 : keyBytes + 1),
+      MAX_BROWSER_AUCTION_PROJECTION_BYTES
+    );
+    if (frame.bytes > MAX_BROWSER_AUCTION_PROJECTION_BYTES) return frame.bytes;
+    const childPrimitive = jsonPrimitiveBytes(entry.value);
+    if (childPrimitive !== undefined) {
+      frame.bytes = boundedJsonBytes(
+        frame.bytes,
+        childPrimitive,
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES
+      );
+      if (frame.bytes > MAX_BROWSER_AUCTION_PROJECTION_BYTES) return frame.bytes;
+      continue;
+    }
+    if (typeof entry.value !== 'object' || entry.value === null || active.has(entry.value)) {
+      return Number.POSITIVE_INFINITY;
+    }
+    const completed = memo.get(entry.value);
+    if (completed !== undefined) {
+      frame.bytes = boundedJsonBytes(frame.bytes, completed, MAX_BROWSER_AUCTION_PROJECTION_BYTES);
+      if (frame.bytes > MAX_BROWSER_AUCTION_PROJECTION_BYTES) return frame.bytes;
+      continue;
+    }
+    const child = snapshotJsonForMeasurement(entry.value);
+    if (!child) return Number.POSITIVE_INFINITY;
+    active.add(entry.value);
+    stack.push({ ...child, bytes: 2, index: 0, source: entry.value });
+  }
+  return Number.POSITIVE_INFINITY;
+}
+
+/** Whether a value is one exact server-minted renderer reservation identity. */
+export function isRendererReservationIdV1(value: unknown): value is string {
+  return typeof value === 'string' && matches(reservationIdPattern, value);
+}
+
+/** Validate and copy one exact browser render-source contract. */
+export function parseBidRenderSourceV1(value: unknown): BidRenderSourceV1 | undefined {
+  const record = ownDataObject(value);
+  if (!record || typeof record.type !== 'string') return undefined;
+
+  if (record.type === 'aps') {
+    const keys = Object.prototype.hasOwnProperty.call(record, 'creativeId')
+      ? [
+          'type',
+          'version',
+          'accountId',
+          'bidId',
+          'creativeId',
+          'tagType',
+          'creativeUrl',
+          'aaxResponse',
+          'width',
+          'height',
+        ]
+      : [
+          'type',
+          'version',
+          'accountId',
+          'bidId',
+          'tagType',
+          'creativeUrl',
+          'aaxResponse',
+          'width',
+          'height',
+        ];
+    if (!ownDataObject(value, keys)) return undefined;
+    const renderer = validateApsRenderer(record);
+    if (!renderer) return undefined;
+    return {
+      type: 'aps',
+      version: 1,
+      accountId: renderer.accountId,
+      bidId: renderer.bidId,
+      ...(renderer.creativeId === undefined ? {} : { creativeId: renderer.creativeId }),
+      tagType: renderer.tagType,
+      creativeUrl: renderer.creativeUrl,
+      aaxResponse: renderer.aaxResponse,
+      width: renderer.width,
+      height: renderer.height,
+    };
+  }
+
+  if (record.type === 'adm') {
+    const source = ownDataObject(value, ['type', 'version', 'adm', 'width', 'height']);
+    if (
+      !source ||
+      source.version !== 1 ||
+      !validBoundedString(source.adm, MAX_ADM_BYTES, { allowControls: true }) ||
+      !validDimension(source.width) ||
+      !validDimension(source.height)
+    ) {
+      return undefined;
+    }
+    return {
+      type: 'adm',
+      version: 1,
+      adm: source.adm,
+      width: source.width,
+      height: source.height,
+    } satisfies AdmRenderSourceV1;
+  }
+
+  if (record.type === 'pbs_cache') {
+    const source = ownDataObject(value, [
+      'type',
+      'version',
+      'cacheId',
+      'cacheHost',
+      'cachePath',
+      'width',
+      'height',
+    ]);
+    if (
+      !source ||
+      source.version !== 1 ||
+      !validBoundedString(source.cacheId, 4096, { allowControls: true }) ||
+      !validBoundedString(source.cacheHost, MAX_URL_BYTES, { allowControls: true }) ||
+      !validBoundedString(source.cachePath, MAX_URL_BYTES, { allowControls: true }) ||
+      typeof source.width !== 'number' ||
+      !Number.isInteger(source.width) ||
+      source.width < 0 ||
+      source.width > 0xffff_ffff ||
+      typeof source.height !== 'number' ||
+      !Number.isInteger(source.height) ||
+      source.height < 0 ||
+      source.height > 0xffff_ffff
+    ) {
+      return undefined;
+    }
+    return {
+      type: 'pbs_cache',
+      version: 1,
+      cacheId: source.cacheId,
+      cacheHost: source.cacheHost,
+      cachePath: source.cachePath,
+      width: source.width,
+      height: source.height,
+    } satisfies BaselinePbsCacheSourceV1;
+  }
+
+  return undefined;
+}
+
+/** Validate and copy one exact auction decision-set contract. */
+export function parseAuctionDecisionSetV1(value: unknown): AuctionDecisionSetV1 | undefined {
+  const record = ownDataObject(value, ['version', 'auctionId', 'results']);
+  if (!record || record.version !== 1 || typeof record.auctionId !== 'string') return undefined;
+  if (!matches(auctionIdPattern, record.auctionId)) return undefined;
+  const results = ownDataArray(record.results, MAX_AUCTION_RESULTS);
+  if (!results) return undefined;
+
+  const parsed: SlotAuctionDecisionV1[] = [];
+  const slots = new Set<string>();
+  const candidates = new Set<string>();
+  for (let index = 0; index < results.length; index += 1) {
+    const raw = results[index];
+    const base = ownDataObject(raw);
+    if (!base || !validBoundedString(base.slot, 256) || slots.has(base.slot)) return undefined;
+    slots.add(base.slot);
+    if (base.outcome === 'winner') {
+      const winner = ownDataObject(raw, ['slot', 'outcome', 'candidateId']);
+      if (
+        !winner ||
+        !isAuctionCandidateIdV1(winner.candidateId) ||
+        candidates.has(winner.candidateId)
+      ) {
+        return undefined;
+      }
+      candidates.add(winner.candidateId);
+      parsed.push({ slot: base.slot, outcome: 'winner', candidateId: winner.candidateId });
+    } else if (base.outcome === 'no_bid') {
+      if (!ownDataObject(raw, ['slot', 'outcome'])) return undefined;
+      parsed.push({ slot: base.slot, outcome: 'no_bid' });
+    } else if (base.outcome === 'failed') {
+      const failed = ownDataObject(raw, ['slot', 'outcome', 'reason']);
+      if (
+        !failed ||
+        typeof failed.reason !== 'string' ||
+        !auctionFailureReasons.has(failed.reason as AuctionSlotFailureReason)
+      ) {
+        return undefined;
+      }
+      parsed.push({
+        slot: base.slot,
+        outcome: 'failed',
+        reason: failed.reason as AuctionSlotFailureReason,
+      });
+    } else {
+      return undefined;
+    }
+  }
+
+  return { version: 1, auctionId: record.auctionId, results: parsed };
+}
+
+function parseTargeting(value: unknown): Record<string, string> | undefined {
+  const record = ownDataObject(value);
+  if (!record) return undefined;
+  const entries = Object.entries(record);
+  if (entries.length > MAX_TARGETING_ENTRIES) return undefined;
+  const targeting: Record<string, string> = {};
+  entries.sort((leftEntry, rightEntry) => {
+    const left = leftEntry[0];
+    const right = rightEntry[0];
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+  for (let index = 0; index < entries.length; index += 1) {
+    const pair = entries[index];
+    if (!pair) return undefined;
+    const key = pair[0];
+    const entry = pair[1];
+    if (
+      key === 'hb_adid' ||
+      !matches(targetingKeyPattern, key) ||
+      !validBoundedString(entry, 160, { maximumScalars: 40 })
+    ) {
+      return undefined;
+    }
+    Object.defineProperty(targeting, key, {
+      value: entry,
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    });
+  }
+  return targeting;
+}
+
+function parseBrowserBid(value: unknown): BrowserAuctionBidV1 | undefined {
+  const rawBid = ownDataObject(value);
+  if (!rawBid) return undefined;
+  const hasReservation = Object.prototype.hasOwnProperty.call(rawBid, 'rendererReservationId');
+  const bid = ownDataObject(
+    value,
+    hasReservation
+      ? [
+          'candidateId',
+          'slot',
+          'provider',
+          'upstreamBidId',
+          'cpm',
+          'currency',
+          'targeting',
+          'rendererReservationId',
+          'renderSource',
+        ]
+      : [
+          'candidateId',
+          'slot',
+          'provider',
+          'upstreamBidId',
+          'cpm',
+          'currency',
+          'targeting',
+          'renderSource',
+        ]
+  );
+  if (
+    !bid ||
+    !isAuctionCandidateIdV1(bid.candidateId) ||
+    !validBoundedString(bid.slot, 256) ||
+    !isAuctionProviderIdV1(bid.provider) ||
+    !validBoundedString(bid.upstreamBidId, 64) ||
+    typeof bid.cpm !== 'number' ||
+    !Number.isFinite(bid.cpm) ||
+    bid.cpm < 0 ||
+    bid.currency !== 'USD'
+  ) {
+    return undefined;
+  }
+  const targeting = parseTargeting(bid.targeting);
+  const renderSource = parseBidRenderSourceV1(bid.renderSource);
+  if (!targeting || !renderSource) return undefined;
+  const base = {
+    candidateId: bid.candidateId,
+    slot: bid.slot,
+    provider: bid.provider,
+    upstreamBidId: bid.upstreamBidId,
+    cpm: bid.cpm,
+    currency: 'USD' as const,
+    targeting,
+  };
+  if (renderSource.type === 'pbs_cache') {
+    if (hasReservation) return undefined;
+    return { ...base, renderSource };
+  }
+  if (!hasReservation || !isRendererReservationIdV1(bid.rendererReservationId)) return undefined;
+  return { ...base, rendererReservationId: bid.rendererReservationId, renderSource };
+}
+
+function parseBrowserSlot(value: unknown): BrowserAuctionSlotV1 | undefined {
+  const slot = ownDataObject(value, ['slot', 'gamUnitPath', 'divId', 'formats', 'targeting']);
+  if (
+    !slot ||
+    !validBoundedString(slot.slot, 256) ||
+    !validBoundedString(slot.gamUnitPath, 256) ||
+    !validBoundedString(slot.divId, 256)
+  ) {
+    return undefined;
+  }
+  const rawFormats = ownDataArray(slot.formats, MAX_SLOT_FORMATS);
+  if (!rawFormats || rawFormats.length === 0) return undefined;
+  const formats: Array<readonly [number, number]> = [];
+  for (let index = 0; index < rawFormats.length; index += 1) {
+    const pair = ownDataArray(rawFormats[index], 2);
+    if (!pair || pair.length !== 2 || !validDimension(pair[0]) || !validDimension(pair[1])) {
+      return undefined;
+    }
+    formats.push([pair[0], pair[1]]);
+  }
+  const targeting = parseTargeting(slot.targeting);
+  if (!targeting) return undefined;
+  return {
+    slot: slot.slot,
+    gamUnitPath: slot.gamUnitPath,
+    divId: slot.divId,
+    formats,
+    targeting,
+  };
+}
+
+/** Validate, canonicalize, and deep-copy a complete browser auction projection. */
+export function parseBrowserAuctionProjectionV1(
+  value: unknown
+): BrowserAuctionProjectionV1 | undefined {
+  try {
+    const record = ownDataObject(value, ['version', 'auction', 'slots', 'bids']);
+    if (!record || record.version !== 1) return undefined;
+    const auction = parseAuctionDecisionSetV1(record.auction);
+    const rawSlots = ownDataArray(record.slots, MAX_AUCTION_RESULTS);
+    const rawBids = ownDataArray(record.bids, MAX_AUCTION_RESULTS);
+    if (!auction || !rawSlots || !rawBids || rawSlots.length !== auction.results.length) {
+      return undefined;
+    }
+    const slots: BrowserAuctionSlotV1[] = [];
+    const slotIds = new Set<string>();
+    for (let index = 0; index < rawSlots.length; index += 1) {
+      const slot = parseBrowserSlot(rawSlots[index]);
+      if (!slot || slotIds.has(slot.slot) || slot.slot !== auction.results[index]?.slot) {
+        return undefined;
+      }
+      slotIds.add(slot.slot);
+      slots.push(slot);
+    }
+    const bids: BrowserAuctionBidV1[] = [];
+    const candidateIds = new Set<string>();
+    const reservationIds = new Set<string>();
+    for (let index = 0; index < rawBids.length; index += 1) {
+      const raw = rawBids[index];
+      const bid = parseBrowserBid(raw);
+      if (
+        !bid ||
+        candidateIds.has(bid.candidateId) ||
+        ('rendererReservationId' in bid && reservationIds.has(bid.rendererReservationId))
+      ) {
+        return undefined;
+      }
+      candidateIds.add(bid.candidateId);
+      if ('rendererReservationId' in bid) reservationIds.add(bid.rendererReservationId);
+      bids.push(bid);
+    }
+
+    let winnerIndex = 0;
+    for (let index = 0; index < auction.results.length; index += 1) {
+      const result = auction.results[index];
+      if (!result || result.outcome !== 'winner') continue;
+      const bid = bids[winnerIndex];
+      if (bid?.candidateId !== result.candidateId || bid.slot !== result.slot) return undefined;
+      winnerIndex += 1;
+    }
+    if (winnerIndex !== bids.length) return undefined;
+
+    const projection: BrowserAuctionProjectionV1 = { version: 1, auction, slots, bids };
+    if (jsonUtf8ByteLength(projection) > MAX_BROWSER_AUCTION_PROJECTION_BYTES) {
+      return undefined;
+    }
+    return projection;
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/boot.ts b/crates/trusted-server-js/lib/src/core/contracts/boot.ts
new file mode 100644
index 000000000..3b4b40a87
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/boot.ts
@@ -0,0 +1,396 @@
+import {
+  snapshotTakeoverOutlineV1,
+  type TakeoverOutlineV1,
+} from '../../shared/first_display_contracts';
+import type {
+  BootManifestIntegrationV1,
+  BootManifestV1,
+  IntegrationConfigIdV1,
+  TsjsBootV1,
+} from '../types';
+import { INTEGRATION_CONFIG_IDS_V1 } from '../types';
+
+import { parseBrowserAuctionProjectionV1 } from './auction_projection';
+import {
+  canonicalIntegrationConfigDigestV1,
+  snapshotIntegrationConfigsV1,
+} from './integration_configs';
+
+const FIRST_DISPLAY_SRC =
+  /^\/static\/tsjs=tsjs-first-display\.min\.js\?m=([0-9a-f]{4})&v=[0-9a-f]{64}$/;
+const RUNTIME_SRC = /^\/static\/tsjs=tsjs-unified\.min\.js\?v=[0-9a-f]{64}$/;
+const DEFERRED_SRC = /^\/static\/tsjs=tsjs-[a-z0-9][a-z0-9_-]{0,63}\.min\.js\?v=[0-9a-f]{64}$/;
+const INTEGRATION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const RELEASE_ID = /^[0-9a-f]{64}$/;
+const FIRST_DISPLAY_IDS = Object.freeze([
+  'first_display',
+  'render_owner_initial',
+  'aps_initial',
+  'creative_initial',
+  'datadome_initial',
+  'didomi_initial',
+  'google_tag_manager_initial',
+  'gpt_initial',
+  'lockr_initial',
+  'osano_initial',
+  'permutive_initial',
+  'sourcepoint_initial',
+  'prebid_initial',
+  'testlight_initial',
+] as const);
+
+export interface BootstrapInputSnapshotV1 {
+  readonly target: object & { boot?: unknown; que?: unknown };
+  readonly boot: Readonly<TsjsBootV1>;
+  readonly outline: TakeoverOutlineV1 | null;
+}
+
+function ownPlainDataRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+  const result: Record<string, unknown> = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== 'string') return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      value: descriptor.value,
+      writable: true,
+    });
+  }
+  return result;
+}
+
+function exactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+
+function snapshotArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+  const length = Object.getOwnPropertyDescriptor(value, 'length');
+  if (!length || !('value' in length) || !Number.isSafeInteger(length.value)) return undefined;
+  if (length.value < 0 || length.value > maximum) return undefined;
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== length.value + 1) return undefined;
+  const result: unknown[] = [];
+  for (let index = 0; index < length.value; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result.push(descriptor.value);
+  }
+  return result;
+}
+
+function snapshotManifest(candidate: unknown, releaseId: string): BootManifestV1 | undefined {
+  const root = ownPlainDataRecord(candidate);
+  if (
+    !root ||
+    !exactKeys(root, ['version', 'releaseId', 'firstDisplay', 'runtimeSrc', 'integrations']) ||
+    root.version !== 1 ||
+    root.releaseId !== releaseId ||
+    typeof root.runtimeSrc !== 'string' ||
+    !RUNTIME_SRC.test(root.runtimeSrc)
+  ) {
+    return undefined;
+  }
+
+  const rawIntegrations = snapshotArray(root.integrations, 20);
+  if (!rawIntegrations) return undefined;
+  const integrations: BootManifestIntegrationV1[] = [];
+  const ids = new Set<string>();
+  let sawDeferred = false;
+  for (const candidateEntry of rawIntegrations) {
+    const entry = ownPlainDataRecord(candidateEntry);
+    if (
+      !entry ||
+      typeof entry.id !== 'string' ||
+      !INTEGRATION_ID.test(entry.id) ||
+      ids.has(entry.id)
+    ) {
+      return undefined;
+    }
+    ids.add(entry.id);
+    if (entry.phase === 'takeover') {
+      if (sawDeferred || !exactKeys(entry, ['id', 'phase'])) return undefined;
+      integrations.push(Object.freeze({ id: entry.id, phase: 'takeover' }));
+      continue;
+    }
+    if (
+      entry.phase !== 'deferred' ||
+      !exactKeys(entry, ['id', 'phase', 'trigger', 'src']) ||
+      entry.trigger !== 'first_display_or_idle' ||
+      typeof entry.src !== 'string' ||
+      !DEFERRED_SRC.test(entry.src)
+    ) {
+      return undefined;
+    }
+    sawDeferred = true;
+    integrations.push(
+      Object.freeze({
+        id: entry.id,
+        phase: 'deferred',
+        trigger: 'first_display_or_idle',
+        src: entry.src,
+      })
+    );
+  }
+
+  let firstDisplay: BootManifestV1['firstDisplay'];
+  if (root.firstDisplay === null) {
+    firstDisplay = null;
+  } else {
+    const fields = ownPlainDataRecord(root.firstDisplay);
+    const slices = snapshotArray(fields?.slices, FIRST_DISPLAY_IDS.length);
+    if (
+      !fields ||
+      !exactKeys(fields, ['src', 'slices']) ||
+      typeof fields.src !== 'string' ||
+      !slices ||
+      slices.length === 0 ||
+      slices.some((id) => typeof id !== 'string')
+    ) {
+      return undefined;
+    }
+    const match = FIRST_DISPLAY_SRC.exec(fields.src);
+    if (!match) return undefined;
+    const mask = Number.parseInt(match[1]!, 16);
+    const selected = FIRST_DISPLAY_IDS.filter((_id, index) => (mask & (1 << index)) !== 0);
+    if (
+      (mask & 1) === 0 ||
+      mask >>> FIRST_DISPLAY_IDS.length !== 0 ||
+      ((mask & 4) !== 0 && (mask & 2) === 0) ||
+      ((mask & 2) !== 0 && (mask & 128) === 0) ||
+      selected.length !== slices.length ||
+      selected.some((id, index) => id !== slices[index])
+    ) {
+      return undefined;
+    }
+    firstDisplay = Object.freeze({
+      src: fields.src,
+      slices: Object.freeze([...slices] as string[]),
+    });
+  }
+
+  return Object.freeze({
+    version: 1,
+    releaseId,
+    firstDisplay,
+    runtimeSrc: root.runtimeSrc,
+    integrations: Object.freeze(integrations),
+  });
+}
+
+function productForModule(id: string): IntegrationConfigIdV1 | undefined {
+  if (id === 'gpt' || id === 'gpt_later') return 'gpt';
+  if (id === 'osano_consent' || id === 'osano_lifecycle') return 'osano';
+  if (id === 'permutive_context' || id === 'permutive_lifecycle') return 'permutive';
+  if (id === 'prebid' || id === 'prebid_later') return 'prebid';
+  if (id === 'sourcepoint_consent' || id === 'sourcepoint_lifecycle') return 'sourcepoint';
+  return INTEGRATION_CONFIG_IDS_V1.includes(id as IntegrationConfigIdV1)
+    ? (id as IntegrationConfigIdV1)
+    : undefined;
+}
+
+function configMatchesManifest(boot: TsjsBootV1): boolean {
+  const selected = new Set(
+    boot.manifest.integrations.flatMap(({ id }) => {
+      const product = productForModule(id);
+      return product ? [product] : [];
+    })
+  );
+  const expected = INTEGRATION_CONFIG_IDS_V1.filter((id) => selected.has(id));
+  return (
+    expected.length === boot.integrations.entries.length &&
+    expected.every((id, index) => boot.integrations.entries[index]?.id === id)
+  );
+}
+
+function recursivelyFreeze(value: unknown): void {
+  if (typeof value !== 'object' || value === null || Object.isFrozen(value)) return;
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && 'value' in descriptor) recursivelyFreeze(descriptor.value);
+  }
+  Object.freeze(value);
+}
+
+function recursivelyFrozenPlainData(value: unknown, seen = new Set<object>()): boolean {
+  if (typeof value !== 'object' || value === null) return true;
+  if (seen.has(value) || !Object.isFrozen(value)) return false;
+  seen.add(value);
+  const isArray = Array.isArray(value);
+  if (Object.getPrototypeOf(value) !== (isArray ? Array.prototype : Object.prototype)) return false;
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== 'string') return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      !descriptor ||
+      ((!isArray || key !== 'length') && (!descriptor.enumerable || !('value' in descriptor)))
+    ) {
+      return false;
+    }
+    if ('value' in descriptor && !recursivelyFrozenPlainData(descriptor.value, seen)) return false;
+  }
+  return true;
+}
+
+/** Validate and copy the complete server-authored boot contract before browser effects. */
+export function snapshotTsjsBootV1(candidate: unknown, releaseId: string): TsjsBootV1 | undefined {
+  try {
+    if (!RELEASE_ID.test(releaseId)) return undefined;
+    const root = ownPlainDataRecord(candidate);
+    if (
+      !root ||
+      !exactKeys(root, [
+        'abi',
+        'releaseId',
+        'manifest',
+        'auctionProjection',
+        'integrations',
+        'creative',
+        'diagnostics',
+      ]) ||
+      root.abi !== 1 ||
+      root.releaseId !== releaseId
+    ) {
+      return undefined;
+    }
+    const manifest = snapshotManifest(root.manifest, releaseId);
+    const auctionProjection = parseBrowserAuctionProjectionV1(root.auctionProjection);
+    const integrations = snapshotIntegrationConfigsV1(root.integrations);
+    const creative = ownPlainDataRecord(root.creative);
+    const diagnostics = ownPlainDataRecord(root.diagnostics);
+    const gpt = ownPlainDataRecord(diagnostics?.gpt);
+    if (
+      !manifest ||
+      !auctionProjection ||
+      !integrations ||
+      !creative ||
+      !exactKeys(creative, ['version', 'enabled', 'clickGuard', 'renderGuard']) ||
+      creative.version !== 1 ||
+      typeof creative.enabled !== 'boolean' ||
+      typeof creative.clickGuard !== 'boolean' ||
+      typeof creative.renderGuard !== 'boolean' ||
+      (!creative.enabled && (creative.clickGuard || creative.renderGuard)) ||
+      !diagnostics ||
+      !exactKeys(diagnostics, ['version', 'renderTraceOverlay', 'gpt']) ||
+      diagnostics.version !== 1 ||
+      typeof diagnostics.renderTraceOverlay !== 'boolean' ||
+      !gpt ||
+      !exactKeys(gpt, ['active']) ||
+      typeof gpt.active !== 'boolean'
+    ) {
+      return undefined;
+    }
+    recursivelyFreeze(auctionProjection);
+    const boot: TsjsBootV1 = Object.freeze({
+      abi: 1,
+      releaseId,
+      manifest,
+      auctionProjection,
+      integrations,
+      creative: Object.freeze({
+        version: 1,
+        enabled: creative.enabled,
+        clickGuard: creative.clickGuard,
+        renderGuard: creative.renderGuard,
+      }),
+      diagnostics: Object.freeze({
+        version: 1,
+        renderTraceOverlay: diagnostics.renderTraceOverlay,
+        gpt: Object.freeze({ active: gpt.active }),
+      }),
+    });
+    const has = (id: string): boolean => manifest.integrations.some((entry) => entry.id === id);
+    if (
+      !configMatchesManifest(boot) ||
+      has('creative') !==
+        (boot.creative.enabled && (boot.creative.clickGuard || boot.creative.renderGuard)) ||
+      has('gpt_diagnostics') !== boot.diagnostics.gpt.active ||
+      has('diagnostics_presentation') !==
+        (boot.diagnostics.renderTraceOverlay || boot.diagnostics.gpt.active)
+    ) {
+      return undefined;
+    }
+    return boot;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Revalidate one recursively frozen boot and return the independent accepted snapshot. */
+export function snapshotFrozenTsjsBootV1(
+  candidate: unknown,
+  releaseId: string
+): TsjsBootV1 | undefined {
+  try {
+    const accepted = snapshotTsjsBootV1(candidate, releaseId);
+    return accepted &&
+      recursivelyFrozenPlainData(candidate) &&
+      JSON.stringify(candidate) === JSON.stringify(accepted)
+      ? accepted
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Revalidate a bootstrap snapshot while retaining its exact object identity. */
+export function retainTsjsBootSnapshotV1(
+  candidate: unknown,
+  releaseId: string
+): Readonly<TsjsBootV1> | undefined {
+  return snapshotFrozenTsjsBootV1(candidate, releaseId)
+    ? (candidate as Readonly<TsjsBootV1>)
+    : undefined;
+}
+
+/** Capture the exact server lexical, including the one retained immutable boot copy. */
+export function snapshotBootstrapInputV1(
+  candidate: unknown,
+  releaseId: string
+): BootstrapInputSnapshotV1 | undefined {
+  try {
+    const root = ownPlainDataRecord(candidate);
+    if (!root || !exactKeys(root, ['target', 'boot', 'outline'])) return undefined;
+    if (
+      (typeof root.target !== 'object' && typeof root.target !== 'function') ||
+      root.target === null
+    ) {
+      return undefined;
+    }
+    const boot = snapshotTsjsBootV1(root.boot, releaseId);
+    if (!boot) return undefined;
+    let outline: TakeoverOutlineV1 | null = null;
+    if (root.outline !== null) {
+      const acceptedOutline = snapshotTakeoverOutlineV1(root.outline);
+      if (!acceptedOutline) return undefined;
+      outline = acceptedOutline;
+    }
+    const firstDisplay = boot.manifest.firstDisplay;
+    if (
+      (firstDisplay === null && outline !== null) ||
+      (firstDisplay !== null &&
+        (!outline ||
+          outline.releaseId !== releaseId ||
+          outline.integrationConfigDigest !==
+            canonicalIntegrationConfigDigestV1(boot.integrations) ||
+          outline.slotCount !== boot.auctionProjection.slots.length ||
+          outline.outcomeCount !== boot.auctionProjection.auction.results.length ||
+          outline.slices.length !== firstDisplay.slices.length ||
+          outline.slices.some((id, index) => id !== firstDisplay.slices[index])))
+    ) {
+      return undefined;
+    }
+    return Object.freeze({
+      target: root.target as BootstrapInputSnapshotV1['target'],
+      boot,
+      outline,
+    });
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/bounded_string.ts b/crates/trusted-server-js/lib/src/core/contracts/bounded_string.ts
new file mode 100644
index 000000000..ef89f69e5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/bounded_string.ts
@@ -0,0 +1,44 @@
+const reflectApplyIntrinsic = Reflect.apply;
+const textEncoder = new TextEncoder();
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+
+function unicodeScalarCount(value: string): number | undefined {
+  let scalars = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) return undefined;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return undefined;
+    }
+    scalars += 1;
+  }
+  return scalars;
+}
+
+function hasAsciiControl(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+/** Validate a nonempty, well-formed UTF-16 string against byte and scalar bounds. */
+export function validBoundedString(
+  value: unknown,
+  maximumBytes: number,
+  options: { allowControls?: boolean; maximumScalars?: number } = {}
+): value is string {
+  if (typeof value !== 'string' || value.length === 0) return false;
+  const scalarCount = unicodeScalarCount(value);
+  return (
+    scalarCount !== undefined &&
+    (options.allowControls === true || !hasAsciiControl(value)) &&
+    (reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [value]) as Uint8Array)
+      .length <= maximumBytes &&
+    (options.maximumScalars === undefined || scalarCount <= options.maximumScalars)
+  );
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_document_v1.ts b/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_document_v1.ts
new file mode 100644
index 000000000..cd2b0dff9
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_document_v1.ts
@@ -0,0 +1,5 @@
+// @generated by scripts/generate-aps-renderer-contract.mjs
+// schema-sha256: 3f82e9c8d57719c29810a0ed181f4fe2779919c65605ae0cd7c61bd6d865b027
+// corpus-sha256: 3aea612e3316e6df4852e80cb3aa8882ca43d842455a22ba29e63fa88291c7b9
+export const APS_RENDERER_VALIDATOR_ES5_V1 =
+  "// @generated by scripts/generate-aps-renderer-contract.mjs\n// schema-sha256: 3f82e9c8d57719c29810a0ed181f4fe2779919c65605ae0cd7c61bd6d865b027\n// corpus-sha256: 3aea612e3316e6df4852e80cb3aa8882ca43d842455a22ba29e63fa88291c7b9\nvar DESCRIPTOR_KEYS = [\"aaxResponse\",\"accountId\",\"bidId\",\"creativeUrl\",\"height\",\"tagType\",\"type\",\"version\",\"width\"];\nvar DESCRIPTOR_KEYS_WITH_CREATIVE_ID = [\"aaxResponse\",\"accountId\",\"bidId\",\"creativeId\",\"creativeUrl\",\"height\",\"tagType\",\"type\",\"version\",\"width\"];\nvar ENVELOPE_ROOT_KEYS = [\"seatbid\"];\nvar ENVELOPE_SEAT_KEYS = [\"bid\"];\nvar ENVELOPE_BID_KEYS = [\"ext\",\"h\",\"id\",\"price\",\"w\"];\nvar ENVELOPE_EXT_KEYS = [\"creativeurl\",\"tagtype\"];\nvar MAX_ACCOUNT_ID_BYTES = 1024;\nvar MAX_BID_ID_BYTES = 64;\nvar MAX_CREATIVE_ID_BYTES = 1024;\nvar MAX_CREATIVE_URL_BYTES = 4096;\nvar MAX_RENDER_ENVELOPE_BYTES = 262144;\nvar MAX_RENDER_ENVELOPE_BASE64_BYTES = 349528;\nvar STANDARD_BASE64_PATTERN = \"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$\";\nvar RENDER_DIMENSION_MIN = 1;\nvar RENDER_DIMENSION_MAX = 4096;\nfunction apsExactRecord(value, expectedKeys) {\n  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;\n  var prototype = Object.getPrototypeOf(value);\n  if (prototype !== Object.prototype && prototype !== null) return false;\n  if (typeof Object.getOwnPropertySymbols === 'function' && Object.getOwnPropertySymbols(value).length !== 0) return false;\n  var actual = Object.getOwnPropertyNames(value).sort();\n  if (actual.length !== expectedKeys.length) return false;\n  for (var index = 0; index < actual.length; index += 1) {\n    var propertyName = actual[index];\n    if (propertyName === undefined || propertyName !== expectedKeys[index]) return false;\n    var property = Object.getOwnPropertyDescriptor(value, propertyName);\n    if (!property || !Object.prototype.hasOwnProperty.call(property, 'value')) return false;\n  }\n  return true;\n}\n\nfunction apsUtf8Length(value) {\n  return (new TextEncoder()).encode(value).length;\n}\n\nfunction apsHasAsciiControl(value) {\n  return /[\\x00-\\x1f\\x7f]/.test(value);\n}\n\nfunction apsDimensionResult(value) {\n  if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value || value <= 0) {\n    return 'invalid_dimensions';\n  }\n  if (value < RENDER_DIMENSION_MIN || value > RENDER_DIMENSION_MAX) {\n    return 'dimensions_out_of_range';\n  }\n  return 'accepted';\n}\n\nfunction apsValidCreativeUrl(value, publisherOrigin) {\n  try {\n    var url = new URL(value);\n    return url.protocol === 'https:' && url.hostname !== '' && url.username === '' &&\n      url.password === '' && url.origin !== publisherOrigin;\n  } catch (_error) {\n    return false;\n  }\n}\n\nfunction apsDecodeEnvelope(value) {\n  if (value.length === 0 || value.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||\n      value.length % 4 !== 0 || !(new RegExp(STANDARD_BASE64_PATTERN)).test(value)) {\n    return undefined;\n  }\n  try {\n    var binary = atob(value);\n    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;\n    var bytes = new Uint8Array(binary.length);\n    for (var index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);\n    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));\n  } catch (_error) {\n    return undefined;\n  }\n}\n\nfunction classifyApsRendererDescriptorV1(\n  value\n) {\n  var renderer = value;\n  if (!apsExactRecord(renderer, DESCRIPTOR_KEYS) &&\n      !apsExactRecord(renderer, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)) return 'descriptor_invalid';\n  if (renderer.type !== 'aps' || renderer.version !== 1 ||\n      typeof renderer.accountId !== 'string' || renderer.accountId.length === 0 ||\n      apsUtf8Length(renderer.accountId) > MAX_ACCOUNT_ID_BYTES ||\n      typeof renderer.bidId !== 'string' || renderer.bidId.length === 0 ||\n      apsUtf8Length(renderer.bidId) > MAX_BID_ID_BYTES ||\n      apsHasAsciiControl(renderer.bidId)) return 'descriptor_invalid';\n  if (Object.prototype.hasOwnProperty.call(renderer, 'creativeId') &&\n      (typeof renderer.creativeId !== 'string' || renderer.creativeId.length === 0 ||\n       apsUtf8Length(renderer.creativeId) > MAX_CREATIVE_ID_BYTES)) return 'descriptor_invalid';\n  if (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') return 'descriptor_invalid';\n\n  var widthResult = apsDimensionResult(renderer.width);\n  if (widthResult !== 'accepted') return widthResult;\n  var heightResult = apsDimensionResult(renderer.height);\n  if (heightResult !== 'accepted') return heightResult;\n\n  if (typeof renderer.creativeUrl !== 'string' ||\n      apsUtf8Length(renderer.creativeUrl) > MAX_CREATIVE_URL_BYTES ||\n      typeof renderer.aaxResponse !== 'string' ||\n      renderer.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES) return 'descriptor_invalid';\n  return 'accepted';\n}\n\nfunction classifyApsRendererV1(\n  value,\n  publisherOrigin\n) {\n  var renderer = value;\n  var descriptorResult =\n    classifyApsRendererDescriptorV1(renderer);\n  if (descriptorResult !== 'accepted') return descriptorResult;\n  if (!apsValidCreativeUrl(renderer.creativeUrl, publisherOrigin)) return 'descriptor_invalid';\n\n  var decoded = apsDecodeEnvelope(renderer.aaxResponse);\n  if (!apsExactRecord(decoded, ENVELOPE_ROOT_KEYS) || !Array.isArray(decoded.seatbid) ||\n      decoded.seatbid.length !== 1) return 'descriptor_invalid';\n  var seat = decoded.seatbid[0];\n  if (!apsExactRecord(seat, ENVELOPE_SEAT_KEYS) || !Array.isArray(seat.bid) ||\n      seat.bid.length !== 1) return 'descriptor_invalid';\n  var bid = seat.bid[0];\n  if (!apsExactRecord(bid, ENVELOPE_BID_KEYS) ||\n      !apsExactRecord(bid.ext, ENVELOPE_EXT_KEYS)) return 'descriptor_invalid';\n\n  var bidWidthResult = apsDimensionResult(bid.w);\n  if (bidWidthResult !== 'accepted') return bidWidthResult;\n  var bidHeightResult = apsDimensionResult(bid.h);\n  if (bidHeightResult !== 'accepted') return bidHeightResult;\n  if (bid.id !== renderer.bidId || bid.w !== renderer.width || bid.h !== renderer.height ||\n      bid.ext.creativeurl !== renderer.creativeUrl || bid.ext.tagtype !== renderer.tagType ||\n      typeof bid.price !== 'number' || !isFinite(bid.price) || bid.price < 0) {\n    return 'descriptor_invalid';\n  }\n  return 'accepted';\n}\n";
diff --git a/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_v1.ts b/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_v1.ts
new file mode 100644
index 000000000..dec409ae6
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_v1.ts
@@ -0,0 +1,141 @@
+// @generated by scripts/generate-aps-renderer-contract.mjs
+// schema-sha256: 3f82e9c8d57719c29810a0ed181f4fe2779919c65605ae0cd7c61bd6d865b027
+// corpus-sha256: 3aea612e3316e6df4852e80cb3aa8882ca43d842455a22ba29e63fa88291c7b9
+/* eslint-disable */
+export type ApsRendererValidationResult = 'accepted' | 'descriptor_invalid' | 'invalid_dimensions' | 'dimensions_out_of_range';
+var DESCRIPTOR_KEYS = ["aaxResponse","accountId","bidId","creativeUrl","height","tagType","type","version","width"];
+var DESCRIPTOR_KEYS_WITH_CREATIVE_ID = ["aaxResponse","accountId","bidId","creativeId","creativeUrl","height","tagType","type","version","width"];
+var ENVELOPE_ROOT_KEYS = ["seatbid"];
+var ENVELOPE_SEAT_KEYS = ["bid"];
+var ENVELOPE_BID_KEYS = ["ext","h","id","price","w"];
+var ENVELOPE_EXT_KEYS = ["creativeurl","tagtype"];
+var MAX_ACCOUNT_ID_BYTES = 1024;
+var MAX_BID_ID_BYTES = 64;
+var MAX_CREATIVE_ID_BYTES = 1024;
+var MAX_CREATIVE_URL_BYTES = 4096;
+var MAX_RENDER_ENVELOPE_BYTES = 262144;
+var MAX_RENDER_ENVELOPE_BASE64_BYTES = 349528;
+var STANDARD_BASE64_PATTERN = "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$";
+export { MAX_ACCOUNT_ID_BYTES, MAX_BID_ID_BYTES, MAX_CREATIVE_ID_BYTES, MAX_RENDER_ENVELOPE_BASE64_BYTES };
+export const RENDER_DIMENSION_MIN = 1;
+export const RENDER_DIMENSION_MAX = 4096;
+function apsExactRecord(value: any, expectedKeys: string[]): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  var prototype: any = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  if (typeof Object.getOwnPropertySymbols === 'function' && Object.getOwnPropertySymbols(value).length !== 0) return false;
+  var actual: string[] = Object.getOwnPropertyNames(value).sort();
+  if (actual.length !== expectedKeys.length) return false;
+  for (var index = 0; index < actual.length; index += 1) {
+    var propertyName: string | undefined = actual[index];
+    if (propertyName === undefined || propertyName !== expectedKeys[index]) return false;
+    var property: any = Object.getOwnPropertyDescriptor(value, propertyName);
+    if (!property || !Object.prototype.hasOwnProperty.call(property, 'value')) return false;
+  }
+  return true;
+}
+
+function apsUtf8Length(value: string): number {
+  return (new TextEncoder()).encode(value).length;
+}
+
+function apsHasAsciiControl(value: string): boolean {
+  return /[\x00-\x1f\x7f]/.test(value);
+}
+
+function apsDimensionResult(value: any): ApsRendererValidationResult {
+  if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value || value <= 0) {
+    return 'invalid_dimensions';
+  }
+  if (value < RENDER_DIMENSION_MIN || value > RENDER_DIMENSION_MAX) {
+    return 'dimensions_out_of_range';
+  }
+  return 'accepted';
+}
+
+function apsValidCreativeUrl(value: string, publisherOrigin: string): boolean {
+  try {
+    var url: URL = new URL(value);
+    return url.protocol === 'https:' && url.hostname !== '' && url.username === '' &&
+      url.password === '' && url.origin !== publisherOrigin;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function apsDecodeEnvelope(value: string): any | undefined {
+  if (value.length === 0 || value.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||
+      value.length % 4 !== 0 || !(new RegExp(STANDARD_BASE64_PATTERN)).test(value)) {
+    return undefined;
+  }
+  try {
+    var binary: string = atob(value);
+    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;
+    var bytes: Uint8Array = new Uint8Array(binary.length);
+    for (var index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } catch (_error) {
+    return undefined;
+  }
+}
+
+export function classifyApsRendererDescriptorV1(
+  value: unknown
+): ApsRendererValidationResult {
+  var renderer: any = value;
+  if (!apsExactRecord(renderer, DESCRIPTOR_KEYS) &&
+      !apsExactRecord(renderer, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)) return 'descriptor_invalid';
+  if (renderer.type !== 'aps' || renderer.version !== 1 ||
+      typeof renderer.accountId !== 'string' || renderer.accountId.length === 0 ||
+      apsUtf8Length(renderer.accountId) > MAX_ACCOUNT_ID_BYTES ||
+      typeof renderer.bidId !== 'string' || renderer.bidId.length === 0 ||
+      apsUtf8Length(renderer.bidId) > MAX_BID_ID_BYTES ||
+      apsHasAsciiControl(renderer.bidId)) return 'descriptor_invalid';
+  if (Object.prototype.hasOwnProperty.call(renderer, 'creativeId') &&
+      (typeof renderer.creativeId !== 'string' || renderer.creativeId.length === 0 ||
+       apsUtf8Length(renderer.creativeId) > MAX_CREATIVE_ID_BYTES)) return 'descriptor_invalid';
+  if (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') return 'descriptor_invalid';
+
+  var widthResult: ApsRendererValidationResult = apsDimensionResult(renderer.width);
+  if (widthResult !== 'accepted') return widthResult;
+  var heightResult: ApsRendererValidationResult = apsDimensionResult(renderer.height);
+  if (heightResult !== 'accepted') return heightResult;
+
+  if (typeof renderer.creativeUrl !== 'string' ||
+      apsUtf8Length(renderer.creativeUrl) > MAX_CREATIVE_URL_BYTES ||
+      typeof renderer.aaxResponse !== 'string' ||
+      renderer.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES) return 'descriptor_invalid';
+  return 'accepted';
+}
+
+export function classifyApsRendererV1(
+  value: unknown,
+  publisherOrigin: string
+): ApsRendererValidationResult {
+  var renderer: any = value;
+  var descriptorResult: ApsRendererValidationResult =
+    classifyApsRendererDescriptorV1(renderer);
+  if (descriptorResult !== 'accepted') return descriptorResult;
+  if (!apsValidCreativeUrl(renderer.creativeUrl, publisherOrigin)) return 'descriptor_invalid';
+
+  var decoded: any = apsDecodeEnvelope(renderer.aaxResponse);
+  if (!apsExactRecord(decoded, ENVELOPE_ROOT_KEYS) || !Array.isArray(decoded.seatbid) ||
+      decoded.seatbid.length !== 1) return 'descriptor_invalid';
+  var seat: any = decoded.seatbid[0];
+  if (!apsExactRecord(seat, ENVELOPE_SEAT_KEYS) || !Array.isArray(seat.bid) ||
+      seat.bid.length !== 1) return 'descriptor_invalid';
+  var bid: any = seat.bid[0];
+  if (!apsExactRecord(bid, ENVELOPE_BID_KEYS) ||
+      !apsExactRecord(bid.ext, ENVELOPE_EXT_KEYS)) return 'descriptor_invalid';
+
+  var bidWidthResult: ApsRendererValidationResult = apsDimensionResult(bid.w);
+  if (bidWidthResult !== 'accepted') return bidWidthResult;
+  var bidHeightResult: ApsRendererValidationResult = apsDimensionResult(bid.h);
+  if (bidHeightResult !== 'accepted') return bidHeightResult;
+  if (bid.id !== renderer.bidId || bid.w !== renderer.width || bid.h !== renderer.height ||
+      bid.ext.creativeurl !== renderer.creativeUrl || bid.ext.tagtype !== renderer.tagType ||
+      typeof bid.price !== 'number' || !isFinite(bid.price) || bid.price < 0) {
+    return 'descriptor_invalid';
+  }
+  return 'accepted';
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/integration_configs.ts b/crates/trusted-server-js/lib/src/core/contracts/integration_configs.ts
new file mode 100644
index 000000000..692e33d27
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/integration_configs.ts
@@ -0,0 +1,175 @@
+import {
+  INTEGRATION_CONFIG_IDS_V1,
+  type BootJsonValueV1,
+  type IntegrationConfigEntryV1,
+  type IntegrationConfigIdV1,
+  type IntegrationConfigsV1,
+} from '../types';
+
+import { sha256HexUtf8V1 } from './sha256';
+
+export { sha256HexUtf8V1 } from './sha256';
+
+const MAX_DEPTH = 16;
+const MAX_VALUES = 4_096;
+const MAX_STRING_BYTES = 4_096;
+const MAX_ENTRY_BYTES = 65_536;
+const MAX_CARRIER_BYTES = 524_288;
+
+const CONFIG_ORDER = new Map(INTEGRATION_CONFIG_IDS_V1.map((id, index) => [id, index] as const));
+
+function utf8Length(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function ownPlainDataRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+  const result: Record<string, unknown> = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== 'string') return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    Object.defineProperty(result, key, {
+      configurable: true,
+      enumerable: true,
+      value: descriptor.value,
+      writable: true,
+    });
+  }
+  return result;
+}
+
+function exactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  const actual = Object.keys(value);
+  return actual.length === keys.length && actual.every((key) => keys.includes(key));
+}
+
+function snapshotArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+  const length = Object.getOwnPropertyDescriptor(value, 'length');
+  if (!length || !('value' in length) || !Number.isSafeInteger(length.value)) return undefined;
+  if (length.value < 0 || length.value > maximum) return undefined;
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== length.value + 1) return undefined;
+  const result: unknown[] = [];
+  for (let index = 0; index < length.value; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result.push(descriptor.value);
+  }
+  return result;
+}
+
+function snapshotJsonValue(
+  candidate: unknown,
+  depth: number,
+  seen: Set<object>,
+  count: { value: number }
+): BootJsonValueV1 | undefined {
+  if (candidate === null || typeof candidate === 'boolean') {
+    count.value += 1;
+    return count.value <= MAX_VALUES ? candidate : undefined;
+  }
+  if (typeof candidate === 'number') {
+    count.value += 1;
+    return count.value <= MAX_VALUES && Number.isFinite(candidate) ? candidate : undefined;
+  }
+  if (typeof candidate === 'string') {
+    count.value += 1;
+    return count.value <= MAX_VALUES && utf8Length(candidate) <= MAX_STRING_BYTES
+      ? candidate
+      : undefined;
+  }
+  if (typeof candidate !== 'object' || depth > MAX_DEPTH || seen.has(candidate)) {
+    return undefined;
+  }
+  seen.add(candidate);
+  count.value += 1;
+  if (count.value > MAX_VALUES) return undefined;
+
+  const array = snapshotArray(candidate, MAX_VALUES);
+  if (array) {
+    const copy: BootJsonValueV1[] = [];
+    for (const value of array) {
+      const accepted = snapshotJsonValue(value, depth + 1, seen, count);
+      if (accepted === undefined && value !== null) return undefined;
+      copy.push(accepted as BootJsonValueV1);
+    }
+    return Object.freeze(copy);
+  }
+
+  const record = ownPlainDataRecord(candidate);
+  if (!record) return undefined;
+  const copy: Record<string, BootJsonValueV1> = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (utf8Length(key) > MAX_STRING_BYTES) return undefined;
+    const accepted = snapshotJsonValue(value, depth + 1, seen, count);
+    if (accepted === undefined && value !== null) return undefined;
+    Object.defineProperty(copy, key, {
+      configurable: true,
+      enumerable: true,
+      value: accepted as BootJsonValueV1,
+      writable: true,
+    });
+  }
+  return Object.freeze(copy);
+}
+
+/** Copy and recursively freeze the sole generic browser configuration carrier. */
+export function snapshotIntegrationConfigsV1(candidate: unknown): IntegrationConfigsV1 | undefined {
+  try {
+    const root = ownPlainDataRecord(candidate);
+    if (!root || !exactKeys(root, ['version', 'entries']) || root.version !== 1) return undefined;
+    const entries = snapshotArray(root.entries, INTEGRATION_CONFIG_IDS_V1.length);
+    if (!entries) return undefined;
+    const seen = new Set<object>();
+    const count = { value: 0 };
+    const accepted = [];
+    let previous = -1;
+    for (const candidateEntry of entries) {
+      const entry = ownPlainDataRecord(candidateEntry);
+      if (!entry || !exactKeys(entry, ['id', 'config']) || typeof entry.id !== 'string') {
+        return undefined;
+      }
+      const order = CONFIG_ORDER.get(entry.id as IntegrationConfigIdV1);
+      if (order === undefined || order <= previous) return undefined;
+      const config = snapshotJsonValue(entry.config, 0, seen, count);
+      if (
+        !config ||
+        Array.isArray(config) ||
+        typeof config !== 'object' ||
+        utf8Length(JSON.stringify({ id: entry.id, config })) > MAX_ENTRY_BYTES
+      ) {
+        return undefined;
+      }
+      accepted.push(
+        Object.freeze({
+          id: entry.id as IntegrationConfigIdV1,
+          config: config as Readonly<Record<string, BootJsonValueV1>>,
+        })
+      );
+      previous = order;
+    }
+    const result: IntegrationConfigsV1 = Object.freeze({
+      version: 1,
+      entries: Object.freeze(accepted),
+    });
+    return utf8Length(JSON.stringify(result)) <= MAX_CARRIER_BYTES ? result : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Return one already-frozen product value without exposing the carrier map. */
+export function integrationConfigValueV1(
+  carrier: IntegrationConfigsV1,
+  id: IntegrationConfigIdV1
+): IntegrationConfigEntryV1['config'] | undefined {
+  return carrier.entries.find((entry) => entry.id === id)?.config;
+}
+
+/** Bind a retained carrier snapshot to first-display takeover metadata. */
+export function canonicalIntegrationConfigDigestV1(carrier: IntegrationConfigsV1): string {
+  return sha256HexUtf8V1(JSON.stringify(carrier));
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/request_ads.ts b/crates/trusted-server-js/lib/src/core/contracts/request_ads.ts
new file mode 100644
index 000000000..0258dbe14
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/request_ads.ts
@@ -0,0 +1,182 @@
+const REQUEST_ADS_DEFAULT_TIMEOUT_MS = 10_000;
+const REQUEST_ADS_MAX_SLOTS = 256;
+const reflectApplyIntrinsic = Reflect.apply;
+const objectGetOwnPropertyNamesIntrinsic = Object.getOwnPropertyNames;
+const objectKeysIntrinsic = Object.keys;
+const textEncoder = new TextEncoder();
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+const regExpTestIntrinsic = RegExp.prototype.test;
+const loneSurrogatePattern = /[\uD800-\uDFFF]/u;
+const abortSignalAbortedGetter =
+  typeof AbortSignal === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(AbortSignal.prototype, 'aborted')?.get;
+
+export type RequestAdsInputErrorCode =
+  | 'invalid_options'
+  | 'invalid_slots'
+  | 'empty_slots'
+  | 'duplicate_slot'
+  | 'invalid_timeout'
+  | 'invalid_signal';
+
+export class RequestAdsInputError extends Error {
+  public readonly code: RequestAdsInputErrorCode;
+
+  public constructor(code: RequestAdsInputErrorCode) {
+    super(code);
+    this.name = 'RequestAdsInputError';
+    this.code = code;
+  }
+}
+
+export interface ValidatedRequestAdsOptions {
+  readonly aborted: boolean;
+  readonly signal: AbortSignal | undefined;
+  readonly slots: readonly string[] | undefined;
+  readonly timeoutMs: number;
+}
+
+function ownDataOptions(value: unknown): Record<string, unknown> | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    const names = reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [
+      value,
+    ]) as string[];
+    for (let index = 0; index < names.length; index += 1) {
+      const key = names[index];
+      if (key === undefined) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      output[key] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownDataSlots(value: unknown): readonly unknown[] | undefined {
+  try {
+    if (
+      !Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Array.prototype ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return undefined;
+    }
+    const length = Object.getOwnPropertyDescriptor(value, 'length');
+    if (
+      !length ||
+      !('value' in length) ||
+      !Number.isSafeInteger(length.value) ||
+      length.value < 0 ||
+      length.value > REQUEST_ADS_MAX_SLOTS ||
+      (reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [value]) as string[])
+        .length !==
+        length.value + 1
+    ) {
+      return undefined;
+    }
+    const output: unknown[] = [];
+    for (let index = 0; index < length.value; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      output[index] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function readAbortSignal(signal: unknown): boolean | undefined {
+  try {
+    return typeof abortSignalAbortedGetter === 'function'
+      ? (reflectApplyIntrinsic(abortSignalAbortedGetter, signal, []) as boolean)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasAsciiControl(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 0x1f || code === 0x7f) return true;
+  }
+  return false;
+}
+
+/** Validate and detach the complete public request before creating attempts. */
+export function validateRequestAdsOptions(value: unknown): ValidatedRequestAdsOptions {
+  if (value === undefined) {
+    return Object.freeze({
+      aborted: false,
+      signal: undefined,
+      slots: undefined,
+      timeoutMs: REQUEST_ADS_DEFAULT_TIMEOUT_MS,
+    });
+  }
+  const options = ownDataOptions(value);
+  if (!options) throw new RequestAdsInputError('invalid_options');
+  const optionKeys = reflectApplyIntrinsic(objectKeysIntrinsic, Object, [options]) as string[];
+  for (let index = 0; index < optionKeys.length; index += 1) {
+    const key = optionKeys[index];
+    if (key === 'slots' || key === 'timeoutMs' || key === 'signal') continue;
+    throw new RequestAdsInputError('invalid_options');
+  }
+
+  let slots: readonly string[] | undefined;
+  if (Object.prototype.hasOwnProperty.call(options, 'slots')) {
+    const rawSlots = ownDataSlots(options.slots);
+    if (!rawSlots) throw new RequestAdsInputError('invalid_slots');
+    if (rawSlots.length === 0) throw new RequestAdsInputError('empty_slots');
+    const seen = new Set<string>();
+    const copy: string[] = [];
+    for (let index = 0; index < rawSlots.length; index += 1) {
+      const slot = rawSlots[index];
+      if (
+        typeof slot !== 'string' ||
+        slot.length === 0 ||
+        (reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [slot]) as Uint8Array)
+          .byteLength > 256 ||
+        hasAsciiControl(slot) ||
+        reflectApplyIntrinsic(regExpTestIntrinsic, loneSurrogatePattern, [slot])
+      ) {
+        throw new RequestAdsInputError('invalid_slots');
+      }
+      if (seen.has(slot)) throw new RequestAdsInputError('duplicate_slot');
+      seen.add(slot);
+      copy.push(slot);
+    }
+    slots = Object.freeze(copy);
+  }
+
+  let timeoutMs = REQUEST_ADS_DEFAULT_TIMEOUT_MS;
+  if (Object.prototype.hasOwnProperty.call(options, 'timeoutMs')) {
+    if (
+      typeof options.timeoutMs !== 'number' ||
+      !Number.isInteger(options.timeoutMs) ||
+      options.timeoutMs < 100 ||
+      options.timeoutMs > 30_000
+    ) {
+      throw new RequestAdsInputError('invalid_timeout');
+    }
+    timeoutMs = options.timeoutMs;
+  }
+
+  let signal: AbortSignal | undefined;
+  let aborted = false;
+  if (Object.prototype.hasOwnProperty.call(options, 'signal')) {
+    const observed = readAbortSignal(options.signal);
+    if (observed === undefined) throw new RequestAdsInputError('invalid_signal');
+    signal = options.signal as AbortSignal;
+    aborted = observed;
+  }
+  return Object.freeze({ aborted, signal, slots, timeoutMs });
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/server_boot_transport.ts b/crates/trusted-server-js/lib/src/core/contracts/server_boot_transport.ts
new file mode 100644
index 000000000..0537eda42
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/server_boot_transport.ts
@@ -0,0 +1,328 @@
+import type { TakeoverOutlineV1 } from '../../shared/first_display_contracts';
+import type { BootManifestV1, TsjsBootV1 } from '../types';
+
+const MAX_TRANSPORT_BYTES = 10 * 1024 * 1024;
+const MAX_TAKEOVER_INTEGRATIONS = 14;
+const RELEASE_ID = /^[0-9a-f]{64}$/;
+const HASH = /^[0-9a-f]{64}$/;
+const INTEGRATION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const FIRST_DISPLAY_SRC =
+  /^\/static\/tsjs=tsjs-first-display\.min\.js\?m=([0-9a-f]{4})&v=[0-9a-f]{64}$/;
+const RUNTIME_SRC = /^\/static\/tsjs=tsjs-unified\.min\.js\?v=[0-9a-f]{64}$/;
+const DEFERRED_SRC = /^\/static\/tsjs=tsjs-([a-z0-9][a-z0-9_-]{0,63})\.min\.js\?v=[0-9a-f]{64}$/;
+const FIRST_DISPLAY_IDS = Object.freeze([
+  'first_display',
+  'render_owner_initial',
+  'aps_initial',
+  'creative_initial',
+  'datadome_initial',
+  'didomi_initial',
+  'google_tag_manager_initial',
+  'gpt_initial',
+  'lockr_initial',
+  'osano_initial',
+  'permutive_initial',
+  'sourcepoint_initial',
+  'prebid_initial',
+  'testlight_initial',
+] as const);
+const CONFIG_IDS = Object.freeze([
+  'aps',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'sourcepoint',
+  'testlight',
+] as const);
+export interface ServerBootIntegrityV1 {
+  readonly version: 1;
+  readonly projectionDigest: string;
+  readonly integrationConfigDigest: string;
+}
+
+export interface ServerBootTransportSnapshotV1 {
+  readonly version: 1;
+  readonly boot: Readonly<TsjsBootV1>;
+  readonly integrity: Readonly<ServerBootIntegrityV1>;
+  readonly outline: TakeoverOutlineV1 | null;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function exact(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  const candidate = record(value);
+  if (!candidate || Object.getPrototypeOf(candidate) !== Object.prototype) return undefined;
+  const actual = Object.keys(candidate);
+  return actual.length === keys.length && actual.every((key) => keys.includes(key))
+    ? candidate
+    : undefined;
+}
+
+export function deepFreezeTransportV1(value: unknown): void {
+  if (typeof value !== 'object' || value === null || Object.isFrozen(value)) return;
+  for (const key of Object.keys(value)) {
+    deepFreezeTransportV1((value as Record<string, unknown>)[key]);
+  }
+  Object.freeze(value);
+}
+
+function validManifest(candidate: unknown, releaseId: string): BootManifestV1 | undefined {
+  const manifest = exact(candidate, [
+    'version',
+    'releaseId',
+    'firstDisplay',
+    'runtimeSrc',
+    'integrations',
+  ]);
+  if (
+    !manifest ||
+    manifest.version !== 1 ||
+    manifest.releaseId !== releaseId ||
+    typeof manifest.runtimeSrc !== 'string' ||
+    !RUNTIME_SRC.test(manifest.runtimeSrc) ||
+    !Array.isArray(manifest.integrations) ||
+    manifest.integrations.length > 20
+  ) {
+    return undefined;
+  }
+  const seen = new Set<string>();
+  let deferred = false;
+  let takeoverCount = 0;
+  for (const value of manifest.integrations) {
+    const integration = record(value);
+    if (
+      !integration ||
+      typeof integration.id !== 'string' ||
+      !INTEGRATION_ID.test(integration.id) ||
+      seen.has(integration.id)
+    ) {
+      return undefined;
+    }
+    seen.add(integration.id);
+    if (integration.phase === 'takeover') {
+      takeoverCount += 1;
+      if (
+        deferred ||
+        takeoverCount > MAX_TAKEOVER_INTEGRATIONS ||
+        !exact(integration, ['id', 'phase'])
+      ) {
+        return undefined;
+      }
+      continue;
+    }
+    const deferredSource =
+      typeof integration.src === 'string' ? DEFERRED_SRC.exec(integration.src) : null;
+    if (
+      integration.phase !== 'deferred' ||
+      !exact(integration, ['id', 'phase', 'trigger', 'src']) ||
+      integration.trigger !== 'first_display_or_idle' ||
+      deferredSource?.[1] !== integration.id
+    ) {
+      return undefined;
+    }
+    deferred = true;
+  }
+  if (manifest.firstDisplay === null) return manifest as unknown as BootManifestV1;
+  const firstDisplay = exact(manifest.firstDisplay, ['src', 'slices']);
+  const slices = firstDisplay?.slices;
+  if (
+    !firstDisplay ||
+    typeof firstDisplay.src !== 'string' ||
+    !Array.isArray(slices) ||
+    slices.length === 0 ||
+    slices.length > FIRST_DISPLAY_IDS.length
+  ) {
+    return undefined;
+  }
+  const match = FIRST_DISPLAY_SRC.exec(firstDisplay.src);
+  if (!match) return undefined;
+  const mask = Number.parseInt(match[1]!, 16);
+  const selected = FIRST_DISPLAY_IDS.filter((_id, index) => (mask & (1 << index)) !== 0);
+  if (
+    (mask & 1) === 0 ||
+    mask >>> FIRST_DISPLAY_IDS.length !== 0 ||
+    ((mask & 4) !== 0 && (mask & 2) === 0) ||
+    ((mask & 2) !== 0 && (mask & 128) === 0) ||
+    selected.length !== slices.length ||
+    selected.some((id, index) => slices[index] !== id)
+  ) {
+    return undefined;
+  }
+  return manifest as unknown as BootManifestV1;
+}
+
+function validBoot(candidate: unknown, releaseId: string): Readonly<TsjsBootV1> | undefined {
+  const boot = exact(candidate, [
+    'abi',
+    'releaseId',
+    'manifest',
+    'auctionProjection',
+    'integrations',
+    'creative',
+    'diagnostics',
+  ]);
+  if (!boot || boot.abi !== 1 || boot.releaseId !== releaseId) return undefined;
+  if (!validManifest(boot.manifest, releaseId)) return undefined;
+
+  const projection = exact(boot.auctionProjection, ['version', 'auction', 'slots', 'bids']);
+  const auction = exact(projection?.auction, ['version', 'auctionId', 'results']);
+  if (
+    !projection ||
+    projection.version !== 1 ||
+    !auction ||
+    auction.version !== 1 ||
+    typeof auction.auctionId !== 'string' ||
+    !Array.isArray(auction.results) ||
+    auction.results.length > 256 ||
+    !Array.isArray(projection.slots) ||
+    projection.slots.length > 256 ||
+    !Array.isArray(projection.bids)
+  ) {
+    return undefined;
+  }
+
+  const integrations = exact(boot.integrations, ['version', 'entries']);
+  if (
+    !integrations ||
+    integrations.version !== 1 ||
+    !Array.isArray(integrations.entries) ||
+    integrations.entries.length > CONFIG_IDS.length
+  ) {
+    return undefined;
+  }
+  let previous = -1;
+  for (const value of integrations.entries) {
+    const entry = exact(value, ['id', 'config']);
+    const order =
+      entry && typeof entry.id === 'string'
+        ? CONFIG_IDS.indexOf(entry.id as (typeof CONFIG_IDS)[number])
+        : -1;
+    if (!entry || order <= previous || !record(entry.config)) return undefined;
+    previous = order;
+  }
+
+  const creative = exact(boot.creative, ['version', 'enabled', 'clickGuard', 'renderGuard']);
+  const diagnostics = exact(boot.diagnostics, ['version', 'renderTraceOverlay', 'gpt']);
+  const gpt = exact(diagnostics?.gpt, ['active']);
+  if (
+    !creative ||
+    creative.version !== 1 ||
+    typeof creative.enabled !== 'boolean' ||
+    typeof creative.clickGuard !== 'boolean' ||
+    typeof creative.renderGuard !== 'boolean' ||
+    (!creative.enabled && (creative.clickGuard || creative.renderGuard)) ||
+    !diagnostics ||
+    diagnostics.version !== 1 ||
+    typeof diagnostics.renderTraceOverlay !== 'boolean' ||
+    !gpt ||
+    typeof gpt.active !== 'boolean'
+  ) {
+    return undefined;
+  }
+  return boot as unknown as Readonly<TsjsBootV1>;
+}
+function validIntegrity(candidate: unknown): Readonly<ServerBootIntegrityV1> | undefined {
+  const integrity = exact(candidate, ['version', 'projectionDigest', 'integrationConfigDigest']);
+  return integrity &&
+    integrity.version === 1 &&
+    typeof integrity.projectionDigest === 'string' &&
+    HASH.test(integrity.projectionDigest) &&
+    typeof integrity.integrationConfigDigest === 'string' &&
+    HASH.test(integrity.integrationConfigDigest)
+    ? (integrity as unknown as Readonly<ServerBootIntegrityV1>)
+    : undefined;
+}
+
+function validOutline(
+  candidate: unknown,
+  releaseId: string,
+  integrity: Readonly<ServerBootIntegrityV1>,
+  boot: Readonly<TsjsBootV1>
+): TakeoverOutlineV1 | null | undefined {
+  if (candidate === null) return boot.manifest.firstDisplay === null ? null : undefined;
+  const outline = exact(candidate, [
+    'version',
+    'releaseId',
+    'generation',
+    'projectionDigest',
+    'integrationConfigDigest',
+    'slices',
+    'slotCount',
+    'outcomeCount',
+    'capabilities',
+    'objectKinds',
+  ]);
+  const firstDisplay = boot.manifest.firstDisplay;
+  const projection = boot.auctionProjection;
+  if (
+    !outline ||
+    !firstDisplay ||
+    outline.version !== 1 ||
+    outline.releaseId !== releaseId ||
+    !Number.isInteger(outline.generation) ||
+    (outline.generation as number) < 1 ||
+    (outline.generation as number) > 4_294_967_295 ||
+    outline.projectionDigest !== integrity.projectionDigest ||
+    outline.integrationConfigDigest !== integrity.integrationConfigDigest ||
+    !Array.isArray(outline.slices) ||
+    outline.slices.length !== firstDisplay.slices.length ||
+    outline.slices.some((id, index) => id !== firstDisplay.slices[index]) ||
+    !Number.isInteger(outline.slotCount) ||
+    outline.slotCount !== projection.slots.length ||
+    (outline.slotCount as number) < 1 ||
+    !Number.isInteger(outline.outcomeCount) ||
+    outline.outcomeCount !== projection.auction.results.length ||
+    outline.outcomeCount !== outline.slotCount ||
+    !Array.isArray(outline.capabilities) ||
+    outline.capabilities.length !== 0 ||
+    !Array.isArray(outline.objectKinds)
+  ) {
+    return undefined;
+  }
+  const expectedKinds = projection.bids.length === 0 ? [] : ['gpt_slot', 'dom_artifact'];
+  if (
+    outline.objectKinds.length !== expectedKinds.length ||
+    outline.objectKinds.some((kind, index) => kind !== expectedKinds[index])
+  ) {
+    return undefined;
+  }
+  return outline as unknown as TakeoverOutlineV1;
+}
+
+/** Parse the one server-sealed lexical boot value without importing domain validators. */
+export function snapshotServerBootTransportV1(
+  payload: unknown,
+  releaseId: string
+): ServerBootTransportSnapshotV1 | undefined {
+  try {
+    if (
+      typeof payload !== 'string' ||
+      typeof releaseId !== 'string' ||
+      !RELEASE_ID.test(releaseId) ||
+      payload.length > MAX_TRANSPORT_BYTES ||
+      new TextEncoder().encode(payload).byteLength > MAX_TRANSPORT_BYTES
+    ) {
+      return undefined;
+    }
+    const root = exact(JSON.parse(payload), ['version', 'boot', 'integrity', 'outline']);
+    if (!root || root.version !== 1) return undefined;
+    const boot = validBoot(root.boot, releaseId);
+    const integrity = validIntegrity(root.integrity);
+    if (!boot || !integrity) return undefined;
+    const outline = validOutline(root.outline, releaseId, integrity, boot);
+    if (outline === undefined) return undefined;
+    deepFreezeTransportV1(root);
+    return root as unknown as ServerBootTransportSnapshotV1;
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/contracts/sha256.ts b/crates/trusted-server-js/lib/src/core/contracts/sha256.ts
new file mode 100644
index 000000000..49887c590
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/contracts/sha256.ts
@@ -0,0 +1,75 @@
+const H: number[] = [];
+const K: number[] = [];
+const ENCODER = new TextEncoder();
+for (let n = 2; K.length < 64; n += 1) {
+  let prime = true;
+  for (let d = 2; d * d <= n; d += 1) {
+    if (n % d === 0) {
+      prime = false;
+      break;
+    }
+  }
+  if (!prime) continue;
+  if (H.length < 8) H.push((Math.sqrt(n) * 0x1_0000_0000) >>> 0);
+  K.push((Math.cbrt(n) * 0x1_0000_0000) >>> 0);
+}
+
+function rotr(word: number, bits: number): number {
+  return (word >>> bits) | (word << (32 - bits));
+}
+
+/** Calculate SHA-256 synchronously so boot validation remains effect-inert. */
+export function sha256HexUtf8V1(text: string): string {
+  const bytes = ENCODER.encode(text);
+  const length = Math.ceil((bytes.length + 9) / 64) * 64;
+  const data = new Uint8Array(length);
+  data.set(bytes);
+  data[bytes.length] = 0x80;
+  const bits = bytes.length * 8;
+  const view = new DataView(data.buffer);
+  view.setUint32(length - 8, Math.floor(bits / 0x1_0000_0000));
+  view.setUint32(length - 4, bits >>> 0);
+  const state = [...H];
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i += 1) {
+      const left = w[i - 15]!;
+      const right = w[i - 2]!;
+      const s0 = rotr(left, 7) ^ rotr(left, 18) ^ (left >>> 3);
+      const s1 = rotr(right, 17) ^ rotr(right, 19) ^ (right >>> 10);
+      w[i] = (w[i - 16]! + s0 + w[i - 7]! + s1) >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = state;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rotr(e!, 6) ^ rotr(e!, 11) ^ rotr(e!, 25);
+      const ch = (e! & f!) ^ (~e! & g!);
+      const t1 = (h! + s1 + ch + K[i]! + w[i]!) >>> 0;
+      const s0 = rotr(a!, 2) ^ rotr(a!, 13) ^ rotr(a!, 22);
+      const maj = (a! & b!) ^ (a! & c!) ^ (b! & c!);
+      const t2 = (s0 + maj) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d! + t1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) >>> 0;
+    }
+    state[0] = (state[0]! + a!) >>> 0;
+    state[1] = (state[1]! + b!) >>> 0;
+    state[2] = (state[2]! + c!) >>> 0;
+    state[3] = (state[3]! + d!) >>> 0;
+    state[4] = (state[4]! + e!) >>> 0;
+    state[5] = (state[5]! + f!) >>> 0;
+    state[6] = (state[6]! + g!) >>> 0;
+    state[7] = (state[7]! + h!) >>> 0;
+  }
+  return state.map((word) => word.toString(16).padStart(8, '0')).join('');
+}
+
+/** Measure UTF-8 with the same intrinsic used by the synchronous digest. */
+export function utf8LengthV1(text: string): number {
+  return ENCODER.encode(text).byteLength;
+}
diff --git a/crates/trusted-server-js/lib/src/core/first_impression.ts b/crates/trusted-server-js/lib/src/core/first_impression.ts
deleted file mode 100644
index 05252fcc1..000000000
--- a/crates/trusted-server-js/lib/src/core/first_impression.ts
+++ /dev/null
@@ -1,386 +0,0 @@
-import { resolveSlotElementByDivId } from './slot_element';
-import type {
-  FirstImpressionPhase,
-  FirstImpressionPublisherAuction,
-  FirstImpressionSlotClaim,
-  FirstImpressionState,
-  TsjsApi,
-} from './types';
-
-/** Time allowed for one navigation's losing first-impression delivery. */
-export const FIRST_IMPRESSION_LEASE_MS = 5000;
-
-const MAX_FIRST_IMPRESSION_SLOTS = 256;
-const MAX_PUBLISHER_AUCTIONS_PER_SLOT = 16;
-
-function currentGeneration(ts: TsjsApi): number {
-  return ts.navGeneration ?? 0;
-}
-
-function claimMatchesElement(
-  claim: FirstImpressionSlotClaim,
-  element: HTMLElement,
-  generation: number
-): boolean {
-  return (
-    claim.generation === generation &&
-    claim.slotElementId === element.id &&
-    claim.element === element &&
-    element.ownerDocument === document &&
-    element.isConnected &&
-    document.getElementById(element.id) === element
-  );
-}
-
-function removePublisherAuction(
-  state: FirstImpressionState,
-  claim: FirstImpressionSlotClaim,
-  token: string,
-  now: number
-): void {
-  delete claim.publisherAuctions[token];
-  if (
-    claim.owner === 'publisher' &&
-    (claim.phase === 'auctioning' || claim.phase === 'delivery_pending') &&
-    Object.keys(claim.publisherAuctions).length === 0 &&
-    claim.expiresAt <= now
-  ) {
-    delete state.slots[claim.slotElementId];
-  }
-}
-
-function pruneFirstImpressionState(ts: TsjsApi, now = Date.now()): FirstImpressionState {
-  const generation = currentGeneration(ts);
-  if (ts.firstImpression?.generation !== generation) {
-    ts.firstImpression = { generation, nextToken: 0, slots: {}, fallbackSlots: {} };
-  }
-
-  const state = ts.firstImpression;
-  state.slots ??= {};
-  state.fallbackSlots ??= {};
-  for (const [elementId, claim] of Object.entries(state.slots)) {
-    if (
-      claim.slotElementId !== elementId ||
-      !claimMatchesElement(claim, claim.element, generation)
-    ) {
-      delete state.slots[elementId];
-      continue;
-    }
-    const hasReservedFallback =
-      claim.owner === 'publisher' &&
-      (claim.phase === 'auctioning' || claim.phase === 'delivery_pending') &&
-      state.fallbackSlots[elementId] === claim.element;
-    for (const [token, auction] of Object.entries(claim.publisherAuctions)) {
-      // A TS-owned losing publisher auction remains a fail-closed tombstone for
-      // this physical element and navigation. Publisher registrations also stay
-      // intact while an expired claim is waiting to transition to its reserved
-      // TS fallback, so an overlapping late callback cannot escape suppression.
-      if (
-        auction.expiresAt <= now &&
-        !hasReservedFallback &&
-        !(claim.owner === 'trusted_server' && auction.suppressDelivery)
-      ) {
-        removePublisherAuction(state, claim, token, now);
-      }
-    }
-    if (
-      claim.owner === 'publisher' &&
-      (claim.phase === 'auctioning' || claim.phase === 'delivery_pending') &&
-      Object.keys(claim.publisherAuctions).length === 0 &&
-      claim.expiresAt <= now &&
-      !hasReservedFallback
-    ) {
-      delete state.slots[elementId];
-    }
-  }
-  for (const [elementId, element] of Object.entries(state.fallbackSlots)) {
-    if (
-      !element.isConnected ||
-      element.id !== elementId ||
-      document.getElementById(elementId) !== element
-    ) {
-      delete state.fallbackSlots[elementId];
-    }
-  }
-  return state;
-}
-
-/** Resolve a publisher ad-unit code with the same contract GPT uses. */
-export function resolveFirstImpressionElement(adUnitCode: string): HTMLElement | undefined {
-  return resolveSlotElementByDivId(adUnitCode).element ?? undefined;
-}
-
-/** Return the live ownership claim for an exact slot element. */
-export function firstImpressionClaim(
-  ts: TsjsApi,
-  element: HTMLElement
-): FirstImpressionSlotClaim | undefined {
-  const state = pruneFirstImpressionState(ts);
-  const claim = state.slots[element.id];
-  return claim && claimMatchesElement(claim, element, state.generation) ? claim : undefined;
-}
-
-function storeClaim(state: FirstImpressionState, claim: FirstImpressionSlotClaim): boolean {
-  if (
-    !state.slots[claim.slotElementId] &&
-    Object.keys(state.slots).length >= MAX_FIRST_IMPRESSION_SLOTS
-  ) {
-    return false;
-  }
-  state.slots[claim.slotElementId] = claim;
-  return true;
-}
-
-/** Atomically claim an untouched slot for Trusted Server. */
-export function claimFirstImpressionForTrustedServer(
-  ts: TsjsApi,
-  element: HTMLElement,
-  now = Date.now()
-): FirstImpressionSlotClaim | undefined {
-  const state = pruneFirstImpressionState(ts, now);
-  const existing = state.slots[element.id];
-  if (existing && claimMatchesElement(existing, element, state.generation)) {
-    const canTransitionPublisherFallback =
-      existing.owner === 'publisher' &&
-      existing.phase !== 'requested' &&
-      existing.phase !== 'rendered' &&
-      existing.expiresAt <= now &&
-      state.fallbackSlots[element.id] === element;
-    if (!canTransitionPublisherFallback) return undefined;
-
-    existing.owner = 'trusted_server';
-    existing.phase = 'delivery_pending';
-    existing.expiresAt = now + FIRST_IMPRESSION_LEASE_MS;
-    for (const auction of Object.values(existing.publisherAuctions)) {
-      auction.suppressDelivery = true;
-    }
-    return existing;
-  }
-
-  const claim: FirstImpressionSlotClaim = {
-    generation: state.generation,
-    slotElementId: element.id,
-    element,
-    owner: 'trusted_server',
-    phase: 'delivery_pending',
-    expiresAt: now + FIRST_IMPRESSION_LEASE_MS,
-    publisherAuctions: {},
-  };
-  return storeClaim(state, claim) ? claim : undefined;
-}
-
-function schedulePublisherAuctionExpiry(ts: TsjsApi, token: string): void {
-  window.setTimeout(() => {
-    // Pruning releases ordinary publisher claims. TS-owned suppression tokens
-    // deliberately survive as bounded tombstones until navigation/element change.
-    findPublisherAuction(ts, token);
-  }, FIRST_IMPRESSION_LEASE_MS);
-}
-
-/** Release a TS claim when slot setup failed before any request could start. */
-export function releaseTrustedServerFirstImpressionClaim(
-  ts: TsjsApi,
-  element: HTMLElement,
-  claim: FirstImpressionSlotClaim
-): void {
-  const state = pruneFirstImpressionState(ts);
-  if (
-    state.slots[element.id] === claim &&
-    claim.owner === 'trusted_server' &&
-    claim.phase === 'delivery_pending'
-  ) {
-    delete state.slots[element.id];
-    if (state.fallbackSlots[element.id] === element) {
-      delete state.fallbackSlots[element.id];
-    }
-  }
-}
-
-/** Register real publisher auctions before native `requestBids()` starts. */
-export function registerPublisherFirstImpressionAuctions(
-  ts: TsjsApi,
-  adUnitCodes: Iterable<string>,
-  now = Date.now()
-): Map<string, string> {
-  const state = pruneFirstImpressionState(ts, now);
-  const registrations = new Map<string, string>();
-
-  for (const adUnitCode of adUnitCodes) {
-    const element = resolveFirstImpressionElement(adUnitCode);
-    if (!element) continue;
-
-    let claim = state.slots[element.id];
-    if (!claim || !claimMatchesElement(claim, element, state.generation)) {
-      claim = {
-        generation: state.generation,
-        slotElementId: element.id,
-        element,
-        owner: 'publisher',
-        phase: 'auctioning',
-        expiresAt: now + FIRST_IMPRESSION_LEASE_MS,
-        publisherAuctions: {},
-      };
-      if (!storeClaim(state, claim)) continue;
-    }
-
-    if (
-      claim.owner === 'publisher' &&
-      (claim.phase === 'requested' || claim.phase === 'rendered')
-    ) {
-      continue;
-    }
-    if (
-      claim.owner === 'trusted_server' &&
-      (claim.publisherRegistrationClosed || claim.expiresAt <= now)
-    ) {
-      continue;
-    }
-    if (Object.keys(claim.publisherAuctions).length >= MAX_PUBLISHER_AUCTIONS_PER_SLOT) continue;
-
-    const token = `${state.generation}:${++state.nextToken}`;
-    const auction: FirstImpressionPublisherAuction = {
-      token,
-      adUnitCode,
-      phase: 'auctioning',
-      expiresAt: now + FIRST_IMPRESSION_LEASE_MS,
-      adIds: [],
-      suppressDelivery: claim.owner === 'trusted_server',
-    };
-    claim.publisherAuctions[token] = auction;
-    if (claim.owner === 'publisher') claim.expiresAt = Math.max(claim.expiresAt, auction.expiresAt);
-    registrations.set(adUnitCode, token);
-    schedulePublisherAuctionExpiry(ts, token);
-  }
-
-  return registrations;
-}
-
-function findPublisherAuction(
-  ts: TsjsApi,
-  token: string,
-  now = Date.now()
-):
-  | {
-      state: FirstImpressionState;
-      claim: FirstImpressionSlotClaim;
-      auction: FirstImpressionPublisherAuction;
-    }
-  | undefined {
-  const state = pruneFirstImpressionState(ts, now);
-  for (const claim of Object.values(state.slots)) {
-    const auction = claim.publisherAuctions[token];
-    if (auction) return { state, claim, auction };
-  }
-  return undefined;
-}
-
-/** Move one publisher auction to delivery-pending without disturbing overlaps. */
-export function markPublisherFirstImpressionDeliveryPending(
-  ts: TsjsApi,
-  token: string,
-  adIds: string[],
-  now = Date.now()
-): void {
-  const found = findPublisherAuction(ts, token, now);
-  if (!found) return;
-  found.auction.phase = 'delivery_pending';
-  found.auction.adIds = [...new Set(adIds)];
-  if (found.claim.owner === 'publisher') found.claim.phase = 'delivery_pending';
-}
-
-/** Release exactly one publisher auction token after failure, timeout, or removal. */
-export function releasePublisherFirstImpressionAuction(
-  ts: TsjsApi,
-  token: string,
-  now = Date.now()
-): void {
-  const found = findPublisherAuction(ts, token, now);
-  if (!found) return;
-  if (found.claim.owner === 'trusted_server' && found.auction.suppressDelivery) {
-    found.claim.publisherRegistrationClosed = true;
-    return;
-  }
-  found.auction.expiresAt = Math.min(found.auction.expiresAt, now);
-  if (
-    found.claim.owner === 'publisher' &&
-    Object.keys(found.claim.publisherAuctions).length === 1
-  ) {
-    found.claim.expiresAt = now;
-  }
-  removePublisherAuction(found.state, found.claim, token, now);
-}
-
-/** Consume one correlated publisher delivery and report whether TS owns it. */
-export function consumePublisherFirstImpressionDelivery(
-  ts: TsjsApi,
-  token: string | undefined,
-  now = Date.now()
-): boolean {
-  if (!token) return false;
-  const found = findPublisherAuction(ts, token, now);
-  if (!found) return false;
-
-  const suppress = found.claim.owner === 'trusted_server' && found.auction.suppressDelivery;
-  delete found.claim.publisherAuctions[token];
-  if (suppress) found.claim.publisherRegistrationClosed = true;
-  return suppress;
-}
-
-/** Record a GPT request or render, using publisher ownership when no claimant exists. */
-export function observeFirstImpressionGptLifecycle(
-  ts: TsjsApi,
-  element: HTMLElement,
-  phase: Extract<FirstImpressionPhase, 'requested' | 'rendered'>,
-  now = Date.now()
-): void {
-  const state = pruneFirstImpressionState(ts, now);
-  let claim = state.slots[element.id];
-  if (!claim || !claimMatchesElement(claim, element, state.generation)) {
-    claim = {
-      generation: state.generation,
-      slotElementId: element.id,
-      element,
-      owner: 'publisher',
-      phase,
-      expiresAt: Number.POSITIVE_INFINITY,
-      publisherAuctions: {},
-    };
-    storeClaim(state, claim);
-    return;
-  }
-
-  claim.phase = phase;
-  if (claim.owner === 'publisher') {
-    claim.expiresAt = Number.POSITIVE_INFINITY;
-  } else {
-    // Once TS has committed a GPT request, only publisher auctions that were
-    // already registered can still represent an overlapping first impression.
-    // New publisher refreshes are ordinary later impressions and must proceed.
-    claim.publisherRegistrationClosed = true;
-  }
-}
-
-/** Reserve the only Trusted Server fallback allowed for this physical slot and generation. */
-export function reservePublisherFirstImpressionFallback(
-  ts: TsjsApi,
-  element: HTMLElement
-): boolean {
-  const state = pruneFirstImpressionState(ts);
-  const reservedElement = state.fallbackSlots[element.id];
-  if (reservedElement) return false;
-  state.fallbackSlots[element.id] = element;
-  return true;
-}
-
-/** Delay before an abandoned publisher claim can receive one per-slot TS fallback. */
-export function publisherFirstImpressionRetryDelay(
-  ts: TsjsApi,
-  element: HTMLElement,
-  now = Date.now()
-): number | undefined {
-  const claim = firstImpressionClaim(ts, element);
-  if (!claim) return 0;
-  if (claim.owner !== 'publisher') return undefined;
-  if (claim.phase === 'requested' || claim.phase === 'rendered') return undefined;
-  return Math.max(0, claim.expiresAt - now);
-}
diff --git a/crates/trusted-server-js/lib/src/core/global.d.ts b/crates/trusted-server-js/lib/src/core/global.d.ts
index c7c8b08fb..66a892730 100644
--- a/crates/trusted-server-js/lib/src/core/global.d.ts
+++ b/crates/trusted-server-js/lib/src/core/global.d.ts
@@ -1,9 +1,8 @@
-import type { TsjsApi } from './types';
-
 declare global {
   interface Window {
-    tsjs?: TsjsApi;
-    pbjs?: TsjsApi;
+    /** Bootstrap input before the runtime atomically publishes its exact API. */
+    tsjs?: unknown;
+    pbjs?: unknown;
   }
 }
 
diff --git a/crates/trusted-server-js/lib/src/core/index.ts b/crates/trusted-server-js/lib/src/core/index.ts
index b2c4e41e1..9dacfee04 100644
--- a/crates/trusted-server-js/lib/src/core/index.ts
+++ b/crates/trusted-server-js/lib/src/core/index.ts
@@ -1,72 +1,275 @@
-// Public tsjs core bundle: sets up the global API, queue, and default methods.
+// Sole production bootstrap for the resilient TSJS runtime.
+declare const __TSJS_RUNTIME_CLAIMED_V1__: unknown;
+
 export type {
-  AdUnit,
+  AddAdUnitsResult,
   GptDiagnosticsApi,
   GptDiagnosticsExportV1,
   GptDiagnosticsRequestCycle,
+  ProgrammaticAdUnit,
+  RequestAdsOptions,
+  RequestAdsResult,
   TsjsApi,
+  TsjsBootV1,
+  TsjsDiagnostics,
 } from './types';
-import type { TsjsApi } from './types';
-import { addAdUnits } from './registry';
-import { renderAdUnit, renderAllAdUnits } from './render';
-import { log } from './log';
-import { setConfig, getConfig } from './config';
-import { requestAds } from './request';
-import { installQueue } from './queue';
+export type { Runtime, RuntimeOptions, RuntimeState } from '../kernel/runtime';
+
+import type { Runtime, RuntimeOptions } from '../kernel/runtime';
+import { validateRuntimeManifestV1 } from '../kernel/integration_registry';
+import {
+  coordinatePreparedFirstDisplayTakeoverV1,
+  finalizeFirstDisplayAgentCaptureV1,
+} from '../shared/first_display_handoff';
+import type { ClaimedFirstDisplayTakeoverV1 } from '../shared/takeover';
+
+import { ownDataObject } from './contracts/auction_projection';
+import { snapshotFrozenTsjsBootV1 } from './contracts/boot';
+import type { ServerBootIntegrityV1 } from './contracts/server_boot_transport';
+import { sha256HexUtf8V1 } from './contracts/sha256';
+import { EMBEDDED_INTEGRATION_IDS, EMBEDDED_RELEASE_ID, EMBEDDED_RUNTIME_CATALOG } from './release';
+import type { TsjsBootV1 } from './types';
+
+type BootstrapTarget = object & {
+  boot?: unknown;
+  que?: unknown;
+};
 
-const VERSION = '0.1.0';
+type DirectRuntimeCompletion = (outcome: 'kernel' | 'runtime_fallback' | 'failed_start') => void;
 
-const w: Window & { tsjs?: TsjsApi } =
-  ((globalThis as unknown as { window?: Window }).window as Window & {
-    tsjs?: TsjsApi;
-  }) || ({} as Window & { tsjs?: TsjsApi });
+interface ClaimedServerBootV1 {
+  readonly source: object;
+  readonly target: BootstrapTarget;
+  readonly boot: Readonly<TsjsBootV1>;
+  readonly integrity: Readonly<ServerBootIntegrityV1>;
+  readonly complete: (outcome: 'kernel' | 'abi_mismatch' | 'bundle_partial') => void;
+  readonly currentScript: () => HTMLScriptElement | null;
+  readonly mode: 'direct' | 'takeover';
+  readonly bind: (input: unknown) => unknown;
+}
 
-// Collect existing tsjs queued fns before we overwrite
-const pending: Array<() => void> = Array.isArray(w.tsjs?.que) ? [...w.tsjs.que] : [];
+function retainServerBoot(candidate: unknown, releaseId: string): Readonly<TsjsBootV1> | undefined {
+  try {
+    const boot = snapshotFrozenTsjsBootV1(candidate, releaseId);
+    if (!boot) return undefined;
+    const manifest = validateRuntimeManifestV1(
+      boot.manifest,
+      releaseId,
+      EMBEDDED_RUNTIME_CATALOG,
+      true
+    );
+    return manifest && JSON.stringify(boot.manifest) === JSON.stringify(manifest)
+      ? boot
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
 
-// Create API and attach methods
-const api: TsjsApi = (w.tsjs ??= {} as TsjsApi);
-api.version = VERSION;
-api.addAdUnits = addAdUnits;
-api.renderAdUnit = renderAdUnit;
-api.renderAllAdUnits = () => renderAllAdUnits();
-api.log = log;
-api.setConfig = setConfig;
-api.getConfig = getConfig;
-// Provide core requestAds API
-api.requestAds = requestAds;
-// Defensive defaults: the edge injects adSlots (head-open) and bids (before
-// </body>) only when server-side ad templates run for the request. When template
-// delivery is disabled or gated off (auction/consent, bots, prefetch), page code
-// reading window.tsjs.bids / window.tsjs.adSlots must still see defined values
-// instead of throwing. Injected scripts overwrite these wholesale.
-api.adSlots ??= [];
-api.bids ??= {};
-// Point global tsjs
-w.tsjs = api;
+export type BrowserRuntimeCompositionFactory = (
+  runtimeOptions: RuntimeOptions,
+  compositionOptions: Readonly<Record<string, never>>
+) => Readonly<{ runtime: Runtime }>;
 
-// Single shared queue
-installQueue(api, w);
+function claimedRuntimeCandidate(): unknown {
+  if (typeof __TSJS_RUNTIME_CLAIMED_V1__ !== 'undefined') {
+    return __TSJS_RUNTIME_CLAIMED_V1__;
+  }
+  try {
+    const source = (window as unknown as { tsjs?: unknown }).tsjs;
+    if ((typeof source !== 'object' && typeof source !== 'function') || source === null) return;
+    const claim = (source as { _claimRuntimeV1?: unknown })._claimRuntimeV1;
+    return typeof claim === 'function' ? claim(source) : undefined;
+  } catch {
+    return;
+  }
+}
 
-// Flush prior queued callbacks
-for (const fn of pending) {
+function retainClaimedServerBootV1(candidate: unknown): ClaimedServerBootV1 | undefined {
   try {
-    if (typeof fn === 'function') {
-      fn.call(api);
-      log.debug('queue: flushed callback');
+    const fields = ownDataObject(candidate, [
+      'boot',
+      'integrity',
+      'complete',
+      'currentScript',
+      'source',
+      'target',
+      'mode',
+      'bind',
+    ]);
+    if (!fields || !Object.isFrozen(candidate)) return undefined;
+    const boot = retainServerBoot(fields['boot'], EMBEDDED_RELEASE_ID);
+    const integrity = fields['integrity'];
+    const acceptedIntegrity = ownDataObject(integrity, [
+      'version',
+      'projectionDigest',
+      'integrationConfigDigest',
+    ]);
+    if (
+      !boot ||
+      !acceptedIntegrity ||
+      !Object.isFrozen(integrity) ||
+      typeof fields['complete'] !== 'function' ||
+      typeof fields['currentScript'] !== 'function' ||
+      (typeof fields['source'] !== 'object' && typeof fields['source'] !== 'function') ||
+      fields['source'] === null ||
+      (typeof fields['target'] !== 'object' && typeof fields['target'] !== 'function') ||
+      fields['target'] === null ||
+      (fields['mode'] !== 'direct' && fields['mode'] !== 'takeover') ||
+      typeof fields['bind'] !== 'function'
+    ) {
+      return undefined;
     }
+    if (
+      acceptedIntegrity['version'] !== 1 ||
+      acceptedIntegrity['projectionDigest'] !==
+        sha256HexUtf8V1(JSON.stringify(boot.auctionProjection)) ||
+      acceptedIntegrity['integrationConfigDigest'] !==
+        sha256HexUtf8V1(JSON.stringify(boot.integrations))
+    ) {
+      return undefined;
+    }
+    return candidate as ClaimedServerBootV1;
   } catch {
-    /* ignore queued callback error */
+    return undefined;
   }
 }
 
-log.info('tsjs initialized', {
-  methods: [
-    'setConfig',
-    'getConfig',
-    'requestAds',
-    'addAdUnits',
-    'renderAdUnit',
-    'renderAllAdUnits',
-  ],
-});
+function claimedBootCompletion(candidate: unknown): ClaimedServerBootV1['complete'] | undefined {
+  const fields = ownDataObject(candidate, [
+    'boot',
+    'integrity',
+    'complete',
+    'currentScript',
+    'source',
+    'target',
+    'mode',
+    'bind',
+  ]);
+  return fields && typeof fields['complete'] === 'function'
+    ? (fields['complete'] as ClaimedServerBootV1['complete'])
+    : undefined;
+}
+
+/** Claim the browser namespace and start the injected sole composition root. */
+export function startProductionRuntime(createComposition: BrowserRuntimeCompositionFactory): void {
+  const candidate = claimedRuntimeCandidate();
+  const completeBoot = claimedBootCompletion(candidate);
+  const claimed = retainClaimedServerBootV1(candidate);
+  if (!claimed) {
+    try {
+      completeBoot?.('abi_mismatch');
+    } catch {
+      // The authenticated bootstrap watchdog remains the terminal fallback owner.
+    }
+    return;
+  }
+  const source = claimed.source;
+  const target = claimed.target;
+  let authenticatedSource: HTMLScriptElement | null;
+  try {
+    authenticatedSource = claimed.currentScript();
+  } catch {
+    authenticatedSource = null;
+  }
+  if (authenticatedSource !== source) {
+    try {
+      claimed.complete('abi_mismatch');
+    } catch {
+      // The authenticated bootstrap watchdog remains the terminal fallback owner.
+    }
+    return;
+  }
+  const { boot } = claimed;
+  const directMode = boot.manifest.firstDisplay === null;
+  if ((directMode && claimed.mode !== 'direct') || (!directMode && claimed.mode !== 'takeover')) {
+    try {
+      claimed.complete('abi_mismatch');
+    } catch {
+      // The authenticated bootstrap watchdog remains the terminal fallback owner.
+    }
+    return;
+  }
+  let trustedScriptUrl: ((value: string) => unknown) | undefined;
+  let trustedCurrentScript: (() => HTMLScriptElement | null) | undefined = claimed.currentScript;
+  const composition = createComposition(
+    {
+      target,
+      releaseId: EMBEDDED_RELEASE_ID,
+      manifest: boot.manifest,
+      knownIntegrationIds: EMBEDDED_INTEGRATION_IDS,
+      catalog: EMBEDDED_RUNTIME_CATALOG,
+      boot,
+      currentScript: () => trustedCurrentScript?.() ?? null,
+      ...(!directMode
+        ? {
+            trustedScriptUrl: (value: string) => {
+              if (!trustedScriptUrl) throw new TypeError('tsjs');
+              return trustedScriptUrl(value);
+            },
+            coordinateTakeover: (prepared) => {
+              const leased = claimed.bind(finalizeFirstDisplayAgentCaptureV1) as
+                ClaimedFirstDisplayTakeoverV1 | undefined;
+              if (!leased) throw new TypeError('tsjs');
+              trustedScriptUrl = leased[9];
+              trustedCurrentScript = leased[10];
+              if (
+                !coordinatePreparedFirstDisplayTakeoverV1({
+                  prepared,
+                  finalized: leased[0],
+                  outline: leased[1],
+                  boot,
+                  isCurrentGeneration: leased[2],
+                  authenticateRuntimeScript: leased[3],
+                  currentMutationRevision: leased[4],
+                  quiesceAgent: () => undefined,
+                  detachCommittedArtifacts: () => {
+                    if (!leased[5]()) throw new TypeError('tsjs');
+                  },
+                  disposeAgent: leased[6],
+                  onFailure: leased[7],
+                })
+              ) {
+                throw new TypeError('tsjs');
+              }
+              leased[8]();
+            },
+          }
+        : {}),
+      autoInstall: true,
+      onInstallComplete: (result) => {
+        try {
+          claimed.complete(result.state === 'kernel' ? 'kernel' : result.reason);
+        } catch {
+          // Direct completion still closes its independently authenticated watchdog.
+        }
+        completeDirect?.(result.state === 'kernel' ? 'kernel' : 'runtime_fallback');
+      },
+      kernel: {
+        addAdUnits: () => Object.freeze({ registered: Object.freeze([]) }),
+        diagnostics: Object.freeze({}),
+        requestAds: async () => Object.freeze({ slots: Object.freeze([]) }),
+      },
+    },
+    {}
+  );
+  const completeDirect = directMode
+    ? (claimed.bind(() => composition.runtime.dispose()) as DirectRuntimeCompletion | undefined)
+    : undefined;
+  if (directMode && !completeDirect) {
+    try {
+      composition.runtime.dispose();
+    } catch {
+      // Completion still commits the independently authenticated terminal fallback.
+    }
+    try {
+      claimed.complete('abi_mismatch');
+    } catch {
+      // The authenticated bootstrap watchdog remains the terminal fallback owner.
+    }
+    return;
+  }
+  if (!composition.runtime.start()) {
+    completeDirect?.('failed_start');
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/log.ts b/crates/trusted-server-js/lib/src/core/log.ts
index b750430c6..fb616292c 100644
--- a/crates/trusted-server-js/lib/src/core/log.ts
+++ b/crates/trusted-server-js/lib/src/core/log.ts
@@ -37,8 +37,9 @@ function styleFor(method: 'log' | 'info' | 'warn' | 'error'): string {
 
 function print(method: 'log' | 'info' | 'warn' | 'error', ...args: unknown[]) {
   const c:
-    | Partial<Record<'log' | 'info' | 'warn' | 'error', (...a: unknown[]) => void>>
-    | undefined = (globalThis as unknown as { console?: Console }).console;
+    Partial<Record<'log' | 'info' | 'warn' | 'error', (...a: unknown[]) => void>> | undefined = (
+    globalThis as unknown as { console?: Console }
+  ).console;
   if (!c || typeof c[method] !== 'function') return;
   if (supportsCss()) {
     c[method]('%c[tsjs]%c ' + ts() + ':', styleFor(method), 'color:inherit', ...args);
diff --git a/crates/trusted-server-js/lib/src/core/puc_shell.ts b/crates/trusted-server-js/lib/src/core/puc_shell.ts
new file mode 100644
index 000000000..51249e8ac
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/puc_shell.ts
@@ -0,0 +1,147 @@
+const shellDocument = typeof document === 'undefined' ? undefined : document;
+const shellWindow = shellDocument?.defaultView ?? undefined;
+const queryAll = typeof Document === 'undefined' ? undefined : Document.prototype.querySelectorAll;
+const connected =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')?.get;
+const parentElement =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'parentElement')?.get;
+const frameWindow =
+  typeof HTMLIFrameElement === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'contentWindow')?.get;
+const getAttribute = typeof Element === 'undefined' ? undefined : Element.prototype.getAttribute;
+const closest = typeof Element === 'undefined' ? undefined : Element.prototype.closest;
+const style =
+  typeof HTMLElement === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'style')?.get;
+const setProperty =
+  typeof CSSStyleDeclaration === 'undefined'
+    ? undefined
+    : CSSStyleDeclaration.prototype.setProperty;
+const getComputedStyle = shellWindow?.getComputedStyle;
+
+export interface CollapsedPucShellResizeInput {
+  readonly source: object;
+  readonly width: number;
+  readonly height: number;
+}
+
+function attribute(element: Element, name: string): string | null | undefined {
+  if (!getAttribute) return undefined;
+  try {
+    return Reflect.apply(getAttribute, element, [name]) as string | null;
+  } catch {
+    return undefined;
+  }
+}
+
+function onePixelAttribute(element: Element, name: 'width' | 'height'): boolean {
+  const value = attribute(element, name);
+  if (value === undefined || value === null || !/^\d+(?:\.\d+)?$/.test(value)) return false;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed <= 1;
+}
+
+function computedStyle(element: Element): CSSStyleDeclaration | undefined {
+  if (!shellWindow || !getComputedStyle) return undefined;
+  try {
+    return Reflect.apply(getComputedStyle, shellWindow, [element]) as CSSStyleDeclaration;
+  } catch {
+    return undefined;
+  }
+}
+
+function onePixelComputed(value: CSSStyleDeclaration, dimension: 'width' | 'height'): boolean {
+  const match = /^(\d+(?:\.\d+)?)px$/.exec(dimension === 'width' ? value.width : value.height);
+  return match !== null && Number(match[1]) <= 1;
+}
+
+function ordinaryCollapsedElement(element: HTMLElement): boolean {
+  const value = computedStyle(element);
+  return (
+    value !== undefined &&
+    value.position !== 'fixed' &&
+    value.position !== 'sticky' &&
+    onePixelComputed(value, 'width') &&
+    onePixelComputed(value, 'height')
+  );
+}
+
+/** Resize only the authenticated, ordinary collapsed Universal Creative shell. */
+export function resizeCollapsedPucShell(input: CollapsedPucShellResizeInput): boolean {
+  if (
+    !shellDocument ||
+    !queryAll ||
+    !connected ||
+    !parentElement ||
+    !frameWindow ||
+    !closest ||
+    !style ||
+    !setProperty ||
+    typeof input !== 'object' ||
+    input === null ||
+    typeof input.source !== 'object' ||
+    input.source === null ||
+    !Number.isFinite(input.width) ||
+    !Number.isFinite(input.height) ||
+    input.width <= 0 ||
+    input.height <= 0
+  ) {
+    return false;
+  }
+
+  try {
+    const candidates = Reflect.apply(queryAll, shellDocument, [
+      'iframe',
+    ]) as NodeListOf<HTMLIFrameElement>;
+    let frame: HTMLIFrameElement | undefined;
+    for (let index = 0; index < candidates.length; index += 1) {
+      const candidate = candidates.item(index);
+      if (
+        candidate &&
+        Reflect.apply(connected, candidate, []) === true &&
+        Reflect.apply(frameWindow, candidate, []) === input.source
+      ) {
+        if (frame) return false;
+        frame = candidate;
+      }
+    }
+    if (
+      !frame ||
+      !onePixelAttribute(frame, 'width') ||
+      !onePixelAttribute(frame, 'height') ||
+      !ordinaryCollapsedElement(frame) ||
+      Reflect.apply(closest, frame, ['a,[data-anchor-status]']) !== null
+    ) {
+      return false;
+    }
+
+    const wrapper = Reflect.apply(parentElement, frame, []) as HTMLElement | null;
+    if (
+      !wrapper ||
+      wrapper === shellDocument.body ||
+      wrapper === shellDocument.documentElement ||
+      wrapper instanceof HTMLAnchorElement ||
+      Reflect.apply(connected, wrapper, []) !== true ||
+      !ordinaryCollapsedElement(wrapper) ||
+      Reflect.apply(closest, wrapper, ['a,[data-anchor-status]']) !== null
+    ) {
+      return false;
+    }
+
+    const frameStyle = Reflect.apply(style, frame, []) as CSSStyleDeclaration;
+    const wrapperStyle = Reflect.apply(style, wrapper, []) as CSSStyleDeclaration;
+    Reflect.apply(setProperty, frameStyle, ['width', `${input.width}px`]);
+    Reflect.apply(setProperty, frameStyle, ['height', `${input.height}px`]);
+    Reflect.apply(setProperty, wrapperStyle, ['width', `${input.width}px`]);
+    Reflect.apply(setProperty, wrapperStyle, ['height', `${input.height}px`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/core/queue.ts b/crates/trusted-server-js/lib/src/core/queue.ts
index 73c2741be..414af4f5b 100644
--- a/crates/trusted-server-js/lib/src/core/queue.ts
+++ b/crates/trusted-server-js/lib/src/core/queue.ts
@@ -1,6 +1,240 @@
-// Minimal Prebid-style queue shim that executes callbacks immediately.
 import { log } from './log';
 
+export type QueueCallback = (this: object) => void;
+
+export interface PublishedQueue {
+  readonly queue: unknown[];
+  readonly drain: () => void;
+}
+
+type QueueOwner = object & { que?: unknown };
+
+function immediatePush(owner: object): unknown[]['push'] {
+  return function (item: unknown): number {
+    if (typeof item !== 'function') return 0;
+    try {
+      (item as QueueCallback).call(owner);
+    } catch (error) {
+      try {
+        log.warn('queue: callback failed', error);
+      } catch {
+        // Callback isolation cannot depend on an observer.
+      }
+      return 0;
+    }
+    try {
+      log.debug('queue: push executed immediately');
+    } catch {
+      // Queue behavior cannot depend on an observer.
+    }
+    return 0;
+  } as unknown[]['push'];
+}
+
+function ownArrayEntries(value: unknown[]): readonly [number, unknown][] {
+  const entries: [number, unknown][] = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/.test(key)) continue;
+    const index = Number(key);
+    if (!Number.isSafeInteger(index) || index < 0 || index >= 4_294_967_295) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && 'value' in descriptor) entries.push([index, descriptor.value]);
+  }
+  entries.sort(([left], [right]) => left - right);
+  return entries;
+}
+
+function canReuseIngress(value: unknown[]): boolean {
+  if (!Object.isExtensible(value)) return false;
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+  if (!lengthDescriptor?.writable) return false;
+  const pushDescriptor = Object.getOwnPropertyDescriptor(value, 'push');
+  if (pushDescriptor && !pushDescriptor.configurable) return false;
+  return ownArrayEntries(value).every(([index]) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    return descriptor?.configurable === true;
+  });
+}
+
+function preflightTerminalFields(
+  target: QueueOwner,
+  committedFields: Readonly<Record<string, unknown>>,
+  removedFields: readonly string[]
+): Readonly<{ committed: readonly string[]; removed: readonly string[] }> {
+  const keys: string[] = [];
+  const seen = new Set<string>();
+  for (const key of Reflect.ownKeys(committedFields)) {
+    if (typeof key !== 'string') continue;
+    const field = Object.getOwnPropertyDescriptor(committedFields, key);
+    if (!field || !('value' in field)) continue;
+    const existing = Object.getOwnPropertyDescriptor(target, key);
+    if (existing && !existing.configurable) {
+      throw new TypeError(`TSJS terminal field is not configurable: ${key}`);
+    }
+    keys.push(key);
+    seen.add(key);
+  }
+  const removed: string[] = [];
+  for (const key of removedFields) {
+    if (seen.has(key) || removed.includes(key)) {
+      throw new TypeError(`TSJS terminal field inventory overlaps: ${key}`);
+    }
+    const existing = Object.getOwnPropertyDescriptor(target, key);
+    if (existing && !existing.configurable) {
+      throw new TypeError(`TSJS removed field is not configurable: ${key}`);
+    }
+    removed.push(key);
+  }
+  // A terminal publication is an exact replacement, not a compatibility
+  // merge. Remove every other own string field without carrying an inventory
+  // of retired public names into the shipped bundle.
+  for (const key of Object.getOwnPropertyNames(target)) {
+    if (key === 'que' || seen.has(key) || removed.includes(key)) continue;
+    const existing = Object.getOwnPropertyDescriptor(target, key);
+    if (existing && !existing.configurable) {
+      throw new TypeError(`TSJS unpublished field is not configurable: ${key}`);
+    }
+    removed.push(key);
+  }
+  const queueDescriptor = Object.getOwnPropertyDescriptor(target, 'que');
+  if (queueDescriptor && !queueDescriptor.configurable) {
+    throw new TypeError('TSJS terminal field is not configurable: que');
+  }
+  return Object.freeze({ committed: Object.freeze(keys), removed: Object.freeze(removed) });
+}
+
+/** Side-effect-free ordinary-object preflight used before fallback queue normalization. */
+export function canPublishTerminalFields(
+  target: QueueOwner,
+  committedFields: Readonly<Record<string, unknown>>,
+  removedFields: readonly string[] = Object.freeze([])
+): boolean {
+  try {
+    preflightTerminalFields(target, committedFields, removedFields);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function preflightPublication(
+  target: QueueOwner,
+  ingress: unknown[],
+  committedFields: Readonly<Record<string, unknown>>,
+  removedFields: readonly string[]
+): Readonly<{ committed: readonly string[]; removed: readonly string[] }> {
+  if (!canReuseIngress(ingress)) {
+    throw new TypeError('TSJS ingress queue cannot be committed');
+  }
+  return preflightTerminalFields(target, committedFields, removedFields);
+}
+
+/** Establishes the mutable preload queue used only during bootstrap preparation. */
+export function prepareQueue<T extends QueueOwner>(target: T): unknown[] {
+  const existing = Object.getOwnPropertyDescriptor(target, 'que');
+  const publisherQueue =
+    existing && 'value' in existing && Array.isArray(existing.value) ? existing.value : undefined;
+  const ingress = publisherQueue && canReuseIngress(publisherQueue) ? publisherQueue : [];
+  if (publisherQueue && ingress !== publisherQueue) {
+    for (const [index, value] of ownArrayEntries(publisherQueue)) ingress[index] = value;
+  }
+  Object.defineProperty(ingress, 'push', {
+    configurable: true,
+    enumerable: false,
+    value: Array.prototype.push,
+    writable: true,
+  });
+  Object.defineProperty(target, 'que', {
+    configurable: true,
+    enumerable: true,
+    value: ingress,
+    writable: false,
+  });
+  return ingress;
+}
+
+/**
+ * Performs the terminal, synchronous queue and public-field handoff.
+ *
+ * The returned queue is a frozen real Array whose own `push` executes callable
+ * entries immediately without ever retaining them.
+ */
+export function publishQueue<T extends QueueOwner>(
+  target: T,
+  ingress: unknown[],
+  committedFields: Readonly<Record<string, unknown>> = {},
+  removedFields: readonly string[] = Object.freeze([])
+): PublishedQueue {
+  const inventory = preflightPublication(target, ingress, committedFields, removedFields);
+  const queue: unknown[] = [];
+  Object.defineProperty(queue, 'push', {
+    configurable: false,
+    enumerable: false,
+    value: immediatePush(target),
+    writable: false,
+  });
+  Object.freeze(queue);
+
+  const snapshot: QueueCallback[] = [];
+  for (const [, value] of ownArrayEntries(ingress)) {
+    if (typeof value === 'function') snapshot.push(value as QueueCallback);
+  }
+
+  ingress.length = 0;
+  Object.defineProperty(ingress, 'push', {
+    configurable: false,
+    enumerable: false,
+    value: immediatePush(target),
+    writable: false,
+  });
+  Object.freeze(ingress);
+
+  for (const key of inventory.removed) {
+    if (!Reflect.deleteProperty(target, key)) {
+      throw new TypeError(`TSJS removed field could not be deleted: ${key}`);
+    }
+  }
+  for (const key of inventory.committed) {
+    const descriptor = Object.getOwnPropertyDescriptor(committedFields, key);
+    if (!descriptor || !('value' in descriptor)) {
+      throw new TypeError(`TSJS terminal field changed during publication: ${key}`);
+    }
+    Object.defineProperty(target, key, {
+      configurable: false,
+      enumerable: descriptor.enumerable ?? true,
+      value: descriptor.value,
+      writable: false,
+    });
+  }
+  Object.defineProperty(target, 'que', {
+    configurable: false,
+    enumerable: true,
+    value: queue,
+    writable: false,
+  });
+
+  let drained = false;
+  return Object.freeze({
+    queue,
+    drain: () => {
+      if (drained) return;
+      drained = true;
+      for (const callback of snapshot) queue.push(callback);
+    },
+  });
+}
+
+/** Publish and immediately drain a queue outside the transactional registry. */
+export function commitQueue<T extends QueueOwner>(
+  target: T,
+  ingress: unknown[],
+  committedFields: Readonly<Record<string, unknown>> = {}
+): unknown[] {
+  const published = publishQueue(target, ingress, committedFields);
+  published.drain();
+  return published.queue;
+}
+
 // Replace the legacy Prebid-style queue with an immediate executor so queued work runs in order.
 export function installQueue<T extends { que?: Array<() => void> }>(
   target: T,
diff --git a/crates/trusted-server-js/lib/src/core/registry.ts b/crates/trusted-server-js/lib/src/core/registry.ts
index 9af4a0a34..8250628bb 100644
--- a/crates/trusted-server-js/lib/src/core/registry.ts
+++ b/crates/trusted-server-js/lib/src/core/registry.ts
@@ -1,31 +1,686 @@
-// In-memory registry for ad units registered via tsjs (used by core + extensions).
-import type { AdUnit, Size } from './types';
-import { toArray } from './util';
-import { log } from './log';
+// Programmatic ad-unit validation for the hard-cutover runtime.
+import type { AddAdUnitsResult, ProgrammaticAdUnit } from './types';
+import { validBoundedString } from './contracts/bounded_string';
 
-const registry = new Map<string, AdUnit>();
+const MAX_AUCTION_BODY_BYTES = 256 * 1024;
+const MAX_PROGRAMMATIC_UNITS = 256;
+const MAX_ACTIVE_SLOT_RECORDS = 256;
+const MAX_JSON_STRUCTURE_ENTRIES = Math.floor((MAX_AUCTION_BODY_BYTES - 1) / 2);
+const textEncoder = new TextEncoder();
+const reflectApplyIntrinsic = Reflect.apply;
+const jsonStringifyIntrinsic = JSON.stringify;
+const objectCreateIntrinsic = Object.create;
+const objectGetOwnPropertyNamesIntrinsic = Object.getOwnPropertyNames;
+const objectKeysIntrinsic = Object.keys;
+const objectSetPrototypeOfIntrinsic = Object.setPrototypeOf;
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
 
-// Merge ad unit definitions into the in-memory registry (supports array or single unit).
-export function addAdUnits(units: AdUnit | AdUnit[]): void {
-  for (const u of toArray(units)) {
-    if (!u || !u.code) continue;
-    registry.set(u.code, { ...registry.get(u.code), ...u });
+export type AdUnitRegistrationErrorCode =
+  | 'invalid_units'
+  | 'invalid_unit'
+  | 'invalid_code'
+  | 'duplicate_code'
+  | 'slot_collision'
+  | 'invalid_media_types'
+  | 'invalid_dimensions'
+  | 'dimensions_out_of_range'
+  | 'invalid_bids'
+  | 'invalid_bidder'
+  | 'invalid_params'
+  | 'request_body_too_large'
+  | 'registry_capacity';
+
+export class AdUnitRegistrationError extends Error {
+  public readonly code: AdUnitRegistrationErrorCode;
+  public readonly unitIndex?: number;
+
+  public constructor(code: AdUnitRegistrationErrorCode, unitIndex?: number) {
+    super(code);
+    this.name = 'AdUnitRegistrationError';
+    this.code = code;
+    if (unitIndex !== undefined) this.unitIndex = unitIndex;
+  }
+}
+
+interface JsonContainerSnapshot {
+  readonly array: boolean;
+  readonly entries: readonly Readonly<{ key: string; value: unknown }>[];
+}
+
+interface JsonCloneFrame {
+  readonly output: Record<string, unknown> | unknown[];
+  readonly snapshot: JsonContainerSnapshot;
+  readonly source: object;
+  index: number;
+}
+
+interface JsonMeasureFrame {
+  readonly array: boolean;
+  readonly entries: readonly Readonly<{ key: string; value: unknown }>[];
+  readonly source: object;
+  bytes: number;
+  structureEntries: number;
+  index: number;
+}
+
+interface JsonMeasurement {
+  readonly bytes: number;
+  readonly snapshot?: JsonContainerSnapshot;
+  readonly structureEntries: number;
+}
+
+interface PendingProgrammaticBid {
+  readonly bidder: string;
+  readonly params?: object;
+}
+
+interface PendingProgrammaticAdUnit {
+  readonly code: string;
+  readonly mediaTypes: ProgrammaticAdUnit['mediaTypes'];
+  readonly bids?: readonly PendingProgrammaticBid[];
+}
+
+function ownDataRecord(value: unknown): Record<string, unknown> | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    const names = reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [
+      value,
+    ]) as string[];
+    for (let index = 0; index < names.length; index += 1) {
+      const key = names[index];
+      if (key === undefined) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      Object.defineProperty(output, key, {
+        configurable: true,
+        enumerable: true,
+        value: descriptor.value,
+        writable: true,
+      });
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownDataArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+  try {
+    if (
+      !Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Array.prototype ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return undefined;
+    }
+    const length = Object.getOwnPropertyDescriptor(value, 'length');
+    if (
+      !length ||
+      !('value' in length) ||
+      !Number.isSafeInteger(length.value) ||
+      length.value < 0 ||
+      length.value > maximum ||
+      (reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [value]) as string[])
+        .length !==
+        length.value + 1
+    ) {
+      return undefined;
+    }
+    const output: unknown[] = [];
+    for (let index = 0; index < length.value; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      output[index] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function exactKeys(record: Record<string, unknown>, keys: readonly string[]): boolean {
+  const actual = reflectApplyIntrinsic(objectKeysIntrinsic, Object, [record]) as string[];
+  if (actual.length !== keys.length) return false;
+  for (let actualIndex = 0; actualIndex < actual.length; actualIndex += 1) {
+    const actualKey = actual[actualIndex];
+    let found = false;
+    for (let expectedIndex = 0; expectedIndex < keys.length; expectedIndex += 1) {
+      if (keys[expectedIndex] === actualKey) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) return false;
+  }
+  return true;
+}
+
+function jsonPrimitive(value: unknown): null | boolean | number | string | undefined {
+  if (value === null || typeof value === 'boolean' || typeof value === 'string') return value;
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function validPositiveInteger(value: unknown): value is number {
+  return (
+    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0
+  );
+}
+
+function snapshotJsonContainer(value: object): JsonContainerSnapshot | undefined {
+  const array = Array.isArray(value);
+  const values = array ? ownDataArray(value, MAX_JSON_STRUCTURE_ENTRIES) : undefined;
+  if (array && !values) return undefined;
+  const record = array ? undefined : ownDataRecord(value);
+  if (!array && !record) return undefined;
+  const entries = array
+    ? values!.map((entry, index) => Object.freeze({ key: String(index), value: entry }))
+    : (reflectApplyIntrinsic(objectKeysIntrinsic, Object, [record]) as string[]).map((key) =>
+        Object.freeze({ key, value: record![key] })
+      );
+  return Object.freeze({ array, entries: Object.freeze(entries) });
+}
+
+/** Copy JSON data without invoking accessors or retaining publisher-owned objects. */
+function copyJsonRecord(
+  value: unknown,
+  completed = new WeakMap<object, Record<string, unknown> | unknown[]>(),
+  measurements?: WeakMap<object, JsonMeasurement>
+): Readonly<Record<string, unknown>> | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  const completedRoot = completed.get(value);
+  if (completedRoot) {
+    return Array.isArray(completedRoot) ? undefined : completedRoot;
+  }
+  const rootSnapshot = measurements?.get(value)?.snapshot ?? snapshotJsonContainer(value);
+  if (!rootSnapshot || rootSnapshot.array) return undefined;
+  const root: Record<string, unknown> = {};
+  const active = new Set<object>();
+  active.add(value);
+  const stack: JsonCloneFrame[] = [
+    { index: 0, output: root, snapshot: rootSnapshot, source: value },
+  ];
+  let structureEntries = 1;
+  try {
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) return undefined;
+      if (frame.index >= frame.snapshot.entries.length) {
+        Object.freeze(frame.output);
+        completed.set(frame.source, frame.output);
+        active.delete(frame.source);
+        stack.pop();
+        continue;
+      }
+      const entry = frame.snapshot.entries[frame.index];
+      frame.index += 1;
+      if (!entry || ++structureEntries > MAX_JSON_STRUCTURE_ENTRIES) return undefined;
+      const primitive = jsonPrimitive(entry.value);
+      if (primitive !== undefined || entry.value === null) {
+        Object.defineProperty(frame.output, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: primitive,
+          writable: true,
+        });
+        continue;
+      }
+      if (typeof entry.value !== 'object' || entry.value === null || active.has(entry.value)) {
+        return undefined;
+      }
+      const completedChild = completed.get(entry.value);
+      if (completedChild) {
+        Object.defineProperty(frame.output, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: completedChild,
+          writable: true,
+        });
+        continue;
+      }
+      const childSnapshot =
+        measurements?.get(entry.value)?.snapshot ?? snapshotJsonContainer(entry.value);
+      if (!childSnapshot) return undefined;
+      const child: Record<string, unknown> | unknown[] = childSnapshot.array ? [] : {};
+      Object.defineProperty(frame.output, entry.key, {
+        configurable: true,
+        enumerable: true,
+        value: child,
+        writable: true,
+      });
+      active.add(entry.value);
+      stack.push({ index: 0, output: child, snapshot: childSnapshot, source: entry.value });
+    }
+    return Object.freeze(root);
+  } catch {
+    return undefined;
+  }
+}
+
+function safeSerializationContainer(array: boolean): Record<string, unknown> | unknown[] {
+  if (!array) {
+    return reflectApplyIntrinsic(objectCreateIntrinsic, Object, [null]) as Record<string, unknown>;
+  }
+  const output: unknown[] = [];
+  reflectApplyIntrinsic(objectSetPrototypeOfIntrinsic, Object, [output, null]);
+  return output;
+}
+
+/** Copy accepted JSON data onto containers that inherit no publisher hooks. */
+function copyJsonForSerialization(value: object): object | undefined {
+  const rootSnapshot = snapshotJsonContainer(value);
+  if (!rootSnapshot) return undefined;
+  const root = safeSerializationContainer(rootSnapshot.array);
+  const active = new Set<object>();
+  active.add(value);
+  const completed = new WeakMap<object, Record<string, unknown> | unknown[]>();
+  const stack: JsonCloneFrame[] = [
+    { index: 0, output: root, snapshot: rootSnapshot, source: value },
+  ];
+  let structureEntries = 1;
+  try {
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) return undefined;
+      if (frame.index >= frame.snapshot.entries.length) {
+        completed.set(frame.source, frame.output);
+        active.delete(frame.source);
+        stack.pop();
+        continue;
+      }
+      const entry = frame.snapshot.entries[frame.index];
+      frame.index += 1;
+      if (!entry || ++structureEntries > MAX_JSON_STRUCTURE_ENTRIES) return undefined;
+      const primitive = jsonPrimitive(entry.value);
+      if (primitive !== undefined || entry.value === null) {
+        Object.defineProperty(frame.output, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: primitive,
+          writable: true,
+        });
+        continue;
+      }
+      if (typeof entry.value !== 'object' || entry.value === null || active.has(entry.value)) {
+        return undefined;
+      }
+      const completedChild = completed.get(entry.value);
+      if (completedChild) {
+        Object.defineProperty(frame.output, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: completedChild,
+          writable: true,
+        });
+        continue;
+      }
+      const childSnapshot = snapshotJsonContainer(entry.value);
+      if (!childSnapshot) return undefined;
+      const child = safeSerializationContainer(childSnapshot.array);
+      Object.defineProperty(frame.output, entry.key, {
+        configurable: true,
+        enumerable: true,
+        value: child,
+        writable: true,
+      });
+      active.add(entry.value);
+      stack.push({ index: 0, output: child, snapshot: childSnapshot, source: entry.value });
+    }
+    return root;
+  } catch {
+    return undefined;
+  }
+}
+
+function encodedJsonStringBytes(value: string): number {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x22 || code === 0x5c) bytes += 2;
+    else if (code <= 0x1f) {
+      bytes +=
+        code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6;
+    } else if (code <= 0x7f) bytes += 1;
+    else if (code <= 0x7ff) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 6;
+    } else if (code >= 0xdc00 && code <= 0xdfff) bytes += 6;
+    else bytes += 3;
+    if (bytes > MAX_AUCTION_BODY_BYTES) return bytes;
   }
-  log.info('addAdUnits:', { count: toArray(units).length });
+  return bytes;
 }
 
-// Convenience helper to grab the first banner size off an ad unit.
-export function firstSize(unit: AdUnit): Size | null {
-  const sizes = unit.mediaTypes?.banner?.sizes;
-  return sizes && sizes.length ? sizes[0] : null;
+function primitiveJsonBytes(value: unknown): number | undefined {
+  if (value === null) return 4;
+  if (typeof value === 'boolean') return value ? 4 : 5;
+  if (typeof value === 'string') return encodedJsonStringBytes(value);
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value).length;
+  return undefined;
 }
 
-// Return a snapshot array of all registered ad units.
-export function getAllUnits(): AdUnit[] {
-  return Array.from(registry.values());
+function boundedBytes(left: number, right: number): number {
+  return left > MAX_AUCTION_BODY_BYTES - right ? MAX_AUCTION_BODY_BYTES + 1 : left + right;
+}
+
+function boundedStructureEntries(left: number, right: number): number {
+  return left > MAX_JSON_STRUCTURE_ENTRIES - right ? MAX_JSON_STRUCTURE_ENTRIES + 1 : left + right;
+}
+
+/** Exact JSON byte measurement that never consults `toJSON` or publisher prototypes. */
+function measureJson(
+  value: unknown,
+  memo = new WeakMap<object, JsonMeasurement>()
+): JsonMeasurement | undefined {
+  const primitive = primitiveJsonBytes(value);
+  if (primitive !== undefined) return Object.freeze({ bytes: primitive, structureEntries: 0 });
+  if (typeof value !== 'object' || value === null) return undefined;
+  const completedRoot = memo.get(value);
+  if (completedRoot) return completedRoot;
+  const root = snapshotJsonContainer(value);
+  if (!root) return undefined;
+  const active = new Set<object>();
+  active.add(value);
+  const stack: JsonMeasureFrame[] = [
+    {
+      array: root.array,
+      bytes: 2,
+      entries: root.entries,
+      index: 0,
+      source: value,
+      structureEntries: 1,
+    },
+  ];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (!frame) return undefined;
+    if (frame.index >= frame.entries.length) {
+      const measurement = Object.freeze({
+        bytes: frame.bytes,
+        snapshot: Object.freeze({ array: frame.array, entries: frame.entries }),
+        structureEntries: frame.structureEntries,
+      });
+      memo.set(frame.source, measurement);
+      active.delete(frame.source);
+      stack.pop();
+      const parent = stack[stack.length - 1];
+      if (!parent) return measurement;
+      parent.bytes = boundedBytes(parent.bytes, measurement.bytes);
+      parent.structureEntries = boundedStructureEntries(
+        parent.structureEntries,
+        measurement.structureEntries - 1
+      );
+      continue;
+    }
+    const entry = frame.entries[frame.index];
+    const entryIndex = frame.index;
+    frame.index += 1;
+    if (!entry) return undefined;
+    const prefix =
+      (entryIndex === 0 ? 0 : 1) + (frame.array ? 0 : encodedJsonStringBytes(entry.key) + 1);
+    frame.bytes = boundedBytes(frame.bytes, prefix);
+    frame.structureEntries = boundedStructureEntries(frame.structureEntries, 1);
+    const childPrimitive = primitiveJsonBytes(entry.value);
+    if (childPrimitive !== undefined) {
+      frame.bytes = boundedBytes(frame.bytes, childPrimitive);
+      continue;
+    }
+    if (typeof entry.value !== 'object' || entry.value === null || active.has(entry.value)) {
+      return undefined;
+    }
+    const completed = memo.get(entry.value);
+    if (completed !== undefined) {
+      frame.bytes = boundedBytes(frame.bytes, completed.bytes);
+      frame.structureEntries = boundedStructureEntries(
+        frame.structureEntries,
+        completed.structureEntries - 1
+      );
+      continue;
+    }
+    const child = snapshotJsonContainer(entry.value);
+    if (!child) return undefined;
+    active.add(entry.value);
+    stack.push({
+      array: child.array,
+      bytes: 2,
+      entries: child.entries,
+      index: 0,
+      source: entry.value,
+      structureEntries: 1,
+    });
+  }
+  return undefined;
 }
 
-// Look up a unit by its code.
-export function getUnit(code: string): AdUnit | undefined {
-  return registry.get(code);
+function snapshotKnownSlots(knownSlots: ReadonlySet<string>): ReadonlySet<string> {
+  try {
+    return new Set(knownSlots);
+  } catch {
+    throw new AdUnitRegistrationError('slot_collision');
+  }
+}
+
+interface ValidatedProgrammaticAdUnits {
+  readonly measurementMemo: WeakMap<object, JsonMeasurement>;
+  readonly pending: readonly PendingProgrammaticAdUnit[];
+}
+
+/**
+ * Validate and detach one complete public registration call before slot mutation.
+ *
+ * The returned graph is recursively frozen and safe to serialize later without
+ * reading publisher accessors again.
+ */
+function validateProgrammaticAdUnitsInput(
+  value: unknown,
+  knownSlots: ReadonlySet<string>
+): ValidatedProgrammaticAdUnits {
+  let units: readonly unknown[] | undefined;
+  try {
+    units = Array.isArray(value) ? ownDataArray(value, MAX_PROGRAMMATIC_UNITS) : [value];
+  } catch {
+    units = undefined;
+  }
+  if (!units || units.length === 0 || units.length > MAX_PROGRAMMATIC_UNITS) {
+    throw new AdUnitRegistrationError('invalid_units');
+  }
+
+  const occupied = snapshotKnownSlots(knownSlots);
+  const seen = new Set<string>();
+  const pending: PendingProgrammaticAdUnit[] = [];
+  const measurementMemo = new WeakMap<object, JsonMeasurement>();
+  for (let index = 0; index < units.length; index += 1) {
+    const unit = ownDataRecord(units[index]);
+    if (
+      !unit ||
+      (!exactKeys(unit, ['code', 'mediaTypes']) && !exactKeys(unit, ['code', 'mediaTypes', 'bids']))
+    ) {
+      throw new AdUnitRegistrationError('invalid_unit', index);
+    }
+    if (!validBoundedString(unit.code, 256)) {
+      throw new AdUnitRegistrationError('invalid_code', index);
+    }
+    if (seen.has(unit.code)) throw new AdUnitRegistrationError('duplicate_code', index);
+    if (occupied.has(unit.code)) throw new AdUnitRegistrationError('slot_collision', index);
+    seen.add(unit.code);
+
+    const mediaTypes = ownDataRecord(unit.mediaTypes);
+    const banner = ownDataRecord(mediaTypes?.banner);
+    if (
+      !mediaTypes ||
+      !exactKeys(mediaTypes, ['banner']) ||
+      !banner ||
+      !exactKeys(banner, ['sizes'])
+    ) {
+      throw new AdUnitRegistrationError('invalid_media_types', index);
+    }
+    const rawSizes = ownDataArray(banner.sizes, MAX_JSON_STRUCTURE_ENTRIES);
+    if (!rawSizes || rawSizes.length === 0) {
+      throw new AdUnitRegistrationError('invalid_media_types', index);
+    }
+    const sizes: Array<readonly [number, number]> = [];
+    for (let sizeIndex = 0; sizeIndex < rawSizes.length; sizeIndex += 1) {
+      const rawSize = rawSizes[sizeIndex];
+      const dimensions = ownDataArray(rawSize, 2);
+      const width = dimensions?.[0];
+      const height = dimensions?.[1];
+      if (
+        !dimensions ||
+        dimensions.length !== 2 ||
+        !validPositiveInteger(width) ||
+        !validPositiveInteger(height)
+      ) {
+        throw new AdUnitRegistrationError('invalid_dimensions', index);
+      }
+      if (width > 4_096 || height > 4_096) {
+        throw new AdUnitRegistrationError('dimensions_out_of_range', index);
+      }
+      sizes.push(Object.freeze([width, height]));
+    }
+
+    let bids: readonly PendingProgrammaticBid[] | undefined;
+    if (unit.bids !== undefined) {
+      const rawBids = ownDataArray(unit.bids, MAX_JSON_STRUCTURE_ENTRIES);
+      if (!rawBids) throw new AdUnitRegistrationError('invalid_bids', index);
+      const pendingBids: PendingProgrammaticBid[] = [];
+      for (let bidIndex = 0; bidIndex < rawBids.length; bidIndex += 1) {
+        const rawBid = rawBids[bidIndex];
+        const bid = ownDataRecord(rawBid);
+        if (!bid || (!exactKeys(bid, ['bidder']) && !exactKeys(bid, ['bidder', 'params']))) {
+          throw new AdUnitRegistrationError('invalid_bids', index);
+        }
+        if (
+          typeof bid.bidder !== 'string' ||
+          bid.bidder.length === 0 ||
+          (
+            reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [
+              bid.bidder,
+            ]) as Uint8Array
+          ).byteLength > 64
+        ) {
+          throw new AdUnitRegistrationError('invalid_bidder', index);
+        }
+        let params: object | undefined;
+        if (bid.params !== undefined) {
+          if (typeof bid.params !== 'object' || bid.params === null || Array.isArray(bid.params)) {
+            throw new AdUnitRegistrationError('invalid_params', index);
+          }
+          const measurement = measureJson(bid.params, measurementMemo);
+          if (!measurement) throw new AdUnitRegistrationError('invalid_params', index);
+          params = bid.params;
+        }
+        pendingBids.push(
+          Object.freeze({ bidder: bid.bidder, ...(params === undefined ? {} : { params }) })
+        );
+      }
+      bids = Object.freeze(pendingBids);
+    }
+
+    pending.push(
+      Object.freeze({
+        code: unit.code,
+        mediaTypes: Object.freeze({
+          banner: Object.freeze({ sizes: Object.freeze(sizes) }),
+        }),
+        ...(bids === undefined ? {} : { bids }),
+      })
+    );
+  }
+
+  const bodyMeasurement = measureJson({ adUnits: pending, config: {} }, measurementMemo);
+  if (!bodyMeasurement) throw new AdUnitRegistrationError('invalid_params');
+  if (
+    bodyMeasurement.bytes > MAX_AUCTION_BODY_BYTES ||
+    bodyMeasurement.structureEntries > MAX_JSON_STRUCTURE_ENTRIES
+  ) {
+    throw new AdUnitRegistrationError('request_body_too_large');
+  }
+  if (occupied.size + pending.length > MAX_ACTIVE_SLOT_RECORDS) {
+    throw new AdUnitRegistrationError('registry_capacity');
+  }
+  return Object.freeze({ measurementMemo, pending: Object.freeze(pending) });
+}
+
+/** Validate one complete registration without retaining publisher-owned input. */
+export function validateProgrammaticAdUnits(value: unknown, knownSlots: ReadonlySet<string>): void {
+  validateProgrammaticAdUnitsInput(value, knownSlots);
+}
+
+/** Validate and detach one complete public registration call before slot mutation. */
+export function prepareProgrammaticAdUnits(
+  value: unknown,
+  knownSlots: ReadonlySet<string>
+): readonly ProgrammaticAdUnit[] {
+  const { measurementMemo, pending } = validateProgrammaticAdUnitsInput(value, knownSlots);
+
+  const completedCopies = new WeakMap<object, Record<string, unknown> | unknown[]>();
+  const prepared: ProgrammaticAdUnit[] = [];
+  for (let index = 0; index < pending.length; index += 1) {
+    const unit = pending[index];
+    if (!unit) throw new AdUnitRegistrationError('invalid_unit', index);
+    let bids: ProgrammaticAdUnit['bids'];
+    if (unit.bids !== undefined) {
+      const copiedBids: Array<NonNullable<ProgrammaticAdUnit['bids']>[number]> = [];
+      for (let bidIndex = 0; bidIndex < unit.bids.length; bidIndex += 1) {
+        const bid = unit.bids[bidIndex];
+        if (!bid) throw new AdUnitRegistrationError('invalid_bids', index);
+        let params: Readonly<Record<string, unknown>> | undefined;
+        if (bid.params !== undefined) {
+          params = copyJsonRecord(bid.params, completedCopies, measurementMemo);
+          if (!params) throw new AdUnitRegistrationError('invalid_params', index);
+        }
+        copiedBids.push(
+          Object.freeze({ bidder: bid.bidder, ...(params === undefined ? {} : { params }) })
+        );
+      }
+      bids = Object.freeze(copiedBids);
+    }
+    prepared.push(
+      Object.freeze({
+        code: unit.code,
+        mediaTypes: unit.mediaTypes,
+        ...(bids === undefined ? {} : { bids }),
+      })
+    );
+  }
+  const frozenPrepared = Object.freeze(prepared);
+  const finalMeasurement = measureJson({ adUnits: frozenPrepared, config: {} });
+  if (!finalMeasurement) throw new AdUnitRegistrationError('invalid_params');
+  if (
+    finalMeasurement.bytes > MAX_AUCTION_BODY_BYTES ||
+    finalMeasurement.structureEntries > MAX_JSON_STRUCTURE_ENTRIES
+  ) {
+    throw new AdUnitRegistrationError('request_body_too_large');
+  }
+  return frozenPrepared;
+}
+
+export function addAdUnitsResult(units: readonly ProgrammaticAdUnit[]): AddAdUnitsResult {
+  return Object.freeze({ registered: Object.freeze(units.map(({ code }) => code)) });
+}
+
+/** Serialize one bounded `/auction` body without consulting inherited `toJSON` hooks. */
+export function serializeAuctionRequestBody(
+  adUnits: readonly Readonly<object>[],
+  config: Readonly<Record<string, unknown>>
+): string | undefined {
+  try {
+    const detached = copyJsonForSerialization({ adUnits, config });
+    if (!detached) return undefined;
+    const serialized = reflectApplyIntrinsic(jsonStringifyIntrinsic, JSON, [detached]) as unknown;
+    if (typeof serialized !== 'string') return undefined;
+    const bytes = reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [
+      serialized,
+    ]) as Uint8Array;
+    return bytes.byteLength <= MAX_AUCTION_BODY_BYTES ? serialized : undefined;
+  } catch {
+    return undefined;
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/core/release.ts b/crates/trusted-server-js/lib/src/core/release.ts
new file mode 100644
index 000000000..aaf201c27
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/release.ts
@@ -0,0 +1,28 @@
+declare const __TSJS_EMBEDDED_INTEGRATION_IDS_V1__: readonly string[];
+declare const __TSJS_EMBEDDED_RUNTIME_CATALOG_V1__: readonly Readonly<{
+  id: string;
+  phase: 'takeover' | 'deferred';
+  trigger: 'first_display_or_idle' | null;
+  config: import('../kernel/release_catalog').ReleaseConfigSourceV1;
+  consumes: readonly string[];
+  provides: readonly string[];
+}>[];
+
+export { EMBEDDED_RELEASE_ID } from './release_id';
+
+/** Build-generated inventory of every integration bundle admitted by this release. */
+export const EMBEDDED_INTEGRATION_IDS = Object.freeze([...__TSJS_EMBEDDED_INTEGRATION_IDS_V1__]);
+
+/** Build-generated capability/order authority without build-only product prose. */
+export const EMBEDDED_RUNTIME_CATALOG = Object.freeze(
+  __TSJS_EMBEDDED_RUNTIME_CATALOG_V1__.map((entry) =>
+    Object.freeze({
+      id: entry.id,
+      phase: entry.phase,
+      trigger: entry.trigger,
+      config: entry.config,
+      consumes: Object.freeze([...entry.consumes]),
+      provides: Object.freeze([...entry.provides]),
+    })
+  )
+);
diff --git a/crates/trusted-server-js/lib/src/core/release_id.ts b/crates/trusted-server-js/lib/src/core/release_id.ts
new file mode 100644
index 000000000..303574bce
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/release_id.ts
@@ -0,0 +1,4 @@
+declare const __TSJS_EMBEDDED_RELEASE_ID_V1__: string;
+
+/** Build-stamped identity shared by every artifact in one generated release. */
+export const EMBEDDED_RELEASE_ID = __TSJS_EMBEDDED_RELEASE_ID_V1__;
diff --git a/crates/trusted-server-js/lib/src/core/render.ts b/crates/trusted-server-js/lib/src/core/render.ts
index e0f25a807..b16f94376 100644
--- a/crates/trusted-server-js/lib/src/core/render.ts
+++ b/crates/trusted-server-js/lib/src/core/render.ts
@@ -1,10 +1,4 @@
-// Rendering utilities for Trusted Server demo placements: find slots, seed placeholders,
-// and inject creatives into sandboxed iframes.
-import { normalizeTrustedOrigin } from '../shared/origin';
-
-import { log } from './log';
-import type { AdUnit } from './types';
-import { getUnit, getAllUnits, firstSize } from './registry';
+// Rendering utilities for injecting creatives into sandboxed iframes.
 import NORMALIZE_CSS from './styles/normalize.css?inline';
 import IFRAME_TEMPLATE from './templates/iframe.html?raw';
 
@@ -29,6 +23,97 @@ const CREATIVE_SANDBOX_TOKENS = [
   'allow-top-navigation-by-user-activation',
 ] as const;
 
+/** Exact sandbox granted to TS-owned ADM documents. */
+export const ADM_IFRAME_SANDBOX = CREATIVE_SANDBOX_TOKENS.join(' ');
+
+const ADM_MAX_UTF8_BYTES = 512 * 1024;
+const RENDER_DIMENSION_MIN = 1;
+const RENDER_DIMENSION_MAX = 4096;
+const nativeDocument = typeof document === 'undefined' ? undefined : document;
+const nativeUrl = typeof URL === 'undefined' ? undefined : URL;
+const nativeTextEncoder = typeof TextEncoder === 'undefined' ? undefined : TextEncoder;
+const nativeTextEncoderEncode = nativeTextEncoder?.prototype.encode;
+const nativePublisherOrigin =
+  typeof location === 'undefined' ? undefined : exactHttpOrigin(location.origin);
+const documentCreateElement =
+  typeof Document === 'undefined' ? undefined : Document.prototype.createElement;
+const nodeAppendChild = typeof Node === 'undefined' ? undefined : Node.prototype.appendChild;
+const nodeRemoveChild = typeof Node === 'undefined' ? undefined : Node.prototype.removeChild;
+const nodeParentGetter =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'parentNode')?.get;
+const nodeOwnerDocumentGetter =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'ownerDocument')?.get;
+const nodeConnectedGetter =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')?.get;
+const elementChildrenGetter =
+  typeof Element === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Element.prototype, 'children')?.get;
+const elementGetAttribute =
+  typeof Element === 'undefined' ? undefined : Element.prototype.getAttribute;
+const elementHasAttribute =
+  typeof Element === 'undefined' ? undefined : Element.prototype.hasAttribute;
+const elementSetAttribute =
+  typeof Element === 'undefined' ? undefined : Element.prototype.setAttribute;
+const eventTargetAddEventListener =
+  typeof EventTarget === 'undefined' ? undefined : EventTarget.prototype.addEventListener;
+const eventTargetRemoveEventListener =
+  typeof EventTarget === 'undefined' ? undefined : EventTarget.prototype.removeEventListener;
+const htmlCollectionLengthGetter =
+  typeof HTMLCollection === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(HTMLCollection.prototype, 'length')?.get;
+const htmlCollectionItem =
+  typeof HTMLCollection === 'undefined' ? undefined : HTMLCollection.prototype.item;
+const iframeSrcdocDescriptor =
+  typeof HTMLIFrameElement === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'srcdoc');
+const iframeReferrerPolicyDescriptor =
+  typeof HTMLIFrameElement === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'referrerPolicy');
+const objectDefineProperty = Object.defineProperty;
+const objectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const objectFreezeIntrinsic = Object.freeze;
+const numberIsIntegerIntrinsic = Number.isInteger;
+const reflectApplyIntrinsic = Reflect.apply;
+const stringReplaceIntrinsic = String.prototype.replace;
+const stringTrimIntrinsic = String.prototype.trim;
+const stringIntrinsic = String;
+
+export interface PrepareAdmIframeOptions {
+  readonly adm: string;
+  readonly container: HTMLElement;
+  readonly height: number;
+  readonly onError: () => void;
+  readonly onLoad: () => void;
+  readonly width: number;
+}
+
+export interface AdmIframeHandle {
+  readonly frame: HTMLIFrameElement;
+  append(): boolean;
+  activate(): boolean;
+  commit(): boolean;
+  current(): boolean;
+  dispose(): void;
+}
+
+function applyIntrinsic<Result>(
+  method: (...arguments_: never[]) => unknown,
+  receiver: unknown,
+  arguments_: unknown[]
+): Result {
+  return reflectApplyIntrinsic(method, receiver, arguments_) as Result;
+}
+
 export type CreativeSanitizationRejectionReason = 'empty-after-sanitize' | 'invalid-creative-html';
 
 export type AcceptedCreativeHtml = {
@@ -58,11 +143,6 @@ export type RejectedCreativeHtml = {
 
 export type SanitizeCreativeHtmlResult = AcceptedCreativeHtml | RejectedCreativeHtml;
 
-function normalizeId(raw: string): string {
-  const s = String(raw ?? '').trim();
-  return s.startsWith('#') ? s.slice(1) : s;
-}
-
 // Validate the untrusted creative fragment before embedding it in the sandboxed iframe.
 // This is validation-only, not sanitization: it guards against type errors and empty
 // payloads and never removes content. Server-side stripping of executable markup is
@@ -103,78 +183,6 @@ export function sanitizeCreativeHtml(creativeHtml: unknown): SanitizeCreativeHtm
   };
 }
 
-// Locate an ad slot element by id, tolerating funky selectors provided by tag managers.
-export function findSlot(id: string): HTMLElement | null {
-  const nid = normalizeId(id);
-  // Fast path
-  const byId = document.getElementById(nid) as HTMLElement | null;
-  if (byId) return byId;
-  // Fallback for odd IDs (special chars) or if provided with quotes/etc.
-  try {
-    const selector = `[id="${nid.replace(/"/g, '\\"')}"]`;
-    const byAttr = document.querySelector(selector) as HTMLElement | null;
-    if (byAttr) return byAttr;
-  } catch {
-    // Ignore selector errors (e.g., invalid characters)
-  }
-  return null;
-}
-
-function ensureSlot(id: string): HTMLElement {
-  const nid = normalizeId(id);
-  let el = document.getElementById(nid) as HTMLElement | null;
-  if (el) return el;
-  el = document.createElement('div');
-  el.id = nid;
-  const body: HTMLElement | null = typeof document !== 'undefined' ? document.body : null;
-  if (body && typeof body.appendChild === 'function') {
-    body.appendChild(el);
-  } else {
-    // DOM not ready — attach once available
-    const element = el;
-    const onReady = () => {
-      const readyBody = document.body;
-      if (readyBody && !document.getElementById(nid) && element) readyBody.appendChild(element);
-    };
-    document.addEventListener('DOMContentLoaded', onReady, { once: true });
-  }
-  return el;
-}
-
-// Drop a placeholder message into the slot so pages don't sit empty pre-render.
-export function renderAdUnit(codeOrUnit: string | AdUnit): void {
-  const code = typeof codeOrUnit === 'string' ? codeOrUnit : codeOrUnit?.code;
-  if (!code) return;
-  const unit = typeof codeOrUnit === 'string' ? getUnit(code) : codeOrUnit;
-  const size = (unit && firstSize(unit)) || [300, 250];
-  const el = ensureSlot(code);
-  try {
-    el.textContent = `Trusted Server — ${size[0]}x${size[1]}`;
-    log.info('renderAdUnit: rendered placeholder', { code, size });
-  } catch {
-    log.warn('renderAdUnit: failed', { code });
-  }
-}
-
-// Render placeholders for every registered ad unit (used in simple publisher demos).
-export function renderAllAdUnits(): void {
-  try {
-    const parentReady =
-      typeof document !== 'undefined' && (document.body || document.documentElement);
-    if (!parentReady) {
-      log.warn('renderAllAdUnits: DOM not ready; skipping');
-      return;
-    }
-    const units = getAllUnits();
-    for (const u of units) {
-      renderAdUnit(u);
-    }
-    log.info('renderAllAdUnits: rendered all placeholders', { count: units.length });
-  } catch (e) {
-    log.warn('renderAllAdUnits: failed', e as unknown);
-  }
-}
-
 type IframeOptions = { name?: string; title?: string; width?: number; height?: number };
 
 // Construct a sandboxed iframe for creative HTML. The markup may be raw bidder
@@ -200,8 +208,7 @@ export function createAdIframe(
     } else {
       iframe.setAttribute('sandbox', CREATIVE_SANDBOX_TOKENS.join(' '));
     }
-  } catch (err) {
-    log.debug('createAdIframe: sandbox add failed', err);
+  } catch {
     iframe.setAttribute('sandbox', CREATIVE_SANDBOX_TOKENS.join(' '));
   }
   // Sizing + style
@@ -231,9 +238,22 @@ export function createAdIframe(
 //
 // Only an exact `scheme://host[:port]` shape is emitted, so the value cannot
 // break out of the quoted string it is written into.
+function exactHttpOrigin(candidate: unknown): string | undefined {
+  if (typeof candidate !== 'string' || !nativeUrl) return undefined;
+  try {
+    const parsed = new nativeUrl(candidate);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return undefined;
+    if (parsed.username !== '' || parsed.password !== '') return undefined;
+    if (parsed.origin !== candidate) return undefined;
+    return parsed.origin;
+  } catch {
+    return undefined;
+  }
+}
+
 function trustedCreativeOrigin(): string {
   try {
-    return normalizeTrustedOrigin(location.origin);
+    return exactHttpOrigin(location.origin) ?? '';
   } catch {
     // fall through to an empty stamp; the runtime degrades to document.baseURI
   }
@@ -241,8 +261,370 @@ function trustedCreativeOrigin(): string {
 }
 
 // Build a complete HTML document for a creative fragment, suitable for iframe.srcdoc.
-export function buildCreativeDocument(creativeHtml: string): string {
-  return IFRAME_TEMPLATE.replace('%NORMALIZE_CSS%', () => NORMALIZE_CSS)
-    .replace('%TRUSTED_ORIGIN%', () => trustedCreativeOrigin())
-    .replace('%CREATIVE_HTML%', () => creativeHtml);
+export function buildCreativeDocument(
+  creativeHtml: string,
+  publisherOrigin: string = trustedCreativeOrigin()
+): string {
+  const normalized = applyIntrinsic<string>(stringReplaceIntrinsic, IFRAME_TEMPLATE, [
+    '%NORMALIZE_CSS%',
+    () => NORMALIZE_CSS,
+  ]);
+  const trusted = applyIntrinsic<string>(stringReplaceIntrinsic, normalized, [
+    '%TRUSTED_ORIGIN%',
+    () => exactHttpOrigin(publisherOrigin) ?? '',
+  ]);
+  return applyIntrinsic<string>(stringReplaceIntrinsic, trusted, [
+    '%CREATIVE_HTML%',
+    () => creativeHtml,
+  ]);
+}
+
+function nativeParent(node: Node): Node | null | undefined {
+  try {
+    return nodeParentGetter ? applyIntrinsic<Node | null>(nodeParentGetter, node, []) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function nativeOwnerDocument(node: Node): Document | null | undefined {
+  try {
+    return nodeOwnerDocumentGetter
+      ? applyIntrinsic<Document | null>(nodeOwnerDocumentGetter, node, [])
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function nativeConnected(node: Node): boolean {
+  try {
+    return !!nodeConnectedGetter && applyIntrinsic(nodeConnectedGetter, node, []) === true;
+  } catch {
+    return false;
+  }
+}
+
+function nativeAttribute(element: Element, name: string): string | null | undefined {
+  try {
+    return elementGetAttribute
+      ? applyIntrinsic<string | null>(elementGetAttribute, element, [name])
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function hasNativeAttribute(element: Element, name: string): boolean {
+  try {
+    return (
+      !!elementHasAttribute &&
+      applyIntrinsic<boolean>(elementHasAttribute, element, [name]) === true
+    );
+  } catch {
+    return true;
+  }
+}
+
+function setNativeAttribute(element: Element, name: string, value: string): boolean {
+  try {
+    if (!elementSetAttribute) return false;
+    applyIntrinsic(elementSetAttribute, element, [name, value]);
+    return nativeAttribute(element, name) === value;
+  } catch {
+    return false;
+  }
+}
+
+function nativeSrcdoc(frame: HTMLIFrameElement): string | undefined {
+  try {
+    return iframeSrcdocDescriptor?.get
+      ? applyIntrinsic<string>(iframeSrcdocDescriptor.get, frame, [])
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function nativeReferrerPolicy(frame: HTMLIFrameElement): string | undefined {
+  try {
+    if (iframeReferrerPolicyDescriptor?.get) {
+      return applyIntrinsic<string>(iframeReferrerPolicyDescriptor.get, frame, []);
+    }
+    const own = objectGetOwnPropertyDescriptor(frame, 'referrerPolicy');
+    return own && 'value' in own && typeof own.value === 'string' ? own.value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function removeNativeNode(node: Node): void {
+  const parent = nativeParent(node);
+  if (!parent || !nodeRemoveChild) return;
+  try {
+    applyIntrinsic(nodeRemoveChild, parent, [node]);
+  } catch {
+    // Best-effort disposal is intentionally exact to this owned node.
+  }
+}
+
+function snapshotChildren(container: Element): Element[] | undefined {
+  try {
+    const children = elementChildrenGetter
+      ? applyIntrinsic<HTMLCollection>(elementChildrenGetter, container, [])
+      : undefined;
+    if (!children || !htmlCollectionLengthGetter || !htmlCollectionItem) return undefined;
+    const length = applyIntrinsic<number>(htmlCollectionLengthGetter, children, []);
+    const snapshot: Element[] = [];
+    for (let index = 0; index < length; index += 1) {
+      const child = applyIntrinsic<Element | null>(htmlCollectionItem, children, [index]);
+      if (!child) return undefined;
+      snapshot[snapshot.length] = child;
+    }
+    return snapshot;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Prepare one detached, fully configured ADM iframe.
+ *
+ * The returned handle owns insertion, event delivery, predecessor cleanup, and
+ * disposal. No publisher-overridable instance methods are used for those actions.
+ */
+export function prepareAdmIframe(options: PrepareAdmIframeOptions): AdmIframeHandle | undefined {
+  const { adm, container, height, onError, onLoad, width } = options;
+  if (
+    !nativeDocument ||
+    !documentCreateElement ||
+    !nodeAppendChild ||
+    !nodeRemoveChild ||
+    !eventTargetAddEventListener ||
+    !eventTargetRemoveEventListener ||
+    !iframeSrcdocDescriptor?.get ||
+    !iframeSrcdocDescriptor.set ||
+    nativeOwnerDocument(container) !== nativeDocument ||
+    !nativeConnected(container) ||
+    typeof adm !== 'string' ||
+    applyIntrinsic<string>(stringTrimIntrinsic, adm, []).length === 0 ||
+    !nativeTextEncoder ||
+    !nativeTextEncoderEncode ||
+    !applyIntrinsic<boolean>(numberIsIntegerIntrinsic, Number, [width]) ||
+    width < RENDER_DIMENSION_MIN ||
+    width > RENDER_DIMENSION_MAX ||
+    !applyIntrinsic<boolean>(numberIsIntegerIntrinsic, Number, [height]) ||
+    height < RENDER_DIMENSION_MIN ||
+    height > RENDER_DIMENSION_MAX ||
+    typeof onLoad !== 'function' ||
+    typeof onError !== 'function'
+  ) {
+    return undefined;
+  }
+
+  try {
+    const encoder = new nativeTextEncoder();
+    const bytes = applyIntrinsic<Uint8Array>(nativeTextEncoderEncode, encoder, [adm]);
+    if (bytes.byteLength > ADM_MAX_UTF8_BYTES) return undefined;
+  } catch {
+    return undefined;
+  }
+
+  let frame: HTMLIFrameElement;
+  try {
+    frame = applyIntrinsic<HTMLIFrameElement>(documentCreateElement, nativeDocument, ['iframe']);
+  } catch {
+    return undefined;
+  }
+  if (nativeOwnerDocument(frame) !== nativeDocument || nativeParent(frame) !== null)
+    return undefined;
+
+  const intendedSrcdoc = buildCreativeDocument(adm, nativePublisherOrigin ?? '');
+  const attributes = [
+    ['sandbox', ADM_IFRAME_SANDBOX],
+    ['referrerpolicy', 'no-referrer'],
+    ['width', applyIntrinsic<string>(stringIntrinsic, undefined, [width])],
+    ['height', applyIntrinsic<string>(stringIntrinsic, undefined, [height])],
+    ['scrolling', 'no'],
+    ['frameborder', '0'],
+    ['marginwidth', '0'],
+    ['marginheight', '0'],
+    ['title', 'Ad content'],
+    ['aria-label', 'Advertisement'],
+    [
+      'style',
+      `border: 0; margin: 0; overflow: hidden; display: block; width: ${width}px; height: ${height}px;`,
+    ],
+  ] as const;
+  for (let index = 0; index < attributes.length; index += 1) {
+    const attribute = attributes[index];
+    if (!attribute) return undefined;
+    const name = attribute[0];
+    const value = attribute[1];
+    if (!setNativeAttribute(frame, name, value)) return undefined;
+  }
+  try {
+    if (iframeReferrerPolicyDescriptor?.set) {
+      applyIntrinsic(iframeReferrerPolicyDescriptor.set, frame, ['no-referrer']);
+    } else {
+      objectDefineProperty(frame, 'referrerPolicy', {
+        configurable: false,
+        enumerable: true,
+        value: 'no-referrer',
+        writable: false,
+      });
+    }
+  } catch {
+    return undefined;
+  }
+
+  let active = false;
+  let appended = false;
+  let committed = false;
+  let disposed = false;
+  let terminal = false;
+  let pending: 'error' | 'load' | undefined;
+  let predecessors: Element[] = [];
+
+  const exactAttributes = (): boolean => {
+    for (let index = 0; index < attributes.length; index += 1) {
+      const attribute = attributes[index];
+      if (!attribute) return false;
+      const name = attribute[0];
+      const value = attribute[1];
+      if (nativeAttribute(frame, name) !== value) return false;
+    }
+    return nativeReferrerPolicy(frame) === 'no-referrer';
+  };
+
+  const current = (): boolean => {
+    if (
+      disposed ||
+      !appended ||
+      nativeParent(frame) !== container ||
+      nativeOwnerDocument(frame) !== nativeDocument ||
+      !nativeConnected(frame) ||
+      nativeSrcdoc(frame) !== intendedSrcdoc ||
+      hasNativeAttribute(frame, 'src')
+    ) {
+      return false;
+    }
+    return exactAttributes();
+  };
+
+  const removeListeners = (): void => {
+    try {
+      applyIntrinsic(eventTargetRemoveEventListener, frame, ['load', onFrameLoad]);
+      applyIntrinsic(eventTargetRemoveEventListener, frame, ['error', onFrameError]);
+    } catch {
+      // Listener disposal remains best-effort after a hostile realm mutation.
+    }
+  };
+
+  const settle = (outcome: 'error' | 'load'): void => {
+    if (disposed || terminal) return;
+    terminal = true;
+    pending = undefined;
+    removeListeners();
+    if (outcome === 'load' && current()) onLoad();
+    else onError();
+  };
+
+  function onFrameLoad(): void {
+    if (disposed || terminal || !appended) return;
+    if (!current()) {
+      if (active) settle('error');
+      else pending = 'error';
+      return;
+    }
+    if (active) settle('load');
+    else pending = 'load';
+  }
+
+  function onFrameError(): void {
+    if (disposed || terminal || !appended) return;
+    if (active) settle('error');
+    else pending = 'error';
+  }
+
+  try {
+    applyIntrinsic(eventTargetAddEventListener, frame, ['load', onFrameLoad]);
+    applyIntrinsic(eventTargetAddEventListener, frame, ['error', onFrameError]);
+    applyIntrinsic(iframeSrcdocDescriptor.set, frame, [intendedSrcdoc]);
+  } catch {
+    removeListeners();
+    return undefined;
+  }
+  if (nativeSrcdoc(frame) !== intendedSrcdoc || hasNativeAttribute(frame, 'src')) {
+    removeListeners();
+    return undefined;
+  }
+
+  const dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    pending = undefined;
+    removeListeners();
+    removeNativeNode(frame);
+  };
+
+  return applyIntrinsic<Readonly<AdmIframeHandle>>(objectFreezeIntrinsic, Object, [
+    {
+      frame,
+      append: (): boolean => {
+        if (
+          disposed ||
+          committed ||
+          appended ||
+          nativeParent(frame) !== null ||
+          nativeOwnerDocument(container) !== nativeDocument ||
+          !nativeConnected(container) ||
+          nativeSrcdoc(frame) !== intendedSrcdoc ||
+          hasNativeAttribute(frame, 'src')
+        ) {
+          return false;
+        }
+        const before = snapshotChildren(container);
+        if (!before) return false;
+        predecessors = before;
+        appended = true;
+        try {
+          applyIntrinsic(nodeAppendChild, container, [frame]);
+        } catch {
+          dispose();
+          return false;
+        }
+        if (!current()) {
+          dispose();
+          return false;
+        }
+        return true;
+      },
+      activate: (): boolean => {
+        if (disposed || committed || terminal || active || !appended) return false;
+        active = true;
+        if (!current()) settle('error');
+        else if (pending) settle(pending);
+        return true;
+      },
+      commit: (): boolean => {
+        if (disposed || committed || !terminal || !current()) return false;
+        removeListeners();
+        for (let index = 0; index < predecessors.length; index += 1) {
+          const predecessor = predecessors[index];
+          if (!predecessor || !current()) return false;
+          if (predecessor !== frame && nativeParent(predecessor) === container) {
+            removeNativeNode(predecessor);
+            if (nativeParent(predecessor) === container) return false;
+          }
+        }
+        if (!current()) return false;
+        predecessors = [];
+        committed = true;
+        return true;
+      },
+      current,
+      dispose,
+    },
+  ]);
 }
diff --git a/crates/trusted-server-js/lib/src/core/request.ts b/crates/trusted-server-js/lib/src/core/request.ts
deleted file mode 100644
index c05070a9d..000000000
--- a/crates/trusted-server-js/lib/src/core/request.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-// Request orchestration for tsjs: unified auction endpoint with iframe-based creative rendering.
-import { dispatchApsRendering, renderApsCreative } from '../integrations/aps/render';
-
-import { buildAdRequest, sendAuction } from './auction';
-import { collectContext } from './context';
-import { log } from './log';
-import { getAllUnits, firstSize } from './registry';
-import { createAdIframe, findSlot, buildCreativeDocument, sanitizeCreativeHtml } from './render';
-
-export type RequestAdsCallback = () => void;
-export interface RequestAdsOptions {
-  bidsBackHandler?: RequestAdsCallback;
-  timeout?: number;
-}
-
-type RenderCreativeInlineOptions = {
-  slotId: string;
-  // Accept unknown input here because bidder JSON is untrusted at runtime.
-  creativeHtml: unknown;
-  creativeWidth?: number;
-  creativeHeight?: number;
-  seat: string;
-  creativeId: string;
-};
-
-// Entry point matching Prebid's requestBids signature; uses unified /auction endpoint.
-export function requestAds(
-  callbackOrOpts?: RequestAdsCallback | RequestAdsOptions,
-  maybeOpts?: RequestAdsOptions
-): void {
-  let callback: RequestAdsCallback | undefined;
-  let opts: RequestAdsOptions | undefined;
-  if (typeof callbackOrOpts === 'function') {
-    callback = callbackOrOpts as RequestAdsCallback;
-    opts = maybeOpts;
-  } else {
-    opts = callbackOrOpts as RequestAdsOptions | undefined;
-    callback = opts?.bidsBackHandler;
-  }
-
-  log.info('requestAds: called', { hasCallback: typeof callback === 'function' });
-  try {
-    const adUnits = getAllUnits();
-    const config = collectContext();
-    const payload = { ...buildAdRequest(adUnits), config };
-    log.debug('requestAds: payload', { units: adUnits.length, contextKeys: Object.keys(config) });
-
-    // Use unified auction endpoint
-    void sendAuction('/auction', payload)
-      .then((bids) => {
-        log.info('requestAds: got bids', { count: bids.length });
-        for (const bid of bids) {
-          if (!bid.impid) continue;
-          if (bid.renderer) {
-            void Promise.resolve(
-              dispatchApsRendering({
-                slotId: bid.impid,
-                renderer: bid.renderer,
-                trustedServer: (renderer) => renderApsCreative({ slotId: bid.impid, renderer }),
-              })
-            );
-            continue;
-          }
-          if (!bid.adm) {
-            log.debug('requestAds: bid has no adm, skipping', { slotId: bid.impid });
-            continue;
-          }
-          renderCreativeInline({
-            slotId: bid.impid,
-            creativeHtml: bid.adm,
-            creativeWidth: bid.width,
-            creativeHeight: bid.height,
-            seat: bid.seat,
-            creativeId: bid.creativeId,
-          });
-        }
-        log.info('requestAds: rendered creatives from response');
-      })
-      .catch((err) => {
-        log.warn('requestAds: auction failed', err);
-      });
-
-    // Synchronously invoke callback to match test expectations
-    try {
-      if (callback) callback();
-    } catch {
-      /* ignore callback errors */
-    }
-  } catch {
-    log.warn('requestAds: failed to initiate');
-  }
-}
-
-// Render a creative by writing its HTML into a sandboxed iframe. The markup may
-// be raw bidder output (server-side sanitization is opt-in); the sandbox's
-// origin isolation is the security boundary.
-function renderCreativeInline({
-  slotId,
-  creativeHtml,
-  creativeWidth,
-  creativeHeight,
-  seat,
-  creativeId,
-}: RenderCreativeInlineOptions): void {
-  const container = findSlot(slotId) as HTMLElement | null;
-  if (!container) {
-    log.warn('renderCreativeInline: slot not found; skipping render', { slotId, seat, creativeId });
-    return;
-  }
-
-  try {
-    const sanitization = sanitizeCreativeHtml(creativeHtml);
-    if (sanitization.kind === 'rejected') {
-      log.warn('renderCreativeInline: rejected creative', {
-        slotId,
-        seat,
-        creativeId,
-        originalLength: sanitization.originalLength,
-        rejectionReason: sanitization.rejectionReason,
-      });
-      return;
-    }
-
-    // Clear the slot only after sanitization succeeds so rejected creatives never blank existing content.
-    container.innerHTML = '';
-
-    // Determine size with fallback chain: creative size → ad unit size → 300x250
-    let width: number;
-    let height: number;
-
-    if (creativeWidth && creativeHeight && creativeWidth > 0 && creativeHeight > 0) {
-      width = creativeWidth;
-      height = creativeHeight;
-      log.debug('renderCreativeInline: using creative dimensions', { width, height });
-    } else {
-      const unit = getAllUnits().find((u) => u.code === slotId);
-      const size = (unit && firstSize(unit)) || [300, 250];
-      width = size[0];
-      height = size[1];
-      log.debug('renderCreativeInline: using ad unit dimensions', { width, height });
-    }
-
-    const iframe = createAdIframe(container, {
-      name: `tsjs_iframe_${slotId}`,
-      title: 'Ad content',
-      width,
-      height,
-    });
-
-    iframe.srcdoc = buildCreativeDocument(sanitization.sanitizedHtml);
-
-    log.info('renderCreativeInline: rendered', {
-      slotId,
-      seat,
-      creativeId,
-      width,
-      height,
-      originalLength: sanitization.originalLength,
-    });
-  } catch (err) {
-    log.warn('renderCreativeInline: failed', { slotId, seat, creativeId, err });
-  }
-}
diff --git a/crates/trusted-server-js/lib/src/core/slot_element.ts b/crates/trusted-server-js/lib/src/core/slot_element.ts
deleted file mode 100644
index b7cf47d88..000000000
--- a/crates/trusted-server-js/lib/src/core/slot_element.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-/** Result of resolving one configured slot div ID against the live DOM. */
-export interface SlotElementResolution {
-  element: HTMLElement | null;
-  prefixMatchCount: number;
-  activeMatchCount: number;
-}
-
-function isElementVisible(element: HTMLElement): boolean {
-  const elementWithVisibilityCheck = element as HTMLElement & {
-    checkVisibility?: (options?: {
-      checkVisibilityCSS?: boolean;
-      visibilityProperty?: boolean;
-    }) => boolean;
-  };
-  if (typeof elementWithVisibilityCheck.checkVisibility === 'function') {
-    return elementWithVisibilityCheck.checkVisibility({
-      checkVisibilityCSS: true,
-      visibilityProperty: true,
-    });
-  }
-
-  for (let current: HTMLElement | null = element; current; current = current.parentElement) {
-    const style = window.getComputedStyle(current);
-    if (
-      style.display === 'none' ||
-      style.visibility === 'hidden' ||
-      style.visibility === 'collapse'
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function slotElementHasLayout(element: HTMLElement): boolean {
-  if (!isElementVisible(element)) return false;
-  const elementRect = element.getBoundingClientRect();
-  if (elementRect.width > 0 && elementRect.height > 0) return true;
-
-  const container = document.getElementById(`${element.id}-container`);
-  if (!container || !isElementVisible(container)) return false;
-  const containerRect = container.getBoundingClientRect();
-  return containerRect.width > 0;
-}
-
-/** Resolve an exact ID or one unambiguous visible/layout prefix match. */
-export function resolveSlotElementByDivId(divId: string): SlotElementResolution {
-  if (!divId) {
-    return { element: null, prefixMatchCount: 0, activeMatchCount: 0 };
-  }
-
-  const exact = document.getElementById(divId);
-  if (exact) {
-    return { element: exact, prefixMatchCount: 1, activeMatchCount: 1 };
-  }
-
-  const prefixMatches = Array.from(document.querySelectorAll<HTMLElement>('[id]')).filter(
-    (element) => element.id.startsWith(divId) && !element.id.endsWith('-container')
-  );
-  if (prefixMatches.length === 1 && isElementVisible(prefixMatches[0]!)) {
-    return {
-      element: prefixMatches[0]!,
-      prefixMatchCount: 1,
-      activeMatchCount: 1,
-    };
-  }
-
-  const visibleMatches = prefixMatches.filter(isElementVisible);
-  if (visibleMatches.length === 1) {
-    return {
-      element: visibleMatches[0]!,
-      prefixMatchCount: prefixMatches.length,
-      activeMatchCount: 1,
-    };
-  }
-
-  const activeMatches = visibleMatches.filter(slotElementHasLayout);
-  return {
-    element: activeMatches.length === 1 ? activeMatches[0]! : null,
-    prefixMatchCount: prefixMatches.length,
-    activeMatchCount: activeMatches.length,
-  };
-}
diff --git a/crates/trusted-server-js/lib/src/core/trace.ts b/crates/trusted-server-js/lib/src/core/trace.ts
new file mode 100644
index 000000000..5601c7ab5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/core/trace.ts
@@ -0,0 +1,1027 @@
+// Closure-private render diagnostics data for the hard-cutover runtime.
+import type { RenderTraceDiagnostics, RenderTraceRecord } from './types';
+
+const MAX_RENDER_LOG_ENTRIES = 200;
+
+const MAX_RENDER_TRACE_SLOTS = 256;
+const MAX_RENDER_TRACE_COUNTERS = 768;
+const MAX_RENDER_TRACE_SUBSCRIBERS = 32;
+const MAX_RENDER_TRACE_NOTIFICATIONS = 200;
+const EMPTY_RENDER_TRACE_CURRENT = Object.freeze(
+  Object.create(null) as Record<string, Readonly<RenderTraceRecord>>
+);
+const EMPTY_RENDER_TRACE_HISTORY = Object.freeze([]) as readonly Readonly<RenderTraceRecord>[];
+
+type RenderTraceInputV1 = Omit<RenderTraceRecord, 'at' | 'count' | 'seq'>;
+type RenderTraceUpdateV1 = Partial<Omit<RenderTraceRecord, 'at' | 'count' | 'seq' | 'slotId'>>;
+
+/** Safe GPT fact shape admitted by the closure-private diagnostics bus. */
+export interface RenderTraceGptFactV1 extends Readonly<Record<string, unknown>> {
+  readonly kind:
+    | 'slotRequested'
+    | 'slotResponseReceived'
+    | 'slotRenderEnded'
+    | 'slotOnload'
+    | 'impressionViewable'
+    | 'slotVisibilityChanged';
+  readonly slot: Readonly<{
+    readonly token: string;
+    readonly cycleOrdinal: number;
+    readonly elementId?: string;
+  }>;
+  readonly isEmpty?: boolean;
+  readonly inViewPercentage?: number;
+}
+
+/** Current registered-slot identity and presentation state for one safe GPT fact. */
+export interface RenderTraceGptResolutionV1 {
+  readonly slotId: string;
+  readonly navigationGeneration: object;
+  readonly traceToken: string;
+  readonly elementId?: string;
+  readonly visible?: boolean;
+}
+
+export interface RenderTraceRuntimeScheduler {
+  readonly set: (callback: () => void, milliseconds: number) => unknown;
+  readonly clear: (handle: unknown) => void;
+}
+
+export interface RenderTraceRuntimeOptions {
+  readonly now?: () => number;
+  readonly onOverflow?: (droppedNotifications: number) => void;
+  readonly onPresentationError?: (error: unknown) => void;
+  readonly onSubscriberError?: (error: unknown) => void;
+  readonly schedule?: (callback: () => void) => () => void;
+  readonly scheduler?: RenderTraceRuntimeScheduler;
+}
+
+export interface FirstDisplayTraceAdoptionV1 {
+  readonly navigationGeneration: object;
+  readonly nextSequence: number;
+  readonly slots: readonly Readonly<{
+    readonly bindings: readonly Readonly<{
+      readonly cycleOrdinal: number;
+      readonly historySequence: number;
+      readonly state: 'completed' | 'retired';
+      readonly token: string;
+    }>[];
+    readonly impressions: number;
+    readonly records: readonly Readonly<RenderTraceRecord>[];
+    readonly slotId: string;
+  }>[];
+}
+
+/** Closure-private data channel made available only to the deferred presentation owner. */
+export interface RenderTracePresentationSource {
+  readonly current: RenderTraceDiagnostics['current'];
+  readonly history: RenderTraceDiagnostics['history'];
+  readonly subscribe: (listener: () => void) => () => void;
+}
+
+export interface RenderTracePresentationControls {
+  readonly dispose: () => void;
+}
+
+export type RenderTracePresentationFactory = (
+  source: RenderTracePresentationSource
+) => RenderTracePresentationControls;
+
+export interface RenderTraceRuntimeOwner {
+  readonly api: RenderTraceDiagnostics;
+  readonly diagnostics: RenderTraceDiagnostics;
+  readonly record: (input: RenderTraceInputV1) => Readonly<RenderTraceRecord> | undefined;
+  readonly enrich: (
+    recordOrSequence: Readonly<RenderTraceRecord> | number,
+    patch: RenderTraceUpdateV1
+  ) => Readonly<RenderTraceRecord> | undefined;
+  readonly prune: (slotId: string, sequence?: number) => boolean;
+  readonly pruneNavigation: (navigationGeneration: object) => number;
+  readonly observeGptFact: (
+    fact: Readonly<RenderTraceGptFactV1>,
+    resolve: (elementId: string | undefined) => RenderTraceGptResolutionV1 | undefined
+  ) => void;
+  readonly attachPresentation: (factory: RenderTracePresentationFactory) => () => void;
+  readonly adoptFirstDisplay: (candidate: FirstDisplayTraceAdoptionV1) => boolean;
+  readonly dispose: () => void;
+}
+
+export class DiagnosticsSubscriberLimitError extends Error {
+  public readonly code = 'subscriber_capacity' as const;
+  public readonly surface: 'renderTrace' | 'gpt';
+
+  public constructor(surface: 'renderTrace' | 'gpt') {
+    super('subscriber_capacity');
+    this.name = 'DiagnosticsSubscriberLimitError';
+    this.surface = surface;
+  }
+}
+
+interface RenderTraceSubscription {
+  readonly id: number;
+  readonly listener: (record: Readonly<RenderTraceRecord>) => void;
+}
+
+interface PendingRenderTraceNotification {
+  readonly record: Readonly<RenderTraceRecord>;
+  readonly subscriberIds: readonly number[];
+}
+
+function copyRenderTraceRecord(record: Readonly<RenderTraceRecord>): Readonly<RenderTraceRecord> {
+  const copy: Record<string, unknown> = {
+    slotId: record.slotId,
+    path: record.path,
+    rendered: record.rendered,
+  };
+  const optional = [
+    'elementId',
+    'auctionId',
+    'bidder',
+    'adId',
+    'bidId',
+    'creativeId',
+    'admHash',
+    'servedFrom',
+    'gamEmpty',
+    'injected',
+    'visible',
+  ] as const;
+  for (const key of optional) {
+    const value = record[key];
+    if (value !== undefined) copy[key] = value;
+  }
+  copy.count = record.count;
+  copy.seq = record.seq;
+  copy.at = record.at;
+  return Object.freeze(copy) as unknown as Readonly<RenderTraceRecord>;
+}
+
+function scheduleRenderTraceTask(callback: () => void): () => void {
+  const handle = globalThis.setTimeout(callback, 0);
+  return (): void => globalThis.clearTimeout(handle);
+}
+
+function createRenderTraceOwner(options: RenderTraceRuntimeOptions): RenderTraceRuntimeOwner {
+  const current = new Map<string, Readonly<RenderTraceRecord>>();
+  const counts = new Map<string, number>();
+  const history: Array<Readonly<RenderTraceRecord>> = [];
+  const recordsBySequence = new Map<number, Readonly<RenderTraceRecord>>();
+  const gptImpressions = new Map<
+    string,
+    {
+      readonly baselineSequence: number | undefined;
+      historySequence?: number;
+      readonly navigationGeneration: object;
+      reconciled?: boolean;
+      readonly slotId: string;
+      state: 'open' | 'completed' | 'retired';
+      readonly token: string;
+    }
+  >();
+  const subscribers = new Map<number, RenderTraceSubscription>();
+  const pendingOrder: number[] = [];
+  const pendingBySequence = new Map<number, PendingRenderTraceNotification>();
+  let sequence = 0;
+  let subscriberSequence = 0;
+  let droppedNotifications = 0;
+  let reportedDroppedNotifications = 0;
+  let cancelScheduled: (() => void) | undefined;
+  let presentationSubscriber: Readonly<{ generation: number; listener: () => void }> | undefined;
+  let presentationGeneration = 0;
+  let presentationPending:
+    | Readonly<{
+        subscriber: Readonly<{ generation: number; listener: () => void }>;
+      }>
+    | undefined;
+  let cancelPresentationScheduled: (() => void) | undefined;
+  let presentationControls: RenderTracePresentationControls | undefined;
+  let invalidatePresentationSource: (() => void) | undefined;
+  let presentationAttaching = false;
+  let disposed = false;
+
+  const adoptFirstDisplay = (candidate: FirstDisplayTraceAdoptionV1): boolean => {
+    try {
+      if (
+        disposed ||
+        sequence !== 0 ||
+        current.size !== 0 ||
+        history.length !== 0 ||
+        recordsBySequence.size !== 0 ||
+        counts.size !== 0 ||
+        gptImpressions.size !== 0 ||
+        typeof candidate !== 'object' ||
+        candidate === null ||
+        typeof candidate.navigationGeneration !== 'object' ||
+        candidate.navigationGeneration === null ||
+        !Number.isInteger(candidate.nextSequence) ||
+        candidate.nextSequence < 1 ||
+        candidate.nextSequence > 4_294_967_295 ||
+        !Array.isArray(candidate.slots) ||
+        candidate.slots.length > MAX_RENDER_TRACE_SLOTS
+      ) {
+        return false;
+      }
+      const adopted = new Map<
+        string,
+        Readonly<{
+          bindings: readonly Readonly<{
+            cycleOrdinal: number;
+            historySequence: number;
+            state: 'completed' | 'retired';
+            token: string;
+          }>[];
+          impressions: number;
+          records: readonly Readonly<RenderTraceRecord>[];
+        }>
+      >();
+      const recordSequences = new Set<number>();
+      const bindingKeys = new Set<string>();
+      let bindingCount = 0;
+      for (const slot of candidate.slots) {
+        if (
+          typeof slot !== 'object' ||
+          slot === null ||
+          typeof slot.slotId !== 'string' ||
+          slot.slotId.length === 0 ||
+          adopted.has(slot.slotId) ||
+          !Number.isInteger(slot.impressions) ||
+          slot.impressions < 0 ||
+          slot.impressions > 4_294_967_295 ||
+          !Array.isArray(slot.bindings) ||
+          slot.bindings.length > 10 ||
+          !Array.isArray(slot.records) ||
+          slot.records.length > 10
+        ) {
+          return false;
+        }
+        const adoptedRecords: Readonly<RenderTraceRecord>[] = [];
+        for (const record of slot.records) {
+          if (
+            typeof record !== 'object' ||
+            record === null ||
+            record.slotId !== slot.slotId ||
+            !['auction', 'ssat', 'gam-refresh'].includes(record.path) ||
+            typeof record.rendered !== 'boolean' ||
+            !Number.isInteger(record.count) ||
+            record.count < 1 ||
+            record.count > slot.impressions ||
+            !Number.isInteger(record.seq) ||
+            record.seq < 1 ||
+            record.seq >= candidate.nextSequence ||
+            recordSequences.has(record.seq) ||
+            typeof record.at !== 'number' ||
+            !Number.isFinite(record.at) ||
+            record.at < 0
+          ) {
+            return false;
+          }
+          recordSequences.add(record.seq);
+          adoptedRecords.push(copyRenderTraceRecord(record));
+        }
+        const adoptedBindings: Array<
+          Readonly<{
+            cycleOrdinal: number;
+            historySequence: number;
+            state: 'completed' | 'retired';
+            token: string;
+          }>
+        > = [];
+        for (const binding of slot.bindings) {
+          if (
+            typeof binding !== 'object' ||
+            binding === null ||
+            typeof binding.token !== 'string' ||
+            !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(binding.token) ||
+            !Number.isInteger(binding.cycleOrdinal) ||
+            binding.cycleOrdinal < 1 ||
+            binding.cycleOrdinal > 4_294_967_295 ||
+            !Number.isInteger(binding.historySequence) ||
+            !recordSequences.has(binding.historySequence) ||
+            (binding.state !== 'completed' && binding.state !== 'retired')
+          ) {
+            return false;
+          }
+          const key = `${binding.token}:${binding.cycleOrdinal}`;
+          if (bindingKeys.has(key)) return false;
+          bindingKeys.add(key);
+          bindingCount += 1;
+          if (bindingCount > MAX_RENDER_TRACE_SLOTS) return false;
+          adoptedBindings.push(
+            Object.freeze({
+              cycleOrdinal: binding.cycleOrdinal,
+              historySequence: binding.historySequence,
+              state: binding.state,
+              token: binding.token,
+            })
+          );
+        }
+        if (
+          adoptedRecords.length > 0 &&
+          !adoptedRecords.some((record) => record.count === slot.impressions)
+        ) {
+          return false;
+        }
+        adopted.set(
+          slot.slotId,
+          Object.freeze({
+            bindings: Object.freeze(adoptedBindings),
+            impressions: slot.impressions,
+            records: Object.freeze(adoptedRecords),
+          })
+        );
+      }
+      const adoptedHistory = [...adopted.entries()]
+        .flatMap(([, value]) => value.records)
+        .sort((left, right) => left.seq - right.seq);
+      const adoptedCurrent = new Map<string, Readonly<RenderTraceRecord>>();
+      for (const [slotId, value] of adopted) {
+        const latest = value.records.reduce<Readonly<RenderTraceRecord> | undefined>(
+          (candidateRecord, record) =>
+            !candidateRecord || record.seq > candidateRecord.seq ? record : candidateRecord,
+          undefined
+        );
+        if (latest) adoptedCurrent.set(slotId, latest);
+      }
+      const retainedSequences = new Set(
+        [...adoptedHistory.slice(-MAX_RENDER_LOG_ENTRIES), ...adoptedCurrent.values()].map(
+          (record) => record.seq
+        )
+      );
+      if (
+        [...adopted.values()].some((value) =>
+          value.bindings.some((binding) => !retainedSequences.has(binding.historySequence))
+        )
+      ) {
+        return false;
+      }
+
+      sequence = candidate.nextSequence - 1;
+      for (const [slotId, value] of adopted) {
+        if (value.impressions > 0) counts.set(slotId, value.impressions);
+        const latest = adoptedCurrent.get(slotId);
+        if (latest) current.set(slotId, latest);
+        for (const binding of value.bindings) {
+          gptImpressions.set(`${binding.token}:${binding.cycleOrdinal}`, {
+            baselineSequence: undefined,
+            historySequence: binding.historySequence,
+            navigationGeneration: candidate.navigationGeneration,
+            slotId,
+            state: binding.state,
+            token: binding.token,
+          });
+        }
+      }
+      for (const record of adoptedHistory.slice(-MAX_RENDER_LOG_ENTRIES)) {
+        history.push(record);
+      }
+      for (const record of current.values()) recordsBySequence.set(record.seq, record);
+      for (const record of history) recordsBySequence.set(record.seq, record);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const schedule = (callback: () => void): (() => void) => {
+    if (options.schedule) return options.schedule(callback);
+    if (options.scheduler) {
+      const handle = options.scheduler.set(callback, 0);
+      return (): void => options.scheduler?.clear(handle);
+    }
+    return scheduleRenderTraceTask(callback);
+  };
+
+  const reportSubscriberError = (error: unknown): void => {
+    try {
+      options.onSubscriberError?.(error);
+    } catch {
+      // Diagnostics error reporting cannot affect correctness work.
+    }
+  };
+
+  const reportPresentationError = (error: unknown): void => {
+    try {
+      options.onPresentationError?.(error);
+    } catch {
+      // Deferred presentation reporting cannot affect trace data ownership.
+    }
+  };
+
+  const cancelPresentationTask = (): void => {
+    const cancel = cancelPresentationScheduled;
+    cancelPresentationScheduled = undefined;
+    presentationPending = undefined;
+    if (!cancel) return;
+    try {
+      cancel();
+    } catch (error) {
+      reportPresentationError(error);
+    }
+  };
+
+  const notifyPresentation = (): void => {
+    const subscriber = presentationSubscriber;
+    if (disposed || !subscriber || presentationPending) return;
+    const pending = Object.freeze({ subscriber });
+    presentationPending = pending;
+    try {
+      const cancel = schedule(() => {
+        if (presentationPending !== pending) return;
+        cancelPresentationScheduled = undefined;
+        presentationPending = undefined;
+        if (disposed || presentationSubscriber !== subscriber) return;
+        try {
+          subscriber.listener();
+        } catch (error) {
+          reportPresentationError(error);
+        }
+      });
+      if (typeof cancel !== 'function') throw new TypeError('invalid presentation scheduler');
+      if (presentationPending === pending && presentationSubscriber === subscriber) {
+        cancelPresentationScheduled = cancel;
+      }
+    } catch (error) {
+      if (presentationPending === pending) presentationPending = undefined;
+      cancelPresentationScheduled = undefined;
+      reportPresentationError(error);
+    }
+  };
+
+  const drain = (): void => {
+    cancelScheduled = undefined;
+    if (droppedNotifications !== reportedDroppedNotifications) {
+      reportedDroppedNotifications = droppedNotifications;
+      try {
+        options.onOverflow?.(droppedNotifications);
+      } catch {
+        // Diagnostics-only overflow reporting stays inside the diagnostics task.
+      }
+    }
+    while (!disposed && pendingOrder.length > 0) {
+      const next = pendingOrder.shift();
+      if (next === undefined) continue;
+      const pending = pendingBySequence.get(next);
+      pendingBySequence.delete(next);
+      if (!pending) continue;
+      for (const id of pending.subscriberIds) {
+        const subscription = subscribers.get(id);
+        if (!subscription) continue;
+        try {
+          subscription.listener(pending.record);
+        } catch (error) {
+          reportSubscriberError(error);
+        }
+      }
+    }
+  };
+
+  const ensureDrain = (): boolean => {
+    if (cancelScheduled) return true;
+    try {
+      const cancel = schedule(drain);
+      if (typeof cancel !== 'function') throw new TypeError('invalid diagnostics scheduler');
+      if (!disposed && pendingOrder.length > 0) cancelScheduled = cancel;
+      return true;
+    } catch {
+      pendingOrder.length = 0;
+      pendingBySequence.clear();
+      cancelScheduled = undefined;
+      return false;
+    }
+  };
+
+  const enqueue = (record: Readonly<RenderTraceRecord>): void => {
+    if (disposed || subscribers.size === 0) return;
+    const pending = Object.freeze({
+      record: copyRenderTraceRecord(record),
+      subscriberIds: Object.freeze([...subscribers.keys()]),
+    });
+    if (pendingBySequence.has(record.seq)) {
+      pendingBySequence.set(record.seq, pending);
+      return;
+    }
+    if (pendingOrder.length >= MAX_RENDER_TRACE_NOTIFICATIONS) {
+      const dropped = pendingOrder.shift();
+      if (dropped !== undefined) pendingBySequence.delete(dropped);
+      droppedNotifications += 1;
+    }
+    pendingOrder.push(record.seq);
+    pendingBySequence.set(record.seq, pending);
+    ensureDrain();
+  };
+
+  const retained = (record: Readonly<RenderTraceRecord>): boolean =>
+    current.get(record.slotId)?.seq === record.seq ||
+    history.some((candidate) => candidate.seq === record.seq);
+
+  const trimCounters = (): void => {
+    if (counts.size <= MAX_RENDER_TRACE_COUNTERS) return;
+    const protectedSlotIds = new Set<string>();
+    for (const slotId of current.keys()) protectedSlotIds.add(slotId);
+    for (const traceRecord of history) protectedSlotIds.add(traceRecord.slotId);
+    for (const impression of gptImpressions.values()) protectedSlotIds.add(impression.slotId);
+    while (counts.size > MAX_RENDER_TRACE_COUNTERS) {
+      let evicted = false;
+      for (const slotId of counts.keys()) {
+        if (protectedSlotIds.has(slotId)) continue;
+        counts.delete(slotId);
+        evicted = true;
+        break;
+      }
+      if (!evicted) break;
+    }
+  };
+
+  const record = (input: RenderTraceInputV1): Readonly<RenderTraceRecord> | undefined => {
+    if (disposed) return undefined;
+    if (input.path !== 'gam-refresh') {
+      for (const impression of gptImpressions.values()) {
+        if (
+          impression.slotId !== input.slotId ||
+          impression.state !== 'completed' ||
+          impression.reconciled === true ||
+          impression.historySequence === undefined ||
+          current.get(input.slotId)?.seq !== impression.historySequence
+        ) {
+          continue;
+        }
+        const reconciled = enrich(impression.historySequence, input);
+        if (reconciled) {
+          impression.reconciled = true;
+          return reconciled;
+        }
+      }
+    }
+    const previous = current.get(input.slotId);
+    const evictedCurrentSlot =
+      !previous && current.size >= MAX_RENDER_TRACE_SLOTS
+        ? (current.keys().next().value as string | undefined)
+        : undefined;
+    let at: number;
+    try {
+      at = (options.now ?? Date.now)();
+    } catch {
+      at = Date.now();
+    }
+    const previousCount = counts.get(input.slotId) ?? 0;
+    if (previousCount > 0) counts.delete(input.slotId);
+    counts.set(input.slotId, previousCount + 1);
+    const committed = copyRenderTraceRecord({
+      ...input,
+      count: previousCount + 1,
+      seq: (sequence += 1),
+      at,
+    });
+    if (evictedCurrentSlot !== undefined) {
+      current.delete(evictedCurrentSlot);
+    }
+    current.set(committed.slotId, committed);
+    recordsBySequence.set(committed.seq, committed);
+    history.push(committed);
+    if (history.length > MAX_RENDER_LOG_ENTRIES) {
+      const evicted = history.shift();
+      if (evicted && !retained(evicted)) recordsBySequence.delete(evicted.seq);
+    }
+    if (previous && !retained(previous)) recordsBySequence.delete(previous.seq);
+    trimCounters();
+    enqueue(committed);
+    notifyPresentation();
+    return committed;
+  };
+
+  const enrich = (
+    recordOrSequence: Readonly<RenderTraceRecord> | number,
+    patch: RenderTraceUpdateV1
+  ): Readonly<RenderTraceRecord> | undefined => {
+    if (disposed) return undefined;
+    const targetSequence =
+      typeof recordOrSequence === 'number' ? recordOrSequence : recordOrSequence?.seq;
+    if (!Number.isSafeInteger(targetSequence) || targetSequence <= 0) return undefined;
+    const existing = recordsBySequence.get(targetSequence);
+    if (!existing) return undefined;
+    const injected =
+      existing.injected === true || patch.injected === true
+        ? { injected: true as const }
+        : existing.injected === false || patch.injected === false
+          ? { injected: false as const }
+          : {};
+    const merged = {
+      ...existing,
+      ...patch,
+      rendered:
+        existing.rendered === true && patch.rendered === false
+          ? true
+          : (patch.rendered ?? existing.rendered),
+      ...injected,
+      slotId: existing.slotId,
+      count: existing.count,
+      seq: existing.seq,
+      at: existing.at,
+    } as RenderTraceRecord;
+    const committed = copyRenderTraceRecord(merged);
+    recordsBySequence.set(targetSequence, committed);
+    if (current.get(existing.slotId)?.seq === targetSequence) {
+      current.set(existing.slotId, committed);
+    }
+    const historyIndex = history.findIndex(({ seq }) => seq === targetSequence);
+    if (historyIndex >= 0) history[historyIndex] = committed;
+    enqueue(committed);
+    notifyPresentation();
+    return committed;
+  };
+
+  const prune = (slotId: string, expectedSequence?: number): boolean => {
+    if (disposed || typeof slotId !== 'string') return false;
+    let retired = false;
+    for (const impression of gptImpressions.values()) {
+      if (
+        impression.slotId === slotId &&
+        (expectedSequence === undefined ||
+          impression.historySequence === expectedSequence ||
+          impression.baselineSequence === expectedSequence)
+      ) {
+        impression.state = 'retired';
+        retired = true;
+      }
+    }
+    const existing = current.get(slotId);
+    if (!existing || (expectedSequence !== undefined && existing.seq !== expectedSequence)) {
+      return retired;
+    }
+    current.delete(slotId);
+    if (!retained(existing)) recordsBySequence.delete(existing.seq);
+    notifyPresentation();
+    return true;
+  };
+
+  const pruneNavigation = (navigationGeneration: object): number => {
+    if (disposed || typeof navigationGeneration !== 'object' || navigationGeneration === null) {
+      return 0;
+    }
+    let retired = 0;
+    let currentChanged = false;
+    for (const impression of gptImpressions.values()) {
+      if (
+        impression.navigationGeneration !== navigationGeneration ||
+        impression.state === 'retired'
+      ) {
+        continue;
+      }
+      impression.state = 'retired';
+      retired += 1;
+      const sequence = impression.historySequence ?? impression.baselineSequence;
+      const existing = current.get(impression.slotId);
+      if (sequence === undefined || existing?.seq !== sequence) continue;
+      current.delete(impression.slotId);
+      if (!retained(existing)) recordsBySequence.delete(existing.seq);
+      currentChanged = true;
+    }
+    if (currentChanged) notifyPresentation();
+    return retired;
+  };
+
+  const observeGptFact = (
+    fact: Readonly<RenderTraceGptFactV1>,
+    resolve: (elementId: string | undefined) => RenderTraceGptResolutionV1 | undefined
+  ): void => {
+    if (disposed || typeof resolve !== 'function') return;
+    try {
+      const token = fact.slot.token;
+      const cycleOrdinal = fact.slot.cycleOrdinal;
+      if (
+        typeof token !== 'string' ||
+        !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(token) ||
+        token.length > 11 ||
+        Number.parseInt(token.slice(4), 36) > 4_294_967_295 ||
+        !Number.isInteger(cycleOrdinal) ||
+        cycleOrdinal < 1 ||
+        cycleOrdinal > 4_294_967_295
+      ) {
+        return;
+      }
+      const key = `${token}:${cycleOrdinal}`;
+
+      if (fact.kind === 'slotRequested') {
+        if (gptImpressions.has(key)) return;
+        const resolution = resolve(fact.slot.elementId);
+        if (
+          !resolution ||
+          typeof resolution.slotId !== 'string' ||
+          resolution.slotId === '' ||
+          typeof resolution.navigationGeneration !== 'object' ||
+          resolution.navigationGeneration === null ||
+          resolution.traceToken !== token
+        ) {
+          return;
+        }
+        for (const impression of gptImpressions.values()) {
+          if (impression.token === token && impression.state === 'open') return;
+        }
+        if (gptImpressions.size >= MAX_RENDER_TRACE_SLOTS) {
+          let prunable: string | undefined;
+          for (const [candidateKey, impression] of gptImpressions) {
+            if (impression.state !== 'open') {
+              prunable = candidateKey;
+              break;
+            }
+          }
+          if (prunable === undefined) return;
+          gptImpressions.delete(prunable);
+        }
+        for (const impression of gptImpressions.values()) {
+          if (
+            impression.slotId === resolution.slotId &&
+            (impression.state === 'completed' ||
+              impression.navigationGeneration !== resolution.navigationGeneration ||
+              impression.token !== token)
+          ) {
+            impression.state = 'retired';
+          }
+        }
+        gptImpressions.set(key, {
+          baselineSequence: current.get(resolution.slotId)?.seq,
+          navigationGeneration: resolution.navigationGeneration,
+          slotId: resolution.slotId,
+          state: 'open',
+          token,
+        });
+        return;
+      }
+
+      const impression = gptImpressions.get(key);
+      if (!impression) return;
+      if (fact.kind === 'slotResponseReceived') return;
+      if (fact.kind === 'slotRenderEnded') {
+        if (typeof fact.isEmpty !== 'boolean' || impression.state !== 'open') return;
+        const resolution = resolve(fact.slot.elementId);
+        if (
+          !resolution ||
+          resolution.slotId !== impression.slotId ||
+          resolution.navigationGeneration !== impression.navigationGeneration ||
+          resolution.traceToken !== token
+        ) {
+          impression.state = 'retired';
+          return;
+        }
+        const latest = current.get(impression.slotId);
+        const target =
+          latest && latest.seq !== impression.baselineSequence
+            ? latest
+            : record({
+                slotId: impression.slotId,
+                path: 'gam-refresh',
+                rendered: !fact.isEmpty,
+                gamEmpty: fact.isEmpty,
+                injected: false,
+                ...(resolution?.elementId === undefined ? {} : { elementId: resolution.elementId }),
+                ...(resolution?.visible === undefined
+                  ? {}
+                  : { visible: !fact.isEmpty && resolution.visible }),
+                servedFrom: 'gam',
+              });
+        if (!target) return;
+        const enriched = enrich(target, {
+          rendered: !fact.isEmpty,
+          gamEmpty: fact.isEmpty,
+          injected: false,
+          ...(target.servedFrom === undefined ? { servedFrom: 'gam' as const } : {}),
+          ...(resolution?.elementId === undefined ? {} : { elementId: resolution.elementId }),
+          ...(resolution?.visible === undefined
+            ? {}
+            : { visible: !fact.isEmpty && resolution.visible }),
+        });
+        impression.historySequence = enriched?.seq ?? target.seq;
+        impression.state = 'completed';
+        return;
+      }
+
+      const targetSequence = impression.historySequence;
+      if (targetSequence === undefined) return;
+      const update = (patch: RenderTraceUpdateV1): void => {
+        if (impression.state !== 'retired') {
+          enrich(targetSequence, patch);
+          return;
+        }
+        const active = current.get(impression.slotId);
+        const enriched = enrich(targetSequence, patch);
+        if (active?.seq === targetSequence && enriched) current.set(impression.slotId, active);
+      };
+      if (fact.kind === 'impressionViewable') {
+        update({ visible: true });
+      } else if (
+        fact.kind === 'slotVisibilityChanged' &&
+        typeof fact.inViewPercentage === 'number' &&
+        Number.isFinite(fact.inViewPercentage)
+      ) {
+        update({ visible: fact.inViewPercentage > 0 });
+      } else if (fact.kind === 'slotOnload') {
+        const resolution = resolve(fact.slot.elementId);
+        if (
+          resolution &&
+          resolution.slotId === impression.slotId &&
+          resolution.navigationGeneration === impression.navigationGeneration &&
+          resolution.traceToken === impression.token &&
+          resolution.visible !== undefined
+        ) {
+          update({ visible: resolution.visible });
+        }
+      }
+    } catch {
+      // GPT diagnostics cannot affect the committed render or adapter callback.
+    }
+  };
+
+  const api: RenderTraceDiagnostics = Object.freeze({
+    current: (): Readonly<Record<string, Readonly<RenderTraceRecord>>> => {
+      const snapshot = Object.create(null) as Record<string, Readonly<RenderTraceRecord>>;
+      for (const [slotId, traceRecord] of current) {
+        Object.defineProperty(snapshot, slotId, {
+          configurable: false,
+          enumerable: true,
+          value: copyRenderTraceRecord(traceRecord),
+          writable: false,
+        });
+      }
+      return Object.freeze(snapshot);
+    },
+    history: (): readonly Readonly<RenderTraceRecord>[] =>
+      Object.freeze(history.map((traceRecord) => copyRenderTraceRecord(traceRecord))),
+    subscribe: (listener: (record: Readonly<RenderTraceRecord>) => void): (() => void) => {
+      if (typeof listener !== 'function')
+        throw new TypeError('diagnostics listener must be callable');
+      if (disposed) return () => undefined;
+      if (subscribers.size >= MAX_RENDER_TRACE_SUBSCRIBERS) {
+        throw new DiagnosticsSubscriberLimitError('renderTrace');
+      }
+      const id = (subscriberSequence += 1);
+      const subscription = Object.freeze({ id, listener });
+      subscribers.set(id, subscription);
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        if (subscribers.get(id) === subscription) subscribers.delete(id);
+      };
+    },
+  });
+
+  const clearPresentationSubscriber = (): void => {
+    presentationSubscriber = undefined;
+    cancelPresentationTask();
+  };
+
+  const disposePresentationCandidate = (candidate: unknown): void => {
+    try {
+      if (typeof candidate !== 'object' || candidate === null) return;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, 'dispose');
+      if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
+        Reflect.apply(descriptor.value, candidate, []);
+      }
+    } catch (error) {
+      reportPresentationError(error);
+    }
+  };
+
+  const validPresentationControls = (
+    candidate: unknown
+  ): candidate is RenderTracePresentationControls => {
+    try {
+      if (typeof candidate !== 'object' || candidate === null || !Object.isFrozen(candidate)) {
+        return false;
+      }
+      const keys = Reflect.ownKeys(candidate);
+      if (keys.length !== 1 || keys[0] !== 'dispose') return false;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, 'dispose');
+      return Boolean(
+        descriptor?.enumerable && 'value' in descriptor && typeof descriptor.value === 'function'
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const attachPresentation = (factory: RenderTracePresentationFactory): (() => void) => {
+    if (typeof factory !== 'function') {
+      throw new TypeError('render trace presentation factory must be callable');
+    }
+    if (disposed || presentationControls || presentationAttaching) {
+      throw new TypeError('render trace presentation is unavailable');
+    }
+    presentationAttaching = true;
+    let sourceLive = true;
+    const invalidateSource = (): void => {
+      sourceLive = false;
+    };
+    invalidatePresentationSource = invalidateSource;
+    const source = Object.freeze({
+      current: (): Readonly<Record<string, Readonly<RenderTraceRecord>>> =>
+        sourceLive && !disposed ? api.current() : EMPTY_RENDER_TRACE_CURRENT,
+      history: (): readonly Readonly<RenderTraceRecord>[] =>
+        sourceLive && !disposed ? api.history() : EMPTY_RENDER_TRACE_HISTORY,
+      subscribe: (listener: () => void): (() => void) => {
+        if (typeof listener !== 'function') {
+          throw new TypeError('render trace presentation listener must be callable');
+        }
+        if (
+          disposed ||
+          !sourceLive ||
+          presentationSubscriber ||
+          (!presentationAttaching && !presentationControls)
+        ) {
+          throw new TypeError('render trace presentation subscription is unavailable');
+        }
+        const subscription = Object.freeze({
+          generation: (presentationGeneration += 1),
+          listener,
+        });
+        presentationSubscriber = subscription;
+        let active = true;
+        return (): void => {
+          if (!active) return;
+          active = false;
+          if (presentationSubscriber === subscription) clearPresentationSubscriber();
+        };
+      },
+    }) satisfies RenderTracePresentationSource;
+    let candidate: unknown;
+    try {
+      candidate = factory(source);
+      if (!validPresentationControls(candidate)) {
+        throw new TypeError('render trace presentation controls are malformed');
+      }
+      if (!presentationSubscriber) {
+        throw new TypeError('render trace presentation subscription is unavailable');
+      }
+      const controls = candidate;
+      presentationControls = controls;
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        if (presentationControls !== controls) return;
+        presentationControls = undefined;
+        if (invalidatePresentationSource === invalidateSource) {
+          invalidatePresentationSource = undefined;
+        }
+        invalidateSource();
+        clearPresentationSubscriber();
+        disposePresentationCandidate(controls);
+      };
+    } catch (error) {
+      if (invalidatePresentationSource === invalidateSource) {
+        invalidatePresentationSource = undefined;
+      }
+      invalidateSource();
+      clearPresentationSubscriber();
+      disposePresentationCandidate(candidate);
+      throw error;
+    } finally {
+      presentationAttaching = false;
+    }
+  };
+
+  const dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    const controls = presentationControls;
+    presentationControls = undefined;
+    invalidatePresentationSource?.();
+    invalidatePresentationSource = undefined;
+    clearPresentationSubscriber();
+    if (controls) disposePresentationCandidate(controls);
+    try {
+      cancelScheduled?.();
+    } catch {
+      // The disposed latch suppresses a hostile late callback.
+    }
+    cancelScheduled = undefined;
+    subscribers.clear();
+    pendingOrder.length = 0;
+    pendingBySequence.clear();
+    current.clear();
+    history.length = 0;
+    recordsBySequence.clear();
+    counts.clear();
+    gptImpressions.clear();
+  };
+
+  return Object.freeze({
+    api,
+    diagnostics: api,
+    record,
+    enrich,
+    prune,
+    pruneNavigation,
+    observeGptFact,
+    attachPresentation,
+    adoptFirstDisplay,
+    dispose,
+  });
+}
+
+/** Data-only takeover trace owner; contains no DOM presentation behavior. */
+export function createRenderTraceStore(
+  options: RenderTraceRuntimeOptions = {}
+): RenderTraceRuntimeOwner {
+  return createRenderTraceOwner(options);
+}
diff --git a/crates/trusted-server-js/lib/src/core/types.ts b/crates/trusted-server-js/lib/src/core/types.ts
index e49b66146..f88010c51 100644
--- a/crates/trusted-server-js/lib/src/core/types.ts
+++ b/crates/trusted-server-js/lib/src/core/types.ts
@@ -1,55 +1,6 @@
 // Shared TypeScript types for the tsjs core API and extensions.
 export type Size = readonly [number, number];
 
-export interface Banner {
-  sizes: ReadonlyArray<Size>;
-}
-
-export interface MediaTypes {
-  banner?: Banner;
-}
-
-export interface Bid {
-  bidder: string;
-  params?: Record<string, unknown>;
-}
-
-export interface AdUnit {
-  code: string;
-  mediaTypes?: MediaTypes;
-  bids?: Bid[];
-}
-
-/** Minimal shape of a server-side auction slot injected into `window.tsjs.adSlots`. */
-export interface AuctionSlot {
-  id: string;
-  gam_unit_path: string;
-  div_id: string;
-  formats: Array<[number, number]>;
-  targeting?: Record<string, string>;
-}
-
-/** Debug-only copy of server-side bid fields exposed for pipeline inspection. */
-export interface AuctionDebugBidData {
-  slot_id?: string;
-  price?: number | null;
-  currency?: string;
-  creative?: string | null;
-  adomain?: string[] | null;
-  bidder?: string;
-  width?: number;
-  height?: number;
-  nurl?: string | null;
-  burl?: string | null;
-  bid_id?: string | null;
-  ad_id?: string | null;
-  creative_id?: string | null;
-  cache_id?: string | null;
-  cache_host?: string | null;
-  cache_path?: string | null;
-  metadata?: Record<string, unknown>;
-}
-
 export type ApsTagType = 'iframe' | 'script';
 
 /** Version 1 Trusted Server APS renderer descriptor. */
@@ -58,7 +9,7 @@ export interface ApsRendererV1 {
   version: 1;
   accountId: string;
   bidId: string;
-  creativeId?: string;
+  creativeId?: string | undefined;
   tagType: ApsTagType;
   creativeUrl: string;
   aaxResponse: string;
@@ -66,46 +17,82 @@ export interface ApsRendererV1 {
   height: number;
 }
 
-export type AuctionBidRenderer = ApsRendererV1;
-
-/** A client-side Prebid bid's generated ad ID bound to its APS render capability. */
-export interface ApsPrebidRendererEntry {
-  adUnitCode: string;
-  renderer: ApsRendererV1;
-  registeredAt: number;
-  expiresAt: number;
-  /** Mark the bid as won and rendered after replying to Universal Creative. */
-  markUsed(): void;
-}
-
-/** Bid targeting data from the server-side auction, injected into `window.tsjs.bids`. */
-export interface AuctionBidData {
-  hb_pb?: string;
-  hb_bidder?: string;
-  hb_adid?: string;
-  hb_cache_host?: string;
-  hb_cache_path?: string;
-  /** Opaque server-auction correlation ID used only by GPT diagnostics. */
-  hb_auction_id?: string;
-  /** Winning creative width; the bridge sizes the inline render from this. */
-  w?: number;
-  /** Winning creative height; the bridge sizes the inline render from this. */
-  h?: number;
-  nurl?: string;
-  burl?: string;
-  /** Typed winning-bid renderer capability. */
-  renderer?: AuctionBidRenderer;
-  /** Winning creative width used by the inline render bridge. */
-  w?: number;
-  /** Winning creative height used by the inline render bridge. */
-  h?: number;
-  /**
-   * Sanitized winning creative markup for the inline render bridge. Present
-   * when the server retained a non-empty creative; not gated by debug mode.
-   */
-  adm?: string;
-  /** Debug-only bid field mirror. Only present when `[debug] inject_adm_for_testing = true`. */
-  debug_bid?: AuctionDebugBidData;
+export interface AdmRenderSourceV1 {
+  type: 'adm';
+  version: 1;
+  adm: string;
+  width: number;
+  height: number;
+}
+
+export interface BaselinePbsCacheSourceV1 {
+  type: 'pbs_cache';
+  version: 1;
+  cacheId: string;
+  cacheHost: string;
+  cachePath: string;
+  width: number;
+  height: number;
+}
+
+export type BidRenderSourceV1 = ApsRendererV1 | AdmRenderSourceV1 | BaselinePbsCacheSourceV1;
+
+export type AuctionSlotFailureReason =
+  | 'auction_disabled'
+  | 'consent_denied'
+  | 'slot_not_eligible'
+  | 'provider_timeout'
+  | 'provider_error'
+  | 'invalid_provider_response'
+  | 'mediation_failed'
+  | 'winner_not_renderable'
+  | 'identity_generation_failed'
+  | 'internal_error';
+
+export type SlotAuctionDecisionV1 =
+  | { slot: string; outcome: 'winner'; candidateId: string }
+  | { slot: string; outcome: 'no_bid' }
+  | { slot: string; outcome: 'failed'; reason: AuctionSlotFailureReason };
+
+export interface AuctionDecisionSetV1 {
+  version: 1;
+  auctionId: string;
+  results: SlotAuctionDecisionV1[];
+}
+
+interface BrowserAuctionBidBaseV1 {
+  candidateId: string;
+  slot: string;
+  provider: string;
+  upstreamBidId: string;
+  cpm: number;
+  currency: 'USD';
+  targeting: Record<string, string>;
+}
+
+export type BrowserAuctionBidV1 =
+  | (BrowserAuctionBidBaseV1 & {
+      rendererReservationId: string;
+      renderSource: ApsRendererV1 | AdmRenderSourceV1;
+    })
+  | (BrowserAuctionBidBaseV1 & {
+      renderSource: BaselinePbsCacheSourceV1;
+    });
+
+/** Exact GAM placement metadata required to publish one server-projected slot. */
+export interface BrowserAuctionSlotV1 {
+  slot: string;
+  gamUnitPath: string;
+  divId: string;
+  formats: ReadonlyArray<Size>;
+  targeting: Record<string, string>;
+}
+
+export interface BrowserAuctionProjectionV1 {
+  version: 1;
+  auction: AuctionDecisionSetV1;
+  slots: BrowserAuctionSlotV1[];
+  bids: BrowserAuctionBidV1[];
 }
 
 export type GptDiagnosticsCallbackKind =
@@ -127,15 +114,15 @@ export type GptDiagnosticsBindingReason =
 
 export interface GptDiagnosticsBinding {
   status: 'bound' | 'unbound' | 'ambiguous';
-  reason?: GptDiagnosticsBindingReason;
+  reason?: GptDiagnosticsBindingReason | undefined;
 }
 
 export interface GptDiagnosticsDurations {
-  requestToResponseMs?: number;
-  responseToRenderMs?: number;
-  requestToRenderMs?: number;
-  renderToLoadMs?: number;
-  renderToViewableMs?: number;
+  requestToResponseMs?: number | undefined;
+  responseToRenderMs?: number | undefined;
+  requestToRenderMs?: number | undefined;
+  renderToLoadMs?: number | undefined;
+  renderToViewableMs?: number | undefined;
 }
 
 /**
@@ -147,14 +134,14 @@ export interface GptDiagnosticsDurations {
  * Manager delivered; they claim nothing about which demand source supplied it.
  */
 export interface GptDiagnosticsAdManagerIdentity {
-  lineItemId?: number;
-  creativeId?: number;
-  campaignId?: number;
-  advertiserId?: number;
-  sourceAgnosticLineItemId?: number;
-  sourceAgnosticCreativeId?: number;
-  yieldGroupIds?: number[];
-  companyIds?: number[];
+  lineItemId?: number | undefined;
+  creativeId?: number | undefined;
+  campaignId?: number | undefined;
+  advertiserId?: number | undefined;
+  sourceAgnosticLineItemId?: number | undefined;
+  sourceAgnosticCreativeId?: number | undefined;
+  yieldGroupIds?: number[] | undefined;
+  companyIds?: number[] | undefined;
 }
 
 /**
@@ -162,31 +149,19 @@ export interface GptDiagnosticsAdManagerIdentity {
  * facts GPT reported.
  */
 export type GptDiagnosticsResponseClass =
-  | 'empty'
-  | 'backfill'
-  | 'reservation'
-  | 'unclassified_non_empty';
+  'empty' | 'backfill' | 'reservation' | 'unclassified_non_empty';
 
 /** The request path observed for a GPT request cycle. */
 export type GptDiagnosticsRequestPath =
-  | 'trusted_server_direct'
-  | 'prebid_refresh'
-  | 'publisher_refresh'
-  | 'competing'
-  | 'unattributed';
+  'trusted_server_direct' | 'prebid_refresh' | 'publisher_refresh' | 'competing' | 'unattributed';
 
 /** The Trusted Server creative opportunity observed for a request. */
 export type GptDiagnosticsTrustedServerOpportunity =
-  | 'renderable_candidate'
-  | 'unrenderable_candidate'
-  | 'no_candidate';
+  'renderable_candidate' | 'unrenderable_candidate' | 'no_candidate';
 
 /** A safe failure category observed while obtaining or posting creative markup. */
 export type GptDiagnosticsCreativeFailure =
-  | 'missing_render_source'
-  | 'cache_fetch_failed'
-  | 'invalid_cache_payload'
-  | 'response_post_failed';
+  'missing_render_source' | 'cache_fetch_failed' | 'invalid_cache_payload' | 'response_post_failed';
 
 /** Delivery evidence derived for a GPT request cycle. */
 export type GptDiagnosticsDelivery =
@@ -200,58 +175,58 @@ export type GptDiagnosticsDelivery =
 
 export interface GptDiagnosticsRequestCycle {
   requestNumber: number;
-  requestedAtMs?: number;
-  responseAtMs?: number;
-  renderAtMs?: number;
-  loadAtMs?: number;
-  viewableAtMs?: number;
+  requestedAtMs?: number | undefined;
+  responseAtMs?: number | undefined;
+  renderAtMs?: number | undefined;
+  loadAtMs?: number | undefined;
+  viewableAtMs?: number | undefined;
   durations: GptDiagnosticsDurations;
-  isEmpty?: boolean;
+  isEmpty?: boolean | undefined;
   /** Configured sizes Trusted Server supplied to GPT for this request. */
-  requestedSlotSizes?: ReadonlyArray<Size>;
-  /** Exact fill size fact GPT reported in its `slotRenderEnded` callback. */
-  size?: Size;
+  requestedSlotSizes?: ReadonlyArray<Size> | undefined;
+  /** Exact fill size fact GPT reported in `slotRenderEnded`. */
+  size?: Size | undefined;
   /**
    * Outer CSS box observed on the uniquely bound, connected slot element after
-   * a filled GPT render. This is not an assertion about internal creative pixels.
+   * a filled GPT render. This does not assert the internal creative pixel size.
    */
-  observedSlotSize?: Size;
-  isBackfill?: boolean;
-  slotContentChanged?: boolean;
+  observedSlotSize?: Size | undefined;
+  isBackfill?: boolean | undefined;
+  slotContentChanged?: boolean | undefined;
   incompleteSequence: boolean;
-  adManager?: GptDiagnosticsAdManagerIdentity;
-  responseClass?: GptDiagnosticsResponseClass;
-  requestPath?: GptDiagnosticsRequestPath;
-  requestIntentId?: number;
-  trustedServerAuctionId?: string;
-  opportunityToRequestMs?: number;
-  replacedRequestNumber?: number;
-  previousRenderToRequestMs?: number;
-  creativeChanged?: boolean;
-  previousCreativeId?: GptDiagnosticsAdManagerIdentity['creativeId'];
-  loadObservedBeforeRender?: boolean;
-  trustedServerOpportunity?: GptDiagnosticsTrustedServerOpportunity;
-  trustedServerCreativeRequestAtMs?: number;
-  trustedServerCreativeResponseAtMs?: number;
-  trustedServerCreativeFailures?: GptDiagnosticsCreativeFailure[];
+  adManager?: GptDiagnosticsAdManagerIdentity | undefined;
+  responseClass?: GptDiagnosticsResponseClass | undefined;
+  requestPath?: GptDiagnosticsRequestPath | undefined;
+  requestIntentId?: number | undefined;
+  trustedServerAuctionId?: string | undefined;
+  opportunityToRequestMs?: number | undefined;
+  replacedRequestNumber?: number | undefined;
+  previousRenderToRequestMs?: number | undefined;
+  creativeChanged?: boolean | undefined;
+  previousCreativeId?: GptDiagnosticsAdManagerIdentity['creativeId'] | undefined;
+  loadObservedBeforeRender?: boolean | undefined;
+  trustedServerOpportunity?: GptDiagnosticsTrustedServerOpportunity | undefined;
+  trustedServerCreativeRequestAtMs?: number | undefined;
+  trustedServerCreativeResponseAtMs?: number | undefined;
+  trustedServerCreativeFailures?: GptDiagnosticsCreativeFailure[] | undefined;
   /** Derived on every snapshot; absent only on a cycle read before derivation. */
-  delivery?: GptDiagnosticsDelivery;
+  delivery?: GptDiagnosticsDelivery | undefined;
 }
 
 export interface GptDiagnosticsSlotExport {
   runtimeSlotNumber: number;
-  slotElementId?: string;
-  adUnitPath?: string;
+  slotElementId?: string | undefined;
+  adUnitPath?: string | undefined;
   binding: GptDiagnosticsBinding;
-  currentVisibilityPercentage?: number;
-  maximumVisibilityPercentage?: number;
-  requests: GptDiagnosticsRequestCycle[];
+  currentVisibilityPercentage?: number | undefined;
+  maximumVisibilityPercentage?: number | undefined;
+  requests: readonly Readonly<GptDiagnosticsRequestCycle>[];
 }
 
 export interface GptDiagnosticsCallbackIssue {
   kind: GptDiagnosticsCallbackKind;
   runtimeSlotNumber: number;
-  slotElementId?: string;
+  slotElementId?: string | undefined;
   timestampMs: number;
   disposition: GptDiagnosticsCallbackDisposition;
   reason: string;
@@ -284,22 +259,24 @@ export interface GptDiagnosticsCoverageCounters {
 }
 
 export interface GptDiagnosticsExportV1 {
-  version: 1;
-  capturedAt: string;
-  page: {
+  readonly version: 1;
+  readonly capturedAt: string;
+  readonly page: Readonly<{
     origin: string;
     pathname: string;
-  };
-  slots: GptDiagnosticsSlotExport[];
-  callbackIssues: GptDiagnosticsCallbackIssue[];
-  attributionIssues?: GptDiagnosticsAttributionIssue[];
-  coverage: Record<GptDiagnosticsCallbackKind, GptDiagnosticsCoverageCounters>;
-  metadata: {
+  }>;
+  readonly slots: readonly Readonly<GptDiagnosticsSlotExport>[];
+  readonly callbackIssues: readonly Readonly<GptDiagnosticsCallbackIssue>[];
+  readonly attributionIssues: readonly Readonly<GptDiagnosticsAttributionIssue>[];
+  readonly coverage: Readonly<
+    Record<GptDiagnosticsCallbackKind, Readonly<GptDiagnosticsCoverageCounters>>
+  >;
+  readonly metadata: Readonly<{
     droppedCallbacks: number;
-    droppedAttributionIssues?: number;
+    droppedAttributionIssues: number;
     evictedSlots: number;
     evictedRequestCycles: number;
-  };
+  }>;
 }
 
 /** GPT slot object identity, the only key diagnostics correlates slots by. */
@@ -310,23 +287,15 @@ export interface GptDiagnosticsSlotHandle {
 
 /** The documented, read-only operator API. It records no evidence. */
 export interface GptDiagnosticsApi {
-  snapshot(): GptDiagnosticsExportV1;
+  snapshot(): Readonly<GptDiagnosticsExportV1>;
   export(): void;
-  subscribe(listener: (snapshot: GptDiagnosticsExportV1) => void): () => void;
+  subscribe(listener: (snapshot: Readonly<GptDiagnosticsExportV1>) => void): () => void;
   show(): void;
   hide(): void;
 }
 
-/**
- * Evidence writers used by Trusted Server's own integration modules.
- *
- * Separate bundles can only reach each other through `window.tsjs`, so this
- * channel is reachable from the page like anything else there. Keeping it off
- * [`GptDiagnosticsApi`] is what makes the documented operator surface read-only
- * and stops the writers from becoming part of the public contract.
- */
+/** Closure-private evidence channel shared only by release-bound TSJS modules. */
 export interface GptDiagnosticsRecorder {
-  /** Record Trusted Server's creative opportunity and configured sizes for an associated GPT slot. */
   recordTrustedServerOpportunity(
     slot: GptDiagnosticsSlotHandle,
     auctionSlotId: string,
@@ -334,191 +303,258 @@ export interface GptDiagnosticsRecorder {
     trustedServerAuctionId?: string,
     requestedSlotSizes?: ReadonlyArray<Size>
   ): void;
-  /** Mark slots whose next observed GPT request follows the Prebid refresh path. */
   recordPrebidRefresh(slots: GptDiagnosticsSlotHandle[]): void;
-  /** Record a creative markup request and return its opaque attempt ID. */
   recordTrustedServerCreativeRequest(auctionSlotId: string): number | undefined;
-  /** Record that a creative attempt successfully posted markup. */
   recordTrustedServerCreativeResponse(attemptId: number): void;
-  /** Record a safe failure category for a creative attempt. */
   recordTrustedServerCreativeFailure(
     attemptId: number,
     reason: GptDiagnosticsCreativeFailure
   ): void;
 }
 
-/**
- * Lifecycle state for a GPT slot TS created before its publisher declares it.
- *
- * Stored on `window.tsjs` so the head bootstrap and the full TSJS bundle share
- * one handoff protocol.
- */
-export interface GptSlotHandoff {
-  gamUnitPath: string;
-  formats: Array<[number, number]>;
-  /** Stable configured prefix used to safely bridge framework-generated IDs. */
-  divIdPrefix: string;
-  /** Element ID GPT received when TS created the fallback slot. */
-  slotElementId: string;
-  publisherClaimed: boolean;
-  suppressPublisherDisplay: boolean;
-  suppressPublisherRefresh: boolean;
-}
-
-export type FirstImpressionOwner = 'publisher' | 'trusted_server';
-export type FirstImpressionPhase = 'auctioning' | 'delivery_pending' | 'requested' | 'rendered';
-
-/** One publisher auction participating in the current navigation's first impression. */
-export interface FirstImpressionPublisherAuction {
-  token: string;
-  adUnitCode: string;
-  phase: 'auctioning' | 'delivery_pending';
-  expiresAt: number;
-  adIds: string[];
-  suppressDelivery: boolean;
-}
-
-/** First-impression ownership for one exact physical slot element. */
-export interface FirstImpressionSlotClaim {
-  generation: number;
-  slotElementId: string;
-  element: HTMLElement;
-  owner: FirstImpressionOwner;
-  phase: FirstImpressionPhase;
-  expiresAt: number;
-  publisherAuctions: Record<string, FirstImpressionPublisherAuction>;
-  /** No later publisher auction may join this TS-owned first impression. */
-  publisherRegistrationClosed?: boolean;
-  targeting?: Record<string, string | string[]>;
-}
-
-/** Bounded first-impression state shared by the GPT bootstrap, GPT, and Prebid bundles. */
-export interface FirstImpressionState {
-  generation: number;
-  nextToken: number;
-  slots: Record<string, FirstImpressionSlotClaim>;
-  fallbackSlots: Record<string, HTMLElement>;
-}
-
-export interface TsjsApi {
-  version: string;
-  que: Array<() => void>;
-  addAdUnits(units: AdUnit | AdUnit[]): void;
-  renderAdUnit(codeOrUnit: string | AdUnit): void;
-  renderAllAdUnits(): void;
-  setConfig?(cfg: Record<string, unknown>): void;
-  getConfig?(): Record<string, unknown>;
-  requestAds?(opts?: { bidsBackHandler?: () => void; timeout?: number }): void;
-  requestAds?(
-    callback: () => void,
-    opts?: { bidsBackHandler?: () => void; timeout?: number }
-  ): void;
-  log?: {
-    setLevel(l: 'silent' | 'error' | 'warn' | 'info' | 'debug'): void;
-    getLevel(): 'silent' | 'error' | 'warn' | 'info' | 'debug';
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-    debug(...args: unknown[]): void;
-  };
-
-  // ── Server-side auction runtime (populated by TS edge injection) ──────────
-  /** Ad slot definitions injected at <head> open. */
-  adSlots?: AuctionSlot[];
-  /** Winning bid targeting data injected before </body>. */
-  bids?: Record<string, AuctionBidData>;
-  /**
-   * Bounded client-side Prebid APS renderer capabilities keyed by Prebid's generated
-   * `hb_adid`. The Universal Creative bridge consumes each entry at most once.
-   */
-  apsPrebidRenderers?: Record<string, ApsPrebidRendererEntry>;
-  /** Initialises GPT slots with server-side bid targeting and calls refresh(). */
-  adInit?: () => void;
-  /** GPT slot objects TS defined — used to destroy stale slots on SPA navigation. */
-  prevGptSlots?: unknown[];
-  /** Guards one-time-per-page enableSingleRequest/enableServices calls. */
-  servicesEnabled?: boolean;
-  /** Maps actualDivId → slotId for slotRenderEnded billing lookup. */
-  divToSlotId?: Record<string, string>;
-  /**
-   * Win/billing beacons already fired, keyed by `slotId|bidIdentity|kind|url`.
-   * Used by the GPT render bridge so a bid's nurl/burl fire at most once even
-   * across repeated Prebid Universal Creative requests for the same adId.
-   */
-  firedBeacons?: Record<string, boolean>;
-  /** Slot-level GPT targeting keys TS applied on the previous route. */
-  prevSlotTargetingKeys?: Record<string, string[]>;
-  /**
-   * One-shot bypass for the slim-Prebid refresh wrapper: true only while
-   * adInit() runs its internal refresh of server-side-targeted slots, so the
-   * wrapper passes that refresh straight to GPT instead of starting a
-   * client-side auction that would clear the just-applied TS targeting.
-   */
-  adInitRefreshInProgress?: boolean;
-  /** Scoped context marking an active Prebid-controlled GPT refresh delegation. */
-  prebidRefreshDispatchInProgress?: boolean;
-  /**
-   * Whether the publisher disabled GPT initial load through
-   * `googletag.setConfig()` or `googletag.pubads().disableInitialLoad()`.
-   * TS synchronizes this from GPT's getter and wraps both configuration APIs as
-   * a fallback when the getter is unavailable.
-   * When set, `display()` only registers a slot and the ad request must come
-   * from a `refresh()`; adInit() uses this to refresh its own freshly defined
-   * slots so they are not left blank.
-   */
-  gptInitialLoadDisabled?: boolean;
-  /** Late publisher claims for TS-created GPT slots, keyed by actual div ID. */
-  gptSlotHandoffs?: Record<string, GptSlotHandoff>;
-  /** True only while TS calls a GPT function that the handoff wrappers observe. */
-  gptSlotHandoffInternal?: boolean;
-  /** Per-navigation first-impression ownership shared by GPT and Prebid. */
-  firstImpression?: FirstImpressionState;
-  /** Guards the shared production GPT lifecycle listener installation. */
-  firstImpressionListenersInstalled?: boolean;
-  /** Guards SPA pushState hook installation. */
-  spaHookInstalled?: boolean;
-  /** Internal one-shot state shared by bootstrap and bundle scheduler installs. */
-  initialAdInitScheduled?: boolean;
-  /**
-   * Monotonic count of committed SPA navigations, incremented synchronously by
-   * the SPA auction hook the moment it accepts a route change. The deferred
-   * initial-adInit bootstrap ([`scheduleInitialAdInit`]) is pinned to
-   * generation 0 (the SSR document) and no-ops when a navigation has
-   * committed — before it was called, or while it was pending. A counter is
-   * used instead of a URL comparison so the guard cannot diverge from the
-   * auction path: a query-only history change (which the hook deliberately
-   * ignores) leaves the counter unchanged, and an `/a → /b → /a` round trip
-   * (where the URL compares equal again) advances it.
-   */
-  navGeneration?: number;
-  /**
-   * Defers the initial `adInit()` until after React hydration: window `load`,
-   * then a double `requestAnimationFrame`. Called by the server-injected
-   * `</body>` bids script with the SSR bids payload. The whole initial pass
-   * is pinned to navigation generation 0 (the SSR document): if an SPA
-   * navigation has already committed — or commits while the deferred callback
-   * is pending — the payload is dropped and `adInit()` is not run, so a stale
-   * SSR bootstrap can neither clobber the live route's bids nor re-run it.
-   * Lives in the bundle so the lifecycle is executable under test and shares
-   * [`navGeneration`] with the SPA auction hook; `gpt_bootstrap.js` installs
-   * a minimal fallback for pages where the bundle fails to load.
-   *
-   * `initialSlots` exists for the shared-template `</body>` seam, which is the
-   * only place slot definitions arrive with the bids rather than from the head
-   * script. Passing them here rather than assigning `tsjs.adSlots` before the
-   * call puts them behind the same generation guard: an assignment made ahead
-   * of the guard would clobber a committed SPA navigation's slots with the SSR
-   * document's, and then be read by that route's `adInit()`.
-   */
-  scheduleInitialAdInit?: (
-    initialBids?: Record<string, AuctionBidData>,
-    initialSlots?: AuctionSlot[]
-  ) => void;
-  /** Read-only GPT lifecycle diagnostics API, present only in an activated tab. */
-  gptDiagnostics?: GptDiagnosticsApi;
-  /**
-   * Internal evidence channel for Trusted Server integration modules. Not part
-   * of the operator API; present only in an activated tab.
-   */
-  gptDiagnosticsRecorder?: GptDiagnosticsRecorder;
+/** Release-internal takeover module emitted inside the persistent artifact. */
+export interface BootManifestTakeoverIntegrationV1 {
+  readonly id: string;
+  readonly phase: 'takeover';
+}
+
+/** Release-internal later module authenticated and loaded by core. */
+export interface BootManifestDeferredIntegrationV1 {
+  readonly id: string;
+  readonly phase: 'deferred';
+  readonly trigger: 'first_display_or_idle';
+  readonly src: string;
+}
+
+export type BootManifestIntegrationV1 =
+  BootManifestTakeoverIntegrationV1 | BootManifestDeferredIntegrationV1;
+
+export interface BootManifestFirstDisplayV1 {
+  readonly src: string;
+  readonly slices: readonly string[];
+}
+
+/** Exact phase-aware bundle set and injection order required by one TSJS release. */
+export interface BootManifestV1 {
+  readonly version: 1;
+  readonly releaseId: string;
+  readonly firstDisplay: Readonly<BootManifestFirstDisplayV1> | null;
+  readonly runtimeSrc: string;
+  readonly integrations: readonly BootManifestIntegrationV1[];
+}
+
+/** One direct-auction ad unit admitted into the current navigation. */
+export interface ProgrammaticAdUnit {
+  readonly code: string;
+  readonly mediaTypes: Readonly<{
+    banner: Readonly<{ sizes: readonly (readonly [number, number])[] }>;
+  }>;
+  readonly bids?: readonly Readonly<{
+    bidder: string;
+    params?: Readonly<Record<string, unknown>>;
+  }>[];
+}
+
+export interface AddAdUnitsResult {
+  readonly registered: readonly string[];
+}
+
+export interface RequestAdsOptions {
+  readonly slots?: readonly string[];
+  readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
+}
+
+export type RenderFailureReason =
+  | 'auction_timeout'
+  | AuctionSlotFailureReason
+  | 'network_error'
+  | 'http_error'
+  | 'invalid_response'
+  | 'slot_unresolved'
+  | 'descriptor_invalid'
+  | 'invalid_dimensions'
+  | 'dimensions_out_of_range'
+  | 'no_render_source'
+  | 'registry_full'
+  | 'capability_registry_full'
+  | 'external_queue_full'
+  | 'external_ready_timeout'
+  | 'external_artifact_incompatible'
+  | 'prebid_admission_failed'
+  | 'prebid_contract_violation'
+  | 'prebid_selection_timeout'
+  | 'reservation_collision'
+  | 'identity_generation_failed'
+  | 'cycle_unattributable'
+  | 'slot_quarantined'
+  | 'gpt_request_failed'
+  | 'gpt_request_timeout'
+  | 'gpt_completion_timeout'
+  | 'reconciliation_capacity'
+  | 'gam_empty'
+  | 'bridge_claim_timeout'
+  | 'bridge_id_mismatch'
+  | 'owner_registration_timeout'
+  | 'owner_insertion_timeout'
+  | 'renderer_document_no_load'
+  | 'runner_no_load'
+  | 'runner_failed'
+  | 'cache_fetch_failed'
+  | 'invalid_cache_payload'
+  | 'response_post_failed'
+  | 'adm_document_no_load'
+  | 'abi_mismatch'
+  | 'bundle_partial';
+
+export type RequestAdsSlotResult =
+  | Readonly<{ slot: string; path: 'primary' | 'fallback'; outcome: 'accepted' }>
+  | Readonly<{ slot: string; path: 'primary' | 'fallback'; outcome: 'no_bid' }>
+  | Readonly<{
+      slot: string;
+      path: 'primary' | 'fallback';
+      outcome: 'failed';
+      reason: RenderFailureReason;
+    }>
+  | Readonly<{
+      slot: string;
+      path: 'primary' | 'fallback';
+      outcome: 'cancelled';
+      reason: 'caller_aborted' | 'superseded' | 'navigation_disposed';
+    }>;
+
+export interface RequestAdsResult {
+  readonly slots: readonly RequestAdsSlotResult[];
+}
+
+export type TsjsLogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+
+export interface TsjsLog {
+  setLevel(level: TsjsLogLevel): void;
+  getLevel(): TsjsLogLevel;
+  error(...values: readonly unknown[]): void;
+  warn(...values: readonly unknown[]): void;
+  info(...values: readonly unknown[]): void;
+  debug(...values: readonly unknown[]): void;
+}
+
+export interface TsjsCommandQueue {
+  readonly length: 0;
+  push(callback: unknown): 0;
+}
+
+export interface CreativeBootV1 {
+  readonly version: 1;
+  readonly enabled: boolean;
+  readonly clickGuard: boolean;
+  readonly renderGuard: boolean;
+}
+
+export interface DiagnosticsBootV1 {
+  readonly version: 1;
+  readonly renderTraceOverlay: boolean;
+  readonly gpt: Readonly<{ readonly active: boolean }>;
+}
+
+export const INTEGRATION_CONFIG_IDS_V1 = Object.freeze([
+  'aps',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'sourcepoint',
+  'testlight',
+] as const);
+
+export type IntegrationConfigIdV1 = (typeof INTEGRATION_CONFIG_IDS_V1)[number];
+export type BootJsonPrimitiveV1 = null | boolean | number | string;
+export type BootJsonValueV1 =
+  | BootJsonPrimitiveV1
+  | readonly BootJsonValueV1[]
+  | Readonly<{ readonly [key: string]: BootJsonValueV1 }>;
+
+export interface IntegrationConfigEntryV1 {
+  readonly id: IntegrationConfigIdV1;
+  readonly config: Readonly<{ readonly [key: string]: BootJsonValueV1 }>;
+}
+
+export interface IntegrationConfigsV1 {
+  readonly version: 1;
+  readonly entries: readonly Readonly<IntegrationConfigEntryV1>[];
+}
+
+export interface TsjsBootV1 {
+  readonly abi: 1;
+  readonly releaseId: string;
+  readonly manifest: Readonly<BootManifestV1>;
+  readonly auctionProjection: Readonly<BrowserAuctionProjectionV1>;
+  readonly integrations: Readonly<IntegrationConfigsV1>;
+  readonly creative: Readonly<CreativeBootV1>;
+  readonly diagnostics: Readonly<DiagnosticsBootV1>;
 }
+
+export type RenderTracePathV1 = 'auction' | 'ssat' | 'gam-refresh';
+export type RenderTraceServedFromV1 = 'inline' | 'gam' | 'debug-adm' | 'pbs-cache' | 'prebid';
+
+export interface RenderTraceRecord {
+  readonly slotId: string;
+  readonly path: RenderTracePathV1;
+  readonly rendered: boolean;
+  readonly elementId?: string;
+  readonly auctionId?: string;
+  readonly bidder?: string;
+  readonly adId?: string;
+  readonly bidId?: string;
+  readonly creativeId?: string;
+  readonly admHash?: string;
+  readonly servedFrom?: RenderTraceServedFromV1;
+  readonly gamEmpty?: boolean;
+  readonly injected?: boolean;
+  readonly visible?: boolean;
+  readonly count: number;
+  readonly seq: number;
+  readonly at: number;
+}
+
+export interface RenderTraceDiagnostics {
+  current(): Readonly<Record<string, Readonly<RenderTraceRecord>>>;
+  history(): readonly Readonly<RenderTraceRecord>[];
+  subscribe(listener: (record: Readonly<RenderTraceRecord>) => void): () => void;
+}
+
+export interface TsjsDiagnostics {
+  readonly renderTrace: RenderTraceDiagnostics;
+  readonly gpt?: GptDiagnosticsApi;
+}
+
+export interface TsjsApiBase {
+  readonly version: '1.0.0';
+  readonly releaseId: string;
+  readonly boot: Readonly<TsjsBootV1>;
+  readonly que: TsjsCommandQueue;
+  readonly log: TsjsLog;
+  readonly _registerIntegration: (registration: unknown) => false;
+  addAdUnits(units: ProgrammaticAdUnit | readonly ProgrammaticAdUnit[]): AddAdUnitsResult;
+  requestAds(options?: RequestAdsOptions): Promise<RequestAdsResult>;
+}
+
+export interface TsjsKernelApi extends TsjsApiBase {
+  readonly diagnostics: Readonly<TsjsDiagnostics>;
+  readonly _internal: Readonly<{ state: 'kernel'; releaseId: string }>;
+}
+
+export interface TsjsFallbackApi extends TsjsApiBase {
+  readonly diagnostics?: never;
+  readonly _internal: Readonly<{
+    state: 'fallback';
+    releaseId: string;
+    reason: 'abi_mismatch' | 'bundle_partial';
+    initialDisplayCommitted: boolean;
+  }>;
+}
+
+export type TsjsApi = TsjsKernelApi | TsjsFallbackApi;
diff --git a/crates/trusted-server-js/lib/src/first_display/adapters/googletag.ts b/crates/trusted-server-js/lib/src/first_display/adapters/googletag.ts
new file mode 100644
index 000000000..d04ff1728
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/adapters/googletag.ts
@@ -0,0 +1,1756 @@
+import type {
+  FirstDisplayProjectionBidV1,
+  FirstDisplayProjectionSlotV1,
+  FirstDisplayProjectionV1,
+} from '../leaf/projection';
+import type { FirstDisplayGptBatchPolicyV1 } from '../leaf/gpt_protocol';
+import type {
+  FirstDisplayGptDiagnosticEventV1,
+  FirstDisplayGptDiagnosticsV1,
+  FirstDisplayGptFactV1,
+} from '../../shared/takeover';
+
+const MAX_DIAGNOSTIC_FACTS = 512;
+const MAX_DIAGNOSTIC_FACT_BYTES = 1_000;
+const MAX_DIAGNOSTIC_SECTION_BYTES = 512 * 1024;
+const MAX_U32 = 4_294_967_295;
+const SLOT_REQUESTED = 'slotRequested';
+const SLOT_RESPONSE_RECEIVED = 'slotResponseReceived';
+const SLOT_RENDER_ENDED = 'slotRenderEnded';
+const SLOT_ONLOAD = 'slotOnload';
+const IMPRESSION_VIEWABLE = 'impressionViewable';
+const SLOT_VISIBILITY_CHANGED = 'slotVisibilityChanged';
+const OVERLAPPING_REQUEST_CYCLES = 'overlapping_request_cycles';
+const INVALID_EVENT_ORDER = 'invalid_event_order';
+const GPT_REQUEST_FAILED = 'gpt_request_failed';
+const SLOT_UNRESOLVED = 'slot_unresolved';
+const DIAGNOSTIC_ONLY_EVENTS = Object.freeze([
+  SLOT_RESPONSE_RECEIVED,
+  SLOT_ONLOAD,
+  IMPRESSION_VIEWABLE,
+  SLOT_VISIBILITY_CHANGED,
+] as const);
+const DIAGNOSTIC_EVENT_ORDER: readonly FirstDisplayGptDiagnosticEventV1[] = Object.freeze([
+  SLOT_REQUESTED,
+  SLOT_RESPONSE_RECEIVED,
+  SLOT_RENDER_ENDED,
+  SLOT_ONLOAD,
+  IMPRESSION_VIEWABLE,
+  SLOT_VISIBILITY_CHANGED,
+]);
+
+export type FirstDisplayGptRenderResult = 'gam_empty' | 'nonempty_gam';
+export type FirstDisplayGptFailureReason =
+  | 'cycle_unattributable'
+  | 'external_artifact_incompatible'
+  | 'external_ready_timeout'
+  | 'gpt_completion_timeout'
+  | typeof GPT_REQUEST_FAILED
+  | 'gpt_request_timeout'
+  | typeof SLOT_UNRESOLVED;
+
+/** Compact live physical-cycle authority crossing GPT, bootstrap, and render owner. */
+export type FirstDisplayGptBoundCycleV1 = readonly [
+  bid: FirstDisplayProjectionBidV1,
+  element: HTMLElement,
+  /** Closure-private physical-cycle validity; false after a later GPT request takes the slot. */
+  isCurrent: () => boolean,
+  ownership: 'publisher' | 'trusted_server',
+  physicalSlot: object,
+  placement: FirstDisplayProjectionSlotV1,
+  slotId: string,
+  traceToken: string,
+];
+
+export interface FirstDisplayTargetingOwnershipV1 {
+  readonly installed: string;
+  readonly key: string;
+  readonly prior: readonly string[];
+}
+
+export type FirstDisplayGptHandoffCycleV1 = readonly [
+  ...FirstDisplayGptBoundCycleV1,
+  targetingOwnership: readonly FirstDisplayTargetingOwnershipV1[],
+];
+
+/** Compact physical GPT state crossing from the selected slice to the inline owner. */
+export type FirstDisplayGptCaptureCycleV1 = readonly [
+  slotId: string,
+  elementId: string,
+  ownership: 'trusted_server' | 'publisher',
+  targetingOwnership: readonly FirstDisplayTargetingOwnershipV1[],
+  traceToken: string,
+  physicalSlot: object,
+];
+
+export type FirstDisplayGptDiagnosticCycleV1 = readonly [
+  slotId: string,
+  token: string,
+  nextCycleOrdinal: number,
+  unknownPriorCycle: boolean,
+  quarantines: readonly string[],
+  records: readonly (readonly [
+    ordinal: number,
+    responseIdentifier: string | null,
+    seen: readonly FirstDisplayGptDiagnosticEventV1[],
+    state: 'open' | 'completed' | 'retired',
+  ])[],
+];
+
+export type FirstDisplayGptDiagnosticsHandoffV1 = readonly [
+  cycles: readonly FirstDisplayGptDiagnosticCycleV1[],
+  facts: FirstDisplayGptDiagnosticsV1['facts'],
+  nextTraceTokenOrdinal: number,
+  overflowCount: number,
+  dropCount: number,
+];
+
+/** Compact authenticated callback capability crossing from the inline owner. */
+export type FirstDisplayGoogletagBatchCallbacks = readonly [
+  onBound: (cycle: FirstDisplayGptBoundCycleV1) => void,
+  onFailure: (slotId: string, reason: FirstDisplayGptFailureReason) => void,
+  onFirstAction: () => boolean,
+  onRenderEnded: (cycle: FirstDisplayGptBoundCycleV1, result: FirstDisplayGptRenderResult) => void,
+  /** Retire an accepted TS artifact when its exact parser-time physical binding is lost. */
+  onRetire: ((cycle: FirstDisplayGptBoundCycleV1) => void) | undefined,
+];
+
+export interface FirstDisplayGoogletagBatch {
+  readonly start: (callbacks: FirstDisplayGoogletagBatchCallbacks) => boolean;
+  /** Stop provisional GPT ingress after every physical cycle is terminal. */
+  /** Destroy noncommitted TS slots before closing publisher-mutation observation. */
+  readonly closeIngress: (committedSlotIds: readonly string[]) => boolean;
+  /** Capture exact terminal physical identities without changing disposal ownership. */
+  readonly captureHandoff: () => readonly FirstDisplayGptCaptureCycleV1[] | undefined;
+  readonly captureDiagnosticsHandoff: () => FirstDisplayGptDiagnosticsHandoffV1 | undefined;
+  /** Exempt exactly the accepted slot identities from provisional destruction/restoration. */
+  readonly detachCommittedSlots: (slotIds: readonly string[]) => boolean;
+  readonly dispose: () => void;
+}
+
+/** Compact authenticated capability passed from the GPT slice to the inline owner. */
+export type FirstDisplayGoogletagBatchCapabilityV1 = readonly [
+  start: FirstDisplayGoogletagBatch['start'],
+  closeIngress: FirstDisplayGoogletagBatch['closeIngress'],
+  captureHandoff: FirstDisplayGoogletagBatch['captureHandoff'],
+  captureDiagnosticsHandoff: FirstDisplayGoogletagBatch['captureDiagnosticsHandoff'],
+  detachCommittedSlots: FirstDisplayGoogletagBatch['detachCommittedSlots'],
+  dispose: FirstDisplayGoogletagBatch['dispose'],
+];
+
+export interface FirstDisplayGoogletagBatchOptions {
+  readonly browser: Window & { googletag?: unknown };
+  readonly clearTimer: (handle: unknown) => void;
+  readonly document: Document;
+  readonly diagnosticsActive?: boolean;
+  readonly onNativeMutation?: () => boolean;
+  readonly projection: FirstDisplayProjectionV1;
+  readonly protocol: FirstDisplayGptBatchPolicyV1;
+  readonly setTimer: (callback: () => void, delayMs: number) => unknown;
+}
+
+/** Compact authenticated input crossing from the inline owner to the GPT slice. */
+export type FirstDisplayGoogletagBatchInput = readonly [
+  browser: FirstDisplayGoogletagBatchOptions['browser'],
+  clearTimer: FirstDisplayGoogletagBatchOptions['clearTimer'],
+  document: FirstDisplayGoogletagBatchOptions['document'],
+  setTimer: FirstDisplayGoogletagBatchOptions['setTimer'],
+  projection: FirstDisplayGoogletagBatchOptions['projection'],
+  diagnosticsActive?: FirstDisplayGoogletagBatchOptions['diagnosticsActive'],
+  onNativeMutation?: FirstDisplayGoogletagBatchOptions['onNativeMutation'],
+];
+
+type ExternalObject = Record<PropertyKey, unknown>;
+
+interface FirstDisplayDiagnosticCycleRecord {
+  readonly ordinal: number;
+  readonly seen: Set<FirstDisplayGptDiagnosticEventV1>;
+  responseIdentifier?: string;
+  state: 'open' | 'completed' | 'retired';
+}
+
+interface ActiveCycle {
+  readonly bindingState: { current: boolean };
+  readonly diagnosticRecords: FirstDisplayDiagnosticCycleRecord[];
+  elementId: string;
+  readonly initialLoadDisabled: boolean;
+  readonly operations: readonly ('display' | 'refresh')[];
+  ownership: 'publisher' | 'trusted_server';
+  readonly publicCycle: FirstDisplayGptBoundCycleV1;
+  readonly requestOperation: 0 | 1;
+  readonly runtimeSlotNumber: number;
+  completionTimer?: unknown;
+  nextDiagnosticCycleOrdinal: number;
+  requestInvoked: boolean;
+  requested: boolean;
+  requestTimer?: unknown;
+  settled: boolean;
+  suppressPublisherDisplay: boolean;
+  suppressPublisherRefresh: boolean;
+  unknownPriorCycle: boolean;
+}
+
+interface TargetingRestorer {
+  readonly installed: string;
+  readonly key: string;
+  readonly prior: readonly string[];
+  readonly slot: object;
+  valid: boolean;
+}
+
+interface TargetingWrite {
+  consumed: boolean;
+  readonly operation: 'clearTargeting' | 'setTargeting';
+  readonly slot: object;
+}
+
+interface TargetingObserverRestorer {
+  readonly isCurrent: () => boolean;
+  readonly restore: () => boolean;
+}
+
+interface TargetingObserver {
+  readonly isCurrent: () => boolean;
+  readonly restore: () => boolean;
+}
+
+function externalObject(value: unknown): ExternalObject | undefined {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function'
+    ? (value as ExternalObject)
+    : undefined;
+}
+
+/** Enqueue the document-local GAM attribution command at the parser-time boundary. */
+export function enqueueFirstDisplayGamAttribution(
+  target: Window & { googletag?: unknown }
+): boolean {
+  try {
+    let binding = externalObject(target.googletag);
+    if (!binding) {
+      binding = { cmd: [] };
+      if (
+        !Reflect.defineProperty(target, 'googletag', {
+          configurable: true,
+          enumerable: true,
+          value: binding,
+          writable: true,
+        }) ||
+        target.googletag !== binding
+      ) {
+        return false;
+      }
+    }
+    const queue = externalObject(Reflect.get(binding, 'cmd'));
+    const push = queue && Reflect.get(queue, 'push');
+    if (!queue || typeof push !== 'function') return false;
+    Reflect.apply(push, queue, [
+      () => {
+        try {
+          const root = externalObject(target.googletag) ?? binding;
+          const setConfig = Reflect.get(root, 'setConfig');
+          if (typeof setConfig === 'function') {
+            Reflect.apply(setConfig, root, [{ targeting: { ts: 'true' } }]);
+          }
+        } catch {
+          // Missing or hostile GPT targeting cannot block later queue work.
+        }
+      },
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function member(value: unknown, key: PropertyKey): unknown {
+  const object = externalObject(value);
+  if (!object) return undefined;
+  try {
+    return Reflect.get(object, key);
+  } catch {
+    return undefined;
+  }
+}
+
+function call(receiver: unknown, key: PropertyKey, arguments_: readonly unknown[]): unknown {
+  const callable = member(receiver, key);
+  if (typeof callable !== 'function') throw new TypeError('tsjs');
+  return Reflect.apply(callable, receiver, arguments_);
+}
+
+function physicalSlot(value: unknown): object | undefined {
+  return externalObject(value);
+}
+
+function resolveElement(
+  document: Document,
+  placement: FirstDisplayProjectionSlotV1
+): HTMLElement | undefined {
+  try {
+    const ElementConstructor = document.defaultView?.HTMLElement;
+    if (!ElementConstructor) return undefined;
+    const exact = document.getElementById(placement.divId);
+    if (exact instanceof ElementConstructor) return exact;
+    const matches = [...document.querySelectorAll<HTMLElement>('[id]')].filter(
+      (element) => element.id.startsWith(placement.divId) && !element.id.endsWith('-container')
+    );
+    return matches.length === 1 ? matches[0] : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function initialLoadDisabled(binding: ExternalObject): boolean {
+  try {
+    const getConfig = member(binding, 'getConfig');
+    if (typeof getConfig !== 'function') return false;
+    const config = Reflect.apply(getConfig, binding, ['disableInitialLoad']);
+    return member(config, 'disableInitialLoad') === true;
+  } catch {
+    return false;
+  }
+}
+
+function targetingEntries(
+  bid: FirstDisplayProjectionBidV1,
+  placement: FirstDisplayProjectionSlotV1
+): readonly (readonly [string, string])[] {
+  const targeting: Record<string, string> = {};
+  for (const key of Object.keys(placement.targeting)) targeting[key] = placement.targeting[key]!;
+  for (const key of Object.keys(bid.targeting)) targeting[key] = bid.targeting[key]!;
+  targeting.hb_adid = bid.rendererReservationId;
+  return Object.freeze(
+    Object.keys(targeting)
+      .sort()
+      .map((key) => Object.freeze([key, targeting[key]!] as const))
+  );
+}
+
+function winnerRows(
+  projection: FirstDisplayProjectionV1
+): readonly (readonly [FirstDisplayProjectionBidV1, FirstDisplayProjectionSlotV1])[] {
+  const rows: Array<readonly [FirstDisplayProjectionBidV1, FirstDisplayProjectionSlotV1]> = [];
+  let winner = 0;
+  for (let index = 0; index < projection.auction.results.length; index += 1) {
+    const decision = projection.auction.results[index];
+    const placement = projection.slots[index];
+    if (!decision || !placement || decision.outcome !== 'winner') continue;
+    const bid = projection.bids[winner];
+    winner += 1;
+    if (bid) rows.push(Object.freeze([bid, placement]));
+  }
+  return Object.freeze(rows);
+}
+
+class FirstDisplayGoogletagBatchOwner implements FirstDisplayGoogletagBatch {
+  private readonly cycleMap = new Map<object, ActiveCycle>();
+  private readonly createdSlots = new Set<object>();
+  private readonly diagnosticFacts: Readonly<FirstDisplayGptFactV1>[] = [];
+  private readonly diagnosticListeners = new Map<string, (event: unknown) => void>();
+  private readonly targetingObservers = new Map<object, TargetingObserver>();
+  private readonly targetingRestorers: TargetingRestorer[] = [];
+  private readonly sealedTargetingOwnership = new Map<
+    object,
+    readonly FirstDisplayTargetingOwnershipV1[]
+  >();
+  private readonly publisherCallRestorers: Array<() => void> = [];
+  private readonly timers = new Set<unknown>();
+  private binding: ExternalObject | undefined;
+  private command: (() => void) | undefined;
+  private commandQueue: unknown[] | undefined;
+  private commandQueueIndex = -1;
+  private createdBinding: ExternalObject | undefined;
+  private renderListener: ((event: unknown) => void) | undefined;
+  private requestedListener: ((event: unknown) => void) | undefined;
+  private service: ExternalObject | undefined;
+  private started = false;
+  private disposed = false;
+  private ingressClosed = false;
+  private ingressClosing = false;
+  private committedSlotsDetached = false;
+  private readonly detachedSlots = new Set<object>();
+  private firstAction = false;
+  private diagnosticFactOverflow = 0;
+  private diagnosticFactDrops = 0;
+  private nextTraceTokenOrdinal = 1;
+  private readonly targetingWrites: TargetingWrite[] = [];
+  private trustedServerCall: readonly [receiver: ExternalObject, key: string] | undefined;
+
+  public constructor(private readonly options: FirstDisplayGoogletagBatchOptions) {}
+
+  public start(callbacks: FirstDisplayGoogletagBatchCallbacks): boolean {
+    if (this.started || this.disposed) return false;
+    this.started = true;
+    const rows = winnerRows(this.options.projection);
+    if (rows.length === 0) return true;
+
+    const binding = this.ensureBinding();
+    const queue = member(binding, 'cmd');
+    const push = member(queue, 'push');
+    if (!binding || !queue || typeof push !== 'function') {
+      this.failRows(rows, callbacks, 'external_artifact_incompatible');
+      return false;
+    }
+    this.binding = binding;
+    const readyTimer = this.timer(() => {
+      this.removePendingCommand();
+      this.failRows(rows, callbacks, 'external_ready_timeout');
+    }, this.options.protocol.deadlines.externalReadyMs);
+    const command = (): void => {
+      if (this.disposed || this.command !== command) return;
+      this.command = undefined;
+      this.clearOwnedTimer(readyTimer);
+      try {
+        this.activate(binding, rows, callbacks);
+      } catch {
+        this.failRows(rows, callbacks, 'external_artifact_incompatible');
+      }
+    };
+    this.command = command;
+    if (Array.isArray(queue)) {
+      this.commandQueue = queue;
+      this.commandQueueIndex = queue.length;
+    }
+    try {
+      Reflect.apply(push, queue, [command]);
+    } catch {
+      this.command = undefined;
+      this.clearOwnedTimer(readyTimer);
+      this.failRows(rows, callbacks, 'external_artifact_incompatible');
+      return false;
+    }
+    return true;
+  }
+
+  public closeIngress(committedSlotIds: readonly string[]): boolean {
+    if (
+      this.disposed ||
+      this.ingressClosed ||
+      this.ingressClosing ||
+      !this.started ||
+      [...this.cycleMap.values()].some((cycle) => !cycle.settled) ||
+      !Array.isArray(committedSlotIds)
+    ) {
+      return false;
+    }
+    const committed = new Set(committedSlotIds);
+    if (committed.size !== committedSlotIds.length) return false;
+    const retainedSlots = new Set<object>();
+    for (const slotId of committed) {
+      const matches = [...this.cycleMap.values()].filter(
+        (cycle) => cycle.publicCycle[6] === slotId
+      );
+      if (matches.length !== 1 || !matches[0]?.settled) return false;
+      retainedSlots.add(matches[0].publicCycle[4]);
+    }
+    const destroyableSlots = [...this.createdSlots].filter((slot) => !retainedSlots.has(slot));
+    this.ingressClosing = true;
+    if (destroyableSlots.length > 0) {
+      try {
+        if (!this.binding || call(this.binding, 'destroySlots', [[...destroyableSlots]]) !== true) {
+          this.ingressClosing = false;
+          return false;
+        }
+      } catch {
+        this.ingressClosing = false;
+        return false;
+      }
+      for (const slot of destroyableSlots) this.createdSlots.delete(slot);
+    }
+    this.invalidateStaleTargetingObservers();
+    const retainedTargetingRestorers = this.targetingRestorers.filter((restoration) =>
+      retainedSlots.has(restoration.slot)
+    );
+    for (const restoration of [...this.targetingRestorers].reverse()) {
+      if (retainedSlots.has(restoration.slot)) continue;
+      try {
+        this.restorePublisherTargeting(restoration);
+      } catch {
+        // Publisher mutations win while retained-slot observation is still authoritative.
+      }
+    }
+    this.targetingRestorers.splice(
+      0,
+      this.targetingRestorers.length,
+      ...retainedTargetingRestorers
+    );
+    this.ingressClosed = true;
+    this.ingressClosing = false;
+    this.removePendingCommand();
+    for (const handle of [...this.timers]) this.clearOwnedTimer(handle);
+    this.removeListener();
+    this.restorePublisherCalls();
+    const targetingCandidates = this.captureRetainedTargeting(retainedSlots);
+    this.restoreTargetingObservers();
+    for (const [slot, restorations] of targetingCandidates) {
+      this.sealedTargetingOwnership.set(
+        slot,
+        Object.freeze(
+          restorations
+            .filter(({ valid }) => valid)
+            .map(({ installed, key, prior }) => Object.freeze({ installed, key, prior }))
+        )
+      );
+    }
+    return true;
+  }
+
+  public captureHandoff(): readonly FirstDisplayGptCaptureCycleV1[] | undefined {
+    if (this.disposed || !this.ingressClosed) return undefined;
+    return Object.freeze(
+      [...this.cycleMap.values()]
+        .filter((cycle) => this.sealedTargetingOwnership.has(cycle.publicCycle[4]))
+        .map((cycle) =>
+          Object.freeze([
+            cycle.publicCycle[6],
+            cycle.elementId,
+            cycle.ownership,
+            Object.freeze(this.sealedTargetingOwnership.get(cycle.publicCycle[4]) ?? []),
+            cycle.publicCycle[7],
+            cycle.publicCycle[4],
+          ] as const)
+        )
+    );
+  }
+
+  public captureDiagnosticsHandoff(): FirstDisplayGptDiagnosticsHandoffV1 | undefined {
+    if (this.disposed || !this.ingressClosed) return undefined;
+    return Object.freeze([
+      Object.freeze(
+        [...this.cycleMap.values()]
+          .filter((cycle) => this.sealedTargetingOwnership.has(cycle.publicCycle[4]))
+          .map((cycle) =>
+            Object.freeze([
+              cycle.publicCycle[6],
+              cycle.publicCycle[7],
+              cycle.nextDiagnosticCycleOrdinal,
+              cycle.unknownPriorCycle,
+              Object.freeze([]),
+              Object.freeze(
+                cycle.diagnosticRecords.map((record) =>
+                  Object.freeze([
+                    record.ordinal,
+                    record.responseIdentifier ?? null,
+                    Object.freeze(DIAGNOSTIC_EVENT_ORDER.filter((event) => record.seen.has(event))),
+                    record.state,
+                  ] as const)
+                )
+              ),
+            ] as const)
+          )
+      ),
+      Object.freeze([...this.diagnosticFacts]),
+      this.nextTraceTokenOrdinal,
+      this.diagnosticFactOverflow,
+      this.diagnosticFactDrops,
+    ] as const);
+  }
+
+  public detachCommittedSlots(slotIds: readonly string[]): boolean {
+    if (this.disposed || !this.ingressClosed || this.committedSlotsDetached) return false;
+    const requested = new Set(slotIds);
+    if (requested.size !== slotIds.length) return false;
+    const selected: object[] = [];
+    for (const slotId of requested) {
+      const matches = [...this.cycleMap.values()].filter(
+        (cycle) => cycle.publicCycle[6] === slotId
+      );
+      if (matches.length !== 1 || !matches[0]?.settled) return false;
+      selected.push(matches[0].publicCycle[4]);
+    }
+    this.committedSlotsDetached = true;
+    for (const slot of selected) this.detachedSlots.add(slot);
+    return true;
+  }
+
+  public dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.removePendingCommand();
+    for (const handle of [...this.timers]) this.clearOwnedTimer(handle);
+    this.removeListener();
+    this.restorePublisherCalls();
+    this.invalidateStaleTargetingObservers();
+    for (const restoration of this.targetingRestorers.reverse()) {
+      if (this.detachedSlots.has(restoration.slot)) continue;
+      try {
+        this.restorePublisherTargeting(restoration);
+      } catch {
+        // Publisher mutations and hostile GPT objects always win over restoration.
+      }
+    }
+    this.targetingRestorers.length = 0;
+    this.restoreTargetingObservers();
+    const destroyableSlots = [...this.createdSlots].filter((slot) => !this.detachedSlots.has(slot));
+    if (this.binding && destroyableSlots.length > 0) {
+      try {
+        call(this.binding, 'destroySlots', [destroyableSlots]);
+      } catch {
+        // Generation latching keeps failed physical cleanup inert.
+      }
+    }
+    this.createdSlots.clear();
+    this.cycleMap.clear();
+    this.sealedTargetingOwnership.clear();
+    if (this.detachedSlots.size === 0) this.restoreCreatedBinding();
+    else this.createdBinding = undefined;
+    this.detachedSlots.clear();
+    this.binding = undefined;
+    this.service = undefined;
+  }
+
+  private ensureBinding(): ExternalObject | undefined {
+    const current = externalObject(this.options.browser.googletag);
+    if (current) return current;
+    const binding: ExternalObject = { cmd: [] };
+    try {
+      if (
+        !Reflect.defineProperty(this.options.browser, 'googletag', {
+          configurable: true,
+          enumerable: true,
+          value: binding,
+          writable: true,
+        }) ||
+        this.options.browser.googletag !== binding
+      ) {
+        return undefined;
+      }
+      this.createdBinding = binding;
+      return binding;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private restoreCreatedBinding(): void {
+    if (!this.createdBinding) return;
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(this.options.browser, 'googletag');
+      if (descriptor && 'value' in descriptor && descriptor.value === this.createdBinding) {
+        Reflect.deleteProperty(this.options.browser, 'googletag');
+      }
+    } catch {
+      // Publisher replacement wins over restoration.
+    }
+    this.createdBinding = undefined;
+  }
+
+  private activate(
+    binding: ExternalObject,
+    rows: readonly (readonly [FirstDisplayProjectionBidV1, FirstDisplayProjectionSlotV1])[],
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    if (this.disposed || this.binding !== binding) return;
+    const service = externalObject(call(binding, 'pubads', []));
+    if (!service) throw new TypeError('tsjs');
+    this.service = service;
+    this.observePublisherCalls(binding, service, callbacks);
+    this.installListeners(service, callbacks);
+    const existing = call(service, 'getSlots', []);
+    if (!Array.isArray(existing)) throw new TypeError('tsjs');
+    const disabled = initialLoadDisabled(binding);
+
+    for (const row of rows) {
+      if (this.disposed) return;
+      const [bid, placement] = row;
+      const element = resolveElement(this.options.document, placement);
+      if (!element) {
+        callbacks[1](placement.slot, SLOT_UNRESOLVED);
+        continue;
+      }
+      const matches = existing.filter((candidate) =>
+        physicalSlot(candidate) && typeof member(candidate, 'getSlotElementId') === 'function'
+          ? call(candidate, 'getSlotElementId', []) === element.id
+          : member(candidate, 'getSlotElementId') === undefined
+            ? member(candidate, 'elementId') === element.id
+            : false
+      );
+      if (matches.length > 1) {
+        callbacks[1](placement.slot, SLOT_UNRESOLVED);
+        continue;
+      }
+      const publisherSlot = physicalSlot(matches[0]);
+      const slot =
+        publisherSlot ??
+        physicalSlot(
+          this.callTrustedServer(binding, 'defineSlot', [
+            placement.gamUnitPath,
+            placement.formats,
+            element.id,
+          ])
+        );
+      if (!slot) {
+        callbacks[1](placement.slot, SLOT_UNRESOLVED);
+        continue;
+      }
+      const ownership = publisherSlot ? 'publisher' : 'trusted_server';
+      if (!publisherSlot) {
+        call(slot, 'addService', [service]);
+        this.createdSlots.add(slot);
+      } else {
+        this.observePublisherTargeting(slot);
+      }
+      const plan = this.options.protocol.requestPlan(
+        Object.freeze({ initialLoadDisabled: disabled, ownership })
+      );
+      if (!plan) {
+        callbacks[1](placement.slot, GPT_REQUEST_FAILED);
+        continue;
+      }
+      const traceTokenOrdinal = this.nextTraceTokenOrdinal;
+      if (traceTokenOrdinal > 4_294_967_295) {
+        callbacks[1](placement.slot, GPT_REQUEST_FAILED);
+        continue;
+      }
+      const traceToken = `gt1_${traceTokenOrdinal.toString(36)}`;
+      this.nextTraceTokenOrdinal += 1;
+      const bindingState = { current: true };
+      const publicCycle: FirstDisplayGptBoundCycleV1 = Object.freeze([
+        bid,
+        element,
+        () => bindingState.current,
+        ownership,
+        slot,
+        placement,
+        placement.slot,
+        traceToken,
+      ]);
+      const cycle: ActiveCycle = {
+        bindingState,
+        diagnosticRecords: [],
+        elementId: element.id,
+        initialLoadDisabled: disabled,
+        operations: plan.operations,
+        ownership,
+        publicCycle,
+        requestOperation: plan.requestOperation,
+        runtimeSlotNumber: traceTokenOrdinal,
+        nextDiagnosticCycleOrdinal: 1,
+        requestInvoked: false,
+        requested: false,
+        settled: false,
+        suppressPublisherDisplay: false,
+        suppressPublisherRefresh: false,
+        unknownPriorCycle: ownership === 'publisher',
+      };
+      this.cycleMap.set(slot, cycle);
+      callbacks[0](publicCycle);
+      for (const [key, value] of targetingEntries(bid, placement)) {
+        if (publisherSlot) this.journalPublisherTargeting(slot, key, value);
+        this.writeTargeting(slot, 'setTargeting', [key, value]);
+      }
+    }
+
+    const armRequest = (candidate: ActiveCycle): void => {
+      if (candidate.requestInvoked) return;
+      candidate.requestInvoked = true;
+      candidate.requestTimer = this.timer(
+        () => this.failCycle(candidate, callbacks, 'gpt_request_timeout'),
+        this.options.protocol.deadlines.requestStartMs
+      );
+      candidate.completionTimer = this.timer(
+        () => this.failCycle(candidate, callbacks, 'gpt_completion_timeout'),
+        this.options.protocol.deadlines.completionMs
+      );
+    };
+    const synchronousSraCycles = [...this.cycleMap.values()].filter(
+      (candidate) =>
+        !candidate.settled &&
+        candidate.requestOperation === 0 &&
+        candidate.operations[0] === 'display'
+    );
+    for (const cycle of this.cycleMap.values()) {
+      if (this.disposed || cycle.settled) continue;
+      try {
+        for (let index = 0; index < cycle.operations.length; index += 1) {
+          const operation = cycle.operations[index];
+          if (index === cycle.requestOperation) {
+            if (operation === 'display' && cycle.requestOperation === 0) {
+              for (const candidate of synchronousSraCycles) armRequest(candidate);
+            } else {
+              armRequest(cycle);
+            }
+            if (!this.firstAction) {
+              this.firstAction = true;
+              if (!callbacks[2]()) {
+                for (const active of this.cycleMap.values()) {
+                  this.failCycle(active, callbacks, GPT_REQUEST_FAILED);
+                }
+                return;
+              }
+              if (member(binding, 'pubadsReady') !== true) {
+                try {
+                  call(service, 'enableSingleRequest', []);
+                  call(binding, 'enableServices', []);
+                } catch {
+                  for (const active of this.cycleMap.values()) {
+                    this.failCycle(active, callbacks, GPT_REQUEST_FAILED);
+                  }
+                  return;
+                }
+              }
+            }
+            if (cycle.settled) break;
+          }
+          if (operation === 'display') {
+            this.callTrustedServer(binding, 'display', [cycle.elementId]);
+          } else {
+            this.callTrustedServer(service, 'refresh', [
+              [cycle.publicCycle[4]],
+              { changeCorrelator: false },
+            ]);
+          }
+        }
+      } catch {
+        if (cycle.settled) continue;
+        this.failCycle(cycle, callbacks, GPT_REQUEST_FAILED);
+      }
+    }
+  }
+
+  private installListeners(
+    service: ExternalObject,
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    const requestedListener = (event: unknown): void => {
+      if (this.disposed || this.requestedListener !== requestedListener) return;
+      this.notifyNativeMutation();
+      const slot = physicalSlot(member(event, 'slot'));
+      const cycle = slot ? this.cycleMap.get(slot) : undefined;
+      if (!cycle) {
+        if (slot) {
+          this.invalidateCyclesForElement(this.readPhysicalElementId(slot), slot, callbacks);
+        }
+        return;
+      }
+      if (cycle.settled) {
+        this.retireCycle(cycle, callbacks);
+        this.captureDiagnosticFact(SLOT_REQUESTED, cycle, event);
+        return;
+      }
+      if (!cycle.requestInvoked) return;
+      if (cycle.requested) {
+        this.failCycle(cycle, callbacks, 'cycle_unattributable');
+        return;
+      }
+      cycle.requested = true;
+      this.captureDiagnosticFact(SLOT_REQUESTED, cycle, event);
+      if (cycle.requestTimer !== undefined) this.clearOwnedTimer(cycle.requestTimer);
+    };
+    const renderListener = (event: unknown): void => {
+      if (this.disposed || this.renderListener !== renderListener) return;
+      this.notifyNativeMutation();
+      const slot = physicalSlot(member(event, 'slot'));
+      const cycle = slot ? this.cycleMap.get(slot) : undefined;
+      if (!cycle) return;
+      if (cycle.settled) {
+        this.captureDiagnosticFact(SLOT_RENDER_ENDED, cycle, event);
+        return;
+      }
+      if (!cycle.requested) return;
+      const result = this.options.protocol.classifyRenderEnded(
+        Object.freeze({ isEmpty: member(event, 'isEmpty') })
+      );
+      if (!result) {
+        this.failCycle(cycle, callbacks, GPT_REQUEST_FAILED);
+        return;
+      }
+      this.captureDiagnosticFact(SLOT_RENDER_ENDED, cycle, event);
+      cycle.settled = true;
+      if (cycle.requestTimer !== undefined) this.clearOwnedTimer(cycle.requestTimer);
+      if (cycle.completionTimer !== undefined) this.clearOwnedTimer(cycle.completionTimer);
+      callbacks[3](cycle.publicCycle, result);
+    };
+    this.requestedListener = requestedListener;
+    this.renderListener = renderListener;
+    this.diagnosticListeners.set(SLOT_REQUESTED, requestedListener);
+    this.diagnosticListeners.set(SLOT_RENDER_ENDED, renderListener);
+    call(service, 'addEventListener', [SLOT_REQUESTED, requestedListener]);
+    call(service, 'addEventListener', [SLOT_RENDER_ENDED, renderListener]);
+    if (this.options.diagnosticsActive === true) {
+      for (const eventType of DIAGNOSTIC_ONLY_EVENTS) {
+        const listener = (event: unknown): void => {
+          if (this.disposed || this.diagnosticListeners.get(eventType) !== listener) return;
+          this.notifyNativeMutation();
+          const slot = physicalSlot(member(event, 'slot'));
+          const cycle = slot ? this.cycleMap.get(slot) : undefined;
+          if (cycle) this.captureDiagnosticFact(eventType, cycle, event);
+        };
+        this.diagnosticListeners.set(eventType, listener);
+        call(service, 'addEventListener', [eventType, listener]);
+      }
+    }
+  }
+
+  private removeListener(): void {
+    if (!this.service) return;
+    this.requestedListener = undefined;
+    this.renderListener = undefined;
+    try {
+      for (const [eventType, listener] of this.diagnosticListeners) {
+        call(this.service, 'removeEventListener', [eventType, listener]);
+      }
+    } catch {
+      // The generation latch remains authoritative if GPT cannot detach physically.
+    } finally {
+      this.diagnosticListeners.clear();
+    }
+  }
+
+  private failCycle(
+    cycle: ActiveCycle,
+    callbacks: FirstDisplayGoogletagBatchCallbacks,
+    reason: FirstDisplayGptFailureReason
+  ): void {
+    if (cycle.settled) return;
+    cycle.settled = true;
+    for (const record of cycle.diagnosticRecords) {
+      if (record.state === 'open') record.state = 'retired';
+    }
+    if (cycle.requestTimer !== undefined) this.clearOwnedTimer(cycle.requestTimer);
+    if (cycle.completionTimer !== undefined) this.clearOwnedTimer(cycle.completionTimer);
+    callbacks[1](cycle.publicCycle[6], reason);
+  }
+
+  private journalPublisherTargeting(slot: object, key: string, installed: string): void {
+    const original = call(slot, 'getTargeting', [key]);
+    if (!Array.isArray(original) || !original.every((value) => typeof value === 'string')) {
+      throw new TypeError('tsjs');
+    }
+    this.targetingRestorers.push({
+      installed,
+      key,
+      prior: Object.freeze([...original]),
+      slot,
+      valid: true,
+    });
+  }
+
+  private observePublisherTargeting(slot: object): void {
+    if (this.targetingObservers.has(slot)) return;
+    const restorers: TargetingObserverRestorer[] = [];
+    try {
+      for (const key of ['setTargeting', 'clearTargeting'] as const) {
+        const original = member(slot, key);
+        if (typeof original !== 'function') throw new TypeError('tsjs');
+        const prior = Object.getOwnPropertyDescriptor(slot, key);
+        const invalidateTargeting = (targetingKey: string | undefined): void =>
+          this.invalidateTargeting(slot, targetingKey);
+        const consumeTrustedServerWrite = (): boolean => this.consumeTargetingWrite(slot, key);
+        const ownerMutation = (): void => this.notifyNativeMutation();
+        const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+          const trustedServerWrite = this === slot && consumeTrustedServerWrite();
+          if (!trustedServerWrite && this === slot) {
+            const targetingKey = typeof arguments_[0] === 'string' ? arguments_[0] : undefined;
+            invalidateTargeting(targetingKey);
+            const result = Reflect.apply(original, this, arguments_);
+            ownerMutation();
+            return result;
+          }
+          return Reflect.apply(original, this, arguments_);
+        };
+        if (
+          !Reflect.defineProperty(slot, key, {
+            configurable: true,
+            enumerable: prior?.enumerable ?? false,
+            value: wrapper,
+            writable: true,
+          })
+        ) {
+          throw new TypeError('tsjs');
+        }
+        const isCurrent = (): boolean => {
+          try {
+            const current = Object.getOwnPropertyDescriptor(slot, key);
+            return !!current && 'value' in current && current.value === wrapper;
+          } catch {
+            return false;
+          }
+        };
+        restorers.push({
+          isCurrent,
+          restore: (): boolean => {
+            if (!isCurrent()) return false;
+            try {
+              return prior
+                ? Reflect.defineProperty(slot, key, prior)
+                : Reflect.deleteProperty(slot, key);
+            } catch {
+              return false;
+            }
+          },
+        });
+      }
+    } catch (error) {
+      for (const restorer of restorers.reverse()) restorer.restore();
+      throw error;
+    }
+    this.targetingObservers.set(slot, {
+      isCurrent: (): boolean => restorers.every(({ isCurrent }) => isCurrent()),
+      restore: (): boolean => {
+        let exact = restorers.every(({ isCurrent }) => isCurrent());
+        for (const restorer of restorers.reverse()) {
+          if (!restorer.restore()) exact = false;
+        }
+        return exact;
+      },
+    });
+  }
+
+  private replacementSizesEqual(
+    candidate: unknown,
+    expected: readonly (readonly [number, number])[]
+  ): boolean {
+    if (!Array.isArray(candidate)) return false;
+    const values =
+      candidate.length === 2 && candidate.every((value) => typeof value === 'number')
+        ? [candidate]
+        : candidate;
+    if (values.length !== expected.length) return false;
+    return values.every(
+      (value, index) =>
+        Array.isArray(value) &&
+        value.length === 2 &&
+        value[0] === expected[index]?.[0] &&
+        value[1] === expected[index]?.[1]
+    );
+  }
+
+  private claimPublisherSlot(arguments_: readonly unknown[]): ActiveCycle | undefined {
+    if (arguments_.length !== 3 || typeof arguments_[2] !== 'string') return undefined;
+    const elementId = arguments_[2];
+    const exact: ActiveCycle[] = [];
+    const hydration: ActiveCycle[] = [];
+    for (const cycle of this.cycleMap.values()) {
+      if (cycle.ownership !== 'trusted_server' || !cycle.bindingState.current) continue;
+      if (cycle.elementId === elementId) {
+        exact.push(cycle);
+        continue;
+      }
+      const placement = cycle.publicCycle[5];
+      const oldElement = this.options.document.getElementById(cycle.elementId);
+      const replacement = this.options.document.getElementById(elementId);
+      if (
+        elementId.startsWith(placement.divId) &&
+        (!oldElement || !oldElement.isConnected) &&
+        replacement?.isConnected === true &&
+        arguments_[0] === placement.gamUnitPath &&
+        this.replacementSizesEqual(arguments_[1], placement.formats)
+      ) {
+        hydration.push(cycle);
+      }
+    }
+    const matches = exact.length > 0 ? exact : hydration;
+    if (matches.length !== 1) return undefined;
+    const cycle = matches[0];
+    if (!cycle) return undefined;
+    const slot = cycle.publicCycle[4];
+    try {
+      this.observePublisherTargeting(slot);
+    } catch {
+      return undefined;
+    }
+    for (const [key, installed] of targetingEntries(cycle.publicCycle[0], cycle.publicCycle[5])) {
+      this.targetingRestorers.push({ installed, key, prior: Object.freeze([]), slot, valid: true });
+    }
+    if (exact.length === 1) {
+      const placement = cycle.publicCycle[5];
+      const formatsMismatch = !this.replacementSizesEqual(arguments_[1], placement.formats);
+      const pathMismatch = arguments_[0] !== placement.gamUnitPath;
+      if (formatsMismatch || pathMismatch) {
+        try {
+          this.options.document.defaultView?.console.warn(
+            'GPT publisher handoff metadata mismatch',
+            {
+              formatsMismatch,
+              pathMismatch,
+            }
+          );
+        } catch {
+          // A bounded local diagnostic cannot block exact publisher ownership transfer.
+        }
+      }
+    }
+    cycle.ownership = 'publisher';
+    cycle.elementId = elementId;
+    cycle.suppressPublisherDisplay = true;
+    cycle.suppressPublisherRefresh = this.binding
+      ? initialLoadDisabled(this.binding)
+      : cycle.initialLoadDisabled;
+    this.createdSlots.delete(slot);
+    return cycle;
+  }
+
+  private publisherCycleForTarget(target: unknown): ActiveCycle | undefined {
+    const slot = physicalSlot(target);
+    if (slot) return this.cycleMap.get(slot);
+    if (typeof target !== 'string') return undefined;
+    const matches = [...this.cycleMap.values()].filter((cycle) => cycle.elementId === target);
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+
+  private mediatePublisherRequest(
+    key: string,
+    arguments_: readonly unknown[]
+  ):
+    | Readonly<{ action: 'forward'; arguments: readonly unknown[] }>
+    | Readonly<{ action: 'suppress' }> {
+    if (key === 'display' && arguments_.length === 1) {
+      const cycle = this.publisherCycleForTarget(arguments_[0]);
+      if (cycle?.suppressPublisherDisplay) {
+        cycle.suppressPublisherDisplay = false;
+        return Object.freeze({ action: 'suppress' });
+      }
+    }
+    if (key !== 'refresh' || arguments_.length > 2) {
+      return Object.freeze({ action: 'forward', arguments: arguments_ });
+    }
+    let requested: readonly unknown[];
+    if (arguments_[0] === undefined) {
+      const all = this.service ? call(this.service, 'getSlots', []) : undefined;
+      if (!Array.isArray(all)) return Object.freeze({ action: 'forward', arguments: arguments_ });
+      requested = all;
+    } else if (Array.isArray(arguments_[0])) {
+      requested = arguments_[0];
+    } else {
+      return Object.freeze({ action: 'forward', arguments: arguments_ });
+    }
+    const forwarded: object[] = [];
+    let suppressed = false;
+    for (const candidate of requested) {
+      const slot = physicalSlot(candidate);
+      const cycle = slot ? this.cycleMap.get(slot) : undefined;
+      if (cycle?.suppressPublisherRefresh) {
+        cycle.suppressPublisherRefresh = false;
+        suppressed = true;
+      } else if (slot) {
+        forwarded.push(slot);
+      }
+    }
+    if (!suppressed) return Object.freeze({ action: 'forward', arguments: arguments_ });
+    if (forwarded.length === 0) return Object.freeze({ action: 'suppress' });
+    return Object.freeze({
+      action: 'forward',
+      arguments: Object.freeze([
+        Object.freeze(forwarded),
+        ...(arguments_.length === 2 ? [arguments_[1]] : []),
+      ]),
+    });
+  }
+
+  private observePublisherCalls(
+    binding: ExternalObject,
+    service: ExternalObject,
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    const installed: Array<() => void> = [];
+    try {
+      for (const [receiver, key] of [
+        [binding, 'defineSlot'],
+        [binding, 'destroySlots'],
+        [binding, 'display'],
+        [service, 'refresh'],
+      ] as const) {
+        const original = member(receiver, key);
+        if (typeof original !== 'function') continue;
+        const prior = Object.getOwnPropertyDescriptor(receiver, key);
+        const notify = (): void => this.notifyNativeMutation();
+        const snapshotDestroy = (arguments_: readonly unknown[]): readonly ActiveCycle[] =>
+          key === 'destroySlots' ? this.snapshotDestroyedCycles(arguments_) : Object.freeze([]);
+        const invalidate = (
+          arguments_: readonly unknown[],
+          result: unknown,
+          destroyed: readonly ActiveCycle[]
+        ): void =>
+          this.invalidateCyclesForPublisherCall(key, arguments_, result, destroyed, callbacks);
+        const invalidateRequest = (arguments_: readonly unknown[]): void =>
+          this.invalidateCyclesForPublisherRequest(key, arguments_, callbacks);
+        const claimPublisherSlot = (arguments_: readonly unknown[]): ActiveCycle | undefined =>
+          this.claimPublisherSlot(arguments_);
+        const mediatePublisherRequest = (arguments_: readonly unknown[]) =>
+          this.mediatePublisherRequest(key, arguments_);
+        const trustedServer = (): boolean => {
+          const current = this.trustedServerCall;
+          if (!current || current[0] !== receiver || current[1] !== key) return false;
+          this.trustedServerCall = undefined;
+          return true;
+        };
+        const wrapper = function (this: unknown, ...arguments_: unknown[]): unknown {
+          const trusted = this === receiver && trustedServer();
+          const destroyed = this === receiver ? snapshotDestroy(arguments_) : Object.freeze([]);
+          let forwardedArguments: readonly unknown[] = arguments_;
+          if (this === receiver && !trusted) {
+            if (key === 'defineSlot') {
+              const claimed = claimPublisherSlot(arguments_);
+              if (claimed) {
+                notify();
+                return claimed.publicCycle[4];
+              }
+            }
+            const mediation = mediatePublisherRequest(arguments_);
+            if (mediation.action === 'suppress') {
+              notify();
+              return undefined;
+            }
+            forwardedArguments = mediation.arguments;
+            invalidateRequest(forwardedArguments);
+          }
+          const result = Reflect.apply(original, this, forwardedArguments);
+          if (this === receiver && !trusted) {
+            invalidate(forwardedArguments, result, destroyed);
+            notify();
+          }
+          return result;
+        };
+        if (
+          !Reflect.defineProperty(receiver, key, {
+            configurable: true,
+            enumerable: prior?.enumerable ?? false,
+            value: wrapper,
+            writable: true,
+          })
+        ) {
+          throw new TypeError('tsjs');
+        }
+        installed.push(() => {
+          const current = Object.getOwnPropertyDescriptor(receiver, key);
+          if (!current || !('value' in current) || current.value !== wrapper) return;
+          if (prior) Reflect.defineProperty(receiver, key, prior);
+          else Reflect.deleteProperty(receiver, key);
+        });
+      }
+    } catch (error) {
+      for (const restore of installed.reverse()) restore();
+      throw error;
+    }
+    this.publisherCallRestorers.push(...installed);
+  }
+
+  private readPhysicalElementId(slot: object): string | undefined {
+    try {
+      const read = member(slot, 'getSlotElementId');
+      if (typeof read !== 'function') return undefined;
+      const value = Reflect.apply(read, slot, []);
+      return typeof value === 'string' && value.length > 0 ? value : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private retireCycle(cycle: ActiveCycle, callbacks: FirstDisplayGoogletagBatchCallbacks): boolean {
+    if (!cycle.bindingState.current) return false;
+    cycle.bindingState.current = false;
+    try {
+      callbacks[4]?.(cycle.publicCycle);
+    } catch {
+      // Binding invalidation remains authoritative when retirement observation fails.
+    }
+    return true;
+  }
+
+  private snapshotDestroyedCycles(arguments_: readonly unknown[]): readonly ActiveCycle[] {
+    try {
+      const targets = arguments_[0];
+      if (targets === undefined) return Object.freeze([...this.cycleMap.values()]);
+      if (!Array.isArray(targets)) return Object.freeze([]);
+      const cycles = new Set<ActiveCycle>();
+      for (let index = 0; index < targets.length; index += 1) {
+        const target = physicalSlot(targets[index]);
+        const cycle = target ? this.cycleMap.get(target) : undefined;
+        if (cycle) cycles.add(cycle);
+      }
+      return Object.freeze([...cycles]);
+    } catch {
+      return Object.freeze([]);
+    }
+  }
+
+  private invalidateCyclesForElement(
+    elementId: string | undefined,
+    replacement: object,
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    if (!elementId) return;
+    for (const cycle of this.cycleMap.values()) {
+      if (cycle.publicCycle[4] !== replacement && cycle.elementId === elementId) {
+        this.retireCycle(cycle, callbacks);
+      }
+    }
+  }
+
+  private invalidateCyclesForPublisherCall(
+    key: string,
+    arguments_: readonly unknown[],
+    result: unknown,
+    destroyed: readonly ActiveCycle[],
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    try {
+      if (key === 'destroySlots' && result === true) {
+        for (const cycle of destroyed) this.retireCycle(cycle, callbacks);
+        return;
+      }
+      if (key === 'defineSlot') {
+        const replacement = physicalSlot(result);
+        const elementId = arguments_[2];
+        if (replacement && typeof elementId === 'string') {
+          this.invalidateCyclesForElement(elementId, replacement, callbacks);
+        }
+      }
+    } catch {
+      // The publisher call already completed; observation cannot alter its result.
+    }
+  }
+
+  private invalidateCyclesForPublisherRequest(
+    key: string,
+    arguments_: readonly unknown[],
+    callbacks: FirstDisplayGoogletagBatchCallbacks
+  ): void {
+    try {
+      const cycles: ActiveCycle[] = [];
+      if (key === 'display') {
+        const requested = arguments_[0];
+        const slot = physicalSlot(requested);
+        const exactCycle = slot ? this.cycleMap.get(slot) : undefined;
+        if (exactCycle) cycles.push(exactCycle);
+        else if (typeof requested === 'string') {
+          for (const cycle of this.cycleMap.values()) {
+            if (cycle.elementId === requested) cycles.push(cycle);
+          }
+        }
+      } else if (key === 'refresh') {
+        const requested = arguments_[0];
+        if (requested === undefined) cycles.push(...this.cycleMap.values());
+        else if (Array.isArray(requested)) {
+          for (const candidate of requested) {
+            const slot = physicalSlot(candidate);
+            const cycle = slot ? this.cycleMap.get(slot) : undefined;
+            if (cycle && !cycles.includes(cycle)) cycles.push(cycle);
+          }
+        }
+      }
+      for (const cycle of cycles) {
+        if (cycle.settled) this.retireCycle(cycle, callbacks);
+        else this.failCycle(cycle, callbacks, 'cycle_unattributable');
+      }
+    } catch {
+      // Publisher calls remain pass-through even if competition observation fails.
+    }
+  }
+
+  private callTrustedServer(
+    receiver: ExternalObject,
+    key: string,
+    arguments_: readonly unknown[]
+  ): unknown {
+    if (this.trustedServerCall) throw new TypeError('tsjs');
+    const marker = Object.freeze([receiver, key] as const);
+    this.trustedServerCall = marker;
+    try {
+      return call(receiver, key, arguments_);
+    } finally {
+      if (this.trustedServerCall === marker) this.trustedServerCall = undefined;
+    }
+  }
+
+  private restorePublisherCalls(): void {
+    for (const restore of this.publisherCallRestorers.reverse()) {
+      try {
+        restore();
+      } catch {
+        // Publisher replacement wins while the old wrapper loses all authority.
+      }
+    }
+    this.publisherCallRestorers.length = 0;
+  }
+
+  private notifyNativeMutation(): void {
+    try {
+      this.options.onNativeMutation?.();
+    } catch {
+      // Mutation observation failure cannot alter the publisher's admitted call.
+    }
+  }
+
+  private captureDiagnosticFact(
+    eventType: FirstDisplayGptDiagnosticEventV1,
+    cycle: ActiveCycle,
+    event: unknown
+  ): void {
+    const responseIdentifier = (() => {
+      const candidate = member(event, 'responseIdentifier');
+      if (typeof candidate !== 'string' || candidate.length === 0) return undefined;
+      if (new TextEncoder().encode(candidate).byteLength > 256) return undefined;
+      for (let index = 0; index < candidate.length; index += 1) {
+        const code = candidate.charCodeAt(index);
+        if (code <= 0x1f || code === 0x7f) return undefined;
+      }
+      return candidate;
+    })();
+    let disposition: FirstDisplayGptFactV1['disposition'] = 'matched';
+    let issueReason: FirstDisplayGptFactV1['issueReason'] = null;
+    let diagnosticCycle: FirstDisplayDiagnosticCycleRecord | undefined;
+    if (eventType === SLOT_REQUESTED) {
+      if (cycle.diagnosticRecords.some((record) => record.state === 'open')) {
+        disposition = 'ambiguous';
+        issueReason = OVERLAPPING_REQUEST_CYCLES;
+      } else if (cycle.nextDiagnosticCycleOrdinal > MAX_U32) {
+        disposition = 'unmatched';
+        issueReason = INVALID_EVENT_ORDER;
+      } else {
+        if (cycle.diagnosticRecords.length >= 10) {
+          const pruneIndex = cycle.diagnosticRecords.findIndex((record) => record.state !== 'open');
+          if (pruneIndex < 0) {
+            disposition = 'ambiguous';
+            issueReason = OVERLAPPING_REQUEST_CYCLES;
+          } else {
+            cycle.diagnosticRecords.splice(pruneIndex, 1);
+            cycle.unknownPriorCycle = true;
+          }
+        }
+        if (disposition === 'matched') {
+          diagnosticCycle = {
+            ordinal: cycle.nextDiagnosticCycleOrdinal,
+            ...(responseIdentifier === undefined ? {} : { responseIdentifier }),
+            seen: new Set([SLOT_REQUESTED]),
+            state: 'open',
+          };
+          cycle.nextDiagnosticCycleOrdinal += 1;
+          cycle.diagnosticRecords.push(diagnosticCycle);
+        }
+      }
+    } else {
+      let candidates: FirstDisplayDiagnosticCycleRecord[];
+      if (responseIdentifier !== undefined) {
+        candidates = cycle.diagnosticRecords.filter(
+          (record) =>
+            record.responseIdentifier === responseIdentifier && !record.seen.has(eventType)
+        );
+        if (candidates.length === 0) {
+          const unboundOpen = cycle.diagnosticRecords.filter(
+            (record) =>
+              record.state === 'open' &&
+              record.responseIdentifier === undefined &&
+              !record.seen.has(eventType)
+          );
+          if (unboundOpen.length === 1) candidates = unboundOpen;
+        }
+      } else {
+        candidates = cycle.diagnosticRecords.filter(
+          (record) => record.state === 'open' && !record.seen.has(eventType)
+        );
+        if (candidates.length === 0 && !cycle.unknownPriorCycle) {
+          candidates = cycle.diagnosticRecords.filter((record) => !record.seen.has(eventType));
+        }
+      }
+      if (candidates.length === 1) {
+        diagnosticCycle = candidates[0];
+      } else if (candidates.length > 1) {
+        disposition = 'ambiguous';
+        issueReason = OVERLAPPING_REQUEST_CYCLES;
+      } else {
+        const duplicate = cycle.diagnosticRecords.find(
+          (record) =>
+            record.seen.has(eventType) &&
+            (responseIdentifier === undefined ||
+              record.responseIdentifier === responseIdentifier ||
+              record.responseIdentifier === undefined)
+        );
+        if (duplicate) {
+          diagnosticCycle = duplicate;
+          issueReason = INVALID_EVENT_ORDER;
+        } else {
+          disposition = 'unmatched';
+          issueReason = cycle.unknownPriorCycle ? 'unknown_prior_cycle' : 'no_request_cycle';
+        }
+      }
+      if (diagnosticCycle && issueReason !== INVALID_EVENT_ORDER) {
+        diagnosticCycle.seen.add(eventType);
+        if (diagnosticCycle.responseIdentifier === undefined && responseIdentifier !== undefined) {
+          diagnosticCycle.responseIdentifier = responseIdentifier;
+        }
+        if (eventType === SLOT_RENDER_ENDED) diagnosticCycle.state = 'completed';
+      }
+    }
+    if (this.options.diagnosticsActive !== true) return;
+    let observedAtMs: number;
+    try {
+      observedAtMs = this.options.browser.performance.now();
+      if (!Number.isFinite(observedAtMs) || observedAtMs < 0) {
+        this.incrementDiagnosticDrops();
+        return;
+      }
+    } catch {
+      this.incrementDiagnosticDrops();
+      return;
+    }
+    const size = member(event, 'size');
+    const renderedSize =
+      eventType === SLOT_RENDER_ENDED &&
+      Array.isArray(size) &&
+      size.length === 2 &&
+      size.every(
+        (dimension) =>
+          typeof dimension === 'number' &&
+          Number.isInteger(dimension) &&
+          dimension >= 1 &&
+          dimension <= 4096
+      )
+        ? Object.freeze([size[0] as number, size[1] as number] as const)
+        : null;
+    const optionalBoolean = (key: string): boolean | null => {
+      const value = member(event, key);
+      return typeof value === 'boolean' ? value : null;
+    };
+    const visibility = member(event, 'inViewPercentage');
+    const requestedSlotSizes =
+      eventType === SLOT_REQUESTED && disposition === 'matched' && !cycle.settled
+        ? Object.freeze(
+            cycle.publicCycle[5].formats
+              .slice(0, 16)
+              .map((size) => Object.freeze([size[0], size[1]] as const))
+          )
+        : null;
+    const fact: Readonly<FirstDisplayGptFactV1> = Object.freeze({
+      version: 1,
+      event: eventType,
+      token: cycle.publicCycle[7],
+      runtimeSlotNumber: cycle.runtimeSlotNumber,
+      cycleOrdinal: disposition === 'matched' ? (diagnosticCycle?.ordinal ?? null) : null,
+      disposition,
+      issueReason,
+      capturedAtMs: observedAtMs,
+      elementId: cycle.elementId,
+      adUnitPath: cycle.publicCycle[5].gamUnitPath,
+      requestedSlotSizes,
+      isEmpty: eventType === SLOT_RENDER_ENDED ? optionalBoolean('isEmpty') : null,
+      renderedSize,
+      isBackfill: eventType === SLOT_RENDER_ENDED ? optionalBoolean('isBackfill') : null,
+      slotContentChanged:
+        eventType === SLOT_RENDER_ENDED ? optionalBoolean('slotContentChanged') : null,
+      visibilityPercent:
+        eventType === SLOT_VISIBILITY_CHANGED &&
+        typeof visibility === 'number' &&
+        Number.isFinite(visibility) &&
+        visibility >= 0 &&
+        visibility <= 100
+          ? visibility
+          : null,
+    });
+    if (this.encodedBytes(fact) > MAX_DIAGNOSTIC_FACT_BYTES) {
+      this.incrementDiagnosticDrops();
+      return;
+    }
+    const overflow = this.diagnosticFacts.length >= MAX_DIAGNOSTIC_FACTS;
+    const nextFacts = overflow
+      ? [...this.diagnosticFacts.slice(1), fact]
+      : [...this.diagnosticFacts, fact];
+    const nextOverflow = overflow
+      ? Math.min(MAX_U32, this.diagnosticFactOverflow + 1)
+      : this.diagnosticFactOverflow;
+    if (
+      this.encodedBytes({
+        facts: nextFacts,
+        overflowCount: nextOverflow,
+        dropCount: this.diagnosticFactDrops,
+      }) > MAX_DIAGNOSTIC_SECTION_BYTES
+    ) {
+      this.incrementDiagnosticDrops();
+      return;
+    }
+    this.diagnosticFacts.splice(0, this.diagnosticFacts.length, ...nextFacts);
+    this.diagnosticFactOverflow = nextOverflow;
+  }
+
+  private encodedBytes(value: unknown): number {
+    try {
+      return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+    } catch {
+      return Number.POSITIVE_INFINITY;
+    }
+  }
+
+  private incrementDiagnosticDrops(): void {
+    this.diagnosticFactDrops = Math.min(MAX_U32, this.diagnosticFactDrops + 1);
+  }
+
+  private invalidateTargeting(slot: object, key: string | undefined): void {
+    for (const restoration of this.targetingRestorers) {
+      if (restoration.slot === slot && (key === undefined || restoration.key === key)) {
+        restoration.valid = false;
+      }
+    }
+  }
+
+  private restorePublisherTargeting(restoration: TargetingRestorer): void {
+    if (!restoration.valid) return;
+    const observer = this.targetingObservers.get(restoration.slot);
+    if (observer && !observer.isCurrent()) {
+      this.invalidateTargeting(restoration.slot, undefined);
+      return;
+    }
+    if (!restoration.valid) return;
+    const current = call(restoration.slot, 'getTargeting', [restoration.key]);
+    if (!restoration.valid) return;
+    if (observer && !observer.isCurrent()) {
+      this.invalidateTargeting(restoration.slot, undefined);
+      return;
+    }
+    if (
+      !restoration.valid ||
+      !Array.isArray(current) ||
+      current.length !== 1 ||
+      current[0] !== restoration.installed
+    ) {
+      return;
+    }
+    if (restoration.prior.length === 0) {
+      this.writeTargeting(restoration.slot, 'clearTargeting', [restoration.key]);
+    } else {
+      this.writeTargeting(restoration.slot, 'setTargeting', [restoration.key, restoration.prior]);
+    }
+  }
+
+  private writeTargeting(
+    slot: object,
+    operation: 'clearTargeting' | 'setTargeting',
+    arguments_: readonly unknown[]
+  ): unknown {
+    const write: TargetingWrite = { consumed: false, operation, slot };
+    this.targetingWrites.push(write);
+    try {
+      return call(slot, operation, arguments_);
+    } finally {
+      const index = this.targetingWrites.lastIndexOf(write);
+      if (index >= 0) this.targetingWrites.splice(index, 1);
+    }
+  }
+
+  private consumeTargetingWrite(
+    slot: object,
+    operation: 'clearTargeting' | 'setTargeting'
+  ): boolean {
+    const write = this.targetingWrites[this.targetingWrites.length - 1];
+    if (!write || write.consumed || write.slot !== slot || write.operation !== operation) {
+      return false;
+    }
+    write.consumed = true;
+    return true;
+  }
+
+  private invalidateStaleTargetingObservers(): void {
+    for (const [slot, observer] of this.targetingObservers) {
+      if (!observer.isCurrent()) this.invalidateTargeting(slot, undefined);
+    }
+  }
+
+  private restoreTargetingObservers(): void {
+    for (const [slot, observer] of this.targetingObservers) {
+      if (!observer.restore()) this.invalidateTargeting(slot, undefined);
+    }
+    this.targetingObservers.clear();
+  }
+
+  private captureRetainedTargeting(
+    retainedSlots: ReadonlySet<object>
+  ): Map<object, TargetingRestorer[]> {
+    const captured = new Map<object, TargetingRestorer[]>();
+    for (const slot of retainedSlots) {
+      const observer = this.targetingObservers.get(slot);
+      if (observer && !observer.isCurrent()) this.invalidateTargeting(slot, undefined);
+      const restorations: TargetingRestorer[] = [];
+      for (const restoration of this.targetingRestorers) {
+        if (!restoration.valid || restoration.slot !== slot) continue;
+        let current: unknown;
+        try {
+          current = call(slot, 'getTargeting', [restoration.key]);
+        } catch {
+          continue;
+        }
+        if (observer && !observer.isCurrent()) {
+          this.invalidateTargeting(slot, undefined);
+          break;
+        }
+        if (
+          restoration.valid &&
+          Array.isArray(current) &&
+          current.length === 1 &&
+          current[0] === restoration.installed
+        ) {
+          restorations.push(restoration);
+        }
+      }
+      captured.set(slot, restorations);
+    }
+    return captured;
+  }
+
+  private failRows(
+    rows: readonly (readonly [FirstDisplayProjectionBidV1, FirstDisplayProjectionSlotV1])[],
+    callbacks: FirstDisplayGoogletagBatchCallbacks,
+    reason: FirstDisplayGptFailureReason
+  ): void {
+    for (const row of rows) {
+      try {
+        callbacks[1](row[1].slot, reason);
+      } catch {
+        // One consumer cannot prevent independent slot settlement.
+      }
+    }
+  }
+
+  private timer(callback: () => void, delayMs: number): unknown {
+    const state: { fired: boolean; handle?: unknown } = { fired: false };
+    const handle = this.options.setTimer(() => {
+      state.fired = true;
+      if (state.handle !== undefined) this.timers.delete(state.handle);
+      if (!this.disposed) callback();
+    }, delayMs);
+    state.handle = handle;
+    if (!state.fired) this.timers.add(handle);
+    return handle;
+  }
+
+  private clearOwnedTimer(handle: unknown): void {
+    if (!this.timers.delete(handle)) return;
+    try {
+      this.options.clearTimer(handle);
+    } catch {
+      // The generation latch prevents a hostile timer from restoring authority.
+    }
+  }
+
+  private removePendingCommand(): void {
+    const command = this.command;
+    this.command = undefined;
+    if (!command || !this.commandQueue) return;
+    try {
+      const index = this.commandQueueIndex;
+      if (index >= 0 && this.commandQueue[index] === command) this.commandQueue.splice(index, 1);
+      else {
+        const current = this.commandQueue.indexOf(command);
+        if (current >= 0) this.commandQueue.splice(current, 1);
+      }
+    } catch {
+      // A poisoned publisher queue cannot keep this generation live.
+    }
+    this.commandQueue = undefined;
+    this.commandQueueIndex = -1;
+  }
+}
+
+/** Create the sole provisional adapter for one immutable projected GPT winner batch. */
+export function createFirstDisplayGoogletagBatch(
+  options: FirstDisplayGoogletagBatchOptions
+): FirstDisplayGoogletagBatch {
+  const owner = new FirstDisplayGoogletagBatchOwner(options);
+  return Object.freeze({
+    start: (callbacks: FirstDisplayGoogletagBatchCallbacks) => owner.start(callbacks),
+    closeIngress: (committedSlotIds: readonly string[]) => owner.closeIngress(committedSlotIds),
+    captureHandoff: () => owner.captureHandoff(),
+    captureDiagnosticsHandoff: () => owner.captureDiagnosticsHandoff(),
+    detachCommittedSlots: (slotIds: readonly string[]) => owner.detachCommittedSlots(slotIds),
+    dispose: () => owner.dispose(),
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/agent.ts b/crates/trusted-server-js/lib/src/first_display/agent.ts
new file mode 100644
index 000000000..ecfc30060
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/agent.ts
@@ -0,0 +1,927 @@
+import type { BootFailureReason } from '../kernel/fallback';
+import type { FirstDisplayNavigationIdentityIssuer } from '../kernel/identity';
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+import type {
+  FirstDisplayGptDiagnosticEventV1,
+  FirstDisplayGptDiagnosticsV1,
+} from '../shared/takeover';
+import type { FirstDisplaySliceActivationContext } from '../shared/first_display_transaction';
+import type {
+  FinalizedFirstDisplayHandoffV1,
+  FirstDisplayAgentCaptureFinalizerV1,
+} from '../shared/first_display_handoff';
+
+import type {
+  FirstDisplayGoogletagBatchInput,
+  FirstDisplayGptBoundCycleV1,
+  FirstDisplayGptHandoffCycleV1,
+} from './adapters/googletag';
+import type { FirstDisplayRenderBridgeCapabilityV1 } from './driver';
+import type { FirstDisplayApsProtocolV1 } from './leaf/aps_protocol';
+import type { FirstDisplayGptCapabilityV1, FirstDisplayGptProtocolV1 } from './leaf/gpt_protocol';
+import type {
+  FirstDisplayRenderOwnerOptionsV1,
+  FirstDisplayRenderOwnerProtocolV1,
+} from './render_journal';
+import type {
+  FirstDisplaySliceHost,
+  InitialSliceInstaller,
+  OptionalFirstDisplaySliceId,
+} from './slices/definition';
+import {
+  acceptServerFirstDisplayBatchV1,
+  type FirstDisplayAgentBatchV1,
+  type FirstDisplayAuctionProtocolId,
+  type FirstDisplayBatchOutcomeV1,
+} from './leaf/projection';
+
+const MAX_U32 = 4_294_967_295;
+const BUNDLE_PARTIAL: BootFailureReason = 'bundle_partial';
+const AUCTION_PROTOCOLS = ['aps', 'gpt', 'prebid'] as const;
+const SLICE_PROTOCOLS = ['render_owner', ...AUCTION_PROTOCOLS] as const;
+const ACTION_KINDS = new Set(['gpt_adm', 'aps']);
+const TERMINAL_RESULTS = new Set(['accepted', 'failed', 'cancelled']);
+
+export type {
+  FirstDisplayAuctionProtocolId,
+  FirstDisplayBatchOutcomeV1,
+  FirstDisplayBatchV1,
+  FirstDisplayProjectedKind,
+} from './leaf/projection';
+export type FirstDisplayTerminalResult = 'accepted' | 'failed' | 'cancelled';
+export type FirstDisplayAgentState =
+  'ready' | 'active' | 'terminal' | 'painted' | 'failed' | 'disposed';
+
+export interface FirstDisplayDriver {
+  readonly start: (
+    outcomes: readonly FirstDisplayBatchOutcomeV1[],
+    onFirstAction: () => boolean,
+    onTerminal: (slotId: string, result: FirstDisplayTerminalResult, reason: string | null) => void
+  ) => void;
+  readonly sealTsAdmission: () => void;
+  readonly closeIngress: () => boolean;
+  readonly captureHandoff: () => FirstDisplayDriverHandoffV1 | undefined;
+  readonly detachCommittedArtifacts: () => boolean;
+  readonly sweepCommittedArtifacts: () => number;
+  readonly dispose: () => void;
+}
+
+export interface FirstDisplayDriverHandoffV1 {
+  readonly artifacts: readonly Readonly<{
+    hostPosition: string | null;
+    hostPositionPriority: string | null;
+    identity: object;
+    kind: 'gpt_adm' | 'aps';
+    owner: 'trusted_server' | 'publisher';
+    slotId: string;
+    token: string;
+  }>[];
+  readonly cycles: readonly FirstDisplayGptHandoffCycleV1[];
+  readonly diagnosticCycles: readonly Readonly<{
+    nextCycleOrdinal: number;
+    quarantines: readonly string[];
+    records: readonly Readonly<{
+      ordinal: number;
+      responseIdentifier: string | null;
+      seen: readonly FirstDisplayGptDiagnosticEventV1[];
+      state: 'open' | 'completed' | 'retired';
+    }>[];
+    slotId: string;
+    token: string;
+    unknownPriorCycle: boolean;
+  }>[];
+  readonly clockEpochMs: number;
+  readonly gptDiagnostics: Readonly<FirstDisplayGptDiagnosticsV1>;
+  readonly identities: readonly object[];
+  readonly nextReservationOrdinal: number;
+  readonly nextTraceTokenOrdinal: number;
+  readonly nextTicketOrdinal: number;
+  readonly tombstones: readonly Readonly<{
+    kind: 'reservation' | 'ticket';
+    value: string;
+    expiresAtMs: number;
+    ordinal: number;
+  }>[];
+}
+
+export interface FirstDisplayPaintScheduler {
+  readonly hidden: () => boolean;
+  readonly requestFrame: (callback: () => void) => void;
+  readonly scheduleHidden: (callback: () => void) => void;
+}
+
+export interface FirstDisplayAgentOptions {
+  readonly batch: unknown;
+  readonly production?: Readonly<{
+    gpt?: FirstDisplayGptProtocolV1;
+    gptInput: readonly [
+      browser: FirstDisplayGoogletagBatchInput[0],
+      clearTimer: FirstDisplayGoogletagBatchInput[1],
+      document: FirstDisplayGoogletagBatchInput[2],
+      setTimer: FirstDisplayGoogletagBatchInput[3],
+      diagnosticsActive?: FirstDisplayGoogletagBatchInput[5],
+      onNativeMutation?: FirstDisplayGoogletagBatchInput[6],
+    ];
+    renderer?: FirstDisplayRenderBridgeCapabilityV1;
+  }>;
+  readonly startedAtMs: number;
+  readonly performance: Readonly<{
+    mark: (name: string) => void;
+    measure?: (name: string, startMark: string, endMark: string) => void;
+  }>;
+  readonly paint: FirstDisplayPaintScheduler;
+  readonly onProtectedPaint: () => void;
+  readonly onSettled: () => void;
+  readonly onFailure: (reason: BootFailureReason) => void;
+  readonly mutationDocument?: Document;
+  readonly initialMutationRevision?: number;
+  readonly now?: () => number;
+  readonly identityIssuer?: FirstDisplayNavigationIdentityIssuer;
+  readonly parserState?: () => readonly (readonly [
+    string,
+    readonly (readonly [string, string | number | boolean | null])[],
+  ])[];
+  readonly handoff?: Readonly<{
+    releaseId: string;
+    generation: number;
+    integrationConfigDigest: string;
+    slices: readonly FirstDisplaySliceId[];
+  }>;
+}
+
+/** Bootstrap-owned dependencies supplied only to the release-bound base component. */
+export interface FirstDisplayAgentRegistrationHostV1 {
+  readonly options: FirstDisplayAgentOptions &
+    Readonly<{
+      gptInput: readonly [
+        browser: FirstDisplayGoogletagBatchInput[0],
+        clearTimer: FirstDisplayGoogletagBatchInput[1],
+        document: FirstDisplayGoogletagBatchInput[2],
+        setTimer: FirstDisplayGoogletagBatchInput[3],
+        diagnosticsActive?: FirstDisplayGoogletagBatchInput[5],
+      ];
+      onAgentReady?: (agent: FirstDisplayAgent) => void;
+    }>;
+  readonly sliceBindings: (
+    id: string,
+    observe: (key: unknown, value: unknown) => void,
+    register: ((protocol: unknown) => () => void) | undefined
+  ) => readonly [bindings: unknown, config: unknown];
+}
+
+function createBrowserMessageChannel(
+  browser: Window
+): ReturnType<FirstDisplayRenderOwnerOptionsV1[2]> {
+  const constructor = Reflect.get(browser, 'MessageChannel');
+  if (typeof constructor !== 'function') {
+    throw new TypeError('tsjs');
+  }
+  const channel = Reflect.construct(constructor, []) as Record<PropertyKey, unknown>;
+  const port1 = Reflect.get(channel, 'port1');
+  const port2 = Reflect.get(channel, 'port2');
+  if (typeof port1 !== 'object' || port1 === null || typeof port2 !== 'object' || port2 === null) {
+    throw new TypeError('tsjs');
+  }
+  return { port1, port2 } as ReturnType<FirstDisplayRenderOwnerOptionsV1[2]>;
+}
+
+function fillBrowserRandom(browser: Window, bytes: Uint8Array): void {
+  const crypto = Reflect.get(browser, 'crypto');
+  const getRandomValues =
+    typeof crypto === 'object' && crypto !== null
+      ? Reflect.get(crypto, 'getRandomValues')
+      : undefined;
+  if (typeof getRandomValues !== 'function') throw new TypeError('tsjs');
+  Reflect.apply(getRandomValues, crypto, [bytes]);
+}
+
+function readBrowserNow(browser: Window): number {
+  const performance = Reflect.get(browser, 'performance');
+  const now =
+    typeof performance === 'object' && performance !== null
+      ? Reflect.get(performance, 'now')
+      : undefined;
+  if (typeof now !== 'function') throw new TypeError('tsjs');
+  return Reflect.apply(now, performance, []) as number;
+}
+
+export interface PreparedFirstDisplayBaseV1 {
+  readonly activate: (context: FirstDisplaySliceActivationContext) => void;
+  readonly sliceHost: FirstDisplaySliceHost;
+}
+
+export interface FirstDisplayAgent {
+  readonly state: FirstDisplayAgentState;
+  readonly mutationRevision: number;
+  readonly initialDisplayCommitted: boolean;
+  readonly start: () => boolean;
+  readonly observeNativeMutation: () => boolean;
+  readonly finalizeHandoff: (
+    finalize: FirstDisplayAgentCaptureFinalizerV1
+  ) => FinalizedFirstDisplayHandoffV1 | undefined;
+  readonly detachCommittedArtifacts: () => boolean;
+  readonly dispose: () => void;
+}
+
+type FirstDisplayRegisteredProtocolId = FirstDisplayAuctionProtocolId | 'render_owner';
+
+function protocolIdentity(
+  candidate: unknown,
+  expected: FirstDisplayRegisteredProtocolId,
+  exact = true
+): boolean {
+  try {
+    const length = exact ? 2 : 3;
+    if (
+      !Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Array.prototype ||
+      !Object.isFrozen(candidate) ||
+      candidate.length !== length ||
+      Reflect.ownKeys(candidate).length !== length + 1
+    ) {
+      return false;
+    }
+    for (let index = 0; index < length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+      if (!descriptor?.enumerable || !('value' in descriptor)) return false;
+    }
+    return candidate[0] === 1 && candidate[1] === expected && (exact || candidate[2] !== undefined);
+  } catch {
+    return false;
+  }
+}
+
+function fullProtocolIdentity(
+  candidate: unknown,
+  expected: FirstDisplayRegisteredProtocolId
+): boolean {
+  return protocolIdentity(candidate, expected, false);
+}
+
+function sameCycle(
+  expected: FirstDisplayGptBoundCycleV1,
+  candidate: FirstDisplayGptBoundCycleV1
+): boolean {
+  return candidate === expected;
+}
+
+class FirstDisplayAgentOwner implements FirstDisplayAgent {
+  private readonly agentBatch: FirstDisplayAgentBatchV1 | undefined;
+  private readonly slotResults = new Map<
+    string,
+    FirstDisplayTerminalResult | 'no_bid' | 'failed' | 'cancelled'
+  >();
+  private readonly pending = new Set<string>();
+  private readonly reasons = new Map<string, string | null>();
+  private handoffCapsule: FinalizedFirstDisplayHandoffV1['capsule'] | undefined;
+  private stateValue: FirstDisplayAgentState = 'ready';
+  private mutationObserver: MutationObserver | undefined;
+  private observedMutationRevision: number;
+  private displayWasCommitted = false;
+  private disposedDriver = false;
+  private failed = false;
+  private actionStarted = false;
+  private handoffFinalized = false;
+  private committedArtifactsDetached = false;
+  private lastTimingMs: number;
+  private firstActionAtMs: number | null = null;
+  private terminalAtMs: number | undefined;
+  private paintAtMs: number | undefined;
+  private nextTraceSequence = 1;
+  private readonly acceptedTrace = new Map<
+    string,
+    Readonly<{ atMs: number; historySequence: number }>
+  >();
+  private readonly bound = new Map<string, FirstDisplayGptBoundCycleV1>();
+  private productionBatch: FirstDisplayGptCapabilityV1 | undefined;
+
+  public constructor(private readonly options: FirstDisplayAgentOptions) {
+    this.agentBatch = acceptServerFirstDisplayBatchV1(options.batch);
+    this.observedMutationRevision = options.initialMutationRevision ?? 0;
+    this.lastTimingMs = options.startedAtMs;
+    this.installNativeMutationIngress();
+  }
+
+  public get state(): FirstDisplayAgentState {
+    return this.stateValue;
+  }
+
+  public get mutationRevision(): number {
+    return this.observedMutationRevision;
+  }
+
+  public get initialDisplayCommitted(): boolean {
+    return this.displayWasCommitted;
+  }
+
+  public start(): boolean {
+    if (this.stateValue !== 'ready') return false;
+    if (!this.agentBatch) return this.fail('abi_mismatch');
+    const started = this.readTiming();
+    if (started === undefined || started - this.options.startedAtMs >= 10_000) {
+      return this.fail(BUNDLE_PARTIAL);
+    }
+
+    let actionCount = 0;
+    const outcomes = this.agentBatch[2];
+    const projection = this.agentBatch[3];
+    for (let index = 0; index < outcomes.length; index += 1) {
+      const outcome = outcomes[index]!;
+      if (ACTION_KINDS.has(outcome[1])) {
+        this.pending.add(outcome[0]);
+        actionCount += 1;
+      } else {
+        this.slotResults.set(outcome[0], outcome[1] as 'no_bid' | 'failed' | 'cancelled');
+        const decision = projection.auction.results[index];
+        this.reasons.set(outcome[0], decision?.outcome === 'failed' ? decision.reason : null);
+      }
+    }
+    this.stateValue = 'active';
+    if (actionCount === 0) {
+      this.recordTerminal();
+      return true;
+    }
+    try {
+      if (!this.startProduction()) {
+        throw new TypeError('tsjs');
+      }
+      return true;
+    } catch {
+      return this.fail(BUNDLE_PARTIAL);
+    }
+  }
+
+  public observeNativeMutation(): boolean {
+    if (this.stateValue !== 'painted' || this.failed) return false;
+    if (this.observedMutationRevision >= MAX_U32) return this.fail(BUNDLE_PARTIAL);
+    this.observedMutationRevision += 1;
+    return true;
+  }
+
+  public finalizeHandoff(
+    finalize: FirstDisplayAgentCaptureFinalizerV1
+  ): FinalizedFirstDisplayHandoffV1 | undefined {
+    if (
+      this.stateValue !== 'painted' ||
+      this.failed ||
+      !this.options.handoff ||
+      this.handoffFinalized ||
+      typeof finalize !== 'function'
+    ) {
+      return undefined;
+    }
+    try {
+      if (!this.closeDriverIngress()) throw new TypeError('tsjs');
+      this.closeNativeMutationIngress();
+      const currentTimeMs = this.readTiming();
+      if (
+        currentTimeMs === undefined ||
+        !this.agentBatch ||
+        this.terminalAtMs === undefined ||
+        this.paintAtMs === undefined
+      ) {
+        throw new TypeError('tsjs');
+      }
+      const finalized = finalize([
+        this.options.handoff,
+        Object.freeze([this.agentBatch[0], this.agentBatch[2]]),
+        this.slotResults,
+        this.reasons,
+        this.acceptedTrace,
+        this.options.parserState?.() ?? [],
+        this.productionBatch?.[2](),
+        this.productionBatch?.[3](),
+        this.options.production?.renderer?.[7](),
+        [
+          this.options.startedAtMs,
+          this.firstActionAtMs,
+          this.terminalAtMs,
+          this.paintAtMs,
+          currentTimeMs,
+        ],
+        this.nextTraceSequence,
+        this.observedMutationRevision,
+      ]);
+      if (!finalized) throw new TypeError('tsjs');
+      this.handoffCapsule = finalized.capsule;
+      this.handoffFinalized = true;
+      return finalized;
+    } catch {
+      this.fail(BUNDLE_PARTIAL);
+      return undefined;
+    }
+  }
+
+  public detachCommittedArtifacts(): boolean {
+    if (
+      !this.handoffFinalized ||
+      this.committedArtifactsDetached ||
+      this.stateValue !== 'painted'
+    ) {
+      return false;
+    }
+    if (!this.detachDriverArtifacts()) return false;
+    this.committedArtifactsDetached = true;
+    return true;
+  }
+
+  public dispose(): void {
+    if (this.stateValue === 'disposed') return;
+    this.stateValue = 'disposed';
+    this.handoffCapsule?.clear();
+    this.handoffCapsule = undefined;
+    this.disposeDriver();
+    this.pending.clear();
+  }
+
+  private settle(slotId: string, result: FirstDisplayTerminalResult, reason: string | null): void {
+    if (!this.actionStarted) {
+      this.fail(BUNDLE_PARTIAL);
+      return;
+    }
+    if (this.stateValue !== 'active') return;
+    if (
+      typeof result !== 'string' ||
+      !TERMINAL_RESULTS.has(result) ||
+      (result === 'accepted'
+        ? reason !== null
+        : typeof reason !== 'string' || reason.length === 0 || reason.length > 256)
+    ) {
+      this.fail(BUNDLE_PARTIAL);
+      return;
+    }
+    if (!this.pending.has(slotId)) {
+      if (!this.slotResults.has(slotId)) this.fail(BUNDLE_PARTIAL);
+      return;
+    }
+    if (result === 'accepted') {
+      const atMs = this.readTiming();
+      if (atMs === undefined || this.nextTraceSequence > 4_294_967_295) {
+        this.fail(BUNDLE_PARTIAL);
+        return;
+      }
+      this.acceptedTrace.set(
+        slotId,
+        Object.freeze({ atMs, historySequence: this.nextTraceSequence })
+      );
+      this.nextTraceSequence += 1;
+    }
+    this.pending.delete(slotId);
+    this.slotResults.set(slotId, result);
+    this.reasons.set(slotId, reason);
+    if (result === 'accepted') this.displayWasCommitted = true;
+    if (this.pending.size === 0) this.recordTerminal();
+  }
+
+  private recordTerminal(): void {
+    if (this.stateValue !== 'active' || this.pending.size !== 0) return;
+    this.stateValue = 'terminal';
+    this.terminalAtMs = this.readTiming();
+    if (this.terminalAtMs === undefined) {
+      this.fail(BUNDLE_PARTIAL);
+      return;
+    }
+    try {
+      this.options.onSettled();
+    } catch {
+      this.fail(BUNDLE_PARTIAL);
+      return;
+    }
+    this.mark('tsjs:first-display-terminal');
+    this.scheduleProtectedPaint(2);
+  }
+
+  private recordFirstAction(): boolean {
+    if (this.stateValue !== 'active' || this.actionStarted) return this.fail(BUNDLE_PARTIAL);
+    const firstDisplayMs = this.readTiming();
+    if (firstDisplayMs === undefined || firstDisplayMs - this.options.startedAtMs >= 10_000) {
+      return this.fail(BUNDLE_PARTIAL);
+    }
+    this.actionStarted = true;
+    this.firstActionAtMs = firstDisplayMs;
+    this.mark('tsjs:first-display');
+    try {
+      this.options.performance.measure?.(
+        'tsjs:boot-to-first-display',
+        'tsjs:bids-script',
+        'tsjs:first-display'
+      );
+    } catch {
+      // Timing observability cannot alter display ownership.
+    }
+    return true;
+  }
+
+  private scheduleProtectedPaint(remaining: number): void {
+    const next = (): void => {
+      if (this.stateValue !== 'terminal') return;
+      if (remaining > 1) {
+        this.scheduleProtectedPaint(remaining - 1);
+        return;
+      }
+      try {
+        this.options.production?.renderer?.[5]();
+      } catch {
+        this.fail(BUNDLE_PARTIAL);
+        return;
+      }
+      this.stateValue = 'painted';
+      this.paintAtMs = this.readTiming();
+      if (this.paintAtMs === undefined) {
+        this.fail(BUNDLE_PARTIAL);
+        return;
+      }
+      this.mark('tsjs:first-display-paint');
+      try {
+        this.options.onProtectedPaint();
+      } catch {
+        this.fail(BUNDLE_PARTIAL);
+      }
+    };
+    try {
+      if (this.options.paint.hidden()) this.options.paint.scheduleHidden(next);
+      else this.options.paint.requestFrame(next);
+    } catch {
+      this.fail(BUNDLE_PARTIAL);
+    }
+  }
+
+  private mark(name: string): void {
+    try {
+      this.options.performance.mark(name);
+    } catch {
+      // Timing observability cannot alter display ownership.
+    }
+  }
+
+  private readTiming(): number | undefined {
+    try {
+      const value = this.options.now?.() ?? this.options.startedAtMs;
+      if (!Number.isFinite(value) || value < 0 || value < this.lastTimingMs) return undefined;
+      this.lastTimingMs = value;
+      return value;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private startProduction(): boolean {
+    const production = this.options.production;
+    const batch = this.agentBatch;
+    const renderer = production?.renderer;
+    if (!production || !batch || !renderer) return false;
+    const gptBatch = production.gpt?.[2](
+      Object.freeze([
+        production.gptInput[0],
+        production.gptInput[1],
+        production.gptInput[2],
+        production.gptInput[3],
+        batch[3],
+        production.gptInput[4],
+        production.gptInput[5],
+      ])
+    );
+    if (!gptBatch) return false;
+    this.productionBatch = gptBatch;
+    return gptBatch[0]([
+      (cycle): void => {
+        const action = batch[2].find(([slotId]) => slotId === cycle[6]);
+        const bidIndex = batch[3].bids.indexOf(cycle[0]);
+        const placement = batch[3].slots.find(({ slot }) => slot === cycle[6]);
+        if (
+          !action ||
+          !ACTION_KINDS.has(action[1]) ||
+          this.bound.has(cycle[6]) ||
+          bidIndex < 0 ||
+          batch[3].bids[bidIndex]?.slot !== cycle[6] ||
+          cycle[5] !== placement
+        ) {
+          this.settle(cycle[6], 'failed', 'gpt_request_failed');
+          return;
+        }
+        this.bound.set(cycle[6], cycle);
+        if (!renderer[0](cycle, (result, reason) => this.settle(cycle[6], result, reason))) {
+          this.settle(cycle[6], 'failed', 'internal_error');
+        }
+      },
+      (slotId, reason): void => {
+        const cycle = this.bound.get(slotId);
+        if (cycle) renderer[2](cycle);
+        this.settle(slotId, 'failed', reason);
+      },
+      () => this.recordFirstAction(),
+      (cycle, result): void => {
+        const exact = this.bound.get(cycle[6]);
+        if (!exact || !sameCycle(exact, cycle) || !renderer[1](exact, result)) {
+          this.settle(cycle[6], 'failed', 'gpt_request_failed');
+        }
+      },
+      (cycle): void => {
+        const exact = this.bound.get(cycle[6]);
+        if (exact && sameCycle(exact, cycle)) renderer[3](exact);
+      },
+    ]);
+  }
+
+  private acceptedSlotIds(): string[] {
+    return [...this.slotResults.entries()]
+      .filter(([, result]) => result === 'accepted')
+      .map(([slotId]) => slotId);
+  }
+
+  private closeDriverIngress(): boolean {
+    const production = this.options.production;
+    if (!production) return false;
+    const accepted = this.acceptedSlotIds();
+    return (
+      (!this.productionBatch || this.productionBatch[1](accepted)) &&
+      (!production.renderer || production.renderer[6]())
+    );
+  }
+
+  private detachDriverArtifacts(): boolean {
+    const production = this.options.production;
+    if (!production) return false;
+    const accepted = this.acceptedSlotIds();
+    return (
+      (!this.productionBatch || this.productionBatch[4](accepted)) &&
+      (!production.renderer || production.renderer[8]())
+    );
+  }
+
+  private fail(reason: BootFailureReason): false {
+    if (this.failed || this.stateValue === 'disposed') return false;
+    this.failed = true;
+    this.stateValue = 'failed';
+    try {
+      this.options.onFailure(reason);
+    } catch {
+      // Failure publication cannot restore provisional authority.
+    }
+    this.disposeDriver();
+    this.pending.clear();
+    return false;
+  }
+
+  private disposeDriver(): void {
+    if (this.disposedDriver) return;
+    this.disposedDriver = true;
+    this.disposeNativeMutationIngress();
+    try {
+      this.productionBatch?.[5]();
+    } catch {
+      // Every owned subsystem must still receive its independent disposal attempt.
+    }
+    try {
+      this.options.production?.renderer?.[9]();
+    } catch {
+      // Disposal is generation-latched; physical cleanup failure cannot restore authority.
+    }
+    this.bound.clear();
+  }
+
+  private installNativeMutationIngress(): void {
+    if (!this.options.handoff || !this.options.mutationDocument) return;
+    try {
+      const document = this.options.mutationDocument;
+      const Observer = document.defaultView?.MutationObserver;
+      if (!Observer || !document.documentElement) throw new TypeError('tsjs');
+      const observer = new Observer((records) => this.observeDomMutations(records));
+      observer.observe(document.documentElement, {
+        attributes: true,
+        childList: true,
+        subtree: true,
+      });
+      this.mutationObserver = observer;
+    } catch {
+      this.fail(BUNDLE_PARTIAL);
+    }
+  }
+
+  private observeDomMutations(records: readonly MutationRecord[]): void {
+    if (records.length > 0) {
+      try {
+        this.options.production?.renderer?.[4]();
+      } catch {
+        this.fail(BUNDLE_PARTIAL);
+        return;
+      }
+    }
+    for (const record of records) {
+      if (this.isOwnedRuntimeInsertion(record)) continue;
+      if (!this.observeNativeMutation()) return;
+    }
+  }
+
+  private isOwnedRuntimeInsertion(record: MutationRecord): boolean {
+    if (record.type !== 'childList' || record.removedNodes.length !== 0) return false;
+    const added = [...record.addedNodes];
+    return (
+      added.length === 1 &&
+      added[0]?.nodeType === 1 &&
+      (added[0] as Element).tagName === 'SCRIPT' &&
+      (added[0] as Element).id === 'trustedserver-js-runtime'
+    );
+  }
+
+  private closeNativeMutationIngress(): void {
+    const observer = this.mutationObserver;
+    this.mutationObserver = undefined;
+    if (!observer) return;
+    try {
+      const records = observer.takeRecords();
+      observer.disconnect();
+      this.observeDomMutations(records);
+    } catch {
+      throw new TypeError('tsjs');
+    }
+  }
+
+  private disposeNativeMutationIngress(): void {
+    const observer = this.mutationObserver;
+    this.mutationObserver = undefined;
+    if (!observer) return;
+    try {
+      observer.disconnect();
+    } catch {
+      // Generation latching makes a failed physical observer removal inert.
+    }
+  }
+}
+
+/** Create the bounded provisional lifecycle owner; it publishes no runtime API. */
+export function createFirstDisplayAgent(options: FirstDisplayAgentOptions): FirstDisplayAgent {
+  return new FirstDisplayAgentOwner(options);
+}
+
+/** Prepare the bootstrap-owned first-display coordinator for its optional slices. */
+export function prepareFirstDisplayBase(
+  host: FirstDisplayAgentRegistrationHostV1
+): PreparedFirstDisplayBaseV1 {
+  const { options, sliceBindings } = host;
+  const fullProtocols = new Map<FirstDisplayRegisteredProtocolId, unknown>();
+  const parserState = new Map<
+    string,
+    { observations: string[]; values: Map<string, string | number | boolean | null> }
+  >();
+  const registerParserSlice = (id: string): boolean => {
+    if (parserState.has(id) || !options.handoff?.slices.includes(id as FirstDisplaySliceId)) {
+      return false;
+    }
+    parserState.set(id, { observations: [], values: new Map() });
+    return true;
+  };
+  const observeParserValue = (id: string, key: unknown, value: unknown): boolean => {
+    const state = parserState.get(id);
+    if (
+      !state ||
+      typeof key !== 'string' ||
+      key.length === 0 ||
+      key.length > 128 ||
+      (value !== null &&
+        typeof value !== 'string' &&
+        typeof value !== 'boolean' &&
+        !(typeof value === 'number' && Number.isFinite(value))) ||
+      (typeof value === 'string' && value.length > 4_096)
+    ) {
+      return false;
+    }
+    if (!state.values.has(key)) {
+      if (state.values.size >= 256) return false;
+      state.observations.push(key);
+    }
+    state.values.set(key, value as string | number | boolean | null);
+    return true;
+  };
+  const snapshotParserState = () =>
+    Object.freeze(
+      [...parserState].map(([sliceId, state]) =>
+        Object.freeze([
+          sliceId,
+          Object.freeze(
+            state.observations.map((key) => Object.freeze([key, state.values.get(key)!] as const))
+          ),
+        ] as const)
+      )
+    );
+  let agent: FirstDisplayAgent | undefined;
+  const sliceHost: FirstDisplaySliceHost = Object.freeze({
+    activate: (
+      id: OptionalFirstDisplaySliceId,
+      own: FirstDisplaySliceActivationContext['own'],
+      install?: InitialSliceInstaller
+    ): void => {
+      if (typeof install !== 'function') {
+        throw new TypeError('tsjs');
+      }
+      if (!registerParserSlice(id)) {
+        throw new TypeError('tsjs');
+      }
+      const protocolId = id.endsWith('_initial')
+        ? (id.slice(0, -'_initial'.length) as FirstDisplayRegisteredProtocolId)
+        : undefined;
+      const observe = (key: unknown, value: unknown): void => {
+        if (!observeParserValue(id, key, value)) throw new TypeError('tsjs');
+        agent?.observeNativeMutation();
+      };
+      const register =
+        protocolId && SLICE_PROTOCOLS.includes(protocolId)
+          ? (protocol: unknown): (() => void) => {
+              if (!fullProtocolIdentity(protocol, protocolId) || fullProtocols.has(protocolId)) {
+                throw new TypeError('tsjs');
+              }
+              fullProtocols.set(protocolId, protocol);
+              return () => {
+                if (fullProtocols.get(protocolId) === protocol) {
+                  fullProtocols.delete(protocolId);
+                }
+              };
+            }
+          : undefined;
+      // The authenticated bootstrap builds the exact carrier around these
+      // base-owned observation and protocol capabilities.
+      const transported = sliceBindings(id, observe, register);
+      if (!Array.isArray(transported) || transported.length !== 2) {
+        throw new TypeError('tsjs');
+      }
+      const installed = install(transported[0], own, transported[1]);
+      if (
+        protocolId &&
+        SLICE_PROTOCOLS.includes(protocolId) &&
+        !protocolIdentity(installed, protocolId)
+      ) {
+        throw new TypeError('tsjs');
+      }
+    },
+  });
+  return Object.freeze({
+    activate: (context: FirstDisplaySliceActivationContext): void => {
+      const rendererOwner: { value: FirstDisplayRenderBridgeCapabilityV1 | undefined } = {
+        value: undefined,
+      };
+      context.own(() => {
+        if (agent) agent.dispose();
+        else rendererOwner.value?.[9]();
+      });
+      context.afterActivate(() => {
+        const batch = acceptServerFirstDisplayBatchV1(options.batch);
+        if (!batch) throw new TypeError('tsjs');
+        const gpt = fullProtocols.get('gpt');
+        const aps = fullProtocols.get('aps');
+        const renderOwner = fullProtocols.get('render_owner');
+        const requiresRenderOwner = batch[2].some(([, kind]) => ACTION_KINDS.has(kind));
+        const activatedAuctionProtocols = AUCTION_PROTOCOLS.filter((id) => fullProtocols.has(id));
+        if (
+          activatedAuctionProtocols.length !== batch[1].length ||
+          !batch[1].every((id) => fullProtocolIdentity(fullProtocols.get(id), id))
+        ) {
+          throw new TypeError('tsjs');
+        }
+        if (
+          requiresRenderOwner !== fullProtocolIdentity(renderOwner, 'render_owner') ||
+          (aps !== undefined && renderOwner === undefined)
+        ) {
+          throw new TypeError('tsjs');
+        }
+        const renderOptions: FirstDisplayRenderOwnerOptionsV1 = Object.freeze([
+          options.gptInput[0],
+          options.gptInput[1],
+          () => createBrowserMessageChannel(options.gptInput[0]),
+          options.gptInput[2],
+          (bytes) => fillBrowserRandom(options.gptInput[0], bytes),
+          () => readBrowserNow(options.gptInput[0]),
+          () => agent?.observeNativeMutation() === true,
+          options.gptInput[3],
+        ]);
+        const apsProtocol = fullProtocolIdentity(aps, 'aps')
+          ? (aps as FirstDisplayApsProtocolV1)
+          : undefined;
+        const renderStrategy = apsProtocol?.[2].createRenderStrategy(renderOptions);
+        const renderer = renderOwner
+          ? (renderOwner as FirstDisplayRenderOwnerProtocolV1)[2](renderOptions, renderStrategy)
+          : undefined;
+        rendererOwner.value = renderer;
+        agent = createFirstDisplayAgent({
+          ...options,
+          mutationDocument: options.gptInput[2],
+          parserState: snapshotParserState,
+          production: {
+            ...(gpt ? { gpt: gpt as FirstDisplayGptProtocolV1 } : {}),
+            gptInput: Object.freeze([
+              options.gptInput[0],
+              options.gptInput[1],
+              options.gptInput[2],
+              options.gptInput[3],
+              options.gptInput[4],
+              () => agent?.observeNativeMutation() === true,
+            ]),
+            ...(renderer ? { renderer } : {}),
+          },
+        });
+        if (!agent.start()) throw new TypeError('tsjs');
+        options.onAgentReady?.(agent);
+      });
+    },
+    sliceHost,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/base_marker.ts b/crates/trusted-server-js/lib/src/first_display/base_marker.ts
new file mode 100644
index 000000000..df5dc6ddf
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/base_marker.ts
@@ -0,0 +1 @@
+// The logical first-display base is physically co-bundled with the parser-inline bootstrap.
diff --git a/crates/trusted-server-js/lib/src/first_display/composition.ts b/crates/trusted-server-js/lib/src/first_display/composition.ts
new file mode 100644
index 000000000..830c80e36
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/composition.ts
@@ -0,0 +1,107 @@
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+
+import { installApsInitial } from './leaf/aps_protocol';
+import { installTestlightInitial } from './leaf/callback_capture';
+import { installDidomiInitial } from './leaf/config_guard';
+import { installOsanoInitial, installSourcepointInitial } from './leaf/consent_snapshot';
+import { installPermutiveInitial } from './leaf/context_snapshot';
+import { installCreativeInitial } from './leaf/creative_guard';
+import { installPrebidInitial } from './leaf/prebid_protocol';
+import {
+  installDataDomeInitial,
+  installGoogleTagManagerInitial,
+  installLockrInitial,
+} from './leaf/route_guard';
+import { installRenderOwnerInitial } from './render_journal';
+import type { InitialSliceDefinition } from './slices/definition';
+import { installGptInitialSlice } from './slices/gpt';
+
+export const RENDER_OWNER_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'render_owner_initial',
+  install: installRenderOwnerInitial,
+});
+export const APS_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'aps_initial',
+  install: installApsInitial,
+});
+export const CREATIVE_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'creative_initial',
+  install: installCreativeInitial,
+});
+export const DATADOME_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'datadome_initial',
+  install: installDataDomeInitial,
+});
+export const DIDOMI_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'didomi_initial',
+  install: installDidomiInitial,
+});
+export const GOOGLE_TAG_MANAGER_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'google_tag_manager_initial',
+  install: installGoogleTagManagerInitial,
+});
+export const GPT_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'gpt_initial',
+  install: installGptInitialSlice,
+});
+export const LOCKR_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'lockr_initial',
+  install: installLockrInitial,
+});
+export const OSANO_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'osano_initial',
+  install: installOsanoInitial,
+});
+export const PERMUTIVE_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'permutive_initial',
+  install: installPermutiveInitial,
+});
+export const SOURCEPOINT_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'sourcepoint_initial',
+  install: installSourcepointInitial,
+});
+export const PREBID_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'prebid_initial',
+  install: installPrebidInitial,
+});
+export const TESTLIGHT_INITIAL_SLICE: InitialSliceDefinition = Object.freeze({
+  id: 'testlight_initial',
+  install: installTestlightInitial,
+});
+
+export const INITIAL_SLICE_DEFINITIONS: readonly InitialSliceDefinition[] = Object.freeze([
+  RENDER_OWNER_INITIAL_SLICE,
+  APS_INITIAL_SLICE,
+  CREATIVE_INITIAL_SLICE,
+  DATADOME_INITIAL_SLICE,
+  DIDOMI_INITIAL_SLICE,
+  GOOGLE_TAG_MANAGER_INITIAL_SLICE,
+  GPT_INITIAL_SLICE,
+  LOCKR_INITIAL_SLICE,
+  OSANO_INITIAL_SLICE,
+  PERMUTIVE_INITIAL_SLICE,
+  SOURCEPOINT_INITIAL_SLICE,
+  PREBID_INITIAL_SLICE,
+  TESTLIGHT_INITIAL_SLICE,
+]);
+
+/** Resolve only the canonical optional slice definitions already selected by the server. */
+export function selectInitialSliceDefinitions(
+  selected: readonly FirstDisplaySliceId[]
+): readonly InitialSliceDefinition[] | undefined {
+  if (selected[0] !== 'first_display' || selected.length > INITIAL_SLICE_DEFINITIONS.length + 1) {
+    return undefined;
+  }
+  const requested = new Set(selected.slice(1));
+  if (requested.size !== selected.length - 1) return undefined;
+  if (
+    (requested.has('aps_initial') && !requested.has('render_owner_initial')) ||
+    (requested.has('render_owner_initial') && !requested.has('gpt_initial'))
+  )
+    return undefined;
+  const definitions = INITIAL_SLICE_DEFINITIONS.filter(({ id }) => requested.has(id));
+  if (definitions.length !== requested.size) return undefined;
+  const canonical = ['first_display', ...definitions.map(({ id }) => id)];
+  if (canonical.some((id, index) => selected[index] !== id)) return undefined;
+  return Object.freeze(definitions);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/driver.ts b/crates/trusted-server-js/lib/src/first_display/driver.ts
new file mode 100644
index 000000000..231e34893
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/driver.ts
@@ -0,0 +1,391 @@
+import type {
+  FirstDisplayGoogletagBatchInput,
+  FirstDisplayGptBoundCycleV1,
+  FirstDisplayGptRenderResult,
+} from './adapters/googletag';
+import type { FirstDisplayDriver, FirstDisplayTerminalResult } from './agent';
+import type { FirstDisplayGptProtocolV1 } from './leaf/gpt_protocol';
+import type { FirstDisplayBatchOutcomeV1, FirstDisplayBatchV1 } from './leaf/projection';
+
+const ACTION_KINDS = new Set(['gpt_adm', 'aps']);
+const TERMINAL_RESULTS = new Set(['accepted', 'failed', 'cancelled']);
+
+export interface FirstDisplayRenderBridgeV1 {
+  readonly bind: (
+    cycle: FirstDisplayGptBoundCycleV1,
+    onTerminal: (result: FirstDisplayTerminalResult, reason: string | null) => void
+  ) => boolean;
+  readonly recordGam: (
+    cycle: FirstDisplayGptBoundCycleV1,
+    result: FirstDisplayGptRenderResult
+  ) => boolean;
+  readonly recordFailure: (cycle: FirstDisplayGptBoundCycleV1) => boolean;
+  readonly retire: (cycle: FirstDisplayGptBoundCycleV1) => boolean;
+  readonly sweepCommittedArtifacts: () => number;
+  readonly sealTsAdmission: () => void;
+  readonly closeIngress: () => boolean;
+  readonly captureHandoff: () => FirstDisplayRenderCaptureV1 | undefined;
+  readonly detachCommittedArtifacts: () => boolean;
+  readonly dispose: () => void;
+}
+
+/** Compact authenticated capability passed from the render slice to the inline owner. */
+export type FirstDisplayRenderBridgeCapabilityV1 = readonly [
+  bind: FirstDisplayRenderBridgeV1['bind'],
+  recordGam: FirstDisplayRenderBridgeV1['recordGam'],
+  recordFailure: FirstDisplayRenderBridgeV1['recordFailure'],
+  retire: FirstDisplayRenderBridgeV1['retire'],
+  sweepCommittedArtifacts: FirstDisplayRenderBridgeV1['sweepCommittedArtifacts'],
+  sealTsAdmission: FirstDisplayRenderBridgeV1['sealTsAdmission'],
+  closeIngress: FirstDisplayRenderBridgeV1['closeIngress'],
+  captureHandoff: () => FirstDisplayRenderCaptureV1 | undefined,
+  detachCommittedArtifacts: FirstDisplayRenderBridgeV1['detachCommittedArtifacts'],
+  dispose: FirstDisplayRenderBridgeV1['dispose'],
+];
+
+/** Compact cross-artifact render state; live identity remains tuple-local until takeover. */
+export type FirstDisplayRenderCaptureV1 = readonly [
+  artifacts: readonly (readonly [
+    hostPosition: string | null,
+    hostPositionPriority: string | null,
+    identity: object,
+    kind: 'gpt_adm' | 'aps',
+    owner: 'trusted_server' | 'publisher',
+    slotId: string,
+    token: string,
+  ])[],
+  tombstones: readonly (readonly [
+    kind: 'reservation' | 'ticket',
+    value: string,
+    expiresAtMs: number,
+    ordinal: number,
+  ])[],
+  clockEpochMs: number,
+  nextReservationOrdinal: number,
+  nextTicketOrdinal: number,
+];
+
+export interface FirstDisplayRenderHandoffArtifactV1 {
+  readonly hostPosition: string | null;
+  readonly hostPositionPriority: string | null;
+  readonly identity: object;
+  readonly kind: 'gpt_adm' | 'aps';
+  readonly owner: 'trusted_server' | 'publisher';
+  readonly slotId: string;
+  readonly token: string;
+}
+
+export interface FirstDisplayRenderHandoffV1 {
+  readonly artifacts: readonly FirstDisplayRenderHandoffArtifactV1[];
+  readonly clockEpochMs: number;
+  readonly nextReservationOrdinal: number;
+  readonly nextTicketOrdinal: number;
+  readonly tombstones: readonly Readonly<{
+    kind: 'reservation' | 'ticket';
+    value: string;
+    expiresAtMs: number;
+    ordinal: number;
+  }>[];
+}
+
+export interface FirstDisplayProjectedDriverOptionsV1 {
+  readonly batch: FirstDisplayBatchV1;
+  readonly gpt?: FirstDisplayGptProtocolV1;
+  readonly gptInput: readonly [
+    browser: FirstDisplayGoogletagBatchInput[0],
+    clearTimer: FirstDisplayGoogletagBatchInput[1],
+    document: FirstDisplayGoogletagBatchInput[2],
+    setTimer: FirstDisplayGoogletagBatchInput[3],
+    diagnosticsActive?: FirstDisplayGoogletagBatchInput[5],
+    onNativeMutation?: FirstDisplayGoogletagBatchInput[6],
+  ];
+  readonly renderer: FirstDisplayRenderBridgeV1;
+}
+
+function sameCycle(
+  expected: FirstDisplayGptBoundCycleV1,
+  candidate: FirstDisplayGptBoundCycleV1
+): boolean {
+  return (
+    candidate[6] === expected[6] &&
+    candidate[0] === expected[0] &&
+    candidate[1] === expected[1] &&
+    candidate[2] === expected[2] &&
+    candidate[5] === expected[5] &&
+    candidate[4] === expected[4] &&
+    candidate[3] === expected[3] &&
+    candidate[7] === expected[7]
+  );
+}
+
+/** Join GPT's exact physical cycle to the independent APS/ADM render authority. */
+export function createFirstDisplayProjectedDriver(
+  options: FirstDisplayProjectedDriverOptionsV1
+): FirstDisplayDriver {
+  const expected = options.batch.outcomes.filter(({ kind }) => ACTION_KINDS.has(kind));
+  const expectedBySlot = new Map(expected.map((outcome) => [outcome.slotId, outcome]));
+  const bound = new Map<string, FirstDisplayGptBoundCycleV1>();
+  const settled = new Set<string>();
+  const settledResults = new Map<string, FirstDisplayTerminalResult>();
+  const gptBatch =
+    expected.length === 0
+      ? undefined
+      : options.gpt?.[2](
+          Object.freeze([
+            options.gptInput[0],
+            options.gptInput[1],
+            options.gptInput[2],
+            options.gptInput[3],
+            options.batch.projection,
+            options.gptInput[4],
+            options.gptInput[5],
+          ])
+        );
+  if (expected.length > 0 && !gptBatch) {
+    throw new TypeError('tsjs');
+  }
+  let started = false;
+  let disposed = false;
+  let sealed = false;
+  let actionStarted = false;
+  let ingressClosed = false;
+  let handoffCaptured = false;
+  let committedArtifactsDetached = false;
+  let onTerminal:
+    | ((slotId: string, result: FirstDisplayTerminalResult, reason: string | null) => void)
+    | undefined;
+
+  const settle = (
+    slotId: string,
+    result: FirstDisplayTerminalResult,
+    reason: string | null
+  ): boolean => {
+    if (
+      disposed ||
+      !expectedBySlot.has(slotId) ||
+      settled.has(slotId) ||
+      !TERMINAL_RESULTS.has(result)
+    ) {
+      return false;
+    }
+    settled.add(slotId);
+    settledResults.set(slotId, result);
+    onTerminal?.(slotId, result, reason);
+    return true;
+  };
+
+  return Object.freeze({
+    start: (
+      outcomes: readonly FirstDisplayBatchOutcomeV1[],
+      onFirstAction: () => boolean,
+      terminal: (slotId: string, result: FirstDisplayTerminalResult, reason: string | null) => void
+    ): void => {
+      if (started || disposed) throw new TypeError('tsjs');
+      if (
+        outcomes.length !== expected.length ||
+        outcomes.some((outcome, index) => {
+          const row = expected[index];
+          return !row || row.slotId !== outcome.slotId || row.kind !== outcome.kind;
+        })
+      ) {
+        throw new TypeError('tsjs');
+      }
+      started = true;
+      onTerminal = terminal;
+      const accepted = gptBatch?.[0]([
+        (cycle): void => {
+          const action = expectedBySlot.get(cycle[6]);
+          const bidIndex = options.batch.projection.bids.indexOf(cycle[0]);
+          const expectedPlacement = options.batch.projection.slots.find(
+            ({ slot }) => slot === cycle[6]
+          );
+          if (
+            !action ||
+            bound.has(cycle[6]) ||
+            bidIndex < 0 ||
+            options.batch.projection.bids[bidIndex]?.slot !== cycle[6] ||
+            cycle[5] !== expectedPlacement
+          ) {
+            settle(cycle[6], 'failed', 'gpt_request_failed');
+            return;
+          }
+          bound.set(cycle[6], cycle);
+          if (!options.renderer.bind(cycle, (result, reason) => settle(cycle[6], result, reason))) {
+            settle(cycle[6], 'failed', 'internal_error');
+          }
+        },
+        (slotId, reason): void => {
+          const cycle = bound.get(slotId);
+          if (cycle) options.renderer.recordFailure(cycle);
+          settle(slotId, 'failed', reason);
+        },
+        (): boolean => {
+          if (actionStarted || disposed) return false;
+          actionStarted = true;
+          return onFirstAction();
+        },
+        (cycle, result): void => {
+          const exact = bound.get(cycle[6]);
+          if (!exact || !sameCycle(exact, cycle)) {
+            settle(cycle[6], 'failed', 'gpt_request_failed');
+            return;
+          }
+          if (!options.renderer.recordGam(exact, result)) {
+            settle(cycle[6], 'failed', 'gpt_request_failed');
+          }
+        },
+        (cycle): void => {
+          const exact = bound.get(cycle[6]);
+          if (exact && sameCycle(exact, cycle)) options.renderer.retire(exact);
+        },
+      ]);
+      if (accepted !== true) throw new TypeError('tsjs');
+    },
+    sealTsAdmission: (): void => {
+      if (sealed || disposed || settled.size !== expected.length) {
+        throw new TypeError('tsjs');
+      }
+      sealed = true;
+      options.renderer.sealTsAdmission();
+    },
+    sweepCommittedArtifacts: (): number =>
+      disposed ? 0 : options.renderer.sweepCommittedArtifacts(),
+    closeIngress: (): boolean => {
+      if (disposed || !sealed || ingressClosed) return false;
+      const acceptedIds = [...settledResults.entries()]
+        .filter(([, result]) => result === 'accepted')
+        .map(([slotId]) => slotId);
+      if (gptBatch && !gptBatch[1](acceptedIds)) return false;
+      if (!options.renderer.closeIngress()) return false;
+      ingressClosed = true;
+      return true;
+    },
+    captureHandoff: () => {
+      if (disposed || !ingressClosed || handoffCaptured) return undefined;
+      const gptCycles = gptBatch?.[2]() ?? Object.freeze([]);
+      const gptDiagnostics =
+        gptBatch?.[3]() ?? Object.freeze([Object.freeze([]), Object.freeze([]), 1, 0, 0] as const);
+      const render = options.renderer.captureHandoff();
+      if (!render) return undefined;
+      const acceptedIds = new Set(
+        [...settledResults.entries()]
+          .filter(([, result]) => result === 'accepted')
+          .map(([slotId]) => slotId)
+      );
+      const cycles = gptCycles.flatMap((captured) => {
+        const cycle = bound.get(captured[0]);
+        if (
+          !cycle ||
+          !acceptedIds.has(captured[0]) ||
+          cycle[7] !== captured[4] ||
+          cycle[4] !== captured[5]
+        ) {
+          return [];
+        }
+        const element =
+          cycle[1].id === captured[1] ? cycle[1] : options.gptInput[2].getElementById(captured[1]);
+        const ElementConstructor = options.gptInput[2].defaultView?.HTMLElement;
+        if (!ElementConstructor || !(element instanceof ElementConstructor)) return [];
+        return [
+          Object.freeze([
+            cycle[0],
+            element,
+            cycle[2],
+            captured[2],
+            cycle[4],
+            cycle[5],
+            cycle[6],
+            cycle[7],
+            captured[3],
+          ] as const),
+        ];
+      });
+      const diagnosticCycles = gptDiagnostics[0].filter((cycle) => acceptedIds.has(cycle[0]));
+      if (
+        cycles.length !== acceptedIds.size ||
+        diagnosticCycles.length !== cycles.length ||
+        diagnosticCycles.some((cycle) => {
+          const physical = cycles.find((candidate) => candidate[6] === cycle[0]);
+          return !physical || physical[7] !== cycle[1];
+        }) ||
+        render[0].some((artifact) => !acceptedIds.has(artifact[5]))
+      ) {
+        return undefined;
+      }
+      const identities = [
+        ...cycles.map((cycle) => cycle[4]),
+        ...render[0].map((artifact) => artifact[2]),
+      ];
+      if (new Set(identities).size !== identities.length) return undefined;
+      handoffCaptured = true;
+      return Object.freeze({
+        artifacts: Object.freeze(
+          render[0].map((artifact) => ({
+            hostPosition: artifact[0],
+            hostPositionPriority: artifact[1],
+            identity: artifact[2],
+            kind: artifact[3],
+            owner: artifact[4],
+            slotId: artifact[5],
+            token: artifact[6],
+          }))
+        ),
+        clockEpochMs: render[2],
+        cycles: Object.freeze(cycles),
+        diagnosticCycles: Object.freeze(
+          diagnosticCycles.map((cycle) => ({
+            slotId: cycle[0],
+            token: cycle[1],
+            nextCycleOrdinal: cycle[2],
+            unknownPriorCycle: cycle[3],
+            quarantines: cycle[4],
+            records: cycle[5].map((record) => ({
+              ordinal: record[0],
+              responseIdentifier: record[1],
+              seen: record[2],
+              state: record[3],
+            })),
+          }))
+        ),
+        gptDiagnostics: Object.freeze({
+          facts: Object.freeze([...gptDiagnostics[1]]),
+          overflowCount: gptDiagnostics[3],
+          dropCount: gptDiagnostics[4],
+        }),
+        identities: Object.freeze(identities),
+        nextTraceTokenOrdinal: gptDiagnostics[2],
+        nextReservationOrdinal: render[3],
+        nextTicketOrdinal: render[4],
+        tombstones: Object.freeze(
+          render[1].map((entry) => ({
+            kind: entry[0],
+            value: entry[1],
+            expiresAtMs: entry[2],
+            ordinal: entry[3],
+          }))
+        ),
+      });
+    },
+    detachCommittedArtifacts: (): boolean => {
+      if (disposed || !ingressClosed || !handoffCaptured || committedArtifactsDetached) {
+        return false;
+      }
+      const acceptedIds = [...settledResults.entries()]
+        .filter(([, result]) => result === 'accepted')
+        .map(([slotId]) => slotId);
+      if (gptBatch && !gptBatch[4](acceptedIds)) return false;
+      if (!options.renderer.detachCommittedArtifacts()) return false;
+      committedArtifactsDetached = true;
+      return true;
+    },
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      gptBatch?.[5]();
+      options.renderer.dispose();
+      bound.clear();
+      settledResults.clear();
+      onTerminal = undefined;
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/aps_protocol.ts b/crates/trusted-server-js/lib/src/first_display/leaf/aps_protocol.ts
new file mode 100644
index 000000000..ab2e060d2
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/aps_protocol.ts
@@ -0,0 +1,318 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+import { createFirstDisplayApsRenderStrategy } from '../render_bridge';
+import type {
+  FirstDisplayRenderOwnerOptionsV1,
+  FirstDisplayRenderStrategyV1,
+} from '../render_journal';
+
+export type FirstDisplayApsDocumentMessageV1 =
+  | Readonly<{ kind: 'document_accepted' }>
+  | Readonly<{ kind: 'runner_loaded' }>
+  | Readonly<{ kind: 'render_completed' }>
+  | Readonly<{
+      kind: 'render_failed';
+      reason: 'descriptor_invalid' | 'runner_no_load' | 'runner_failed';
+    }>;
+
+export type FirstDisplayApsWindowMessageV1 =
+  | Readonly<{ kind: 'bootstrap_ready'; bootstrap: string }>
+  | Readonly<{
+      kind: 'container_ready';
+      bootstrap: string;
+      renderer: string;
+    }>;
+
+export interface FirstDisplayApsBootstrapPolicyV2 {
+  readonly creativeOrigin: string;
+  readonly tagType: 'iframe' | 'script';
+}
+
+export interface FirstDisplayApsPolicyV1 {
+  readonly version: 1;
+  readonly id: 'aps';
+  readonly publisherOrigin: string;
+  readonly rendererUrl: string;
+  readonly sandbox: string;
+  readonly permanentSandbox: string;
+  readonly deadlines: Readonly<{
+    documentAcceptanceMs: 3_000;
+    completionMs: 10_000;
+  }>;
+  readonly isBootstrapNonce: (candidate: unknown) => candidate is string;
+  readonly isRendererNonce: (candidate: unknown) => candidate is string;
+  readonly bootstrapPolicy: (
+    renderer: unknown
+  ) => Readonly<FirstDisplayApsBootstrapPolicyV2> | undefined;
+  readonly parseDocumentMessage: (
+    candidate: unknown,
+    expectedNonce: string
+  ) => FirstDisplayApsDocumentMessageV1 | undefined;
+  readonly parseWindowMessage: (candidate: unknown) => FirstDisplayApsWindowMessageV1 | undefined;
+  readonly createRenderStrategy: (
+    options: FirstDisplayRenderOwnerOptionsV1
+  ) => FirstDisplayRenderStrategyV1;
+}
+
+export type FirstDisplayApsProtocolV1 = readonly [
+  version: 1,
+  id: 'aps',
+  policy: FirstDisplayApsPolicyV1,
+];
+
+interface ApsInitialBindings {
+  readonly observe: (name: 'protocol_version', value: number) => void;
+  readonly publisherOrigin: string;
+  readonly register: (protocol: FirstDisplayApsProtocolV1) => () => void;
+}
+
+const OPAQUE_ID = /^[bn]1_[A-Za-z0-9_-]{22}$/;
+const LOOPBACK_IPV4 = /^127(?:\.\d{1,3}){3}$/;
+const FAILURE_REASONS = new Set(['descriptor_invalid', 'runner_no_load', 'runner_failed']);
+const SANDBOX =
+  'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation';
+const PERMANENT_SANDBOX =
+  'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation';
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function bindings(candidate: unknown): ApsInitialBindings | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate)
+    ) {
+      return undefined;
+    }
+    const fields = exactRecord(candidate, ['observe', 'publisherOrigin', 'register']);
+    if (
+      !fields ||
+      typeof fields.observe !== 'function' ||
+      typeof fields.publisherOrigin !== 'string' ||
+      typeof fields.register !== 'function'
+    ) {
+      return undefined;
+    }
+    const origin = new URL(fields.publisherOrigin);
+    const loopbackHttp =
+      origin.protocol === 'http:' &&
+      (origin.hostname === 'localhost' ||
+        origin.hostname === '[::1]' ||
+        LOOPBACK_IPV4.test(origin.hostname));
+    if (
+      origin.origin !== fields.publisherOrigin ||
+      (origin.protocol !== 'https:' && !loopbackHttp) ||
+      origin.username !== '' ||
+      origin.password !== ''
+    ) {
+      return undefined;
+    }
+    return fields as unknown as ApsInitialBindings;
+  } catch {
+    return undefined;
+  }
+}
+
+function exactOpaqueId(candidate: unknown, prefix: 'b1_' | 'n1_'): candidate is string {
+  return typeof candidate === 'string' && candidate.startsWith(prefix) && OPAQUE_ID.test(candidate);
+}
+
+function parseDocumentMessage(
+  candidate: unknown,
+  expectedNonce: string
+): FirstDisplayApsDocumentMessageV1 | undefined {
+  if (!exactOpaqueId(expectedNonce, 'n1_')) return undefined;
+  const base = exactRecord(candidate, ['message', 'version', 'nonce']);
+  if (base && base.version === 1 && base.nonce === expectedNonce) {
+    if (base.message === 'TS APS Document Accepted') {
+      return Object.freeze({ kind: 'document_accepted' });
+    }
+    if (base.message === 'TS APS Runner Loaded') {
+      return Object.freeze({ kind: 'runner_loaded' });
+    }
+    if (base.message === 'TS APS Render Completed') {
+      return Object.freeze({ kind: 'render_completed' });
+    }
+  }
+  const failed = exactRecord(candidate, ['message', 'version', 'nonce', 'reason']);
+  if (
+    failed?.message === 'TS APS Render Failed' &&
+    failed.version === 1 &&
+    failed.nonce === expectedNonce &&
+    typeof failed.reason === 'string' &&
+    FAILURE_REASONS.has(failed.reason)
+  ) {
+    return Object.freeze({
+      kind: 'render_failed',
+      reason: failed.reason as 'descriptor_invalid' | 'runner_no_load' | 'runner_failed',
+    });
+  }
+  return undefined;
+}
+
+function parseWindowMessage(candidate: unknown): FirstDisplayApsWindowMessageV1 | undefined {
+  if (typeof candidate !== 'string' || candidate.length > 4_096) return undefined;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(candidate) as unknown;
+  } catch {
+    return undefined;
+  }
+  const bootstrap = exactRecord(parsed, ['message', 'version', 'bootstrapNonce']);
+  if (
+    bootstrap?.message === 'TS APS Bootstrap Ready' &&
+    bootstrap.version === 1 &&
+    exactOpaqueId(bootstrap.bootstrapNonce, 'b1_') &&
+    candidate ===
+      JSON.stringify({
+        message: 'TS APS Bootstrap Ready',
+        version: 1,
+        bootstrapNonce: bootstrap.bootstrapNonce,
+      })
+  ) {
+    return Object.freeze({ kind: 'bootstrap_ready', bootstrap: bootstrap.bootstrapNonce });
+  }
+  const container = exactRecord(parsed, ['message', 'version', 'bootstrapNonce', 'rendererNonce']);
+  if (
+    container?.message === 'TS APS Container Ready' &&
+    container.version === 1 &&
+    exactOpaqueId(container.bootstrapNonce, 'b1_') &&
+    exactOpaqueId(container.rendererNonce, 'n1_') &&
+    candidate ===
+      JSON.stringify({
+        message: 'TS APS Container Ready',
+        version: 1,
+        bootstrapNonce: container.bootstrapNonce,
+        rendererNonce: container.rendererNonce,
+      })
+  ) {
+    return Object.freeze({
+      kind: 'container_ready',
+      bootstrap: container.bootstrapNonce,
+      renderer: container.rendererNonce,
+    });
+  }
+  return undefined;
+}
+
+function bootstrapPolicy(
+  candidate: unknown,
+  publisherOrigin: string
+): Readonly<FirstDisplayApsBootstrapPolicyV2> | undefined {
+  try {
+    const renderer = exactRecord(
+      candidate,
+      Object.prototype.hasOwnProperty.call(candidate, 'creativeId')
+        ? [
+            'aaxResponse',
+            'accountId',
+            'bidId',
+            'creativeId',
+            'creativeUrl',
+            'height',
+            'tagType',
+            'type',
+            'version',
+            'width',
+          ]
+        : [
+            'aaxResponse',
+            'accountId',
+            'bidId',
+            'creativeUrl',
+            'height',
+            'tagType',
+            'type',
+            'version',
+            'width',
+          ]
+    );
+    if (
+      !renderer ||
+      renderer.type !== 'aps' ||
+      renderer.version !== 1 ||
+      (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') ||
+      typeof renderer.creativeUrl !== 'string'
+    ) {
+      return undefined;
+    }
+    const creative = new URL(renderer.creativeUrl);
+    if (
+      creative.protocol !== 'https:' ||
+      creative.hostname === '' ||
+      creative.username !== '' ||
+      creative.password !== '' ||
+      creative.origin === publisherOrigin
+    ) {
+      return undefined;
+    }
+    return Object.freeze({ creativeOrigin: creative.origin, tagType: renderer.tagType });
+  } catch {
+    return undefined;
+  }
+}
+
+/** Register the exact APS reservation identity and renderer-document protocol. */
+export function installApsInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): readonly [version: 1, id: 'aps'] {
+  const value = bindings(candidate);
+  if (!value || typeof own !== 'function') throw new TypeError('tsjs');
+  const publisherOrigin = value['publisherOrigin'];
+  const rendererUrl = new URL('/integrations/aps/renderer/v2', publisherOrigin).href;
+  const policy: FirstDisplayApsPolicyV1 = Object.freeze({
+    version: 1,
+    id: 'aps',
+    publisherOrigin: value.publisherOrigin,
+    rendererUrl,
+    sandbox: SANDBOX,
+    permanentSandbox: PERMANENT_SANDBOX,
+    deadlines: Object.freeze({
+      documentAcceptanceMs: 3_000,
+      completionMs: 10_000,
+    }),
+    isBootstrapNonce: (input: unknown): input is string => exactOpaqueId(input, 'b1_'),
+    isRendererNonce: (input: unknown): input is string => exactOpaqueId(input, 'n1_'),
+    bootstrapPolicy: (renderer: unknown) => bootstrapPolicy(renderer, value.publisherOrigin),
+    parseDocumentMessage,
+    parseWindowMessage,
+    createRenderStrategy: (options: FirstDisplayRenderOwnerOptionsV1) =>
+      createFirstDisplayApsRenderStrategy(options, policy),
+  });
+  const protocol: FirstDisplayApsProtocolV1 = Object.freeze([1, 'aps', policy]);
+  const release = value.register(protocol);
+  if (typeof release !== 'function') throw new TypeError('tsjs');
+  own(release);
+  value.observe('protocol_version', 1);
+  return Object.freeze([1, 'aps']);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/browser_route_owner.ts b/crates/trusted-server-js/lib/src/first_display/leaf/browser_route_owner.ts
new file mode 100644
index 000000000..d79c6c2ed
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/browser_route_owner.ts
@@ -0,0 +1,294 @@
+type BrowserRouteKind = 'script' | 'preload' | 'prefetch' | 'beacon' | 'fetch';
+
+export interface FirstDisplayBrowserRouteRuleV1 {
+  readonly matches: (kind: BrowserRouteKind, url: string) => boolean;
+  readonly rewrite: (url: string) => string;
+}
+
+export interface FirstDisplayBrowserRouteOwnerV1 {
+  readonly register: (rule: FirstDisplayBrowserRouteRuleV1, network?: boolean) => () => void;
+  readonly dispose: () => void;
+}
+
+interface RouteRegistration {
+  readonly rule: FirstDisplayBrowserRouteRuleV1;
+  readonly network: boolean;
+}
+
+function restoreOwnedProperty(
+  owner: object,
+  key: PropertyKey,
+  installed: unknown,
+  original: unknown
+): void {
+  try {
+    if (Reflect.get(owner, key) === installed) Reflect.set(owner, key, original);
+  } catch {
+    // Browser-owned or publisher-hardened surfaces may reject restoration.
+    // Every other surface must still receive its independent best-effort restore.
+  }
+}
+
+function route(
+  registrations: readonly RouteRegistration[],
+  kind: BrowserRouteKind,
+  url: string
+): string {
+  let current = url;
+  for (const registration of registrations) {
+    if ((kind === 'beacon' || kind === 'fetch') && !registration.network) continue;
+    try {
+      if (registration.rule.matches(kind, current)) current = registration.rule.rewrite(current);
+    } catch {
+      // A malformed integration rule cannot suppress the remaining route owners.
+    }
+  }
+  return current;
+}
+
+/** Create one document-scoped parser-time route owner shared by every selected slice. */
+export function createFirstDisplayBrowserRouteOwner(
+  routeDocument: Document,
+  browser: Window
+): FirstDisplayBrowserRouteOwnerV1 {
+  const registrations: RouteRegistration[] = [];
+  const ElementConstructor = routeDocument.defaultView?.Element ?? Element;
+  const prototype = ElementConstructor.prototype;
+  const appendChild = prototype.appendChild;
+  const insertBefore = prototype.insertBefore;
+  const append = prototype.append;
+  const prepend = prototype.prepend;
+  const replaceChildren = prototype.replaceChildren;
+  const navigator = browser.navigator;
+  const sendBeacon = navigator.sendBeacon;
+  const fetch = browser.fetch;
+  let disposed = false;
+  let networkInstalled = false;
+
+  const rewriteNode = (node: Node): void => {
+    if (node.nodeType !== Node.ELEMENT_NODE) return;
+    const element = node as Element;
+    if (element.tagName === 'SCRIPT') {
+      const script = element as HTMLScriptElement;
+      const source = script.getAttribute('src') ?? script.src;
+      const rewritten = source && route(registrations, 'script', source);
+      if (rewritten && rewritten !== source) script.src = rewritten;
+      return;
+    }
+    if (element.tagName !== 'LINK') return;
+    const link = element as HTMLLinkElement;
+    const rel = link.getAttribute('rel');
+    if ((rel !== 'preload' && rel !== 'prefetch') || link.getAttribute('as') !== 'script') return;
+    const source = link.getAttribute('href') ?? link.href;
+    const rewritten = source && route(registrations, rel, source);
+    if (rewritten && rewritten !== source) link.href = rewritten;
+  };
+  const rewriteTree = (node: Node): void => {
+    rewriteNode(node);
+    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
+      return;
+    for (const nested of (node as Element | DocumentFragment).querySelectorAll(
+      'script[src],link[href]'
+    )) {
+      rewriteNode(nested);
+    }
+  };
+  const rewriteVariadic = (nodes: readonly (Node | string)[]): void => {
+    for (const node of nodes) {
+      if (typeof node !== 'string') rewriteTree(node);
+    }
+  };
+  const appendWrapper: typeof prototype.appendChild = function <T extends Node>(
+    this: Element,
+    node: T
+  ): T {
+    rewriteTree(node);
+    return Reflect.apply(appendChild, this, [node]) as T;
+  };
+  const insertWrapper: typeof prototype.insertBefore = function <T extends Node>(
+    this: Element,
+    node: T,
+    child: Node | null
+  ): T {
+    rewriteTree(node);
+    return Reflect.apply(insertBefore, this, [node, child]) as T;
+  };
+  const appendVariadicWrapper: typeof prototype.append = function (
+    this: Element,
+    ...nodes: (Node | string)[]
+  ): void {
+    rewriteVariadic(nodes);
+    Reflect.apply(append, this, nodes);
+  };
+  const prependWrapper: typeof prototype.prepend = function (
+    this: Element,
+    ...nodes: (Node | string)[]
+  ): void {
+    rewriteVariadic(nodes);
+    Reflect.apply(prepend, this, nodes);
+  };
+  const replaceChildrenWrapper: typeof prototype.replaceChildren = function (
+    this: Element,
+    ...nodes: (Node | string)[]
+  ): void {
+    rewriteVariadic(nodes);
+    Reflect.apply(replaceChildren, this, nodes);
+  };
+  const restoreDom = (): void => {
+    restoreOwnedProperty(prototype, 'appendChild', appendWrapper, appendChild);
+    restoreOwnedProperty(prototype, 'insertBefore', insertWrapper, insertBefore);
+    restoreOwnedProperty(prototype, 'append', appendVariadicWrapper, append);
+    restoreOwnedProperty(prototype, 'prepend', prependWrapper, prepend);
+    restoreOwnedProperty(prototype, 'replaceChildren', replaceChildrenWrapper, replaceChildren);
+  };
+
+  const Observer = routeDocument.defaultView?.MutationObserver;
+  let observer: MutationObserver | undefined;
+  try {
+    prototype.appendChild = appendWrapper;
+    prototype.insertBefore = insertWrapper;
+    prototype.append = appendVariadicWrapper;
+    prototype.prepend = prependWrapper;
+    prototype.replaceChildren = replaceChildrenWrapper;
+    observer = Observer
+      ? new Observer((records) => {
+          for (const record of records) {
+            for (const node of record.addedNodes) rewriteTree(node);
+          }
+        })
+      : undefined;
+    observer?.observe(routeDocument.documentElement, { childList: true, subtree: true });
+  } catch (error) {
+    try {
+      observer?.disconnect();
+    } catch {
+      // Continue restoring every installed insertion surface.
+    }
+    restoreDom();
+    throw error;
+  }
+
+  const beaconWrapper = function (url: string | URL, data?: BodyInit | null): boolean {
+    return Reflect.apply(sendBeacon, navigator, [
+      route(registrations, 'beacon', String(url)),
+      data,
+    ]);
+  };
+  const fetchWrapper = function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+    let source: string | undefined;
+    if (typeof input === 'string' || input instanceof URL) source = String(input);
+    else if (typeof Request !== 'undefined' && input instanceof Request) source = input.url;
+    const rewritten = source && route(registrations, 'fetch', source);
+    let request = input;
+    if (rewritten && rewritten !== source) {
+      if (typeof Request !== 'undefined' && input instanceof Request) {
+        const requestInit: RequestInit & { duplex?: 'half' } = {
+          cache: input.cache,
+          credentials: input.credentials,
+          headers: input.headers,
+          integrity: input.integrity,
+          keepalive: input.keepalive,
+          method: input.method,
+          mode: input.mode,
+          redirect: input.redirect,
+          referrer: input.referrer,
+          referrerPolicy: input.referrerPolicy,
+          signal: input.signal,
+        };
+        if (input.body !== null && input.method !== 'GET' && input.method !== 'HEAD') {
+          requestInit.body = input.body as BodyInit;
+          requestInit.duplex = 'half';
+        }
+        request = new Request(rewritten, requestInit);
+      } else {
+        request = rewritten;
+      }
+    }
+    return Reflect.apply(fetch, browser, [request, init]);
+  };
+
+  const restoreNetwork = (): void => {
+    if (!networkInstalled) return;
+    networkInstalled = false;
+    restoreOwnedProperty(navigator, 'sendBeacon', beaconWrapper, sendBeacon);
+    restoreOwnedProperty(browser, 'fetch', fetchWrapper, fetch);
+  };
+  const installNetwork = (): void => {
+    if (networkInstalled) return;
+    try {
+      if (typeof sendBeacon === 'function') navigator.sendBeacon = beaconWrapper;
+      if (typeof fetch === 'function') browser.fetch = fetchWrapper;
+      networkInstalled = true;
+    } catch (error) {
+      restoreOwnedProperty(navigator, 'sendBeacon', beaconWrapper, sendBeacon);
+      restoreOwnedProperty(browser, 'fetch', fetchWrapper, fetch);
+      throw error;
+    }
+  };
+  const dispose = (): void => {
+    if (disposed) return;
+    disposed = true;
+    registrations.length = 0;
+    try {
+      observer?.disconnect();
+    } catch {
+      // Generation latching makes an unremovable observer inert.
+    }
+    restoreDom();
+    restoreNetwork();
+  };
+
+  return Object.freeze({
+    register: (rule: FirstDisplayBrowserRouteRuleV1, network = false): (() => void) => {
+      if (
+        disposed ||
+        !rule ||
+        typeof rule.matches !== 'function' ||
+        typeof rule.rewrite !== 'function'
+      ) {
+        throw new TypeError('tsjs');
+      }
+      const registration = Object.freeze({ rule, network });
+      registrations.push(registration);
+      try {
+        if (network) installNetwork();
+      } catch (error) {
+        registrations.pop();
+        if (registrations.length === 0) dispose();
+        throw error;
+      }
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        const index = registrations.indexOf(registration);
+        if (index >= 0) registrations.splice(index, 1);
+        if (!registrations.some((entry) => entry.network)) restoreNetwork();
+        if (registrations.length === 0) dispose();
+      };
+    },
+    dispose,
+  });
+}
+
+let defaultOwner: FirstDisplayBrowserRouteOwnerV1 | undefined;
+let defaultRegistrations = 0;
+
+/** Register through the document singleton used by direct unit consumers. */
+export function registerFirstDisplayBrowserRoute(
+  rule: FirstDisplayBrowserRouteRuleV1,
+  network = false
+): () => void {
+  if (!defaultOwner) defaultOwner = createFirstDisplayBrowserRouteOwner(document, window);
+  const owner = defaultOwner;
+  const release = owner.register(rule, network);
+  defaultRegistrations += 1;
+  let active = true;
+  return (): void => {
+    if (!active) return;
+    active = false;
+    release();
+    defaultRegistrations -= 1;
+    if (defaultRegistrations === 0 && defaultOwner === owner) defaultOwner = undefined;
+  };
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/callback_capture.ts b/crates/trusted-server-js/lib/src/first_display/leaf/callback_capture.ts
new file mode 100644
index 000000000..3320693cd
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/callback_capture.ts
@@ -0,0 +1,167 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+interface TestlightGlobal {
+  que?: unknown[];
+  [key: string]: unknown;
+}
+
+interface TestlightTarget {
+  testlight?: TestlightGlobal;
+}
+
+interface TestlightInitialBindings {
+  readonly enqueue: (callback: () => void) => void;
+  readonly observe: (name: 'callback_count', count: number) => void;
+  readonly target: TestlightTarget;
+}
+
+function snapshotBindings(candidate: unknown): TestlightInitialBindings | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate) ||
+      Reflect.ownKeys(candidate).length !== 3
+    ) {
+      return undefined;
+    }
+    const values: Record<string, unknown> = {};
+    for (const key of ['enqueue', 'observe', 'target']) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      values[key] = descriptor.value;
+    }
+    if (
+      typeof values.enqueue !== 'function' ||
+      typeof values.observe !== 'function' ||
+      typeof values.target !== 'object' ||
+      values.target === null
+    ) {
+      return undefined;
+    }
+    return {
+      enqueue: values.enqueue as TestlightInitialBindings['enqueue'],
+      observe: values.observe as TestlightInitialBindings['observe'],
+      target: values.target as TestlightTarget,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function ownQueueValues(candidate: unknown): unknown[] {
+  if (!Array.isArray(candidate)) return [];
+  const entries: Array<readonly [number, unknown]> = [];
+  try {
+    for (const key of Reflect.ownKeys(candidate)) {
+      if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/.test(key)) continue;
+      const index = Number(key);
+      if (!Number.isSafeInteger(index) || index < 0 || index >= 4_294_967_295) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (descriptor?.enumerable && 'value' in descriptor) entries.push([index, descriptor.value]);
+    }
+  } catch {
+    return [];
+  }
+  entries.sort(([left], [right]) => left - right);
+  return entries.map(([, value]) => value);
+}
+
+/** Capture preexisting and later Testlight callbacks into the bootstrap ingress once. */
+export function installTestlightInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = snapshotBindings(candidate);
+  if (!bindings || typeof own !== 'function') {
+    throw new TypeError('invalid Testlight initial bindings');
+  }
+  const { enqueue, observe, target } = bindings;
+  const previousTargetDescriptor = Object.getOwnPropertyDescriptor(target, 'testlight');
+  if (previousTargetDescriptor && !('value' in previousTargetDescriptor)) {
+    throw new TypeError('Testlight publisher global accessor is unsupported');
+  }
+  const currentGlobal = previousTargetDescriptor?.value;
+  const global: TestlightGlobal =
+    typeof currentGlobal === 'object' && currentGlobal !== null ? currentGlobal : {};
+  const createdGlobal = global !== currentGlobal;
+  if (createdGlobal && !Reflect.set(target, 'testlight', global)) {
+    throw new TypeError('Testlight publisher global is not writable');
+  }
+  const previousQueueDescriptor = Object.getOwnPropertyDescriptor(global, 'que');
+  if (previousQueueDescriptor && !('value' in previousQueueDescriptor)) {
+    throw new TypeError('Testlight publisher queue accessor is unsupported');
+  }
+  const originalQueue =
+    previousQueueDescriptor &&
+    'value' in previousQueueDescriptor &&
+    Array.isArray(previousQueueDescriptor.value)
+      ? previousQueueDescriptor.value
+      : undefined;
+  const queue = ownQueueValues(originalQueue);
+  if (originalQueue) originalQueue.length = 0;
+  Object.defineProperty(global, 'que', {
+    configurable: true,
+    enumerable: true,
+    value: queue,
+    writable: true,
+  });
+
+  let active = true;
+  own(() => {
+    if (!active) return;
+    active = false;
+    try {
+      if (Object.getOwnPropertyDescriptor(global, 'que')?.value === queue) {
+        if (previousQueueDescriptor) Object.defineProperty(global, 'que', previousQueueDescriptor);
+        else Reflect.deleteProperty(global, 'que');
+      }
+      if (
+        createdGlobal &&
+        Object.getOwnPropertyDescriptor(target, 'testlight')?.value === global &&
+        Reflect.ownKeys(global).length === 0
+      ) {
+        if (previousTargetDescriptor) {
+          Object.defineProperty(target, 'testlight', previousTargetDescriptor);
+        } else {
+          Reflect.deleteProperty(target, 'testlight');
+        }
+      }
+    } catch {
+      // Publisher replacement wins over provisional rollback.
+    }
+  });
+
+  let forwarded = 0;
+  const forward = (values: readonly unknown[]): void => {
+    for (const value of values) {
+      if (typeof value !== 'function') continue;
+      try {
+        enqueue(value as () => void);
+      } catch {
+        // One publisher callback or hostile ingress cannot block later callbacks.
+      }
+      forwarded += 1;
+    }
+    observe('callback_count', forwarded);
+  };
+  const pending = ownQueueValues(queue);
+  queue.length = 0;
+  const nativePush = queue.push.bind(queue);
+  Object.defineProperty(queue, 'push', {
+    configurable: true,
+    enumerable: false,
+    value: (...values: unknown[]): number => {
+      if (!active) return nativePush(...values);
+      const length = nativePush(...values);
+      const later = ownQueueValues(queue);
+      queue.length = 0;
+      forward(later);
+      return length;
+    },
+    writable: false,
+  });
+  forward(pending);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/config_guard.ts b/crates/trusted-server-js/lib/src/first_display/leaf/config_guard.ts
new file mode 100644
index 000000000..fdab0fbeb
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/config_guard.ts
@@ -0,0 +1,165 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+interface DidomiConfig {
+  sdkPath?: string;
+  [key: string]: unknown;
+}
+
+interface DidomiTarget {
+  didomiConfig?: DidomiConfig;
+  readonly location: { readonly origin: string };
+}
+
+interface DidomiInitialBindings {
+  readonly config: Readonly<{ proxyPath: string }>;
+  readonly observe: (name: 'sdk_path', value: string) => void;
+  readonly target: DidomiTarget;
+}
+
+function exactDataRecord(
+  value: unknown,
+  keys: readonly string[]
+): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotBindings(candidate: unknown): DidomiInitialBindings | undefined {
+  const fields = exactDataRecord(candidate, ['config', 'observe', 'target']);
+  const config = exactDataRecord(fields?.config, ['proxyPath']);
+  if (
+    !fields ||
+    !config ||
+    typeof config.proxyPath !== 'string' ||
+    !config.proxyPath.startsWith('/') ||
+    config.proxyPath.startsWith('//') ||
+    config.proxyPath.startsWith('/\\') ||
+    config.proxyPath.length > 2_048 ||
+    config.proxyPath.includes('?') ||
+    config.proxyPath.includes('#') ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.target !== 'object' ||
+    fields.target === null
+  ) {
+    return undefined;
+  }
+  const target = fields.target as DidomiTarget;
+  if (typeof target.location?.origin !== 'string') return undefined;
+  return {
+    config: Object.freeze({ proxyPath: config.proxyPath }),
+    observe: fields.observe as DidomiInitialBindings['observe'],
+    target,
+  };
+}
+
+function sameDescriptor(
+  left: PropertyDescriptor | undefined,
+  right: PropertyDescriptor | undefined
+): boolean {
+  return Boolean(
+    left &&
+    right &&
+    'value' in left &&
+    'value' in right &&
+    left.value === right.value &&
+    left.configurable === right.configurable &&
+    left.enumerable === right.enumerable &&
+    left.writable === right.writable
+  );
+}
+
+/** Install only Didomi's same-origin parser-time SDK path and own its rollback. */
+export function installDidomiInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = snapshotBindings(candidate);
+  if (!bindings || typeof own !== 'function')
+    throw new TypeError('invalid Didomi initial bindings');
+  const { config, observe, target } = bindings;
+  const origin = new URL(target.location.origin).origin;
+  const parsed = new URL(config.proxyPath, origin);
+  if (parsed.origin !== origin || parsed.username !== '' || parsed.password !== '') {
+    throw new TypeError('Didomi proxy path must remain on the publisher origin');
+  }
+  const installedPath = `${parsed.origin}${parsed.pathname}`;
+  const previousTargetDescriptor = Object.getOwnPropertyDescriptor(target, 'didomiConfig');
+  if (previousTargetDescriptor && !('value' in previousTargetDescriptor)) {
+    throw new TypeError('Didomi publisher config accessor is unsupported');
+  }
+  let publisherConfig = previousTargetDescriptor?.value as DidomiConfig | undefined;
+  const created = publisherConfig === undefined;
+  if (created) {
+    publisherConfig = {};
+    if (!Reflect.set(target, 'didomiConfig', publisherConfig)) {
+      throw new TypeError('Didomi publisher config is not writable');
+    }
+  }
+  if (typeof publisherConfig !== 'object' || publisherConfig === null) {
+    throw new TypeError('Didomi publisher config is invalid');
+  }
+  const previousSdkDescriptor = Object.getOwnPropertyDescriptor(publisherConfig, 'sdkPath');
+  if (previousSdkDescriptor && !('value' in previousSdkDescriptor)) {
+    throw new TypeError('Didomi sdkPath accessor is unsupported');
+  }
+  if (!Reflect.set(publisherConfig, 'sdkPath', installedPath)) {
+    throw new TypeError('Didomi sdkPath is not writable');
+  }
+  const installedSdkDescriptor = Object.getOwnPropertyDescriptor(publisherConfig, 'sdkPath');
+  let active = true;
+  own(() => {
+    if (!active) return;
+    active = false;
+    try {
+      if (target.didomiConfig !== publisherConfig) return;
+      if (
+        !sameDescriptor(
+          Object.getOwnPropertyDescriptor(publisherConfig, 'sdkPath'),
+          installedSdkDescriptor
+        )
+      ) {
+        return;
+      }
+      if (previousSdkDescriptor) {
+        Object.defineProperty(publisherConfig, 'sdkPath', previousSdkDescriptor);
+      } else {
+        Reflect.deleteProperty(publisherConfig, 'sdkPath');
+      }
+      if (created && Reflect.ownKeys(publisherConfig).length === 0) {
+        if (previousTargetDescriptor) {
+          Object.defineProperty(target, 'didomiConfig', previousTargetDescriptor);
+        } else {
+          Reflect.deleteProperty(target, 'didomiConfig');
+        }
+      }
+    } catch {
+      // Publisher replacement wins over provisional rollback.
+    }
+  });
+  observe('sdk_path', installedPath);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/consent_snapshot.ts b/crates/trusted-server-js/lib/src/first_display/leaf/consent_snapshot.ts
new file mode 100644
index 000000000..ed6948ace
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/consent_snapshot.ts
@@ -0,0 +1,543 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+export type FirstDisplayConsentRouteKindV1 = 'script' | 'preload' | 'prefetch';
+
+export interface FirstDisplayConsentRouteRuleV1 {
+  readonly id: 'sourcepoint';
+  readonly matches: (kind: FirstDisplayConsentRouteKindV1, url: string) => boolean;
+  readonly rewrite: (url: string) => string;
+}
+
+interface CookieDocument {
+  cookie: string;
+}
+
+interface StorageReader {
+  readonly length: number;
+  readonly getItem: (key: string) => string | null;
+  readonly key: (index: number) => string | null;
+}
+
+interface SourcepointInitialBindings {
+  readonly config: Readonly<{ rewriteSdk: boolean }>;
+  readonly document: CookieDocument;
+  readonly observe: (name: string, value: string | number) => void;
+  readonly origin: string;
+  readonly registerRoute: (rule: FirstDisplayConsentRouteRuleV1) => () => void;
+  readonly storage: StorageReader;
+}
+
+interface OsanoInitialBindings {
+  readonly clearTimer: (handle: unknown) => void;
+  readonly document: CookieDocument;
+  readonly observe: (name: string, value: string | number) => void;
+  readonly setTimer: (callback: () => void, delayMs: number) => unknown;
+  readonly target: OsanoTarget;
+}
+
+interface OsanoTarget {
+  readonly __uspapi?: (
+    command: 'getUSPData',
+    version: 1,
+    callback: (data?: unknown, success?: boolean) => void
+  ) => void;
+  readonly __gpp?: (command: 'ping', callback: (data?: unknown, success?: boolean) => void) => void;
+  readonly __tcfapi?: (
+    command: 'getTCData',
+    version: 2,
+    callback: (data?: unknown, success?: boolean) => void
+  ) => void;
+}
+
+interface ConsentWrite {
+  readonly name: string;
+  readonly value: string;
+}
+
+interface ConsentResult {
+  readonly writes: readonly ConsentWrite[];
+  readonly clears: readonly string[];
+}
+
+const SCRIPT_KINDS = new Set<FirstDisplayConsentRouteKindV1>(['script', 'preload', 'prefetch']);
+const OSANO_MARKER = '_ts_consent_src';
+const OSANO_VALUE = 'osano';
+const OSANO_TARGETS = ['us_privacy', '__gpp', '__gpp_sid', 'euconsent-v2'] as const;
+const SOURCEPOINT_MARKER = '_ts_gpp_src';
+const SOURCEPOINT_VALUE = 'sp';
+const MAX_STORAGE_ENTRIES = 512;
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readCookie(document: CookieDocument, name: string): string | undefined {
+  try {
+    const prefix = `${name}=`;
+    return document.cookie
+      .split('; ')
+      .find((entry) => entry.startsWith(prefix))
+      ?.slice(prefix.length);
+  } catch {
+    return undefined;
+  }
+}
+
+function writeCookie(document: CookieDocument, name: string, value: string): void {
+  document.cookie = `${name}=${value}; Path=/; Secure; SameSite=Lax`;
+}
+
+function clearCookie(document: CookieDocument, name: string): void {
+  document.cookie = `${name}=; Path=/; Secure; SameSite=Lax; Max-Age=0`;
+}
+
+function createCookieOwner(document: CookieDocument): {
+  readonly clear: (name: string) => void;
+  readonly dispose: () => void;
+  readonly write: (name: string, value: string) => void;
+} {
+  const previous = new Map<string, string | undefined>();
+  const installed = new Map<string, string | undefined>();
+  const remember = (name: string): void => {
+    if (!previous.has(name)) previous.set(name, readCookie(document, name));
+  };
+  return Object.freeze({
+    clear: (name: string): void => {
+      remember(name);
+      clearCookie(document, name);
+      installed.set(name, undefined);
+    },
+    dispose: (): void => {
+      for (const [name, installedValue] of [...installed].reverse()) {
+        const current = readCookie(document, name);
+        if (current !== installedValue) continue;
+        const previousValue = previous.get(name);
+        if (previousValue === undefined) clearCookie(document, name);
+        else writeCookie(document, name, previousValue);
+      }
+      installed.clear();
+      previous.clear();
+    },
+    write: (name: string, value: string): void => {
+      remember(name);
+      writeCookie(document, name, value);
+      installed.set(name, value);
+    },
+  });
+}
+
+function sourcepointBindings(candidate: unknown): SourcepointInitialBindings | undefined {
+  const fields = exactRecord(candidate, [
+    'config',
+    'document',
+    'observe',
+    'origin',
+    'registerRoute',
+    'storage',
+  ]);
+  const config = exactRecord(fields?.config, ['rewriteSdk']);
+  if (
+    !fields ||
+    !config ||
+    typeof config.rewriteSdk !== 'boolean' ||
+    typeof fields.document !== 'object' ||
+    fields.document === null ||
+    typeof (fields.document as CookieDocument).cookie !== 'string' ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.origin !== 'string' ||
+    typeof fields.registerRoute !== 'function' ||
+    typeof fields.storage !== 'object' ||
+    fields.storage === null
+  ) {
+    return undefined;
+  }
+  const storage = fields.storage as StorageReader;
+  if (
+    typeof storage.length !== 'number' ||
+    typeof storage.key !== 'function' ||
+    typeof storage.getItem !== 'function'
+  ) {
+    return undefined;
+  }
+  try {
+    if (new URL(fields.origin).origin !== fields.origin) return undefined;
+  } catch {
+    return undefined;
+  }
+  return {
+    config: Object.freeze({ rewriteSdk: config.rewriteSdk }),
+    document: fields.document as CookieDocument,
+    observe: fields.observe as SourcepointInitialBindings['observe'],
+    origin: fields.origin,
+    registerRoute: fields.registerRoute as SourcepointInitialBindings['registerRoute'],
+    storage,
+  };
+}
+
+function normalizeSourcepointUrl(url: string): URL | undefined {
+  const trimmed = url.trim();
+  if (!trimmed) return undefined;
+  try {
+    return new URL(
+      trimmed.startsWith('//')
+        ? `https:${trimmed}`
+        : /^https?:\/\//.test(trimmed)
+          ? trimmed
+          : `https://${trimmed}`
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function sourcepointConsent(
+  storage: StorageReader
+): Readonly<{ applicableSections?: readonly number[]; gppString: string }> | undefined {
+  let length: number;
+  try {
+    length = Math.min(Math.max(0, storage.length), MAX_STORAGE_ENTRIES);
+  } catch {
+    return undefined;
+  }
+  for (let index = 0; index < length; index += 1) {
+    let key: string | null;
+    let raw: string | null;
+    try {
+      key = storage.key(index);
+      if (!key?.startsWith('_sp_user_consent_')) continue;
+      raw = storage.getItem(key);
+    } catch {
+      continue;
+    }
+    if (!raw) continue;
+    try {
+      const payload = JSON.parse(raw);
+      const gppData = payload?.gppData;
+      if (typeof gppData?.gppString === 'string' && gppData.gppString.length > 0) {
+        return Object.freeze({
+          gppString: gppData.gppString,
+          ...(Array.isArray(gppData.applicableSections) &&
+          gppData.applicableSections.every((value: unknown) => typeof value === 'number')
+            ? { applicableSections: Object.freeze([...gppData.applicableSections]) }
+            : {}),
+        });
+      }
+      for (const [name, section] of Object.entries(payload ?? {})) {
+        if (name === 'gppData' || !isRecord(section)) continue;
+        const consentString = section.consentString;
+        if (typeof consentString !== 'string' || !consentString.includes('~')) continue;
+        let applicableSections: readonly number[] | undefined;
+        if (
+          Array.isArray(section.applicableSections) &&
+          section.applicableSections.every((value) => typeof value === 'number')
+        ) {
+          applicableSections = Object.freeze([...section.applicableSections]);
+        } else if (Array.isArray(section.consentStrings)) {
+          const ids = section.consentStrings
+            .map((entry: unknown) => (isRecord(entry) ? entry.sectionId : undefined))
+            .filter((value: unknown): value is number => typeof value === 'number');
+          if (ids.length > 0) applicableSections = Object.freeze(ids);
+        }
+        return Object.freeze({
+          gppString: consentString,
+          ...(applicableSections ? { applicableSections } : {}),
+        });
+      }
+    } catch {
+      // Continue to the next origin-scoped Sourcepoint payload.
+    }
+  }
+  return undefined;
+}
+
+/** Own Sourcepoint's one-shot SDK route and initial GPP storage mirror. */
+export function installSourcepointInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = sourcepointBindings(candidate);
+  if (!bindings || typeof own !== 'function') {
+    throw new TypeError('invalid Sourcepoint initial bindings');
+  }
+  if (bindings.config.rewriteSdk) {
+    const release = bindings.registerRoute(
+      Object.freeze({
+        id: 'sourcepoint' as const,
+        matches: (kind: FirstDisplayConsentRouteKindV1, url: string) =>
+          SCRIPT_KINDS.has(kind) &&
+          normalizeSourcepointUrl(url)?.hostname === 'cdn.privacy-mgmt.com',
+        rewrite: (url: string) => {
+          const parsed = normalizeSourcepointUrl(url);
+          return parsed
+            ? `${bindings.origin}/integrations/sourcepoint/cdn${parsed.pathname}${parsed.search}`
+            : url;
+        },
+      })
+    );
+    if (typeof release !== 'function') throw new TypeError('invalid Sourcepoint route disposer');
+    own(release);
+  }
+
+  const cookies = createCookieOwner(bindings.document);
+  own(cookies.dispose);
+  const consent = sourcepointConsent(bindings.storage);
+  const marker = readCookie(bindings.document, SOURCEPOINT_MARKER);
+  if (!consent) {
+    if (marker === SOURCEPOINT_VALUE) {
+      cookies.clear('__gpp');
+      cookies.clear('__gpp_sid');
+      cookies.clear(SOURCEPOINT_MARKER);
+    }
+    bindings.observe('gpp_snapshot', 0);
+    return;
+  }
+  const existingGpp = readCookie(bindings.document, '__gpp');
+  if (existingGpp && existingGpp !== consent.gppString && marker !== SOURCEPOINT_VALUE) {
+    bindings.observe('gpp_snapshot', 0);
+    return;
+  }
+  cookies.write(SOURCEPOINT_MARKER, SOURCEPOINT_VALUE);
+  cookies.write('__gpp', consent.gppString);
+  if (consent.applicableSections && consent.applicableSections.length > 0) {
+    cookies.write('__gpp_sid', consent.applicableSections.join(','));
+  } else {
+    cookies.clear('__gpp_sid');
+  }
+  bindings.observe('gpp_snapshot', consent.gppString.length);
+}
+
+function osanoBindings(candidate: unknown): OsanoInitialBindings | undefined {
+  const fields = exactRecord(candidate, [
+    'clearTimer',
+    'document',
+    'observe',
+    'setTimer',
+    'target',
+  ]);
+  if (
+    !fields ||
+    typeof fields.clearTimer !== 'function' ||
+    typeof fields.document !== 'object' ||
+    fields.document === null ||
+    typeof (fields.document as CookieDocument).cookie !== 'string' ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.setTimer !== 'function' ||
+    typeof fields.target !== 'object' ||
+    fields.target === null
+  ) {
+    return undefined;
+  }
+  return fields as unknown as OsanoInitialBindings;
+}
+
+function emptyResult(): ConsentResult {
+  return Object.freeze({ writes: Object.freeze([]), clears: Object.freeze([]) });
+}
+
+function canWriteOsano(document: CookieDocument): boolean {
+  const marker = readCookie(document, OSANO_MARKER);
+  if (marker === OSANO_VALUE) return true;
+  if (marker !== undefined) return false;
+  return OSANO_TARGETS.every((name) => readCookie(document, name) === undefined);
+}
+
+/** Own the initial one-shot Osano USP/GPP/TCF snapshot, without later lifecycle hooks. */
+export function installOsanoInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = osanoBindings(candidate);
+  if (!bindings || typeof own !== 'function') throw new TypeError('invalid Osano initial bindings');
+
+  const cookies = createCookieOwner(bindings.document);
+  const timers = new Set<unknown>();
+  let active = true;
+  own(() => {
+    if (!active) return;
+    active = false;
+    for (const timer of timers) {
+      try {
+        bindings.clearTimer(timer);
+      } catch {
+        // Continue releasing the remaining initial API timeouts.
+      }
+    }
+    timers.clear();
+    cookies.dispose();
+  });
+
+  const results: ConsentResult[] = [];
+  let remaining = 3;
+  const finish = (result: ConsentResult): void => {
+    if (!active) return;
+    results.push(result);
+    remaining -= 1;
+    if (remaining !== 0) return;
+    const writes = results.flatMap((entry) => entry.writes);
+    const clears = results.flatMap((entry) => entry.clears);
+    if ((writes.length === 0 && clears.length === 0) || !canWriteOsano(bindings.document)) {
+      bindings.observe('consent_snapshot', 0);
+      return;
+    }
+    const writtenNames = new Set(writes.map(({ name }) => name));
+    for (const name of clears) if (!writtenNames.has(name)) cookies.clear(name);
+    for (const { name, value } of writes) cookies.write(name, value);
+    const hasTarget = OSANO_TARGETS.some(
+      (name) => readCookie(bindings.document, name) !== undefined
+    );
+    if (hasTarget) cookies.write(OSANO_MARKER, OSANO_VALUE);
+    else if (readCookie(bindings.document, OSANO_MARKER) === OSANO_VALUE) {
+      cookies.clear(OSANO_MARKER);
+    }
+    bindings.observe('consent_snapshot', writes.length + clears.length);
+  };
+
+  const invoke = (
+    available: boolean,
+    call: (callback: (data?: unknown, success?: boolean) => void) => void,
+    parse: (data: unknown, success: boolean | undefined) => ConsentResult
+  ): void => {
+    if (!available) {
+      finish(emptyResult());
+      return;
+    }
+    let settled = false;
+    const timerBox: { value?: unknown } = {};
+    const done = (result: ConsentResult): void => {
+      if (settled) return;
+      settled = true;
+      if (timerBox.value !== undefined) {
+        timers.delete(timerBox.value);
+        try {
+          bindings.clearTimer(timerBox.value);
+        } catch {
+          // Timer cancellation failure does not permit a second settlement.
+        }
+      }
+      finish(result);
+    };
+    const handle = bindings.setTimer(() => done(emptyResult()), 500);
+    timerBox.value = handle;
+    if (settled) {
+      try {
+        bindings.clearTimer(handle);
+      } catch {
+        // A synchronous timer cannot reopen an already-settled signal.
+      }
+    } else {
+      timers.add(handle);
+    }
+    try {
+      call((data, success) => {
+        try {
+          done(parse(data, success));
+        } catch {
+          done(emptyResult());
+        }
+      });
+    } catch {
+      done(emptyResult());
+    }
+  };
+
+  const usp = bindings.target.__uspapi;
+  invoke(
+    typeof usp === 'function',
+    (callback) => usp?.('getUSPData', 1, callback),
+    (data, success) => {
+      if (success === false || !isRecord(data)) return emptyResult();
+      if ('uspString' in data && typeof data.uspString !== 'string') return emptyResult();
+      return typeof data.uspString === 'string' && data.uspString.length > 0
+        ? Object.freeze({
+            writes: Object.freeze([{ name: 'us_privacy', value: data.uspString }]),
+            clears: Object.freeze([]),
+          })
+        : emptyResult();
+    }
+  );
+
+  const gpp = bindings.target.__gpp;
+  invoke(
+    typeof gpp === 'function',
+    (callback) => gpp?.('ping', callback),
+    (data, success) => {
+      if (success === false || !isRecord(data) || data.signalStatus !== 'ready') {
+        return emptyResult();
+      }
+      if ('gppString' in data && typeof data.gppString !== 'string') return emptyResult();
+      if (
+        'applicableSections' in data &&
+        data.applicableSections !== undefined &&
+        (!Array.isArray(data.applicableSections) ||
+          !data.applicableSections.every((value) => typeof value === 'number'))
+      ) {
+        return emptyResult();
+      }
+      if (typeof data.gppString !== 'string' || data.gppString.length === 0) {
+        return emptyResult();
+      }
+      const sections = data.applicableSections as number[] | undefined;
+      const includeSections =
+        Array.isArray(sections) && sections.length > 0 && !sections.includes(-1);
+      return Object.freeze({
+        writes: Object.freeze([
+          { name: '__gpp', value: data.gppString },
+          ...(includeSections ? [{ name: '__gpp_sid', value: sections.join(',') }] : []),
+        ]),
+        clears: Object.freeze(includeSections ? [] : ['__gpp_sid']),
+      });
+    }
+  );
+
+  const tcf = bindings.target.__tcfapi;
+  invoke(
+    typeof tcf === 'function',
+    (callback) => tcf?.('getTCData', 2, callback),
+    (data, success) => {
+      if (
+        success === false ||
+        !isRecord(data) ||
+        !['tcloaded', 'useractioncomplete'].includes(data.eventStatus as string) ||
+        ('tcString' in data && typeof data.tcString !== 'string') ||
+        typeof data.tcString !== 'string' ||
+        data.tcString.length === 0
+      ) {
+        return emptyResult();
+      }
+      return Object.freeze({
+        writes: Object.freeze([{ name: 'euconsent-v2', value: data.tcString }]),
+        clears: Object.freeze([]),
+      });
+    }
+  );
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/context_snapshot.ts b/crates/trusted-server-js/lib/src/first_display/leaf/context_snapshot.ts
new file mode 100644
index 000000000..73b3317f9
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/context_snapshot.ts
@@ -0,0 +1,277 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+export type FirstDisplayContextRouteKindV1 = 'script' | 'preload' | 'prefetch';
+
+export interface FirstDisplayContextRouteRuleV1 {
+  readonly id: 'permutive';
+  readonly matches: (kind: FirstDisplayContextRouteKindV1, url: string) => boolean;
+  readonly rewrite: (url: string) => string;
+}
+
+const CONFIG_FIELDS = [
+  'apiHost',
+  'apiProtocol',
+  'cdnBaseUrl',
+  'cdnProtocol',
+  'secureSignalsApiHost',
+  'segmentSyncApiHost',
+] as const;
+const SCRIPT_KINDS = new Set<FirstDisplayContextRouteKindV1>(['script', 'preload', 'prefetch']);
+const MAX_SEGMENTS = 100;
+const MAX_SEGMENT_LENGTH = 256;
+const MAX_SERIALIZED_SEGMENTS_LENGTH = 4_096;
+
+type ConfigField = (typeof CONFIG_FIELDS)[number];
+type PermutiveConfig = Record<ConfigField, string>;
+
+interface PermutiveSdk {
+  readonly config: PermutiveConfig;
+}
+
+interface PermutiveInitialBindings {
+  readonly clearTimer: (handle: unknown) => void;
+  readonly getSdk: () => PermutiveSdk | undefined;
+  readonly host: string;
+  readonly observe: (name: string, value: string | number) => void;
+  readonly origin: string;
+  readonly protocol: 'http:' | 'https:';
+  readonly readStorage: (key: string) => string | null;
+  readonly registerRoute: (rule: FirstDisplayContextRouteRuleV1) => () => void;
+  readonly setTimer: (callback: () => void, delayMs: number) => unknown;
+}
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const fields: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      fields[key] = descriptor.value;
+    }
+    return fields;
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotBindings(candidate: unknown): PermutiveInitialBindings | undefined {
+  const fields = exactRecord(candidate, [
+    'clearTimer',
+    'getSdk',
+    'host',
+    'observe',
+    'origin',
+    'protocol',
+    'readStorage',
+    'registerRoute',
+    'setTimer',
+  ]);
+  if (
+    !fields ||
+    typeof fields.clearTimer !== 'function' ||
+    typeof fields.getSdk !== 'function' ||
+    typeof fields.host !== 'string' ||
+    fields.host.length === 0 ||
+    fields.host.length > 255 ||
+    fields.host.includes('/') ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.origin !== 'string' ||
+    !['http:', 'https:'].includes(fields.protocol as string) ||
+    typeof fields.readStorage !== 'function' ||
+    typeof fields.registerRoute !== 'function' ||
+    typeof fields.setTimer !== 'function'
+  ) {
+    return undefined;
+  }
+  try {
+    const origin = new URL(fields.origin).origin;
+    if (origin !== fields.origin) return undefined;
+    if (new URL(origin).protocol !== fields.protocol) return undefined;
+  } catch {
+    return undefined;
+  }
+  return fields as unknown as PermutiveInitialBindings;
+}
+
+function normalizedSegments(candidate: unknown): readonly string[] {
+  if (!Array.isArray(candidate) || candidate.length === 0) return Object.freeze([]);
+  const values: string[] = [];
+  for (let index = 0; index < candidate.length && values.length < MAX_SEGMENTS; index += 1) {
+    const value = candidate[index];
+    if (typeof value !== 'string' && typeof value !== 'number') continue;
+    const normalized = String(value);
+    if (normalized.length === 0 || normalized.length > MAX_SEGMENT_LENGTH) continue;
+    const candidateValues = [...values, normalized];
+    if (JSON.stringify(candidateValues).length > MAX_SERIALIZED_SEGMENTS_LENGTH) break;
+    values.push(normalized);
+  }
+  return Object.freeze(values);
+}
+
+/** Parse the exact current-main Permutive storage shapes without importing its persistent owner. */
+export function snapshotPermutiveInitialSegments(raw: string | null): readonly string[] {
+  if (!raw) return Object.freeze([]);
+  try {
+    const data = JSON.parse(raw);
+    const primary = normalizedSegments(data?.core?.cohorts?.all);
+    if (primary.length > 0) return primary;
+    const uploads = data?.eventPublication?.eventUpload;
+    if (!Array.isArray(uploads)) return Object.freeze([]);
+    for (let index = uploads.length - 1; index >= 0; index -= 1) {
+      const entry = uploads[index];
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const fallback = normalizedSegments(entry[1]?.event?.properties?.segments);
+      if (fallback.length > 0) return fallback;
+    }
+  } catch {
+    // Malformed or hostile storage is equivalent to no context.
+  }
+  return Object.freeze([]);
+}
+
+function isPermutiveSdkUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    const hostname = parsed.hostname.toLowerCase();
+    return (
+      parsed.protocol === 'https:' &&
+      (hostname === 'cdn.permutive.com' || hostname.endsWith('.edge.permutive.app')) &&
+      parsed.pathname.toLowerCase().endsWith('-web.js') &&
+      parsed.search === '' &&
+      parsed.hash === ''
+    );
+  } catch {
+    return false;
+  }
+}
+
+function bestEffort(action: () => void): void {
+  try {
+    action();
+  } catch {
+    // Independent provisional resources must continue releasing in reverse order.
+  }
+}
+
+/** Own Permutive's one-shot route, auction context, and bounded SDK config readiness. */
+export function installPermutiveInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = snapshotBindings(candidate);
+  if (!bindings || typeof own !== 'function') {
+    throw new TypeError('invalid Permutive initial bindings');
+  }
+
+  const releaseRoute = bindings.registerRoute(
+    Object.freeze({
+      id: 'permutive' as const,
+      matches: (kind: FirstDisplayContextRouteKindV1, url: string) =>
+        SCRIPT_KINDS.has(kind) && isPermutiveSdkUrl(url),
+      rewrite: () => `${bindings.origin}/integrations/permutive/sdk`,
+    })
+  );
+  if (typeof releaseRoute !== 'function') throw new TypeError('invalid Permutive route disposer');
+  own(releaseRoute);
+
+  let initialSegments: readonly string[] = Object.freeze([]);
+  try {
+    initialSegments = snapshotPermutiveInitialSegments(bindings.readStorage('permutive-app'));
+  } catch {
+    // Hostile storage is equivalent to no initial Permutive context.
+  }
+  if (initialSegments.length > 0) {
+    bindings.observe('segments', JSON.stringify(initialSegments));
+  }
+
+  let active = true;
+  let timer: unknown;
+  let ownedConfig: PermutiveConfig | undefined;
+  let installedValues: PermutiveConfig | undefined;
+  let previousValues: PermutiveConfig | undefined;
+  own(() => {
+    if (!active) return;
+    active = false;
+    if (timer !== undefined) {
+      bestEffort(() => bindings.clearTimer(timer));
+      timer = undefined;
+    }
+    const config = ownedConfig;
+    const installed = installedValues;
+    const previous = previousValues;
+    if (!config || !installed || !previous) return;
+    for (const field of CONFIG_FIELDS) {
+      bestEffort(() => {
+        if (config[field] === installed[field]) config[field] = previous[field];
+      });
+    }
+  });
+
+  const installConfig = (config: PermutiveConfig): boolean => {
+    const protocol = bindings.protocol === 'https:' ? 'https' : 'http';
+    const next: PermutiveConfig = {
+      apiHost: `${bindings.host}/integrations/permutive/api`,
+      apiProtocol: protocol,
+      cdnBaseUrl: `${bindings.host}/integrations/permutive/cdn`,
+      cdnProtocol: protocol,
+      secureSignalsApiHost: `${bindings.host}/integrations/permutive/secure-signal`,
+      segmentSyncApiHost: `${bindings.host}/integrations/permutive/sync`,
+    };
+    const previous = {} as PermutiveConfig;
+    const written: ConfigField[] = [];
+    try {
+      for (const field of CONFIG_FIELDS) previous[field] = config[field];
+      for (const field of CONFIG_FIELDS) {
+        config[field] = next[field];
+        written.push(field);
+      }
+    } catch {
+      for (const field of written.reverse()) {
+        bestEffort(() => {
+          if (config[field] === next[field]) config[field] = previous[field];
+        });
+      }
+      return false;
+    }
+    ownedConfig = config;
+    installedValues = next;
+    previousValues = previous;
+    bindings.observe('sdk_config', bindings.host);
+    return true;
+  };
+
+  let attempts = 0;
+  const check = (): void => {
+    timer = undefined;
+    if (!active) return;
+    attempts += 1;
+    try {
+      const sdk = bindings.getSdk();
+      if (sdk?.config && installConfig(sdk.config)) return;
+    } catch {
+      // An unreadable SDK is treated as not ready until the bounded deadline.
+    }
+    if (attempts >= 50) {
+      bindings.observe('readiness_timeout', attempts);
+      return;
+    }
+    timer = bindings.setTimer(check, 50);
+  };
+  check();
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/creative_guard.ts b/crates/trusted-server-js/lib/src/first_display/leaf/creative_guard.ts
new file mode 100644
index 000000000..9dbd38bf6
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/creative_guard.ts
@@ -0,0 +1,83 @@
+import type { CreativeBootV1 } from '../../core/types';
+import {
+  createCreativeStartup,
+  type CreativeStartupOptions,
+} from '../../integrations/creative/startup';
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+interface CreativeInitialBindings extends Pick<
+  CreativeStartupOptions,
+  'document' | 'installClickGuard' | 'installDynamicIframeProxy' | 'installDynamicImageProxy'
+> {
+  readonly observe: (name: 'guard_count', value: number) => void;
+}
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotConfig(candidate: unknown): Readonly<CreativeBootV1> | undefined {
+  const config = exactRecord(candidate, ['version', 'enabled', 'clickGuard', 'renderGuard']);
+  if (
+    !config ||
+    config.version !== 1 ||
+    config.enabled !== true ||
+    typeof config.clickGuard !== 'boolean' ||
+    typeof config.renderGuard !== 'boolean' ||
+    (!config.clickGuard && !config.renderGuard)
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    version: 1,
+    enabled: true,
+    clickGuard: config.clickGuard,
+    renderGuard: config.renderGuard,
+  });
+}
+
+/** Install the selected parser-time creative guards under the agent rollback owner. */
+export function installCreativeInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own'],
+  configCandidate: unknown
+): void {
+  const bindings = candidate as CreativeInitialBindings;
+  const config = snapshotConfig(configCandidate);
+  if (!config || typeof own !== 'function') throw new TypeError('tsjs');
+  const startup = createCreativeStartup({
+    document: bindings.document,
+    installClickGuard: bindings.installClickGuard,
+    installDynamicIframeProxy: bindings.installDynamicIframeProxy,
+    installDynamicImageProxy: bindings.installDynamicImageProxy,
+  });
+  const release = startup.activate(config);
+  own(release);
+  bindings.observe('guard_count', (config.clickGuard ? 1 : 0) + (config.renderGuard ? 2 : 0));
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/gpt_protocol.ts b/crates/trusted-server-js/lib/src/first_display/leaf/gpt_protocol.ts
new file mode 100644
index 000000000..50a3c7b2c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/gpt_protocol.ts
@@ -0,0 +1,165 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+import type {
+  FirstDisplayGoogletagBatch,
+  FirstDisplayGoogletagBatchCallbacks,
+  FirstDisplayGoogletagBatchInput,
+  FirstDisplayGptCaptureCycleV1,
+  FirstDisplayGptDiagnosticsHandoffV1,
+} from '../adapters/googletag';
+import { enqueueFirstDisplayGamAttribution } from '../adapters/googletag';
+
+export type { FirstDisplayGptCaptureCycleV1 } from '../adapters/googletag';
+
+export interface FirstDisplayGptRequestPlanV1 {
+  readonly operations: readonly ('display' | 'refresh')[];
+  readonly requestOperation: 0 | 1;
+}
+
+export type FirstDisplayGptProtocolV1 = readonly [
+  version: 1,
+  id: 'gpt',
+  createBatch: (input: FirstDisplayGoogletagBatchInput) => FirstDisplayGptCapabilityV1,
+];
+
+export type FirstDisplayGptDiagnosticsCaptureV1 = FirstDisplayGptDiagnosticsHandoffV1;
+
+export type FirstDisplayGptCapabilityV1 = readonly [
+  start: (callbacks: FirstDisplayGoogletagBatchCallbacks) => boolean,
+  closeIngress: (committedSlotIds: readonly string[]) => boolean,
+  captureHandoff: () => readonly FirstDisplayGptCaptureCycleV1[] | undefined,
+  captureDiagnosticsHandoff: () => FirstDisplayGptDiagnosticsCaptureV1 | undefined,
+  detachCommittedSlots: (slotIds: readonly string[]) => boolean,
+  dispose: () => void,
+];
+
+export interface FirstDisplayGptBatchPolicyV1 {
+  readonly deadlines: Readonly<{
+    externalReadyMs: 10_000;
+    requestStartMs: 3_000;
+    completionMs: 10_000;
+  }>;
+  readonly requestPlan: (candidate: unknown) => FirstDisplayGptRequestPlanV1 | undefined;
+  readonly classifyRenderEnded: (candidate: unknown) => 'gam_empty' | 'nonempty_gam' | undefined;
+}
+
+interface GptInitialBindings {
+  readonly browser: Window & { googletag?: unknown };
+  readonly observe: (name: 'gam' | 'v', value: boolean | number) => void;
+  readonly register: (protocol: FirstDisplayGptProtocolV1) => () => void;
+}
+
+export type FirstDisplayGptBatchFactoryV1 = (
+  input: FirstDisplayGoogletagBatchInput,
+  policy: FirstDisplayGptBatchPolicyV1
+) => FirstDisplayGoogletagBatch;
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function requestPlan(candidate: unknown): FirstDisplayGptRequestPlanV1 | undefined {
+  const fields = exactRecord(candidate, ['initialLoadDisabled', 'ownership']);
+  if (
+    !fields ||
+    !Object.isFrozen(candidate) ||
+    typeof fields.initialLoadDisabled !== 'boolean' ||
+    (fields.ownership !== 'publisher' && fields.ownership !== 'trusted_server')
+  ) {
+    return undefined;
+  }
+  if (fields.ownership === 'publisher') {
+    return Object.freeze({ operations: Object.freeze(['refresh'] as const), requestOperation: 0 });
+  }
+  if (fields.initialLoadDisabled) {
+    return Object.freeze({
+      operations: Object.freeze(['display', 'refresh'] as const),
+      requestOperation: 1,
+    });
+  }
+  return Object.freeze({ operations: Object.freeze(['display'] as const), requestOperation: 0 });
+}
+
+function classifyRenderEnded(candidate: unknown): 'gam_empty' | 'nonempty_gam' | undefined {
+  const fields = exactRecord(candidate, ['isEmpty']);
+  if (!fields || typeof fields.isEmpty !== 'boolean') return undefined;
+  return fields.isEmpty ? 'gam_empty' : 'nonempty_gam';
+}
+
+/** Register the sole provisional GPT request planning and cycle-attribution policy. */
+export function installGptInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own'],
+  createBatch: FirstDisplayGptBatchFactoryV1,
+  configCandidate: unknown
+): readonly [version: 1, id: 'gpt'] {
+  // The authenticated bootstrap is the sole caller and owns this capability object.
+  const value = candidate as GptInitialBindings;
+  const gamAttributionEnabled = (
+    configCandidate as Readonly<{ gamAttributionEnabled?: unknown }> | undefined
+  )?.gamAttributionEnabled;
+  if (
+    typeof own !== 'function' ||
+    typeof createBatch !== 'function' ||
+    typeof gamAttributionEnabled !== 'boolean'
+  ) {
+    throw new TypeError('tsjs');
+  }
+  const policy: FirstDisplayGptBatchPolicyV1 = Object.freeze({
+    deadlines: Object.freeze({
+      externalReadyMs: 10_000,
+      requestStartMs: 3_000,
+      completionMs: 10_000,
+    }),
+    requestPlan,
+    classifyRenderEnded,
+  });
+  const protocol: FirstDisplayGptProtocolV1 = Object.freeze([
+    1,
+    'gpt',
+    (input: FirstDisplayGoogletagBatchInput): FirstDisplayGptCapabilityV1 => {
+      const batch = createBatch(input, policy);
+      return Object.freeze([
+        batch.start,
+        batch.closeIngress,
+        batch.captureHandoff,
+        batch.captureDiagnosticsHandoff,
+        batch.detachCommittedSlots,
+        batch.dispose,
+      ]);
+    },
+  ]);
+  const release = value.register(protocol);
+  if (typeof release !== 'function') throw new TypeError('tsjs');
+  own(release);
+  value.observe('gam', gamAttributionEnabled);
+  value.observe('v', 1);
+  if (gamAttributionEnabled && !enqueueFirstDisplayGamAttribution(value.browser)) {
+    throw new TypeError('tsjs');
+  }
+  return Object.freeze([1, 'gpt']);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/prebid_protocol.ts b/crates/trusted-server-js/lib/src/first_display/leaf/prebid_protocol.ts
new file mode 100644
index 000000000..55c4a64bb
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/prebid_protocol.ts
@@ -0,0 +1,254 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+export interface FirstDisplayPreparedTrustedBidV1 {
+  readonly auctionId: string;
+  readonly adUnitCode: string;
+  readonly bid: Readonly<{
+    readonly requestId: string;
+    readonly adId: string;
+    readonly cpm: number;
+    readonly width: number;
+    readonly height: number;
+    readonly ad: '';
+    readonly ttl: 300;
+    readonly creativeId: string;
+    readonly netRevenue: true;
+    readonly currency: 'USD';
+    readonly bidderCode: 'trustedServer';
+    readonly meta: Readonly<{
+      readonly advertiserDomains: readonly string[];
+      readonly tsAuctionId: string;
+      readonly tsBidId: string;
+      readonly tsAdmHash?: string;
+    }>;
+  }>;
+}
+
+export interface FirstDisplayPrebidPolicyV1 {
+  readonly version: 1;
+  readonly id: 'prebid';
+  readonly bidderCode: 'trustedServer';
+  readonly maxPendingOperations: 64;
+  readonly externalReadyMs: 10_000;
+  readonly admissionLeaseMs: 10_000;
+  readonly renderReservationMs: 900_000;
+  readonly normalizeEidSource: (candidate: unknown) => string | undefined;
+  readonly snapshotTrustedBid: (candidate: unknown) => FirstDisplayPreparedTrustedBidV1 | undefined;
+}
+
+export type FirstDisplayPrebidProtocolV1 = readonly [
+  version: 1,
+  id: 'prebid',
+  policy: FirstDisplayPrebidPolicyV1,
+];
+
+interface PrebidInitialBindings {
+  readonly observe: (name: 'protocol_version', value: number) => void;
+  readonly register: (protocol: FirstDisplayPrebidProtocolV1) => () => void;
+}
+
+const textEncoder = new TextEncoder();
+const RESERVATION = /^r1_[A-Za-z0-9_-]{22}$/;
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function bindings(candidate: unknown): PrebidInitialBindings | undefined {
+  const fields = exactRecord(candidate, ['observe', 'register']);
+  return fields && typeof fields.observe === 'function' && typeof fields.register === 'function'
+    ? (fields as unknown as PrebidInitialBindings)
+    : undefined;
+}
+
+function validString(candidate: unknown, maximumBytes: number): candidate is string {
+  if (
+    typeof candidate !== 'string' ||
+    candidate.length === 0 ||
+    textEncoder.encode(candidate).byteLength > maximumBytes
+  ) {
+    return false;
+  }
+  for (let index = 0; index < candidate.length; index += 1) {
+    const code = candidate.charCodeAt(index);
+    if (code <= 0x1f || code === 0x7f) return false;
+  }
+  return true;
+}
+
+function frozenStrings(
+  candidate: unknown,
+  maximumLength: number,
+  maximumBytes: number
+): readonly string[] | undefined {
+  if (
+    !Array.isArray(candidate) ||
+    !Object.isFrozen(candidate) ||
+    candidate.length > maximumLength ||
+    Reflect.ownKeys(candidate).length !== candidate.length + 1
+  ) {
+    return undefined;
+  }
+  const result: string[] = [];
+  for (let index = 0; index < candidate.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+    if (
+      !descriptor?.enumerable ||
+      !('value' in descriptor) ||
+      !validString(descriptor.value, maximumBytes)
+    ) {
+      return undefined;
+    }
+    result.push(descriptor.value);
+  }
+  return Object.freeze(result);
+}
+
+function normalizeEidSource(candidate: unknown): string | undefined {
+  if (typeof candidate !== 'string') return undefined;
+  const normalized = candidate.trim().toLowerCase();
+  return validString(normalized, 256) ? normalized : undefined;
+}
+
+function snapshotTrustedBid(candidate: unknown): FirstDisplayPreparedTrustedBidV1 | undefined {
+  try {
+    const prepared = exactRecord(candidate, ['auctionId', 'adUnitCode', 'bid']);
+    const bid = exactRecord(prepared?.bid, [
+      'requestId',
+      'adId',
+      'cpm',
+      'width',
+      'height',
+      'ad',
+      'ttl',
+      'creativeId',
+      'netRevenue',
+      'currency',
+      'bidderCode',
+      'meta',
+    ]);
+    if (
+      !prepared ||
+      !bid ||
+      !validString(prepared.auctionId, 128) ||
+      !validString(prepared.adUnitCode, 256) ||
+      !validString(bid.requestId, 128) ||
+      typeof bid.adId !== 'string' ||
+      !RESERVATION.test(bid.adId) ||
+      typeof bid.cpm !== 'number' ||
+      !Number.isFinite(bid.cpm) ||
+      bid.cpm < 0 ||
+      typeof bid.width !== 'number' ||
+      !Number.isInteger(bid.width) ||
+      bid.width < 1 ||
+      bid.width > 4096 ||
+      typeof bid.height !== 'number' ||
+      !Number.isInteger(bid.height) ||
+      bid.height < 1 ||
+      bid.height > 4096 ||
+      bid.ad !== '' ||
+      bid.ttl !== 300 ||
+      !validString(bid.creativeId, 256) ||
+      bid.netRevenue !== true ||
+      bid.currency !== 'USD' ||
+      bid.bidderCode !== 'trustedServer'
+    ) {
+      return undefined;
+    }
+    const hasAdmHash = Object.prototype.hasOwnProperty.call(bid.meta, 'tsAdmHash');
+    const meta = exactRecord(
+      bid.meta,
+      hasAdmHash
+        ? ['advertiserDomains', 'tsAuctionId', 'tsBidId', 'tsAdmHash']
+        : ['advertiserDomains', 'tsAuctionId', 'tsBidId']
+    );
+    const advertiserDomains = frozenStrings(meta?.advertiserDomains, 16, 256);
+    if (
+      !meta ||
+      !advertiserDomains ||
+      meta.tsAuctionId !== prepared.auctionId ||
+      !validString(meta.tsBidId, 256) ||
+      (meta.tsAdmHash !== undefined && !validString(meta.tsAdmHash, 128))
+    ) {
+      return undefined;
+    }
+    const frozenMeta = Object.freeze({
+      advertiserDomains,
+      tsAuctionId: meta.tsAuctionId as string,
+      tsBidId: meta.tsBidId,
+      ...(meta.tsAdmHash === undefined ? {} : { tsAdmHash: meta.tsAdmHash }),
+    });
+    return Object.freeze({
+      auctionId: prepared.auctionId,
+      adUnitCode: prepared.adUnitCode,
+      bid: Object.freeze({
+        requestId: bid.requestId,
+        adId: bid.adId,
+        cpm: bid.cpm,
+        width: bid.width,
+        height: bid.height,
+        ad: '',
+        ttl: 300,
+        creativeId: bid.creativeId,
+        netRevenue: true,
+        currency: 'USD',
+        bidderCode: 'trustedServer',
+        meta: frozenMeta,
+      }),
+    }) as FirstDisplayPreparedTrustedBidV1;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Register initial Prebid artifact, queue, EID, bidder, and reservation admission policy. */
+export function installPrebidInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): readonly [version: 1, id: 'prebid'] {
+  const value = bindings(candidate);
+  if (!value || typeof own !== 'function') throw new TypeError('tsjs');
+  const policy: FirstDisplayPrebidPolicyV1 = Object.freeze({
+    version: 1,
+    id: 'prebid',
+    bidderCode: 'trustedServer',
+    maxPendingOperations: 64,
+    externalReadyMs: 10_000,
+    admissionLeaseMs: 10_000,
+    renderReservationMs: 900_000,
+    normalizeEidSource,
+    snapshotTrustedBid,
+  });
+  const protocol: FirstDisplayPrebidProtocolV1 = Object.freeze([1, 'prebid', policy]);
+  const release = value.register(protocol);
+  if (typeof release !== 'function') throw new TypeError('tsjs');
+  own(release);
+  value.observe('protocol_version', 1);
+  return Object.freeze([1, 'prebid']);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/projection.ts b/crates/trusted-server-js/lib/src/first_display/leaf/projection.ts
new file mode 100644
index 000000000..66a319817
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/projection.ts
@@ -0,0 +1,601 @@
+const HASH = /^[0-9a-f]{64}$/;
+const AUCTION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const CANDIDATE_ID = /^[A-Za-z0-9_-]{12}$/;
+const PROVIDER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const RESERVATION_ID = /^r1_[A-Za-z0-9_-]{22}$/;
+const TARGETING_KEY = /^[A-Za-z0-9_]{1,20}$/;
+const MAX_SLOTS = 256;
+const MAX_FORMATS = 64;
+const MAX_TARGETING = 32;
+const MAX_PROJECTION_BYTES = 8 * 1024 * 1024;
+const MAX_ADM_BYTES = 512 * 1024;
+const MAX_APS_ENVELOPE_BASE64_BYTES = 349_528;
+const FAILURE_REASONS = new Set([
+  'auction_disabled',
+  'consent_denied',
+  'slot_not_eligible',
+  'provider_timeout',
+  'provider_error',
+  'invalid_provider_response',
+  'mediation_failed',
+  'winner_not_renderable',
+  'identity_generation_failed',
+  'internal_error',
+]);
+
+export type FirstDisplayAuctionProtocolId = 'aps' | 'gpt' | 'prebid';
+export type FirstDisplayProjectedKind = 'no_bid' | 'failed' | 'gpt_adm' | 'aps';
+
+export interface FirstDisplayBatchOutcomeV1 {
+  readonly slotId: string;
+  readonly kind: FirstDisplayProjectedKind;
+}
+
+export interface FirstDisplayProjectionSlotV1 {
+  readonly slot: string;
+  readonly gamUnitPath: string;
+  readonly divId: string;
+  readonly formats: readonly (readonly [number, number])[];
+  readonly targeting: Readonly<Record<string, string>>;
+}
+
+export interface FirstDisplayAdmSourceV1 {
+  readonly type: 'adm';
+  readonly version: 1;
+  readonly adm: string;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface FirstDisplayApsSourceV1 {
+  readonly type: 'aps';
+  readonly version: 1;
+  readonly accountId: string;
+  readonly bidId: string;
+  readonly creativeId?: string;
+  readonly tagType: 'iframe' | 'script';
+  readonly creativeUrl: string;
+  readonly aaxResponse: string;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface FirstDisplayProjectionBidV1 {
+  readonly candidateId: string;
+  readonly slot: string;
+  readonly provider: string;
+  readonly upstreamBidId: string;
+  readonly cpm: number;
+  readonly currency: 'USD';
+  readonly targeting: Readonly<Record<string, string>>;
+  readonly rendererReservationId: string;
+  readonly renderSource: FirstDisplayAdmSourceV1 | FirstDisplayApsSourceV1;
+}
+
+export type FirstDisplayProjectionDecisionV1 =
+  | Readonly<{ slot: string; outcome: 'winner'; candidateId: string }>
+  | Readonly<{ slot: string; outcome: 'no_bid' }>
+  | Readonly<{ slot: string; outcome: 'failed'; reason: string }>;
+
+export interface FirstDisplayProjectionV1 {
+  readonly version: 1;
+  readonly auction: Readonly<{
+    version: 1;
+    auctionId: string;
+    results: readonly FirstDisplayProjectionDecisionV1[];
+  }>;
+  readonly slots: readonly FirstDisplayProjectionSlotV1[];
+  readonly bids: readonly FirstDisplayProjectionBidV1[];
+}
+
+export interface FirstDisplayBatchV1 {
+  readonly version: 1;
+  readonly projectionDigest: string;
+  readonly requiredProtocols: readonly FirstDisplayAuctionProtocolId[];
+  readonly outcomes: readonly FirstDisplayBatchOutcomeV1[];
+  readonly projection: FirstDisplayProjectionV1;
+}
+
+/** Closure-compact batch retained by the bootstrap-owned first-display agent. */
+export type FirstDisplayAgentBatchV1 = readonly [
+  projectionDigest: string,
+  requiredProtocols: readonly FirstDisplayAuctionProtocolId[],
+  outcomes: readonly (readonly [slotId: string, kind: FirstDisplayProjectedKind])[],
+  projection: FirstDisplayProjectionV1,
+];
+
+/**
+ * Admit the immutable same-script server projection without cloning it again.
+ *
+ * Rust owns the exhaustive projection grammar and the bootstrap recursively freezes
+ * that generated data before this authenticated release artifact can receive it.
+ */
+export function acceptServerFirstDisplayBatchV1(
+  candidate: unknown
+): FirstDisplayAgentBatchV1 | undefined {
+  try {
+    const envelope = candidate as Readonly<{
+      version: unknown;
+      projectionDigest: unknown;
+      projection: FirstDisplayProjectionV1;
+    }>;
+    const projection = envelope.projection;
+    const results = projection.auction.results;
+    const { slots, bids } = projection;
+    // The authenticated bootstrap constructed this envelope from the already
+    // bounded, recursively frozen server transport. This leaf only derives the
+    // compact action plan and rechecks the bid/result relationships it consumes.
+    if (!Object.isFrozen(candidate)) return undefined;
+    const outcomes: Array<readonly [string, FirstDisplayProjectedKind]> = [];
+    let winner = 0;
+    let aps = false;
+    let prebid = false;
+    for (let index = 0; index < results.length; index += 1) {
+      const decision = results[index]!;
+      const slot = slots[index]!;
+      if (decision.slot !== slot.slot) return undefined;
+      if (decision.outcome !== 'winner') {
+        if (decision.outcome !== 'no_bid' && decision.outcome !== 'failed') return undefined;
+        outcomes.push(Object.freeze([decision.slot, decision.outcome] as const));
+        continue;
+      }
+      const bid = bids[winner++];
+      if (
+        !bid ||
+        bid.candidateId !== decision.candidateId ||
+        bid.slot !== decision.slot ||
+        (bid.renderSource.type !== 'adm' && bid.renderSource.type !== 'aps')
+      ) {
+        return undefined;
+      }
+      aps ||= bid.renderSource.type === 'aps';
+      prebid ||= bid.provider === 'prebid';
+      outcomes.push(
+        Object.freeze([decision.slot, bid.renderSource.type === 'aps' ? 'aps' : 'gpt_adm'])
+      );
+    }
+    if (winner !== bids.length) return undefined;
+    return Object.freeze([
+      envelope.projectionDigest as string,
+      Object.freeze([
+        ...(aps ? (['aps'] as const) : []),
+        ...(winner ? (['gpt'] as const) : []),
+        ...(prebid ? (['prebid'] as const) : []),
+      ]),
+      Object.freeze(outcomes),
+      projection,
+    ]);
+  } catch {
+    return undefined;
+  }
+}
+
+const textEncoder = new TextEncoder();
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      !Object.isFrozen(value)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(value);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const result: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[key] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function exactArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+  try {
+    if (
+      !Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Array.prototype ||
+      !Object.isFrozen(value) ||
+      value.length > maximum ||
+      Reflect.ownKeys(value).length !== value.length + 1
+    ) {
+      return undefined;
+    }
+    const result: unknown[] = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result.push(descriptor.value);
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function validString(
+  value: unknown,
+  maximumBytes: number,
+  options: Readonly<{ allowControls?: boolean; maximumScalars?: number }> = {}
+): value is string {
+  if (typeof value !== 'string' || value.length === 0) return false;
+  let scalars = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (options.allowControls !== true && (code <= 0x1f || code === 0x7f)) return false;
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return false;
+    }
+    scalars += 1;
+    if (options.maximumScalars !== undefined && scalars > options.maximumScalars) return false;
+  }
+  return textEncoder.encode(value).byteLength <= maximumBytes;
+}
+
+function validDimension(value: unknown): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isInteger(value) &&
+    Number.isFinite(value) &&
+    value >= 1 &&
+    value <= 4096
+  );
+}
+
+function snapshotTargeting(value: unknown): Readonly<Record<string, string>> | undefined {
+  const record = exactRecord(value, Reflect.ownKeys(value as object) as string[]);
+  if (!record) return undefined;
+  const keys = Object.keys(record).sort();
+  if (keys.length > MAX_TARGETING) return undefined;
+  const result: Record<string, string> = {};
+  for (const key of keys) {
+    const entry = record[key];
+    if (
+      key === 'hb_adid' ||
+      !TARGETING_KEY.test(key) ||
+      !validString(entry, 160, { maximumScalars: 40 })
+    ) {
+      return undefined;
+    }
+    result[key] = entry;
+  }
+  return Object.freeze(result);
+}
+
+function snapshotFormats(value: unknown): readonly (readonly [number, number])[] | undefined {
+  const formats = exactArray(value, MAX_FORMATS);
+  if (!formats || formats.length === 0) return undefined;
+  const result: Array<readonly [number, number]> = [];
+  for (const candidate of formats) {
+    const pair = exactArray(candidate, 2);
+    if (!pair || pair.length !== 2 || !validDimension(pair[0]) || !validDimension(pair[1])) {
+      return undefined;
+    }
+    result.push(Object.freeze([pair[0], pair[1]]));
+  }
+  return Object.freeze(result);
+}
+
+function snapshotSlot(value: unknown): FirstDisplayProjectionSlotV1 | undefined {
+  const slot = exactRecord(value, ['slot', 'gamUnitPath', 'divId', 'formats', 'targeting']);
+  const formats = snapshotFormats(slot?.formats);
+  const targeting = snapshotTargeting(slot?.targeting);
+  if (
+    !slot ||
+    !validString(slot.slot, 256) ||
+    !validString(slot.gamUnitPath, 256) ||
+    !validString(slot.divId, 256) ||
+    !formats ||
+    !targeting
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    slot: slot.slot,
+    gamUnitPath: slot.gamUnitPath,
+    divId: slot.divId,
+    formats,
+    targeting,
+  });
+}
+
+function snapshotAdm(value: unknown): FirstDisplayAdmSourceV1 | undefined {
+  const source = exactRecord(value, ['type', 'version', 'adm', 'width', 'height']);
+  if (
+    !source ||
+    source.type !== 'adm' ||
+    source.version !== 1 ||
+    !validString(source.adm, MAX_ADM_BYTES, { allowControls: true }) ||
+    !validDimension(source.width) ||
+    !validDimension(source.height)
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    type: 'adm',
+    version: 1,
+    adm: source.adm,
+    width: source.width,
+    height: source.height,
+  });
+}
+
+function snapshotAps(value: unknown): FirstDisplayApsSourceV1 | undefined {
+  const raw = exactRecord(
+    value,
+    Object.prototype.hasOwnProperty.call(value, 'creativeId')
+      ? [
+          'type',
+          'version',
+          'accountId',
+          'bidId',
+          'creativeId',
+          'tagType',
+          'creativeUrl',
+          'aaxResponse',
+          'width',
+          'height',
+        ]
+      : [
+          'type',
+          'version',
+          'accountId',
+          'bidId',
+          'tagType',
+          'creativeUrl',
+          'aaxResponse',
+          'width',
+          'height',
+        ]
+  );
+  if (
+    !raw ||
+    raw.type !== 'aps' ||
+    raw.version !== 1 ||
+    !validString(raw.accountId, 1024, { allowControls: true }) ||
+    !validString(raw.bidId, 64) ||
+    (raw.creativeId !== undefined && !validString(raw.creativeId, 1024, { allowControls: true })) ||
+    (raw.tagType !== 'iframe' && raw.tagType !== 'script') ||
+    !validString(raw.creativeUrl, 4096) ||
+    typeof raw.aaxResponse !== 'string' ||
+    raw.aaxResponse.length > MAX_APS_ENVELOPE_BASE64_BYTES ||
+    !validDimension(raw.width) ||
+    !validDimension(raw.height)
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    type: 'aps',
+    version: 1,
+    accountId: raw.accountId,
+    bidId: raw.bidId,
+    ...(raw.creativeId === undefined ? {} : { creativeId: raw.creativeId }),
+    tagType: raw.tagType,
+    creativeUrl: raw.creativeUrl,
+    aaxResponse: raw.aaxResponse,
+    width: raw.width,
+    height: raw.height,
+  });
+}
+
+function snapshotBid(value: unknown): FirstDisplayProjectionBidV1 | undefined {
+  const bid = exactRecord(value, [
+    'candidateId',
+    'slot',
+    'provider',
+    'upstreamBidId',
+    'cpm',
+    'currency',
+    'targeting',
+    'rendererReservationId',
+    'renderSource',
+  ]);
+  const targeting = snapshotTargeting(bid?.targeting);
+  const sourceRecord = exactRecord(
+    bid?.renderSource,
+    Reflect.ownKeys((bid?.renderSource ?? {}) as object) as string[]
+  );
+  const renderSource =
+    sourceRecord?.type === 'adm'
+      ? snapshotAdm(bid?.renderSource)
+      : sourceRecord?.type === 'aps'
+        ? snapshotAps(bid?.renderSource)
+        : undefined;
+  if (
+    !bid ||
+    typeof bid.candidateId !== 'string' ||
+    !CANDIDATE_ID.test(bid.candidateId) ||
+    !validString(bid.slot, 256) ||
+    typeof bid.provider !== 'string' ||
+    !PROVIDER_ID.test(bid.provider) ||
+    !validString(bid.upstreamBidId, 64) ||
+    typeof bid.cpm !== 'number' ||
+    !Number.isFinite(bid.cpm) ||
+    bid.cpm < 0 ||
+    bid.currency !== 'USD' ||
+    !targeting ||
+    typeof bid.rendererReservationId !== 'string' ||
+    !RESERVATION_ID.test(bid.rendererReservationId) ||
+    !renderSource
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    candidateId: bid.candidateId as string,
+    slot: bid.slot,
+    provider: bid.provider as string,
+    upstreamBidId: bid.upstreamBidId,
+    cpm: bid.cpm,
+    currency: 'USD',
+    targeting,
+    rendererReservationId: bid.rendererReservationId,
+    renderSource,
+  });
+}
+
+function snapshotDecision(value: unknown): FirstDisplayProjectionDecisionV1 | undefined {
+  const base = exactRecord(value, Reflect.ownKeys((value ?? {}) as object) as string[]);
+  if (!base || !validString(base.slot, 256)) return undefined;
+  if (base.outcome === 'winner') {
+    const winner = exactRecord(value, ['slot', 'outcome', 'candidateId']);
+    return winner && typeof winner.candidateId === 'string' && CANDIDATE_ID.test(winner.candidateId)
+      ? Object.freeze({
+          slot: winner.slot as string,
+          outcome: 'winner',
+          candidateId: winner.candidateId as string,
+        })
+      : undefined;
+  }
+  if (base.outcome === 'no_bid') {
+    return exactRecord(value, ['slot', 'outcome'])
+      ? Object.freeze({ slot: base.slot, outcome: 'no_bid' })
+      : undefined;
+  }
+  if (base.outcome === 'failed') {
+    const failed = exactRecord(value, ['slot', 'outcome', 'reason']);
+    return failed && typeof failed.reason === 'string' && FAILURE_REASONS.has(failed.reason)
+      ? Object.freeze({ slot: base.slot, outcome: 'failed', reason: failed.reason })
+      : undefined;
+  }
+  return undefined;
+}
+
+/** Validate and freeze the sole server-projected batch admitted by the lean agent. */
+export function snapshotFirstDisplayBatchV1(candidate: unknown): FirstDisplayBatchV1 | undefined {
+  try {
+    const envelope = exactRecord(candidate, ['version', 'projectionDigest', 'projection']);
+    const rawProjection = exactRecord(envelope?.projection, [
+      'version',
+      'auction',
+      'slots',
+      'bids',
+    ]);
+    const rawAuction = exactRecord(rawProjection?.auction, ['version', 'auctionId', 'results']);
+    const rawDecisions = exactArray(rawAuction?.results, MAX_SLOTS);
+    const rawSlots = exactArray(rawProjection?.slots, MAX_SLOTS);
+    const rawBids = exactArray(rawProjection?.bids, MAX_SLOTS);
+    if (
+      !envelope ||
+      envelope.version !== 1 ||
+      typeof envelope.projectionDigest !== 'string' ||
+      !HASH.test(envelope.projectionDigest) ||
+      !rawProjection ||
+      rawProjection.version !== 1 ||
+      !rawAuction ||
+      rawAuction.version !== 1 ||
+      typeof rawAuction.auctionId !== 'string' ||
+      !AUCTION_ID.test(rawAuction.auctionId) ||
+      !rawDecisions ||
+      rawDecisions.length === 0 ||
+      !rawSlots ||
+      rawSlots.length !== rawDecisions.length ||
+      !rawBids
+    ) {
+      return undefined;
+    }
+
+    const decisions: FirstDisplayProjectionDecisionV1[] = [];
+    const slots: FirstDisplayProjectionSlotV1[] = [];
+    const bids: FirstDisplayProjectionBidV1[] = [];
+    const slotIds = new Set<string>();
+    for (let index = 0; index < rawDecisions.length; index += 1) {
+      const decision = snapshotDecision(rawDecisions[index]);
+      const slot = snapshotSlot(rawSlots[index]);
+      if (!decision || !slot || decision.slot !== slot.slot || slotIds.has(slot.slot)) {
+        return undefined;
+      }
+      slotIds.add(slot.slot);
+      decisions.push(decision);
+      slots.push(slot);
+    }
+
+    const candidateIds = new Set<string>();
+    const reservationIds = new Set<string>();
+    for (const rawBid of rawBids) {
+      const bid = snapshotBid(rawBid);
+      if (
+        !bid ||
+        candidateIds.has(bid.candidateId) ||
+        reservationIds.has(bid.rendererReservationId)
+      ) {
+        return undefined;
+      }
+      candidateIds.add(bid.candidateId);
+      reservationIds.add(bid.rendererReservationId);
+      bids.push(bid);
+    }
+
+    const outcomes: FirstDisplayBatchOutcomeV1[] = [];
+    let winnerIndex = 0;
+    let aps = false;
+    let prebid = false;
+    for (const decision of decisions) {
+      if (decision.outcome === 'winner') {
+        const bid = bids[winnerIndex];
+        if (!bid || bid.candidateId !== decision.candidateId || bid.slot !== decision.slot) {
+          return undefined;
+        }
+        winnerIndex += 1;
+        aps ||= bid.renderSource.type === 'aps';
+        prebid ||= bid.provider === 'prebid';
+        outcomes.push(
+          Object.freeze({
+            slotId: decision.slot,
+            kind: bid.renderSource.type === 'aps' ? 'aps' : 'gpt_adm',
+          })
+        );
+      } else {
+        outcomes.push(
+          Object.freeze({
+            slotId: decision.slot,
+            kind: decision.outcome,
+          })
+        );
+      }
+    }
+    if (winnerIndex !== bids.length) return undefined;
+
+    const projection: FirstDisplayProjectionV1 = Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: rawAuction.auctionId,
+        results: Object.freeze(decisions),
+      }),
+      slots: Object.freeze(slots),
+      bids: Object.freeze(bids),
+    });
+    if (textEncoder.encode(JSON.stringify(projection)).byteLength > MAX_PROJECTION_BYTES) {
+      return undefined;
+    }
+    return Object.freeze({
+      version: 1,
+      projectionDigest: envelope.projectionDigest,
+      requiredProtocols: Object.freeze([
+        ...(aps ? (['aps'] as const) : []),
+        ...(winnerIndex > 0 ? (['gpt'] as const) : []),
+        ...(prebid ? (['prebid'] as const) : []),
+      ]),
+      outcomes: Object.freeze(outcomes),
+      projection,
+    });
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/leaf/route_guard.ts b/crates/trusted-server-js/lib/src/first_display/leaf/route_guard.ts
new file mode 100644
index 000000000..1ec10f3c4
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/leaf/route_guard.ts
@@ -0,0 +1,266 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+
+export type FirstDisplayRouteKindV1 = 'script' | 'preload' | 'prefetch' | 'beacon' | 'fetch';
+
+export interface FirstDisplayRouteRuleV1 {
+  readonly id: 'datadome' | 'google_tag_manager' | 'lockr';
+  readonly matches: (kind: FirstDisplayRouteKindV1, url: string) => boolean;
+  readonly rewrite: (url: string) => string;
+}
+
+interface RouteBindings {
+  readonly observe: (name: string, value: string | number) => void;
+  readonly origin: string;
+  readonly register: (rule: FirstDisplayRouteRuleV1) => () => void;
+}
+
+interface LockrSdk {
+  host: string;
+}
+
+interface LockrBindings extends RouteBindings {
+  readonly clearTimer: (handle: unknown) => void;
+  readonly getSdk: () => LockrSdk | undefined;
+  readonly host: string;
+  readonly protocol: string;
+  readonly setTimer: (callback: () => void, delayMs: number) => unknown;
+}
+
+const DATADOME_URL = /^(?:https?:)?\/\/js\.datadome\.co(?:\/|$)|^js\.datadome\.co(?:\/|$)/i;
+const GTM_URL =
+  /^(?:https?:)?(?:\/\/)?(www\.(googletagmanager|google-analytics)\.com|analytics\.google\.com)(?:\/|$)/i;
+const GTM_PATHS = new Set(['/gtm.js', '/gtag/js', '/gtag.js', '/collect', '/g/collect']);
+const SCRIPT_KINDS = new Set<FirstDisplayRouteKindV1>(['script', 'preload', 'prefetch']);
+const GTM_KINDS = new Set<FirstDisplayRouteKindV1>([
+  'script',
+  'preload',
+  'prefetch',
+  'beacon',
+  'fetch',
+]);
+
+function exactBindings(
+  candidate: unknown,
+  keys: readonly string[]
+): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate)
+    ) {
+      return undefined;
+    }
+    const ownKeys = Reflect.ownKeys(candidate);
+    if (
+      ownKeys.length !== keys.length ||
+      !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+    ) {
+      return undefined;
+    }
+    const fields: Record<string, unknown> = {};
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      fields[key] = descriptor.value;
+    }
+    return fields;
+  } catch {
+    return undefined;
+  }
+}
+
+function routeBindings(candidate: unknown): RouteBindings | undefined {
+  const fields = exactBindings(candidate, ['observe', 'origin', 'register']);
+  if (
+    !fields ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.origin !== 'string' ||
+    typeof fields.register !== 'function'
+  ) {
+    return undefined;
+  }
+  try {
+    const parsed = new URL(fields.origin);
+    if (!/^https?:$/.test(parsed.protocol) || parsed.origin !== fields.origin) return undefined;
+  } catch {
+    return undefined;
+  }
+  return fields as unknown as RouteBindings;
+}
+
+function absoluteExternalUrl(url: string): URL | undefined {
+  try {
+    const normalized = url.startsWith('//')
+      ? `https:${url}`
+      : /^https?:/i.test(url)
+        ? url
+        : `https://${url}`;
+    return new URL(normalized);
+  } catch {
+    return undefined;
+  }
+}
+
+function ownRule(
+  bindings: RouteBindings,
+  own: FirstDisplaySliceActivationContext['own'],
+  rule: FirstDisplayRouteRuleV1
+): void {
+  const release = bindings.register(Object.freeze(rule));
+  if (typeof release !== 'function') throw new TypeError('tsjs');
+  own(release);
+  bindings.observe('route_guard', rule.id);
+}
+
+/** Own DataDome's initial script/preload first-party routing. */
+export function installDataDomeInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = routeBindings(candidate);
+  if (!bindings) throw new TypeError('tsjs');
+  ownRule(bindings, own, {
+    id: 'datadome',
+    matches: (kind, url) => SCRIPT_KINDS.has(kind) && DATADOME_URL.test(url),
+    rewrite: (url) => {
+      const parsed = absoluteExternalUrl(url);
+      const suffix = parsed ? `${parsed.pathname}${parsed.search}` : '/tags.js';
+      return `${bindings.origin}/integrations/datadome${suffix}`;
+    },
+  });
+}
+
+function isGtmUrl(url: string): boolean {
+  if (!GTM_URL.test(url)) return false;
+  const parsed = absoluteExternalUrl(url);
+  return Boolean(parsed && GTM_PATHS.has(parsed.pathname));
+}
+
+/** Own GTM/GA's initial script, preload, beacon, and fetch first-party routing. */
+export function installGoogleTagManagerInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = routeBindings(candidate);
+  if (!bindings) throw new TypeError('tsjs');
+  ownRule(bindings, own, {
+    id: 'google_tag_manager',
+    matches: (kind, url) => GTM_KINDS.has(kind) && isGtmUrl(url),
+    rewrite: (url) => {
+      const parsed = absoluteExternalUrl(url);
+      const suffix = parsed ? `${parsed.pathname}${parsed.search}` : '/gtm.js';
+      return `${bindings.origin}/integrations/google_tag_manager${suffix}`;
+    },
+  });
+}
+
+function isLockrUrl(url: string): boolean {
+  const lower = url.toLowerCase();
+  return (
+    lower.includes('aim.loc.kr') ||
+    (lower.includes('identity.loc.kr') && lower.includes('identity-lockr') && lower.endsWith('.js'))
+  );
+}
+
+function snapshotLockrBindings(candidate: unknown): LockrBindings | undefined {
+  const fields = exactBindings(candidate, [
+    'clearTimer',
+    'getSdk',
+    'host',
+    'observe',
+    'origin',
+    'protocol',
+    'register',
+    'setTimer',
+  ]);
+  if (
+    !fields ||
+    typeof fields.clearTimer !== 'function' ||
+    typeof fields.getSdk !== 'function' ||
+    typeof fields.host !== 'string' ||
+    fields.host.length === 0 ||
+    fields.host.length > 255 ||
+    fields.host.includes('/') ||
+    typeof fields.observe !== 'function' ||
+    typeof fields.origin !== 'string' ||
+    typeof fields.protocol !== 'string' ||
+    !['http:', 'https:'].includes(fields.protocol) ||
+    typeof fields.register !== 'function' ||
+    typeof fields.setTimer !== 'function'
+  ) {
+    return undefined;
+  }
+  const base = routeBindings(
+    Object.freeze({ observe: fields.observe, origin: fields.origin, register: fields.register })
+  );
+  return base ? (fields as unknown as LockrBindings) : undefined;
+}
+
+/** Own Lockr's initial route guard and bounded API-host readiness observation. */
+export function installLockrInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): void {
+  const bindings = snapshotLockrBindings(candidate);
+  if (!bindings) throw new TypeError('tsjs');
+  ownRule(bindings, own, {
+    id: 'lockr',
+    matches: (kind, url) => SCRIPT_KINDS.has(kind) && isLockrUrl(url),
+    rewrite: () => `${bindings.origin}/integrations/lockr/sdk`,
+  });
+
+  let active = true;
+  let timer: unknown;
+  let ownedSdk: LockrSdk | undefined;
+  let installedHost: string | undefined;
+  let previousHost: string | undefined;
+  own(() => {
+    if (!active) return;
+    active = false;
+    if (timer !== undefined) {
+      try {
+        bindings.clearTimer(timer);
+      } catch {
+        // Continue through independent SDK restoration.
+      }
+      timer = undefined;
+    }
+    try {
+      if (ownedSdk && installedHost !== undefined && ownedSdk.host === installedHost) {
+        ownedSdk.host = previousHost ?? ownedSdk.host;
+      }
+    } catch {
+      // Publisher replacement wins over provisional rollback.
+    }
+  });
+
+  let attempts = 0;
+  const check = (): void => {
+    timer = undefined;
+    if (!active) return;
+    attempts += 1;
+    try {
+      const sdk = bindings.getSdk();
+      if (sdk && typeof sdk.host === 'string' && sdk.host.length > 0) {
+        const nextHost = `${bindings.protocol}//${bindings.host}/integrations/lockr/api`;
+        previousHost = sdk.host;
+        sdk.host = nextHost;
+        ownedSdk = sdk;
+        installedHost = nextHost;
+        bindings.observe('sdk_host', nextHost);
+        return;
+      }
+    } catch {
+      // Treat an unreadable or unwritable SDK as not ready.
+    }
+    if (attempts >= 50) {
+      bindings.observe('readiness_timeout', attempts);
+      return;
+    }
+    timer = bindings.setTimer(check, 50);
+  };
+  check();
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/registration_client.ts b/crates/trusted-server-js/lib/src/first_display/registration_client.ts
new file mode 100644
index 000000000..05c393ff6
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/registration_client.ts
@@ -0,0 +1,20 @@
+declare const __TSJS_EMBEDDED_RELEASE_ID_V1__: string;
+
+import type { FirstDisplayComponentRegistrationV1 } from '../shared/first_display_registration';
+
+/** Submit one immutable component record and the synchronous current-script identity. */
+export function registerCurrentFirstDisplayComponent(
+  id: string,
+  install: FirstDisplayComponentRegistrationV1['install']
+): boolean {
+  try {
+    const target = window.tsjs as unknown as {
+      _registerFirstDisplay?: (candidate: readonly unknown[]) => boolean;
+    };
+    return (
+      target._registerFirstDisplay?.([1, id, __TSJS_EMBEDDED_RELEASE_ID_V1__, install]) === true
+    );
+  } catch {
+    return false;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/render_bridge.ts b/crates/trusted-server-js/lib/src/first_display/render_bridge.ts
new file mode 100644
index 000000000..4e2175267
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/render_bridge.ts
@@ -0,0 +1,783 @@
+import type { FirstDisplayGptBoundCycleV1 } from './adapters/googletag';
+import type { FirstDisplayApsPolicyV1 } from './leaf/aps_protocol';
+import type {
+  FirstDisplayCommittedRenderArtifactV1,
+  FirstDisplayRenderOwnerOptionsV1,
+  FirstDisplayRenderStrategyAttemptV1,
+  FirstDisplayRenderStrategyCallbacksV1,
+  FirstDisplayRenderStrategyV1,
+} from './render_journal';
+
+const RENDERER_DOCUMENT_NO_LOAD = 'renderer_document_no_load';
+const INTERNAL_ERROR = 'internal_error';
+const RUNNER_FAILED = 'runner_failed';
+const WINNER_NOT_RENDERABLE = 'winner_not_renderable';
+const MAX_DRAWS = 8;
+const BASE64URL = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+interface PortLike {
+  readonly addEventListener?: (name: string, listener: (event: unknown) => void) => void;
+  readonly close: () => void;
+  readonly postMessage: (message: unknown, transfer?: readonly PortLike[]) => void;
+  readonly removeEventListener?: (name: string, listener: (event: unknown) => void) => void;
+  readonly start?: () => void;
+}
+
+interface ApsAttempt {
+  readonly callbacks: FirstDisplayRenderStrategyCallbacksV1;
+  readonly cycle: FirstDisplayGptBoundCycleV1;
+  readonly overlay: boolean;
+  active: boolean;
+  accepted: boolean;
+  bootstrapNavigated: boolean;
+  bootstrapNonceInternal: string;
+  bootstrapSource: object | undefined;
+  completionTimer: unknown;
+  documentAccepted: boolean;
+  documentPort: PortLike | undefined;
+  documentRelease: (() => void) | undefined;
+  documentTimer: unknown;
+  frame: HTMLIFrameElement;
+  hostPositionOwned: boolean;
+  pendingTerminal:
+    | 'completed'
+    | typeof WINNER_NOT_RENDERABLE
+    | 'runner_no_load'
+    | typeof RUNNER_FAILED
+    | undefined;
+  previousHostPosition: string;
+  previousHostPositionPriority: string;
+  rendererNonceInternal: string;
+}
+
+function eventField(
+  event: unknown,
+  name: 'data' | 'origin' | 'ports' | 'source',
+  trustedPrototype: object | undefined
+): unknown {
+  try {
+    if (typeof event !== 'object' || event === null) return undefined;
+    const own = Object.getOwnPropertyDescriptor(event, name);
+    if (own) return 'value' in own ? own.value : undefined;
+    const prototype = Object.getPrototypeOf(event);
+    if (!trustedPrototype || prototype !== trustedPrototype) return undefined;
+    const inherited = Object.getOwnPropertyDescriptor(trustedPrototype, name);
+    return inherited?.get ? Reflect.apply(inherited.get, event, []) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function usablePort(value: unknown): value is PortLike {
+  try {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      typeof Reflect.get(value, 'postMessage') === 'function' &&
+      typeof Reflect.get(value, 'close') === 'function'
+    );
+  } catch {
+    return false;
+  }
+}
+
+function exactPorts(
+  event: unknown,
+  trustedPrototype: object | undefined,
+  expected: 0 | 1
+): readonly PortLike[] | undefined {
+  const value = eventField(event, 'ports', trustedPrototype);
+  try {
+    if (!Array.isArray(value)) return undefined;
+    const length = Object.getOwnPropertyDescriptor(value, 'length');
+    if (!length || !('value' in length) || !Number.isSafeInteger(length.value)) return undefined;
+    let exact =
+      length.value === expected &&
+      Object.getPrototypeOf(value) === Array.prototype &&
+      Object.getOwnPropertySymbols(value).length === 0 &&
+      Object.getOwnPropertyNames(value).length === length.value + 1;
+    const ports: PortLike[] = [];
+    const seen = new Set<PortLike>();
+    for (let index = 0; index < length.value; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor?.enumerable || !('value' in descriptor) || !usablePort(descriptor.value)) {
+        exact = false;
+        continue;
+      }
+      if (seen.has(descriptor.value)) {
+        exact = false;
+        continue;
+      }
+      seen.add(descriptor.value);
+      ports.push(descriptor.value);
+    }
+    if (exact && ports.length === expected) return ports;
+    for (const port of ports) closePort(port);
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function eventSource(event: unknown, trustedPrototype: object | undefined): object | undefined {
+  const value = eventField(event, 'source', trustedPrototype);
+  return (typeof value === 'object' || typeof value === 'function') && value !== null
+    ? value
+    : undefined;
+}
+
+function closePort(port: PortLike | undefined): void {
+  try {
+    port?.close();
+  } catch {
+    // The endpoint is already generation-inert.
+  }
+}
+
+function post(port: PortLike, message: unknown): boolean {
+  try {
+    Reflect.apply(port.postMessage, port, [message, []]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function postWindow(target: object, message: string): boolean {
+  try {
+    const postMessage = Reflect.get(target, 'postMessage');
+    if (typeof postMessage !== 'function') return false;
+    Reflect.apply(postMessage, target, [message, '*', []]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function encodeOpaque(bytes: Uint8Array): string {
+  let output = '';
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = (buffer << 8) | byte;
+    bits += 8;
+    while (bits >= 6) {
+      bits -= 6;
+      output += BASE64URL[(buffer >>> bits) & 63];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits > 0) output += BASE64URL[(buffer << (6 - bits)) & 63];
+  return output;
+}
+
+function snapshotFrameAttributes(frame: HTMLIFrameElement): string | undefined {
+  try {
+    return frame.outerHTML;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Create the APS-owned URL, nonce, document-port, and overlay strategy. */
+export function createFirstDisplayApsRenderStrategy(
+  options: FirstDisplayRenderOwnerOptionsV1,
+  aps: FirstDisplayApsPolicyV1
+): FirstDisplayRenderStrategyV1 {
+  const attempts = new Set<ApsAttempt>();
+  const bootstrapNonces = new Map<string, ApsAttempt>();
+  const rendererNonces = new Map<string, ApsAttempt>();
+  const timers = new Set<unknown>();
+  let disposed = false;
+  const messageEventPrototype = (() => {
+    try {
+      const constructor = Reflect.get(options[0], 'MessageEvent');
+      const prototype =
+        typeof constructor === 'function' ? Reflect.get(constructor, 'prototype') : undefined;
+      return typeof prototype === 'object' && prototype !== null ? prototype : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  const notifyNativeMutation = (): void => {
+    try {
+      options[6]?.();
+    } catch {
+      // Observation cannot alter admitted APS state.
+    }
+  };
+
+  const clearOwnedTimer = (handle: unknown): void => {
+    if (handle === undefined || !timers.delete(handle)) return;
+    try {
+      options[1](handle);
+    } catch {
+      // Timer state is already detached.
+    }
+  };
+
+  const arm = (callback: () => void, delayMs: number): unknown => {
+    let handle: unknown;
+    let scheduling = true;
+    let firedSynchronously = false;
+    try {
+      handle = options[7](() => {
+        if (scheduling) {
+          firedSynchronously = true;
+          return;
+        }
+        if (!timers.delete(handle)) return;
+        callback();
+      }, delayMs);
+    } catch {
+      handle = undefined;
+    }
+    scheduling = false;
+    if (handle === undefined) return undefined;
+    if (firedSynchronously) {
+      try {
+        options[1](handle);
+      } catch {
+        // Synchronous timers are refused regardless of cleanup outcome.
+      }
+      return undefined;
+    }
+    timers.add(handle);
+    return handle;
+  };
+
+  const mint = (
+    prefix: 'b1_' | 'n1_',
+    registry: ReadonlyMap<string, unknown>
+  ): string | undefined => {
+    for (let draw = 0; draw < MAX_DRAWS; draw += 1) {
+      const bytes = new Uint8Array(16);
+      try {
+        options[4](bytes);
+      } catch {
+        return undefined;
+      }
+      const candidate = `${prefix}${encodeOpaque(bytes)}`;
+      if (!registry.has(candidate)) return candidate;
+    }
+    return undefined;
+  };
+
+  const configureFrame = (
+    frame: HTMLIFrameElement,
+    width: number,
+    height: number,
+    overlay: boolean
+  ): void => {
+    frame.setAttribute('sandbox', aps.sandbox);
+    frame.setAttribute('referrerpolicy', 'no-referrer');
+    frame.setAttribute('width', String(width));
+    frame.setAttribute('height', String(height));
+    frame.setAttribute('scrolling', 'no');
+    frame.setAttribute('frameborder', '0');
+    frame.setAttribute('marginwidth', '0');
+    frame.setAttribute('marginheight', '0');
+    frame.setAttribute('title', 'Ad content');
+    frame.setAttribute('aria-label', 'Advertisement');
+    frame.setAttribute(
+      'style',
+      overlay
+        ? `border: 0; display: block; height: ${height}px; inset: 0; margin: 0; overflow: hidden; position: absolute; visibility: hidden; width: ${width}px; z-index: 2147483647;`
+        : `border: 0; margin: 0; overflow: hidden; display: block; width: ${width}px; height: ${height}px;`
+    );
+  };
+
+  const restoreHostPosition = (attempt: ApsAttempt): void => {
+    if (!attempt.hostPositionOwned) return;
+    attempt.hostPositionOwned = false;
+    try {
+      const style = attempt.cycle[1].style;
+      if (
+        style.getPropertyValue('position') !== 'relative' ||
+        style.getPropertyPriority('position') !== ''
+      )
+        return;
+      if (attempt.previousHostPosition === '') style.removeProperty('position');
+      else
+        style.setProperty(
+          'position',
+          attempt.previousHostPosition,
+          attempt.previousHostPositionPriority
+        );
+    } catch {
+      // Compare-owned restoration never overwrites publisher changes.
+    }
+  };
+
+  const acquireHostPosition = (attempt: ApsAttempt): boolean => {
+    if (!attempt.overlay) return true;
+    try {
+      const host = attempt.cycle[1];
+      const browser = host.ownerDocument.defaultView;
+      if (!browser || !attempt.cycle[2]()) return false;
+      if (browser.getComputedStyle(host).position !== 'static') return true;
+      attempt.previousHostPosition = host.style.getPropertyValue('position');
+      attempt.previousHostPositionPriority = host.style.getPropertyPriority('position');
+      host.style.setProperty('position', 'relative');
+      attempt.hostPositionOwned =
+        host.style.getPropertyValue('position') === 'relative' &&
+        host.style.getPropertyPriority('position') === '';
+      return attempt.hostPositionOwned && attempt.cycle[2]();
+    } catch {
+      return false;
+    }
+  };
+
+  const exactFrame = (attempt: ApsAttempt, permanent: boolean): boolean => {
+    try {
+      return (
+        attempt.active &&
+        attempt.cycle[2]() &&
+        attempt.frame.isConnected &&
+        attempt.frame.parentNode === attempt.cycle[1] &&
+        attempt.frame.contentWindow === attempt.bootstrapSource &&
+        attempt.frame.getAttribute('src') ===
+          `${aps.rendererUrl}#${attempt.bootstrapNonceInternal}` &&
+        attempt.frame.src === `${aps.rendererUrl}#${attempt.bootstrapNonceInternal}` &&
+        attempt.frame.getAttribute('sandbox') ===
+          (permanent ? aps.permanentSandbox : aps.sandbox) &&
+        (!attempt.hostPositionOwned ||
+          (attempt.cycle[1].style.getPropertyValue('position') === 'relative' &&
+            attempt.cycle[1].style.getPropertyPriority('position') === ''))
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const releasePort = (attempt: ApsAttempt): void => {
+    const release = attempt.documentRelease;
+    const port = attempt.documentPort;
+    attempt.documentRelease = undefined;
+    attempt.documentPort = undefined;
+    try {
+      release?.();
+    } catch {
+      // Port closure remains authoritative.
+    }
+    closePort(port);
+  };
+
+  const detachAttempt = (attempt: ApsAttempt): void => {
+    clearOwnedTimer(attempt.documentTimer);
+    clearOwnedTimer(attempt.completionTimer);
+    attempt.documentTimer = undefined;
+    attempt.completionTimer = undefined;
+    if (bootstrapNonces.get(attempt.bootstrapNonceInternal) === attempt) {
+      bootstrapNonces.delete(attempt.bootstrapNonceInternal);
+    }
+    if (rendererNonces.get(attempt.rendererNonceInternal) === attempt) {
+      rendererNonces.delete(attempt.rendererNonceInternal);
+    }
+    attempts.delete(attempt);
+    releasePort(attempt);
+  };
+
+  const cancelAttempt = (attempt: ApsAttempt): void => {
+    if (!attempt.active && !attempt.accepted) return;
+    attempt.active = false;
+    attempt.accepted = false;
+    detachAttempt(attempt);
+    attempt.frame.onload = null;
+    attempt.frame.onerror = null;
+    try {
+      attempt.frame.remove();
+    } catch {
+      // The exact node cannot regain authority.
+    }
+    restoreHostPosition(attempt);
+    notifyNativeMutation();
+  };
+
+  const fail = (attempt: ApsAttempt, reason: string): void => {
+    if (!attempt.active) return;
+    attempt.active = false;
+    detachAttempt(attempt);
+    attempt.frame.onload = null;
+    attempt.frame.onerror = null;
+    try {
+      attempt.frame.remove();
+    } catch {
+      // Failed APS identity is already detached.
+    }
+    restoreHostPosition(attempt);
+    notifyNativeMutation();
+    try {
+      attempt.callbacks.fail(reason);
+    } catch {
+      // Consumers cannot restore APS authority.
+    }
+  };
+
+  const installDocumentPort = (
+    attempt: ApsAttempt,
+    port: PortLike,
+    receive: (event: unknown) => void,
+    receiveError: () => void
+  ): boolean => {
+    try {
+      if (typeof port.addEventListener !== 'function') return false;
+      let live = true;
+      const release = (): void => {
+        if (!live) return;
+        live = false;
+        try {
+          if (typeof port.removeEventListener === 'function') {
+            Reflect.apply(port.removeEventListener, port, ['message', receive]);
+            Reflect.apply(port.removeEventListener, port, ['messageerror', receiveError]);
+          }
+        } catch {
+          // Port closure remains authoritative.
+        }
+      };
+      Reflect.apply(port.addEventListener, port, ['message', receive]);
+      Reflect.apply(port.addEventListener, port, ['messageerror', receiveError]);
+      attempt.documentRelease = release;
+      if (typeof port.start === 'function') Reflect.apply(port.start, port, []);
+      return live && attempt.active && attempt.documentPort === port;
+    } catch {
+      return false;
+    }
+  };
+
+  const complete = (attempt: ApsAttempt): void => {
+    if (!attempt.active || !exactFrame(attempt, true)) {
+      fail(attempt, 'slot_unresolved');
+      return;
+    }
+    if (attempt.overlay) {
+      try {
+        attempt.frame.style.setProperty('visibility', 'visible');
+        if (attempt.frame.style.getPropertyValue('visibility') !== 'visible') {
+          fail(attempt, INTERNAL_ERROR);
+          return;
+        }
+      } catch {
+        fail(attempt, INTERNAL_ERROR);
+        return;
+      }
+    }
+    const attributes = snapshotFrameAttributes(attempt.frame);
+    const frameWindow = attempt.frame.contentWindow;
+    const frameSource = attempt.frame.src;
+    const frameSourceDocument = attempt.frame.srcdoc;
+    if (attributes === undefined || !frameWindow) {
+      fail(attempt, INTERNAL_ERROR);
+      return;
+    }
+    attempt.active = false;
+    attempt.accepted = true;
+    detachAttempt(attempt);
+    attempt.frame.onload = null;
+    attempt.frame.onerror = null;
+    let artifactLive = true;
+    const retire = (): void => {
+      if (!artifactLive) return;
+      artifactLive = false;
+      attempt.accepted = false;
+      try {
+        attempt.frame.remove();
+      } catch {
+        // Exact-node retirement is best-effort.
+      }
+      restoreHostPosition(attempt);
+      notifyNativeMutation();
+    };
+    const artifact: FirstDisplayCommittedRenderArtifactV1 = Object.freeze({
+      hostPosition: attempt.hostPositionOwned ? attempt.previousHostPosition : null,
+      hostPositionPriority: attempt.hostPositionOwned ? attempt.previousHostPositionPriority : null,
+      identity: attempt.frame,
+      kind: 'aps',
+      owner: 'trusted_server',
+      slotId: attempt.cycle[6],
+      token: attempt.cycle[0].rendererReservationId,
+      current: () => {
+        try {
+          return (
+            artifactLive &&
+            attempt.accepted &&
+            attempt.cycle[2]() &&
+            attempt.frame.isConnected &&
+            attempt.frame.parentNode === attempt.cycle[1] &&
+            attempt.frame.contentWindow === frameWindow &&
+            attempt.frame.src === frameSource &&
+            attempt.frame.srcdoc === frameSourceDocument &&
+            snapshotFrameAttributes(attempt.frame) === attributes &&
+            (!attempt.hostPositionOwned ||
+              (attempt.cycle[1].style.getPropertyValue('position') === 'relative' &&
+                attempt.cycle[1].style.getPropertyPriority('position') === ''))
+          );
+        } catch {
+          return false;
+        }
+      },
+      retire,
+    });
+    notifyNativeMutation();
+    try {
+      attempt.callbacks.accept(artifact);
+    } catch {
+      retire();
+    }
+  };
+
+  const handleDocument = (attempt: ApsAttempt, event: unknown): void => {
+    if (!attempt.active || !exactFrame(attempt, true)) {
+      fail(attempt, attempt.documentAccepted ? RUNNER_FAILED : RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    if (!exactPorts(event, messageEventPrototype, 0)) {
+      fail(attempt, attempt.documentAccepted ? RUNNER_FAILED : RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    const parsed = aps.parseDocumentMessage(
+      eventField(event, 'data', messageEventPrototype),
+      attempt.rendererNonceInternal
+    );
+    if (!parsed) {
+      fail(attempt, attempt.documentAccepted ? RUNNER_FAILED : RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    if (parsed.kind === 'document_accepted') {
+      if (attempt.documentAccepted) return;
+      attempt.documentAccepted = true;
+      if (rendererNonces.get(attempt.rendererNonceInternal) === attempt) {
+        rendererNonces.delete(attempt.rendererNonceInternal);
+      }
+      clearOwnedTimer(attempt.documentTimer);
+      attempt.documentTimer = undefined;
+      attempt.completionTimer = arm(() => fail(attempt, RUNNER_FAILED), aps.deadlines.completionMs);
+      if (attempt.completionTimer === undefined) {
+        fail(attempt, INTERNAL_ERROR);
+        return;
+      }
+      const pending = attempt.pendingTerminal;
+      attempt.pendingTerminal = undefined;
+      if (pending === 'completed') complete(attempt);
+      else if (pending) fail(attempt, pending);
+      return;
+    }
+    if (parsed.kind === 'runner_loaded') return;
+    if (parsed.kind === 'render_completed') {
+      if (attempt.documentAccepted) complete(attempt);
+      else if (!attempt.pendingTerminal) attempt.pendingTerminal = 'completed';
+      else fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    const failureReason =
+      parsed.reason === 'descriptor_invalid' ? WINNER_NOT_RENDERABLE : parsed.reason;
+    if (attempt.documentAccepted) fail(attempt, failureReason);
+    else if (!attempt.pendingTerminal) attempt.pendingTerminal = failureReason;
+    else fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+  };
+
+  const dispatch = (event: unknown): void => {
+    if (disposed) return;
+    const data = eventField(event, 'data', messageEventPrototype);
+    const message = aps.parseWindowMessage(data);
+    if (!message) return;
+    if (message.kind === 'bootstrap_ready') {
+      const nonce = message.bootstrap;
+      const attempt = bootstrapNonces.get(nonce);
+      const source = eventSource(event, messageEventPrototype);
+      if (
+        !attempt ||
+        eventField(event, 'origin', messageEventPrototype) !== 'null' ||
+        source !== attempt.bootstrapSource
+      )
+        return;
+      if (!exactPorts(event, messageEventPrototype, 0)) {
+        fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+        return;
+      }
+      if (attempt.bootstrapNavigated || !exactFrame(attempt, false)) {
+        fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+        return;
+      }
+      const policy = aps.bootstrapPolicy(attempt.cycle[0].renderSource);
+      if (!policy) {
+        fail(attempt, WINNER_NOT_RENDERABLE);
+        return;
+      }
+      try {
+        attempt.frame.setAttribute('sandbox', aps.permanentSandbox);
+      } catch {
+        fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+        return;
+      }
+      const navigation = JSON.stringify({
+        message: 'TS APS Bootstrap Configure',
+        version: 2,
+        bootstrapNonce: nonce,
+        rendererNonce: attempt.rendererNonceInternal,
+        creativeOrigin: policy.creativeOrigin,
+        tagType: policy.tagType,
+      });
+      if (!exactFrame(attempt, true) || !postWindow(source!, navigation)) {
+        fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+        return;
+      }
+      attempt.bootstrapNavigated = true;
+      return;
+    }
+
+    const { bootstrap: bootstrapNonce, renderer: rendererNonce } = message;
+    const attempt = bootstrapNonces.get(bootstrapNonce);
+    const source = eventSource(event, messageEventPrototype);
+    if (
+      !attempt ||
+      rendererNonces.get(rendererNonce) !== attempt ||
+      eventField(event, 'origin', messageEventPrototype) !== 'null' ||
+      source !== attempt.bootstrapSource
+    )
+      return;
+    const ports = exactPorts(event, messageEventPrototype, 1);
+    const port = ports?.[0];
+    if (
+      !port ||
+      !attempt.bootstrapNavigated ||
+      attempt.documentPort ||
+      !exactFrame(attempt, true)
+    ) {
+      fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    attempt.documentPort = port;
+    const listening = installDocumentPort(
+      attempt,
+      port,
+      (portEvent) => handleDocument(attempt, portEvent),
+      () => fail(attempt, attempt.documentAccepted ? RUNNER_FAILED : RENDERER_DOCUMENT_NO_LOAD)
+    );
+    if (!listening || !attempt.active) {
+      if (attempt.active) fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+      return;
+    }
+    bootstrapNonces.delete(bootstrapNonce);
+    if (
+      !post(port, {
+        version: 1,
+        nonce: rendererNonce,
+        ['publisherOrigin']: aps.publisherOrigin,
+        renderer: attempt.cycle[0].renderSource,
+      }) ||
+      !attempt.active ||
+      !exactFrame(attempt, true)
+    )
+      fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+  };
+
+  try {
+    options[0].addEventListener('message', dispatch as EventListener, true);
+  } catch {
+    throw new TypeError('tsjs');
+  }
+
+  return Object.freeze({
+    supports: (source: unknown): boolean => {
+      try {
+        return aps.bootstrapPolicy(source) !== undefined;
+      } catch {
+        return false;
+      }
+    },
+    start: (
+      cycle: FirstDisplayGptBoundCycleV1,
+      overlay: boolean,
+      callbacks: FirstDisplayRenderStrategyCallbacksV1
+    ): FirstDisplayRenderStrategyAttemptV1 | undefined => {
+      const source = cycle[0].renderSource;
+      if (disposed || source.type !== 'aps' || !cycle[2]() || !aps.bootstrapPolicy(source)) {
+        return undefined;
+      }
+      const bootstrapNonce = mint('b1_', bootstrapNonces);
+      const rendererNonce = mint('n1_', rendererNonces);
+      if (
+        !bootstrapNonce ||
+        !rendererNonce ||
+        !aps.isBootstrapNonce(bootstrapNonce) ||
+        !aps.isRendererNonce(rendererNonce)
+      )
+        return undefined;
+      let frame: HTMLIFrameElement;
+      try {
+        frame = options[3].createElement('iframe');
+        configureFrame(frame, source.width, source.height, overlay);
+      } catch {
+        return undefined;
+      }
+      const attempt: ApsAttempt = {
+        active: true,
+        accepted: false,
+        bootstrapNavigated: false,
+        bootstrapNonceInternal: bootstrapNonce,
+        bootstrapSource: undefined,
+        callbacks,
+        completionTimer: undefined,
+        cycle,
+        documentAccepted: false,
+        documentPort: undefined,
+        documentRelease: undefined,
+        documentTimer: undefined,
+        frame,
+        hostPositionOwned: false,
+        overlay,
+        pendingTerminal: undefined,
+        previousHostPosition: '',
+        previousHostPositionPriority: '',
+        rendererNonceInternal: rendererNonce,
+      };
+      attempts.add(attempt);
+      bootstrapNonces.set(bootstrapNonce, attempt);
+      rendererNonces.set(rendererNonce, attempt);
+      try {
+        frame.onerror = () => fail(attempt, RENDERER_DOCUMENT_NO_LOAD);
+        frame.src = `${aps.rendererUrl}#${bootstrapNonce}`;
+        if (!acquireHostPosition(attempt)) {
+          cancelAttempt(attempt);
+          return undefined;
+        }
+        cycle[1].appendChild(frame);
+        const frameWindow = frame.contentWindow;
+        if (!frameWindow) {
+          cancelAttempt(attempt);
+          return undefined;
+        }
+        attempt.bootstrapSource = frameWindow;
+        attempt.documentTimer = arm(
+          () => fail(attempt, RENDERER_DOCUMENT_NO_LOAD),
+          aps.deadlines.documentAcceptanceMs
+        );
+        if (attempt.documentTimer === undefined || !exactFrame(attempt, false)) {
+          cancelAttempt(attempt);
+          return undefined;
+        }
+      } catch {
+        cancelAttempt(attempt);
+        return undefined;
+      }
+      notifyNativeMutation();
+      return Object.freeze({ cancel: () => cancelAttempt(attempt) });
+    },
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      try {
+        options[0].removeEventListener('message', dispatch as EventListener, true);
+      } catch {
+        // Generation state remains authoritative.
+      }
+      for (const attempt of [...attempts]) cancelAttempt(attempt);
+      for (const handle of [...timers]) clearOwnedTimer(handle);
+      attempts.clear();
+      bootstrapNonces.clear();
+      rendererNonces.clear();
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/render_journal.ts b/crates/trusted-server-js/lib/src/first_display/render_journal.ts
new file mode 100644
index 000000000..2d6e470ae
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/render_journal.ts
@@ -0,0 +1,1585 @@
+import { PUC_DYNAMIC_OWNER } from '../kernel/contracts/puc_dynamic_owner';
+import type { FirstDisplaySliceActivationContext } from '../shared/first_display_transaction';
+
+import type {
+  FirstDisplayGptBoundCycleV1,
+  FirstDisplayGptRenderResult,
+} from './adapters/googletag';
+import type {
+  FirstDisplayRenderBridgeCapabilityV1,
+  FirstDisplayRenderBridgeV1,
+  FirstDisplayRenderHandoffArtifactV1,
+} from './driver';
+
+const ADM_SANDBOX =
+  'allow-forms allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation';
+const INTERNAL_ERROR = 'internal_error';
+const ADM_DOCUMENT_NO_LOAD = 'adm_document_no_load';
+const NAVIGATION_DISPOSED = 'navigation_disposed';
+const CLAIM_DEADLINE_MS = 3_000;
+const INSERTION_DEADLINE_MS = 1_000;
+const ADM_LOAD_DEADLINE_MS = 5_000;
+const TICKET_TTL_MS = 3_000;
+const RESERVATION_TTL_MS = 15 * 60 * 1_000;
+const MAX_CAPABILITIES = 320;
+const MAX_DRAWS = 8;
+const MAX_GLOBAL_MESSAGE_BYTES = 4_096;
+const MAX_DOMAIN_BYTES = 2_048;
+const MAX_OWNER_BYTES = 64 * 1_024;
+const MAX_RESPONSE_BYTES = 72 * 1_024;
+const RESERVATION_ID = /^r1_[A-Za-z0-9_-]{22}$/;
+const TICKET_ID = /^t1_[A-Za-z0-9_-]{22}$/;
+const BASE64URL = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const textEncoder = new TextEncoder();
+
+export interface FirstDisplayPortLikeV1 {
+  readonly addEventListener?: (name: string, listener: (event: unknown) => void) => void;
+  readonly close: () => void;
+  readonly postMessage: (message: unknown, transfer?: readonly FirstDisplayPortLikeV1[]) => void;
+  readonly removeEventListener?: (name: string, listener: (event: unknown) => void) => void;
+  readonly start?: () => void;
+}
+
+export interface FirstDisplayChannelLikeV1 {
+  readonly port1: FirstDisplayPortLikeV1;
+  readonly port2: FirstDisplayPortLikeV1;
+}
+
+/** Compact authenticated capability crossing from the inline owner. */
+export type FirstDisplayRenderOwnerOptionsV1 = readonly [
+  browser: Window,
+  clearTimer: (handle: unknown) => void,
+  createChannel: () => FirstDisplayChannelLikeV1,
+  document: Document,
+  fillRandom: (bytes: Uint8Array) => void,
+  now: () => number,
+  onNativeMutation: (() => boolean) | undefined,
+  setTimer: (callback: () => void, delayMs: number) => unknown,
+];
+
+export interface FirstDisplayCommittedRenderArtifactV1 extends FirstDisplayRenderHandoffArtifactV1 {
+  readonly current: () => boolean;
+  readonly retire: () => void;
+}
+
+export interface FirstDisplayRenderStrategyCallbacksV1 {
+  readonly accept: (artifact: FirstDisplayCommittedRenderArtifactV1) => void;
+  readonly fail: (reason: string) => void;
+}
+
+export interface FirstDisplayRenderStrategyAttemptV1 {
+  readonly cancel: () => void;
+}
+
+/** Source-specific authority is narrowed before it reaches the render owner. */
+export interface FirstDisplayRenderStrategyV1 {
+  readonly supports: (source: unknown) => boolean;
+  readonly start: (
+    cycle: FirstDisplayGptBoundCycleV1,
+    overlay: boolean,
+    callbacks: FirstDisplayRenderStrategyCallbacksV1
+  ) => FirstDisplayRenderStrategyAttemptV1 | undefined;
+  readonly dispose: () => void;
+}
+
+export type FirstDisplayRenderOwnerProtocolV1 = readonly [
+  version: 1,
+  id: 'render_owner',
+  createRenderBridge: (
+    options: FirstDisplayRenderOwnerOptionsV1,
+    strategy?: FirstDisplayRenderStrategyV1
+  ) => FirstDisplayRenderBridgeCapabilityV1,
+];
+
+interface RenderOwnerInitialBindings {
+  readonly observe: (name: 'protocol_version', value: number) => void;
+  readonly register: (protocol: FirstDisplayRenderOwnerProtocolV1) => () => void;
+}
+
+interface PendingClaim {
+  readonly port: FirstDisplayPortLikeV1;
+  readonly source: object;
+}
+
+interface Attempt {
+  readonly cycle: FirstDisplayGptBoundCycleV1;
+  readonly onTerminal: (result: 'accepted' | 'failed' | 'cancelled', reason: string | null) => void;
+  readonly reservationId: string;
+  active: boolean;
+  claim: PendingClaim | undefined;
+  claimTimer: unknown;
+  controlPort: FirstDisplayPortLikeV1 | undefined;
+  controlRelease: (() => void) | undefined;
+  execution: FirstDisplayRenderStrategyAttemptV1 | undefined;
+  gam: FirstDisplayGptRenderResult | undefined;
+  insertionTimer: unknown;
+  inserted: boolean;
+  ownerSource: object | undefined;
+  ownerTicket: string | undefined;
+  phaseValue:
+    | 'waiting_for_gam_and_claim'
+    | 'waiting_for_owner'
+    | 'waiting_for_insertion'
+    | 'rendering_direct';
+  ticket: string | undefined;
+}
+
+interface LiveTicket {
+  readonly attempt: Attempt;
+  readonly expiresAtInternal: number;
+  readonly ordinalInternal: number;
+  readonly registryState: 'live';
+  timer?: unknown;
+}
+
+interface TicketTombstone {
+  readonly expiresAtInternal: number;
+  readonly ordinalInternal: number;
+  readonly registryState: 'tombstone';
+  timer?: unknown;
+}
+
+type TicketEntry = LiveTicket | TicketTombstone;
+
+interface ReservationEntry {
+  readonly expiresAtInternal: number;
+  readonly ordinalInternal: number;
+  readonly registryState: 'live' | 'tombstone';
+}
+
+function utf8Length(value: string): number {
+  return textEncoder.encode(value).byteLength;
+}
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return undefined;
+    }
+    if (Object.getOwnPropertyNames(value).length !== keys.length) return undefined;
+    const result: Record<string, unknown> = {};
+    for (let index = 0; index < keys.length; index += 1) {
+      const name = keys[index];
+      if (!name) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      result[name] = descriptor.value;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseJson(source: string): unknown {
+  if (utf8Length(source) > MAX_GLOBAL_MESSAGE_BYTES) return undefined;
+  try {
+    return JSON.parse(source) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function routingMessage(
+  data: unknown
+): readonly [message: string | undefined, adId: string | undefined, ticket: string | undefined] {
+  const value = typeof data === 'string' ? parseJson(data) : data;
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Array.isArray(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype
+    ) {
+      return [undefined, undefined, undefined];
+    }
+    const read = (name: string): string | undefined => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      return descriptor?.enumerable && 'value' in descriptor && typeof descriptor.value === 'string'
+        ? descriptor.value
+        : undefined;
+    };
+    const message = read('message');
+    const adId = read('adId');
+    const lifecycleTicket = read('lifecycleTicket');
+    return [message, adId, lifecycleTicket];
+  } catch {
+    return [undefined, undefined, undefined];
+  }
+}
+
+function exactPrebidRequest(data: unknown): string | undefined {
+  if (typeof data !== 'string') return undefined;
+  const fields = exactRecord(parseJson(data), ['message', 'adId', 'adServerDomain']);
+  return fields?.message === 'Prebid Request' &&
+    typeof fields.adId === 'string' &&
+    RESERVATION_ID.test(fields.adId) &&
+    typeof fields.adServerDomain === 'string' &&
+    fields.adServerDomain.length > 0 &&
+    utf8Length(fields.adServerDomain) <= MAX_DOMAIN_BYTES &&
+    data ===
+      JSON.stringify({
+        message: 'Prebid Request',
+        adId: fields.adId,
+        adServerDomain: fields.adServerDomain,
+      })
+    ? fields.adId
+    : undefined;
+}
+
+function exactOwnerRegistration(
+  data: unknown
+): readonly [adId: string, ticket: string] | undefined {
+  if (typeof data !== 'string') return undefined;
+  const fields = exactRecord(parseJson(data), ['message', 'adId', 'version', 'lifecycleTicket']);
+  return fields?.message === 'TS Render Owner Register' &&
+    fields.version === 1 &&
+    typeof fields.adId === 'string' &&
+    RESERVATION_ID.test(fields.adId) &&
+    typeof fields.lifecycleTicket === 'string' &&
+    TICKET_ID.test(fields.lifecycleTicket) &&
+    data ===
+      JSON.stringify({
+        message: 'TS Render Owner Register',
+        adId: fields.adId,
+        version: 1,
+        lifecycleTicket: fields.lifecycleTicket,
+      })
+    ? [fields.adId, fields.lifecycleTicket]
+    : undefined;
+}
+
+function eventField(
+  event: unknown,
+  name: 'data' | 'ports' | 'source',
+  trustedPrototype: object | undefined
+): unknown {
+  try {
+    if (typeof event !== 'object' || event === null) return undefined;
+    const own = Object.getOwnPropertyDescriptor(event, name);
+    if (own) return 'value' in own ? own.value : undefined;
+    const prototype = Object.getPrototypeOf(event);
+    if (!trustedPrototype || prototype !== trustedPrototype) return undefined;
+    const inherited = Object.getOwnPropertyDescriptor(trustedPrototype, name);
+    return inherited?.get ? Reflect.apply(inherited.get, event, []) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function usablePort(value: unknown): value is FirstDisplayPortLikeV1 {
+  try {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      typeof Reflect.get(value, 'postMessage') === 'function' &&
+      typeof Reflect.get(value, 'close') === 'function'
+    );
+  } catch {
+    return false;
+  }
+}
+
+function inspectPorts(
+  event: unknown,
+  trustedPrototype: object | undefined
+):
+  | Readonly<{
+      exact: boolean;
+      originalCount: number;
+      ports: readonly FirstDisplayPortLikeV1[];
+    }>
+  | undefined {
+  const value = eventField(event, 'ports', trustedPrototype);
+  try {
+    if (!Array.isArray(value)) return undefined;
+    const length = Object.getOwnPropertyDescriptor(value, 'length');
+    if (!length || !('value' in length) || !Number.isSafeInteger(length.value)) return undefined;
+    let exact =
+      Object.getPrototypeOf(value) === Array.prototype &&
+      Object.getOwnPropertySymbols(value).length === 0 &&
+      Object.getOwnPropertyNames(value).length === length.value + 1;
+    const ports: FirstDisplayPortLikeV1[] = [];
+    const seen = new Set<FirstDisplayPortLikeV1>();
+    for (let index = 0; index < length.value; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor?.enumerable || !('value' in descriptor) || !usablePort(descriptor.value)) {
+        exact = false;
+        continue;
+      }
+      if (seen.has(descriptor.value)) {
+        exact = false;
+        continue;
+      }
+      seen.add(descriptor.value);
+      ports.push(descriptor.value);
+    }
+    return { exact, originalCount: length.value, ports };
+  } catch {
+    return undefined;
+  }
+}
+
+function eventSource(event: unknown, trustedPrototype: object | undefined): object | undefined {
+  const value = eventField(event, 'source', trustedPrototype);
+  return (typeof value === 'object' || typeof value === 'function') && value !== null
+    ? value
+    : undefined;
+}
+
+function suppress(event: unknown): boolean {
+  try {
+    if (typeof event !== 'object' || event === null) return false;
+    const stop = Reflect.get(event, 'stopImmediatePropagation');
+    if (typeof stop !== 'function') return false;
+    Reflect.apply(stop, event, []);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function closePort(port: FirstDisplayPortLikeV1 | undefined): void {
+  try {
+    port?.close();
+  } catch {
+    // The endpoint is already generation-inert.
+  }
+}
+
+function post(
+  port: FirstDisplayPortLikeV1,
+  data: unknown,
+  transfer: readonly FirstDisplayPortLikeV1[] = []
+): boolean {
+  try {
+    Reflect.apply(port.postMessage, port, [data, transfer]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installPortListeners(
+  port: FirstDisplayPortLikeV1,
+  receive: (event: unknown) => void,
+  receiveError: () => void,
+  publishRelease: (release: () => void) => void
+): boolean {
+  try {
+    if (typeof port.addEventListener !== 'function') return false;
+    let live = true;
+    const release = (): void => {
+      if (!live) return;
+      live = false;
+      try {
+        if (typeof port.removeEventListener === 'function') {
+          Reflect.apply(port.removeEventListener, port, ['message', receive]);
+          Reflect.apply(port.removeEventListener, port, ['messageerror', receiveError]);
+        }
+      } catch {
+        // Port closure remains authoritative.
+      }
+    };
+    Reflect.apply(port.addEventListener, port, ['message', receive]);
+    Reflect.apply(port.addEventListener, port, ['messageerror', receiveError]);
+    publishRelease(release);
+    if (typeof port.start === 'function') Reflect.apply(port.start, port, []);
+    return live;
+  } catch {
+    return false;
+  }
+}
+
+function encodeOpaque(bytes: Uint8Array): string {
+  let output = '';
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = (buffer << 8) | byte;
+    bits += 8;
+    while (bits >= 6) {
+      bits -= 6;
+      output += BASE64URL[(buffer >>> bits) & 63];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits > 0) output += BASE64URL[(buffer << (6 - bits)) & 63];
+  return output;
+}
+
+function refusedResponse(adId: string): string {
+  return JSON.stringify({
+    message: 'Prebid Response',
+    adId,
+    rendererVersion: '4',
+    tsOwner: { version: 1, status: 'refused' },
+  });
+}
+
+function ownerRefused(adId: string): string {
+  return JSON.stringify({ message: 'TS Render Owner Refused', adId, version: 1 });
+}
+
+function snapshotFrameAttributes(frame: HTMLIFrameElement): string | undefined {
+  try {
+    return JSON.stringify(
+      [...frame.attributes]
+        .map((attribute) => [attribute.name, attribute.value] as const)
+        .sort(([left], [right]) => left.localeCompare(right))
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function exactPublisherFrame(document: Document, source: object): HTMLIFrameElement | undefined {
+  try {
+    const frames = document.querySelectorAll('iframe');
+    let selected: HTMLIFrameElement | undefined;
+    for (let index = 0; index < frames.length; index += 1) {
+      const candidate = frames.item(index);
+      if (candidate?.isConnected && candidate.contentWindow === source) {
+        if (selected) return undefined;
+        selected = candidate;
+      }
+    }
+    return selected;
+  } catch {
+    return undefined;
+  }
+}
+
+function resizeCollapsedPucShell(
+  document: Document,
+  source: object,
+  width: number,
+  height: number
+): boolean {
+  try {
+    const browser = document.defaultView;
+    const selected = exactPublisherFrame(document, source);
+    if (!browser || !selected || width <= 0 || height <= 0) return false;
+    const onePixelAttribute = (element: Element, name: 'width' | 'height'): boolean => {
+      const value = element.getAttribute(name);
+      if (value === null || !/^\d+(?:\.\d+)?$/.test(value)) return false;
+      const parsed = Number(value);
+      return Number.isFinite(parsed) && parsed <= 1;
+    };
+    const ordinaryCollapsed = (element: HTMLElement): boolean => {
+      const style = browser.getComputedStyle(element);
+      const pixel = (value: string): boolean => {
+        const match = /^(\d+(?:\.\d+)?)px$/.exec(value);
+        return match !== null && Number(match[1]) <= 1;
+      };
+      return (
+        style.position !== 'fixed' &&
+        style.position !== 'sticky' &&
+        pixel(style.width) &&
+        pixel(style.height)
+      );
+    };
+    if (
+      !onePixelAttribute(selected, 'width') ||
+      !onePixelAttribute(selected, 'height') ||
+      !ordinaryCollapsed(selected) ||
+      selected.closest('a,[data-anchor-status]') !== null
+    )
+      return false;
+    const wrapper = selected.parentElement;
+    if (
+      !wrapper ||
+      wrapper === document.body ||
+      wrapper === document.documentElement ||
+      wrapper.tagName === 'A' ||
+      !wrapper.isConnected ||
+      !ordinaryCollapsed(wrapper) ||
+      wrapper.closest('a,[data-anchor-status]') !== null
+    )
+      return false;
+    selected.style.setProperty('width', `${width}px`);
+    selected.style.setProperty('height', `${height}px`);
+    wrapper.style.setProperty('width', `${width}px`);
+    wrapper.style.setProperty('height', `${height}px`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function configureAdmFrame(frame: HTMLIFrameElement, width: number, height: number): void {
+  frame.setAttribute('sandbox', ADM_SANDBOX);
+  frame.setAttribute('referrerpolicy', 'no-referrer');
+  frame.setAttribute('width', String(width));
+  frame.setAttribute('height', String(height));
+  frame.setAttribute('scrolling', 'no');
+  frame.setAttribute('frameborder', '0');
+  frame.setAttribute('marginwidth', '0');
+  frame.setAttribute('marginheight', '0');
+  frame.setAttribute('title', 'Ad content');
+  frame.setAttribute('aria-label', 'Advertisement');
+  frame.setAttribute(
+    'style',
+    `border: 0; margin: 0; overflow: hidden; display: block; width: ${width}px; height: ${height}px;`
+  );
+}
+
+function validCycle(
+  cycle: FirstDisplayGptBoundCycleV1,
+  strategy: FirstDisplayRenderStrategyV1 | undefined
+): boolean {
+  try {
+    const source = cycle[0].renderSource;
+    const document = cycle[1].ownerDocument;
+    let exactElementMatches = 0;
+    const elements = document.getElementsByTagName('*');
+    for (let index = 0; index < elements.length; index += 1) {
+      const candidate = elements.item(index);
+      if (candidate?.id !== cycle[1].id) continue;
+      if (candidate !== cycle[1]) return false;
+      exactElementMatches += 1;
+    }
+    return (
+      cycle[2]() &&
+      cycle[6] === cycle[0].slot &&
+      cycle[6] === cycle[5].slot &&
+      exactElementMatches === 1 &&
+      document.getElementById(cycle[1].id) === cycle[1] &&
+      RESERVATION_ID.test(cycle[0].rendererReservationId) &&
+      (source.type === 'adm' || strategy?.supports(source) === true)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function publisherArtifact(
+  document: Document,
+  attempt: Attempt
+): FirstDisplayCommittedRenderArtifactV1 | undefined {
+  const source = attempt.ownerSource;
+  if (!source) return undefined;
+  const frame = exactPublisherFrame(document, source);
+  const attributes = frame ? snapshotFrameAttributes(frame) : undefined;
+  const parent = frame?.parentNode;
+  const frameWindow = frame?.contentWindow;
+  if (!frame || attributes === undefined || !parent || !frameWindow) return undefined;
+  return Object.freeze({
+    hostPosition: null,
+    hostPositionPriority: null,
+    identity: frame,
+    kind: 'gpt_adm' as const,
+    owner: 'publisher' as const,
+    slotId: attempt.cycle[6],
+    token: attempt.reservationId,
+    current: () => {
+      try {
+        return (
+          frame.ownerDocument === document &&
+          frame.isConnected &&
+          frame.parentNode === parent &&
+          frame.contentWindow === frameWindow &&
+          frame.contentWindow === source &&
+          snapshotFrameAttributes(frame) === attributes
+        );
+      } catch {
+        return false;
+      }
+    },
+    retire: () => undefined,
+  });
+}
+
+function directAdmExecution(
+  document: Document,
+  cycle: FirstDisplayGptBoundCycleV1,
+  callbacks: FirstDisplayRenderStrategyCallbacksV1,
+  setTimer: (callback: () => void, delayMs: number) => unknown,
+  clearTimer: (handle: unknown) => void
+): FirstDisplayRenderStrategyAttemptV1 | undefined {
+  const source = cycle[0].renderSource;
+  if (source.type !== 'adm') return undefined;
+  let live = true;
+  let timer: unknown;
+  let frame: HTMLIFrameElement | undefined;
+  const retire = (): void => {
+    if (!live) return;
+    live = false;
+    try {
+      if (timer !== undefined) clearTimer(timer);
+    } catch {
+      // Exact-node retirement remains authoritative.
+    }
+    if (!frame) return;
+    frame.onload = null;
+    frame.onerror = null;
+    try {
+      frame.remove();
+    } catch {
+      // The exact node cannot regain authority.
+    }
+  };
+  try {
+    const created = document.createElement('iframe');
+    frame = created;
+    configureAdmFrame(created, source.width, source.height);
+    const intended = `<!doctype html><html><head><meta charset="utf-8"><meta name="referrer" content="no-referrer"><style>html,body{border:0;margin:0;padding:0;overflow:hidden}</style></head><body>${source.adm}</body></html>`;
+    created.onload = () => {
+      if (!live) return;
+      const attributes = snapshotFrameAttributes(created);
+      const frameWindow = created.contentWindow;
+      if (
+        !cycle[2]() ||
+        created.parentNode !== cycle[1] ||
+        created.srcdoc !== intended ||
+        created.getAttribute('src') !== null ||
+        attributes === undefined ||
+        !frameWindow
+      ) {
+        callbacks.fail(ADM_DOCUMENT_NO_LOAD);
+        return;
+      }
+      if (timer !== undefined) clearTimer(timer);
+      timer = undefined;
+      created.onload = null;
+      created.onerror = null;
+      callbacks.accept(
+        Object.freeze({
+          hostPosition: null,
+          hostPositionPriority: null,
+          identity: created,
+          kind: 'gpt_adm' as const,
+          owner: 'trusted_server' as const,
+          slotId: cycle[6],
+          token: cycle[0].rendererReservationId,
+          current: () => {
+            try {
+              return (
+                live &&
+                cycle[2]() &&
+                created.isConnected &&
+                created.parentNode === cycle[1] &&
+                created.contentWindow === frameWindow &&
+                created.srcdoc === intended &&
+                created.getAttribute('src') === null &&
+                snapshotFrameAttributes(created) === attributes
+              );
+            } catch {
+              return false;
+            }
+          },
+          retire,
+        })
+      );
+    };
+    created.onerror = () => callbacks.fail(ADM_DOCUMENT_NO_LOAD);
+    created.srcdoc = intended;
+    cycle[1].appendChild(created);
+    let scheduling = true;
+    let firedSynchronously = false;
+    timer = setTimer(() => {
+      if (scheduling) {
+        firedSynchronously = true;
+        return;
+      }
+      if (live) callbacks.fail(ADM_DOCUMENT_NO_LOAD);
+    }, ADM_LOAD_DEADLINE_MS);
+    scheduling = false;
+    if (timer === undefined || firedSynchronously) {
+      if (timer !== undefined) clearTimer(timer);
+      retire();
+      return undefined;
+    }
+    return Object.freeze({ cancel: retire });
+  } catch {
+    retire();
+    return undefined;
+  }
+}
+
+/** Own the bounded, source-neutral render journal for one first-display batch. */
+export function createFirstDisplayRenderJournal(
+  options: FirstDisplayRenderOwnerOptionsV1,
+  strategy?: FirstDisplayRenderStrategyV1
+): FirstDisplayRenderBridgeV1 {
+  const attempts = new Map<string, Attempt>();
+  const reservations = new Map<string, ReservationEntry>();
+  const tickets = new Map<string, TicketEntry>();
+  const committed = new Map<string, FirstDisplayCommittedRenderArtifactV1>();
+  const timers = new Set<unknown>();
+  let disposed = false;
+  let sealed = false;
+  let ingressClosed = false;
+  let handoffCaptured = false;
+  let committedArtifactsDetached = false;
+  let nextTicketOrdinal = 1;
+  let nextReservationOrdinal = 1;
+  let lastNow = Number.NEGATIVE_INFINITY;
+  const messageEventPrototype = (() => {
+    try {
+      const constructor = Reflect.get(options[0], 'MessageEvent');
+      const prototype =
+        typeof constructor === 'function' ? Reflect.get(constructor, 'prototype') : undefined;
+      return typeof prototype === 'object' && prototype !== null ? prototype : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  const readNow = (): number | undefined => {
+    try {
+      const value = options[5]();
+      if (!Number.isFinite(value) || value < 0 || value < lastNow) return undefined;
+      lastNow = value;
+      return value;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const notifyNativeMutation = (): void => {
+    try {
+      options[6]?.();
+    } catch {
+      // Observation cannot alter the admitted event.
+    }
+  };
+
+  const clearOwnedTimer = (handle: unknown): void => {
+    if (handle === undefined || !timers.delete(handle)) return;
+    try {
+      options[1](handle);
+    } catch {
+      // Timer state is already generation-inert.
+    }
+  };
+
+  const arm = (callback: () => void, delayMs: number): unknown => {
+    let handle: unknown;
+    let scheduling = true;
+    let firedSynchronously = false;
+    try {
+      handle = options[7](() => {
+        if (scheduling) {
+          firedSynchronously = true;
+          return;
+        }
+        if (!timers.delete(handle)) return;
+        callback();
+      }, delayMs);
+    } catch {
+      handle = undefined;
+    }
+    scheduling = false;
+    if (handle === undefined) return undefined;
+    if (firedSynchronously) {
+      try {
+        options[1](handle);
+      } catch {
+        // Synchronous timers are refused regardless of cleanup outcome.
+      }
+      return undefined;
+    }
+    timers.add(handle);
+    return handle;
+  };
+
+  const mint = (registry: ReadonlyMap<string, unknown>): string | undefined => {
+    for (let draw = 0; draw < MAX_DRAWS; draw += 1) {
+      const bytes = new Uint8Array(16);
+      try {
+        options[4](bytes);
+      } catch {
+        return undefined;
+      }
+      const candidate = `t1_${encodeOpaque(bytes)}`;
+      if (!registry.has(candidate)) return candidate;
+    }
+    return undefined;
+  };
+
+  const retireTicket = (attempt: Attempt): void => {
+    const ticket = attempt.ticket;
+    attempt.ticket = undefined;
+    if (!ticket) return;
+    const entry = tickets.get(ticket);
+    if (entry?.registryState !== 'live' || entry.attempt !== attempt) return;
+    tickets.set(ticket, {
+      registryState: 'tombstone',
+      expiresAtInternal: entry.expiresAtInternal,
+      ordinalInternal: entry.ordinalInternal,
+      timer: entry.timer,
+    });
+  };
+
+  const retireReservation = (attempt: Attempt): void => {
+    const entry = reservations.get(attempt.reservationId);
+    if (entry?.registryState !== 'live') return;
+    reservations.set(attempt.reservationId, {
+      expiresAtInternal: entry.expiresAtInternal,
+      ordinalInternal: entry.ordinalInternal,
+      registryState: 'tombstone',
+    });
+  };
+
+  const releaseAttempt = (
+    attempt: Attempt,
+    cancelExecution: boolean
+  ): Readonly<{
+    claim?: PendingClaim;
+    controlPort?: FirstDisplayPortLikeV1;
+    controlRelease?: () => void;
+    execution?: FirstDisplayRenderStrategyAttemptV1;
+  }> => {
+    clearOwnedTimer(attempt.claimTimer);
+    clearOwnedTimer(attempt.insertionTimer);
+    attempt.claimTimer = undefined;
+    attempt.insertionTimer = undefined;
+    const claim = attempt.claim;
+    const controlPort = attempt.controlPort;
+    const controlRelease = attempt.controlRelease;
+    const execution = cancelExecution ? attempt.execution : undefined;
+    attempt.claim = undefined;
+    attempt.controlPort = undefined;
+    attempt.controlRelease = undefined;
+    attempt.execution = undefined;
+    attempt.ownerSource = undefined;
+    attempt.ownerTicket = undefined;
+    retireTicket(attempt);
+    retireReservation(attempt);
+    attempts.delete(attempt.reservationId);
+    return {
+      ...(claim ? { claim } : {}),
+      ...(controlPort ? { controlPort } : {}),
+      ...(controlRelease ? { controlRelease } : {}),
+      ...(execution ? { execution } : {}),
+    };
+  };
+
+  const settle = (
+    attempt: Attempt,
+    result: 'accepted' | 'failed' | 'cancelled',
+    reason = result === 'cancelled' ? NAVIGATION_DISPOSED : INTERNAL_ERROR,
+    candidateArtifact?: FirstDisplayCommittedRenderArtifactV1
+  ): boolean => {
+    if (!attempt.active) return false;
+    if (result === 'accepted') {
+      if (
+        !candidateArtifact ||
+        candidateArtifact.slotId !== attempt.cycle[6] ||
+        candidateArtifact.token !== attempt.reservationId ||
+        candidateArtifact.current() !== true
+      ) {
+        return settle(attempt, 'failed', INTERNAL_ERROR);
+      }
+      committed.set(attempt.cycle[6], candidateArtifact);
+    }
+    attempt.active = false;
+    const ticket = attempt.ownerTicket;
+    const released = releaseAttempt(attempt, result !== 'accepted');
+    notifyNativeMutation();
+    try {
+      released.controlRelease?.();
+    } catch {
+      // State was detached before publisher-controlled cleanup.
+    }
+    try {
+      released.execution?.cancel();
+    } catch {
+      // Strategy authority is detached from this generation.
+    }
+    if (released.controlPort && ticket) {
+      const settlement: Record<string, unknown> = {
+        message: 'TS Owner Settled',
+        version: 1,
+        lifecycleTicket: ticket,
+        outcome: result,
+      };
+      post(released.controlPort, settlement);
+    }
+    closePort(released.claim?.port);
+    closePort(released.controlPort);
+    try {
+      attempt.onTerminal(result, result === 'accepted' ? null : reason);
+    } catch {
+      // A terminal observer cannot restore detached authority.
+    }
+    return true;
+  };
+
+  const fail = (attempt: Attempt, reason: string, refuseClaim = false): boolean => {
+    if (!attempt.active) return false;
+    if (refuseClaim && attempt.claim) {
+      const claim = attempt.claim;
+      attempt.claim = undefined;
+      post(claim.port, refusedResponse(attempt.reservationId));
+      closePort(claim.port);
+      if (!attempt.active) return false;
+    }
+    return settle(attempt, 'failed', reason);
+  };
+
+  const issueTicket = (attempt: Attempt): string | undefined => {
+    if (tickets.size >= MAX_CAPABILITIES || utf8Length(PUC_DYNAMIC_OWNER) > MAX_OWNER_BYTES) {
+      return undefined;
+    }
+    const ticket = mint(tickets);
+    if (!ticket || !TICKET_ID.test(ticket)) return undefined;
+    const issuedAt = readNow();
+    if (issuedAt === undefined) return undefined;
+    const expiresAt = issuedAt + TICKET_TTL_MS;
+    const ordinal = nextTicketOrdinal;
+    nextTicketOrdinal += 1;
+    const entry: LiveTicket = {
+      registryState: 'live',
+      attempt,
+      expiresAtInternal: expiresAt,
+      ordinalInternal: ordinal,
+    };
+    tickets.set(ticket, entry);
+    attempt.ticket = ticket;
+    entry.timer = arm(() => {
+      const current = tickets.get(ticket);
+      if (current !== entry) {
+        const observedAt = readNow();
+        if (
+          current?.registryState === 'tombstone' &&
+          observedAt !== undefined &&
+          current.expiresAtInternal <= observedAt
+        ) {
+          tickets.delete(ticket);
+          notifyNativeMutation();
+        }
+        return;
+      }
+      tickets.delete(ticket);
+      attempt.ticket = undefined;
+      notifyNativeMutation();
+      fail(attempt, 'owner_registration_timeout');
+    }, TICKET_TTL_MS);
+    if (entry.timer === undefined) {
+      tickets.delete(ticket);
+      attempt.ticket = undefined;
+      return undefined;
+    }
+    return ticket;
+  };
+
+  const join = (attempt: Attempt): boolean => {
+    const claim = attempt.claim;
+    if (
+      !attempt.active ||
+      !claim ||
+      attempt.gam !== 'nonempty_gam' ||
+      attempt.phaseValue !== 'waiting_for_gam_and_claim'
+    )
+      return false;
+    clearOwnedTimer(attempt.claimTimer);
+    attempt.claimTimer = undefined;
+    const ticket = issueTicket(attempt);
+    if (!ticket) return fail(attempt, 'capability_registry_full', true);
+    const response = JSON.stringify({
+      message: 'Prebid Response',
+      adId: attempt.reservationId,
+      renderer: PUC_DYNAMIC_OWNER,
+      rendererVersion: '4',
+      tsOwner: {
+        version: 1,
+        status: 'ready',
+        kind: attempt.cycle[0].renderSource.type,
+        lifecycleTicket: ticket,
+      },
+    });
+    attempt.claim = undefined;
+    attempt.ownerSource = claim.source;
+    attempt.phaseValue = 'waiting_for_owner';
+    retireReservation(attempt);
+    const source = attempt.cycle[0].renderSource;
+    resizeCollapsedPucShell(options[3], claim.source, source.width, source.height);
+    if (
+      !attempt.active ||
+      attempt.phaseValue !== 'waiting_for_owner' ||
+      attempt.ownerSource !== claim.source ||
+      attempt.ticket !== ticket
+    ) {
+      closePort(claim.port);
+      return false;
+    }
+    const posted = utf8Length(response) <= MAX_RESPONSE_BYTES && post(claim.port, response);
+    closePort(claim.port);
+    if (!posted && attempt.active) return fail(attempt, INTERNAL_ERROR);
+    return posted;
+  };
+
+  const beginExecution = (attempt: Attempt, overlay: boolean): boolean => {
+    type Pending =
+      | Readonly<{ kind: 'accept'; artifact: FirstDisplayCommittedRenderArtifactV1 }>
+      | Readonly<{ kind: 'fail'; reason: string }>;
+    let starting = true;
+    let pending: Pending | undefined;
+    let duplicate = false;
+    const enqueue = (next: Pending): void => {
+      if (!attempt.active) return;
+      if (starting) {
+        if (pending) duplicate = true;
+        else pending = next;
+        return;
+      }
+      if (next.kind === 'accept') settle(attempt, 'accepted', INTERNAL_ERROR, next.artifact);
+      else fail(attempt, next.reason);
+    };
+    const callbacks = Object.freeze({
+      accept: (artifact: FirstDisplayCommittedRenderArtifactV1) =>
+        enqueue(Object.freeze({ kind: 'accept' as const, artifact })),
+      fail: (reason: string) => enqueue(Object.freeze({ kind: 'fail' as const, reason })),
+    });
+    let execution: FirstDisplayRenderStrategyAttemptV1 | undefined;
+    if (attempt.cycle[0].renderSource.type === 'adm') {
+      if (overlay) return false;
+      execution = directAdmExecution(options[3], attempt.cycle, callbacks, options[7], options[1]);
+    } else if (strategy?.supports(attempt.cycle[0].renderSource) === true) {
+      try {
+        execution = strategy.start(attempt.cycle, overlay, callbacks);
+      } catch {
+        execution = undefined;
+      }
+    }
+    starting = false;
+    if (!execution || duplicate) {
+      try {
+        execution?.cancel();
+      } catch {
+        // Refused execution cannot retain authority.
+      }
+      return false;
+    }
+    attempt.execution = execution;
+    if (pending?.kind === 'accept') settle(attempt, 'accepted', INTERNAL_ERROR, pending.artifact);
+    else if (pending?.kind === 'fail') fail(attempt, pending.reason);
+    return true;
+  };
+
+  const ownerInserted = (attempt: Attempt): void => {
+    if (!attempt.active || attempt.phaseValue !== 'waiting_for_insertion' || attempt.inserted)
+      return;
+    attempt.inserted = true;
+    clearOwnedTimer(attempt.insertionTimer);
+    attempt.insertionTimer = undefined;
+    if (attempt.cycle[0].renderSource.type === 'adm') {
+      attempt.insertionTimer = arm(() => fail(attempt, ADM_DOCUMENT_NO_LOAD), ADM_LOAD_DEADLINE_MS);
+      if (attempt.insertionTimer === undefined) fail(attempt, INTERNAL_ERROR);
+    }
+  };
+
+  const handleOwnerControl = (attempt: Attempt, event: unknown): void => {
+    if (!attempt.active) return;
+    const ports = inspectPorts(event, messageEventPrototype);
+    if (!ports?.exact || ports.originalCount !== 0 || ports.ports.length !== 0) {
+      fail(attempt, INTERNAL_ERROR);
+      return;
+    }
+    const message = exactRecord(eventField(event, 'data', messageEventPrototype), [
+      'message',
+      'version',
+      'lifecycleTicket',
+    ]);
+    const ticket = attempt.ownerTicket;
+    if (
+      message?.message === 'TS Owner Inserted' &&
+      message.version === 1 &&
+      message.lifecycleTicket === ticket
+    ) {
+      ownerInserted(attempt);
+      return;
+    }
+    if (attempt.cycle[0].renderSource.type !== 'adm') {
+      fail(attempt, INTERNAL_ERROR);
+      return;
+    }
+    if (
+      message?.message === 'TS ADM Loaded' &&
+      message.version === 1 &&
+      message.lifecycleTicket === ticket &&
+      attempt.inserted
+    ) {
+      clearOwnedTimer(attempt.insertionTimer);
+      attempt.insertionTimer = undefined;
+      const artifact = publisherArtifact(options[3], attempt);
+      if (artifact) settle(attempt, 'accepted', INTERNAL_ERROR, artifact);
+      else fail(attempt, ADM_DOCUMENT_NO_LOAD);
+      return;
+    }
+    if (
+      message?.message === 'TS ADM Failed' &&
+      message.version === 1 &&
+      message.lifecycleTicket === ticket
+    ) {
+      fail(attempt, ADM_DOCUMENT_NO_LOAD);
+      return;
+    }
+    fail(attempt, ADM_DOCUMENT_NO_LOAD);
+  };
+
+  const startOwner = (attempt: Attempt): boolean => {
+    const controlPort = attempt.controlPort;
+    const ticket = attempt.ownerTicket;
+    if (!controlPort || !ticket || !attempt.active) return false;
+    if (!validCycle(attempt.cycle, strategy)) return fail(attempt, 'slot_unresolved');
+    attempt.insertionTimer = arm(
+      () => fail(attempt, 'owner_insertion_timeout'),
+      INSERTION_DEADLINE_MS
+    );
+    if (attempt.insertionTimer === undefined) return fail(attempt, INTERNAL_ERROR);
+    if (attempt.cycle[0].renderSource.type === 'adm') {
+      return (
+        post(controlPort, {
+          message: 'TS ADM Start',
+          version: 1,
+          lifecycleTicket: ticket,
+          source: attempt.cycle[0].renderSource,
+        }) || fail(attempt, INTERNAL_ERROR)
+      );
+    }
+    if (!beginExecution(attempt, true)) return fail(attempt, 'winner_not_renderable');
+    if (attempt.active) ownerInserted(attempt);
+    return (
+      post(controlPort, {
+        message: 'TS APS Top Mount Started',
+        version: 1,
+        lifecycleTicket: ticket,
+      }) || fail(attempt, INTERNAL_ERROR)
+    );
+  };
+
+  const handleOwnerRegistration = (
+    event: unknown,
+    data: unknown,
+    routing: ReturnType<typeof routingMessage>
+  ): void => {
+    const ticket = routing[2];
+    if (!ticket) return;
+    const beforeSuppress = tickets.get(ticket);
+    if (!beforeSuppress || !suppress(event)) return;
+    const entry = tickets.get(ticket);
+    const inspection = inspectPorts(event, messageEventPrototype);
+    const responsePort = inspection?.ports[0];
+    const refuse = (): void => {
+      if (responsePort) post(responsePort, ownerRefused(routing[1] ?? ''));
+      for (const port of inspection?.ports ?? []) closePort(port);
+    };
+    if (entry !== beforeSuppress || entry.registryState !== 'live') {
+      refuse();
+      return;
+    }
+    const exact = exactOwnerRegistration(data);
+    const attempt = entry.attempt;
+    if (
+      !exact ||
+      !inspection?.exact ||
+      inspection.originalCount !== 1 ||
+      inspection.ports.length !== 1 ||
+      !responsePort ||
+      exact[0] !== attempt.reservationId ||
+      exact[1] !== ticket ||
+      eventSource(event, messageEventPrototype) !== attempt.ownerSource ||
+      !attempt.active ||
+      attempt.phaseValue !== 'waiting_for_owner'
+    ) {
+      refuse();
+      if (attempt.active) fail(attempt, 'bridge_id_mismatch');
+      return;
+    }
+    let channel: FirstDisplayChannelLikeV1;
+    try {
+      channel = options[2]();
+    } catch {
+      post(responsePort, ownerRefused(attempt.reservationId));
+      closePort(responsePort);
+      fail(attempt, INTERNAL_ERROR);
+      return;
+    }
+    if (
+      tickets.get(ticket) !== entry ||
+      !attempt.active ||
+      attempt.phaseValue !== 'waiting_for_owner'
+    ) {
+      closePort(channel.port1);
+      closePort(channel.port2);
+      refuse();
+      return;
+    }
+    retireTicket(attempt);
+    attempt.ownerTicket = ticket;
+    attempt.controlPort = channel.port1;
+    attempt.phaseValue = 'waiting_for_insertion';
+    const listening = installPortListeners(
+      channel.port1,
+      (message) => handleOwnerControl(attempt, message),
+      () =>
+        fail(
+          attempt,
+          attempt.cycle[0].renderSource.type === 'adm' ? ADM_DOCUMENT_NO_LOAD : INTERNAL_ERROR
+        ),
+      (release) => {
+        attempt.controlRelease = release;
+      }
+    );
+    if (!listening || !attempt.active) {
+      closePort(responsePort);
+      closePort(channel.port2);
+      if (attempt.active) fail(attempt, INTERNAL_ERROR);
+      return;
+    }
+    const registered = JSON.stringify({
+      message: 'TS Render Owner Registered',
+      adId: attempt.reservationId,
+      version: 1,
+      lifecycleTicket: ticket,
+    });
+    const posted = post(responsePort, registered, [channel.port2]);
+    closePort(responsePort);
+    closePort(channel.port2);
+    if (!posted || !attempt.active || !startOwner(attempt)) {
+      if (attempt.active) fail(attempt, INTERNAL_ERROR);
+    }
+  };
+
+  const dispatch = (event: unknown): void => {
+    if (disposed || ingressClosed) return;
+    const data = eventField(event, 'data', messageEventPrototype);
+    const routing = routingMessage(data);
+    if (routing[0] === 'TS Render Owner Register' && routing[2]) {
+      notifyNativeMutation();
+      handleOwnerRegistration(event, data, routing);
+      return;
+    }
+    const adId = routing[1];
+    if (routing[0] !== 'Prebid Request' || !adId) return;
+    const beforeSuppress = reservations.get(adId);
+    if (!beforeSuppress || !suppress(event)) return;
+    notifyNativeMutation();
+    const reservationState = reservations.get(adId);
+    const inspection = inspectPorts(event, messageEventPrototype);
+    const responsePort = inspection?.ports[0];
+    const refuse = (): void => {
+      if (responsePort) post(responsePort, refusedResponse(adId));
+      for (const port of inspection?.ports ?? []) closePort(port);
+    };
+    if (
+      reservationState !== beforeSuppress ||
+      reservationState.registryState !== 'live' ||
+      !inspection?.exact ||
+      inspection.originalCount !== 1 ||
+      inspection.ports.length !== 1 ||
+      !responsePort
+    ) {
+      refuse();
+      return;
+    }
+    const exact = exactPrebidRequest(data);
+    const attempt = attempts.get(adId);
+    const source = eventSource(event, messageEventPrototype);
+    if (
+      !exact ||
+      exact !== adId ||
+      !attempt?.active ||
+      attempt.phaseValue !== 'waiting_for_gam_and_claim' ||
+      attempt.claim ||
+      !source
+    ) {
+      refuse();
+      return;
+    }
+    attempt.claim = Object.freeze({ port: responsePort, source });
+    if (attempt.gam === 'nonempty_gam') join(attempt);
+  };
+
+  try {
+    options[0].addEventListener('message', dispatch as EventListener, true);
+  } catch {
+    throw new TypeError('tsjs');
+  }
+
+  const sweepCommittedArtifacts = (): number => {
+    if (disposed || committedArtifactsDetached) return 0;
+    let retired = 0;
+    for (const [slotId, artifact] of [...committed.entries()]) {
+      if (committed.get(slotId) !== artifact || artifact.current()) continue;
+      committed.delete(slotId);
+      try {
+        artifact.retire();
+      } catch {
+        // Invalidated identity is already detached from the journal.
+      }
+      retired += 1;
+    }
+    if (retired > 0) notifyNativeMutation();
+    return retired;
+  };
+
+  return Object.freeze({
+    bind: (
+      cycle: FirstDisplayGptBoundCycleV1,
+      onTerminal: (result: 'accepted' | 'failed' | 'cancelled', reason: string | null) => void
+    ): boolean => {
+      if (
+        disposed ||
+        ingressClosed ||
+        sealed ||
+        typeof onTerminal !== 'function' ||
+        !validCycle(cycle, strategy) ||
+        reservations.size >= MAX_CAPABILITIES ||
+        reservations.has(cycle[0].rendererReservationId)
+      )
+        return false;
+      const observedAt = readNow();
+      if (observedAt === undefined) return false;
+      const expiresAt = observedAt + RESERVATION_TTL_MS;
+      const ordinal = nextReservationOrdinal;
+      if (!Number.isFinite(expiresAt) || expiresAt <= observedAt || ordinal > 4_294_967_295) {
+        return false;
+      }
+      const attempt: Attempt = {
+        active: true,
+        claim: undefined,
+        claimTimer: undefined,
+        controlPort: undefined,
+        controlRelease: undefined,
+        cycle,
+        execution: undefined,
+        gam: undefined,
+        insertionTimer: undefined,
+        inserted: false,
+        onTerminal,
+        ownerSource: undefined,
+        ownerTicket: undefined,
+        phaseValue: 'waiting_for_gam_and_claim',
+        reservationId: cycle[0].rendererReservationId,
+        ticket: undefined,
+      };
+      attempts.set(attempt.reservationId, attempt);
+      reservations.set(attempt.reservationId, {
+        expiresAtInternal: expiresAt,
+        ordinalInternal: ordinal,
+        registryState: 'live',
+      });
+      nextReservationOrdinal += 1;
+      return true;
+    },
+    recordGam: (
+      cycle: FirstDisplayGptBoundCycleV1,
+      result: FirstDisplayGptRenderResult
+    ): boolean => {
+      const attempt = attempts.get(cycle[0].rendererReservationId);
+      if (
+        !attempt?.active ||
+        attempt.cycle !== cycle ||
+        attempt.gam ||
+        attempt.phaseValue !== 'waiting_for_gam_and_claim'
+      )
+        return false;
+      attempt.gam = result;
+      if (result === 'gam_empty') {
+        attempt.phaseValue = 'rendering_direct';
+        retireReservation(attempt);
+        const claim = attempt.claim;
+        attempt.claim = undefined;
+        if (claim) {
+          post(claim.port, refusedResponse(attempt.reservationId));
+          closePort(claim.port);
+          if (!attempt.active) return false;
+        }
+        return beginExecution(attempt, false) || fail(attempt, 'winner_not_renderable');
+      }
+      if (attempt.claim) return join(attempt);
+      attempt.claimTimer = arm(() => fail(attempt, 'bridge_claim_timeout'), CLAIM_DEADLINE_MS);
+      return attempt.claimTimer !== undefined || fail(attempt, INTERNAL_ERROR);
+    },
+    recordFailure: (cycle: FirstDisplayGptBoundCycleV1): boolean => {
+      const attempt = attempts.get(cycle[0].rendererReservationId);
+      return Boolean(
+        attempt?.active && attempt.cycle === cycle && fail(attempt, 'gpt_request_failed')
+      );
+    },
+    retire: (cycle: FirstDisplayGptBoundCycleV1): boolean => {
+      if (disposed || committedArtifactsDetached) return false;
+      const artifact = committed.get(cycle[6]);
+      if (!artifact || artifact.token !== cycle[0].rendererReservationId) return false;
+      committed.delete(cycle[6]);
+      try {
+        artifact.retire();
+      } catch {
+        // Exact identity is already retired from the journal.
+      }
+      notifyNativeMutation();
+      return true;
+    },
+    sweepCommittedArtifacts,
+    sealTsAdmission: (): void => {
+      if (disposed || [...attempts.values()].some((attempt) => attempt.active)) {
+        throw new TypeError('tsjs');
+      }
+      sealed = true;
+    },
+    closeIngress: (): boolean => {
+      if (
+        disposed ||
+        ingressClosed ||
+        !sealed ||
+        [...attempts.values()].some((attempt) => attempt.active)
+      )
+        return false;
+      ingressClosed = true;
+      try {
+        options[0].removeEventListener('message', dispatch as EventListener, true);
+      } catch {
+        // Closed generation state remains authoritative.
+      }
+      for (const handle of [...timers]) clearOwnedTimer(handle);
+      return true;
+    },
+    captureHandoff: () => {
+      if (disposed || !ingressClosed || handoffCaptured) return undefined;
+      sweepCommittedArtifacts();
+      const observedAt = readNow();
+      if (observedAt === undefined) return undefined;
+      const reservationTombstones = [...reservations.entries()]
+        .filter(
+          ([, entry]) => entry.registryState === 'tombstone' && entry.expiresAtInternal > observedAt
+        )
+        .map(([value, entry]) =>
+          Object.freeze([
+            'reservation' as const,
+            value,
+            entry.expiresAtInternal,
+            entry.ordinalInternal,
+          ] as const)
+        );
+      const ticketTombstones = [...tickets.entries()]
+        .filter(
+          ([, entry]) => entry.registryState === 'tombstone' && entry.expiresAtInternal > observedAt
+        )
+        .map(([value, entry]) =>
+          Object.freeze([
+            'ticket' as const,
+            value,
+            entry.expiresAtInternal,
+            entry.ordinalInternal,
+          ] as const)
+        );
+      const artifacts = [...committed.values()].map((artifact) =>
+        Object.freeze([
+          artifact.hostPosition,
+          artifact.hostPositionPriority,
+          artifact.identity,
+          artifact.kind,
+          artifact.owner,
+          artifact.slotId,
+          artifact.token,
+        ] as const)
+      );
+      handoffCaptured = true;
+      return Object.freeze([
+        Object.freeze(artifacts),
+        Object.freeze([...reservationTombstones, ...ticketTombstones]),
+        observedAt,
+        nextReservationOrdinal,
+        nextTicketOrdinal,
+      ] as const);
+    },
+    detachCommittedArtifacts: (): boolean => {
+      if (disposed || !ingressClosed || !handoffCaptured || committedArtifactsDetached) {
+        return false;
+      }
+      if (sweepCommittedArtifacts() > 0) return false;
+      committedArtifactsDetached = true;
+      return true;
+    },
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      if (!ingressClosed) {
+        ingressClosed = true;
+        try {
+          options[0].removeEventListener('message', dispatch as EventListener, true);
+        } catch {
+          // Generation latching keeps a failed physical removal inert.
+        }
+      }
+      for (const attempt of [...attempts.values()]) {
+        if (attempt.active) settle(attempt, 'cancelled', NAVIGATION_DISPOSED);
+      }
+      for (const handle of [...timers]) clearOwnedTimer(handle);
+      if (!committedArtifactsDetached) {
+        for (const artifact of committed.values()) {
+          try {
+            artifact.retire();
+          } catch {
+            // Exact artifact retirement is best-effort after ownership removal.
+          }
+        }
+      }
+      committed.clear();
+      attempts.clear();
+      reservations.clear();
+      tickets.clear();
+      try {
+        strategy?.dispose();
+      } catch {
+        // Strategy authority is generation-latched.
+      }
+    },
+  });
+}
+
+/** Install the one-use release-private source-neutral initial render owner. */
+export function installRenderOwnerInitial(
+  candidate: unknown,
+  own: FirstDisplaySliceActivationContext['own']
+): readonly [version: 1, id: 'render_owner'] {
+  // The authenticated bootstrap is the sole caller and owns this capability object.
+  const bindings = candidate as RenderOwnerInitialBindings;
+  if (typeof own !== 'function') throw new TypeError('tsjs');
+  let consumed = false;
+  let created: FirstDisplayRenderBridgeV1 | undefined;
+  const protocol: FirstDisplayRenderOwnerProtocolV1 = Object.freeze([
+    1,
+    'render_owner',
+    (options: FirstDisplayRenderOwnerOptionsV1, strategy?: FirstDisplayRenderStrategyV1) => {
+      if (consumed) throw new TypeError('tsjs');
+      consumed = true;
+      created = createFirstDisplayRenderJournal(options, strategy);
+      return Object.freeze([
+        created.bind,
+        created.recordGam,
+        created.recordFailure,
+        created.retire,
+        created.sweepCommittedArtifacts,
+        created.sealTsAdmission,
+        created.closeIngress,
+        created.captureHandoff,
+        created.detachCommittedArtifacts,
+        created.dispose,
+      ] as FirstDisplayRenderBridgeCapabilityV1);
+    },
+  ]);
+  const release = bindings.register(protocol);
+  if (typeof release !== 'function') throw new TypeError('tsjs');
+  own(() => {
+    const bridge = created;
+    created = undefined;
+    try {
+      bridge?.dispose();
+    } finally {
+      release();
+    }
+  });
+  bindings.observe('protocol_version', 1);
+  return Object.freeze([1, 'render_owner']);
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/aps.ts b/crates/trusted-server-js/lib/src/first_display/slices/aps.ts
new file mode 100644
index 000000000..1af82ec1d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/aps.ts
@@ -0,0 +1,4 @@
+import { installApsInitial } from '../leaf/aps_protocol';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+registerCurrentFirstDisplayComponent('aps_initial', installApsInitial);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/creative.ts b/crates/trusted-server-js/lib/src/first_display/slices/creative.ts
new file mode 100644
index 000000000..bf5bbb01f
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/creative.ts
@@ -0,0 +1,22 @@
+import { installCreativeInitial } from '../leaf/creative_guard';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+import { installClickGuard } from '../../integrations/creative/click';
+import { installDynamicIframeProxy } from '../../integrations/creative/iframe';
+import { installDynamicImageProxy } from '../../integrations/creative/image';
+
+import type { InitialSliceInstaller } from './definition';
+
+const installCreativeInitialSlice: InitialSliceInstaller = (candidate, own, config) =>
+  installCreativeInitial(
+    Object.freeze({
+      document,
+      installClickGuard: () => installClickGuard(false),
+      installDynamicIframeProxy: () => installDynamicIframeProxy(false),
+      installDynamicImageProxy: () => installDynamicImageProxy(false),
+      observe: (candidate as Readonly<{ observe: unknown }>).observe,
+    }),
+    own,
+    config
+  );
+
+registerCurrentFirstDisplayComponent('creative_initial', installCreativeInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/datadome.ts b/crates/trusted-server-js/lib/src/first_display/slices/datadome.ts
new file mode 100644
index 000000000..37a5cb632
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/datadome.ts
@@ -0,0 +1,18 @@
+import { installDataDomeInitial } from '../leaf/route_guard';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installDataDomeInitialSlice: InitialSliceInstaller = (candidate, own) => {
+  const bindings = candidate as Readonly<{ observe: unknown; register: unknown }>;
+  return installDataDomeInitial(
+    Object.freeze({
+      observe: bindings.observe,
+      origin: location.origin,
+      register: bindings.register,
+    }),
+    own
+  );
+};
+
+registerCurrentFirstDisplayComponent('datadome_initial', installDataDomeInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/definition.ts b/crates/trusted-server-js/lib/src/first_display/slices/definition.ts
new file mode 100644
index 000000000..c8d171642
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/definition.ts
@@ -0,0 +1,23 @@
+import type { FirstDisplaySliceActivationContext } from '../../shared/first_display_transaction';
+import type { FirstDisplaySliceId } from '../../kernel/release_catalog';
+
+export type OptionalFirstDisplaySliceId = Exclude<FirstDisplaySliceId, 'first_display'>;
+
+export interface FirstDisplaySliceHost {
+  readonly activate: (
+    id: OptionalFirstDisplaySliceId,
+    own: FirstDisplaySliceActivationContext['own'],
+    install: InitialSliceInstaller
+  ) => void;
+}
+
+export type InitialSliceInstaller = (
+  bindings: unknown,
+  own: FirstDisplaySliceActivationContext['own'],
+  config: unknown
+) => unknown;
+
+export interface InitialSliceDefinition {
+  readonly id: OptionalFirstDisplaySliceId;
+  readonly install: InitialSliceInstaller;
+}
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/didomi.ts b/crates/trusted-server-js/lib/src/first_display/slices/didomi.ts
new file mode 100644
index 000000000..c9bb85928
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/didomi.ts
@@ -0,0 +1,16 @@
+import { installDidomiInitial } from '../leaf/config_guard';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installDidomiInitialSlice: InitialSliceInstaller = (candidate, own, config) =>
+  installDidomiInitial(
+    Object.freeze({
+      config,
+      observe: (candidate as Readonly<{ observe: unknown }>).observe,
+      target: window,
+    }),
+    own
+  );
+
+registerCurrentFirstDisplayComponent('didomi_initial', installDidomiInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/google_tag_manager.ts b/crates/trusted-server-js/lib/src/first_display/slices/google_tag_manager.ts
new file mode 100644
index 000000000..0c1d350be
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/google_tag_manager.ts
@@ -0,0 +1,21 @@
+import { installGoogleTagManagerInitial } from '../leaf/route_guard';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installGoogleTagManagerInitialSlice: InitialSliceInstaller = (candidate, own) => {
+  const bindings = candidate as Readonly<{ observe: unknown; register: unknown }>;
+  return installGoogleTagManagerInitial(
+    Object.freeze({
+      observe: bindings.observe,
+      origin: location.origin,
+      register: bindings.register,
+    }),
+    own
+  );
+};
+
+registerCurrentFirstDisplayComponent(
+  'google_tag_manager_initial',
+  installGoogleTagManagerInitialSlice
+);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/gpt.ts b/crates/trusted-server-js/lib/src/first_display/slices/gpt.ts
new file mode 100644
index 000000000..824971a52
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/gpt.ts
@@ -0,0 +1,25 @@
+import { createFirstDisplayGoogletagBatch } from '../adapters/googletag';
+import { installGptInitial } from '../leaf/gpt_protocol';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installGptInitialSlice: InitialSliceInstaller = (candidate, own, config) =>
+  installGptInitial(
+    candidate,
+    own,
+    (input, protocol) =>
+      createFirstDisplayGoogletagBatch({
+        browser: input[0],
+        clearTimer: input[1],
+        document: input[2],
+        setTimer: input[3],
+        projection: input[4],
+        ...(input[5] === undefined ? {} : { diagnosticsActive: input[5] }),
+        ...(input[6] === undefined ? {} : { onNativeMutation: input[6] }),
+        protocol,
+      }),
+    config
+  );
+
+registerCurrentFirstDisplayComponent('gpt_initial', installGptInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/lockr.ts b/crates/trusted-server-js/lib/src/first_display/slices/lockr.ts
new file mode 100644
index 000000000..830146419
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/lockr.ts
@@ -0,0 +1,23 @@
+import { installLockrInitial } from '../leaf/route_guard';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installLockrInitialSlice: InitialSliceInstaller = (candidate, own) => {
+  const bindings = candidate as Readonly<{ observe: unknown; register: unknown }>;
+  return installLockrInitial(
+    Object.freeze({
+      clearTimer: (handle: unknown) => window.clearTimeout(handle as number),
+      getSdk: () => Reflect.get(window, 'identityLockr'),
+      host: location.host,
+      observe: bindings.observe,
+      origin: location.origin,
+      protocol: location.protocol,
+      register: bindings.register,
+      setTimer: (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+    }),
+    own
+  );
+};
+
+registerCurrentFirstDisplayComponent('lockr_initial', installLockrInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/osano.ts b/crates/trusted-server-js/lib/src/first_display/slices/osano.ts
new file mode 100644
index 000000000..f88463483
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/osano.ts
@@ -0,0 +1,18 @@
+import { installOsanoInitial } from '../leaf/consent_snapshot';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installOsanoInitialSlice: InitialSliceInstaller = (candidate, own) =>
+  installOsanoInitial(
+    Object.freeze({
+      clearTimer: (handle: unknown) => window.clearTimeout(handle as number),
+      document,
+      observe: (candidate as Readonly<{ observe: unknown }>).observe,
+      setTimer: (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+      target: window,
+    }),
+    own
+  );
+
+registerCurrentFirstDisplayComponent('osano_initial', installOsanoInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/permutive.ts b/crates/trusted-server-js/lib/src/first_display/slices/permutive.ts
new file mode 100644
index 000000000..3fa181e05
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/permutive.ts
@@ -0,0 +1,24 @@
+import { installPermutiveInitial } from '../leaf/context_snapshot';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installPermutiveInitialSlice: InitialSliceInstaller = (candidate, own) => {
+  const bindings = candidate as Readonly<{ observe: unknown; register: unknown }>;
+  return installPermutiveInitial(
+    Object.freeze({
+      clearTimer: (handle: unknown) => window.clearTimeout(handle as number),
+      getSdk: () => Reflect.get(window, 'permutive'),
+      host: location.host,
+      observe: bindings.observe,
+      origin: location.origin,
+      protocol: location.protocol,
+      readStorage: (key: string) => window.localStorage.getItem(key),
+      registerRoute: bindings.register,
+      setTimer: (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+    }),
+    own
+  );
+};
+
+registerCurrentFirstDisplayComponent('permutive_initial', installPermutiveInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/prebid.ts b/crates/trusted-server-js/lib/src/first_display/slices/prebid.ts
new file mode 100644
index 000000000..96a6241e1
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/prebid.ts
@@ -0,0 +1,4 @@
+import { installPrebidInitial } from '../leaf/prebid_protocol';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+registerCurrentFirstDisplayComponent('prebid_initial', installPrebidInitial);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/render_owner.ts b/crates/trusted-server-js/lib/src/first_display/slices/render_owner.ts
new file mode 100644
index 000000000..1d3fdd38d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/render_owner.ts
@@ -0,0 +1,4 @@
+import { installRenderOwnerInitial } from '../render_journal';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+registerCurrentFirstDisplayComponent('render_owner_initial', installRenderOwnerInitial);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/sourcepoint.ts b/crates/trusted-server-js/lib/src/first_display/slices/sourcepoint.ts
new file mode 100644
index 000000000..6acc7bf63
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/sourcepoint.ts
@@ -0,0 +1,21 @@
+import { installSourcepointInitial } from '../leaf/consent_snapshot';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+import type { InitialSliceInstaller } from './definition';
+
+export const installSourcepointInitialSlice: InitialSliceInstaller = (candidate, own, config) => {
+  const bindings = candidate as Readonly<{ observe: unknown; register: unknown }>;
+  return installSourcepointInitial(
+    Object.freeze({
+      config,
+      document,
+      observe: bindings.observe,
+      origin: location.origin,
+      registerRoute: bindings.register,
+      storage: window.localStorage,
+    }),
+    own
+  );
+};
+
+registerCurrentFirstDisplayComponent('sourcepoint_initial', installSourcepointInitialSlice);
diff --git a/crates/trusted-server-js/lib/src/first_display/slices/testlight.ts b/crates/trusted-server-js/lib/src/first_display/slices/testlight.ts
new file mode 100644
index 000000000..5752ea376
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/first_display/slices/testlight.ts
@@ -0,0 +1,4 @@
+import { installTestlightInitial } from '../leaf/callback_capture';
+import { registerCurrentFirstDisplayComponent } from '../registration_client';
+
+registerCurrentFirstDisplayComponent('testlight_initial', installTestlightInitial);
diff --git a/crates/trusted-server-js/lib/src/index.ts b/crates/trusted-server-js/lib/src/index.ts
index aa0f7931d..74caed3a8 100644
--- a/crates/trusted-server-js/lib/src/index.ts
+++ b/crates/trusted-server-js/lib/src/index.ts
@@ -1,11 +1,28 @@
-// Barrel re-export for convenience and tests.
-// At build time, each module (core + integrations) is built as a separate IIFE
-// by build-all.mjs. The Rust server concatenates the enabled modules at runtime.
 export type {
-  AdUnit,
+  AddAdUnitsResult,
+  CreativeBootV1,
+  DiagnosticsBootV1,
   GptDiagnosticsApi,
   GptDiagnosticsExportV1,
   GptDiagnosticsRequestCycle,
+  ProgrammaticAdUnit,
+  RenderFailureReason,
+  RenderTraceDiagnostics,
+  RenderTracePathV1,
+  RenderTraceRecord,
+  RenderTraceServedFromV1,
+  RequestAdsOptions,
+  RequestAdsResult,
+  RequestAdsSlotResult,
   TsjsApi,
+  TsjsBootV1,
+  TsjsCommandQueue,
+  TsjsDiagnostics,
+  TsjsFallbackApi,
+  TsjsKernelApi,
+  TsjsLog,
+  TsjsLogLevel,
 } from './core/types';
-export { log } from './core/log';
+export { AdUnitRegistrationError, type AdUnitRegistrationErrorCode } from './core/registry';
+export { RequestAdsInputError, type RequestAdsInputErrorCode } from './core/contracts/request_ads';
+export { TsjsUnavailableError } from './kernel/fallback';
diff --git a/crates/trusted-server-js/lib/src/integrations/aps/documents.ts b/crates/trusted-server-js/lib/src/integrations/aps/documents.ts
new file mode 100644
index 000000000..01fd174fc
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/aps/documents.ts
@@ -0,0 +1 @@
+export * from '../../shared/aps_documents';
diff --git a/crates/trusted-server-js/lib/src/integrations/aps/index.ts b/crates/trusted-server-js/lib/src/integrations/aps/index.ts
new file mode 100644
index 000000000..4c2cad1a5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/aps/index.ts
@@ -0,0 +1,11 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+
+import { createApsIntegrationRegistration } from './module';
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [createApsIntegrationRegistration(EMBEDDED_RELEASE_ID)]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/aps/module.ts b/crates/trusted-server-js/lib/src/integrations/aps/module.ts
new file mode 100644
index 000000000..596e34fc1
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/aps/module.ts
@@ -0,0 +1,163 @@
+import type { MessagingAdapter } from '../../adapters/messaging';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type {
+  ArtifactHostPositionLeaseRegistry,
+  BootstrapNonceRegistry,
+  CommittedRenderArtifact,
+  RendererNonceRegistry,
+  RenderAttempt,
+} from '../../services/render';
+import { validatePersistentFirstDisplaySliceAdoptionV1 } from '../../shared/takeover';
+import type { PucApsMountInput } from '../../services/puc_bridge';
+
+import {
+  renderDirectApsAttempt,
+  renderPucApsAttempt,
+  resolveApsRendererV2Url,
+  validateApsRenderer,
+} from './render';
+
+interface RenderCapability {
+  readonly bindArtifactGuard: (
+    artifact: CommittedRenderArtifact,
+    current: () => boolean
+  ) => boolean;
+  readonly bootstrapNonces: BootstrapNonceRegistry;
+  readonly hostPositions: ArtifactHostPositionLeaseRegistry;
+  readonly publisherOrigin: string;
+  readonly rendererNonces: RendererNonceRegistry;
+  readonly registerRenderer: (
+    type: 'aps',
+    renderer: (attempt: RenderAttempt, container: HTMLElement) => boolean
+  ) => () => void;
+}
+
+interface MessagesCapability {
+  readonly messaging: MessagingAdapter;
+  readonly registerApsValidation: (
+    validation: Readonly<{
+      readonly expectedPublisherOrigin: string;
+      readonly expectedRendererUrl: string;
+      readonly validateApsRenderer: (candidate: unknown) => boolean;
+    }>
+  ) => () => void;
+}
+
+function capability<Value extends object>(
+  interfaces: Readonly<Record<string, unknown>>,
+  key: string
+): Value {
+  const value = interfaces[key];
+  if (typeof value !== 'object' || value === null || !Object.isFrozen(value)) {
+    throw new TypeError(`APS requires ${key}`);
+  }
+  return value as Value;
+}
+
+/** APS owns only its renderer implementation; shared services remain provider capabilities. */
+export function createApsIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = (context: IntegrationPrepareContext) => {
+    if (!isEmptyIntegrationConfigV1(context.config)) {
+      throw new TypeError('APS integration config is invalid');
+    }
+    const render = capability<RenderCapability>(context.interfaces, 'render.v1');
+    const messages = capability<MessagesCapability>(context.interfaces, 'messages.v1');
+    if (
+      typeof render.bindArtifactGuard !== 'function' ||
+      typeof render.registerRenderer !== 'function' ||
+      typeof render.publisherOrigin !== 'string' ||
+      typeof render.hostPositions !== 'object' ||
+      render.hostPositions === null ||
+      !Object.isFrozen(render.hostPositions) ||
+      typeof render.hostPositions.bindOwned !== 'function' ||
+      typeof render.hostPositions.inherit !== 'function' ||
+      typeof render.hostPositions.claim !== 'function' ||
+      typeof render.hostPositions.current !== 'function' ||
+      typeof render.hostPositions.release !== 'function' ||
+      typeof messages.messaging !== 'object' ||
+      messages.messaging === null ||
+      typeof messages.registerApsValidation !== 'function'
+    ) {
+      throw new TypeError('APS capability graph is malformed');
+    }
+    const rendererUrl = resolveApsRendererV2Url(render.publisherOrigin);
+    if (!rendererUrl) throw new TypeError('APS publisher origin is invalid');
+    let active = false;
+    const renderer = (attempt: RenderAttempt, container: HTMLElement): boolean =>
+      active &&
+      renderDirectApsAttempt({
+        attempt,
+        bindArtifactGuard: render.bindArtifactGuard,
+        bootstrapNonces: render.bootstrapNonces,
+        container,
+        messaging: messages.messaging,
+        nonces: render.rendererNonces,
+        publisherOrigin: render.publisherOrigin,
+      });
+    const renderPuc = (input: PucApsMountInput): boolean =>
+      active &&
+      renderPucApsAttempt({
+        ...input,
+        bindArtifactGuard: render.bindArtifactGuard,
+        bootstrapNonces: render.bootstrapNonces,
+        hostPositions: render.hostPositions,
+        messaging: messages.messaging,
+        nonces: render.rendererNonces,
+        publisherOrigin: render.publisherOrigin,
+      });
+    const apsCapability = Object.freeze({ render: renderer, renderPuc });
+    const validation = Object.freeze({
+      expectedPublisherOrigin: render.publisherOrigin,
+      expectedRendererUrl: rendererUrl,
+      validateApsRenderer: (candidate: unknown): boolean =>
+        validateApsRenderer(candidate, render.publisherOrigin) !== undefined,
+    });
+    context.onDispose(() => {
+      active = false;
+    });
+    return Object.freeze({
+      activate: (activation: IntegrationActivationContext) => {
+        if (active) throw new Error('APS already activated');
+        if (
+          activation.adoption !== undefined &&
+          !validatePersistentFirstDisplaySliceAdoptionV1(
+            activation.adoption,
+            'aps_initial',
+            (state) =>
+              state.values.length === 1 &&
+              state.values[0]?.[0] === 'protocol_version' &&
+              state.values[0][1] === 1
+          )
+        ) {
+          throw new TypeError('APS first-display parser state is invalid');
+        }
+        const validationRelease: { current?: () => void } = {};
+        const rendererRelease: { current?: () => void } = {};
+        activation.onDispose(() => validationRelease.current?.());
+        activation.onDispose(() => rendererRelease.current?.());
+        activation.onDispose(() => {
+          active = false;
+        });
+        validationRelease.current = messages.registerApsValidation(validation);
+        rendererRelease.current = render.registerRenderer('aps', renderer);
+        active = true;
+      },
+      interfaces: Object.freeze({
+        'aps.v1': apsCapability,
+      }),
+    });
+  };
+  return Object.freeze({
+    abi: 1 as const,
+    id: 'aps',
+    phase: 'takeover' as const,
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/aps/render.ts b/crates/trusted-server-js/lib/src/integrations/aps/render.ts
index 610271bd1..414314c52 100644
--- a/crates/trusted-server-js/lib/src/integrations/aps/render.ts
+++ b/crates/trusted-server-js/lib/src/integrations/aps/render.ts
@@ -1,724 +1,1083 @@
-import { log } from '../../core/log';
-import { findSlot } from '../../core/render';
-import type { ApsPrebidRendererEntry, ApsRendererV1, TsjsApi } from '../../core/types';
-
-export const APS_RENDERER_PATH = '/integrations/aps/renderer';
-export const APS_RENDERING_MODE_ATTRIBUTE_NAME = 'data-ts-aps-rendering-mode';
-export const APS_PREBID_CREATIVE_RUNNER_URL =
-  'https://client.aps.amazon-adsystem.com/prebid-creative.js';
-export const APS_NATIVE_RENDERER_TIMEOUT_MS = 10_000;
+import type { ApsRendererV1 } from '../../core/types';
+import { validateApsRenderer } from '../../core/contracts/aps_renderer';
+import type { MessagingAdapter, MessagingPort } from '../../adapters/messaging';
+import type {
+  ArtifactHostPositionLeaseRegistry,
+  BootstrapNonceRegistry,
+  CommittedRenderArtifact,
+  RenderAttempt,
+  RenderFailureReason,
+  RendererNonceRegistry,
+} from '../../services/render';
+import type { ApsSlotMountBinding } from '../../services/slots';
+
+const objectFreezeIntrinsic = Object.freeze;
+const objectGetPrototypeOfIntrinsic = Object.getPrototypeOf;
+const regexpTestIntrinsic = RegExp.prototype.test;
+const bootstrapNoncePattern = /^b1_[A-Za-z0-9_-]{22}$/;
+const rendererNoncePattern = /^n1_[A-Za-z0-9_-]{22}$/;
+const loopbackIpv4Pattern = /^127(?:\.\d{1,3}){3}$/;
+const iframeNamespace = 'http://www.w3.org/1999/xhtml';
+const directDomAvailable =
+  typeof document !== 'undefined' &&
+  typeof HTMLIFrameElement !== 'undefined' &&
+  typeof Document !== 'undefined' &&
+  typeof Node !== 'undefined' &&
+  typeof Element !== 'undefined' &&
+  typeof EventTarget !== 'undefined' &&
+  typeof HTMLCollection !== 'undefined';
+const directRenderDocument = directDomAvailable ? document : undefined;
+const directIframePrototype = directDomAvailable ? HTMLIFrameElement.prototype : undefined;
+const documentCreateElementIntrinsic = directDomAvailable
+  ? Document.prototype.createElement
+  : undefined;
+const documentGetElementByIdIntrinsic = directDomAvailable
+  ? Document.prototype.getElementById
+  : undefined;
+const nodeAppendChildIntrinsic = directDomAvailable ? Node.prototype.appendChild : undefined;
+const nodeRemoveChildIntrinsic = directDomAvailable ? Node.prototype.removeChild : undefined;
+const elementRemoveIntrinsic = directDomAvailable ? Element.prototype.remove : undefined;
+const elementSetAttributeIntrinsic = directDomAvailable
+  ? Element.prototype.setAttribute
+  : undefined;
+const elementGetAttributeIntrinsic = directDomAvailable
+  ? Element.prototype.getAttribute
+  : undefined;
+const eventTargetAddListenerIntrinsic = directDomAvailable
+  ? EventTarget.prototype.addEventListener
+  : undefined;
+const eventTargetRemoveListenerIntrinsic = directDomAvailable
+  ? EventTarget.prototype.removeEventListener
+  : undefined;
+const htmlCollectionItemIntrinsic = directDomAvailable ? HTMLCollection.prototype.item : undefined;
+const nodeOwnerDocumentGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Node.prototype, 'ownerDocument')?.get
+  : undefined;
+const nodeParentNodeGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Node.prototype, 'parentNode')?.get
+  : undefined;
+const nodeIsConnectedGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Node.prototype, 'isConnected')?.get
+  : undefined;
+const elementLocalNameGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Element.prototype, 'localName')?.get
+  : undefined;
+const elementNamespaceGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Element.prototype, 'namespaceURI')?.get
+  : undefined;
+const elementChildrenGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Element.prototype, 'children')?.get
+  : undefined;
+const elementIdGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(Element.prototype, 'id')?.get
+  : undefined;
+const htmlCollectionLengthGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(HTMLCollection.prototype, 'length')?.get
+  : undefined;
+const iframeContentWindowGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'contentWindow')?.get
+  : undefined;
+const iframeSourceGetter = directDomAvailable
+  ? Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'src')?.get
+  : undefined;
+
+export { parseApsRendererDescriptor, validateApsRenderer } from '../../core/contracts/aps_renderer';
+
+export const APS_RENDERER_V2_PATH = '/integrations/aps/renderer/v2';
 export const APS_RENDERER_SANDBOX =
   'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation';
-export const APS_UNIVERSAL_CREATIVE_RENDERER_VERSION = 4;
-
-const MAX_ACCOUNT_ID_BYTES = 1024;
-const MAX_CREATIVE_ID_BYTES = 1024;
-const MAX_CREATIVE_URL_BYTES = 4096;
-const MAX_RENDER_ENVELOPE_BYTES = 256 * 1024;
-const MAX_RENDER_ENVELOPE_BASE64_BYTES = 4 * Math.ceil(MAX_RENDER_ENVELOPE_BYTES / 3);
-const DESCRIPTOR_KEYS = [
-  'aaxResponse',
-  'accountId',
-  'bidId',
-  'creativeUrl',
-  'height',
-  'tagType',
-  'type',
-  'version',
-  'width',
-] as const;
-const DESCRIPTOR_KEYS_WITH_CREATIVE_ID = [...DESCRIPTOR_KEYS, 'creativeId'].sort();
-const activeFrames = new WeakMap<HTMLElement, HTMLIFrameElement>();
-const pendingFrameCancels = new WeakMap<HTMLElement, () => void>();
-const RENDERER_READY_MESSAGE = 'trusted-server/aps/renderer-ready';
-const RENDERER_FAILED_MESSAGE = 'trusted-server/aps/renderer-failed';
-const RENDERER_READY_TIMEOUT_MS = 10_000;
-const MAX_PREBID_RENDERER_ENTRIES = 256;
-const DEFAULT_PREBID_RENDERER_TTL_SECONDS = 300;
-const MAX_PREBID_RENDERER_TTL_SECONDS = 3600;
-const MAX_PREBID_ID_BYTES = 1024;
-
-type ValidatedRendererCacheEntry = {
-  publisherOrigin: string;
-  renderer: ApsRendererV1;
-};
-const validatedRendererCache = new WeakMap<object, ValidatedRendererCacheEntry>();
-const nativeDispatches = new Map<string, symbol>();
-const publisherNativeRendering =
-  typeof document !== 'undefined' &&
-  document.currentScript?.getAttribute(APS_RENDERING_MODE_ATTRIBUTE_NAME) === 'publisher_native';
+export const APS_PERMANENT_SANDBOX =
+  'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation';
 
-function releaseNativeDispatch(slotId: string, dispatch: symbol): boolean {
-  if (nativeDispatches.get(slotId) !== dispatch) return false;
-  nativeDispatches.delete(slotId);
-  return true;
+/** Validate, copy, and freeze one APS tagged render source. */
+export function prepareApsRenderSource(
+  input: unknown,
+  publisherOrigin?: string
+): Readonly<ApsRendererV1> | undefined {
+  try {
+    const renderer = validateApsRenderer(input, publisherOrigin);
+    return renderer
+      ? (Reflect.apply(objectFreezeIntrinsic, Object, [renderer]) as Readonly<ApsRendererV1>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
 }
 
-function sourceBelongsToElement(
-  source: MessageEventSource | null | undefined,
-  element: HTMLElement
-): boolean {
-  return source
-    ? Array.from(element.querySelectorAll('iframe')).some(
-        (iframe) => iframe.contentWindow === source
-      )
-    : false;
+export interface DirectApsAttemptOptions {
+  readonly attempt: RenderAttempt;
+  readonly bindArtifactGuard: (
+    artifact: CommittedRenderArtifact,
+    current: () => boolean
+  ) => boolean;
+  readonly bootstrapNonces: BootstrapNonceRegistry;
+  readonly container: HTMLElement;
+  readonly messaging: MessagingAdapter;
+  readonly nonces: RendererNonceRegistry;
+  readonly publisherOrigin: string;
 }
 
-function sourceMatchedCandidates(
-  candidates: HTMLElement[],
-  source?: MessageEventSource | null
-): HTMLElement[] {
-  if (!source) return candidates;
-  return candidates.filter((element) => sourceBelongsToElement(source, element));
+export interface PucApsAttemptOptions extends DirectApsAttemptOptions {
+  readonly baseArtifact: CommittedRenderArtifact;
+  readonly bindArtifact: ApsSlotMountBinding['bindArtifact'];
+  readonly hostPositions: ArtifactHostPositionLeaseRegistry;
+  readonly isBindingCurrent: () => boolean;
+  readonly onArtifactTransferred: () => void;
 }
 
-function dynamicSlotCandidates(
-  divIdPrefix: string,
-  source?: MessageEventSource | null
-): HTMLElement[] {
-  const candidates = Array.from(document.querySelectorAll<HTMLElement>('[id]')).filter(
-    (element) => element.id.startsWith(divIdPrefix) && !element.id.endsWith('-container')
-  );
-  return sourceMatchedCandidates(candidates, source);
-}
+type ApsTopPageAttemptOptions =
+  | (DirectApsAttemptOptions & Readonly<{ mode: 'direct' }>)
+  | (PucApsAttemptOptions & Readonly<{ mode: 'puc_overlay' }>);
 
-function uniqueSlotCandidate(candidates: HTMLElement[]): HTMLElement | null {
-  return candidates.length === 1 ? candidates[0]! : null;
+function freeze<Value extends object>(value: Value): Readonly<Value> {
+  return Reflect.apply(objectFreezeIntrinsic, Object, [value]) as Readonly<Value>;
 }
 
-function findApsContainer(slotId: string, source?: MessageEventSource | null): HTMLElement | null {
+export function resolveApsRendererV2Url(publisherOrigin: string): string | undefined {
   try {
-    const mapping = window.tsjs?.divToSlotId ?? {};
-    const mappedCandidates = sourceMatchedCandidates(
-      Object.entries(mapping)
-        .filter(([, mappedSlotId]) => mappedSlotId === slotId)
-        .map(([divId]) => findSlot(divId))
-        .filter((element): element is HTMLElement => element !== null),
-      source
-    );
-    const mapped = uniqueSlotCandidate(mappedCandidates);
-    if (mapped) return mapped;
-
-    if (slotId.endsWith('-container')) {
-      const inner = findSlot(slotId.slice(0, -'-container'.length));
-      if (inner) return source && !sourceBelongsToElement(source, inner) ? null : inner;
-    }
-
-    const direct = findSlot(slotId);
-    if (direct && !direct.id.endsWith('-container')) {
-      return source && !sourceBelongsToElement(source, direct) ? null : direct;
-    }
-
-    const configuredDivId = window.tsjs?.adSlots?.find((slot) => slot.id === slotId)?.div_id;
-    if (configuredDivId) {
-      const configured = findSlot(configuredDivId);
-      if (configured) {
-        return source && !sourceBelongsToElement(source, configured) ? null : configured;
-      }
-
-      const dynamic = uniqueSlotCandidate(dynamicSlotCandidates(configuredDivId, source));
-      if (dynamic) return dynamic;
+    const origin = new URL(publisherOrigin);
+    const loopbackHttp =
+      origin.protocol === 'http:' &&
+      (origin.hostname === 'localhost' ||
+        origin.hostname === '[::1]' ||
+        (Reflect.apply(regexpTestIntrinsic, loopbackIpv4Pattern, [origin.hostname]) as boolean));
+    if (
+      origin.origin !== publisherOrigin ||
+      (origin.protocol !== 'https:' && !loopbackHttp) ||
+      origin.username !== '' ||
+      origin.password !== ''
+    ) {
+      return undefined;
     }
-
-    return uniqueSlotCandidate(dynamicSlotCandidates(slotId, source));
+    const rendererUrl = new URL(APS_RENDERER_V2_PATH, origin);
+    if (
+      rendererUrl.origin !== origin.origin ||
+      rendererUrl.pathname !== APS_RENDERER_V2_PATH ||
+      rendererUrl.search !== '' ||
+      rendererUrl.hash !== ''
+    ) {
+      return undefined;
+    }
+    return rendererUrl.href;
   } catch {
-    return null;
+    return undefined;
   }
 }
 
-function cancelPendingApsRendering(slotId: string, source?: MessageEventSource | null): void {
-  const container = findApsContainer(slotId, source);
-  if (container) pendingFrameCancels.get(container)?.();
+function mapNonceIssueFailure(
+  reason: 'capability_registry_full' | 'identity_generation_failed' | 'invalid_attempt'
+): RenderFailureReason {
+  return reason === 'invalid_attempt' ? 'internal_error' : reason;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+function mapRunnerFailure(reason: unknown): RenderFailureReason | undefined {
+  if (reason === 'descriptor_invalid') return 'winner_not_renderable';
+  if (reason === 'runner_no_load' || reason === 'runner_failed') return reason;
+  return undefined;
 }
 
-function hasExactKeys(
+function readNonceIssueResult(
   value: unknown,
-  expected: readonly string[]
-): value is Record<string, unknown> {
-  if (!isRecord(value)) return false;
-  const actual = Object.keys(value).sort();
-  const sortedExpected = [...expected].sort();
-  return (
-    actual.length === sortedExpected.length &&
-    actual.every((key, index) => key === sortedExpected[index])
-  );
-}
-
-/** Parse only the versioned descriptor shape; decoded-envelope trust checks happen separately. */
-export function parseApsRendererDescriptor(value: unknown): ApsRendererV1 | undefined {
-  if (
-    !hasExactKeys(value, DESCRIPTOR_KEYS) &&
-    !hasExactKeys(value, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)
-  ) {
-    return undefined;
-  }
-
-  if (
-    value.type !== 'aps' ||
-    value.version !== 1 ||
-    typeof value.accountId !== 'string' ||
-    value.accountId.length === 0 ||
-    new TextEncoder().encode(value.accountId).length > MAX_ACCOUNT_ID_BYTES ||
-    typeof value.bidId !== 'string' ||
-    value.bidId.length === 0 ||
-    (Object.prototype.hasOwnProperty.call(value, 'creativeId') &&
-      (typeof value.creativeId !== 'string' ||
-        value.creativeId.length === 0 ||
-        new TextEncoder().encode(value.creativeId).length > MAX_CREATIVE_ID_BYTES)) ||
-    (value.tagType !== 'iframe' && value.tagType !== 'script') ||
-    typeof value.creativeUrl !== 'string' ||
-    typeof value.aaxResponse !== 'string' ||
-    value.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||
-    !Number.isSafeInteger(value.width) ||
-    (value.width as number) <= 0 ||
-    !Number.isSafeInteger(value.height) ||
-    (value.height as number) <= 0
-  ) {
+  pattern: RegExp
+):
+  | Readonly<{ ok: true; nonce: string }>
+  | Readonly<{
+      ok: false;
+      reason: 'capability_registry_full' | 'identity_generation_failed' | 'invalid_attempt';
+    }>
+  | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      !Object.isFrozen(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return undefined;
+    }
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length !== 2) return undefined;
+    const ok = Object.getOwnPropertyDescriptor(value, 'ok');
+    if (!ok || !ok.enumerable || !('value' in ok)) return undefined;
+    if (ok.value === true) {
+      const nonce = Object.getOwnPropertyDescriptor(value, 'nonce');
+      if (
+        !nonce ||
+        !nonce.enumerable ||
+        !('value' in nonce) ||
+        typeof nonce.value !== 'string' ||
+        !(Reflect.apply(regexpTestIntrinsic, pattern, [nonce.value]) as boolean)
+      ) {
+        return undefined;
+      }
+      return freeze({ ok: true as const, nonce: nonce.value });
+    }
+    if (ok.value !== false) return undefined;
+    const reason = Object.getOwnPropertyDescriptor(value, 'reason');
+    if (
+      !reason ||
+      !reason.enumerable ||
+      !('value' in reason) ||
+      (reason.value !== 'capability_registry_full' &&
+        reason.value !== 'identity_generation_failed' &&
+        reason.value !== 'invalid_attempt')
+    ) {
+      return undefined;
+    }
+    return freeze({ ok: false as const, reason: reason.value });
+  } catch {
     return undefined;
   }
-
-  return value as unknown as ApsRendererV1;
 }
 
-function decodeStandardBase64(value: string): Uint8Array | undefined {
+/** Drive one APS attempt through the shared three-phase top-page mount protocol. */
+export function mountApsTopPageAttempt(options: ApsTopPageAttemptOptions): boolean {
   if (
-    value.length === 0 ||
-    value.length % 4 !== 0 ||
-    !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)
+    !directRenderDocument ||
+    !directIframePrototype ||
+    typeof documentCreateElementIntrinsic !== 'function' ||
+    typeof documentGetElementByIdIntrinsic !== 'function' ||
+    typeof nodeAppendChildIntrinsic !== 'function' ||
+    typeof nodeRemoveChildIntrinsic !== 'function' ||
+    typeof elementRemoveIntrinsic !== 'function' ||
+    typeof elementSetAttributeIntrinsic !== 'function' ||
+    typeof elementGetAttributeIntrinsic !== 'function' ||
+    typeof eventTargetAddListenerIntrinsic !== 'function' ||
+    typeof eventTargetRemoveListenerIntrinsic !== 'function' ||
+    typeof htmlCollectionItemIntrinsic !== 'function' ||
+    typeof nodeOwnerDocumentGetter !== 'function' ||
+    typeof nodeParentNodeGetter !== 'function' ||
+    typeof nodeIsConnectedGetter !== 'function' ||
+    typeof elementLocalNameGetter !== 'function' ||
+    typeof elementNamespaceGetter !== 'function' ||
+    typeof elementChildrenGetter !== 'function' ||
+    typeof elementIdGetter !== 'function' ||
+    typeof htmlCollectionLengthGetter !== 'function' ||
+    typeof iframeContentWindowGetter !== 'function' ||
+    typeof iframeSourceGetter !== 'function'
   ) {
-    return undefined;
+    return false;
   }
 
+  let attempt: RenderAttempt;
+  let bindArtifactGuard: DirectApsAttemptOptions['bindArtifactGuard'];
+  let bootstrapNonces: BootstrapNonceRegistry;
+  let rendererNonces: RendererNonceRegistry;
+  let messaging: MessagingAdapter;
+  let container: HTMLElement;
+  let publisherOrigin: string;
+  let sourceCandidate: unknown;
+  let attemptId: string;
+  let attemptSlot: string;
+  let attemptGeneration: object;
+  let navigationGeneration: object;
+  let ownerDocument: Document;
+  let mode: ApsTopPageAttemptOptions['mode'];
+  let baseArtifact: CommittedRenderArtifact | undefined;
+  let bindArtifact: ApsSlotMountBinding['bindArtifact'] | undefined;
+  let hostPositions: ArtifactHostPositionLeaseRegistry | undefined;
+  let isBindingCurrent: () => boolean;
+  let onArtifactTransferred: () => void;
+  let expectedContainerId: string | undefined;
   try {
-    const binary = atob(value);
-    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;
-    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    attempt = options.attempt;
+    bindArtifactGuard = options.bindArtifactGuard;
+    bootstrapNonces = options.bootstrapNonces;
+    rendererNonces = options.nonces;
+    messaging = options.messaging;
+    container = options.container;
+    publisherOrigin = options.publisherOrigin;
+    sourceCandidate = attempt.renderSource;
+    attemptId = attempt.id;
+    attemptSlot = attempt.slot;
+    attemptGeneration = attempt.generation;
+    navigationGeneration = attempt.navigationGeneration;
+    ownerDocument = Reflect.apply(nodeOwnerDocumentGetter, container, []) as Document;
+    mode = options.mode;
+    baseArtifact = options.mode === 'puc_overlay' ? options.baseArtifact : undefined;
+    bindArtifact = options.mode === 'puc_overlay' ? options.bindArtifact : undefined;
+    hostPositions = options.mode === 'puc_overlay' ? options.hostPositions : undefined;
+    isBindingCurrent = options.mode === 'puc_overlay' ? options.isBindingCurrent : () => true;
+    onArtifactTransferred =
+      options.mode === 'puc_overlay' ? options.onArtifactTransferred : () => undefined;
+    expectedContainerId =
+      options.mode === 'puc_overlay'
+        ? (Reflect.apply(elementIdGetter, container, []) as string)
+        : undefined;
   } catch {
-    return undefined;
+    return false;
   }
-}
-
-function validCreativeUrl(value: string, publisherOrigin: string): boolean {
-  if (new TextEncoder().encode(value).length > MAX_CREATIVE_URL_BYTES) return false;
 
+  let exactDocumentOrigin: boolean;
   try {
-    const url = new URL(value);
-    return (
-      url.protocol === 'https:' &&
-      url.username === '' &&
-      url.password === '' &&
-      url.origin !== publisherOrigin
-    );
+    exactDocumentOrigin =
+      ownerDocument === directRenderDocument &&
+      ownerDocument.defaultView?.location.origin === publisherOrigin;
   } catch {
+    exactDocumentOrigin = false;
+  }
+  const renderer = prepareApsRenderSource(sourceCandidate, publisherOrigin);
+  const rendererUrl = resolveApsRendererV2Url(publisherOrigin);
+  let creativeOrigin: string | undefined;
+  try {
+    creativeOrigin = renderer ? new URL(renderer.creativeUrl).origin : undefined;
+  } catch {
+    creativeOrigin = undefined;
+  }
+  if (
+    !exactDocumentOrigin ||
+    !renderer ||
+    !rendererUrl ||
+    !creativeOrigin ||
+    (mode === 'puc_overlay' && !expectedContainerId)
+  ) {
+    try {
+      attempt.fail('winner_not_renderable');
+    } catch {
+      // Invalid input remains rejected even when the attempt boundary is hostile.
+    }
     return false;
   }
-}
 
-/** Fully validate the exact APS envelope and cross-check every duplicated descriptor field. */
-export function validateApsRenderer(
-  value: unknown,
-  publisherOrigin = window.location.origin
-): ApsRendererV1 | undefined {
-  if (isRecord(value)) {
-    const cached = validatedRendererCache.get(value);
-    if (cached?.publisherOrigin === publisherOrigin) return cached.renderer;
+  let installCaptureMethod: MessagingAdapter['installCaptureListener'];
+  let extractPortsMethod: MessagingAdapter['extractTransferredPorts'];
+  let postWindowMethod: MessagingAdapter['postWindow'];
+  let parseMessageMethod: MessagingAdapter['parseProtocolMessage'];
+  let issueBootstrapMethod: BootstrapNonceRegistry['issue'];
+  let bindBootstrapMethod: BootstrapNonceRegistry['bindSource'];
+  let consumeBootstrapMethod: BootstrapNonceRegistry['consume'];
+  let issueRendererMethod: RendererNonceRegistry['issue'];
+  let bindRendererMethod: RendererNonceRegistry['bindSource'];
+  let consumeRendererMethod: RendererNonceRegistry['consume'];
+  let beginDirectMethod: RenderAttempt['beginDirect'];
+  let beginDocumentMethod: RenderAttempt['beginApsDocument'];
+  let documentAcceptedMethod: RenderAttempt['apsDocumentAccepted'];
+  let acceptMethod: RenderAttempt['accept'];
+  let failMethod: RenderAttempt['fail'];
+  let snapshotMethod: RenderAttempt['snapshot'];
+  try {
+    installCaptureMethod = messaging.installCaptureListener;
+    extractPortsMethod = messaging.extractTransferredPorts;
+    postWindowMethod = messaging.postWindow;
+    parseMessageMethod = messaging.parseProtocolMessage;
+    issueBootstrapMethod = bootstrapNonces.issue;
+    bindBootstrapMethod = bootstrapNonces.bindSource;
+    consumeBootstrapMethod = bootstrapNonces.consume;
+    issueRendererMethod = rendererNonces.issue;
+    bindRendererMethod = rendererNonces.bindSource;
+    consumeRendererMethod = rendererNonces.consume;
+    beginDirectMethod = attempt.beginDirect;
+    beginDocumentMethod = attempt.beginApsDocument;
+    documentAcceptedMethod = attempt.apsDocumentAccepted;
+    acceptMethod = attempt.accept;
+    failMethod = attempt.fail;
+    snapshotMethod = attempt.snapshot;
+    if (
+      typeof installCaptureMethod !== 'function' ||
+      typeof extractPortsMethod !== 'function' ||
+      typeof postWindowMethod !== 'function' ||
+      typeof parseMessageMethod !== 'function' ||
+      typeof issueBootstrapMethod !== 'function' ||
+      typeof bindBootstrapMethod !== 'function' ||
+      typeof consumeBootstrapMethod !== 'function' ||
+      typeof issueRendererMethod !== 'function' ||
+      typeof bindRendererMethod !== 'function' ||
+      typeof consumeRendererMethod !== 'function' ||
+      typeof beginDocumentMethod !== 'function' ||
+      typeof documentAcceptedMethod !== 'function' ||
+      typeof acceptMethod !== 'function' ||
+      typeof failMethod !== 'function' ||
+      typeof snapshotMethod !== 'function' ||
+      (mode === 'direct'
+        ? typeof beginDirectMethod !== 'function' ||
+          Reflect.apply(beginDirectMethod, attempt, []) !== true
+        : attempt.snapshot().state !== 'waiting_for_insertion' || !isBindingCurrent())
+    ) {
+      return false;
+    }
+  } catch {
+    return false;
   }
 
-  const renderer = parseApsRendererDescriptor(value);
-  if (!renderer || !validCreativeUrl(renderer.creativeUrl, publisherOrigin)) return undefined;
-
-  const bytes = decodeStandardBase64(renderer.aaxResponse);
-  if (!bytes) return undefined;
+  const fail = (reason: RenderFailureReason): false => {
+    try {
+      Reflect.apply(failMethod, attempt, [reason]);
+    } catch {
+      // The attempt's terminal latch owns failure authority.
+    }
+    return false;
+  };
+  const attemptState = (): ReturnType<RenderAttempt['snapshot']>['state'] | undefined => {
+    try {
+      return Reflect.apply(snapshotMethod, attempt, []).state;
+    } catch {
+      return undefined;
+    }
+  };
+  const exactAttemptIdentity = (): boolean => {
+    try {
+      return (
+        attempt.id === attemptId &&
+        attempt.slot === attemptSlot &&
+        attempt.generation === attemptGeneration &&
+        attempt.navigationGeneration === navigationGeneration &&
+        (mode === 'direct' || isBindingCurrent())
+      );
+    } catch {
+      return false;
+    }
+  };
 
-  let decoded: unknown;
+  let bootstrapIssue: unknown;
   try {
-    decoded = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    bootstrapIssue = Reflect.apply(issueBootstrapMethod, bootstrapNonces, [{ attempt }]);
   } catch {
-    return undefined;
+    return fail('identity_generation_failed');
   }
+  const issuedBootstrap = readNonceIssueResult(bootstrapIssue, bootstrapNoncePattern);
+  if (!issuedBootstrap) return fail('identity_generation_failed');
+  if (!issuedBootstrap.ok) return fail(mapNonceIssueFailure(issuedBootstrap.reason));
 
-  if (!hasExactKeys(decoded, ['seatbid'])) return undefined;
-  const seatbids = decoded.seatbid;
-  if (!Array.isArray(seatbids) || seatbids.length !== 1) return undefined;
-  const seat = seatbids[0];
-  if (!hasExactKeys(seat, ['bid']) || !Array.isArray(seat.bid) || seat.bid.length !== 1) {
-    return undefined;
+  let rendererIssue: unknown;
+  try {
+    rendererIssue = Reflect.apply(issueRendererMethod, rendererNonces, [{ attempt }]);
+  } catch {
+    return fail('identity_generation_failed');
   }
+  const issuedRenderer = readNonceIssueResult(rendererIssue, rendererNoncePattern);
+  if (!issuedRenderer) return fail('identity_generation_failed');
+  if (!issuedRenderer.ok) return fail(mapNonceIssueFailure(issuedRenderer.reason));
 
-  const bid = seat.bid[0];
-  if (!hasExactKeys(bid, ['ext', 'h', 'id', 'price', 'w'])) return undefined;
-  if (!hasExactKeys(bid.ext, ['creativeurl', 'tagtype'])) return undefined;
+  const bootstrapNonce = issuedBootstrap.nonce;
+  const rendererNonce = issuedRenderer.nonce;
 
-  if (
-    bid.id !== renderer.bidId ||
-    bid.w !== renderer.width ||
-    bid.h !== renderer.height ||
-    bid.ext.creativeurl !== renderer.creativeUrl ||
-    bid.ext.tagtype !== renderer.tagType ||
-    typeof bid.price !== 'number' ||
-    !Number.isFinite(bid.price) ||
-    bid.price < 0
-  ) {
-    return undefined;
+  let iframe: HTMLIFrameElement;
+  try {
+    iframe = Reflect.apply(documentCreateElementIntrinsic, ownerDocument, [
+      'iframe',
+    ]) as HTMLIFrameElement;
+    if (
+      typeof iframe !== 'object' ||
+      iframe === null ||
+      Reflect.apply(objectGetPrototypeOfIntrinsic, Object, [iframe]) !== directIframePrototype ||
+      Reflect.apply(nodeOwnerDocumentGetter, iframe, []) !== ownerDocument ||
+      Reflect.apply(elementLocalNameGetter, iframe, []) !== 'iframe' ||
+      Reflect.apply(elementNamespaceGetter, iframe, []) !== iframeNamespace ||
+      Reflect.apply(nodeParentNodeGetter, iframe, []) !== null ||
+      Reflect.apply(nodeIsConnectedGetter, iframe, []) === true
+    ) {
+      return fail('renderer_document_no_load');
+    }
+    const attributes = [
+      ['title', 'Ad content'],
+      ['scrolling', 'no'],
+      ['frameborder', '0'],
+      ['width', String(renderer.width)],
+      ['height', String(renderer.height)],
+      ['aria-label', 'Advertisement'],
+      ['marginheight', '0'],
+      ['marginwidth', '0'],
+      ['sandbox', APS_RENDERER_SANDBOX],
+      [
+        'style',
+        mode === 'puc_overlay'
+          ? 'border: 0; display: block; height: ' +
+            String(renderer.height) +
+            'px; inset: 0; margin: 0; overflow: hidden; position: absolute; visibility: hidden; width: ' +
+            String(renderer.width) +
+            'px; z-index: 2147483647'
+          : 'border: 0; display: block; height: ' +
+            String(renderer.height) +
+            'px; margin: 0; overflow: hidden; width: ' +
+            String(renderer.width) +
+            'px',
+      ],
+    ] as const;
+    for (let attributeIndex = 0; attributeIndex < attributes.length; attributeIndex += 1) {
+      const attribute = attributes[attributeIndex];
+      if (attribute) {
+        Reflect.apply(elementSetAttributeIntrinsic, iframe, [attribute[0], attribute[1]]);
+      }
+    }
+  } catch {
+    return fail('renderer_document_no_load');
   }
 
-  const validated = Object.freeze({ ...renderer }) as ApsRendererV1;
-  validatedRendererCache.set(value as object, { publisherOrigin, renderer: validated });
-  validatedRendererCache.set(validated, { publisherOrigin, renderer: validated });
-  return validated;
-}
+  let disposed = false;
+  let artifactOwnedByAttempt = false;
+  let insertionCommitted = false;
+  let appendInProgress = false;
+  let frameErrorObserved = false;
+  let frameSource: object | undefined;
+  let bootstrapBound = false;
+  let navigationPosted = false;
+  let containerReady = false;
+  let envelopeSent = false;
+  let documentAccepted = false;
+  let documentPort: MessagingPort | undefined;
+  let releaseGlobalListener: (() => void) | undefined;
+  let insertionPredecessors: readonly Element[] = [];
+  let baseArtifactDisposed = false;
+  let baseArtifactTransferred = false;
+  let hostPositionBound = false;
+  const expectedFrameSource = rendererUrl + '#' + bootstrapNonce;
+
+  const disposeBaseArtifact = (): void => {
+    if (mode !== 'puc_overlay' || !baseArtifactTransferred || baseArtifactDisposed) return;
+    baseArtifactDisposed = true;
+    try {
+      baseArtifact?.dispose();
+    } catch {
+      // The combined artifact remains terminal even when prior cleanup is hostile.
+    }
+  };
 
-function validPrebidIdentity(value: unknown): value is string {
-  return (
-    typeof value === 'string' &&
-    value.length > 0 &&
-    new TextEncoder().encode(value).length <= MAX_PREBID_ID_BYTES
-  );
-}
+  const restoreHostPosition = (): void => {
+    try {
+      hostPositions?.release(artifact);
+    } catch {
+      // Compare-owned style restoration cannot expand into publisher styles.
+    }
+  };
 
-function validPrebidAdId(value: unknown): value is string {
-  return validPrebidIdentity(value) && /^[A-Za-z0-9-]+$/.test(value);
-}
+  const bootstrapListenerResource = freeze({
+    close: (): void => {
+      const release = releaseGlobalListener;
+      releaseGlobalListener = undefined;
+      if (!release) return;
+      try {
+        release();
+      } catch {
+        // Capture-listener removal remains best-effort and exact-once.
+      }
+    },
+  });
 
-function prunePrebidRenderers(registry: Record<string, ApsPrebidRendererEntry>, now: number): void {
-  for (const [adId, entry] of Object.entries(registry)) {
-    if (!Number.isFinite(entry.expiresAt) || entry.expiresAt <= now) delete registry[adId];
-  }
+  const removeFrameErrorListener = (): void => {
+    try {
+      Reflect.apply(eventTargetRemoveListenerIntrinsic, iframe, ['error', onFrameError]);
+    } catch {
+      // Listener cleanup cannot interrupt terminal resource disposal.
+    }
+  };
 
-  const entries = Object.entries(registry);
-  if (entries.length <= MAX_PREBID_RENDERER_ENTRIES) return;
-  entries
-    .sort(([, left], [, right]) => left.registeredAt - right.registeredAt)
-    .slice(0, entries.length - MAX_PREBID_RENDERER_ENTRIES)
-    .forEach(([adId]) => delete registry[adId]);
-}
+  let artifactBinding:
+    | Readonly<{
+        commit: () => boolean;
+        finalize: () => void;
+        isCurrent: () => boolean;
+        previousArtifact: CommittedRenderArtifact | undefined;
+        release: () => void;
+        rollback: () => void;
+      }>
+    | undefined;
+  const artifact: CommittedRenderArtifact = freeze({
+    kind: 'aps_mount' as const,
+    attemptId,
+    slot: attemptSlot,
+    navigationGeneration,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      removeFrameErrorListener();
+      bootstrapListenerResource.close();
+      try {
+        documentPort?.close();
+      } catch {
+        // The renderer registry also owns exact-once retained-port cleanup.
+      }
+      try {
+        Reflect.apply(elementRemoveIntrinsic, iframe, []);
+      } catch {
+        // DOM removal remains best-effort under a hostile publisher realm.
+      }
+      restoreHostPosition();
+      artifactBinding?.release();
+      disposeBaseArtifact();
+    },
+  });
 
-/** Bind Prebid's generated ad ID to a fully validated APS renderer capability. */
-export function registerApsPrebidRenderer(
-  adId: unknown,
-  adUnitCode: unknown,
-  input: unknown,
-  ttlSeconds: unknown = DEFAULT_PREBID_RENDERER_TTL_SECONDS,
-  lifecycle?: { markUsed(): void }
-): boolean {
-  if (
-    !validPrebidAdId(adId) ||
-    !validPrebidIdentity(adUnitCode) ||
-    typeof lifecycle?.markUsed !== 'function'
-  ) {
-    return false;
+  const persistentFrameCurrent = (): boolean => {
+    try {
+      return (
+        insertionCommitted &&
+        !disposed &&
+        Reflect.apply(nodeOwnerDocumentGetter, iframe, []) === ownerDocument &&
+        Reflect.apply(nodeParentNodeGetter, iframe, []) === container &&
+        Reflect.apply(nodeIsConnectedGetter, iframe, []) === true &&
+        (mode !== 'puc_overlay' ||
+          (Reflect.apply(elementIdGetter, container, []) === expectedContainerId &&
+            Reflect.apply(documentGetElementByIdIntrinsic, ownerDocument, [expectedContainerId]) ===
+              container)) &&
+        Reflect.apply(iframeContentWindowGetter, iframe, []) === frameSource &&
+        Reflect.apply(elementGetAttributeIntrinsic, iframe, ['src']) === expectedFrameSource &&
+        Reflect.apply(iframeSourceGetter, iframe, []) === expectedFrameSource &&
+        Reflect.apply(elementGetAttributeIntrinsic, iframe, ['sandbox']) ===
+          APS_PERMANENT_SANDBOX &&
+        (mode !== 'puc_overlay' ||
+          !hostPositionBound ||
+          hostPositions?.current(artifact) === true) &&
+        (mode !== 'puc_overlay' || artifactBinding?.isCurrent() === true)
+      );
+    } catch {
+      return false;
+    }
+  };
+  if (!bindArtifactGuard(artifact, persistentFrameCurrent)) {
+    artifact.dispose();
+    return fail('internal_error');
   }
-  const renderer = validateApsRenderer(input);
-  if (!renderer) return false;
-
-  const now = Date.now();
-  const boundedTtlSeconds =
-    typeof ttlSeconds === 'number' && Number.isFinite(ttlSeconds) && ttlSeconds > 0
-      ? Math.min(ttlSeconds, MAX_PREBID_RENDERER_TTL_SECONDS)
-      : DEFAULT_PREBID_RENDERER_TTL_SECONDS;
-  const tsjs = (window.tsjs ??= {} as TsjsApi);
-  const registry = (tsjs.apsPrebidRenderers ??= Object.create(null) as Record<
-    string,
-    ApsPrebidRendererEntry
-  >);
-  prunePrebidRenderers(registry, now);
-
-  if (!(adId in registry) && Object.keys(registry).length >= MAX_PREBID_RENDERER_ENTRIES) {
-    const oldest = Object.entries(registry).sort(
-      ([, left], [, right]) => left.registeredAt - right.registeredAt
-    )[0];
-    if (oldest) delete registry[oldest[0]];
+  if (mode === 'puc_overlay') {
+    try {
+      artifactBinding = bindArtifact?.(artifact);
+    } catch {
+      artifactBinding = undefined;
+    }
+    if (!artifactBinding) {
+      artifact.dispose();
+      return fail('slot_unresolved');
+    }
   }
 
-  registry[adId] = {
-    adUnitCode,
-    renderer,
-    registeredAt: now,
-    expiresAt: now + boundedTtlSeconds * 1000,
-    markUsed: lifecycle.markUsed,
+  const startupFailure = (reason: RenderFailureReason): false => {
+    if (!artifactOwnedByAttempt) artifact.dispose();
+    return fail(reason);
   };
-  return true;
-}
 
-/** Return an unexpired Prebid APS capability without consuming it. */
-export function getApsPrebidRenderer(adId: string): ApsPrebidRendererEntry | undefined {
-  if (!validPrebidAdId(adId)) return undefined;
-  const registry = window.tsjs?.apsPrebidRenderers;
-  const entry = registry?.[adId];
-  if (!entry) return undefined;
-  if (
-    !Number.isFinite(entry.expiresAt) ||
-    entry.expiresAt <= Date.now() ||
-    typeof entry.markUsed !== 'function'
-  ) {
-    delete registry![adId];
-    return undefined;
-  }
-  return entry;
-}
-
-/** Atomically consume the exact capability previously returned by the registry. */
-export function consumeApsPrebidRenderer(adId: string, expected: ApsPrebidRendererEntry): boolean {
-  const registry = window.tsjs?.apsPrebidRenderers;
-  if (!registry || registry[adId] !== expected) return false;
-  delete registry[adId];
-  return true;
-}
+  const snapshotContainerPredecessors = (): readonly Element[] => {
+    const predecessors: Element[] = [];
+    try {
+      const children = Reflect.apply(elementChildrenGetter, container, []) as HTMLCollection;
+      const length = Reflect.apply(htmlCollectionLengthGetter, children, []) as number;
+      for (let childIndex = 0; childIndex < length; childIndex += 1) {
+        const child = Reflect.apply(htmlCollectionItemIntrinsic, children, [
+          childIndex,
+        ]) as Element | null;
+        if (child && child !== iframe) predecessors[predecessors.length] = child;
+      }
+    } catch {
+      // Failure to inspect publisher siblings cannot expand cleanup authority.
+    }
+    return predecessors;
+  };
 
-export interface DispatchApsRenderingOptions {
-  slotId: string;
-  renderer: unknown;
-  source?: MessageEventSource | null;
-  /** Existing Trusted Server owner, invoked only in the default mode. */
-  trustedServer: (renderer: ApsRendererV1) => boolean;
-}
+  const commitContainer = (predecessors: readonly Element[]): void => {
+    try {
+      for (let childIndex = predecessors.length - 1; childIndex >= 0; childIndex -= 1) {
+        const child = predecessors[childIndex];
+        if (
+          child &&
+          child !== iframe &&
+          Reflect.apply(nodeParentNodeGetter, child, []) === container
+        ) {
+          Reflect.apply(nodeRemoveChildIntrinsic, container, [child]);
+        }
+      }
+    } catch {
+      // A hostile predecessor cannot revoke the accepted artifact.
+    }
+  };
 
-/**
- * Dispatch a validated APS descriptor to exactly one configured rendering owner.
- *
- * Native mode loads APS's fixed Prebid creative runner in a publisher-origin friendly
- * frame. Superseded attempts are cancelled and never fall back to the opaque renderer.
- */
-export function dispatchApsRendering({
-  slotId,
-  renderer: input,
-  source,
-  trustedServer,
-}: DispatchApsRenderingOptions): boolean | Promise<boolean> {
-  // Every native attempt supersedes a pending frame for this slot, including an
-  // invalid replacement. Default mode preserves a valid in-flight frame until a
-  // validated replacement reaches renderApsCreative.
-  if (publisherNativeRendering) cancelPendingApsRendering(slotId, source);
-  const dispatch = Symbol(slotId);
-  nativeDispatches.set(slotId, dispatch);
-
-  const renderer = validateApsRenderer(input);
-  if (!renderer) {
-    releaseNativeDispatch(slotId, dispatch);
-    log.warn('APS renderer: rejected descriptor');
-    return false;
-  }
-  if (!publisherNativeRendering) {
+  const acquireOverlayPosition = (): boolean => {
+    if (mode !== 'puc_overlay') return true;
     try {
-      return trustedServer(renderer);
-    } finally {
-      releaseNativeDispatch(slotId, dispatch);
+      if (!isBindingCurrent()) return false;
+      const view = ownerDocument.defaultView;
+      if (!view) return false;
+      const computed = view.getComputedStyle(container);
+      if (computed.position !== 'static') {
+        const previousArtifact = artifactBinding?.previousArtifact;
+        hostPositionBound = Boolean(
+          previousArtifact && hostPositions?.inherit(artifact, previousArtifact, container)
+        );
+        return true;
+      }
+      const style = container.style;
+      const previousPosition = style.getPropertyValue('position');
+      const previousPriority = style.getPropertyPriority('position');
+      style.setProperty('position', 'relative');
+      if (
+        style.getPropertyValue('position') !== 'relative' ||
+        style.getPropertyPriority('position') !== ''
+      ) {
+        return false;
+      }
+      hostPositionBound =
+        hostPositions?.bindOwned(artifact, container, previousPosition, previousPriority) === true;
+      return hostPositionBound && isBindingCurrent();
+    } catch {
+      return false;
     }
-  }
+  };
 
-  let rendering: Promise<boolean>;
-  try {
-    rendering = renderApsPublisherNative({ slotId, renderer, source });
-  } catch {
-    releaseNativeDispatch(slotId, dispatch);
-    log.warn('APS native renderer: failed to start publisher-origin frame');
-    return Promise.resolve(false);
-  }
+  const claimOverlayPositionLease = (): boolean => {
+    if (mode !== 'puc_overlay' || !hostPositionBound) return true;
+    try {
+      return isBindingCurrent() && hostPositions?.claim(artifact) === true;
+    } catch {
+      return false;
+    }
+  };
 
-  return rendering.then((accepted) => {
-    if (!releaseNativeDispatch(slotId, dispatch)) {
-      if (accepted) log.warn('APS native renderer: ignored stale completion');
+  const exactFrameBinding = (permanent: boolean): boolean => {
+    try {
+      return (
+        insertionCommitted &&
+        !disposed &&
+        exactAttemptIdentity() &&
+        Reflect.apply(nodeOwnerDocumentGetter, iframe, []) === ownerDocument &&
+        Reflect.apply(nodeParentNodeGetter, iframe, []) === container &&
+        Reflect.apply(nodeIsConnectedGetter, iframe, []) === true &&
+        Reflect.apply(iframeContentWindowGetter, iframe, []) === frameSource &&
+        Reflect.apply(elementGetAttributeIntrinsic, iframe, ['src']) === expectedFrameSource &&
+        Reflect.apply(iframeSourceGetter, iframe, []) === expectedFrameSource &&
+        Reflect.apply(elementGetAttributeIntrinsic, iframe, ['sandbox']) ===
+          (permanent ? APS_PERMANENT_SANDBOX : APS_RENDERER_SANDBOX)
+      );
+    } catch {
       return false;
     }
-    return accepted;
-  });
-}
+  };
 
-interface RenderApsPublisherNativeOptions {
-  slotId: string;
-  renderer: unknown;
-  source?: MessageEventSource | null;
-}
+  const eventField = (event: unknown, key: 'data' | 'origin' | 'source'): unknown => {
+    try {
+      return typeof event === 'object' && event !== null ? Reflect.get(event, key) : undefined;
+    } catch {
+      return undefined;
+    }
+  };
 
-function prepareApsRunnerDocument(
-  frameWindow: Window & typeof globalThis,
-  frameDocument: Document
-): void {
-  for (const element of [frameDocument.documentElement, frameDocument.body]) {
-    element.style.margin = '0px';
-    element.style.padding = '0px';
-  }
+  const exactGlobalMessage = (
+    kind: 'apsBootstrapReady' | 'apsContainerReady',
+    data: unknown,
+    expected: Readonly<Record<string, unknown>>
+  ): boolean => {
+    if (typeof data !== 'string' || data !== JSON.stringify(expected)) return false;
+    const parsed = Reflect.apply(parseMessageMethod, messaging, [kind, data]);
+    if (!parsed) return false;
+    const expectedKeys = Object.keys(expected);
+    for (let keyIndex = 0; keyIndex < expectedKeys.length; keyIndex += 1) {
+      const key = expectedKeys[keyIndex];
+      if (!key || parsed[key] !== expected[key]) return false;
+    }
+    return Object.keys(parsed).length === expectedKeys.length;
+  };
 
-  const normalizeFrame = (node: Node): void => {
+  const bootstrapExpectation = () =>
+    freeze({
+      nonce: bootstrapNonce,
+      attempt,
+      generation: attemptGeneration,
+      source: frameSource!,
+      port: bootstrapListenerResource,
+    });
+  const rendererExpectation = (port: MessagingPort) =>
+    freeze({
+      nonce: rendererNonce,
+      attempt,
+      generation: attemptGeneration,
+      source: frameSource!,
+      port,
+    });
+
+  const receiveDocument = (event: unknown): void => {
     if (
-      node instanceof frameWindow.HTMLIFrameElement &&
-      node.parentElement === frameDocument.body
+      disposed ||
+      !containerReady ||
+      !envelopeSent ||
+      !documentPort ||
+      !frameSource ||
+      !exactFrameBinding(true)
     ) {
-      node.style.display = 'block';
+      if (!disposed && containerReady && frameSource && !exactFrameBinding(true)) {
+        fail(documentAccepted ? 'runner_failed' : 'renderer_document_no_load');
+      }
+      return;
     }
-  };
-  Array.from(frameDocument.body.children).forEach(normalizeFrame);
-  new frameWindow.MutationObserver((records) => {
-    for (const record of records) record.addedNodes.forEach(normalizeFrame);
-  }).observe(frameDocument.body, { childList: true });
-}
-
-/** Render the exact selected response through APS's fixed runner in a friendly iframe. */
-function renderApsPublisherNative({
-  slotId,
-  renderer: input,
-  source,
-}: RenderApsPublisherNativeOptions): Promise<boolean> {
-  const renderer = validateApsRenderer(input);
-  const container = findApsContainer(slotId, source);
-  if (!renderer || !container) {
-    log.warn(
-      renderer ? 'APS native renderer: slot not found' : 'APS renderer: rejected descriptor'
-    );
-    return Promise.resolve(false);
-  }
-
-  // Keep an already committed creative visible until the replacement runner loads.
-  pendingFrameCancels.get(container)?.();
-  const iframe = document.createElement('iframe');
-  iframe.title = 'Ad content';
-  iframe.width = String(renderer.width);
-  iframe.height = String(renderer.height);
-  iframe.style.border = '0';
-  iframe.style.display = 'none';
-  activeFrames.set(container, iframe);
-
-  return new Promise<boolean>((resolve) => {
-    let settled = false;
-    let runner: HTMLScriptElement | undefined;
-
-    const cleanup = (): void => {
-      window.clearTimeout(timeoutId);
-      runner?.removeEventListener('load', commit);
-      runner?.removeEventListener('error', fail);
-    };
-    const finish = (accepted: boolean, warning?: string): void => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      if (pendingFrameCancels.get(container) === cancel) pendingFrameCancels.delete(container);
-
-      if (!accepted || activeFrames.get(container) !== iframe || !iframe.isConnected) {
-        if (activeFrames.get(container) === iframe) activeFrames.delete(container);
-        iframe.remove();
-        if (warning) log.warn(warning);
-        resolve(false);
+    const data = eventField(event, 'data');
+    const accepted = Reflect.apply(parseMessageMethod, messaging, ['apsDocumentAccepted', data]);
+    if (accepted?.['nonce'] === rendererNonce) {
+      if (documentAccepted || attemptState() !== 'waiting_for_document') return;
+      if (
+        Reflect.apply(consumeRendererMethod, rendererNonces, [
+          rendererExpectation(documentPort),
+        ]) === true &&
+        Reflect.apply(documentAcceptedMethod, attempt, []) === true
+      ) {
+        documentAccepted = true;
+      } else {
+        fail('renderer_document_no_load');
+      }
+      return;
+    }
+    const loaded = Reflect.apply(parseMessageMethod, messaging, ['apsRunnerLoaded', data]);
+    if (loaded?.['nonce'] === rendererNonce) return;
+    const completed = Reflect.apply(parseMessageMethod, messaging, ['apsRenderCompleted', data]);
+    if (completed?.['nonce'] === rendererNonce) {
+      if (!documentAccepted) return;
+      if (mode === 'puc_overlay') {
+        try {
+          if (!exactFrameBinding(true) || !isBindingCurrent()) {
+            fail('slot_unresolved');
+            return;
+          }
+          iframe.style.setProperty('visibility', 'visible');
+          if (iframe.style.getPropertyValue('visibility') !== 'visible') {
+            fail('internal_error');
+            return;
+          }
+        } catch {
+          fail('internal_error');
+          return;
+        }
+      }
+      let artifactAssociationCommitted = false;
+      if (mode === 'puc_overlay') {
+        try {
+          artifactAssociationCommitted = artifactBinding?.commit() === true;
+        } catch {
+          artifactAssociationCommitted = false;
+        }
+        if (!artifactAssociationCommitted) {
+          fail('slot_unresolved');
+          return;
+        }
+        if (!claimOverlayPositionLease()) {
+          artifactBinding?.rollback();
+          fail('slot_unresolved');
+          return;
+        }
+      }
+      const accepted = (() => {
+        try {
+          return Reflect.apply(acceptMethod, attempt, []) === true;
+        } catch {
+          return false;
+        }
+      })();
+      if (!accepted) {
+        if (artifactAssociationCommitted) artifactBinding?.rollback();
+        if (!disposed) fail('internal_error');
         return;
       }
-
-      for (const child of Array.from(container.children)) {
-        if (child !== iframe) child.remove();
+      if (artifactAssociationCommitted) artifactBinding?.finalize();
+      if (!disposed && exactFrameBinding(true) && mode === 'direct') {
+        commitContainer(insertionPredecessors);
       }
-      iframe.style.display = '';
-      resolve(true);
-    };
-    const cancel = (): void => finish(false);
-    function fail(): void {
-      finish(false, 'APS native renderer: creative runner failed');
-    }
-    function commit(): void {
-      finish(true);
+      return;
     }
+    const failed = Reflect.apply(parseMessageMethod, messaging, ['apsRenderFailed', data]);
+    if (failed?.['nonce'] !== rendererNonce) return;
+    const reason = mapRunnerFailure(failed['reason']);
+    if (reason) Reflect.apply(failMethod, attempt, [reason]);
+  };
 
-    const timeoutId = window.setTimeout(
-      () => finish(false, 'APS native renderer: creative runner timed out'),
-      APS_NATIVE_RENDERER_TIMEOUT_MS
-    );
-    pendingFrameCancels.set(container, cancel);
-    container.appendChild(iframe);
+  const receiveDocumentError = (): void => {
+    if (disposed || !containerReady) return;
+    fail(documentAccepted ? 'runner_failed' : 'renderer_document_no_load');
+  };
 
-    try {
-      const frameWindow = iframe.contentWindow as
-        | (Window &
-            typeof globalThis & {
-              _aps: Map<string, { queue: Event[]; store: Map<string, Map<unknown, unknown>> }>;
-            })
-        | null;
-      const frameDocument = iframe.contentDocument;
-      if (!frameWindow || !frameDocument) {
-        fail();
+  const receiveGlobal = (event: MessageEvent): void => {
+    if (
+      disposed ||
+      !frameSource ||
+      eventField(event, 'source') !== frameSource ||
+      eventField(event, 'origin') !== 'null'
+    ) {
+      return;
+    }
+    const data = eventField(event, 'data');
+
+    if (!bootstrapBound) {
+      const expectedReady = freeze({
+        message: 'TS APS Bootstrap Ready',
+        version: 1,
+        bootstrapNonce,
+      });
+      if (!exactGlobalMessage('apsBootstrapReady', data, expectedReady)) return;
+      const ports = Reflect.apply(extractPortsMethod, messaging, [event, 0]);
+      if (!ports) {
+        fail('renderer_document_no_load');
         return;
       }
-
-      frameDocument.open();
-      frameDocument.write(
-        '<!doctype html><html><head><meta charset="utf-8">' +
-          '<meta name="referrer" content="no-referrer"></head><body></body></html>'
-      );
-      frameDocument.close();
-      prepareApsRunnerDocument(frameWindow, frameDocument);
-      frameWindow._aps = new Map();
-      frameWindow._aps.set(renderer.accountId, {
-        queue: [
-          new frameWindow.CustomEvent('prebid/creative/render', {
-            detail: { aaxResponse: renderer.aaxResponse, seatBidId: renderer.bidId },
-          }),
-        ],
-        store: new Map([['listeners', new Map()]]),
+      if (!exactFrameBinding(false) || attemptState() !== 'waiting_for_document') {
+        fail('renderer_document_no_load');
+        return;
+      }
+      if (Reflect.apply(bindBootstrapMethod, bootstrapNonces, [bootstrapExpectation()]) !== true) {
+        fail('renderer_document_no_load');
+        return;
+      }
+      bootstrapBound = true;
+      try {
+        Reflect.apply(elementSetAttributeIntrinsic, iframe, ['sandbox', APS_PERMANENT_SANDBOX]);
+      } catch {
+        fail('renderer_document_no_load');
+        return;
+      }
+      if (!exactFrameBinding(true)) {
+        fail('renderer_document_no_load');
+        return;
+      }
+      const navigation = JSON.stringify({
+        message: 'TS APS Bootstrap Configure',
+        version: 2,
+        bootstrapNonce,
+        rendererNonce,
+        creativeOrigin,
+        tagType: renderer.tagType,
       });
+      if (
+        Reflect.apply(postWindowMethod, messaging, [frameSource, navigation, '*', []]) !== true ||
+        !exactFrameBinding(true)
+      ) {
+        fail('renderer_document_no_load');
+        return;
+      }
+      navigationPosted = true;
+      return;
+    }
 
-      runner = frameDocument.createElement('script');
-      runner.src = APS_PREBID_CREATIVE_RUNNER_URL;
-      runner.addEventListener('load', commit, { once: true });
-      runner.addEventListener('error', fail, { once: true });
-      frameDocument.head.appendChild(runner);
+    if (!navigationPosted || containerReady) return;
+    const expectedContainerReady = freeze({
+      message: 'TS APS Container Ready',
+      version: 1,
+      bootstrapNonce,
+      rendererNonce,
+    });
+    if (!exactGlobalMessage('apsContainerReady', data, expectedContainerReady)) return;
+    if (!exactFrameBinding(true) || attemptState() !== 'waiting_for_document') {
+      fail('renderer_document_no_load');
+      return;
+    }
+    const ports = Reflect.apply(extractPortsMethod, messaging, [event, 1]);
+    const port = ports?.[0];
+    if (!port) {
+      fail('renderer_document_no_load');
+      return;
+    }
+    documentPort = port;
+    if (
+      Reflect.apply(bindRendererMethod, rendererNonces, [rendererExpectation(port)]) !== true ||
+      Reflect.apply(consumeBootstrapMethod, bootstrapNonces, [bootstrapExpectation()]) !== true
+    ) {
+      try {
+        port.close();
+      } catch {
+        // A rejected transferred endpoint remains locally owned.
+      }
+      fail('renderer_document_no_load');
+      return;
+    }
+    containerReady = true;
+    bootstrapListenerResource.close();
+    try {
+      port.listen(receiveDocument, receiveDocumentError);
     } catch {
-      fail();
+      fail('renderer_document_no_load');
+      return;
     }
-  });
-}
+    const envelope = freeze({
+      version: 1 as const,
+      nonce: rendererNonce,
+      publisherOrigin,
+      renderer,
+    });
+    if (port.post(envelope, []) !== true || !exactFrameBinding(true)) {
+      fail('renderer_document_no_load');
+      return;
+    }
+    envelopeSent = true;
+  };
 
-function createNonce(): string | undefined {
-  if (typeof crypto === 'undefined' || typeof crypto.getRandomValues !== 'function')
-    return undefined;
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  let binary = '';
-  for (const byte of bytes) binary += String.fromCharCode(byte);
-  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
-}
+  function onFrameError(): void {
+    if (
+      disposed ||
+      (!insertionCommitted &&
+        !(appendInProgress && Reflect.apply(nodeParentNodeGetter!, iframe, []) === container))
+    ) {
+      return;
+    }
+    frameErrorObserved = true;
+    if (artifactOwnedByAttempt) {
+      fail(documentAccepted ? 'runner_failed' : 'renderer_document_no_load');
+    }
+  }
 
-/**
- * Return the absolute same-publisher URL used by direct and Universal Creative rendering.
- *
- * This intentionally inherits the publisher page scheme for same-origin deployments,
- * including local development. APS endpoints and third-party creative URLs remain
- * HTTPS-only.
- */
-export function apsRendererUrl(pageOrigin = window.location.origin): string | undefined {
   try {
-    const origin = new URL(pageOrigin);
-    const url = new URL(APS_RENDERER_PATH, origin);
+    const initialState = mode === 'direct' ? 'rendering_direct' : 'waiting_for_insertion';
+    releaseGlobalListener = Reflect.apply(installCaptureMethod, messaging, [receiveGlobal]);
+    if (!releaseGlobalListener) return startupFailure('renderer_document_no_load');
+    Reflect.apply(eventTargetAddListenerIntrinsic, iframe, ['error', onFrameError]);
+    Reflect.apply(elementSetAttributeIntrinsic, iframe, ['src', expectedFrameSource]);
     if (
-      url.origin !== origin.origin ||
-      url.pathname !== APS_RENDERER_PATH ||
-      url.search !== '' ||
-      url.hash !== ''
+      Reflect.apply(elementGetAttributeIntrinsic, iframe, ['src']) !== expectedFrameSource ||
+      Reflect.apply(iframeSourceGetter!, iframe, []) !== expectedFrameSource ||
+      attemptState() !== initialState ||
+      Reflect.apply(nodeIsConnectedGetter, container, []) !== true
     ) {
-      return undefined;
+      return startupFailure('renderer_document_no_load');
+    }
+    insertionPredecessors = mode === 'direct' ? snapshotContainerPredecessors() : [];
+    if (
+      disposed ||
+      attemptState() !== initialState ||
+      Reflect.apply(nodeIsConnectedGetter, container, []) !== true ||
+      !acquireOverlayPosition()
+    ) {
+      return startupFailure('renderer_document_no_load');
+    }
+    appendInProgress = true;
+    try {
+      Reflect.apply(nodeAppendChildIntrinsic, container, [iframe]);
+    } finally {
+      appendInProgress = false;
     }
-    return url.href;
+    if (Reflect.apply(nodeParentNodeGetter, iframe, []) !== container) {
+      return startupFailure('renderer_document_no_load');
+    }
+    insertionCommitted = true;
+    const insertedSource = Reflect.apply(iframeContentWindowGetter, iframe, []) as Window | null;
+    if (!insertedSource) {
+      return startupFailure('renderer_document_no_load');
+    }
+    frameSource = insertedSource;
+    if (!exactFrameBinding(false)) {
+      return startupFailure('renderer_document_no_load');
+    }
+    if (Reflect.apply(beginDocumentMethod, attempt, [artifact]) !== true) {
+      return startupFailure('internal_error');
+    }
+    artifactOwnedByAttempt = true;
+    if (mode === 'puc_overlay') {
+      try {
+        onArtifactTransferred();
+        baseArtifactTransferred = true;
+      } catch {
+        return fail('internal_error');
+      }
+    }
+    if (
+      disposed ||
+      frameErrorObserved ||
+      attemptState() !== 'waiting_for_document' ||
+      !exactFrameBinding(false)
+    ) {
+      return fail('renderer_document_no_load');
+    }
+    return true;
   } catch {
-    return undefined;
+    return startupFailure('renderer_document_no_load');
   }
 }
 
-export interface RenderApsCreativeOptions {
-  slotId: string;
-  renderer: unknown;
+/** Drive one direct APS attempt through the shared top-page mount service. */
+export function renderDirectApsAttempt(options: DirectApsAttemptOptions): boolean {
+  return mountApsTopPageAttempt({ ...options, mode: 'direct' });
 }
 
-/** Render APS through the static endpoint under an outer opaque-origin sandbox. */
-export function renderApsCreative({ slotId, renderer: input }: RenderApsCreativeOptions): boolean {
-  const renderer = validateApsRenderer(input);
-  const rendererUrl = apsRendererUrl();
-  const nonce = createNonce();
-  if (!renderer || !rendererUrl || !nonce) {
-    log.warn('APS renderer: rejected descriptor');
-    return false;
-  }
-
-  const container = document.getElementById(slotId);
-  if (!container) {
-    log.warn('APS renderer: slot not found');
-    return false;
-  }
-
-  const iframe = document.createElement('iframe');
-  iframe.title = 'Ad content';
-  iframe.width = String(renderer.width);
-  iframe.height = String(renderer.height);
-  iframe.style.border = '0';
-  iframe.style.display = 'none';
-  iframe.setAttribute('sandbox', APS_RENDERER_SANDBOX);
-  iframe.src = `${rendererUrl}#tsaps=${nonce}`;
-
-  // A replacement must cancel a pending frame, not merely detach it: its
-  // message listener and ready timeout would otherwise remain live until expiry.
-  pendingFrameCancels.get(container)?.();
-  activeFrames.set(container, iframe);
-
-  let settled = false;
-  const cleanup = (): void => {
-    window.removeEventListener('message', receive);
-    window.clearTimeout(timeoutId);
-  };
-  const cancel = (): void => {
-    if (settled) return;
-    settled = true;
-    cleanup();
-    if (pendingFrameCancels.get(container) === cancel) pendingFrameCancels.delete(container);
-    if (activeFrames.get(container) === iframe) activeFrames.delete(container);
-    iframe.remove();
-  };
-  const fail = (): void => {
-    if (settled) return;
-    cancel();
-    log.warn('APS renderer: frame load failed');
-  };
-  const commit = (): void => {
-    if (settled || activeFrames.get(container) !== iframe || !iframe.isConnected) return;
-    settled = true;
-    cleanup();
-    if (pendingFrameCancels.get(container) === cancel) pendingFrameCancels.delete(container);
-    for (const child of Array.from(container.children)) {
-      if (child !== iframe) child.remove();
-    }
-    iframe.style.display = '';
-  };
-  function receive(event: MessageEvent): void {
-    if (event.source !== iframe.contentWindow || !hasExactKeys(event.data, ['message', 'nonce'])) {
-      return;
-    }
-    if (event.data.nonce !== nonce) return;
-    if (event.data.message === RENDERER_READY_MESSAGE) commit();
-    else if (event.data.message === RENDERER_FAILED_MESSAGE) fail();
-  }
-
-  window.addEventListener('message', receive);
-  iframe.addEventListener(
-    'load',
-    () => {
-      if (settled || activeFrames.get(container) !== iframe || !iframe.isConnected) return;
-      try {
-        const target = iframe.contentWindow;
-        if (!target) {
-          fail();
-          return;
-        }
-        target.postMessage({ nonce, renderer }, '*');
-      } catch {
-        fail();
-      }
-    },
-    { once: true }
-  );
-  iframe.addEventListener('error', fail, { once: true });
-
-  const timeoutId = window.setTimeout(fail, RENDERER_READY_TIMEOUT_MS);
-  pendingFrameCancels.set(container, cancel);
-  container.appendChild(iframe);
-  return true;
+/** Drive one PUC APS attempt through a hidden top-page overlay. */
+export function renderPucApsAttempt(options: PucApsAttemptOptions): boolean {
+  return mountApsTopPageAttempt({ ...options, mode: 'puc_overlay' });
 }
-
-/**
- * Static source executed by Prebid Universal Creative's dynamic-renderer frame.
- * It reads only the validated descriptor and trusted absolute endpoint URL from data.
- */
-export const APS_UNIVERSAL_CREATIVE_RENDERER = String.raw`(function(){window.render=function(d,_h,w){return new Promise(function(resolve,reject){
-try{var r=d&&d.apsRenderer,u=d&&d.rendererUrl;if(!r||typeof u!=="string")throw new Error("invalid APS renderer data");
-var p=new URL(u);if((p.protocol!=="https:"&&p.protocol!=="http:")||p.username||p.password||p.pathname!=="${APS_RENDERER_PATH}"||p.search||p.hash)throw new Error("invalid APS renderer URL");
-var c=w.crypto;if(!c||typeof c.getRandomValues!=="function")throw new Error("APS renderer randomness unavailable");
-var b=new Uint8Array(16);c.getRandomValues(b);var s="";for(var i=0;i<b.length;i++)s+=String.fromCharCode(b[i]);
-var n=w.btoa(s).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/g,"");
-var f=w.document.createElement("iframe"),done=false,t;
-function clean(){w.removeEventListener("message",receive);if(t)w.clearTimeout(t);}
-function fail(){if(done)return;done=true;clean();f.remove();reject(new Error("APS renderer frame failed"));}
-function receive(e){var m=e.data;if(e.source!==f.contentWindow||!m||m.nonce!==n)return;
-if(m.message==="${RENDERER_READY_MESSAGE}"){done=true;clean();resolve();}
-else if(m.message==="${RENDERER_FAILED_MESSAGE}")fail();}
-f.width=String(r.width);f.height=String(r.height);f.style.border="0";
-f.setAttribute("sandbox","${APS_RENDERER_SANDBOX}");
-f.src=p.href+"#tsaps="+n;f.onload=function(){if(!done&&f.contentWindow)f.contentWindow.postMessage({nonce:n,renderer:r},"*");};
-f.onerror=fail;w.addEventListener("message",receive);t=w.setTimeout(fail,${RENDERER_READY_TIMEOUT_MS});w.document.body.appendChild(f);
-}catch(e){reject(e);}});};})();`;
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/click.ts b/crates/trusted-server-js/lib/src/integrations/creative/click.ts
index 38d6b982e..8e6306ee6 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/click.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/click.ts
@@ -5,18 +5,12 @@ import { delay, queueTask } from '../../shared/async';
 import { hasOpaqueOrigin, TRUSTED_BASE_URL } from '../../shared/origin';
 import { createMutationScheduler } from '../../shared/scheduler';
 
+import type { CreativeGuardHandle } from './startup';
+
 type AnchorLike = HTMLAnchorElement | HTMLAreaElement;
 type Canon = { base: string; params: Record<string, string> };
 type Diff = { add: Record<string, string>; del: string[] };
-
-// Rebuild URLs already written to an anchor's href by an earlier repair pass
-// (the opaque-origin GET fallback). They are not `/first-party/click` URLs, so
-// they cannot be canonicalized and deliberately never replace the canonical
-// `data-tsclick`. Without remembering them, a later click would canonicalize
-// the fallback against the original signed click, fail the base comparison, and
-// navigate the pre-mutation URL — silently dropping the mutation the fallback
-// exists to carry.
-const pendingRebuilds = new WeakMap<AnchorLike, string>();
+type PendingRebuilds = WeakMap<AnchorLike, string>;
 
 // Allow query/localStorage flag to crank logging when debugging creatives.
 function enableDebugFromEnv(): void {
@@ -96,7 +90,7 @@ function equalCanon(a: Canon, b: Canon): boolean {
   const bk = Object.keys(b.params).sort();
   if (ak.length !== bk.length) return false;
   for (let i = 0; i < ak.length; i++) {
-    const k = ak[i];
+    const k = ak[i]!;
     if (k !== bk[i] || a.params[k] !== b.params[k]) return false;
   }
   return true;
@@ -163,7 +157,13 @@ function buildProxyRebuildUrl(tsClickStr: string, diff: Diff): string {
 // does not answer, and always fails — so the guard skips it and recovers via
 // the GET navigation fallback, which the edge answers with a 302 chain (no
 // CORS applies to navigations).
-async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Promise<string> {
+async function rebuildClick(
+  a: AnchorLike,
+  tsClickStr: string,
+  diff: Diff,
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
+): Promise<string> {
   const addKeys = Object.keys(diff.add);
   const delKeys = diff.del;
   if (addKeys.length === 0 && delKeys.length === 0) {
@@ -173,6 +173,7 @@ async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Prom
   const fallback = buildProxyRebuildUrl(tsClickStr, diff);
 
   if (typeof fetch !== 'function' || hasOpaqueOrigin()) {
+    if (!isActive()) return tsClickStr;
     try {
       const el = a as Element;
       el.setAttribute('href', fallback);
@@ -193,6 +194,7 @@ async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Prom
       body: JSON.stringify(payload),
       credentials: 'same-origin',
     });
+    if (!isActive()) return tsClickStr;
     if (!resp.ok) {
       log.warn('tsjs-creative:click: proxy-rebuild HTTP error', resp.status);
       try {
@@ -204,9 +206,10 @@ async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Prom
       return fallback;
     }
     const data = (await resp.json()) as { href?: string; base?: string } | null;
+    if (!isActive()) return tsClickStr;
     const href = data && typeof data.href === 'string' ? data.href : null;
     if (href) {
-      persistRebuiltClick(a, href);
+      persistRebuiltClick(a, href, pendingRebuilds);
       log.info('tsjs-creative:click: rebuilt click', {
         added: addKeys,
         removed: delKeys,
@@ -214,9 +217,11 @@ async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Prom
       return href;
     }
   } catch (err) {
+    if (!isActive()) return tsClickStr;
     log.warn('tsjs-creative:click: proxy-rebuild request failed', err);
   }
 
+  if (!isActive()) return tsClickStr;
   try {
     const el = a as Element;
     el.setAttribute('href', fallback);
@@ -227,7 +232,12 @@ async function rebuildClick(a: AnchorLike, tsClickStr: string, diff: Diff): Prom
 }
 
 // Work out the href we should navigate to after accounting for creative rewrites.
-async function computeFinalUrl(a: AnchorLike, tsClickStr: string): Promise<string> {
+async function computeFinalUrl(
+  a: AnchorLike,
+  tsClickStr: string,
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
+): Promise<string> {
   const orig = canonFromFirstPartyClick(tsClickStr);
   if (!orig) return tsClickStr;
 
@@ -264,7 +274,7 @@ async function computeFinalUrl(a: AnchorLike, tsClickStr: string): Promise<strin
     del: diff.del,
   });
 
-  return rebuildClick(a, tsClickStr, diff);
+  return rebuildClick(a, tsClickStr, diff, pendingRebuilds, isActive);
 }
 
 // Resolve a click URL against the pinned trusted base and require an http(s)
@@ -275,32 +285,36 @@ async function computeFinalUrl(a: AnchorLike, tsClickStr: string): Promise<strin
 function resolveSafeNavigationUrl(url: string): string | null {
   try {
     const resolved = new URL(url, TRUSTED_BASE_URL);
-    if (resolved.protocol === 'http:' || resolved.protocol === 'https:') {
+    if (
+      (resolved.protocol === 'http:' || resolved.protocol === 'https:') &&
+      resolved.username === '' &&
+      resolved.password === ''
+    ) {
       return resolved.toString();
     }
-    log.warn('tsjs-creative:click: refusing non-http(s) navigation', resolved.protocol);
+    log.warn('tsjs-creative:click: refusing unsafe navigation URL', resolved.protocol);
   } catch (err) {
     log.debug('tsjs-creative:click: could not resolve navigation URL', err);
   }
   return null;
 }
 
-// Longest rebuild URL we will navigate to. Fastly Compute rejects request URLs
-// over 8192 bytes before the handler runs, and a signed click with many
-// tracking parameters can exceed that once nested inside another query string.
-// The margin covers percent-encoding growth and the request line's own overhead.
+// Fastly rejects request URLs over 8192 bytes before the handler runs. Leave
+// room for request-line overhead and percent-encoding expansion.
 const MAX_REBUILD_URL_LENGTH = 7000;
-
 const REBUILD_PATH = '/first-party/proxy-rebuild';
 
-// Navigate the rebuild as a form POST rather than a GET URL.
-//
-// The click is too long to nest in a query string, but a request body has no
-// such bound, and a form submission is a navigation — so it is not subject to
-// the CORS rules that rule out `fetch` from an opaque origin. The sandbox grants
-// `allow-forms`, and the endpoint answers a form-encoded POST with the same 302
-// it gives a GET. Only ever called from a click handler: submitting outside a
-// user gesture would navigate the frame on its own.
+function isRebuildNavigationUrl(url: string): boolean {
+  try {
+    return new URL(url, TRUSTED_BASE_URL).pathname === REBUILD_PATH;
+  } catch {
+    return false;
+  }
+}
+
+// An opaque-origin creative cannot use the JSON fetch path. For a recovery URL
+// too long to navigate as GET, submit the same fields in a form body; this stays
+// a user-initiated navigation and therefore does not require CORS.
 function submitRebuildNavigation(anchor: AnchorLike, rebuildUrl: string): boolean {
   try {
     if (typeof document === 'undefined' || typeof document.createElement !== 'function') {
@@ -311,6 +325,7 @@ function submitRebuildNavigation(anchor: AnchorLike, rebuildUrl: string): boolea
     form.method = 'POST';
     form.action = parsed.origin + parsed.pathname;
     form.target = anchor.getAttribute('target') || '_self';
+    form.rel = 'noopener noreferrer';
     form.style.display = 'none';
     for (const field of ['tsclick', 'add', 'del']) {
       const value = parsed.searchParams.get(field);
@@ -338,12 +353,10 @@ function submitRebuildNavigation(anchor: AnchorLike, rebuildUrl: string): boolea
 function navigate(a: AnchorLike, url: string, isMiddle: boolean): void {
   const resolved = resolveSafeNavigationUrl(url);
   if (!resolved) return;
-  // An over-long recovery URL would be rejected by the platform before the
-  // handler runs, losing the click entirely. Carry it in a form body instead.
   if (
     !isMiddle &&
     resolved.length > MAX_REBUILD_URL_LENGTH &&
-    resolved.includes(REBUILD_PATH) &&
+    isRebuildNavigationUrl(resolved) &&
     submitRebuildNavigation(a, resolved)
   ) {
     return;
@@ -361,10 +374,6 @@ function navigate(a: AnchorLike, url: string, isMiddle: boolean): void {
 // compare against — is only updated when the value is itself a signed
 // /first-party/click URL. Writing the GET proxy-rebuild fallback there would
 // make every later canonicalization fail and lose subsequent mutations.
-// Root-relative form of a first-party URL — the shape the server-side rewriter
-// emits and the shape `data-tsclick` must keep. `href` is absolutized so it
-// resolves inside the srcdoc frame, but the canonical attribute has to stay in
-// the server's format: it is echoed back as the rebuild payload's `tsclick`.
 function canonicalClickValue(resolved: string): string {
   try {
     const url = new URL(resolved, TRUSTED_BASE_URL);
@@ -374,7 +383,11 @@ function canonicalClickValue(resolved: string): string {
   }
 }
 
-function persistRebuiltClick(anchor: AnchorLike, finalUrl: string): void {
+function persistRebuiltClick(
+  anchor: AnchorLike,
+  finalUrl: string,
+  pendingRebuilds: PendingRebuilds
+): void {
   // Persist the validated, absolutized URL — never the raw input. Beyond
   // enforcing the http(s) allowlist, an absolute URL keeps the anchor's
   // default navigation working inside the srcdoc iframe, where a relative
@@ -403,11 +416,18 @@ function persistRebuiltClick(anchor: AnchorLike, finalUrl: string): void {
 }
 
 // Give the creative one microtask to finish mutations before we lock in the href.
-async function rebuildIfNeeded(anchor: AnchorLike, tsClickStr: string): Promise<string> {
-  let finalUrl = await computeFinalUrl(anchor, tsClickStr);
+async function rebuildIfNeeded(
+  anchor: AnchorLike,
+  tsClickStr: string,
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
+): Promise<string> {
+  let finalUrl = await computeFinalUrl(anchor, tsClickStr, pendingRebuilds, isActive);
+  if (!isActive()) return tsClickStr;
   if (finalUrl === tsClickStr) {
     await delay();
-    finalUrl = await computeFinalUrl(anchor, tsClickStr);
+    if (!isActive()) return tsClickStr;
+    finalUrl = await computeFinalUrl(anchor, tsClickStr, pendingRebuilds, isActive);
   }
   return finalUrl;
 }
@@ -416,17 +436,25 @@ async function rebuildIfNeeded(anchor: AnchorLike, tsClickStr: string): Promise<
 async function guardNavigation(
   anchor: AnchorLike,
   tsClickStr: string,
-  isMiddle: boolean
+  isMiddle: boolean,
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
 ): Promise<void> {
-  const finalUrl = await rebuildIfNeeded(anchor, tsClickStr);
+  const finalUrl = await rebuildIfNeeded(anchor, tsClickStr, pendingRebuilds, isActive);
+  if (!isActive()) return;
   if (finalUrl && finalUrl !== tsClickStr) {
-    persistRebuiltClick(anchor, finalUrl);
+    persistRebuiltClick(anchor, finalUrl, pendingRebuilds);
   }
   navigate(anchor, finalUrl || tsClickStr, isMiddle);
 }
 
 // Entry point for click/auxclick handlers: prevent default and queue guarded nav.
-function handleGuardedClick(ev: Event, isMiddle: boolean): void {
+function handleGuardedClick(
+  ev: Event,
+  isMiddle: boolean,
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
+): void {
   const anchor = closestAnchor(ev.target);
   if (!anchor) return;
 
@@ -436,7 +464,9 @@ function handleGuardedClick(ev: Event, isMiddle: boolean): void {
   ev.preventDefault();
 
   const runNavigation = () => {
-    void guardNavigation(anchor, tsClickStr, isMiddle).catch((err) => {
+    if (!isActive()) return;
+    void guardNavigation(anchor, tsClickStr, isMiddle, pendingRebuilds, isActive).catch((err) => {
+      if (!isActive()) return;
       log.warn('tsjs-creative:click: failed to compute final URL', err);
       navigate(anchor, tsClickStr, isMiddle);
     });
@@ -446,16 +476,23 @@ function handleGuardedClick(ev: Event, isMiddle: boolean): void {
 }
 
 // Observe href/data-tsclick mutations and repair anchors that third parties touch.
-function monitorAnchorMutations(): void {
-  if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') return;
+function monitorAnchorMutations(
+  pendingRebuilds: PendingRebuilds,
+  isActive: () => boolean
+): CreativeGuardHandle {
+  if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') {
+    return Object.freeze({ dispose: () => undefined, scan: () => undefined });
+  }
 
   const schedule = createMutationScheduler<AnchorLike>((anchor) => {
+    if (!isActive()) return;
     const tsClickStr = anchor.getAttribute('data-tsclick') || '';
     if (!tsClickStr) return;
-    void rebuildIfNeeded(anchor, tsClickStr)
+    void rebuildIfNeeded(anchor, tsClickStr, pendingRebuilds, isActive)
       .then((finalUrl) => {
+        if (!isActive()) return;
         if (finalUrl && finalUrl !== tsClickStr) {
-          persistRebuiltClick(anchor, finalUrl);
+          persistRebuiltClick(anchor, finalUrl, pendingRebuilds);
         }
       })
       .catch((err) => {
@@ -463,14 +500,14 @@ function monitorAnchorMutations(): void {
       });
   });
 
-  const scan = () => {
+  const scan = (): void => {
+    if (!isActive()) return;
     const anchors = document.querySelectorAll<AnchorLike>('a[data-tsclick], area[data-tsclick]');
     anchors.forEach((anchor) => schedule(anchor));
   };
 
-  scan();
-
   const observer = new MutationObserver((records) => {
+    if (!isActive()) return;
     for (const record of records) {
       if (record.type !== 'attributes') continue;
       const target = record.target;
@@ -485,27 +522,64 @@ function monitorAnchorMutations(): void {
     attributes: true,
     attributeFilter: ['href', 'data-tsclick'],
   });
+
+  let disposed = false;
+  return Object.freeze({
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      observer.disconnect();
+      schedule.dispose();
+    },
+    scan,
+  });
 }
 
 // Wire up capture-phase click handlers + mutation observers to protect clicks.
-export function installClickGuard(): void {
+export function installClickGuard(scanInitially = true): CreativeGuardHandle {
   if (log.getLevel && log.getLevel() === 'warn') {
     log.setLevel('info');
   }
   enableDebugFromEnv();
   log.info('tsjs-creative:click: installing click guard');
 
+  // Opaque rebuild recognition belongs to this exact guard generation. A new
+  // installation must never inherit a disposed generation's anchor state.
+  const pendingRebuilds: PendingRebuilds = new WeakMap();
+  let active = true;
+  const isActive = (): boolean => active;
   const onClick = (ev: Event) => {
-    handleGuardedClick(ev, false);
+    if (!active) return;
+    handleGuardedClick(ev, false, pendingRebuilds, isActive);
   };
 
   const onAuxClick = (ev: MouseEvent) => {
+    if (!active) return;
     if (ev.button !== 1) return;
-    handleGuardedClick(ev, true);
+    handleGuardedClick(ev, true, pendingRebuilds, isActive);
   };
 
   document.addEventListener('click', onClick, true);
   document.addEventListener('auxclick', onAuxClick as EventListener, true);
 
-  monitorAnchorMutations();
+  let mutations: CreativeGuardHandle | undefined;
+  const dispose = (): void => {
+    if (!active) return;
+    active = false;
+    document.removeEventListener('click', onClick, true);
+    document.removeEventListener('auxclick', onAuxClick as EventListener, true);
+    mutations?.dispose();
+  };
+  try {
+    mutations = monitorAnchorMutations(pendingRebuilds, isActive);
+    const handle = Object.freeze({
+      dispose,
+      scan: (): void => mutations?.scan(),
+    });
+    if (scanInitially) handle.scan();
+    return handle;
+  } catch (error) {
+    dispose();
+    throw error;
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/dynamic_src_guard.ts b/crates/trusted-server-js/lib/src/integrations/creative/dynamic_src_guard.ts
index 3cab3465c..79a59c2b7 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/dynamic_src_guard.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/dynamic_src_guard.ts
@@ -1,7 +1,8 @@
 import { log } from '../../core/log';
-import { createMutationScheduler } from '../../shared/scheduler';
+import { createMutationScheduler, type MutationScheduler } from '../../shared/scheduler';
 
 import type { ProxySignOutcome } from './proxy_sign';
+import type { CreativeGuardHandle } from './startup';
 
 type ElementWithSrc = Element & { src: string };
 
@@ -16,6 +17,11 @@ type FactoryFunction<E extends ElementWithSrc> = {
   new (...args: unknown[]): E;
 } & ((...args: unknown[]) => E);
 
+interface InstancePatch {
+  readonly installed: PropertyDescriptor;
+  readonly original: PropertyDescriptor | undefined;
+}
+
 export interface DynamicSrcProxyOptions<E extends ElementWithSrc> {
   elementConstructor: ElementCtor<E> | undefined;
   selector: string;
@@ -28,309 +34,418 @@ export interface DynamicSrcProxyOptions<E extends ElementWithSrc> {
   signProxy(raw: string, element: E): Promise<ProxySignOutcome>;
 }
 
+function sameDescriptor(
+  left: PropertyDescriptor | undefined,
+  right: PropertyDescriptor | undefined
+): boolean {
+  if (!left || !right) return left === right;
+  return (
+    left.configurable === right.configurable &&
+    left.enumerable === right.enumerable &&
+    left.get === right.get &&
+    left.set === right.set &&
+    left.value === right.value &&
+    left.writable === right.writable
+  );
+}
+
+function inertHandle(): CreativeGuardHandle {
+  return Object.freeze({ dispose: () => undefined, scan: () => undefined });
+}
+
 export function createDynamicSrcProxy<E extends ElementWithSrc>(
   options: DynamicSrcProxyOptions<E>
-): () => void {
+): (scanInitially?: boolean) => CreativeGuardHandle {
   const attr = (options.attributeName ?? 'src').toLowerCase();
   const tagName = options.tagName.toLowerCase();
+  let installedHandle: CreativeGuardHandle | undefined;
 
-  const assignments = new WeakMap<E, { raw: string; requestId: number }>();
-  const lastProcessed = new WeakMap<E, string>();
-  let sequence = 0;
-  let proxyInstalled = false;
-  let observerInstalled = false;
-  let nativeSet: ((this: E, value: string) => void) | undefined;
-  let nativeGet: ((this: E) => string) | undefined;
-  let nativeSetAttribute: (this: E, name: string, value: string) => void = () => undefined;
-  let nativeSetAttributeNS:
-    | ((this: E, namespace: string | null, name: string, value: string) => void)
-    | undefined;
-  const wrappedInstances = new WeakSet<E>();
-  let createElementPatched = false;
-  let factoryPatched = false;
-  const nativeCreateElement =
-    typeof document === 'undefined' ? undefined : document.createElement.bind(document);
+  return function install(scanInitially = true): CreativeGuardHandle {
+    if (installedHandle) return installedHandle;
+    const ctor = options.elementConstructor;
+    if (typeof ctor !== 'function') {
+      installedHandle = inertHandle();
+      return installedHandle;
+    }
 
-  function apply(element: E, value: string): void {
-    try {
-      if (typeof nativeSet === 'function') {
-        nativeSet.call(element, value);
-      } else {
-        nativeSetAttribute.call(element, attr, value);
-      }
-    } catch (err) {
-      log.debug(`${options.logPrefix}: failed to apply ${options.resourceName} ${attr}`, err);
+    const sourceDescriptor = Object.getOwnPropertyDescriptor(ctor.prototype, attr);
+    if (!sourceDescriptor || typeof sourceDescriptor.set !== 'function') {
+      log.debug(`${options.logPrefix}: ${ctor.name} proxy install skipped (no setter)`);
+      installedHandle = inertHandle();
+      return installedHandle;
     }
-  }
 
-  function proxyAssignment(element: E, rawInput: string): void {
-    const raw = String(rawInput || '');
-    const last = lastProcessed.get(element);
-    if (last === raw) return;
-    lastProcessed.set(element, raw);
+    const assignments = new WeakMap<E, { raw: string; requestId: number }>();
+    const lastProcessed = new WeakMap<E, string>();
+    const instancePatches = new Map<E, InstancePatch>();
+    const nativeSet = sourceDescriptor.set as (this: E, value: string) => void;
+    const nativeGet =
+      typeof sourceDescriptor.get === 'function'
+        ? (sourceDescriptor.get as (this: E) => string)
+        : undefined;
+    const nativeSetAttribute = ctor.prototype.setAttribute as (
+      this: E,
+      name: string,
+      value: string
+    ) => void;
+    const nativeSetAttributeNS =
+      typeof ctor.prototype.setAttributeNS === 'function'
+        ? (ctor.prototype.setAttributeNS as (
+            this: E,
+            namespace: string | null,
+            name: string,
+            value: string
+          ) => void)
+        : undefined;
+    const originalSetAttribute = Object.getOwnPropertyDescriptor(ctor.prototype, 'setAttribute');
+    const originalSetAttributeNS = Object.getOwnPropertyDescriptor(
+      ctor.prototype,
+      'setAttributeNS'
+    );
+    const targetDocument = typeof document === 'undefined' ? undefined : document;
+    const nativeCreateElement = targetDocument?.createElement;
+    const originalCreateElement = targetDocument
+      ? Object.getOwnPropertyDescriptor(targetDocument, 'createElement')
+      : undefined;
+    let active = true;
+    let sequence = 0;
+    let observer: MutationObserver | undefined;
+    let scheduler: MutationScheduler<E> | undefined;
+    let installedSource: PropertyDescriptor | undefined;
+    let installedSetAttribute: PropertyDescriptor | undefined;
+    let installedSetAttributeNS: PropertyDescriptor | undefined;
+    let installedCreateElement: PropertyDescriptor | undefined;
+    let factoryTarget: Record<string, unknown> | undefined;
+    let factoryOriginal: PropertyDescriptor | undefined;
+    let installedFactory: PropertyDescriptor | undefined;
+
+    const restore = (
+      target: object,
+      key: PropertyKey,
+      owned: PropertyDescriptor | undefined,
+      original: PropertyDescriptor | undefined
+    ): void => {
+      try {
+        if (!sameDescriptor(Object.getOwnPropertyDescriptor(target, key), owned)) return;
+        if (original) Object.defineProperty(target, key, original);
+        else Reflect.deleteProperty(target, key);
+      } catch (error) {
+        log.debug(`${options.logPrefix}: failed to restore ${String(key)}`, error);
+      }
+    };
+
+    const apply = (element: E, value: string): void => {
+      try {
+        nativeSet.call(element, value);
+      } catch (error) {
+        try {
+          nativeSetAttribute.call(element, attr, value);
+        } catch (fallbackError) {
+          log.debug(
+            `${options.logPrefix}: failed to apply ${options.resourceName} ${attr}`,
+            error,
+            fallbackError
+          );
+        }
+      }
+    };
 
-    const requestId = ++sequence;
-    assignments.set(element, { raw, requestId });
+    const proxyAssignment = (element: E, rawInput: string): void => {
+      if (!active) {
+        apply(element, String(rawInput ?? ''));
+        return;
+      }
+      const raw = String(rawInput || '');
+      const last = lastProcessed.get(element);
+      if (last === raw) return;
+      lastProcessed.set(element, raw);
 
-    const proxyable = options.shouldProxy(raw, element);
-    if (!proxyable || typeof fetch !== 'function') {
-      log.info(`${options.logPrefix}: skipping proxy for ${attr}`, {
-        reason: proxyable ? 'no-fetch' : 'non-proxyable',
-        raw,
-      });
-      assignments.delete(element);
-      apply(element, raw);
-      return;
-    }
+      const requestId = ++sequence;
+      assignments.set(element, { raw, requestId });
 
-    log.info(`${options.logPrefix}: signing ${options.resourceName} ${attr}`, { raw });
-    void options
-      .signProxy(raw, element)
-      .then((result) => {
-        const current = assignments.get(element);
-        if (!current || current.requestId !== requestId) return;
+      let proxyable = false;
+      try {
+        proxyable = options.shouldProxy(raw, element);
+      } catch (error) {
+        log.warn(`${options.logPrefix}: ${options.resourceName} policy failed`, error);
+      }
+      if (!proxyable || typeof fetch !== 'function') {
+        log.info(`${options.logPrefix}: skipping proxy for ${attr}`, {
+          reason: proxyable ? 'no-fetch' : 'non-proxyable',
+          raw,
+        });
         assignments.delete(element);
-        if (result.outcome === 'blocked') {
-          log.warn(`${options.logPrefix}: blocked dynamic ${options.resourceName} ${attr}`, {
-            raw,
-          });
-          return;
-        }
+        apply(element, raw);
+        return;
+      }
 
-        const finalUrl = result.outcome === 'signed' ? result.href : raw;
-        if (result.outcome === 'signed') {
-          log.info(`${options.logPrefix}: proxied dynamic ${options.resourceName}`, {
-            base: raw,
-            finalUrl,
-          });
-        }
-        lastProcessed.set(element, finalUrl);
-        apply(element, finalUrl);
-      })
-      .catch((err) => {
-        const current = assignments.get(element);
-        if (!current || current.requestId !== requestId) return;
+      log.info(`${options.logPrefix}: signing ${options.resourceName} ${attr}`, { raw });
+      let signing: Promise<ProxySignOutcome>;
+      try {
+        signing = options.signProxy(raw, element);
+      } catch (error) {
         assignments.delete(element);
         log.warn(
           `${options.logPrefix}: failed to proxy dynamic ${options.resourceName}; using raw ${attr}`,
-          err
+          error
         );
-        lastProcessed.set(element, raw);
         apply(element, raw);
-      });
-  }
-
-  function monitorMutations(ctor: ElementCtor<E>): void {
-    if (observerInstalled) return;
-    if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') return;
-
-    const schedule = createMutationScheduler<E>((element) => {
-      ensureInstancePatched(element);
-      const fromAttr = element.getAttribute(attr) || '';
-      const liveValue = (element as unknown as { [key: string]: string | undefined })[attr] || '';
-      const raw = fromAttr || liveValue;
-      if (!raw) return;
-      log.info(`${options.logPrefix}: observed ${attr} set`, { raw });
-      proxyAssignment(element, raw);
-    });
-
-    const scan = () => {
-      document.querySelectorAll(options.selector).forEach((el) => {
-        schedule(el as E);
-      });
-    };
-
-    log.info(`${options.logPrefix}: initial ${options.resourceName} scan`);
-    scan();
-
-    const observer = new MutationObserver((records) => {
-      for (const record of records) {
-        if (record.type === 'attributes') {
-          const target = record.target;
-          if (target instanceof ctor && record.attributeName === attr) {
-            schedule(target as E);
+        return;
+      }
+      void signing
+        .then((result) => {
+          if (!active) return;
+          const current = assignments.get(element);
+          if (!current || current.requestId !== requestId) return;
+          assignments.delete(element);
+          if (result.outcome === 'blocked') {
+            log.warn(`${options.logPrefix}: blocked dynamic ${options.resourceName} ${attr}`, {
+              raw,
+            });
+            return;
           }
-          continue;
-        }
+          const finalUrl = result.outcome === 'signed' ? result.href : raw;
+          if (result.outcome === 'signed') {
+            log.info(`${options.logPrefix}: proxied dynamic ${options.resourceName}`, {
+              base: raw,
+              finalUrl,
+            });
+          }
+          lastProcessed.set(element, finalUrl);
+          apply(element, finalUrl);
+        })
+        .catch((error) => {
+          if (!active) return;
+          const current = assignments.get(element);
+          if (!current || current.requestId !== requestId) return;
+          assignments.delete(element);
+          log.warn(
+            `${options.logPrefix}: failed to proxy dynamic ${options.resourceName}; using raw ${attr}`,
+            error
+          );
+          lastProcessed.set(element, raw);
+          apply(element, raw);
+        });
+    };
 
-        if (record.type === 'childList') {
-          record.addedNodes.forEach((node) => {
-            if (node instanceof ctor) {
-              schedule(node as E);
+    const ensureInstancePatched = (element: E | null | undefined): void => {
+      if (!active || !element || instancePatches.has(element)) return;
+      const original = Object.getOwnPropertyDescriptor(element, attr);
+      try {
+        Object.defineProperty(element, attr, {
+          configurable: true,
+          enumerable: true,
+          get(this: E) {
+            const pending = assignments.get(this);
+            if (pending) return pending.raw;
+            return nativeGet ? nativeGet.call(this) : '';
+          },
+          set(this: E, value: string) {
+            if (!active) {
+              apply(this, String(value ?? ''));
               return;
             }
-            if (!(node instanceof Element)) return;
-            node.querySelectorAll(options.selector).forEach((el) => schedule(el as E));
-          });
-        }
+            log.info(`${options.logPrefix}: ${tagName} instance ${attr} set`, value);
+            proxyAssignment(this, String(value ?? ''));
+          },
+        });
+        const installed = Object.getOwnPropertyDescriptor(element, attr);
+        if (installed) instancePatches.set(element, { installed, original });
+      } catch (error) {
+        log.debug(`${options.logPrefix}: failed to patch ${tagName} instance ${attr}`, error);
       }
-    });
-
-    observer.observe(document, {
-      subtree: true,
-      childList: true,
-      attributes: true,
-      attributeFilter: [attr],
-    });
-
-    observerInstalled = true;
-    log.info(`${options.logPrefix}: mutation observer active`);
-  }
+    };
 
-  function ensureInstancePatched(element: E | null | undefined): void {
-    if (!element || wrappedInstances.has(element)) return;
-    wrappedInstances.add(element);
-    try {
-      Object.defineProperty(element, attr, {
-        configurable: true,
-        enumerable: true,
-        get(this: E) {
-          const pending = assignments.get(this);
-          if (pending) return pending.raw;
-          return nativeGet ? nativeGet.call(this) : '';
-        },
-        set(this: E, value: string) {
-          log.info(`${options.logPrefix}: ${tagName} instance ${attr} set`, value);
-          proxyAssignment(this, String(value ?? ''));
-        },
+    const scan = (): void => {
+      if (!active || !targetDocument || !scheduler) return;
+      targetDocument.querySelectorAll(options.selector).forEach((element) => {
+        scheduler?.(element as E);
       });
-    } catch (err) {
-      log.debug(`${options.logPrefix}: failed to patch ${tagName} instance ${attr}`, err);
-    }
-  }
+    };
 
-  function patchDocumentCreateElement(): void {
-    if (createElementPatched || typeof document === 'undefined' || !nativeCreateElement) return;
-    createElementPatched = true;
-    document.createElement = function patchedCreateElement(
-      this: Document,
-      name: string,
-      options?: ElementCreationOptions
-    ): HTMLElement {
-      const el = nativeCreateElement(name, options);
-      if (typeof name === 'string' && name.toLowerCase() === tagName) {
-        ensureInstancePatched(el as unknown as E);
+    const dispose = (): void => {
+      if (!active) return;
+      active = false;
+      observer?.disconnect();
+      scheduler?.dispose();
+      for (const [element, patch] of instancePatches) {
+        restore(element, attr, patch.installed, patch.original);
       }
-      return el;
-    } as typeof document.createElement;
-  }
-
-  function patchFactory(): void {
-    if (!options.factoryName || factoryPatched) return;
-    const globalObj = globalThis as Record<string, unknown>;
-    const factory = globalObj[options.factoryName];
-    if (typeof factory !== 'function') return;
-    const factoryFn = factory as FactoryFunction<E>;
-
-    const WrappedFactory = function (this: unknown, ...args: unknown[]) {
-      const instance = Reflect.construct(factoryFn, args, new.target ?? WrappedFactory) as E;
-      ensureInstancePatched(instance);
-      return instance;
+      instancePatches.clear();
+      if (targetDocument) {
+        restore(targetDocument, 'createElement', installedCreateElement, originalCreateElement);
+      }
+      if (factoryTarget && options.factoryName) {
+        restore(factoryTarget, options.factoryName, installedFactory, factoryOriginal);
+      }
+      restore(ctor.prototype, 'setAttributeNS', installedSetAttributeNS, originalSetAttributeNS);
+      restore(ctor.prototype, 'setAttribute', installedSetAttribute, originalSetAttribute);
+      restore(ctor.prototype, attr, installedSource, sourceDescriptor);
+      if (installedHandle === handle) installedHandle = undefined;
     };
 
-    Object.defineProperty(WrappedFactory, 'length', {
-      value: factoryFn.length,
-      configurable: true,
-    });
-    Object.defineProperty(WrappedFactory, 'name', {
-      value: options.factoryName,
-      configurable: true,
-    });
-    WrappedFactory.prototype = factoryFn.prototype;
-    Object.setPrototypeOf(WrappedFactory, factoryFn);
-
-    globalObj[options.factoryName] = WrappedFactory as unknown;
-    factoryPatched = true;
-  }
-
-  return function install(): void {
-    if (proxyInstalled) return;
-    const ctor = options.elementConstructor;
-    if (typeof ctor !== 'function') return;
-
-    log.info(`${options.logPrefix}: installing dynamic ${options.resourceName} proxy hooks`);
-
-    const descriptor = Object.getOwnPropertyDescriptor(ctor.prototype, attr);
-    if (!descriptor || typeof descriptor.set !== 'function') {
-      log.debug(`${options.logPrefix}: ${ctor.name} proxy install skipped (no setter)`);
-      return;
-    }
-
-    nativeSet = descriptor.set as typeof nativeSet;
-    nativeGet =
-      typeof descriptor.get === 'function' ? (descriptor.get as typeof nativeGet) : undefined;
-    nativeSetAttribute = ctor.prototype.setAttribute as typeof nativeSetAttribute;
-    nativeSetAttributeNS =
-      typeof ctor.prototype.setAttributeNS === 'function'
-        ? (ctor.prototype.setAttributeNS as typeof nativeSetAttributeNS)
-        : undefined;
+    const handle = Object.freeze({ dispose, scan });
 
-    let prototypePatched = false;
-    if (descriptor.configurable !== false) {
-      try {
+    try {
+      log.info(`${options.logPrefix}: installing dynamic ${options.resourceName} proxy hooks`);
+      let prototypePatched = false;
+      if (sourceDescriptor.configurable !== false) {
         Object.defineProperty(ctor.prototype, attr, {
           configurable: true,
-          enumerable: descriptor.enumerable ?? true,
+          enumerable: sourceDescriptor.enumerable ?? true,
           get(this: E) {
-            log.info(`${options.logPrefix}: ${ctor.name} ${attr} get`);
             const pending = assignments.get(this);
             if (pending) return pending.raw;
             return nativeGet ? nativeGet.call(this) : '';
           },
           set(this: E, value: string) {
+            if (!active) {
+              apply(this, String(value ?? ''));
+              return;
+            }
             log.info(`${options.logPrefix}: ${ctor.name} ${attr} set`, value);
             proxyAssignment(this, String(value ?? ''));
           },
         });
+        installedSource = Object.getOwnPropertyDescriptor(ctor.prototype, attr);
         prototypePatched = true;
-      } catch (err) {
-        log.debug(`${options.logPrefix}: failed to patch prototype ${attr}`, err);
-      }
-    } else {
-      log.debug(`${options.logPrefix}: prototype ${attr} not configurable; using fallback`);
-    }
-
-    ctor.prototype.setAttribute = function patchedSetAttribute(
-      this: E,
-      name: string,
-      value: string
-    ) {
-      log.debug(`${options.logPrefix}: ${ctor.name} setAttribute`, { name, value });
-      if (typeof name === 'string' && name.toLowerCase() === attr) {
-        proxyAssignment(this, String(value ?? ''));
-        return;
+      } else {
+        log.debug(`${options.logPrefix}: prototype ${attr} not configurable; using fallback`);
       }
-      nativeSetAttribute.call(this, name, value);
-    };
 
-    if (nativeSetAttributeNS) {
-      ctor.prototype.setAttributeNS = function patchedSetAttributeNS(
+      ctor.prototype.setAttribute = function patchedSetAttribute(
         this: E,
-        namespace: string | null,
         name: string,
         value: string
       ): void {
-        log.debug(`${options.logPrefix}: ${ctor.name} setAttributeNS`, { namespace, name, value });
-        if (typeof name === 'string' && name.toLowerCase() === attr) {
-          proxyAssignment(this, String(value ?? ''));
+        if (!active || typeof name !== 'string' || name.toLowerCase() !== attr) {
+          nativeSetAttribute.call(this, name, value);
           return;
         }
-        nativeSetAttributeNS!.call(this, namespace, name, value);
+        log.debug(`${options.logPrefix}: ${ctor.name} setAttribute`, { name, value });
+        proxyAssignment(this, String(value ?? ''));
       };
-    }
+      installedSetAttribute = Object.getOwnPropertyDescriptor(ctor.prototype, 'setAttribute');
+
+      if (nativeSetAttributeNS) {
+        ctor.prototype.setAttributeNS = function patchedSetAttributeNS(
+          this: E,
+          namespace: string | null,
+          name: string,
+          value: string
+        ): void {
+          if (!active || typeof name !== 'string' || name.toLowerCase() !== attr) {
+            nativeSetAttributeNS.call(this, namespace, name, value);
+            return;
+          }
+          log.debug(`${options.logPrefix}: ${ctor.name} setAttributeNS`, {
+            namespace,
+            name,
+            value,
+          });
+          proxyAssignment(this, String(value ?? ''));
+        };
+        installedSetAttributeNS = Object.getOwnPropertyDescriptor(ctor.prototype, 'setAttributeNS');
+      }
 
-    proxyInstalled = true;
-    log.info(`${options.logPrefix}: dynamic ${options.resourceName} proxy installed`);
+      if (!prototypePatched) {
+        if (targetDocument && nativeCreateElement) {
+          targetDocument
+            .querySelectorAll(options.selector)
+            .forEach((element) => ensureInstancePatched(element as E));
+          targetDocument.createElement = function patchedCreateElement(
+            this: Document,
+            name: string,
+            creationOptions?: ElementCreationOptions
+          ): HTMLElement {
+            const element = nativeCreateElement.call(this, name, creationOptions);
+            if (active && typeof name === 'string' && name.toLowerCase() === tagName) {
+              ensureInstancePatched(element as unknown as E);
+            }
+            return element;
+          } as typeof targetDocument.createElement;
+          installedCreateElement = Object.getOwnPropertyDescriptor(targetDocument, 'createElement');
+        }
 
-    if (!prototypePatched) {
-      log.info(`${options.logPrefix}: using instance-level proxy fallback`);
-      if (typeof document !== 'undefined') {
-        document.querySelectorAll(options.selector).forEach((el) => ensureInstancePatched(el as E));
+        if (options.factoryName) {
+          const globalObject = globalThis as Record<string, unknown>;
+          const factory = globalObject[options.factoryName];
+          if (typeof factory === 'function') {
+            const factoryFunction = factory as FactoryFunction<E>;
+            factoryTarget = globalObject;
+            factoryOriginal = Object.getOwnPropertyDescriptor(globalObject, options.factoryName);
+            const WrappedFactory = function (this: unknown, ...args: unknown[]) {
+              const instance = Reflect.construct(
+                factoryFunction,
+                args,
+                new.target ?? WrappedFactory
+              ) as E;
+              if (active) ensureInstancePatched(instance);
+              return instance;
+            };
+            Object.defineProperty(WrappedFactory, 'length', {
+              value: factoryFunction.length,
+              configurable: true,
+            });
+            Object.defineProperty(WrappedFactory, 'name', {
+              value: options.factoryName,
+              configurable: true,
+            });
+            WrappedFactory.prototype = factoryFunction.prototype;
+            Object.setPrototypeOf(WrappedFactory, factoryFunction);
+            globalObject[options.factoryName] = WrappedFactory;
+            installedFactory = Object.getOwnPropertyDescriptor(globalObject, options.factoryName);
+          }
+        }
       }
-      patchDocumentCreateElement();
-      patchFactory();
-    }
 
-    monitorMutations(ctor);
+      if (targetDocument && typeof MutationObserver !== 'undefined') {
+        scheduler = createMutationScheduler<E>((element) => {
+          if (!active) return;
+          ensureInstancePatched(element);
+          const fromAttribute = element.getAttribute(attr) || '';
+          const liveValue =
+            (element as unknown as { [key: string]: string | undefined })[attr] || '';
+          const raw = fromAttribute || liveValue;
+          if (!raw) return;
+          log.info(`${options.logPrefix}: observed ${attr} set`, { raw });
+          proxyAssignment(element, raw);
+        });
+        observer = new MutationObserver((records) => {
+          if (!active) return;
+          for (const record of records) {
+            if (record.type === 'attributes') {
+              const target = record.target;
+              if (target instanceof ctor && record.attributeName === attr) scheduler?.(target as E);
+              continue;
+            }
+            if (record.type !== 'childList') continue;
+            record.addedNodes.forEach((node) => {
+              if (node instanceof ctor) {
+                scheduler?.(node as E);
+                return;
+              }
+              if (!(node instanceof Element)) return;
+              node
+                .querySelectorAll(options.selector)
+                .forEach((element) => scheduler?.(element as E));
+            });
+          }
+        });
+        observer.observe(targetDocument, {
+          subtree: true,
+          childList: true,
+          attributes: true,
+          attributeFilter: [attr],
+        });
+      }
+
+      installedHandle = handle;
+      if (scanInitially) scan();
+      return handle;
+    } catch (error) {
+      dispose();
+      throw error;
+    }
   };
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/iframe.ts b/crates/trusted-server-js/lib/src/integrations/creative/iframe.ts
index 24c003373..a23d1b19f 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/iframe.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/iframe.ts
@@ -1,6 +1,7 @@
 // Dynamic iframe proxy guard: routes iframe src assignments through the first-party proxy.
 import { createDynamicSrcProxy } from './dynamic_src_guard';
 import { shouldProxyExternalUrl, signProxyUrl } from './proxy_sign';
+import type { CreativeGuardHandle } from './startup';
 
 const installProxy = createDynamicSrcProxy<HTMLIFrameElement>({
   elementConstructor: typeof HTMLIFrameElement === 'undefined' ? undefined : HTMLIFrameElement,
@@ -12,6 +13,6 @@ const installProxy = createDynamicSrcProxy<HTMLIFrameElement>({
   signProxy: (raw) => signProxyUrl(raw),
 });
 
-export function installDynamicIframeProxy(): void {
-  installProxy();
+export function installDynamicIframeProxy(scanInitially = true): CreativeGuardHandle {
+  return installProxy(scanInitially);
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/image.ts b/crates/trusted-server-js/lib/src/integrations/creative/image.ts
index dc608fc32..d64a62c95 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/image.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/image.ts
@@ -1,6 +1,7 @@
 // Dynamic image proxy guard: intercepts <img> sources and routes them via first-party proxy.
 import { createDynamicSrcProxy } from './dynamic_src_guard';
 import { shouldProxyExternalUrl, signProxyUrl } from './proxy_sign';
+import type { CreativeGuardHandle } from './startup';
 
 // NOTE: This module intentionally logs at info level in the hot paths so that when
 // creatives crash before reaching a console, we still have breadcrumbs showing how
@@ -20,6 +21,6 @@ const installProxy = createDynamicSrcProxy<HTMLImageElement>({
 });
 
 // Prepare global hooks so every img.src assignment flows through Trusted Server first.
-export function installDynamicImageProxy(): void {
-  installProxy();
+export function installDynamicImageProxy(scanInitially = true): CreativeGuardHandle {
+  return installProxy(scanInitially);
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/index.ts b/crates/trusted-server-js/lib/src/integrations/creative/index.ts
index 395553562..610fa053c 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/index.ts
@@ -1,97 +1,13 @@
-// Entry point for the creative runtime: wires up click + image + iframe guards globally.
-import { log } from '../../core/log';
-import type { TsCreativeConfig, CreativeWindow, TsCreativeApi } from '../../shared/globals';
-import { creativeGlobal, resolveWindow } from '../../shared/globals';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installClickGuard } from './click';
-import { installDynamicImageProxy } from './image';
-import { installDynamicIframeProxy } from './iframe';
+import { createCreativeIntegrationRegistration } from './module';
 
-export { installDynamicImageProxy } from './image';
-export { installDynamicIframeProxy } from './iframe';
-
-const DEFAULT_CONFIG: Required<TsCreativeConfig> = {
-  clickGuard: true,
-  renderGuard: false,
-};
-
-let currentConfig: Required<TsCreativeConfig> = { ...DEFAULT_CONFIG };
-let guardsInstallTriggered = false;
-let clickGuardInstalled = false;
-let renderGuardInstalled = false;
-
-function applyConfig(): void {
-  if (currentConfig.clickGuard && !clickGuardInstalled) {
-    installClickGuard();
-    clickGuardInstalled = true;
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createCreativeIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
   }
-
-  if (currentConfig.renderGuard && !renderGuardInstalled) {
-    installDynamicImageProxy();
-    installDynamicIframeProxy();
-    renderGuardInstalled = true;
-  }
-}
-
-function mergeConfig(cfg: TsCreativeConfig): void {
-  currentConfig = {
-    clickGuard: cfg.clickGuard ?? currentConfig.clickGuard,
-    renderGuard: cfg.renderGuard ?? currentConfig.renderGuard,
-  };
-  creativeGlobal.tsCreativeConfig = { ...currentConfig };
 }
-
-export function setCreativeConfig(cfg: TsCreativeConfig): void {
-  mergeConfig(cfg);
-  if (guardsInstallTriggered) {
-    applyConfig();
-  }
-}
-
-export function getCreativeConfig(): TsCreativeConfig {
-  return { ...currentConfig };
-}
-
-// Public entry for creative runtime: install click + image protections once per page.
-export function installGuards(): void {
-  if (!guardsInstallTriggered) {
-    guardsInstallTriggered = true;
-  }
-  applyConfig();
-}
-
-export const tsCreative: TsCreativeApi = {
-  installGuards,
-  setConfig: setCreativeConfig,
-  getConfig: getCreativeConfig,
-};
-
-try {
-  creativeGlobal.tscreative = tsCreative;
-} catch (err) {
-  log.debug('tsjs-creative: failed to expose global tscreative', err);
-}
-
-export default tsCreative;
-
-(function auto() {
-  // Auto-install on load so publishers just reference the bundle.
-  const maybeWindow = resolveWindow();
-  if (!maybeWindow || typeof document === 'undefined') return;
-
-  const win = maybeWindow as CreativeWindow;
-  const initialConfig = creativeGlobal.tsCreativeConfig ?? win.tsCreativeConfig;
-  if (initialConfig) {
-    mergeConfig(initialConfig);
-  } else {
-    creativeGlobal.tsCreativeConfig = { ...currentConfig };
-  }
-  if (win.__ts_creative_installed) return;
-  win.__ts_creative_installed = true;
-
-  installGuards();
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', () => installGuards());
-  }
-})();
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/module.ts b/crates/trusted-server-js/lib/src/integrations/creative/module.ts
new file mode 100644
index 000000000..0a228c38d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/creative/module.ts
@@ -0,0 +1,138 @@
+import type { CreativeBootV1 } from '../../core/types';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type { RuntimeCapabilityV1 } from '../../kernel/runtime';
+import { validatePersistentFirstDisplaySliceAdoptionV1 } from '../../shared/takeover';
+
+import { installClickGuard } from './click';
+import { installDynamicIframeProxy } from './iframe';
+import { installDynamicImageProxy } from './image';
+import { createCreativeStartup } from './startup';
+
+export const CREATIVE_INTEGRATION_ID = 'creative' as const;
+
+function validFirstDisplayAdoption(candidate: unknown): boolean {
+  return validatePersistentFirstDisplaySliceAdoptionV1(candidate, 'creative_initial', (state) => {
+    const value = state.values[0]?.[1];
+    return (
+      state.values.length === 1 &&
+      state.values[0]?.[0] === 'guard_count' &&
+      typeof value === 'number' &&
+      Number.isInteger(value) &&
+      value >= 1 &&
+      value <= 3
+    );
+  });
+}
+
+function readCreativeBoot(candidate: unknown): Readonly<CreativeBootV1> | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      !Object.isFrozen(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      Object.getOwnPropertySymbols(candidate).length !== 0
+    ) {
+      return undefined;
+    }
+    const keys = Object.getOwnPropertyNames(candidate).sort();
+    const expected = ['clickGuard', 'enabled', 'renderGuard', 'version'];
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+      return undefined;
+    }
+    const values: Record<string, unknown> = {};
+    for (let index = 0; index < expected.length; index += 1) {
+      const key = expected[index];
+      if (!key) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      values[key] = descriptor.value;
+    }
+    return values['version'] === 1 &&
+      typeof values['enabled'] === 'boolean' &&
+      typeof values['clickGuard'] === 'boolean' &&
+      typeof values['renderGuard'] === 'boolean' &&
+      (values['enabled'] || (!values['clickGuard'] && !values['renderGuard']))
+      ? (candidate as Readonly<CreativeBootV1>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function readRuntimeCapability(
+  interfaces: Readonly<Record<string, unknown>>
+): RuntimeCapabilityV1 | undefined {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(interfaces, 'runtime.v1');
+    if (!descriptor || !('value' in descriptor)) return undefined;
+    const candidate = descriptor.value;
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      !Object.isFrozen(candidate) ||
+      !(candidate as RuntimeCapabilityV1).document
+    ) {
+      return undefined;
+    }
+    return candidate as RuntimeCapabilityV1;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Build the inert, release-bound creative module for the coordinated runtime. */
+export function createCreativeIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces }: IntegrationPrepareContext) => {
+    const creative = readCreativeBoot(config);
+    if (!creative) throw new TypeError('Creative boot configuration is invalid');
+    const runtimeCapability = readRuntimeCapability(interfaces);
+    const runtimeDocument = runtimeCapability?.document;
+    if (!runtimeDocument) throw new TypeError('Creative runtime capability is unavailable');
+    if (!creative.enabled || (!creative.clickGuard && !creative.renderGuard)) {
+      return Object.freeze({
+        activate: ({ adoption }: IntegrationActivationContext) => {
+          if (adoption !== undefined && !validFirstDisplayAdoption(adoption)) {
+            throw new TypeError('Creative first-display parser state is invalid');
+          }
+        },
+      });
+    }
+    const runtime = createCreativeStartup({
+      document: runtimeDocument,
+      installClickGuard: () => installClickGuard(false),
+      installDynamicIframeProxy: () => installDynamicIframeProxy(false),
+      installDynamicImageProxy: () => installDynamicImageProxy(false),
+    });
+
+    return Object.freeze({
+      activate: ({ adoption, afterCommit, onDispose }: IntegrationActivationContext) => {
+        if (adoption !== undefined && !validFirstDisplayAdoption(adoption)) {
+          throw new TypeError('Creative first-display parser state is invalid');
+        }
+        const runtimeRelease: { value?: () => void } = {};
+        onDispose(() => runtimeRelease.value?.());
+        const releaseRuntime = runtime.activate(creative);
+        if (typeof releaseRuntime !== 'function') {
+          throw new TypeError('Creative integration activation disposer is unavailable');
+        }
+        runtimeRelease.value = releaseRuntime;
+        afterCommit(() => runtime.start(creative));
+      },
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: CREATIVE_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/proxy_sign.ts b/crates/trusted-server-js/lib/src/integrations/creative/proxy_sign.ts
index 2ea3f7ec9..0ac5601b0 100644
--- a/crates/trusted-server-js/lib/src/integrations/creative/proxy_sign.ts
+++ b/crates/trusted-server-js/lib/src/integrations/creative/proxy_sign.ts
@@ -21,9 +21,7 @@ export function shouldProxyExternalUrl(raw: string): boolean {
 }
 
 export type ProxySignOutcome =
-  | { outcome: 'signed'; href: string }
-  | { outcome: 'fallback' }
-  | { outcome: 'blocked' };
+  { outcome: 'signed'; href: string } | { outcome: 'fallback' } | { outcome: 'blocked' };
 
 const FALLBACK: ProxySignOutcome = { outcome: 'fallback' };
 
diff --git a/crates/trusted-server-js/lib/src/integrations/creative/startup.ts b/crates/trusted-server-js/lib/src/integrations/creative/startup.ts
new file mode 100644
index 000000000..916a3fbe2
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/creative/startup.ts
@@ -0,0 +1,128 @@
+import type { CreativeBootV1 } from '../../core/types';
+
+export interface CreativeGuardHandle {
+  readonly dispose: () => void;
+  readonly scan: () => void;
+}
+
+export interface CreativeStartup {
+  readonly activate: (config: Readonly<CreativeBootV1>) => () => void;
+  readonly start: (config: Readonly<CreativeBootV1>) => void;
+}
+
+export interface CreativeStartupOptions {
+  readonly document: {
+    readonly readyState: DocumentReadyState;
+    addEventListener(type: 'DOMContentLoaded', listener: () => void, options: { once: true }): void;
+    removeEventListener(type: 'DOMContentLoaded', listener: () => void): void;
+  };
+  readonly installClickGuard: () => CreativeGuardHandle;
+  readonly installDynamicIframeProxy: () => CreativeGuardHandle;
+  readonly installDynamicImageProxy: () => CreativeGuardHandle;
+}
+
+function sameBoot(left: Readonly<CreativeBootV1>, right: Readonly<CreativeBootV1>): boolean {
+  return (
+    left.version === right.version &&
+    left.enabled === right.enabled &&
+    left.clickGuard === right.clickGuard &&
+    left.renderGuard === right.renderGuard
+  );
+}
+
+function validHandle(candidate: unknown): candidate is CreativeGuardHandle {
+  return (
+    typeof candidate === 'object' &&
+    candidate !== null &&
+    typeof Reflect.get(candidate, 'dispose') === 'function' &&
+    typeof Reflect.get(candidate, 'scan') === 'function'
+  );
+}
+
+/** Own creative guard installation separately from the post-commit initial scan. */
+export function createCreativeStartup(options: CreativeStartupOptions): CreativeStartup {
+  const handles: CreativeGuardHandle[] = [];
+  let activated = false;
+  let activatedBoot: Readonly<CreativeBootV1> | undefined;
+  let readyListener: (() => void) | undefined;
+  let released = false;
+  let started = false;
+
+  const scan = (): void => {
+    if (released) return;
+    for (let index = 0; index < handles.length; index += 1) {
+      try {
+        handles[index]?.scan();
+      } catch {
+        // One hostile guard scan cannot suppress the remaining active guards.
+      }
+    }
+  };
+
+  const disposeHandles = (): void => {
+    for (let index = handles.length - 1; index >= 0; index -= 1) {
+      try {
+        handles[index]?.dispose();
+      } catch {
+        // Continue releasing every previously installed guard.
+      }
+    }
+    handles.length = 0;
+  };
+
+  const install = (installer: () => CreativeGuardHandle): void => {
+    const handle = installer();
+    if (!validHandle(handle)) throw new TypeError('Creative guard handle is invalid');
+    handles.push(handle);
+  };
+
+  return Object.freeze({
+    activate: (config: Readonly<CreativeBootV1>): (() => void) => {
+      if (activated || released) throw new Error('Creative startup is already activated');
+      activated = true;
+      activatedBoot = config;
+      try {
+        if (config.enabled && config.clickGuard) install(options.installClickGuard);
+        if (config.enabled && config.renderGuard) {
+          install(options.installDynamicImageProxy);
+          install(options.installDynamicIframeProxy);
+        }
+        if (handles.length > 0 && options.document.readyState === 'loading') {
+          readyListener = () => scan();
+          options.document.addEventListener('DOMContentLoaded', readyListener, { once: true });
+        }
+      } catch (error) {
+        const listener = readyListener;
+        readyListener = undefined;
+        try {
+          if (listener) options.document.removeEventListener('DOMContentLoaded', listener);
+        } catch {
+          // Preserve the activation failure while completing owned guard rollback.
+        } finally {
+          disposeHandles();
+        }
+        throw error;
+      }
+      return (): void => {
+        if (released) return;
+        released = true;
+        const listener = readyListener;
+        readyListener = undefined;
+        try {
+          if (listener) options.document.removeEventListener('DOMContentLoaded', listener);
+        } finally {
+          disposeHandles();
+        }
+      };
+    },
+    start: (config: Readonly<CreativeBootV1>): void => {
+      if (started) throw new Error('Creative startup is already started');
+      started = true;
+      if (released) return;
+      if (!activated || !activatedBoot || !sameBoot(activatedBoot, config)) {
+        throw new Error('Creative startup is unavailable');
+      }
+      if (handles.length > 0 && options.document.readyState !== 'loading') scan();
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/datadome/index.ts b/crates/trusted-server-js/lib/src/integrations/datadome/index.ts
index b7dacdebc..5a24093bd 100644
--- a/crates/trusted-server-js/lib/src/integrations/datadome/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/datadome/index.ts
@@ -1,23 +1,13 @@
-import { log } from '../../core/log';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installDataDomeGuard } from './script_guard';
-
-/**
- * DataDome integration for tsjs
- *
- * Installs a script guard to intercept dynamically inserted DataDome SDK
- * scripts and rewrites them to use the first-party proxy endpoint.
- *
- * The guard intercepts:
- * - Script elements with src containing js.datadome.co
- * - Link preload elements for DataDome scripts
- *
- * URLs are rewritten to preserve the original path:
- * - https://js.datadome.co/tags.js -> /integrations/datadome/tags.js
- * - https://js.datadome.co/js/check -> /integrations/datadome/js/check
- */
+import { createDataDomeIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installDataDomeGuard();
-  log.info('DataDome integration initialized');
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createDataDomeIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/datadome/module.ts b/crates/trusted-server-js/lib/src/integrations/datadome/module.ts
new file mode 100644
index 000000000..a606a07e5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/datadome/module.ts
@@ -0,0 +1,60 @@
+import type { IntegrationRegistration } from '../../kernel/integration_registry';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import {
+  createLifecycleIntegrationRegistration,
+  type IntegrationLifecycleRuntime,
+} from '../../kernel/lifecycle_module';
+import { log } from '../../core/log';
+
+import { installDataDomeGuard, resetGuardState } from './script_guard';
+
+export const DATADOME_INTEGRATION_ID = 'datadome' as const;
+
+export interface DataDomeRuntimeDependencies {
+  readonly installGuard: () => void;
+  readonly resetGuard: () => void;
+  readonly started: () => void;
+}
+
+/** Own the reversible DataDome script/preload guard for one runtime. */
+export function createDataDomeRuntime(
+  dependencies: DataDomeRuntimeDependencies = {
+    installGuard: installDataDomeGuard,
+    resetGuard: resetGuardState,
+    started: () => log.info('DataDome integration initialized'),
+  }
+): IntegrationLifecycleRuntime {
+  return Object.freeze({
+    activate: (_config: unknown) => {
+      try {
+        dependencies.installGuard();
+      } catch (error) {
+        try {
+          dependencies.resetGuard();
+        } catch {
+          // Preserve the activation failure after best-effort rollback.
+        }
+        throw error;
+      }
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        dependencies.resetGuard();
+      };
+    },
+    start: (_config: unknown) => dependencies.started(),
+  });
+}
+
+export function createDataDomeIntegrationRegistration(release: string): IntegrationRegistration {
+  return createLifecycleIntegrationRegistration(DATADOME_INTEGRATION_ID, release, {
+    createOwnedRuntime: () => createDataDomeRuntime(),
+    firstDisplaySliceId: 'datadome_initial',
+    validateConfig: isEmptyIntegrationConfigV1,
+    validateFirstDisplayState: (state) =>
+      state.values.length === 1 &&
+      state.values[0]?.[0] === 'route_guard' &&
+      state.values[0][1] === 'datadome',
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/didomi/index.ts b/crates/trusted-server-js/lib/src/integrations/didomi/index.ts
index 3595b2f9a..618c1b068 100644
--- a/crates/trusted-server-js/lib/src/integrations/didomi/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/didomi/index.ts
@@ -1,53 +1,13 @@
-import { log } from '../../core/log';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-const DEFAULT_CONSENT_PROXY_PATH = '/integrations/didomi/consent/';
-
-type DidomiConfig = {
-  sdkPath?: string;
-  [key: string]: unknown;
-};
-
-type DidomiWindow = Window & {
-  didomiConfig?: DidomiConfig;
-  __tsjs_didomi?: { proxyPath?: string };
-};
-
-/** Read the server-injected proxy path, falling back to the default. */
-function getConsentProxyPath(win: DidomiWindow): string {
-  return win.__tsjs_didomi?.proxyPath ?? DEFAULT_CONSENT_PROXY_PATH;
-}
-
-function buildProxySdkPath(win: DidomiWindow): string {
-  const proxyPath = getConsentProxyPath(win);
-  const base = win.location?.origin ?? win.location?.href;
-  if (!base) return proxyPath;
-  const url = new URL(proxyPath, base);
-  return `${url.origin}${url.pathname}`;
-}
-
-export function installDidomiSdkProxy(): boolean {
-  if (typeof window === 'undefined') return false;
-
-  const win = window as DidomiWindow;
-  const config = (win.didomiConfig ??= {});
-  const previousSdkPath =
-    typeof config.sdkPath === 'string' && config.sdkPath.length > 0
-      ? config.sdkPath
-      : 'https://sdk.privacy-center.org/';
-
-  const proxiedSdkPath = buildProxySdkPath(win);
-  config.sdkPath = proxiedSdkPath;
-
-  log.info('didomi sdkPath overridden for trusted server proxy', {
-    previousSdkPath,
-    sdkPath: proxiedSdkPath,
-  });
-
-  return true;
-}
+import { createDidomiIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installDidomiSdkProxy();
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createDidomiIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
 }
-
-export default installDidomiSdkProxy;
diff --git a/crates/trusted-server-js/lib/src/integrations/didomi/module.ts b/crates/trusted-server-js/lib/src/integrations/didomi/module.ts
new file mode 100644
index 000000000..cf6a296ff
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/didomi/module.ts
@@ -0,0 +1,156 @@
+import type { IntegrationRegistration } from '../../kernel/integration_registry';
+import {
+  createLifecycleIntegrationRegistration,
+  type IntegrationLifecycleRuntime,
+} from '../../kernel/lifecycle_module';
+import { log } from '../../core/log';
+
+export const DIDOMI_INTEGRATION_ID = 'didomi' as const;
+
+interface DidomiConfig {
+  sdkPath?: string;
+  [key: string]: unknown;
+}
+
+export interface DidomiRuntimeTarget {
+  didomiConfig?: DidomiConfig;
+  readonly location: { readonly href?: string; readonly origin?: string };
+}
+
+export interface DidomiRuntimeDependencies {
+  readonly started: () => void;
+  readonly target: DidomiRuntimeTarget;
+}
+
+function didomiBootConfig(candidate: unknown): candidate is Readonly<{ proxyPath: string }> {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      !Object.isFrozen(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      Reflect.ownKeys(candidate).length !== 1
+    ) {
+      return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, 'proxyPath');
+    return Boolean(
+      descriptor?.enumerable &&
+      'value' in descriptor &&
+      typeof descriptor.value === 'string' &&
+      descriptor.value.startsWith('/') &&
+      !descriptor.value.startsWith('//') &&
+      !descriptor.value.startsWith('/\\') &&
+      descriptor.value.length <= 2_048 &&
+      !descriptor.value.includes('?') &&
+      !descriptor.value.includes('#')
+    );
+  } catch {
+    return false;
+  }
+}
+
+function sameDescriptor(
+  left: PropertyDescriptor | undefined,
+  right: PropertyDescriptor | undefined
+): boolean {
+  return Boolean(
+    left &&
+    right &&
+    'value' in left &&
+    'value' in right &&
+    left.value === right.value &&
+    left.configurable === right.configurable &&
+    left.enumerable === right.enumerable &&
+    left.writable === right.writable
+  );
+}
+
+/** Own only Didomi's proxied `sdkPath`, preserving all publisher configuration. */
+export function createDidomiRuntime(
+  dependencies: DidomiRuntimeDependencies = {
+    started: () => log.info('Didomi integration initialized'),
+    target: window as DidomiRuntimeTarget,
+  }
+): IntegrationLifecycleRuntime {
+  return Object.freeze({
+    activate: (candidate: unknown): (() => void) => {
+      if (!didomiBootConfig(candidate)) throw new TypeError('Didomi config is invalid');
+      const base = dependencies.target.location.origin ?? dependencies.target.location.href;
+      if (!base) throw new TypeError('Didomi publisher origin is unavailable');
+      const parsed = new URL(candidate.proxyPath, base);
+      if (parsed.origin !== new URL(base).origin) {
+        throw new TypeError('Didomi proxy path must remain on the publisher origin');
+      }
+      const installedPath = `${parsed.origin}${parsed.pathname}`;
+      const previousTargetDescriptor = Object.getOwnPropertyDescriptor(
+        dependencies.target,
+        'didomiConfig'
+      );
+      let config = dependencies.target.didomiConfig;
+      const created = config === undefined;
+      if (created) {
+        config = {};
+        if (!Reflect.set(dependencies.target, 'didomiConfig', config)) {
+          throw new TypeError('Didomi publisher config is not writable');
+        }
+      }
+      if (typeof config !== 'object' || config === null) {
+        throw new TypeError('Didomi publisher config is invalid');
+      }
+      const previousSdkDescriptor = Object.getOwnPropertyDescriptor(config, 'sdkPath');
+      if (previousSdkDescriptor && !('value' in previousSdkDescriptor)) {
+        throw new TypeError('Didomi sdkPath accessor is unsupported');
+      }
+      if (!Reflect.set(config, 'sdkPath', installedPath)) {
+        throw new TypeError('Didomi sdkPath is not writable');
+      }
+      const installedSdkDescriptor = Object.getOwnPropertyDescriptor(config, 'sdkPath');
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        try {
+          if (dependencies.target.didomiConfig !== config) return;
+          const current = Object.getOwnPropertyDescriptor(config, 'sdkPath');
+          if (!sameDescriptor(current, installedSdkDescriptor)) return;
+          if (previousSdkDescriptor)
+            Object.defineProperty(config, 'sdkPath', previousSdkDescriptor);
+          else Reflect.deleteProperty(config, 'sdkPath');
+          if (
+            created &&
+            Reflect.ownKeys(config).length === 0 &&
+            Object.getOwnPropertyDescriptor(dependencies.target, 'didomiConfig')?.value === config
+          ) {
+            if (previousTargetDescriptor) {
+              Object.defineProperty(dependencies.target, 'didomiConfig', previousTargetDescriptor);
+            } else {
+              Reflect.deleteProperty(dependencies.target, 'didomiConfig');
+            }
+          }
+        } catch {
+          // Publisher replacement wins over cleanup.
+        }
+      };
+    },
+    start: (_config: unknown): void => dependencies.started(),
+  });
+}
+
+export function createDidomiIntegrationRegistration(release: string): IntegrationRegistration {
+  return createLifecycleIntegrationRegistration(DIDOMI_INTEGRATION_ID, release, {
+    createOwnedRuntime: () => createDidomiRuntime(),
+    firstDisplaySliceId: 'didomi_initial',
+    validateConfig: didomiBootConfig,
+    validateFirstDisplayState: (state) => {
+      const value = state.values[0]?.[1];
+      return (
+        state.values.length === 1 &&
+        state.values[0]?.[0] === 'sdk_path' &&
+        typeof value === 'string' &&
+        value.length > 0
+      );
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/google_tag_manager/index.ts b/crates/trusted-server-js/lib/src/integrations/google_tag_manager/index.ts
index ca73f2482..5da50a318 100644
--- a/crates/trusted-server-js/lib/src/integrations/google_tag_manager/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/google_tag_manager/index.ts
@@ -1,31 +1,13 @@
-import { log } from '../../core/log';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installGtmBeaconGuard } from './script_guard';
-import { installGtmGuard } from './script_guard';
-
-/**
- * Google Tag Manager integration for tsjs
- *
- * Installs guards to intercept GTM and Google Analytics traffic:
- *
- * 1. **Script guard** — intercepts dynamically inserted `<script>` and
- *    `<link>` elements and rewrites their URLs to the first-party proxy.
- *
- * 2. **Beacon guard** — intercepts `navigator.sendBeacon()` and `fetch()`
- *    calls to Google Analytics domains (www.google-analytics.com,
- *    analytics.google.com) and rewrites them to the first-party proxy.
- *    This is necessary because gtag.js constructs beacon URLs dynamically
- *    from bare domain strings, which can't be safely rewritten at the
- *    script level.
- *
- * URLs are rewritten to preserve the original path:
- * - https://www.googletagmanager.com/gtm.js?id=GTM-XXXX -> /integrations/google_tag_manager/gtm.js?id=GTM-XXXX
- * - https://www.google-analytics.com/g/collect -> /integrations/google_tag_manager/g/collect
- * - https://analytics.google.com/g/collect -> /integrations/google_tag_manager/g/collect
- */
+import { createGoogleTagManagerIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installGtmGuard();
-  installGtmBeaconGuard();
-  log.info('Google Tag Manager integration initialized');
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createGoogleTagManagerIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/google_tag_manager/module.ts b/crates/trusted-server-js/lib/src/integrations/google_tag_manager/module.ts
new file mode 100644
index 000000000..40209b9ee
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/google_tag_manager/module.ts
@@ -0,0 +1,85 @@
+import type { IntegrationRegistration } from '../../kernel/integration_registry';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import {
+  createLifecycleIntegrationRegistration,
+  type IntegrationLifecycleRuntime,
+} from '../../kernel/lifecycle_module';
+import { log } from '../../core/log';
+
+import {
+  installGtmBeaconGuard,
+  installGtmGuard,
+  resetBeaconGuardState,
+  resetGuardState,
+} from './script_guard';
+
+export const GOOGLE_TAG_MANAGER_INTEGRATION_ID = 'google_tag_manager' as const;
+
+export interface GoogleTagManagerRuntimeDependencies {
+  readonly installBeaconGuard: () => void;
+  readonly installScriptGuard: () => void;
+  readonly resetBeaconGuard: () => void;
+  readonly resetScriptGuard: () => void;
+  readonly started: () => void;
+}
+
+/** Own the reversible GTM script/preload and GA network guards for one runtime. */
+export function createGoogleTagManagerRuntime(
+  dependencies: GoogleTagManagerRuntimeDependencies = {
+    installBeaconGuard: installGtmBeaconGuard,
+    installScriptGuard: installGtmGuard,
+    resetBeaconGuard: resetBeaconGuardState,
+    resetScriptGuard: resetGuardState,
+    started: () => log.info('Google Tag Manager integration initialized'),
+  }
+): IntegrationLifecycleRuntime {
+  return Object.freeze({
+    activate: (_config: unknown) => {
+      let beaconAttempted = false;
+      try {
+        dependencies.installScriptGuard();
+        beaconAttempted = true;
+        dependencies.installBeaconGuard();
+      } catch (error) {
+        if (beaconAttempted) {
+          try {
+            dependencies.resetBeaconGuard();
+          } catch {
+            // Continue through independent script-guard rollback.
+          }
+        }
+        try {
+          dependencies.resetScriptGuard();
+        } catch {
+          // Preserve the activation failure after best-effort rollback.
+        }
+        throw error;
+      }
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        try {
+          dependencies.resetBeaconGuard();
+        } finally {
+          dependencies.resetScriptGuard();
+        }
+      };
+    },
+    start: (_config: unknown) => dependencies.started(),
+  });
+}
+
+export function createGoogleTagManagerIntegrationRegistration(
+  release: string
+): IntegrationRegistration {
+  return createLifecycleIntegrationRegistration(GOOGLE_TAG_MANAGER_INTEGRATION_ID, release, {
+    createOwnedRuntime: () => createGoogleTagManagerRuntime(),
+    firstDisplaySliceId: 'google_tag_manager_initial',
+    validateConfig: isEmptyIntegrationConfigV1,
+    validateFirstDisplayState: (state) =>
+      state.values.length === 1 &&
+      state.values[0]?.[0] === 'route_guard' &&
+      state.values[0][1] === 'google_tag_manager',
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/diagnostics_facts.ts b/crates/trusted-server-js/lib/src/integrations/gpt/diagnostics_facts.ts
new file mode 100644
index 000000000..7169628dd
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/diagnostics_facts.ts
@@ -0,0 +1,618 @@
+import type {
+  GptSlotTokenV1,
+  GptTraceCycleOrdinalV1,
+  GoogletagAdapter,
+  GoogletagDiagnosticsFact,
+  GoogletagDiagnosticsSlotSnapshot,
+} from '../../adapters/googletag';
+import {
+  createTrustedServerOpportunityFact,
+  isTrustedServerOpportunityFact,
+  type GptDiagnosticsOpportunityFact,
+} from '../../shared/gpt_diagnostics';
+import type { FirstDisplayGptDiagnosticsV1, FirstDisplayGptFactV1 } from '../../shared/takeover';
+import type { BrowserAuctionProjectionV1 } from '../../core/types';
+
+export { createTrustedServerOpportunityFact, type GptDiagnosticsOpportunityFact };
+
+const MAX_BUFFERED_FACTS = 512;
+const DIAGNOSTICS_ONLY_EVENTS = Object.freeze([
+  'slotResponseReceived',
+  'slotOnload',
+  'impressionViewable',
+  'slotVisibilityChanged',
+] as const);
+const ALL_DIAGNOSTIC_EVENTS = new Set<string>([
+  'slotRequested',
+  'slotResponseReceived',
+  'slotRenderEnded',
+  'slotOnload',
+  'impressionViewable',
+  'slotVisibilityChanged',
+]);
+export interface GptDiagnosticsFactBufferOptions {
+  readonly onConsumerError?: (error: unknown) => void;
+  readonly onOverflow?: (droppedFacts: number) => void;
+}
+
+export type GptDiagnosticsFact = GoogletagDiagnosticsFact | GptDiagnosticsOpportunityFact;
+export type GptDiagnosticsFactObserver = (fact: Readonly<GptDiagnosticsFact>) => void;
+
+/** Publish immutable request evidence captured by the exact request-producing operation. */
+export function publishTrustedServerOpportunityFact(input: {
+  readonly adapter: Pick<GoogletagAdapter, 'diagnosticsIdentity'>;
+  readonly buffer: Pick<GptDiagnosticsFactBuffer, 'publish'>;
+  readonly physicalSlot: object;
+  readonly registeredSlotId: string;
+  readonly opportunity: Readonly<{
+    requestedSlotSizes: readonly (readonly [number, number])[];
+    trustedServerAuctionId: string;
+  }>;
+}): boolean {
+  try {
+    const identity = input.adapter.diagnosticsIdentity(input.physicalSlot);
+    if (!identity) return false;
+    const fact = createTrustedServerOpportunityFact({
+      auctionSlotId: input.registeredSlotId,
+      opportunity: 'renderable_candidate',
+      requestedSlotSizes: input.opportunity.requestedSlotSizes,
+      slot: identity,
+      trustedServerAuctionId: input.opportunity.trustedServerAuctionId,
+    });
+    return fact ? input.buffer.publish(fact) : false;
+  } catch {
+    return false;
+  }
+}
+
+/** Publish the exact projected Trusted Server winner immediately before its GPT request. */
+export function publishTrustedServerRequestFact(input: {
+  readonly adapter: Pick<GoogletagAdapter, 'diagnosticsIdentity'>;
+  readonly buffer: Pick<GptDiagnosticsFactBuffer, 'publish'>;
+  readonly physicalSlot: object;
+  readonly projection: Readonly<{
+    auction: Readonly<{
+      auctionId: string;
+      results: readonly Readonly<BrowserAuctionProjectionV1['auction']['results'][number]>[];
+    }>;
+    bids: readonly Readonly<BrowserAuctionProjectionV1['bids'][number]>[];
+    slots: readonly Readonly<BrowserAuctionProjectionV1['slots'][number]>[];
+  }>;
+  readonly registeredSlotId: string;
+}): boolean {
+  try {
+    const placements = input.projection.slots.filter(
+      (placement) => placement.slot === input.registeredSlotId
+    );
+    const decisions = input.projection.auction.results.filter(
+      (decision) => decision.slot === input.registeredSlotId
+    );
+    if (placements.length !== 1 || decisions.length !== 1) return false;
+    const placement = placements[0];
+    const decision = decisions[0];
+    if (!placement || decision?.outcome !== 'winner') return false;
+    const bids = input.projection.bids.filter(
+      (bid) => bid.slot === input.registeredSlotId && bid.candidateId === decision.candidateId
+    );
+    if (bids.length !== 1) return false;
+    return publishTrustedServerOpportunityFact({
+      adapter: input.adapter,
+      buffer: input.buffer,
+      physicalSlot: input.physicalSlot,
+      registeredSlotId: input.registeredSlotId,
+      opportunity: Object.freeze({
+        requestedSlotSizes: placement.formats,
+        trustedServerAuctionId: input.projection.auction.auctionId,
+      }),
+    });
+  } catch {
+    return false;
+  }
+}
+
+export interface GptDiagnosticsFactBuffer {
+  readonly adoptFirstDisplay: (
+    diagnostics: Readonly<FirstDisplayGptDiagnosticsV1>,
+    resolveSlot?: (traceToken: string) => Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined,
+    resolveOpportunity?: (
+      traceToken: string,
+      slot: Readonly<GoogletagDiagnosticsSlotSnapshot>
+    ) => Readonly<GptDiagnosticsOpportunityFact> | undefined
+  ) => boolean;
+  readonly publish: (fact: Readonly<GptDiagnosticsFact>) => boolean;
+  readonly activate: (consumer: GptDiagnosticsFactObserver) => (() => void) | undefined;
+  readonly dispose: () => void;
+}
+
+/** Project the direct opaque GPT fact into the bounded data-only core trace shape. */
+export function projectGptTraceFact(
+  fact: Readonly<GoogletagDiagnosticsFact>
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const traceToken = fact.slot.traceToken;
+    const cycleOrdinal = fact.slot.cycleOrdinal;
+    if (
+      typeof traceToken !== 'string' ||
+      !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(traceToken) ||
+      traceToken.length > 11 ||
+      Number.parseInt(traceToken.slice(4), 36) > 4_294_967_295 ||
+      !Number.isInteger(cycleOrdinal) ||
+      (cycleOrdinal ?? 0) < 1 ||
+      (cycleOrdinal ?? 0) > 4_294_967_295
+    ) {
+      return undefined;
+    }
+    const slot = Object.freeze({
+      token: traceToken,
+      cycleOrdinal,
+      ...(typeof fact.slot.elementId === 'string' && fact.slot.elementId !== ''
+        ? { elementId: fact.slot.elementId }
+        : {}),
+    });
+    return Object.freeze({
+      kind: fact.kind,
+      observedAtMs: fact.observedAtMs,
+      slot,
+      ...(typeof fact.isEmpty === 'boolean' ? { isEmpty: fact.isEmpty } : {}),
+      ...(typeof fact.inViewPercentage === 'number' && Number.isFinite(fact.inViewPercentage)
+        ? { inViewPercentage: fact.inViewPercentage }
+        : {}),
+      ...(typeof fact.responseIdentifier === 'string' && fact.responseIdentifier !== ''
+        ? { responseIdentifier: fact.responseIdentifier }
+        : {}),
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function validFact(fact: unknown): fact is Readonly<GptDiagnosticsFact> {
+  if (typeof fact !== 'object' || fact === null || !Object.isFrozen(fact)) return false;
+  const kind = Object.getOwnPropertyDescriptor(fact, 'kind');
+  if (kind && 'value' in kind && kind.value === 'trustedServerOpportunity') {
+    return isTrustedServerOpportunityFact(fact);
+  }
+  const slot = Object.getOwnPropertyDescriptor(fact, 'slot');
+  return (
+    ((kind !== undefined &&
+      'value' in kind &&
+      DIAGNOSTICS_ONLY_EVENTS.includes(kind.value as (typeof DIAGNOSTICS_ONLY_EVENTS)[number])) ||
+      kind?.value === 'slotRequested' ||
+      kind?.value === 'slotRenderEnded') &&
+    slot !== undefined &&
+    'value' in slot &&
+    ((typeof slot.value === 'object' && slot.value !== null) || typeof slot.value === 'function')
+  );
+}
+
+const FIRST_DISPLAY_FACT_KEYS = Object.freeze([
+  'version',
+  'event',
+  'token',
+  'runtimeSlotNumber',
+  'cycleOrdinal',
+  'disposition',
+  'issueReason',
+  'capturedAtMs',
+  'elementId',
+  'adUnitPath',
+  'requestedSlotSizes',
+  'isEmpty',
+  'renderedSize',
+  'isBackfill',
+  'slotContentChanged',
+  'visibilityPercent',
+]);
+
+function exactFrozenRecord(
+  candidate: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    Array.isArray(candidate) ||
+    !Object.isFrozen(candidate)
+  ) {
+    return undefined;
+  }
+  const actual = Reflect.ownKeys(candidate);
+  if (
+    actual.length !== keys.length ||
+    actual.some((key) => typeof key !== 'string' || !keys.includes(key))
+  ) {
+    return undefined;
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+
+function validTransferredFact(candidate: unknown): candidate is Readonly<FirstDisplayGptFactV1> {
+  const fields = exactFrozenRecord(candidate, FIRST_DISPLAY_FACT_KEYS);
+  if (!fields) return false;
+  const tokenOrdinal =
+    typeof fields.token === 'string' && /^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(fields.token)
+      ? Number.parseInt(fields.token.slice(4), 36)
+      : undefined;
+  const event = fields.event;
+  const disposition = fields.disposition;
+  const issueReason = fields.issueReason;
+  const renderedSize = fields.renderedSize;
+  const requestedSlotSizes = fields.requestedSlotSizes;
+  return (
+    fields.version === 1 &&
+    ALL_DIAGNOSTIC_EVENTS.has(event as string) &&
+    tokenOrdinal !== undefined &&
+    tokenOrdinal >= 1 &&
+    tokenOrdinal <= 4_294_967_295 &&
+    fields.runtimeSlotNumber === tokenOrdinal &&
+    (fields.cycleOrdinal === null ||
+      (Number.isInteger(fields.cycleOrdinal) &&
+        (fields.cycleOrdinal as number) >= 1 &&
+        (fields.cycleOrdinal as number) <= 4_294_967_295)) &&
+    (disposition === 'matched' || disposition === 'unmatched' || disposition === 'ambiguous') &&
+    (issueReason === null ||
+      issueReason === 'no_request_cycle' ||
+      issueReason === 'overlapping_request_cycles' ||
+      issueReason === 'unknown_prior_cycle' ||
+      issueReason === 'invalid_event_order') &&
+    typeof fields.capturedAtMs === 'number' &&
+    Number.isFinite(fields.capturedAtMs) &&
+    fields.capturedAtMs >= 0 &&
+    (fields.elementId === null ||
+      (typeof fields.elementId === 'string' && fields.elementId.length > 0)) &&
+    (fields.adUnitPath === null ||
+      (typeof fields.adUnitPath === 'string' && fields.adUnitPath.length > 0)) &&
+    (requestedSlotSizes === null ||
+      (event === 'slotRequested' &&
+        disposition === 'matched' &&
+        Array.isArray(requestedSlotSizes) &&
+        Object.isFrozen(requestedSlotSizes) &&
+        requestedSlotSizes.length >= 1 &&
+        requestedSlotSizes.length <= 16 &&
+        requestedSlotSizes.every(
+          (size) =>
+            Array.isArray(size) &&
+            Object.isFrozen(size) &&
+            size.length === 2 &&
+            size.every(
+              (dimension) => Number.isInteger(dimension) && dimension >= 1 && dimension <= 4096
+            )
+        ))) &&
+    (fields.isEmpty === null || typeof fields.isEmpty === 'boolean') &&
+    (renderedSize === null ||
+      (Array.isArray(renderedSize) &&
+        Object.isFrozen(renderedSize) &&
+        renderedSize.length === 2 &&
+        renderedSize.every(
+          (dimension) => Number.isInteger(dimension) && dimension >= 1 && dimension <= 4096
+        ))) &&
+    (fields.isBackfill === null || typeof fields.isBackfill === 'boolean') &&
+    (fields.slotContentChanged === null || typeof fields.slotContentChanged === 'boolean') &&
+    (fields.visibilityPercent === null ||
+      (typeof fields.visibilityPercent === 'number' &&
+        Number.isFinite(fields.visibilityPercent) &&
+        fields.visibilityPercent >= 0 &&
+        fields.visibilityPercent <= 100))
+  );
+}
+
+function rawFirstDisplayFacts(
+  diagnostics: Readonly<FirstDisplayGptDiagnosticsV1>,
+  resolveSlot?: (traceToken: string) => Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined,
+  resolveOpportunity?: (
+    traceToken: string,
+    slot: Readonly<GoogletagDiagnosticsSlotSnapshot>
+  ) => Readonly<GptDiagnosticsOpportunityFact> | undefined
+): readonly Readonly<GptDiagnosticsFact>[] | undefined {
+  const fields = exactFrozenRecord(diagnostics, ['facts', 'overflowCount', 'dropCount']);
+  if (
+    !fields ||
+    !Array.isArray(fields.facts) ||
+    !Object.isFrozen(fields.facts) ||
+    fields.facts.length > MAX_BUFFERED_FACTS ||
+    !Number.isInteger(fields.overflowCount) ||
+    (fields.overflowCount as number) < 0 ||
+    (fields.overflowCount as number) > 4_294_967_295 ||
+    !Number.isInteger(fields.dropCount) ||
+    (fields.dropCount as number) < 0 ||
+    (fields.dropCount as number) > 4_294_967_295
+  ) {
+    return undefined;
+  }
+  const physicalByTraceToken = new Map<
+    string,
+    Readonly<{
+      runtimeSlotNumber: number;
+      token: object;
+      traceToken: GptSlotTokenV1;
+    }>
+  >();
+  const facts: Array<Readonly<GptDiagnosticsFact>> = [];
+  for (const candidate of fields.facts) {
+    if (!validTransferredFact(candidate)) return undefined;
+    let physical = physicalByTraceToken.get(candidate.token);
+    if (!physical) {
+      let resolved: Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined;
+      try {
+        resolved = resolveSlot?.(candidate.token);
+      } catch {
+        return undefined;
+      }
+      if (
+        resolved &&
+        (typeof resolved.token !== 'object' ||
+          resolved.token === null ||
+          resolved.traceToken !== candidate.token ||
+          resolved.runtimeSlotNumber !== candidate.runtimeSlotNumber)
+      ) {
+        return undefined;
+      }
+      physical = Object.freeze({
+        token: resolved?.token ?? Object.freeze(Object.create(null) as object),
+        traceToken: candidate.token as GptSlotTokenV1,
+        runtimeSlotNumber: candidate.runtimeSlotNumber,
+      });
+      physicalByTraceToken.set(candidate.token, physical);
+    }
+    if (physical.runtimeSlotNumber !== candidate.runtimeSlotNumber) return undefined;
+    const slot: Readonly<GoogletagDiagnosticsSlotSnapshot> = Object.freeze({
+      token: physical.token,
+      traceToken: physical.traceToken,
+      runtimeSlotNumber: physical.runtimeSlotNumber,
+      ...(candidate.cycleOrdinal === null
+        ? {}
+        : { cycleOrdinal: candidate.cycleOrdinal as GptTraceCycleOrdinalV1 }),
+      ...(candidate.elementId === null ? {} : { elementId: candidate.elementId }),
+      ...(candidate.adUnitPath === null ? {} : { adUnitPath: candidate.adUnitPath }),
+    });
+    if (candidate.requestedSlotSizes !== null) {
+      if (!resolveOpportunity) return undefined;
+      let opportunity: Readonly<GptDiagnosticsOpportunityFact> | undefined;
+      try {
+        opportunity = resolveOpportunity(candidate.token, slot);
+      } catch {
+        opportunity = undefined;
+      }
+      if (!opportunity || !validFact(opportunity)) return undefined;
+      facts.push(opportunity);
+    }
+    facts.push(
+      Object.freeze({
+        kind: candidate.event,
+        observedAtMs: candidate.capturedAtMs,
+        slot,
+        ...(candidate.isEmpty === null ? {} : { isEmpty: candidate.isEmpty }),
+        ...(candidate.renderedSize === null ? {} : { size: candidate.renderedSize }),
+        ...(candidate.isBackfill === null ? {} : { isBackfill: candidate.isBackfill }),
+        ...(candidate.slotContentChanged === null
+          ? {}
+          : { slotContentChanged: candidate.slotContentChanged }),
+        ...(candidate.visibilityPercent === null
+          ? {}
+          : { inViewPercentage: candidate.visibilityPercent }),
+      })
+    );
+  }
+  return Object.freeze(facts);
+}
+
+/** Own the GPT-side bounded handoff between early callbacks and diagnostics consumers. */
+export function createGptDiagnosticsFactBuffer(
+  options: GptDiagnosticsFactBufferOptions = {}
+): GptDiagnosticsFactBuffer {
+  const pending: Readonly<GptDiagnosticsFact>[] = [];
+  let consumer: GptDiagnosticsFactObserver | undefined;
+  let consumerGeneration = 0;
+  let replaying = false;
+  let disposed = false;
+  let droppedFacts = 0;
+  let adoptionOpen = true;
+
+  const reportConsumerError = (error: unknown): void => {
+    try {
+      options.onConsumerError?.(error);
+    } catch {
+      // Diagnostics error reporting cannot affect later fact delivery.
+    }
+  };
+  const reportOverflow = (): void => {
+    droppedFacts += 1;
+    try {
+      options.onOverflow?.(droppedFacts);
+    } catch {
+      // Overflow reporting is diagnostics-only.
+    }
+  };
+  const enqueue = (fact: Readonly<GptDiagnosticsFact>): void => {
+    if (pending.length >= MAX_BUFFERED_FACTS) {
+      pending.shift();
+      reportOverflow();
+    }
+    pending.push(fact);
+  };
+  const deliver = (fact: Readonly<GptDiagnosticsFact>): void => {
+    const current = consumer;
+    if (!current) return;
+    try {
+      current(fact);
+    } catch (error) {
+      reportConsumerError(error);
+    }
+  };
+
+  return Object.freeze({
+    adoptFirstDisplay: (
+      diagnostics: Readonly<FirstDisplayGptDiagnosticsV1>,
+      resolveSlot?: (traceToken: string) => Readonly<GoogletagDiagnosticsSlotSnapshot> | undefined,
+      resolveOpportunity?: (
+        traceToken: string,
+        slot: Readonly<GoogletagDiagnosticsSlotSnapshot>
+      ) => Readonly<GptDiagnosticsOpportunityFact> | undefined
+    ): boolean => {
+      const facts = rawFirstDisplayFacts(diagnostics, resolveSlot, resolveOpportunity);
+      if (disposed || !adoptionOpen || pending.length !== 0 || consumer !== undefined || !facts) {
+        return false;
+      }
+      pending.push(...facts);
+      droppedFacts = diagnostics.overflowCount;
+      adoptionOpen = false;
+      return true;
+    },
+    publish: (fact: Readonly<GptDiagnosticsFact>): boolean => {
+      adoptionOpen = false;
+      if (disposed || !validFact(fact)) return false;
+      if (replaying || !consumer) enqueue(fact);
+      else deliver(fact);
+      return true;
+    },
+    activate: (nextConsumer: GptDiagnosticsFactObserver): (() => void) | undefined => {
+      adoptionOpen = false;
+      if (disposed || consumer || typeof nextConsumer !== 'function') return undefined;
+      consumer = nextConsumer;
+      consumerGeneration += 1;
+      const generation = consumerGeneration;
+      replaying = true;
+      while (pending.length > 0 && consumer === nextConsumer && !disposed) {
+        const fact = pending.shift();
+        if (fact) deliver(fact);
+      }
+      replaying = false;
+      if (!consumer || disposed) pending.length = 0;
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        if (consumerGeneration === generation && consumer === nextConsumer) consumer = undefined;
+      };
+    },
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      consumer = undefined;
+      replaying = false;
+      pending.length = 0;
+    },
+  });
+}
+
+function activateEventListeners(
+  adapter: Pick<GoogletagAdapter, 'run'>,
+  onFailure: () => void = () => undefined
+): (() => void) | undefined {
+  let disposed = false;
+  let releases: readonly (() => void)[] = Object.freeze([]);
+  let operation: ReturnType<GoogletagAdapter['run']> | undefined;
+  try {
+    operation = adapter.run((gpt) => {
+      const installed: Array<() => void> = [];
+      try {
+        for (let index = 0; index < DIAGNOSTICS_ONLY_EVENTS.length; index += 1) {
+          const eventType = DIAGNOSTICS_ONLY_EVENTS[index];
+          if (!eventType) continue;
+          installed[installed.length] = gpt.subscribe(eventType, () => undefined, true);
+        }
+        return Object.freeze(installed);
+      } catch (error) {
+        for (let index = installed.length - 1; index >= 0; index -= 1) {
+          try {
+            installed[index]?.();
+          } catch {
+            // Continue rolling back the remaining listener ownership.
+          }
+        }
+        throw error;
+      }
+    });
+    void operation.result.then(
+      (installed) => {
+        releases = installed as readonly (() => void)[];
+        if (!disposed) return;
+        for (let index = releases.length - 1; index >= 0; index -= 1) {
+          try {
+            releases[index]?.();
+          } catch {
+            // Late completion still releases every listener independently.
+          }
+        }
+        releases = Object.freeze([]);
+      },
+      () => {
+        try {
+          onFailure();
+        } catch {
+          // Failure notification cannot retain listener ownership.
+        }
+      }
+    );
+  } catch {
+    onFailure();
+    return undefined;
+  }
+
+  return (): void => {
+    if (disposed) return;
+    disposed = true;
+    try {
+      operation?.dispose();
+    } catch {
+      // Disposal continues through every independently owned resource.
+    }
+    for (let index = releases.length - 1; index >= 0; index -= 1) {
+      try {
+        releases[index]?.();
+      } catch {
+        // One hostile listener release cannot retain the others.
+      }
+    }
+    releases = Object.freeze([]);
+  };
+}
+
+/** Install only the four GPT listeners that exist while diagnostics is active. */
+export function activateGptDiagnosticsEventListeners(
+  adapter: Pick<GoogletagAdapter, 'run'>
+): (() => void) | undefined {
+  return activateEventListeners(adapter);
+}
+
+/** Connect the sole GPT adapter stream and only the four diagnostics-only listeners. */
+export function activateGptDiagnosticsFactCapture(
+  adapter: Pick<GoogletagAdapter, 'observeDiagnostics' | 'run'>,
+  buffer: Readonly<{ publish: (fact: Readonly<GoogletagDiagnosticsFact>) => boolean }>
+): (() => void) | undefined {
+  let disposed = false;
+  const observerRelease = adapter.observeDiagnostics((fact) => {
+    try {
+      buffer.publish(fact);
+    } catch {
+      // Fact buffering cannot alter the already-completed GPT callback.
+    }
+  });
+  if (!observerRelease) return undefined;
+  let observerActive = true;
+  const releaseObserver = (): void => {
+    if (!observerActive) return;
+    observerActive = false;
+    observerRelease();
+  };
+  const releaseListeners = activateEventListeners(adapter, releaseObserver);
+  if (!releaseListeners) {
+    releaseObserver();
+    return undefined;
+  }
+  return (): void => {
+    if (disposed) return;
+    disposed = true;
+    try {
+      releaseListeners();
+    } finally {
+      releaseObserver();
+    }
+  };
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
index eb521254d..9c9e2f0c8 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
@@ -1,2288 +1,11 @@
-import {
-  claimFirstImpressionForTrustedServer,
-  firstImpressionClaim,
-  observeFirstImpressionGptLifecycle,
-  publisherFirstImpressionRetryDelay,
-  releaseTrustedServerFirstImpressionClaim,
-  reservePublisherFirstImpressionFallback,
-} from '../../core/first_impression';
-import { log } from '../../core/log';
-import { resolveSlotElementByDivId } from '../../core/slot_element';
-import type {
-  AuctionSlot,
-  AuctionBidData,
-  GptDiagnosticsCreativeFailure,
-  GptDiagnosticsTrustedServerOpportunity,
-  GptSlotHandoff,
-  TsjsApi,
-} from '../../core/types';
-import {
-  APS_UNIVERSAL_CREATIVE_RENDERER,
-  APS_UNIVERSAL_CREATIVE_RENDERER_VERSION,
-  apsRendererUrl,
-  dispatchApsRendering,
-  consumeApsPrebidRenderer,
-  getApsPrebidRenderer,
-  validateApsRenderer,
-} from '../aps/render';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installGptGuard } from './script_guard';
+import { createGptIntegrationRegistration } from './module';
 
-/**
- * Google Publisher Tags (GPT) Integration Shim
- *
- * Hooks into the googletag.cmd command queue so the Trusted Server can
- * observe and augment ad-slot definitions before GPT processes them.
- * The shim ensures the googletag stub exists early (matching GPT's own
- * bootstrap pattern) and patches `cmd.push` to wrap queued callbacks.
- *
- * Current capabilities:
- *   - Installs a script guard that rewrites dynamically inserted GPT
- *     `<script>` elements to the first-party proxy endpoint.
- *   - Takes over the `googletag.cmd` array so that every callback runs
- *     through a wrapper that can inject targeting, logging, or consent
- *     signals before the real GPT processes the command.
- *
- * Future enhancements (driven by config or tsjs API):
- *   - Inject EC ID as page-level key-value targeting.
- *   - Gate ad requests on consent status.
- *   - Rewrite ad-unit paths for A/B testing.
- */
-
-const TS_INITIAL_TARGETING_KEY = 'ts_initial' as const;
-const TS_BID_TARGETING_KEYS = [
-  'hb_pb',
-  'hb_bidder',
-  'hb_adid',
-  'hb_cache_host',
-  'hb_cache_path',
-] as const;
-const TS_BASE_TARGETING_KEYS = [...TS_BID_TARGETING_KEYS, TS_INITIAL_TARGETING_KEY] as const;
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === 'string' && value.length > 0;
-}
-
-function trustedServerOpportunity(bid: AuctionBidData): GptDiagnosticsTrustedServerOpportunity {
-  const hasBidTargeting = TS_BID_TARGETING_KEYS.some((key) => isNonEmptyString(bid[key]));
-  if (!hasBidTargeting) return 'no_candidate';
-
-  const hasAdId = isNonEmptyString(bid.hb_adid);
-  const hasInline = isNonEmptyString(bid.adm);
-  const hasCache = isNonEmptyString(bid.hb_cache_host) && isNonEmptyString(bid.hb_cache_path);
-
-  return hasAdId && (hasInline || hasCache) ? 'renderable_candidate' : 'unrenderable_candidate';
-}
-
-// ------------------------------------------------------------------
-// googletag type stubs (minimal surface needed by the shim)
-// ------------------------------------------------------------------
-
-interface GoogleTagSlot {
-  getAdUnitPath(): string;
-  getSlotElementId(): string;
-  setTargeting(key: string, value: string | string[]): GoogleTagSlot;
-  clearTargeting?(key?: string): GoogleTagSlot;
-  addService(service: GoogleTagPubAdsService): GoogleTagSlot;
-  getTargeting?(key: string): string[];
-}
-
-interface SlotRenderEndedEvent {
-  isEmpty: boolean;
-  slot: GoogleTagSlot;
-}
-
-function findSlotElementByDivId(divId: string): HTMLElement | null {
-  return resolveSlotElementByDivId(divId).element;
-}
-
-function candidateSlotRoots(elementId: string): HTMLElement[] {
-  const roots: HTMLElement[] = [];
-  const slotEl = document.getElementById(elementId);
-  if (slotEl) {
-    roots.push(slotEl);
-  }
-
-  const container = document.getElementById(`${elementId}-container`);
-  if (container && !roots.includes(container)) {
-    roots.push(container);
-  }
-
-  return roots;
-}
-
-interface MessageSourceFrame {
-  iframe: HTMLIFrameElement;
-  root: HTMLElement;
-}
-
-function sourceFrameInRoots(
-  source: MessageEventSource | null,
-  roots: readonly HTMLElement[]
-): MessageSourceFrame | undefined {
-  if (!source) return undefined;
-  const matches = new Map<HTMLIFrameElement, HTMLElement>();
-  for (const root of roots) {
-    for (const iframe of root.querySelectorAll('iframe')) {
-      if (iframe.contentWindow === source && !matches.has(iframe)) matches.set(iframe, root);
-    }
-  }
-  if (matches.size !== 1) return undefined;
-  const [iframe, root] = matches.entries().next().value as [HTMLIFrameElement, HTMLElement];
-  return { iframe, root };
-}
-
-function sourceFrameForConfiguredDivId(
-  source: MessageEventSource | null,
-  divId: string
-): MessageSourceFrame | undefined {
-  const exact = document.getElementById(divId);
-  const candidates = exact
-    ? [exact]
-    : Array.from(document.querySelectorAll<HTMLElement>('[id]')).filter(
-        (element) => element.id.startsWith(divId) && !element.id.endsWith('-container')
-      );
-  const matches = candidates
-    .map((element) => sourceFrameInRoots(source, candidateSlotRoots(element.id)))
-    .filter((frame): frame is MessageSourceFrame => frame !== undefined);
-  return matches.length === 1 ? matches[0] : undefined;
-}
-
-function uniqueSourceFrame(
-  frames: Array<MessageSourceFrame | undefined>
-): MessageSourceFrame | undefined {
-  const matches = new Map<HTMLIFrameElement, MessageSourceFrame>();
-  for (const frame of frames) {
-    if (frame) matches.set(frame.iframe, frame);
-  }
-  return matches.size === 1 ? matches.values().next().value : undefined;
-}
-
-function sourceFrameForSlotId(
-  source: MessageEventSource | null,
-  slotId: string
-): MessageSourceFrame | undefined {
-  const mappedFrames = Object.entries(window.tsjs?.divToSlotId ?? {})
-    .filter(([, mappedSlotId]) => mappedSlotId === slotId)
-    .map(([elementId]) => sourceFrameInRoots(source, candidateSlotRoots(elementId)));
-  const configuredFrames = (window.tsjs?.adSlots ?? [])
-    .filter((slot) => slot.id === slotId)
-    .map((slot) => sourceFrameForConfiguredDivId(source, slot.div_id));
-  return uniqueSourceFrame([...mappedFrames, ...configuredFrames]);
-}
-
-interface MessageSourceSlotFrame extends MessageSourceFrame {
-  slotId: string;
-}
-
-function slotFrameForMessageSource(
-  source: MessageEventSource | null
-): MessageSourceSlotFrame | undefined {
-  const slotIds = new Set<string>();
-  for (const [elementId, slotId] of Object.entries(window.tsjs?.divToSlotId ?? {})) {
-    if (sourceFrameInRoots(source, candidateSlotRoots(elementId))) slotIds.add(slotId);
-  }
-  for (const slot of window.tsjs?.adSlots ?? []) {
-    if (sourceFrameForConfiguredDivId(source, slot.div_id)) slotIds.add(slot.id);
-  }
-  if (slotIds.size !== 1) return undefined;
-  const slotId = slotIds.values().next().value as string;
-  const frame = sourceFrameForSlotId(source, slotId);
-  return frame ? { ...frame, slotId } : undefined;
-}
-
-function sourceFrameForAdUnit(
-  source: MessageEventSource | null,
-  adUnitCode: string
-): MessageSourceFrame | undefined {
-  return sourceFrameForConfiguredDivId(source, adUnitCode);
-}
-
-function hasCollapsedDimension(element: HTMLElement, dimension: 'width' | 'height'): boolean {
-  const value = window.getComputedStyle(element)[dimension];
-  const match = /^(\d+(?:\.\d+)?)px$/.exec(value);
-  return match !== null && Number(match[1]) <= 1;
-}
-
-function usesFixedPositioning(element: HTMLElement): boolean {
-  const position = window.getComputedStyle(element).position;
-  return position === 'fixed' || position === 'sticky';
-}
-
-const MAX_CREATIVE_SHELL_DIMENSION = 10_000;
-
-function creativeFrameIsCurrent(
-  source: MessageEventSource | null,
-  frame: MessageSourceFrame,
-  generation: number,
-  stillOwnsCreative: () => boolean
-): boolean {
-  return (
-    (window.tsjs?.navGeneration ?? 0) === generation &&
-    stillOwnsCreative() &&
-    frame.iframe.isConnected &&
-    frame.root.isConnected &&
-    frame.root.contains(frame.iframe) &&
-    frame.iframe.contentWindow === source
-  );
-}
-
-/** Resize the authenticated source iframe and collapsed ancestors through its slot root. */
-function resizeCollapsedCreativeFrame(
-  source: MessageEventSource | null,
-  frame: MessageSourceFrame,
-  width: number,
-  height: number,
-  generation: number,
-  stillOwnsCreative: () => boolean
-): void {
-  if (
-    !creativeFrameIsCurrent(source, frame, generation, stillOwnsCreative) ||
-    !Number.isFinite(width) ||
-    !Number.isFinite(height) ||
-    width <= 0 ||
-    height <= 0 ||
-    width > MAX_CREATIVE_SHELL_DIMENSION ||
-    height > MAX_CREATIVE_SHELL_DIMENSION ||
-    frame.iframe.getAttribute('width') !== '1' ||
-    frame.iframe.getAttribute('height') !== '1' ||
-    !hasCollapsedDimension(frame.iframe, 'width') ||
-    !hasCollapsedDimension(frame.iframe, 'height') ||
-    usesFixedPositioning(frame.iframe) ||
-    frame.iframe.closest(
-      'ins[data-anchor-status], [data-google-interstitial], [data-vignette-loaded]'
-    )
-  ) {
-    return;
-  }
-
-  const collapsedAncestors: HTMLElement[] = [];
-  let reachedRoot = false;
-  for (let ancestor = frame.iframe.parentElement; ancestor; ancestor = ancestor.parentElement) {
-    if (
-      ancestor === document.body ||
-      ancestor === document.documentElement ||
-      !ancestor.isConnected ||
-      usesFixedPositioning(ancestor) ||
-      ancestor.matches(
-        'ins[data-anchor-status], [data-google-interstitial], [data-vignette-loaded]'
-      )
-    ) {
-      return;
-    }
-    if (hasCollapsedDimension(ancestor, 'width') || hasCollapsedDimension(ancestor, 'height')) {
-      collapsedAncestors.push(ancestor);
-    }
-    if (ancestor === frame.root) {
-      reachedRoot = true;
-      break;
-    }
-  }
-  if (!reachedRoot) return;
-
-  frame.iframe.width = String(width);
-  frame.iframe.height = String(height);
-  frame.iframe.style.width = `${width}px`;
-  frame.iframe.style.height = `${height}px`;
-  for (const ancestor of collapsedAncestors) {
-    ancestor.style.width = `${width}px`;
-    ancestor.style.height = `${height}px`;
-  }
-}
-
-function clearTargetingKeys(slot: GoogleTagSlot, keys: Iterable<string>): void {
-  if (typeof slot.clearTargeting !== 'function') return;
-
-  for (const key of new Set(keys)) {
-    slot.clearTargeting(key);
-  }
-}
-
-interface GoogleTagRefreshOptions {
-  changeCorrelator?: boolean;
-}
-
-interface GoogleTagPubAdsService {
-  setTargeting(key: string, value: string | string[]): GoogleTagPubAdsService;
-  getTargeting(key: string): string[];
-  enableSingleRequest(): void;
-  addEventListener(event: string, fn: (e: SlotRenderEndedEvent) => void): void;
-  refresh(slots?: GoogleTagSlot[], options?: GoogleTagRefreshOptions): void;
-  getSlots?(): GoogleTagSlot[];
-  disableInitialLoad?(): void;
-}
-
-interface GoogleTagConfig extends Record<string, unknown> {
-  disableInitialLoad?: boolean | null;
-}
-
-interface GoogleTagEffectiveConfig {
-  disableInitialLoad?: boolean;
-}
-
-type GoogleTagDisplayTarget = string | Element | GoogleTagSlot;
-
-interface GoogleTag {
-  cmd: Array<() => void>;
-  pubads(): GoogleTagPubAdsService;
-  defineSlot(
-    adUnitPath: string,
-    size: Array<number | number[]>,
-    elementId?: string
-  ): GoogleTagSlot | null;
-  destroySlots(slots?: GoogleTagSlot[]): boolean;
-  enableServices(): void;
-  display(target: GoogleTagDisplayTarget): void;
-  setConfig?(config: GoogleTagConfig): void;
-  getConfig?(keys: string | string[]): GoogleTagEffectiveConfig | undefined;
-  _loaded_?: boolean;
-}
-
-type GptWindow = Window & {
-  googletag?: Partial<GoogleTag>;
-  __tsjs_slim_prebid_url?: string;
-};
-
-const executingPublisherScript = typeof document === 'undefined' ? null : document.currentScript;
-
-// ------------------------------------------------------------------
-// Shim implementation
-// ------------------------------------------------------------------
-
-/**
- * Ensure the `googletag` stub exists on `window`.
- *
- * This mirrors the official GPT bootstrap snippet:
- * ```js
- * window.googletag = window.googletag || {};
- * googletag.cmd = googletag.cmd || [];
- * ```
- * By running before the publisher's own snippet we can patch `cmd` early.
- */
-function ensureGoogleTagStub(win: GptWindow): Partial<GoogleTag> {
-  const tag = (win.googletag = win.googletag ?? {});
-  tag.cmd = tag.cmd ?? [];
-  return tag;
-}
-
-function installTrustedServerPageTargeting(): void {
-  if (executingPublisherScript?.getAttribute('data-ts-gam-attribution') !== 'true') {
-    return;
-  }
-
-  const win = window as GptWindow;
-  const tag = ensureGoogleTagStub(win);
-  tag.cmd!.push(() => {
-    try {
-      const gpt = win.googletag;
-      if (typeof gpt?.setConfig === 'function') {
-        gpt.setConfig({ targeting: { ts: 'true' } });
-      }
-    } catch (error) {
-      log.warn('[tsjs-gpt] GAM attribution targeting failed', error);
-    }
-  });
-}
-
-/**
- * Wrap a queued GPT callback to add instrumentation and future hook points.
- *
- * Today the wrapper only logs; as the integration matures it will inject
- * EC ID targeting and consent gates.
- */
-function wrapCommand(fn: () => void): () => void {
-  return () => {
-    try {
-      fn();
-    } catch (err) {
-      log.error('GPT shim: queued command threw', err);
-    }
-  };
-}
-
-/**
- * Patch `googletag.cmd` so every pushed callback runs through [`wrapCommand`].
- *
- * Preserves the existing `tag.cmd` array identity so that GPT's own custom
- * `cmd.push` behaviour (immediate execution when the library is already
- * loaded) is not lost. The original `push` is saved and delegated to after
- * wrapping each callback.
- *
- * Already-queued callbacks are re-wrapped in place so GPT processes them
- * through our wrapper when it drains the queue.
- */
-function patchCommandQueue(tag: Partial<GoogleTag>): void {
-  // Ensure the queue exists.
-  if (!tag.cmd) {
-    // Cast through unknown so an array satisfies the { push } type.
-    tag.cmd = [];
-  }
-
-  const queue = tag.cmd;
-
-  // Guard against double-patching (idempotent install).
-  if ((queue as { __tsPushed?: boolean }).__tsPushed) {
-    log.debug('GPT shim: command queue already patched, skipping');
-    return;
-  }
-
-  const originalPush = queue.push.bind(queue);
-
-  // Override push on the *existing* array — preserves object identity so
-  // GPT (if already loaded) keeps its reference.
-  (queue as { push: (...cbs: Array<() => void>) => unknown }).push = function (
-    ...callbacks: Array<() => void>
-  ): unknown {
-    const wrapped = callbacks.map(wrapCommand);
-    return originalPush(...wrapped);
-  };
-
-  // Mark as patched to prevent double-wrapping.
-  (queue as { __tsPushed?: boolean }).__tsPushed = true;
-
-  // Re-wrap any callbacks that were queued before we patched.
-  // Only applicable when cmd is an array (pre-GPT-load case).
-  if (Array.isArray(queue)) {
-    for (let i = 0; i < queue.length; i++) {
-      queue[i] = wrapCommand(queue[i]);
-    }
-    log.debug('GPT shim: command queue patched', { pendingCommands: queue.length });
-  } else {
-    log.debug('GPT shim: command queue patched');
-  }
-}
-
-/**
- * Install the GPT integration shim.
- *
- * Sets up the script guard for dynamic script interception and patches the
- * `googletag.cmd` command queue.
- */
-export function installGptShim(): boolean {
-  if (typeof window === 'undefined') {
-    return false;
-  }
-
-  const win = window as GptWindow;
-
-  // Install DOM interception guard first so any dynamic GPT script insertions
-  // are rewritten before the browser fetches them.
-  installGptGuard();
-
-  const tag = ensureGoogleTagStub(win);
-  patchCommandQueue(tag);
-
-  log.info('GPT shim installed');
-  return true;
-}
-
-// ------------------------------------------------------------------
-// GAM interceptor (testing only)
-// ------------------------------------------------------------------
-
-/**
- * Sandbox token list for debug ADM fallback iframes.
- *
- * Deliberately excludes `allow-same-origin`: combined with `allow-scripts` on
- * srcdoc (or first-party src) content, that pair effectively removes the
- * sandbox's origin isolation and would let SSP-provided markup run with the
- * publisher origin's privileges.
- */
-export const ADM_IFRAME_SANDBOX = 'allow-scripts allow-popups allow-forms';
-
-/**
- * Resolve an ADM-extracted iframe src to a safe, loadable URL.
- *
- * Protocol-relative URLs are upgraded to https. Only http(s) URLs (including
- * page-relative paths, which resolve against the page origin) are accepted —
- * anything else (javascript:, data:, blob:, …) is rejected so SSP-provided
- * markup cannot smuggle a script-executing URL into the unsandboxed GAM
- * iframe.
- */
-export function safeAdmIframeSrc(src: string): string | undefined {
-  const resolved = src.startsWith('//') ? `https:${src}` : src;
-  try {
-    const parsed = new URL(resolved, window.location.href);
-    if (parsed.protocol === 'https:' || parsed.protocol === 'http:') {
-      return resolved;
-    }
-  } catch {
-    // Unparseable URL — treat as unsafe.
-  }
-  return undefined;
-}
-
-/**
- * Replace the GAM-rendered creative with the server-side auction adm.
- *
- * Adapted from PR #241 (github.com/IABTechLab/trusted-server/pull/241).
- * Instead of reading from pbjs, reads adm directly from window.tsjs.bids.
- *
- * This is the testing-only direct-replace path that bypasses GAM entirely. The
- * sanitized `adm` now ships in production for the pbRender bridge, so `adm`
- * presence no longer gates it; the caller gates on the per-bid `debug_bid`
- * signal (present only under `inject_adm_for_testing`) instead.
- *
- * Strategy:
- * 1. If adm contains an <iframe src="..."> with a safe http(s) src, set that
- *    src on the GAM iframe directly — avoids cross-origin document access.
- * 2. Otherwise replace the slot element's content with a sandboxed srcdoc
- *    iframe (no `allow-same-origin` — see [ADM_IFRAME_SANDBOX]).
- */
-function injectAdmIntoSlot(divId: string, adm: string): void {
-  try {
-    // divId may be the container div (used by GPT slot) or the inner div.
-    // Resolve it the same way the rest of adInit does (exact then prefix) so
-    // a config div_id prefix with a render-time suffix still finds the element.
-    const slotEl = findSlotElementByDivId(divId);
-    if (!slotEl) return;
-
-    // Extract the first iframe src from the adm (e.g. mocktioneer creative
-    // wraps a first-party proxy iframe in a div). Reject non-http(s) schemes.
-    const srcMatch = adm.match(/<iframe[^>]+\bsrc=["']([^"']+)["']/i);
-    const innerSrc = srcMatch?.[1] ? safeAdmIframeSrc(srcMatch[1]) : undefined;
-    const gamIframe = slotEl.querySelector('iframe') as HTMLIFrameElement | null;
-
-    if (innerSrc && gamIframe) {
-      // Set the GAM iframe src — works even cross-origin (no document access needed).
-      gamIframe.src = innerSrc;
-      log.debug(`[tsjs-gpt] gam-intercept: set iframe src for '${divId}'`);
-    } else if (innerSrc) {
-      // GAM iframe not yet in DOM (APS renders async after slotRenderEnded).
-      // Retry on next animation frame so APS has a tick to insert its iframe;
-      // if it still isn't there, replace slot content directly.
-      requestAnimationFrame(() => {
-        const retryIframe = slotEl!.querySelector('iframe') as HTMLIFrameElement | null;
-        if (retryIframe) {
-          retryIframe.src = innerSrc;
-          log.debug(`[tsjs-gpt] gam-intercept: set iframe src (retry) for '${divId}'`);
-        } else {
-          slotEl!.innerHTML = '';
-          const f = document.createElement('iframe');
-          f.style.cssText = 'border:none';
-          f.width = String(slotEl!.offsetWidth || 728);
-          f.height = String(slotEl!.offsetHeight || 90);
-          f.setAttribute('sandbox', ADM_IFRAME_SANDBOX);
-          f.src = innerSrc;
-          slotEl!.appendChild(f);
-          log.debug(`[tsjs-gpt] gam-intercept: inserted src iframe for '${divId}'`);
-        }
-      });
-    } else {
-      // No extractable safe src — replace slot content with a sandboxed srcdoc iframe.
-      slotEl.innerHTML = '';
-      const f = document.createElement('iframe');
-      f.style.border = 'none';
-      f.width = String(slotEl.offsetWidth || 728);
-      f.height = String(slotEl.offsetHeight || 90);
-      f.setAttribute('sandbox', ADM_IFRAME_SANDBOX);
-      f.srcdoc = adm;
-      slotEl.appendChild(f);
-      log.debug(`[tsjs-gpt] gam-intercept: replaced slot content for '${divId}'`);
-    }
-  } catch (err) {
-    log.warn('[tsjs-gpt] gam-intercept: error injecting adm', err);
-  }
-}
-
-function fireWinBillingBeacons(slotId: string, bid: AuctionBidData): void {
-  if (!slotId || (!bid.nurl && !bid.burl)) return;
-
-  const fired = (window.tsjs!.firedBeacons ??= {});
-  const bidIdentity = bid.hb_adid ?? bid.nurl ?? bid.burl ?? '';
-  const urls = [
-    ['nurl', bid.nurl],
-    ['burl', bid.burl],
-  ] as const;
-
-  for (const [kind, url] of urls) {
-    if (!url) continue;
-
-    const beaconKey = `${slotId}|${bidIdentity}|${kind}|${url}`;
-    if (fired[beaconKey]) continue;
-
-    if (queueWinBillingBeacon(url)) {
-      fired[beaconKey] = true;
-    }
-  }
-}
-
-function queueWinBillingBeacon(url: string): boolean {
-  if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
-    try {
-      if (navigator.sendBeacon(url)) {
-        return true;
-      }
-    } catch (err) {
-      log.warn('[tsjs-gpt] win/billing sendBeacon failed', err);
-    }
-  }
-
-  if (typeof fetch === 'function') {
-    try {
-      void fetch(url, { method: 'POST', keepalive: true, mode: 'no-cors' });
-      return true;
-    } catch (err) {
-      log.warn('[tsjs-gpt] win/billing fetch fallback failed', err);
-    }
-  }
-
-  return false;
-}
-
-// ------------------------------------------------------------------
-// Trusted Server ad-init
-// ------------------------------------------------------------------
-
-/**
- * Install `window.tsjs.adInit`.
- *
- * Reads `window.tsjs.adSlots` (injected at head-open) and `window.tsjs.bids`
- * (injected before </body>) synchronously — no fetch, no Promise. Applies bid
- * targeting to GPT slots, sets the `ts_initial` sentinel, then calls refresh().
- * Win/billing beacons fire from the TS render bridge after a matching Prebid
- * Universal Creative request selects the TS bid and markup is successfully posted
- * to its MessagePort. Neither observation proves that PUC consumed the response or
- * that the creative rendered pixels.
- *
- * Idempotent: destroys previously created TS-managed slots before redefining them,
- * so it is safe to call again after SPA navigation updates `tsjs.adSlots`/`tsjs.bids`.
- */
-/**
- * Track whether the publisher disabled GPT initial load.
- *
- * Read GPT's effective state through `getConfig()` when available and wrap both
- * configuration APIs so changes are synchronized immediately. The wrappers also
- * provide a fallback for runtimes where the getter is unavailable. With initial
- * load disabled, `display()` only registers a slot — the ad request
- * must come from a later `refresh()`. adInit() reads this to refresh its own
- * freshly defined slots so they are not left blank.
- *
- * Installed via the command queue so it runs before the publisher's own GPT
- * configuration (the TS core script is injected ahead of the publisher's GPT
- * setup). Idempotent per googletag object and pubads service.
- *
- * Only hooks an existing `googletag` stub — it never creates one. A plain module
- * import that does not activate the GPT integration must not touch
- * `window.googletag`. When the GPT shim is active it creates the stub before
- * `installTsAdInit` runs, so the detector is still queued ahead of the
- * publisher's GPT setup.
- */
-function syncInitialLoadDisabled(gpt: Partial<GoogleTag>, ts: TsjsApi): boolean {
-  if (typeof gpt.getConfig !== 'function') return false;
-
-  const config = gpt.getConfig('disableInitialLoad');
-  if (!config || config.disableInitialLoad === undefined) return false;
-
-  ts.gptInitialLoadDisabled = config.disableInitialLoad === true;
-  return true;
-}
-
-function installInitialLoadDetector(ts: TsjsApi): void {
-  const win = window as GptWindow;
-  const cmd = win.googletag?.cmd;
-  if (!cmd) return;
-  cmd.push(() => {
-    const gpt = win.googletag as
-      | (Partial<GoogleTag> & { __tsInitialLoadConfigHooked?: boolean })
-      | undefined;
-    if (!gpt) return;
-
-    syncInitialLoadDisabled(gpt, ts);
-
-    if (typeof gpt.setConfig === 'function' && !gpt.__tsInitialLoadConfigHooked) {
-      const originalSetConfig = gpt.setConfig.bind(gpt);
-      gpt.setConfig = function (...args: Parameters<typeof originalSetConfig>) {
-        const config = args[0];
-        const result = originalSetConfig(...args);
-        if (!syncInitialLoadDisabled(gpt, ts) && config && 'disableInitialLoad' in config) {
-          ts.gptInitialLoadDisabled = config.disableInitialLoad === true;
-        }
-        return result;
-      };
-      gpt.__tsInitialLoadConfigHooked = true;
-    }
-
-    const pubads = gpt.pubads?.();
-    if (!pubads) return;
-    const service = pubads as GoogleTagPubAdsService & { __tsInitialLoadHooked?: boolean };
-    if (typeof service.disableInitialLoad !== 'function' || service.__tsInitialLoadHooked) {
-      return;
-    }
-    const originalDisableInitialLoad = service.disableInitialLoad.bind(service);
-    service.disableInitialLoad = function () {
-      const result = originalDisableInitialLoad();
-      if (!syncInitialLoadDisabled(gpt, ts)) {
-        ts.gptInitialLoadDisabled = true;
-      }
-      return result;
-    };
-    service.__tsInitialLoadHooked = true;
-  });
-}
-
-/**
- * Install `window.tsjs.scheduleInitialAdInit`.
- *
- * The server-injected `</body>` bids script calls this to run the initial
- * `adInit()` after React hydration instead of synchronously at body-parse
- * time. `adInit()` defines GPT slots on the publisher's `-container`
- * wrappers, mutating those ad-slot subtrees; on a Next.js App Router page a
- * synchronous call lands that mutation inside React's hydration window and
- * trips a #418 hydration mismatch. Deferral: gate on window `load` (the
- * client bundles that hydrate the tree have executed by then), then a double
- * `requestAnimationFrame` so the call runs after React has committed. A
- * single deferred call — no retry timer.
- *
- * The SSR document is navigation generation 0 by definition, so the scheduler
- * pins the whole initial pass to generation 0 rather than capturing whatever
- * the counter reads when the `</body>` script runs: the SPA hook is installed
- * by the synchronous head bundle, so a navigation can commit while the HTML
- * is still streaming, and capturing that advanced value would adopt the stale
- * SSR bootstrap as current. For the same reason the initial bids payload is
- * passed in and applied here, generation-guarded — assigning it
- * unconditionally at body end would clobber the live bids a faster SPA
- * navigation already applied.
- *
- * Shared-template seams pass `initialSlots`; inline documents omit them because
- * their head script already installed the slots. An explicit empty array clears
- * that state, while omission preserves it. The scheduler accepts only its first
- * generation-0 call so duplicate public API calls cannot define and display the
- * initial slots twice. The latch lives on `tsjs` so a bootstrap fallback that
- * claims the initial pass keeps that claim when the bundle replaces its
- * scheduler. If a navigation commits before scheduling or before the deferred
- * callback, the SSR payload and `adInit()` are both dropped. The generation
- * counter (not a URL comparison) keeps this aligned with the SPA auction hook's
- * navigation identity.
- *
- * Hidden documents: browsers do not service `requestAnimationFrame` while a
- * document is hidden, so a background-tab load (Cmd+click, open-in-new-tab)
- * holds the initial `adInit()` until the tab is first viewed. This is
- * intended, not an oversight: the initial ad request then spends its
- * impression on a tab someone is actually looking at instead of firing —
- * unviewable — at parse time in a tab that may never be foregrounded, and
- * riding rAF keeps a single code path whose post-hydration-commit guarantee
- * holds whenever the request is actually issued.
- */
-function installScheduleInitialAdInit(ts: TsjsApi): void {
-  ts.scheduleInitialAdInit = function (
-    initialBids?: Record<string, AuctionBidData>,
-    initialSlots?: AuctionSlot[]
-  ) {
-    if ((ts.navGeneration ?? 0) !== 0 || ts.initialAdInitScheduled) return;
-    ts.initialAdInitScheduled = true;
-    if (initialSlots !== undefined) ts.adSlots = initialSlots;
-    if (initialBids !== undefined) ts.bids = initialBids;
-    const runUnlessNavigated = (): void => {
-      if ((ts.navGeneration ?? 0) !== 0) return;
-      ts.adInit?.();
-    };
-    const afterHydrationFrames = (): void => {
-      window.requestAnimationFrame(() => {
-        window.requestAnimationFrame(runUnlessNavigated);
-      });
-    };
-    if (document.readyState === 'complete') {
-      afterHydrationFrames();
-    } else {
-      window.addEventListener('load', afterHydrationFrames, { once: true });
-    }
-  };
-}
-
-interface HandoffPatchedFunction {
-  __tsSlotHandoffPatched?: boolean;
-}
-
-function findGptSlotByElementId(
-  pubads: GoogleTagPubAdsService,
-  elementId: string
-): GoogleTagSlot | undefined {
-  return pubads.getSlots?.().find((slot) => slot.getSlotElementId() === elementId);
-}
-
-function handoffForSlot(ts: TsjsApi, slot: GoogleTagSlot): GptSlotHandoff | undefined {
-  return ts.gptSlotHandoffs?.[slot.getSlotElementId()];
-}
-
-function displayTargetElementId(target: GoogleTagDisplayTarget): string | undefined {
-  if (typeof target === 'string') return target;
-  if (typeof (target as GoogleTagSlot).getSlotElementId === 'function') {
-    return (target as GoogleTagSlot).getSlotElementId();
-  }
-  return (target as Element).id || undefined;
-}
-
-function normalizedGptFormats(formats: Array<number | number[]>): Array<number | number[]> {
-  return formats.length === 2 && formats.every((format) => typeof format === 'number')
-    ? [formats as number[]]
-    : formats;
-}
-
-function handoffFormatsMatch(handoff: GptSlotHandoff, formats: Array<number | number[]>): boolean {
-  return JSON.stringify(handoff.formats) === JSON.stringify(normalizedGptFormats(formats));
-}
-
-function matchingHandoff(
-  ts: TsjsApi,
-  pubads: GoogleTagPubAdsService,
-  adUnitPath: string,
-  formats: Array<number | number[]>,
-  elementId: string
-): GptSlotHandoff | undefined {
-  const exact = ts.gptSlotHandoffs?.[elementId];
-  if (exact) return exact.publisherClaimed ? undefined : exact;
-
-  const candidates = new Set(Object.values(ts.gptSlotHandoffs ?? {})).values();
-  const matching = Array.from(candidates).filter(
-    (handoff) =>
-      !handoff.publisherClaimed &&
-      !document.getElementById(handoff.slotElementId) &&
-      elementId.startsWith(handoff.divIdPrefix) &&
-      handoff.gamUnitPath === adUnitPath &&
-      handoffFormatsMatch(handoff, formats) &&
-      findGptSlotByElementId(pubads, handoff.slotElementId)
-  );
-  return matching.length === 1 ? matching[0] : undefined;
-}
-
-function registerHandoffAlias(ts: TsjsApi, elementId: string, handoff: GptSlotHandoff): void {
-  (ts.gptSlotHandoffs ??= {})[elementId] = handoff;
-}
-
-function withGptSlotHandoffInternal<T>(ts: TsjsApi, callback: () => T): T {
-  const wasInternal = ts.gptSlotHandoffInternal;
-  ts.gptSlotHandoffInternal = true;
-  try {
-    return callback();
-  } finally {
-    ts.gptSlotHandoffInternal = wasInternal;
-  }
-}
-
-/**
- * Reuse a TS-created inner-div slot when its publisher defines that div later.
- *
- * TS cannot wait an arbitrary amount of time for framework hydration: doing so
- * would leave placements blank when no publisher slot is ever defined. Instead,
- * TS creates its fallback on the publisher's actual div and aliases only a later
- * `defineSlot()` for that exact div, or for a hydration-renamed replacement after
- * the original div is gone. The first duplicate publisher request is suppressed
- * because TS has already issued the initial request with TS targeting.
- */
-function installLatePublisherSlotHandoff(ts: TsjsApi): void {
-  const win = window as GptWindow;
-  const cmd = win.googletag?.cmd;
-  if (!cmd) return;
-
-  cmd.push(() => {
-    const g = win.googletag;
-    const pubads = g?.pubads?.();
-    if (!g?.defineSlot || !g.display || !pubads) return;
-
-    const defineSlot = g.defineSlot;
-    if (!(defineSlot as HandoffPatchedFunction).__tsSlotHandoffPatched) {
-      const originalDefineSlot = defineSlot.bind(g);
-      const patchedDefineSlot = (
-        adUnitPath: string,
-        formats: Array<number | number[]>,
-        elementId?: string
-      ): GoogleTagSlot | null => {
-        if (!ts.gptSlotHandoffInternal && typeof elementId === 'string') {
-          const handoff = matchingHandoff(ts, pubads, adUnitPath, formats, elementId);
-          if (handoff) {
-            const existingSlot = findGptSlotByElementId(pubads, handoff.slotElementId);
-            if (existingSlot) {
-              registerHandoffAlias(ts, elementId, handoff);
-              handoff.publisherClaimed = true;
-              // The supported publisher lifecycle is defineSlot → addService → display.
-              // Intentionally wait for that display instead of applying a time heuristic.
-              handoff.suppressPublisherDisplay = true;
-              handoff.suppressPublisherRefresh = ts.gptInitialLoadDisabled === true;
-              ts.prevGptSlots = (ts.prevGptSlots ?? []).filter(
-                (ownedSlot) => ownedSlot !== existingSlot
-              );
-              if (handoff.gamUnitPath !== adUnitPath || !handoffFormatsMatch(handoff, formats)) {
-                log.warn('GPT slot handoff: publisher definition differs from TS configuration', {
-                  elementId,
-                  tsGamUnitPath: handoff.gamUnitPath,
-                  publisherGamUnitPath: adUnitPath,
-                });
-              }
-              return existingSlot;
-            }
-          }
-        }
-        return elementId === undefined
-          ? originalDefineSlot(adUnitPath, formats)
-          : originalDefineSlot(adUnitPath, formats, elementId);
-      };
-      (patchedDefineSlot as HandoffPatchedFunction).__tsSlotHandoffPatched = true;
-      g.defineSlot = patchedDefineSlot;
-    }
-
-    const display = g.display;
-    if (!(display as HandoffPatchedFunction).__tsSlotHandoffPatched) {
-      const originalDisplay = display.bind(g);
-      const patchedDisplay = (target: GoogleTagDisplayTarget): void => {
-        const elementId = displayTargetElementId(target);
-        const handoff = elementId ? ts.gptSlotHandoffs?.[elementId] : undefined;
-        if (!ts.gptSlotHandoffInternal && handoff?.suppressPublisherDisplay) {
-          handoff.suppressPublisherDisplay = false;
-          return;
-        }
-        originalDisplay(target);
-      };
-      (patchedDisplay as HandoffPatchedFunction).__tsSlotHandoffPatched = true;
-      g.display = patchedDisplay;
-    }
-
-    const refresh = pubads.refresh;
-    if (!(refresh as HandoffPatchedFunction).__tsSlotHandoffPatched) {
-      const originalRefresh = refresh.bind(pubads);
-      const callRefresh = (
-        slots: GoogleTagSlot[] | undefined,
-        options: GoogleTagRefreshOptions | undefined
-      ): void => {
-        if (options === undefined) {
-          originalRefresh(slots);
-        } else {
-          originalRefresh(slots, options);
-        }
-      };
-      const patchedRefresh = (
-        requestedSlots?: GoogleTagSlot[],
-        options?: GoogleTagRefreshOptions
-      ): void => {
-        if (ts.gptSlotHandoffInternal) {
-          callRefresh(requestedSlots, options);
-          return;
-        }
-
-        const slots = requestedSlots ?? pubads.getSlots?.();
-        if (!slots) {
-          callRefresh(requestedSlots, options);
-          return;
-        }
-
-        let suppressed = false;
-        const remainingSlots = slots.filter((slot) => {
-          const handoff = handoffForSlot(ts, slot);
-          if (!handoff?.suppressPublisherRefresh) return true;
-          handoff.suppressPublisherRefresh = false;
-          suppressed = true;
-          return false;
-        });
-        if (!suppressed) {
-          callRefresh(requestedSlots, options);
-        } else if (remainingSlots.length > 0) {
-          callRefresh(remainingSlots, options);
-        }
-      };
-      (patchedRefresh as HandoffPatchedFunction).__tsSlotHandoffPatched = true;
-      pubads.refresh = patchedRefresh;
-    }
-  });
-}
-
-function installFirstImpressionLifecycleObservers(ts: TsjsApi, g: Partial<GoogleTag>): void {
-  if (ts.firstImpressionListenersInstalled) return;
-  g.cmd?.push(() => {
-    if (ts.firstImpressionListenersInstalled) return;
-    const pubads = g.pubads?.();
-    if (!pubads?.addEventListener) return;
-
-    const observe =
-      (phase: 'requested' | 'rendered') =>
-      (event: SlotRenderEndedEvent): void => {
-        const elementId = event.slot?.getSlotElementId?.();
-        const element = elementId ? document.getElementById(elementId) : null;
-        if (element) observeFirstImpressionGptLifecycle(ts, element, phase);
-      };
-    pubads.addEventListener('slotRequested', observe('requested'));
-    pubads.addEventListener('slotRenderEnded', observe('rendered'));
-    ts.firstImpressionListenersInstalled = true;
-  });
-}
-
-function trustedServerTargeting(
-  slot: AuctionSlot,
-  bid: AuctionBidData
-): Record<string, string | string[]> {
-  const targeting: Record<string, string | string[]> = { ...(slot.targeting ?? {}) };
-  for (const key of TS_BID_TARGETING_KEYS) {
-    if (bid[key]) targeting[key] = String(bid[key]);
-  }
-  targeting[TS_INITIAL_TARGETING_KEY] = '1';
-  return targeting;
-}
-
-function applyTrustedServerTargeting(
-  ts: TsjsApi,
-  gptSlot: GoogleTagSlot,
-  slot: AuctionSlot,
-  bid: AuctionBidData,
-  elementIds: readonly string[]
-): string[] {
-  const previousKeys = ts.prevSlotTargetingKeys ?? {};
-  clearTargetingKeys(gptSlot, [
-    ...TS_BASE_TARGETING_KEYS,
-    ...elementIds.flatMap((elementId) => previousKeys[elementId] ?? []),
-  ]);
-  const targeting = trustedServerTargeting(slot, bid);
-  for (const [key, value] of Object.entries(targeting)) gptSlot.setTargeting(key, value);
-  const element = document.getElementById(elementIds[0]!);
-  const claim = element ? firstImpressionClaim(ts, element) : undefined;
-  if (claim?.owner === 'trusted_server') claim.targeting = targeting;
-  return Object.keys(slot.targeting ?? {});
-}
-
-function clearPreviousNavigationTargeting(ts: TsjsApi, g: Partial<GoogleTag>): void {
-  const previousKeys = ts.prevSlotTargetingKeys ?? {};
-  const touchedElementIds = new Set([
-    ...Object.keys(previousKeys),
-    ...Object.keys(ts.divToSlotId ?? {}),
-  ]);
-
-  const pubads = g.pubads?.();
-  if (pubads && touchedElementIds.size > 0) {
-    for (const slot of pubads.getSlots?.() ?? []) {
-      const elementId = slot.getSlotElementId();
-      if (!touchedElementIds.has(elementId)) continue;
-      clearTargetingKeys(slot, [...TS_BASE_TARGETING_KEYS, ...(previousKeys[elementId] ?? [])]);
-    }
-  }
-
-  ts.prevSlotTargetingKeys = {};
-  ts.divToSlotId = {};
-}
-
-function schedulePublisherFirstImpressionFallback(
-  ts: TsjsApi,
-  g: Partial<GoogleTag>,
-  slot: AuctionSlot,
-  bid: AuctionBidData,
-  element: HTMLElement,
-  generation: number
-): void {
-  if (!reservePublisherFirstImpressionFallback(ts, element)) return;
-
-  const retry = (): void => {
-    if (
-      (ts.navGeneration ?? 0) !== generation ||
-      !element.isConnected ||
-      document.getElementById(element.id) !== element
-    ) {
-      return;
-    }
-    const delay = publisherFirstImpressionRetryDelay(ts, element);
-    if (delay === undefined) return;
-    if (delay > 0) {
-      window.setTimeout(retry, delay + 1);
-      return;
-    }
-
-    g.cmd?.push(() => {
-      if (
-        (ts.navGeneration ?? 0) !== generation ||
-        !element.isConnected ||
-        document.getElementById(element.id) !== element
-      ) {
-        return;
-      }
-      const claim = claimFirstImpressionForTrustedServer(ts, element);
-      if (!claim) return;
-
-      const pubads = g.pubads?.();
-      if (!pubads) {
-        releaseTrustedServerFirstImpressionClaim(ts, element, claim);
-        return;
-      }
-      let gptSlot = pubads
-        .getSlots?.()
-        .find((candidate) => candidate.getSlotElementId() === element.id);
-      let tsOwned = false;
-      if (!gptSlot) {
-        gptSlot =
-          withGptSlotHandoffInternal(ts, () =>
-            g.defineSlot?.(slot.gam_unit_path, slot.formats, element.id)
-          ) ?? undefined;
-        if (!gptSlot) {
-          releaseTrustedServerFirstImpressionClaim(ts, element, claim);
-          return;
-        }
-        gptSlot.addService(pubads);
-        tsOwned = true;
-        (ts.gptSlotHandoffs ??= {})[element.id] = {
-          gamUnitPath: slot.gam_unit_path,
-          formats: slot.formats,
-          divIdPrefix: slot.div_id,
-          slotElementId: element.id,
-          publisherClaimed: false,
-          suppressPublisherDisplay: false,
-          suppressPublisherRefresh: false,
-        };
-      }
-
-      const slotElementId = gptSlot.getSlotElementId?.() ?? element.id;
-      const targetingKeys = applyTrustedServerTargeting(ts, gptSlot, slot, bid, [
-        element.id,
-        slotElementId,
-      ]);
-      (ts.divToSlotId ??= {})[element.id] = slot.id;
-      if (slotElementId !== element.id) ts.divToSlotId[slotElementId] = slot.id;
-      (ts.prevSlotTargetingKeys ??= {})[element.id] = targetingKeys;
-      if (slotElementId !== element.id) ts.prevSlotTargetingKeys[slotElementId] = targetingKeys;
-      if (tsOwned) (ts.prevGptSlots ??= []).push(gptSlot);
-
-      try {
-        ts.gptDiagnosticsRecorder?.recordTrustedServerOpportunity(
-          gptSlot,
-          slot.id,
-          trustedServerOpportunity(bid),
-          bid.hb_auction_id,
-          slot.formats
-        );
-      } catch {
-        // Diagnostics must not alter fallback delivery.
-      }
-
-      if (!ts.servicesEnabled) {
-        pubads.enableSingleRequest();
-        g.enableServices?.();
-        ts.servicesEnabled = true;
-      }
-      if (tsOwned) withGptSlotHandoffInternal(ts, () => g.display?.(slotElementId));
-      syncInitialLoadDisabled(g, ts);
-      if (!tsOwned || ts.gptInitialLoadDisabled) {
-        ts.adInitRefreshInProgress = true;
-        try {
-          withGptSlotHandoffInternal(ts, () => pubads.refresh([gptSlot!]));
-        } finally {
-          ts.adInitRefreshInProgress = false;
-        }
-      }
-    });
-  };
-
-  retry();
-}
-
-export function installTsAdInit(): void {
-  const ts = (window.tsjs ??= {} as TsjsApi);
-  installInitialLoadDetector(ts);
-  installScheduleInitialAdInit(ts);
-
-  const g = (window as GptWindow).googletag;
-  if (g) installFirstImpressionLifecycleObservers(ts, g);
-  installLatePublisherSlotHandoff(ts);
-  ts.adInit = function () {
-    const slots = ts.adSlots ?? [];
-    // Snapshot bids at adInit() call time — correct for targeting setup.
-    // The slotRenderEnded listener below reads ts.bids live so SPA navigation
-    // updates (new ts.bids injected before </body>) are picked up at render time.
-    const bids = ts.bids ?? {};
-    // Generation this invocation belongs to. The destructive slot work below
-    // is queued on googletag.cmd, which only drains when GPT itself loads —
-    // possibly much later (e.g. consent-gated GPT). A navigation can commit
-    // in that gap, so the queued callback rechecks the generation as its
-    // first act and stands down rather than applying this invocation's
-    // slots/bids to the newer route's DOM and double-requesting it.
-    const generation = ts.navGeneration ?? 0;
-    const g = (window as GptWindow).googletag;
-    if (!g) return;
-    installFirstImpressionLifecycleObservers(ts, g);
-    const warnedResolutionFailures = new Set<string>();
-
-    g.cmd?.push(() => {
-      if ((ts.navGeneration ?? 0) !== generation) return;
-      // Destroy previously defined TS slots before redefining for the new page.
-      if (ts.prevGptSlots && ts.prevGptSlots.length > 0) {
-        const destroyedSlotElementIds = new Set(
-          (ts.prevGptSlots as GoogleTagSlot[]).map((slot) => slot.getSlotElementId())
-        );
-        g.destroySlots?.(ts.prevGptSlots as GoogleTagSlot[]);
-        if (ts.gptSlotHandoffs) {
-          for (const [elementId, handoff] of Object.entries(ts.gptSlotHandoffs)) {
-            if (destroyedSlotElementIds.has(handoff.slotElementId)) {
-              delete ts.gptSlotHandoffs[elementId];
-            }
-          }
-        }
-        ts.prevGptSlots = [];
-      }
-
-      // Slots TS defined itself — tracked for SPA destroy. Publisher-owned
-      // slots are reused but never destroyed by TS on navigation.
-      const newSlots: GoogleTagSlot[] = [];
-      // Publisher-owned slots TS reused — refreshed to pick up server-side
-      // targeting. The publisher already display()ed these.
-      const slotsToRefresh: GoogleTagSlot[] = [];
-      // Element IDs of slots TS defined itself this call. GPT requires a
-      // display() call to register/render a freshly-defined slot; refresh()
-      // alone no-ops for a slot that was never displayed, so these are
-      // display()ed instead of refreshed.
-      const slotsToDisplay: string[] = [];
-      const divToSlotId: Record<string, string> = {};
-      const prevSlotTargetingKeys = ts.prevSlotTargetingKeys ?? {};
-      const nextSlotTargetingKeys: Record<string, string[]> = {};
-
-      // Clear TS-managed targeting from every previously TS-touched GPT slot
-      // before applying the current route. Without this sweep, navigating to a
-      // route with no matching TS slots (or one where a previously touched
-      // publisher-owned slot is absent from the new slot list) leaves stale
-      // hb_* / ts_initial / route targeting that later publisher refreshes
-      // would reuse.
-      const prevTouchedDivIds = new Set([
-        ...Object.keys(prevSlotTargetingKeys),
-        ...Object.keys(ts.divToSlotId ?? {}),
-      ]);
-      if (prevTouchedDivIds.size > 0) {
-        (g.pubads!().getSlots?.() ?? []).forEach((gptSlot: GoogleTagSlot) => {
-          const elementId = gptSlot.getSlotElementId();
-          if (!prevTouchedDivIds.has(elementId)) return;
-          const element = document.getElementById(elementId);
-          if (element && firstImpressionClaim(ts, element)) return;
-          clearTargetingKeys(gptSlot, [
-            ...TS_BASE_TARGETING_KEYS,
-            ...(prevSlotTargetingKeys[elementId] ?? []),
-          ]);
-        });
-      }
-
-      slots.forEach((slot) => {
-        // Resolve actual div ID: exact match first, then the visibility and
-        // geometry tiers for prefix matches. div_id in config may be a stable
-        // prefix (e.g. "ad-header-0-") when the suffix is dynamically
-        // generated by the framework at render time.
-        const resolution = resolveSlotElementByDivId(slot.div_id);
-        const el = resolution.element;
-        if (!el) {
-          if (!warnedResolutionFailures.has(slot.div_id)) {
-            if (resolution.prefixMatchCount > 1) {
-              warnedResolutionFailures.add(slot.div_id);
-              log.warn('GPT slot prefix did not resolve to one active element', {
-                divId: slot.div_id,
-                prefixMatchCount: resolution.prefixMatchCount,
-                activeMatchCount: resolution.activeMatchCount,
-              });
-            } else if (resolution.prefixMatchCount === 1 && resolution.activeMatchCount === 0) {
-              // The common breakpoint-hidden config: the prefix matched one
-              // element but it is hidden, so the slot is skipped. Logged so a
-              // blank placement is diagnosable without stepping the resolver.
-              warnedResolutionFailures.add(slot.div_id);
-              log.debug('GPT slot prefix matched only a hidden element; skipping slot', {
-                divId: slot.div_id,
-              });
-            }
-          }
-          return;
-        }
-        const actualDivId = el.id;
-        const bid = bids[slot.id] ?? {};
-        const firstImpression = claimFirstImpressionForTrustedServer(ts, el);
-        if (!firstImpression) {
-          const claim = firstImpressionClaim(ts, el);
-          if (claim?.owner === 'publisher') {
-            schedulePublisherFirstImpressionFallback(ts, g, slot, bid, el, generation);
-          }
-          return;
-        }
-
-        const existingSlot = g.pubads!()
-          .getSlots?.()
-          ?.find?.((s: GoogleTagSlot) => s.getSlotElementId() === actualDivId);
-        let gptSlot: GoogleTagSlot;
-        let tsOwned = false;
-        if (existingSlot) {
-          gptSlot = existingSlot;
-        } else {
-          // Define TS's fallback on the publisher's actual div. A late publisher
-          // defineSlot() for this div is handed the same slot by the scoped GPT
-          // wrapper, preventing a competing container-slot request.
-          const defined = withGptSlotHandoffInternal(ts, () =>
-            g.defineSlot?.(slot.gam_unit_path, slot.formats, actualDivId)
-          );
-          if (!defined) {
-            releaseTrustedServerFirstImpressionClaim(ts, el, firstImpression);
-            return;
-          }
-          defined.addService(g.pubads!());
-          gptSlot = defined;
-          tsOwned = true;
-          (ts.gptSlotHandoffs ??= {})[actualDivId] = {
-            gamUnitPath: slot.gam_unit_path,
-            formats: slot.formats,
-            divIdPrefix: slot.div_id,
-            slotElementId: actualDivId,
-            publisherClaimed: false,
-            suppressPublisherDisplay: false,
-            suppressPublisherRefresh: false,
-          };
-        }
-
-        const slotDivId2 = gptSlot.getSlotElementId?.() ?? actualDivId;
-        const slotTargetingKeys = applyTrustedServerTargeting(ts, gptSlot, slot, bid, [
-          actualDivId,
-          slotDivId2,
-        ]);
-        // Diagnostics are observational only. A missing or malformed debug
-        // implementation must never interrupt slot mapping or delivery.
-        try {
-          const requestedSlotSizes = ts.gptSlotHandoffs?.[slotDivId2]?.formats;
-          const opportunity = trustedServerOpportunity(bid);
-          ts.gptDiagnosticsRecorder?.recordTrustedServerOpportunity(
-            gptSlot,
-            slot.id,
-            opportunity,
-            bid.hb_auction_id,
-            requestedSlotSizes
-          );
-        } catch {
-          // Diagnostics must not alter ad delivery.
-        }
-        // Map the resolved inner div to the slot ID so slotRenderEnded and ADM
-        // injection address the same, single GPT slot.
-        divToSlotId[actualDivId] = slot.id;
-        if (slotDivId2 !== actualDivId) divToSlotId[slotDivId2] = slot.id;
-        nextSlotTargetingKeys[actualDivId] = slotTargetingKeys;
-        if (slotDivId2 !== actualDivId) nextSlotTargetingKeys[slotDivId2] = slotTargetingKeys;
-        if (tsOwned) {
-          newSlots.push(gptSlot);
-          slotsToDisplay.push(slotDivId2);
-        } else {
-          slotsToRefresh.push(gptSlot);
-        }
-
-        // Trusted Server APS winners carry their own typed renderer and never
-        // enter the publisher-owned native apstag rendering path.
-      });
-
-      ts.prevGptSlots = newSlots as unknown[];
-      // Replace (not merge) so destroyed slots from previous navigation don't linger.
-      ts.divToSlotId = divToSlotId;
-      ts.prevSlotTargetingKeys = nextSlotTargetingKeys;
-
-      // Whether this call produced any TS slot to render. A gated page-bids
-      // response (template switch, auction gate, or consent denial) returns no
-      // slots, so the loops above leave these empty.
-      const hasRenderableWork = slotsToDisplay.length > 0 || slotsToRefresh.length > 0;
-
-      // enableSingleRequest and enableServices must only be called once per page
-      // load. Skip activating GPT services when TS has nothing to display or
-      // refresh and has not already enabled them: a consent-denied or
-      // kill-switched navigation must not turn on the publisher's GPT services
-      // or race their own setup. The targeting sweep above still runs so stale
-      // TS targeting from a prior navigation is cleared.
-      if (!ts.servicesEnabled && hasRenderableWork) {
-        g.pubads!().enableSingleRequest();
-        g.enableServices?.();
-        ts.servicesEnabled = true;
-
-        g.pubads!().addEventListener?.('slotRenderEnded', (event: SlotRenderEndedEvent) => {
-          const divId: string = event.slot?.getSlotElementId?.() ?? '';
-          const slotId = (ts.divToSlotId ?? {})[divId];
-          if (!slotId) return;
-          // Read ts.bids live (not the snapshot above) so post-navigation bid data is used.
-          const bid = (ts.bids ?? {})[slotId] ?? {};
-
-          // GAM interceptor (testing bypass): directly replace the GAM creative.
-          // `adm` is now always injected in production, so it can no longer gate
-          // this path. `debug_bid` is present only when inject_adm_for_testing is
-          // on, so it is the per-bid signal that the testing bypass is enabled.
-          // In production the render bridge serves the creative and GAM stays in
-          // the loop; this direct replace stays testing-only.
-          if (bid.adm && bid.debug_bid) {
-            injectAdmIntoSlot(divId, bid.adm);
-          }
-        });
-      }
-
-      // Register and render TS-defined slots. GPT requires display() for a
-      // freshly-defined slot — without it the slot no-ops ("defineSlot was
-      // called without a matching display call") and misses its impression.
-      // Must run after enableServices(); on SPA navigation services are already
-      // enabled, so this runs unconditionally for any newly-defined slots.
-      slotsToDisplay.forEach((divId) => withGptSlotHandoffInternal(ts, () => g.display?.(divId)));
-
-      syncInitialLoadDisabled(g, ts);
-      // Slots needing an explicit ad request via refresh(). Reused
-      // publisher-owned slots always need one to pick up the just-applied
-      // server-side targeting. TS-defined slots are normally fetched by the
-      // display() above — but when the publisher called
-      // pubads().disableInitialLoad(), display() only registers the slot and the
-      // ad request must come from refresh(). Without this, a TS-owned
-      // first-impression slot renders blank on initial-load-disabled pages. Only
-      // add them in that case; otherwise display() + refresh() would
-      // double-request the impression.
-      const slotsNeedingRefresh = ts.gptInitialLoadDisabled
-        ? slotsToRefresh.concat(newSlots)
-        : slotsToRefresh;
-
-      if (slotsNeedingRefresh.length > 0) {
-        // One-shot bypass: this internal refresh delivers the just-applied
-        // server-side targeting to GAM. If slim-Prebid has wrapped refresh(), it
-        // must pass this call straight through — not clear the targeting and run
-        // a duplicate client-side auction. Later publisher-initiated refreshes of
-        // the same slots still go through the wrapper normally.
-        ts.adInitRefreshInProgress = true;
-        try {
-          withGptSlotHandoffInternal(ts, () => g.pubads!().refresh(slotsNeedingRefresh));
-        } finally {
-          ts.adInitRefreshInProgress = false;
-        }
-      }
-    });
-  };
-}
-
-interface PageBidsResponse {
-  slots: AuctionSlot[];
-  bids: Record<string, AuctionBidData>;
-}
-
-/** Canonical SPA re-auction endpoint. Mirrors `PAGE_BIDS_PATH` in Rust. */
-const PAGE_BIDS_PATH = '/_ts/page-bids';
-
-/**
- * Deprecated alias of {@link PAGE_BIDS_PATH}, kept registered server-side so
- * pre-rename bundles keep working. This bundle falls back to it when the
- * canonical path does not serve page-bids: a server rolled back to before the
- * rename does not register the canonical path, and an operator `[[handlers]]`
- * auth regex broad enough to cover `/_ts` answers it with `401` that no
- * anonymous browser fetch can satisfy. Without the fallback either case
- * silently drops ads on every SPA navigation.
- *
- * Removed together with the server-side alias in IABTechLab/trusted-server#970.
- */
-const PAGE_BIDS_LEGACY_PATH = '/__ts/page-bids';
-
-/**
- * `X-TSJS-Page-Bids` value sent on a fallback request, so the server can tell
- * a current bundle that could not use the canonical path from a pre-rename
- * bundle that only knows the alias. Only the former signals a deployment that
- * needs fixing. Mirrors `PAGE_BIDS_FALLBACK_MARKER` in Rust.
- */
-const PAGE_BIDS_FALLBACK_MARKER = 'fallback';
-
-/** Outcome of one page-bids request against a specific endpoint path. */
-interface PageBidsAttempt {
-  /** Parsed payload, or `null` when this endpoint did not serve one. */
-  data: PageBidsResponse | null;
-  /**
-   * The response says this path does not serve page-bids on this deployment,
-   * so the other registered path is worth trying. Transient failures and the
-   * endpoint's own cross-site denial apply equally to both paths and do not
-   * set this.
-   */
-  wrongEndpoint: boolean;
-}
-
-async function fetchPageBids(
-  endpoint: string,
-  path: string,
-  signal: AbortSignal
-): Promise<PageBidsAttempt> {
-  const res = await fetch(`${endpoint}?path=${encodeURIComponent(path)}`, {
-    credentials: 'include',
-    // Non-simple header doubles as a CSRF token: the server rejects
-    // requests that carry neither same-origin Fetch Metadata nor this
-    // header, and cross-origin pages cannot send it without a CORS
-    // preflight the endpoint never grants. The server checks presence, not
-    // value, so the value carries the fallback diagnostic.
-    headers: {
-      'X-TSJS-Page-Bids': endpoint === PAGE_BIDS_LEGACY_PATH ? PAGE_BIDS_FALLBACK_MARKER : '1',
-    },
-    signal,
-  });
-  if (!res.ok) {
-    // 401: an operator auth handler regex covers this path. 404: this server
-    // does not know the route. Either way the other path may still answer.
-    // 403 (cross-site gate) and 5xx would repeat on both, so they do not.
-    return { data: null, wrongEndpoint: res.status === 401 || res.status === 404 };
-  }
-  try {
-    return { data: (await res.json()) as PageBidsResponse, wrongEndpoint: false };
-  } catch (err) {
-    if (err instanceof DOMException && err.name === 'AbortError') throw err;
-    // A server with no route for this path proxies it to the publisher origin,
-    // which answers 200 HTML. An unparseable body is the wrong endpoint, not a
-    // transient failure.
-    return { data: null, wrongEndpoint: true };
-  }
-}
-
-/**
- * Upper bound (ms) on how long the SPA hook waits for a route's ad containers
- * to appear before applying bids anyway.
- */
-const SPA_SLOT_WAIT_MS = 2000;
-
-/**
- * Resolve once every configured `slots` entry has a container element in the DOM, or
- * after `SPA_SLOT_WAIT_MS`, whichever comes first.
- *
- * Many SPA routers update `history` before the new route's markup commits. If
- * bids were applied immediately, `adInit()` would look up each slot element
- * once and silently skip every not-yet-rendered slot, dropping that route's
- * server-side bids with no retry. Waiting via `MutationObserver` lets the apply
- * step run as soon as the route's full slot set exists; the timeout guarantees
- * a slot that never renders cannot hang the hook (the subsequent `adInit()`
- * skips missing elements exactly as before). Resolves immediately when there is
- * nothing to wait for, or when `MutationObserver` is unavailable.
- */
-function waitForSlotElements(slots: AuctionSlot[], signal: AbortSignal): Promise<void> {
-  // A newer navigation may have aborted this signal before we were called; skip
-  // installing an observer/timer that the stale run would only tear down.
-  if (signal.aborted) return Promise.resolve();
-  // Presence and eligibility are different questions here. The tiered
-  // resolver returns no element for a prefix match that is hidden (e.g. a
-  // breakpoint-hidden mobile-only placement), but such a slot has rendered and
-  // will never "appear" — waiting on it would stall every slot on the route
-  // for the full timeout. Count it as present; adInit still applies the strict
-  // tiers when it runs and skips ineligible slots.
-  const allPresent = (): boolean =>
-    slots.every((slot) => {
-      const resolution = resolveSlotElementByDivId(slot.div_id);
-      return resolution.element !== null || resolution.prefixMatchCount > 0;
-    });
-  if (slots.length === 0 || allPresent() || typeof MutationObserver === 'undefined') {
-    return Promise.resolve();
-  }
-
-  return new Promise<void>((resolve) => {
-    let settled = false;
-    let animationFrame: number | undefined;
-    const finish = (): void => {
-      if (settled) return;
-      settled = true;
-      if (animationFrame !== undefined) cancelAnimationFrame(animationFrame);
-      observer.disconnect();
-      clearTimeout(timer);
-      signal.removeEventListener('abort', finish);
-      resolve();
-    };
-    const observer = new MutationObserver(() => {
-      if (document.visibilityState === 'hidden' || typeof requestAnimationFrame === 'undefined') {
-        if (animationFrame !== undefined) {
-          cancelAnimationFrame(animationFrame);
-          animationFrame = undefined;
-        }
-        if (allPresent()) finish();
-        return;
-      }
-      if (animationFrame !== undefined) return;
-      animationFrame = requestAnimationFrame(() => {
-        animationFrame = undefined;
-        if (allPresent()) finish();
-      });
-    });
-    observer.observe(document.documentElement, { childList: true, subtree: true });
-    const timer = setTimeout(finish, SPA_SLOT_WAIT_MS);
-    signal.addEventListener('abort', finish);
-  });
-}
-
-/**
- * Install SPA navigation hook.
- *
- * Patches `history.pushState` and `history.replaceState`, and listens to
- * `popstate`, so that after each client-side route change the trusted server
- * fetches fresh slots + bids from `/_ts/page-bids?path=<new_path>`, updates
- * `window.tsjs.adSlots` / `window.tsjs.bids`, and calls `window.tsjs.adInit()`.
- *
- * Idempotent: guarded by `window.tsjs.spaHookInstalled` so multiple calls are safe.
- */
-export function installSpaAuctionHook(): void {
-  if (typeof window === 'undefined') return;
-  const ts = (window.tsjs ??= {} as TsjsApi);
-  if (ts.spaHookInstalled) return;
-  ts.spaHookInstalled = true;
-  // Navigation identity for the deferred initial-adInit bootstrap (see
-  // installScheduleInitialAdInit). Initialized here, and incremented
-  // synchronously in onNavigate the moment a route change is accepted, so the
-  // counter can never lag the auction decision. Deliberately NOT rolled back
-  // when a navigation later fails: the framework has already swapped the
-  // route's DOM by then, so a pending initial callback must still stand down.
-  ts.navGeneration ??= 0;
-
-  let inflight: AbortController | null = null;
-  // Last path an auction was run for. popstate fires for hash-only and
-  // same-pathname changes, so guard against re-requesting loaded impressions.
-  let currentPath = location.pathname;
-  // Last path whose slots/bids were actually applied — the initial SSR page
-  // counts. A failed navigation rolls `currentPath` back to this rather than to
-  // the immediately-previous committed value: on rapid A→B where A was aborted
-  // mid-flight and B then fails, rolling back to A (never loaded) would strand
-  // it behind the no-op guard, so we roll back to the last applied route instead.
-  let lastAppliedPath = location.pathname;
-  // Endpoint this session requests. Starts canonical; if the deployment does
-  // not serve page-bids there, one navigation retries on the deprecated alias
-  // and the session stays on it rather than re-probing every navigation.
-  let pageBidsEndpoint = PAGE_BIDS_PATH;
-
-  async function requestPageBids(
-    path: string,
-    signal: AbortSignal
-  ): Promise<PageBidsResponse | null> {
-    const attempt = await fetchPageBids(pageBidsEndpoint, path, signal);
-    if (attempt.data || !attempt.wrongEndpoint || pageBidsEndpoint !== PAGE_BIDS_PATH) {
-      return attempt.data;
-    }
-
-    const fallback = await fetchPageBids(PAGE_BIDS_LEGACY_PATH, path, signal);
-    if (!fallback.data) return null;
-    log.warn(
-      `SPA auction hook: ${PAGE_BIDS_PATH} does not serve page-bids here, ` +
-        `falling back to ${PAGE_BIDS_LEGACY_PATH}`
-    );
-    pageBidsEndpoint = PAGE_BIDS_LEGACY_PATH;
-    return fallback.data;
-  }
-
-  async function onNavigate(path: string): Promise<void> {
-    if (path === currentPath) return;
-    currentPath = path;
-    const g = (window as GptWindow).googletag;
-    if (g) clearPreviousNavigationTargeting(ts, g);
-    ts.navGeneration = (ts.navGeneration ?? 0) + 1;
-    delete ts.firstImpression;
-    // A route change invalidates hydration aliases before the new route's
-    // publisher can define a same-prefix slot while page-bids is in flight.
-    for (const [elementId, handoff] of Object.entries(ts.gptSlotHandoffs ?? {})) {
-      if (!handoff.publisherClaimed) delete ts.gptSlotHandoffs![elementId];
-    }
-    inflight?.abort();
-    const controller = new AbortController();
-    inflight = controller;
-
-    try {
-      const data = await requestPageBids(path, controller.signal);
-      if (!data) {
-        // A transient page-bids failure must not strand this route: roll the
-        // committed path back so a later navigation here retries instead of
-        // being skipped by the no-op guard at the top. Only roll back when no
-        // newer navigation has already advanced currentPath.
-        if (inflight === controller) currentPath = lastAppliedPath;
-        return;
-      }
-      if (inflight !== controller) return;
-      // Defer applying bids until the new route's ad containers exist, so a
-      // fast edge response cannot beat the DOM and drop server-side bids.
-      await waitForSlotElements(data.slots, controller.signal);
-      if (inflight !== controller) return;
-      ts.adSlots = data.slots;
-      ts.bids = data.bids;
-      // This route is now the committed, loaded state — a later failed
-      // navigation rolls back here, and a return trip no-ops correctly.
-      lastAppliedPath = path;
-      // An empty page-bids response (template switch, auction, or consent gate)
-      // carries no TS slots. Only run adInit() when there are slots to apply or
-      // prior TS state to sweep — otherwise a gated navigation must not enter
-      // the GPT command queue and risk activating services.
-      const hasPriorTsState =
-        (ts.prevGptSlots?.length ?? 0) > 0 ||
-        Object.keys(ts.prevSlotTargetingKeys ?? {}).length > 0 ||
-        Object.keys(ts.divToSlotId ?? {}).length > 0;
-      if (data.slots.length > 0 || hasPriorTsState) {
-        ts.adInit?.();
-      }
-    } catch (err) {
-      if (err instanceof DOMException && err.name === 'AbortError') return;
-      if (inflight === controller) currentPath = lastAppliedPath;
-      log.warn('SPA auction hook: fetch failed', err);
-    }
-  }
-
-  function patchHistoryMethod(method: 'pushState' | 'replaceState'): void {
-    const original = history[method].bind(history);
-    history[method] = function (state: unknown, unused: string, url?: string | URL | null): void {
-      original(state, unused, url);
-      const locationUrl = url ? new URL(String(url), location.href) : location;
-      const newPath = locationUrl.pathname;
-      // onNavigate no-ops when newPath equals the last loaded path.
-      void onNavigate(newPath);
-    };
-  }
-
-  patchHistoryMethod('pushState');
-  patchHistoryMethod('replaceState');
-
-  window.addEventListener(
-    'popstate',
-    () => {
-      void onNavigate(location.pathname);
-    },
-    true
-  );
-}
-
-/**
- * Register the slim-Prebid lazy loader. Fires after window.load — off the
- * critical path. Slim-Prebid handles scroll/refresh auctions and userID
- * module warm-up (ID5, sharedID, LiveRamp ATS, Lockr).
- *
- * Phase 1: no-op unless `window.__tsjs_slim_prebid_url` is set (the slim
- * bundle build target ships in a later phase).
- */
-export function installSlimPrebidLoader(): void {
-  if (typeof window === 'undefined') return;
-  const url = (window as GptWindow).__tsjs_slim_prebid_url;
-  if (!url) return;
-  window.addEventListener('load', () => {
-    const script = document.createElement('script');
-    script.src = url;
-    script.defer = true;
-    document.head.appendChild(script);
-  });
-}
-
-/** Minimal display renderer injected into the ad iframe by pbRender. */
-const TS_DISPLAY_RENDERER =
-  '(function(){window.render=function(d,h,w){' +
-  'var f=h.mkFrame(w.document,{width:d.width||"100%",height:d.height||"100%"});' +
-  'if(d.adUrl&&!d.ad){f.src=d.adUrl;}else{f.srcdoc=d.ad;}' +
-  'w.document.body.appendChild(f);};})();';
-
-/** The clear-price auction macro DSPs embed in creative markup and tracking URLs. */
-const AUCTION_PRICE_MACRO = '${AUCTION_PRICE}';
-
-/**
- * Substitute the `${AUCTION_PRICE}` macro with a clearing price. Mirrors the
- * server-side `expand_auction_price_macro`: only the exact clear-price token is
- * replaced, so the encrypted `${AUCTION_PRICE:B64}` variant is left intact.
- */
-function expandAuctionPriceMacro(markup: string, cpm: number): string {
-  return markup.includes(AUCTION_PRICE_MACRO)
-    ? markup.split(AUCTION_PRICE_MACRO).join(String(cpm))
-    : markup;
-}
-
-/** A decoded PBS Cache bid: the renderable creative plus its render metadata. */
-export interface CachedBid {
-  adm: string;
-  width?: number;
-  height?: number;
-  price?: number;
-}
-
-/**
- * Decode a PBS Cache GET response into a renderable bid.
- *
- * Prebid Cache entries are JSON bid objects (`{ "adm": "<div…>", "w": …, … }`);
- * the Prebid Universal Creative's own cache path `JSON.parse`s the response and
- * renders `bidObject.adm`, sizing from the cached dimensions. This mirrors that,
- * retaining the fields the fallback render needs — creative dimensions (`w`/`h`
- * or `width`/`height`) and clearing `price` for macro expansion — rather than
- * reducing the payload to a bare `adm` string that forces the first slot format
- * and leaves price macros unresolved.
- *
- * A non-JSON body is treated as raw creative markup (the `{ adm }`-only variant)
- * for backward compatibility with caches that store the creative directly.
- * Returns `undefined` when the JSON payload carries no usable string `adm`, so
- * the caller can decline to render instead of injecting a serialized object.
- */
-export function parseCachedBid(body: string): CachedBid | undefined {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    // Not JSON — a cache that returned the creative markup directly. No render
-    // metadata is available, so only the raw markup variant is returned.
-    return body.trim().length > 0 ? { adm: body } : undefined;
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    // A JSON primitive (string/number/bool) is not a valid cached bid object.
-    return undefined;
-  }
-  const obj = parsed as Record<string, unknown>;
-  const adm = obj.adm;
-  if (typeof adm !== 'string' || adm.length === 0) return undefined;
-
-  const num = (v: unknown): number | undefined =>
-    typeof v === 'number' && Number.isFinite(v) ? v : undefined;
-  // A zero (or missing) dimension is not usable render metadata; treat it as
-  // absent so the caller falls back to the slot format rather than sizing to 0.
-  const dim = (v: unknown): number | undefined => {
-    const n = num(v);
-    return n !== undefined && n > 0 ? n : undefined;
-  };
-
-  return {
-    adm,
-    // PBS OpenRTB bids carry w/h; the Prebid.js cache format uses width/height.
-    width: dim(obj.w) ?? dim(obj.width),
-    height: dim(obj.h) ?? dim(obj.height),
-    price: num(obj.price),
-  };
-}
-
-function safelyRecordCreativeRequest(slotId: string): number | undefined {
-  try {
-    const attemptId =
-      window.tsjs?.gptDiagnosticsRecorder?.recordTrustedServerCreativeRequest(slotId);
-    return typeof attemptId === 'number' && Number.isFinite(attemptId) ? attemptId : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function safelyRecordCreativeResponse(attemptId: number | undefined): void {
-  if (attemptId === undefined) return;
-
-  try {
-    window.tsjs?.gptDiagnosticsRecorder?.recordTrustedServerCreativeResponse(attemptId);
-  } catch {
-    // Diagnostics must not alter creative delivery.
-  }
-}
-
-function safelyRecordCreativeFailure(
-  attemptId: number | undefined,
-  reason: GptDiagnosticsCreativeFailure
-): void {
-  if (attemptId === undefined) return;
-
-  try {
-    window.tsjs?.gptDiagnosticsRecorder?.recordTrustedServerCreativeFailure(attemptId, reason);
-  } catch {
-    // Diagnostics must not alter creative delivery.
-  }
-}
-
-/** Maximum number of consumed APS Prebid IDs retained as security tombstones. */
-const MAX_CONSUMED_PREBID_APS_IDS = 256;
-
-function pruneConsumedPrebidApsIds(
-  consumedIds: Map<string, { expiresAt: number }>,
-  now: number
-): void {
-  for (const [adId, consumed] of consumedIds) {
-    if (consumed.expiresAt <= now) consumedIds.delete(adId);
-  }
-}
-
-function hasConsumedPrebidApsIdCapacity(
-  consumedIds: Map<string, { expiresAt: number }>,
-  adId: string
-): boolean {
-  if (consumedIds.has(adId) || consumedIds.size < MAX_CONSUMED_PREBID_APS_IDS) return true;
-
-  log.warn(`[tsjs-gpt] APS Prebid renderer tombstone capacity reached; declining '${adId}'`);
-  return false;
-}
-
-function recordConsumedPrebidApsId(
-  consumedIds: Map<string, { expiresAt: number }>,
-  adId: string,
-  expiresAt: number
-): void {
-  consumedIds.set(adId, { expiresAt });
-}
-
-/**
- * Install the TS → pbRender bridge.
- *
- * Must be installed synchronously at module init — before `adInit()` fires
- * `refresh()`, which initiates the GAM request that may select the Prebid
- * creative. Installing post-load would miss first-impression `"Prebid Request"`
- * messages.
- *
- * When `adId` matches a TS server-side bid in `window.tsjs.bids` AND the bid
- * has renderable markup, the bridge:
- *   1. Uses the inline `adm` directly when present (the sanitized winning
- *      creative, now shipped in production), otherwise fetches from PBS Cache
- *      and extracts `adm` from the cached bid JSON (see `extractCachedAdm`).
- *   2. Replies via the MessageChannel port with a `"Prebid Response"`.
- *   3. Calls `stopImmediatePropagation()` so Prebid.js does not also process
- *      the message and log spurious failures.
- *
- * Lives in gpt/index.ts (not prebid/index.ts) to avoid pulling the full
- * Prebid bundle into tsjs-gpt.js via inlineDynamicImports.
- */
-export function installTsRenderBridge(): void {
-  if (typeof window === 'undefined') return;
-
-  // `slotId|adId` renders whose PBS Cache fetch is in flight. `fireWinBillingBeacons`
-  // only dedups after the async fetch resolves, so two Prebid Request messages for
-  // the same render arriving before the first fetch settles would both fetch and
-  // both fire the nurl/burl beacons. Tracking the in-flight render prevents the
-  // concurrent double-fire; the entry is cleared once the fetch settles. The key
-  // is scoped to the slot, not the bare adId: hb_adid is not unique per bid, so
-  // keying on it alone would let one slot block a distinct slot's render.
-  const renderingKeys = new Set<string>();
-  const consumedPrebidApsIds = new Map<string, { expiresAt: number }>();
-  // One consumed APS ad ID per slot is sufficient: a newer bid replaces the
-  // slot's old ad ID in `window.tsjs.bids`, so the ownership guard rejects it.
-  const consumedServerApsBySlot = new Map<string, string>();
-
-  window.addEventListener('message', (e: MessageEvent) => {
-    let data: Record<string, unknown>;
-    try {
-      data =
-        typeof e.data === 'object'
-          ? (e.data as Record<string, unknown>)
-          : (JSON.parse(e.data as string) as Record<string, unknown>);
-    } catch {
-      return;
-    }
-
-    if (data['message'] !== 'Prebid Request') return;
-    const adId = data['adId'] as string | undefined;
-    if (!adId) return;
-
-    const port = e.ports?.[0];
-    if (!port) return;
-
-    const now = Date.now();
-    const generation = window.tsjs?.navGeneration ?? 0;
-    pruneConsumedPrebidApsIds(consumedPrebidApsIds, now);
-    const consumedPrebidAps = consumedPrebidApsIds.get(adId);
-    if (consumedPrebidAps) {
-      // Once TS claims an APS capability, keep the ad ID unavailable to every
-      // other iframe. Letting Prebid's global handler answer a foreign source
-      // would expose the creative despite the slot-bound capability check.
-      e.stopImmediatePropagation();
-      return;
-    }
-
-    const prebidRendererEntry = getApsPrebidRenderer(adId);
-    if (prebidRendererEntry) {
-      // Fail closed for a TS-owned APS ad ID before checking its source. Native
-      // Prebid handles ad IDs globally and would otherwise answer a request from
-      // an unrelated iframe when this slot-bound capability rejects it.
-      e.stopImmediatePropagation();
-      const sourceFrame = sourceFrameForAdUnit(e.source, prebidRendererEntry.adUnitCode);
-      if (!sourceFrame) return;
-      const renderer = validateApsRenderer(prebidRendererEntry.renderer);
-      if (!renderer || !hasConsumedPrebidApsIdCapacity(consumedPrebidApsIds, adId)) return;
-      if (!consumeApsPrebidRenderer(adId, prebidRendererEntry)) return;
-      recordConsumedPrebidApsId(consumedPrebidApsIds, adId, prebidRendererEntry.expiresAt);
-
-      const markUsed = (): void => {
-        try {
-          prebidRendererEntry.markUsed();
-        } catch (err) {
-          log.warn(`[tsjs-gpt] APS Prebid markUsed callback threw for '${adId}'`, err);
-        }
-      };
-      const dispatched = dispatchApsRendering({
-        slotId: prebidRendererEntry.adUnitCode,
-        renderer,
-        source: e.source,
-        trustedServer: (validatedRenderer) => {
-          const rendererUrl = apsRendererUrl();
-          if (!rendererUrl) return false;
-          const stillOwnsCreative = () =>
-            sourceFrameForAdUnit(e.source, prebidRendererEntry.adUnitCode)?.iframe ===
-            sourceFrame.iframe;
-          if (!creativeFrameIsCurrent(e.source, sourceFrame, generation, stillOwnsCreative)) {
-            return false;
-          }
-          try {
-            port.postMessage(
-              JSON.stringify({
-                message: 'Prebid Response',
-                adId,
-                renderer: APS_UNIVERSAL_CREATIVE_RENDERER,
-                rendererVersion: APS_UNIVERSAL_CREATIVE_RENDERER_VERSION,
-                rendererUrl,
-                apsRenderer: validatedRenderer,
-                width: validatedRenderer.width,
-                height: validatedRenderer.height,
-              })
-            );
-            resizeCollapsedCreativeFrame(
-              e.source,
-              sourceFrame,
-              validatedRenderer.width,
-              validatedRenderer.height,
-              generation,
-              stillOwnsCreative
-            );
-            return creativeFrameIsCurrent(e.source, sourceFrame, generation, stillOwnsCreative);
-          } catch (err) {
-            log.warn(`[tsjs-gpt] APS Prebid response post failed for '${adId}'`, err);
-            return false;
-          }
-        },
-      });
-      if (typeof dispatched === 'boolean') {
-        if (dispatched) markUsed();
-      } else {
-        void dispatched.then((accepted) => {
-          if (accepted) markUsed();
-        });
-      }
-      return;
-    }
-
-    const sourceSlotFrame = slotFrameForMessageSource(e.source);
-    if (!sourceSlotFrame) return;
-
-    // Resolve the bid by the requesting slot, not by the first bid whose hb_adid
-    // matches. hb_adid is not unique per bid: absent PBS Cache it falls back to a
-    // creative id a bidder may reuse across slots, and only absent that too does it
-    // fall back to the OpenRTB bid id, which is unique per bid instance. A
-    // first-match-by-adId lookup would resolve every duplicate to one slot, so all
-    // but that slot render blank.
-    const bids = window.tsjs?.bids ?? {};
-    const slotId = sourceSlotFrame.slotId;
-    const matchedBid = bids[slotId];
-
-    // Not a TS bid, or the requesting slot's bid does not own this adId — let
-    // Prebid.js handle it. The adId guard also prevents an iframe under slot A from
-    // pulling slot B's creative and firing slot B's win/billing beacons.
-    if (!matchedBid || matchedBid.hb_adid !== adId) return;
-
-    if (matchedBid.renderer !== undefined) {
-      // This slot and ad ID belong to TS, so fail closed before validating the
-      // descriptor and never let native Prebid answer a rejected or replayed request.
-      e.stopImmediatePropagation();
-      if (consumedServerApsBySlot.get(slotId) === adId) return;
-      const renderer = validateApsRenderer(matchedBid.renderer);
-      if (!renderer) return;
-      consumedServerApsBySlot.set(slotId, adId);
-      void Promise.resolve(
-        dispatchApsRendering({
-          slotId,
-          renderer,
-          source: e.source,
-          trustedServer: (validatedRenderer) => {
-            const rendererUrl = apsRendererUrl();
-            if (!rendererUrl) return false;
-            const stillOwnsCreative = () =>
-              window.tsjs?.bids?.[slotId] === matchedBid &&
-              matchedBid.hb_adid === adId &&
-              sourceFrameForSlotId(e.source, slotId)?.iframe === sourceSlotFrame.iframe;
-            if (!creativeFrameIsCurrent(e.source, sourceSlotFrame, generation, stillOwnsCreative)) {
-              return false;
-            }
-            try {
-              port.postMessage(
-                JSON.stringify({
-                  message: 'Prebid Response',
-                  adId,
-                  renderer: APS_UNIVERSAL_CREATIVE_RENDERER,
-                  rendererVersion: APS_UNIVERSAL_CREATIVE_RENDERER_VERSION,
-                  rendererUrl,
-                  apsRenderer: validatedRenderer,
-                  width: validatedRenderer.width,
-                  height: validatedRenderer.height,
-                })
-              );
-              resizeCollapsedCreativeFrame(
-                e.source,
-                sourceSlotFrame,
-                validatedRenderer.width,
-                validatedRenderer.height,
-                generation,
-                stillOwnsCreative
-              );
-              return creativeFrameIsCurrent(
-                e.source,
-                sourceSlotFrame,
-                generation,
-                stillOwnsCreative
-              );
-            } catch (err) {
-              log.warn(`[tsjs-gpt] APS server response post failed for '${slotId}'`, err);
-              return false;
-            }
-          },
-        })
-      );
-      return;
-    }
-
-    const attemptId = safelyRecordCreativeRequest(slotId);
-
-    const slot = window.tsjs?.adSlots?.find((s) => s.id === slotId);
-    // Prefer the winning creative's own dimensions; the first configured slot
-    // format is only a fallback and mis-sizes a multi-size slot whose winner is
-    // not the first format.
-    const [fallbackWidth, fallbackHeight] = slot?.formats?.[0] ?? [728, 90];
-    const width = matchedBid.w ?? fallbackWidth;
-    const height = matchedBid.h ?? fallbackHeight;
-    const inlineAdm = isNonEmptyString(matchedBid.adm) ? matchedBid.adm : undefined;
-    const cacheHost = isNonEmptyString(matchedBid.hb_cache_host)
-      ? matchedBid.hb_cache_host
-      : undefined;
-    const cachePath = isNonEmptyString(matchedBid.hb_cache_path)
-      ? matchedBid.hb_cache_path
-      : undefined;
-
-    if (inlineAdm) {
-      e.stopImmediatePropagation();
-      const stillOwnsCreative = () =>
-        Boolean(
-          window.tsjs?.bids?.[slotId] === matchedBid &&
-          matchedBid.hb_adid === adId &&
-          sourceFrameForSlotId(e.source, slotId)?.iframe === sourceSlotFrame.iframe
-        );
-      if (!creativeFrameIsCurrent(e.source, sourceSlotFrame, generation, stillOwnsCreative)) {
-        return;
-      }
-      try {
-        port.postMessage(
-          JSON.stringify({
-            message: 'Prebid Response',
-            adId,
-            ad: inlineAdm,
-            renderer: TS_DISPLAY_RENDERER,
-            width,
-            height,
-          })
-        );
-      } catch (err) {
-        safelyRecordCreativeFailure(attemptId, 'response_post_failed');
-        log.warn(`[tsjs-gpt] pbRender bridge: response post failed for '${slotId}'`, err);
-        return;
-      }
-      resizeCollapsedCreativeFrame(
-        e.source,
-        sourceSlotFrame,
-        width,
-        height,
-        generation,
-        stillOwnsCreative
-      );
-      if (!creativeFrameIsCurrent(e.source, sourceSlotFrame, generation, stillOwnsCreative)) return;
-      safelyRecordCreativeResponse(attemptId);
-      fireWinBillingBeacons(slotId, matchedBid);
-      log.debug(`[tsjs-gpt] pbRender bridge served '${slotId}' from inline adm`);
-      return;
-    }
-
-    // No TS render source — let Prebid.js handle it.
-    if (!cacheHost || !cachePath) {
-      safelyRecordCreativeFailure(attemptId, 'missing_render_source');
-      return;
-    }
-
-    // TS owns this adId — stop Prebid from also processing it.
-    e.stopImmediatePropagation();
-
-    // Skip a concurrent re-render of the same slot's adId so its win/billing
-    // beacons fire at most once even before the first cache fetch resolves.
-    const renderingKey = `${slotId}|${adId}`;
-    if (renderingKeys.has(renderingKey)) return;
-    renderingKeys.add(renderingKey);
-
-    const cacheUrl = `https://${cacheHost}${cachePath}?uuid=${encodeURIComponent(adId)}`;
-
-    const cachedBody = fetch(cacheUrl, { mode: 'cors' }).then((res) =>
-      res.ok ? res.text() : Promise.reject(res.status)
-    );
-
-    cachedBody
-      .then(
-        (body) => {
-          // PBS Cache returns the cached bid as a JSON object; decode its creative
-          // and render metadata the same way the Prebid Universal Creative does.
-          const cached = parseCachedBid(body);
-          if (!cached) {
-            // No renderable creative in the cache payload — decline rather than
-            // ship a serialized bid document to PUC. Beacons stay unfired.
-            safelyRecordCreativeFailure(attemptId, 'invalid_cache_payload');
-            log.warn(
-              `[tsjs-gpt] pbRender bridge: PBS Cache response for '${slotId}' had no renderable adm`
-            );
-            return;
-          }
-          // Resolve the auction-price macro from the cached clearing price, and
-          // size from the cached bid's own dimensions, falling back to the slot
-          // format only when the cache omits them.
-          const ad =
-            cached.price !== undefined
-              ? expandAuctionPriceMacro(cached.adm, cached.price)
-              : cached.adm;
-          const cachedWidth = cached.width ?? width;
-          const cachedHeight = cached.height ?? height;
-          const stillOwnsCreative = () =>
-            window.tsjs?.bids?.[slotId] === matchedBid &&
-            matchedBid.hb_adid === adId &&
-            sourceFrameForSlotId(e.source, slotId)?.iframe === sourceSlotFrame.iframe;
-          if (!creativeFrameIsCurrent(e.source, sourceSlotFrame, generation, stillOwnsCreative)) {
-            return;
-          }
-          try {
-            port.postMessage(
-              JSON.stringify({
-                message: 'Prebid Response',
-                adId,
-                ad,
-                renderer: TS_DISPLAY_RENDERER,
-                width: cachedWidth,
-                height: cachedHeight,
-              })
-            );
-            resizeCollapsedCreativeFrame(
-              e.source,
-              sourceSlotFrame,
-              cachedWidth,
-              cachedHeight,
-              generation,
-              stillOwnsCreative
-            );
-          } catch (err) {
-            safelyRecordCreativeFailure(attemptId, 'response_post_failed');
-            log.warn(`[tsjs-gpt] pbRender bridge: response post failed for '${slotId}'`, err);
-            return;
-          }
-          if (!creativeFrameIsCurrent(e.source, sourceSlotFrame, generation, stillOwnsCreative)) {
-            return;
-          }
-          safelyRecordCreativeResponse(attemptId);
-          // Beacons carry the server-expanded ${AUCTION_PRICE} from the auction's
-          // clearing price, not `cached.price` — the auction result is the
-          // authoritative clearing price, and the cached copy is only the render
-          // source. Do not re-expand them here.
-          fireWinBillingBeacons(slotId, matchedBid);
-          log.debug(`[tsjs-gpt] pbRender bridge served '${slotId}' from PBS Cache`);
-        },
-        (err) => {
-          safelyRecordCreativeFailure(attemptId, 'cache_fetch_failed');
-          log.warn(`[tsjs-gpt] pbRender bridge: PBS Cache fetch failed for '${slotId}'`, err);
-        }
-      )
-      .catch((err) => {
-        // Errors reaching this stage were thrown after the cache body promise
-        // settled, so parsing, posting follow-up work, beacons, success logging,
-        // or failure reporting must not create new cache-failure evidence. Keep
-        // the fire-and-forget bridge promise handled without changing evidence.
-        try {
-          log.warn(`[tsjs-gpt] pbRender bridge: response processing failed for '${slotId}'`, err);
-        } catch {
-          // Logging must not create an unhandled bridge rejection.
-        }
-      })
-      .finally(() => {
-        renderingKeys.delete(renderingKey);
-      });
-  });
-}
-
-// Register the activation function on `window` so the server-injected inline
-// script can call it explicitly. The server emits:
-//   <script>window.__tsjs_gpt_enabled=true;
-//          window.__tsjs_installGptShim&&window.__tsjs_installGptShim();</script>
-// The HTML pipeline currently injects that inline script before the unified
-// bundle, so the explicit call is best-effort only. To make activation robust
-// regardless of script order, the module also checks for a pre-set enable flag
-// immediately after registering the function.
 if (typeof window !== 'undefined') {
-  const win = window as unknown as Record<string, unknown>;
-
-  win.__tsjs_installGptShim = installGptShim;
-
-  if (win.__tsjs_gpt_enabled === true) {
-    installGptShim();
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [createGptIntegrationRegistration(EMBEDDED_RELEASE_ID)]);
   }
-
-  installTrustedServerPageTargeting();
-  installTsAdInit();
-  installSpaAuctionHook();
-  installSlimPrebidLoader();
-  installTsRenderBridge();
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/later.ts b/crates/trusted-server-js/lib/src/integrations/gpt/later.ts
new file mode 100644
index 000000000..146da8136
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/later.ts
@@ -0,0 +1,214 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import { isGptIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+
+type GptLaterNavigationResult =
+  | Readonly<{
+      status: 'committed';
+      navigationGeneration: object;
+      current: true;
+    }>
+  | Readonly<{
+      status: 'rejected';
+      navigationGeneration: object;
+      current: boolean;
+    }>;
+
+interface GptLaterCapabilityV1 {
+  readonly activateLaterLifecycle: () => Readonly<{
+    readonly navigate: (path: string) => PromiseLike<GptLaterNavigationResult>;
+    readonly release: () => void;
+  }>;
+}
+
+interface RuntimeDocumentCapability {
+  readonly document: Document;
+}
+
+function restoreHistoryMethod(
+  history: History,
+  name: 'pushState' | 'replaceState',
+  previous: PropertyDescriptor | undefined,
+  installed: History['pushState']
+): void {
+  try {
+    const current = Object.getOwnPropertyDescriptor(history, name);
+    if (!current || !('value' in current) || current.value !== installed) return;
+    if (previous) Object.defineProperty(history, name, previous);
+    else Reflect.deleteProperty(history, name);
+  } catch {
+    // A publisher replacement remains authoritative; the disposed wrapper is inert.
+  }
+}
+
+/** Build the release-bound post-first-display GPT registration. */
+export function createGptLaterIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'gpt_later',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const gpt = interfaces['gpt.v1'] as GptLaterCapabilityV1 | undefined;
+      const runtime = interfaces['runtime.v1'] as RuntimeDocumentCapability | undefined;
+      for (const key of ['slots.v1', 'auction.v1', 'render.v1', 'trace.v1']) {
+        const capability = interfaces[key];
+        if (typeof capability !== 'object' || capability === null || !Object.isFrozen(capability)) {
+          throw new TypeError(`GPT later requires ${key}`);
+        }
+      }
+      if (
+        !isGptIntegrationConfigV1(config) ||
+        !runtime ||
+        !Object.isFrozen(runtime) ||
+        !runtime.document?.defaultView ||
+        !gpt ||
+        !Object.isFrozen(gpt) ||
+        typeof gpt.activateLaterLifecycle !== 'function'
+      ) {
+        throw new TypeError('GPT later capability graph is invalid');
+      }
+      const pageBidsEnabled = config.pageBidsEnabled;
+      return Object.freeze({
+        activate: ({ onDispose }: IntegrationActivationContext) => {
+          const candidateView = runtime.document.defaultView;
+          if (!candidateView) throw new TypeError('GPT later document is unavailable');
+          const view: Window = candidateView;
+          const history = view.history;
+          const previousPushState = Object.getOwnPropertyDescriptor(history, 'pushState');
+          const previousReplaceState = Object.getOwnPropertyDescriptor(history, 'replaceState');
+          const pushState = history.pushState;
+          const replaceState = history.replaceState;
+          let active = true;
+          let timer: number | undefined;
+          let lastCommittedPath = `${view.location.pathname}${view.location.search}`;
+          let observedPath = lastCommittedPath;
+          let pendingPath: string | undefined;
+          let invocationOrdinal = 0;
+          let latestInvocationOrdinal = 0;
+          let owner: ReturnType<GptLaterCapabilityV1['activateLaterLifecycle']> | undefined;
+          let wrappedPushState: History['pushState'] | undefined;
+          let wrappedReplaceState: History['replaceState'] | undefined;
+          const dispose = (): void => {
+            if (!active) return;
+            active = false;
+            if (timer !== undefined) view.clearTimeout(timer);
+            timer = undefined;
+            pendingPath = undefined;
+            view.removeEventListener('popstate', scheduleNavigation);
+            if (wrappedReplaceState) {
+              restoreHistoryMethod(
+                history,
+                'replaceState',
+                previousReplaceState,
+                wrappedReplaceState
+              );
+            }
+            if (wrappedPushState) {
+              restoreHistoryMethod(history, 'pushState', previousPushState, wrappedPushState);
+            }
+            const release = owner?.release;
+            owner = undefined;
+            release?.();
+          };
+          const flushNavigation = (): void => {
+            timer = undefined;
+            const path = pendingPath;
+            pendingPath = undefined;
+            if (!active || path === undefined || !owner) return;
+            invocationOrdinal += 1;
+            const invocation = invocationOrdinal;
+            latestInvocationOrdinal = invocation;
+            const rejectCurrentInvocation = (): void => {
+              if (!active || invocation !== latestInvocationOrdinal) return;
+              observedPath = lastCommittedPath;
+            };
+            try {
+              void Promise.resolve(owner.navigate(path)).then((result) => {
+                if (!active || invocation !== latestInvocationOrdinal) return;
+                if (result.status === 'committed' && result.current) {
+                  lastCommittedPath = path;
+                  observedPath = path;
+                  return;
+                }
+                if (result.status === 'rejected' && result.current) {
+                  rejectCurrentInvocation();
+                }
+              }, rejectCurrentInvocation);
+            } catch {
+              rejectCurrentInvocation();
+            }
+          };
+          function scheduleNavigation(): void {
+            if (!active) return;
+            let path: string;
+            try {
+              path = `${view.location.pathname}${view.location.search}`;
+            } catch {
+              return;
+            }
+            if (path === observedPath) return;
+            observedPath = path;
+            pendingPath = path;
+            if (timer === undefined) timer = view.setTimeout(flushNavigation, 0);
+          }
+          const wrap = (original: History['pushState']): History['pushState'] =>
+            function wrappedHistoryState(
+              this: History,
+              data: unknown,
+              unused: string,
+              url?: string | URL | null
+            ): void {
+              Reflect.apply(original, this, [data, unused, url]);
+              scheduleNavigation();
+            };
+          onDispose(dispose);
+          try {
+            owner = gpt.activateLaterLifecycle();
+            if (
+              !owner ||
+              !Object.isFrozen(owner) ||
+              typeof owner.navigate !== 'function' ||
+              typeof owner.release !== 'function'
+            ) {
+              throw new TypeError('GPT later lifecycle owner is invalid');
+            }
+            if (!pageBidsEnabled) return;
+            wrappedPushState = wrap(pushState);
+            wrappedReplaceState = wrap(replaceState);
+            Object.defineProperty(history, 'pushState', {
+              configurable: true,
+              enumerable: previousPushState?.enumerable ?? false,
+              value: wrappedPushState,
+              writable: true,
+            });
+            Object.defineProperty(history, 'replaceState', {
+              configurable: true,
+              enumerable: previousReplaceState?.enumerable ?? false,
+              value: wrappedReplaceState,
+              writable: true,
+            });
+            view.addEventListener('popstate', scheduleNavigation);
+          } catch (error) {
+            dispose();
+            throw error;
+          }
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createGptLaterIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/module.ts b/crates/trusted-server-js/lib/src/integrations/gpt/module.ts
new file mode 100644
index 000000000..0e57d186d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/module.ts
@@ -0,0 +1,2331 @@
+import {
+  persistentFirstDisplaySliceSelectedV1,
+  snapshotPersistentFirstDisplayAdoptionV1,
+  snapshotPersistentFirstDisplaySliceStateV1,
+  type FirstDisplayGptDiagnosticEventV1,
+  type FirstDisplayGptDiagnosticsV1,
+  type PersistentFirstDisplayAdoptionV1,
+} from '../../shared/takeover';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+  PreparedIntegration,
+} from '../../kernel/integration_registry';
+import {
+  createBrowserGoogletagAdapter,
+  type GoogletagAdapter,
+  type GoogletagFacade,
+} from '../../adapters/googletag';
+import type {
+  BaselinePbsCacheSourceV1,
+  BrowserAuctionBidV1,
+  BrowserAuctionProjectionV1,
+  BrowserAuctionSlotV1,
+} from '../../core/types';
+import { isGptIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import { log } from '../../core/log';
+import { DisposableStack } from '../../kernel/disposable';
+import type { RuntimeCapabilityV1 } from '../../kernel/runtime';
+import type { NavigationSession, RenderAttemptScope, RuntimeSession } from '../../kernel/sessions';
+import type { IdentityGenerationResult } from '../../kernel/identity';
+import type {
+  CommittedArtifactStore,
+  CommittedRenderArtifact,
+  RenderAttempt,
+  RenderAttemptCreationResult,
+  RenderFailureReason,
+  SlotOperationCreationResult,
+  SlotOperationOptions,
+} from '../../services/render';
+import { resizeCollapsedPucShell } from '../../core/puc_shell';
+import {
+  createPucBridge,
+  type PucBridge,
+  type PucBridgeOptions,
+  type PucGamAttemptInput,
+} from '../../services/puc_bridge';
+import type { ReservationService } from '../../services/reservations';
+import {
+  createBrowserSlotReconciliationBoundary,
+  createSlotService,
+  type GptSlotBinding,
+  type SlotRequestHandle,
+  type SlotRequestInput,
+  type SlotRequestOutcome,
+  type SlotService,
+  type TrustedServerRequestOpportunity,
+} from '../../services/slots';
+import type {
+  TargetingBoundary,
+  TargetingOwnership,
+  TargetingService,
+} from '../../services/targeting';
+import { createTargetingService } from '../../services/targeting';
+
+import {
+  activateGptDiagnosticsEventListeners,
+  createTrustedServerOpportunityFact,
+  createGptDiagnosticsFactBuffer,
+  publishTrustedServerOpportunityFact,
+  projectGptTraceFact,
+} from './diagnostics_facts';
+import { installGptGuard, resetGuardState } from './script_guard';
+import { createGptStartup } from './startup';
+
+export const GPT_INTEGRATION_ID = 'gpt' as const;
+
+function frozenArray(candidate: unknown): readonly unknown[] | undefined {
+  return Array.isArray(candidate) && Object.isFrozen(candidate) ? candidate : undefined;
+}
+
+function dataField(candidate: unknown, key: string): unknown {
+  if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+    return undefined;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+  return descriptor?.enumerable && 'value' in descriptor ? descriptor.value : undefined;
+}
+
+/** Hydrate exact GPT diagnostic tokens/cycles before adopted slots become observable. */
+export function adoptInitialGptDiagnosticsFromHandoff(
+  candidate: unknown,
+  adapter: Pick<GoogletagAdapter, 'adoptDiagnosticsState'>
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  const adopt = adapter.adoptDiagnosticsState;
+  if (!adoption || typeof adopt !== 'function') return undefined;
+  const cycles = frozenArray(dataField(adoption.handoff, 'cycles'));
+  const artifacts = frozenArray(dataField(adoption.handoff, 'artifacts'));
+  const trace = dataField(adoption.handoff, 'trace');
+  const nextTraceTokenOrdinal = dataField(trace, 'nextGlobalSlotOrdinal');
+  if (
+    !cycles ||
+    !artifacts ||
+    typeof nextTraceTokenOrdinal !== 'number' ||
+    adoption.identities.length !== cycles.length + artifacts.length
+  ) {
+    return undefined;
+  }
+  const slots: Array<{
+    nextCycleOrdinal: number;
+    physicalSlot: object;
+    records: readonly Readonly<{
+      ordinal: number;
+      responseIdentifier: string | null;
+      seen: readonly FirstDisplayGptDiagnosticEventV1[];
+      state: 'open' | 'completed' | 'retired';
+    }>[];
+    traceToken: string;
+    unknownPriorCycle: boolean;
+  }> = [];
+  for (let index = 0; index < cycles.length; index += 1) {
+    const cycle = cycles[index];
+    const physicalSlot = adoption.identities[index];
+    const traceToken = dataField(cycle, 'token');
+    const nextCycleOrdinal = dataField(cycle, 'nextCycleOrdinal');
+    const unknownPriorCycle = dataField(cycle, 'unknownPriorCycle');
+    const records = frozenArray(dataField(cycle, 'records'));
+    if (
+      !physicalSlot ||
+      typeof traceToken !== 'string' ||
+      typeof nextCycleOrdinal !== 'number' ||
+      typeof unknownPriorCycle !== 'boolean' ||
+      !records
+    ) {
+      return undefined;
+    }
+    const copiedRecords: Array<{
+      ordinal: number;
+      responseIdentifier: string | null;
+      seen: readonly FirstDisplayGptDiagnosticEventV1[];
+      state: 'open' | 'completed' | 'retired';
+    }> = [];
+    for (const record of records) {
+      const ordinal = dataField(record, 'ordinal');
+      const responseIdentifier = dataField(record, 'responseIdentifier');
+      const seen = frozenArray(dataField(record, 'seen'));
+      const state = dataField(record, 'state');
+      if (
+        typeof ordinal !== 'number' ||
+        (responseIdentifier !== null && typeof responseIdentifier !== 'string') ||
+        !seen ||
+        seen.some(
+          (event) =>
+            event !== 'slotRequested' &&
+            event !== 'slotResponseReceived' &&
+            event !== 'slotRenderEnded' &&
+            event !== 'slotOnload' &&
+            event !== 'impressionViewable' &&
+            event !== 'slotVisibilityChanged'
+        ) ||
+        (state !== 'open' && state !== 'completed' && state !== 'retired')
+      ) {
+        return undefined;
+      }
+      copiedRecords.push({
+        ordinal,
+        responseIdentifier,
+        seen: seen as readonly FirstDisplayGptDiagnosticEventV1[],
+        state,
+      });
+    }
+    slots.push({
+      nextCycleOrdinal,
+      physicalSlot,
+      records: copiedRecords,
+      traceToken,
+      unknownPriorCycle,
+    });
+  }
+  try {
+    return Reflect.apply(adopt, adapter, [{ nextTraceTokenOrdinal, slots }]) === true
+      ? adoption
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Transfer unexpired lifecycle-ticket tombstones into the sole persistent PUC owner. */
+export function adoptInitialPucTicketsFromHandoff(
+  candidate: unknown,
+  bridge: Pick<PucBridge, 'adoptFirstDisplayTickets'>
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  if (!adoption) return undefined;
+  const highWater = dataField(adoption.handoff, 'highWater');
+  const clockEpochMs = dataField(highWater, 'reservationClockEpochMs');
+  const nextTicketOrdinal = dataField(highWater, 'nextTicketOrdinal');
+  const tombstones = frozenArray(dataField(adoption.handoff, 'tombstones'));
+  if (typeof clockEpochMs !== 'number' || typeof nextTicketOrdinal !== 'number' || !tombstones) {
+    return undefined;
+  }
+  const tickets: Array<{ expiresAtMs: number; ticket: string }> = [];
+  for (const tombstone of tombstones) {
+    if (dataField(tombstone, 'kind') !== 'ticket') continue;
+    const ticket = dataField(tombstone, 'value');
+    const expiresAtMs = dataField(tombstone, 'expiresAtMs');
+    if (typeof ticket !== 'string' || typeof expiresAtMs !== 'number') return undefined;
+    tickets.push({ expiresAtMs, ticket });
+  }
+  try {
+    return bridge.adoptFirstDisplayTickets({
+      clockEpochMs,
+      nextTicketOrdinal,
+      tombstones: tickets,
+    })
+      ? adoption
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Restore the ordered bounded diagnostics buffer without replaying facts as new events. */
+export function adoptInitialGptFactsFromHandoff(
+  candidate: unknown,
+  buffer: Pick<ReturnType<typeof createGptDiagnosticsFactBuffer>, 'adoptFirstDisplay'> | undefined,
+  adapter: Pick<GoogletagAdapter, 'diagnosticsIdentity'>,
+  projection: Readonly<BrowserAuctionProjectionV1> | undefined
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  if (!adoption) return undefined;
+  const diagnostics = dataField(adoption.handoff, 'gptDiagnostics');
+  const facts = frozenArray(dataField(diagnostics, 'facts'));
+  const overflow = dataField(diagnostics, 'overflowCount');
+  const drops = dataField(diagnostics, 'dropCount');
+  if (!facts || typeof overflow !== 'number' || typeof drops !== 'number') return undefined;
+  if (!buffer) {
+    return facts.length === 0 && overflow === 0 && drops === 0 ? adoption : undefined;
+  }
+  const cycles = frozenArray(dataField(adoption.handoff, 'cycles'));
+  const artifacts = frozenArray(dataField(adoption.handoff, 'artifacts'));
+  const slots = frozenArray(dataField(adoption.handoff, 'slots'));
+  if (
+    !cycles ||
+    !artifacts ||
+    !slots ||
+    adoption.identities.length !== cycles.length + artifacts.length
+  ) {
+    return undefined;
+  }
+  const formatsBySlot = new Map<string, readonly (readonly [number, number])[]>();
+  for (const slot of slots) {
+    const slotId = dataField(slot, 'id');
+    const formats = frozenArray(dataField(slot, 'formats'));
+    if (typeof slotId !== 'string' || formatsBySlot.has(slotId) || !formats) return undefined;
+    const copied: Array<readonly [number, number]> = [];
+    for (let index = 0; index < formats.length && index < 16; index += 1) {
+      const format = formats[index];
+      const dimensions = frozenArray(format);
+      if (
+        !dimensions ||
+        dimensions.length !== 2 ||
+        !dimensions.every(
+          (dimension) =>
+            typeof dimension === 'number' &&
+            Number.isInteger(dimension) &&
+            dimension >= 1 &&
+            dimension <= 4096
+        )
+      ) {
+        return undefined;
+      }
+      copied.push(Object.freeze([dimensions[0] as number, dimensions[1] as number] as const));
+    }
+    if (copied.length === 0) return undefined;
+    formatsBySlot.set(slotId, Object.freeze(copied));
+  }
+  const identities = new Map<string, ReturnType<GoogletagAdapter['diagnosticsIdentity']>>();
+  const requestByToken = new Map<
+    string,
+    Readonly<{ formats: readonly (readonly [number, number])[]; slotId: string }>
+  >();
+  for (let index = 0; index < cycles.length; index += 1) {
+    const token = dataField(cycles[index], 'token');
+    const slotId = dataField(cycles[index], 'slotId');
+    const physicalSlot = adoption.identities[index];
+    const formats = typeof slotId === 'string' ? formatsBySlot.get(slotId) : undefined;
+    if (typeof token !== 'string' || typeof slotId !== 'string' || !formats || !physicalSlot) {
+      return undefined;
+    }
+    let identity: ReturnType<GoogletagAdapter['diagnosticsIdentity']>;
+    try {
+      identity = adapter.diagnosticsIdentity(physicalSlot);
+    } catch {
+      return undefined;
+    }
+    if (!identity || identity.traceToken !== token || identities.has(token)) return undefined;
+    identities.set(token, identity);
+    requestByToken.set(token, Object.freeze({ formats, slotId }));
+  }
+  try {
+    return buffer.adoptFirstDisplay(
+      diagnostics as Readonly<FirstDisplayGptDiagnosticsV1>,
+      (traceToken) => identities.get(traceToken),
+      (traceToken, slot) => {
+        const request = requestByToken.get(traceToken);
+        const trustedServerAuctionId = projection?.auction.auctionId;
+        return request &&
+          typeof trustedServerAuctionId === 'string' &&
+          trustedServerAuctionId.length > 0
+          ? createTrustedServerOpportunityFact({
+              auctionSlotId: request.slotId,
+              opportunity: 'renderable_candidate',
+              requestedSlotSizes: request.formats,
+              slot,
+              trustedServerAuctionId,
+            })
+          : undefined;
+      }
+    )
+      ? adoption
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Adopt the exact transferred GPT identities without defining, targeting, displaying, or refreshing. */
+export function adoptInitialGptSlotsFromHandoff(
+  candidate: unknown,
+  navigationGeneration: object,
+  service: Pick<
+    SlotService,
+    'adoptCommittedArtifact' | 'adoptGptSlot' | 'adoptRegistrationHighWater'
+  >,
+  artifactStore: Pick<CommittedArtifactStore, 'current'>,
+  targeting: Pick<TargetingService, 'adopt' | 'observePublisherMutations'>,
+  adapter: GoogletagAdapter
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  if (!adoption) return undefined;
+  const slots = frozenArray(dataField(adoption.handoff, 'slots'));
+  const cycles = frozenArray(dataField(adoption.handoff, 'cycles'));
+  const artifacts = frozenArray(dataField(adoption.handoff, 'artifacts'));
+  const highWater = dataField(adoption.handoff, 'highWater');
+  const nextSlotRegistrationOrdinal = dataField(highWater, 'nextSlotRegistrationOrdinal');
+  if (
+    !slots ||
+    !cycles ||
+    !artifacts ||
+    typeof nextSlotRegistrationOrdinal !== 'number' ||
+    adoption.identities.length !== cycles.length + artifacts.length
+  ) {
+    return undefined;
+  }
+  if (!service.adoptRegistrationHighWater(navigationGeneration, nextSlotRegistrationOrdinal)) {
+    return undefined;
+  }
+  const slotById = new Map<string, unknown>();
+  for (const slot of slots) {
+    const id = dataField(slot, 'id');
+    if (typeof id !== 'string' || slotById.has(id)) return undefined;
+    slotById.set(id, slot);
+  }
+  const adopted = new Set<string>();
+  for (let index = 0; index < cycles.length; index += 1) {
+    const cycle = cycles[index];
+    const slotId = dataField(cycle, 'slotId');
+    const placement = typeof slotId === 'string' ? slotById.get(slotId) : undefined;
+    const identity = adoption.identities[index];
+    const owner = dataField(placement, 'owner');
+    const domId = dataField(placement, 'domId');
+    const gamPath = dataField(placement, 'gamPath');
+    const formats = frozenArray(dataField(placement, 'formats'));
+    const targetingOwnership = frozenArray(dataField(placement, 'targetingOwnership'));
+    if (
+      typeof slotId !== 'string' ||
+      adopted.has(slotId) ||
+      (owner !== 'publisher' && owner !== 'trusted_server') ||
+      typeof identity !== 'object' ||
+      identity === null ||
+      !targetingOwnership ||
+      (owner === 'trusted_server' &&
+        (typeof domId !== 'string' || typeof gamPath !== 'string' || !formats))
+    ) {
+      return undefined;
+    }
+    const binding: GptSlotBinding =
+      owner === 'trusted_server'
+        ? {
+            definition: {
+              adUnitPath: gamPath as string,
+              elementId: domId as string,
+              sizes: formats as readonly unknown[],
+            },
+            ownership: owner,
+            slot: identity,
+          }
+        : { ownership: owner, slot: identity };
+    const result = service.adoptGptSlot(navigationGeneration, slotId, binding);
+    if (!result.ok) return undefined;
+    const artifact = artifactStore.current(slotId);
+    if (!artifact) return undefined;
+    const releases: TargetingOwnership[] = [];
+    let observation: ReturnType<TargetingService['observePublisherMutations']> | undefined;
+    const releaseTargeting = (): void => {
+      for (let releaseIndex = releases.length - 1; releaseIndex >= 0; releaseIndex -= 1) {
+        try {
+          releases[releaseIndex]?.release();
+        } catch {
+          // Exact artifact retirement contains hostile GPT targeting cleanup.
+        }
+      }
+      releases.length = 0;
+      try {
+        observation?.dispose();
+      } catch {
+        // Adapter observation cleanup cannot restore retired ownership.
+      }
+      observation = undefined;
+    };
+    try {
+      if (targetingOwnership.length > 0) {
+        observation = targeting.observePublisherMutations(identity, adapter);
+        if (observation.status !== 'present') {
+          releaseTargeting();
+          return undefined;
+        }
+        const boundary = synchronousTargetingBoundary(adapter, identity);
+        for (
+          let ownershipIndex = 0;
+          ownershipIndex < targetingOwnership.length;
+          ownershipIndex += 1
+        ) {
+          const ownership = targetingOwnership[ownershipIndex];
+          const key = dataField(ownership, 'key');
+          const installed = dataField(ownership, 'installed');
+          const prior = frozenArray(dataField(ownership, 'prior'));
+          if (
+            typeof key !== 'string' ||
+            typeof installed !== 'string' ||
+            !prior ||
+            prior.some((value) => typeof value !== 'string')
+          ) {
+            releaseTargeting();
+            return undefined;
+          }
+          const adopted = targeting.adopt(
+            identity,
+            key,
+            installed,
+            prior as readonly string[],
+            artifact.attemptId,
+            boundary
+          );
+          if (!adopted) {
+            releaseTargeting();
+            return undefined;
+          }
+          releases.push(adopted);
+        }
+      }
+    } catch {
+      releaseTargeting();
+      return undefined;
+    }
+    if (!service.adoptCommittedArtifact(navigationGeneration, slotId, artifact, releaseTargeting)) {
+      releaseTargeting();
+      return undefined;
+    }
+    adopted.add(slotId);
+  }
+  return adoption;
+}
+
+export type GptLaterNavigationResult =
+  | Readonly<{
+      status: 'committed';
+      navigationGeneration: object;
+      current: true;
+    }>
+  | Readonly<{
+      status: 'rejected';
+      navigationGeneration: object;
+      current: boolean;
+    }>;
+
+export interface GptCapabilityV1 {
+  readonly activateLaterLifecycle: () => Readonly<{
+    readonly navigate: (path: string) => Promise<GptLaterNavigationResult>;
+    readonly release: () => void;
+  }>;
+  readonly adapter: GoogletagAdapter;
+  readonly directAuctionUnitForSlot: (slot: object) => Readonly<object> | undefined;
+  readonly installRefreshPolicy: ReturnType<typeof createGptStartup>['installRefreshPolicy'];
+  readonly navigation: () => NavigationSession | undefined;
+  readonly slots: SlotService;
+}
+
+const arrayIsArrayIntrinsic = Array.isArray;
+const numberIsFiniteIntrinsic = Number.isFinite;
+const objectGetOwnPropertyDescriptorIntrinsic = Object.getOwnPropertyDescriptor;
+const objectGetOwnPropertyNamesIntrinsic = Object.getOwnPropertyNames;
+const objectGetOwnPropertySymbolsIntrinsic = Object.getOwnPropertySymbols;
+const objectIsFrozenIntrinsic = Object.isFrozen;
+const jsonParseIntrinsic = JSON.parse;
+const promiseThenIntrinsic = Promise.prototype.then;
+const reflectApplyIntrinsic = Reflect.apply;
+const stringIncludesIntrinsic = String.prototype.includes;
+const stringJoinIntrinsic = Array.prototype.join;
+const stringSplitIntrinsic = String.prototype.split;
+const stringTrimIntrinsic = String.prototype.trim;
+const stringCharCodeAtIntrinsic = String.prototype.charCodeAt;
+const textEncoder = new TextEncoder();
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+
+type OwnedBrowserAuctionBidV1 = Extract<
+  BrowserAuctionBidV1,
+  { readonly rendererReservationId: string }
+>;
+type PbsCacheBrowserAuctionBidV1 = Extract<
+  BrowserAuctionBidV1,
+  { readonly renderSource: BaselinePbsCacheSourceV1 }
+>;
+
+function validGptTargetingValue(value: string): boolean {
+  if (value.length === 0) return false;
+  let scalars = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = reflectApplyIntrinsic(stringCharCodeAtIntrinsic, value, [index]) as number;
+    if (code <= 0x1f || code === 0x7f) return false;
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = reflectApplyIntrinsic(stringCharCodeAtIntrinsic, value, [index + 1]) as number;
+      if (!(next >= 0xdc00 && next <= 0xdfff)) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return false;
+    }
+    scalars += 1;
+    if (scalars > 40) return false;
+  }
+  return (
+    (reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [value]) as Uint8Array)
+      .byteLength <= 160
+  );
+}
+
+interface ProductionAuctionCapability {
+  readonly navigation: NavigationSession;
+  readonly projection: Readonly<BrowserAuctionProjectionV1>;
+  readonly session: RuntimeSession;
+}
+
+interface ProductionSlotsCapability {
+  readonly attachPhysicalService: (service: SlotService) => () => void;
+}
+
+interface ProductionApsCapability {
+  readonly renderPuc: NonNullable<PucBridgeOptions['mountAps']>;
+}
+
+interface ProductionRenderCapability {
+  readonly attachPucGamAttemptRegistrar: (
+    registrar: (input: PucGamAttemptInput) => boolean
+  ) => () => void;
+  readonly artifacts: Readonly<{
+    current: (slot: string) => CommittedRenderArtifact | undefined;
+    release: (artifact: CommittedRenderArtifact) => boolean;
+  }>;
+  readonly bindArtifactRetirement: (
+    artifact: CommittedRenderArtifact,
+    retire: () => void
+  ) => boolean;
+  readonly createAttempt: (
+    owner: RenderAttemptScope,
+    parentAttemptId?: string
+  ) => RenderAttemptCreationResult;
+  readonly createSlotOperation: (options: SlotOperationOptions) => SlotOperationCreationResult;
+  readonly commitPageBids: (
+    owner: NavigationSession,
+    slotRegistry: ReturnType<SlotService['projectionRegistry']>,
+    candidate: unknown
+  ) => boolean;
+  readonly mintLifecycleTicket: () => IdentityGenerationResult<string>;
+  readonly renderWinner: (attempt: RenderAttempt) => boolean;
+  readonly reservations: ReservationService;
+}
+
+interface ProductionMessagesCapability {
+  readonly messaging: Parameters<typeof createPucBridge>[0]['messaging'];
+}
+
+interface ProductionTraceCapability {
+  readonly observations: Readonly<{
+    publish: (observation: Readonly<Record<string, unknown>>) => boolean;
+  }>;
+}
+
+interface InitialProjectionServices {
+  readonly googletag: GoogletagAdapter;
+  readonly projection: Readonly<BrowserAuctionProjectionV1>;
+  readonly navigation: NavigationSession;
+  readonly protect: RuntimeCapabilityV1['protectFirstDisplayAttemptBatch'];
+  readonly pucBridge: Pick<PucBridge, 'recordNonemptyGam' | 'registerGamAttempt'>;
+  readonly render: ProductionRenderCapability;
+  readonly slots: SlotService;
+  readonly targeting: TargetingService;
+  readonly requestClass?: string;
+}
+
+export interface GptSlotOperationInput extends Omit<PucGamAttemptInput, 'attempt'> {
+  readonly attempt: RenderAttempt;
+  readonly createFallback?: SlotOperationOptions['createFallback'];
+  readonly createSlotOperation: (options: SlotOperationOptions) => SlotOperationCreationResult;
+  readonly operation: 'display' | 'refresh';
+  readonly pucBridge: Pick<PucBridge, 'recordNonemptyGam' | 'registerGamAttempt'>;
+  readonly requestClass: string;
+  readonly slots: Pick<SlotService, 'request'>;
+  readonly trustedServerOpportunity?: TrustedServerRequestOpportunity;
+}
+
+export type GptWinnerPublicationFailureReason = Extract<
+  RenderFailureReason,
+  | 'descriptor_invalid'
+  | 'gpt_request_failed'
+  | 'registry_full'
+  | 'reservation_collision'
+  | 'slot_unresolved'
+  | 'winner_not_renderable'
+>;
+
+export type GptWinnerPublicationResult =
+  | Extract<SlotOperationCreationResult, { ok: true }>
+  | Readonly<{ ok: false; reason: GptWinnerPublicationFailureReason }>;
+
+export interface GptWinnerPublicationInput extends Omit<
+  GptSlotOperationInput,
+  'artifact' | 'pucBridge' | 'reservationId' | 'slots'
+> {
+  readonly artifact: CommittedRenderArtifact;
+  readonly bid: OwnedBrowserAuctionBidV1;
+  readonly googletag: GoogletagAdapter;
+  readonly navigation: NavigationSession;
+  readonly placement: BrowserAuctionSlotV1;
+  readonly pucBridge: Pick<PucBridge, 'recordNonemptyGam' | 'registerGamAttempt'>;
+  readonly reservations: Pick<ReservationService, 'registerRender' | 'tombstone'>;
+  readonly slot: object;
+  readonly slots: Pick<SlotService, 'isBoundGptSlot' | 'request'>;
+  readonly targeting: Pick<TargetingService, 'observePublisherMutations' | 'own'>;
+}
+
+function currentProjectedWinner(
+  input: GptWinnerPublicationInput,
+  projection: Readonly<BrowserAuctionProjectionV1> | undefined
+): boolean {
+  try {
+    const bid = input.bid;
+    const placement = input.placement;
+    if (
+      !projection ||
+      !objectIsFrozenIntrinsic(projection) ||
+      !objectIsFrozenIntrinsic(bid) ||
+      !objectIsFrozenIntrinsic(bid.renderSource) ||
+      !objectIsFrozenIntrinsic(bid.targeting) ||
+      !objectIsFrozenIntrinsic(placement) ||
+      !objectIsFrozenIntrinsic(placement.formats) ||
+      !objectIsFrozenIntrinsic(placement.targeting) ||
+      bid.slot !== input.attempt.slot ||
+      placement.slot !== bid.slot ||
+      input.attempt.navigationGeneration !== input.navigation.generation ||
+      input.owner.id !== input.attempt.id ||
+      input.owner.slot !== input.attempt.slot ||
+      input.owner.generation !== input.attempt.generation ||
+      input.owner.navigationGeneration !== input.navigation.generation ||
+      input.artifact.kind !== 'puc' ||
+      input.artifact.attemptId !== input.attempt.id ||
+      input.artifact.slot !== input.attempt.slot ||
+      input.artifact.navigationGeneration !== input.navigation.generation ||
+      typeof input.artifact.dispose !== 'function' ||
+      typeof input.slot !== 'object' ||
+      input.slot === null ||
+      !input.navigation.isCurrent() ||
+      input.attempt.snapshot().outcome !== undefined
+    ) {
+      return false;
+    }
+    let exactBid = false;
+    for (let index = 0; index < projection.bids.length; index += 1) {
+      if (projection.bids[index] === bid) {
+        if (exactBid) return false;
+        exactBid = true;
+      }
+    }
+    if (!exactBid) return false;
+    let exactPlacement = false;
+    for (let index = 0; index < projection.slots.length; index += 1) {
+      if (projection.slots[index] === placement) {
+        if (exactPlacement) return false;
+        exactPlacement = true;
+      }
+    }
+    if (!exactPlacement) return false;
+    let exactWinner = false;
+    for (let index = 0; index < projection.auction.results.length; index += 1) {
+      const result = projection.auction.results[index];
+      if (
+        result?.outcome === 'winner' &&
+        result.slot === bid.slot &&
+        result.candidateId === bid.candidateId
+      ) {
+        if (exactWinner) return false;
+        exactWinner = true;
+      }
+    }
+    return exactWinner;
+  } catch {
+    return false;
+  }
+}
+
+function targetingEntries(
+  bid: BrowserAuctionBidV1,
+  placement: BrowserAuctionSlotV1
+): readonly (readonly [string, string])[] | undefined {
+  try {
+    const bidNames = objectGetOwnPropertyNamesIntrinsic(bid.targeting);
+    const placementNames = objectGetOwnPropertyNamesIntrinsic(placement.targeting);
+    if (
+      bidNames.length > 32 ||
+      placementNames.length > 32 ||
+      objectGetOwnPropertySymbolsIntrinsic(bid.targeting).length !== 0 ||
+      objectGetOwnPropertySymbolsIntrinsic(placement.targeting).length !== 0
+    ) {
+      return undefined;
+    }
+    const names: string[] = [];
+    const insertNames = (source: readonly string[]): boolean => {
+      for (let index = 0; index < source.length; index += 1) {
+        const name = source[index];
+        if (!name || name === 'hb_adid' || name === 'hb_cache_host' || name === 'hb_cache_path') {
+          return false;
+        }
+        let insertion = 0;
+        while (insertion < names.length && (names[insertion] as string) < name) insertion += 1;
+        if (names[insertion] === name) continue;
+        for (let move = names.length; move > insertion; move -= 1) {
+          names[move] = names[move - 1] as string;
+        }
+        names[insertion] = name;
+      }
+      return true;
+    };
+    if (!insertNames(placementNames) || !insertNames(bidNames)) return undefined;
+    const entries: Array<readonly [string, string]> = !('rendererReservationId' in bid)
+      ? [
+          Object.freeze(['hb_adid', bid.renderSource.cacheId]),
+          Object.freeze(['hb_cache_host', bid.renderSource.cacheHost]),
+          Object.freeze(['hb_cache_path', bid.renderSource.cachePath]),
+        ]
+      : [Object.freeze(['hb_adid', bid.rendererReservationId])];
+    for (let index = 0; index < entries.length; index += 1) {
+      const entry = entries[index];
+      if (!entry || !validGptTargetingValue(entry[1])) return undefined;
+    }
+    for (let index = 0; index < names.length; index += 1) {
+      const key = names[index];
+      if (!key) return undefined;
+      const bidDescriptor = objectGetOwnPropertyDescriptorIntrinsic(bid.targeting, key);
+      const placementDescriptor = objectGetOwnPropertyDescriptorIntrinsic(placement.targeting, key);
+      const descriptor = bidDescriptor ?? placementDescriptor;
+      if (
+        !descriptor ||
+        !descriptor.enumerable ||
+        !('value' in descriptor) ||
+        typeof descriptor.value !== 'string'
+      ) {
+        return undefined;
+      }
+      entries[entries.length] = Object.freeze([key, descriptor.value]);
+    }
+    return Object.freeze(entries);
+  } catch {
+    return undefined;
+  }
+}
+
+function synchronousTargetingBoundary(adapter: GoogletagAdapter, slot: object): TargetingBoundary {
+  const invoke = <Value>(command: (gpt: Readonly<GoogletagFacade>) => Value): Value => {
+    let completed = false;
+    let failed = false;
+    let value: Value | undefined;
+    let failure: unknown;
+    const operation = adapter.run((gpt) => {
+      try {
+        value = command(gpt);
+        return value;
+      } catch (error) {
+        failed = true;
+        failure = error;
+        throw error;
+      } finally {
+        completed = true;
+      }
+    });
+    void reflectApplyIntrinsic(promiseThenIntrinsic, operation.result, [
+      () => undefined,
+      () => undefined,
+    ]);
+    if (!completed) {
+      operation.dispose();
+      throw new Error('GPT targeting operation is not synchronously available');
+    }
+    if (failed) throw failure;
+    return value as Value;
+  };
+  return Object.freeze({
+    clearTargeting: (key?: string) => invoke((gpt) => gpt.clearTargeting(slot, key)),
+    getTargeting: (key: string) => invoke((gpt) => gpt.getTargeting(slot, key)),
+    setTargeting: (key: string, value: string | readonly string[]) =>
+      invoke((gpt) => gpt.setTargeting(slot, key, value)),
+  });
+}
+
+function reservationFailure(reason: string): GptWinnerPublicationFailureReason {
+  if (reason === 'reservation_collision') return 'reservation_collision';
+  if (reason === 'registry_full') return 'registry_full';
+  if (reason === 'invalid_render_source' || reason === 'invalid_reservation_id') {
+    return 'descriptor_invalid';
+  }
+  return 'gpt_request_failed';
+}
+
+/** Publish one server-projected PUC winner without exposing capability state out of order. */
+export async function publishGptWinner(
+  input: GptWinnerPublicationInput
+): Promise<GptWinnerPublicationResult> {
+  const failAttempt = (reason: GptWinnerPublicationFailureReason): GptWinnerPublicationResult => {
+    try {
+      input.attempt.fail(reason);
+    } catch {
+      // The attempt latch remains authoritative.
+    }
+    return Object.freeze({ ok: false, reason });
+  };
+  const disposeArtifact = (): void => {
+    try {
+      input.artifact.dispose();
+    } catch {
+      // Rejected publication retains no artifact authority.
+    }
+  };
+  const projection = input.navigation.currentAuctionProjection as
+    Readonly<BrowserAuctionProjectionV1> | undefined;
+  if (!projection || !currentProjectedWinner(input, projection)) {
+    disposeArtifact();
+    return failAttempt('winner_not_renderable');
+  }
+  const trustedServerOpportunity: TrustedServerRequestOpportunity = Object.freeze({
+    requestedSlotSizes: Object.freeze(
+      input.placement.formats.map((size) => Object.freeze([size[0], size[1]] as const))
+    ),
+    trustedServerAuctionId: projection.auction.auctionId,
+  });
+  const isStillBound = (): boolean => {
+    try {
+      return input.slots.isBoundGptSlot(input.navigation.generation, input.bid.slot, input.slot);
+    } catch {
+      return false;
+    }
+  };
+  if (!isStillBound()) {
+    disposeArtifact();
+    return failAttempt('slot_unresolved');
+  }
+  const entries = targetingEntries(input.bid, input.placement);
+  if (!entries) {
+    disposeArtifact();
+    return failAttempt('descriptor_invalid');
+  }
+  const winnerContext = Object.freeze({ selectedCpm: input.bid.cpm });
+  const registration = (() => {
+    try {
+      return input.reservations.registerRender({
+        reservationId: input.bid.rendererReservationId,
+        slot: input.bid.slot,
+        navigation: input.navigation,
+        attemptId: input.attempt.id,
+        renderSource: input.bid.renderSource,
+        winnerContext,
+      });
+    } catch {
+      return Object.freeze({ ok: false as const, reason: 'service_disposed' as const });
+    }
+  })();
+  if (!registration.ok) {
+    disposeArtifact();
+    return failAttempt(reservationFailure(registration.reason));
+  }
+
+  const owners: TargetingOwnership[] = [];
+  let observation: ReturnType<TargetingService['observePublisherMutations']> | undefined;
+  let retirementAttempted = false;
+  let resourcesDisposed = false;
+  const tombstone = (): void => {
+    if (retirementAttempted) return;
+    retirementAttempted = true;
+    try {
+      input.reservations.tombstone(
+        {
+          reservationId: input.bid.rendererReservationId,
+          slot: input.bid.slot,
+          navigationGeneration: input.navigation.generation,
+          attemptId: input.attempt.id,
+        },
+        'disposed'
+      );
+    } catch {
+      // Runtime disposal retains the last-resort retirement boundary.
+    }
+  };
+  const disposeResources = (): void => {
+    if (resourcesDisposed) return;
+    resourcesDisposed = true;
+    tombstone();
+    for (let index = owners.length - 1; index >= 0; index -= 1) {
+      try {
+        owners[index]?.release();
+      } catch {
+        // One targeting cleanup cannot suppress the remaining rollback.
+      }
+    }
+    try {
+      observation?.dispose();
+    } catch {
+      // The adapter owns final wrapper restoration.
+    }
+    disposeArtifact();
+  };
+  try {
+    observation = input.targeting.observePublisherMutations(input.slot, input.googletag);
+    await observation.result;
+    if (!input.navigation.isCurrent() || input.attempt.snapshot().outcome !== undefined) {
+      throw new Error('stale GPT publication');
+    }
+    if (!isStillBound()) {
+      disposeResources();
+      return failAttempt('slot_unresolved');
+    }
+    const boundary = synchronousTargetingBoundary(input.googletag, input.slot);
+    for (let index = 0; index < entries.length; index += 1) {
+      const entry = entries[index];
+      if (!entry) throw new Error('targeting entry unavailable');
+      const owner = input.targeting.own(input.slot, entry[0], entry[1], input.attempt.id, boundary);
+      if (!owner) throw new Error('targeting ownership unavailable');
+      owners[owners.length] = owner;
+    }
+    if (!input.navigation.isCurrent() || input.attempt.snapshot().outcome !== undefined) {
+      throw new Error('stale GPT publication');
+    }
+    if (!isStillBound()) {
+      disposeResources();
+      return failAttempt('slot_unresolved');
+    }
+  } catch {
+    disposeResources();
+    return failAttempt('gpt_request_failed');
+  }
+
+  const publishedArtifact = Object.freeze({
+    kind: 'puc' as const,
+    attemptId: input.artifact.attemptId,
+    slot: input.artifact.slot,
+    navigationGeneration: input.artifact.navigationGeneration,
+    dispose: disposeResources,
+  });
+  let bridgeRegistered = false;
+  let requestStarted = false;
+  let operation: SlotOperationCreationResult;
+  try {
+    operation = startGptSlotOperation({
+      artifact: publishedArtifact,
+      attempt: input.attempt,
+      ...(input.createFallback === undefined ? {} : { createFallback: input.createFallback }),
+      createSlotOperation: input.createSlotOperation,
+      operation: input.operation,
+      owner: input.owner,
+      pucBridge: {
+        registerGamAttempt: (bridgeInput) => {
+          bridgeRegistered = input.pucBridge.registerGamAttempt(bridgeInput) === true;
+          return bridgeRegistered;
+        },
+        recordNonemptyGam: (bridgeInput) => input.pucBridge.recordNonemptyGam(bridgeInput),
+      },
+      requestClass: input.requestClass,
+      trustedServerOpportunity,
+      reservationId: input.bid.rendererReservationId,
+      slots: {
+        request: (requestInput) => {
+          const handle = input.slots.request({ ...requestInput, expectedSlot: input.slot });
+          requestStarted = true;
+          return handle;
+        },
+      },
+    });
+  } catch {
+    disposeResources();
+    return failAttempt('gpt_request_failed');
+  }
+  if (!operation.ok || !bridgeRegistered || !requestStarted) {
+    disposeResources();
+    return failAttempt('gpt_request_failed');
+  }
+  return operation;
+}
+
+interface PbsCacheGptPublicationInput {
+  readonly bid: PbsCacheBrowserAuctionBidV1;
+  readonly binding: Readonly<{ operation: 'display' | 'refresh'; slot: object }>;
+  readonly googletag: GoogletagAdapter;
+  readonly navigation: NavigationSession;
+  readonly placement: BrowserAuctionSlotV1;
+  readonly requestClass: string;
+  readonly slots: Pick<SlotService, 'isBoundGptSlot' | 'request'>;
+  readonly targeting: Pick<TargetingService, 'observePublisherMutations' | 'own'>;
+}
+
+async function publishPbsCacheGptWinner(input: PbsCacheGptPublicationInput): Promise<void> {
+  const projection = input.navigation.currentAuctionProjection as
+    Readonly<BrowserAuctionProjectionV1> | undefined;
+  if (!projection) return;
+  const trustedServerOpportunity: TrustedServerRequestOpportunity = Object.freeze({
+    requestedSlotSizes: Object.freeze(
+      input.placement.formats.map((size) => Object.freeze([size[0], size[1]] as const))
+    ),
+    trustedServerAuctionId: projection.auction.auctionId,
+  });
+  const current = (): boolean => {
+    try {
+      if (
+        !input.navigation.isCurrent() ||
+        input.navigation.currentAuctionProjection !== projection
+      ) {
+        return false;
+      }
+      let bids = 0;
+      let slots = 0;
+      let winners = 0;
+      for (let index = 0; index < projection.bids.length; index += 1) {
+        if (projection.bids[index] === input.bid) bids += 1;
+      }
+      for (let index = 0; index < projection.slots.length; index += 1) {
+        if (projection.slots[index] === input.placement) slots += 1;
+      }
+      for (let index = 0; index < projection.auction.results.length; index += 1) {
+        const decision = projection.auction.results[index];
+        if (
+          decision?.outcome === 'winner' &&
+          decision.slot === input.bid.slot &&
+          decision.candidateId === input.bid.candidateId
+        ) {
+          winners += 1;
+        }
+      }
+      return (
+        bids === 1 &&
+        slots === 1 &&
+        winners === 1 &&
+        input.slots.isBoundGptSlot(input.navigation.generation, input.bid.slot, input.binding.slot)
+      );
+    } catch {
+      return false;
+    }
+  };
+  if (!current()) return;
+  const entries = targetingEntries(input.bid, input.placement);
+  if (!entries) return;
+
+  const ownerId = `pbs-cache:${projection.auction.auctionId}:${input.bid.candidateId}`;
+  const owners: TargetingOwnership[] = [];
+  let observation: ReturnType<TargetingService['observePublisherMutations']> | undefined;
+  let handle: ReturnType<SlotService['request']> | undefined;
+  try {
+    observation = input.targeting.observePublisherMutations(input.binding.slot, input.googletag);
+    await observation.result;
+    if (!current()) return;
+    const boundary = synchronousTargetingBoundary(input.googletag, input.binding.slot);
+    for (let index = 0; index < entries.length; index += 1) {
+      const entry = entries[index];
+      if (!entry) return;
+      const ownership = input.targeting.own(
+        input.binding.slot,
+        entry[0],
+        entry[1],
+        ownerId,
+        boundary
+      );
+      if (!ownership) return;
+      owners.push(ownership);
+    }
+    if (!current()) return;
+    handle = input.slots.request({
+      expectedSlot: input.binding.slot,
+      intentId: ownerId,
+      navigationGeneration: input.navigation.generation,
+      operation: input.binding.operation,
+      registeredSlotId: input.bid.slot,
+      requestClass: input.requestClass,
+      trustedServerOpportunity,
+    });
+    await handle.result;
+  } catch (error) {
+    if (input.navigation.isCurrent()) log.warn('GPT PBS Cache publication failed', error);
+  } finally {
+    try {
+      handle?.dispose();
+    } catch {
+      // Request settlement remains authoritative.
+    }
+    for (let index = owners.length - 1; index >= 0; index -= 1) {
+      try {
+        owners[index]?.release();
+      } catch {
+        // One targeting cleanup cannot suppress the remaining rollback.
+      }
+    }
+    try {
+      observation?.dispose();
+    } catch {
+      // The adapter owns final wrapper restoration.
+    }
+  }
+}
+
+function settleFromSlotOutcome(
+  attempt: RenderAttempt,
+  bridge: GptSlotOperationInput['pucBridge'],
+  bridgeInput: PucGamAttemptInput,
+  outcome: SlotRequestOutcome
+): void {
+  try {
+    if (outcome.status === 'empty') {
+      attempt.fail('gam_empty');
+      return;
+    }
+    if (outcome.status === 'rendered') {
+      if (!bridge.recordNonemptyGam(bridgeInput)) attempt.fail('cycle_unattributable');
+      return;
+    }
+    if (outcome.status === 'failed') {
+      attempt.fail(outcome.reason);
+      return;
+    }
+    if (outcome.status === 'cancelled') attempt.cancel(outcome.reason);
+  } catch {
+    try {
+      attempt.fail('internal_error');
+    } catch {
+      // The attempt latch remains the terminal authority.
+    }
+  }
+}
+
+/**
+ * Join one TS-owned physical GPT cycle to its primary render attempt.
+ *
+ * Only the slot service may identify an attributable empty cycle. The resulting
+ * `gam_empty` transition is therefore the sole path that can activate the
+ * optional `SlotOperation` fallback child.
+ */
+export function startGptSlotOperation(input: GptSlotOperationInput): SlotOperationCreationResult {
+  const operation = input.createSlotOperation({
+    primary: input.attempt,
+    ...(input.createFallback === undefined ? {} : { createFallback: input.createFallback }),
+  });
+  if (!operation.ok) return operation;
+
+  const bridgeInput = Object.freeze({
+    artifact: input.artifact,
+    attempt: input.attempt,
+    owner: input.owner,
+    reservationId: input.reservationId,
+  });
+  const registered = (() => {
+    try {
+      return input.pucBridge.registerGamAttempt(bridgeInput);
+    } catch {
+      return false;
+    }
+  })();
+  if (!registered) {
+    try {
+      input.attempt.fail('gpt_request_failed');
+    } catch {
+      // The operation still observes any terminal result already committed by the bridge.
+    }
+    return operation;
+  }
+
+  let handle: ReturnType<SlotService['request']>;
+  try {
+    handle = input.slots.request({
+      intentId: input.attempt.id,
+      navigationGeneration: input.attempt.navigationGeneration,
+      operation: input.operation,
+      registeredSlotId: input.attempt.slot,
+      requestClass: input.requestClass,
+      ...(input.trustedServerOpportunity === undefined
+        ? {}
+        : { trustedServerOpportunity: input.trustedServerOpportunity }),
+    });
+  } catch {
+    input.attempt.fail('gpt_request_failed');
+    return operation;
+  }
+
+  let handleDisposed = false;
+  const disposeHandle = (): void => {
+    if (handleDisposed) return;
+    handleDisposed = true;
+    try {
+      handle.dispose();
+    } catch {
+      // Attempt settlement remains authoritative when request cleanup throws.
+    }
+  };
+  const observing = (() => {
+    try {
+      return input.attempt.onSettled(disposeHandle);
+    } catch {
+      return false;
+    }
+  })();
+  if (!observing) {
+    disposeHandle();
+    try {
+      input.attempt.fail('internal_error');
+    } catch {
+      // A concurrently terminal attempt cannot be overwritten.
+    }
+    return operation;
+  }
+
+  void handle.result.then(
+    (outcome) => settleFromSlotOutcome(input.attempt, input.pucBridge, bridgeInput, outcome),
+    () => {
+      try {
+        input.attempt.fail('gpt_request_failed');
+      } catch {
+        // A late rejected request cannot overwrite an existing terminal outcome.
+      }
+    }
+  );
+  return operation;
+}
+
+function exactCapability<Value extends object>(
+  interfaces: Readonly<Record<string, unknown>>,
+  key: string
+): Value | undefined {
+  const candidate = interfaces[key];
+  return typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+    ? (candidate as Value)
+    : undefined;
+}
+
+function gptDiagnosticsActive(runtime: RuntimeCapabilityV1): boolean {
+  try {
+    const boot = runtime.boot();
+    if (!boot) return false;
+    const diagnostics = Object.getOwnPropertyDescriptor(boot, 'diagnostics');
+    if (!diagnostics || !('value' in diagnostics)) return false;
+    const gpt = Object.getOwnPropertyDescriptor(diagnostics.value, 'gpt');
+    if (!gpt || !('value' in gpt)) return false;
+    const active = Object.getOwnPropertyDescriptor(gpt.value, 'active');
+    return Boolean(active && 'value' in active && active.value === true);
+  } catch {
+    return false;
+  }
+}
+
+function resolveProjectedSlotElement(
+  document: Document,
+  placement: Readonly<BrowserAuctionSlotV1>
+): HTMLElement | undefined {
+  try {
+    const exact = document.getElementById(placement.divId);
+    if (exact instanceof HTMLElement) return exact;
+    const matches = [...document.querySelectorAll<HTMLElement>('[id]')].filter(
+      (element) => element.id.startsWith(placement.divId) && !element.id.endsWith('-container')
+    );
+    return matches.length === 1 ? matches[0] : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const TS_DISPLAY_RENDERER =
+  '(function(){window.render=function(d,h,w){' +
+  'var f=h.mkFrame(w.document,{width:d.width||"100%",height:d.height||"100%"});' +
+  'if(d.adUrl&&!d.ad){f.src=d.adUrl;}else{f.srcdoc=d.ad;}' +
+  'w.document.body.appendChild(f);};})();';
+
+const AUCTION_PRICE_MACRO = '${AUCTION_PRICE}';
+
+interface CachedPbsBid {
+  readonly adm: string;
+  readonly width?: number;
+  readonly height?: number;
+  readonly price?: number;
+}
+
+function expandCachedAuctionPriceMacro(markup: string, cpm: number): string {
+  if (!(reflectApplyIntrinsic(stringIncludesIntrinsic, markup, [AUCTION_PRICE_MACRO]) as boolean)) {
+    return markup;
+  }
+  const pieces = reflectApplyIntrinsic(stringSplitIntrinsic, markup, [
+    AUCTION_PRICE_MACRO,
+  ]) as string[];
+  return reflectApplyIntrinsic(stringJoinIntrinsic, pieces, [String(cpm)]) as string;
+}
+
+/** Preserve current-main PBS Cache decoding inside GPT without publishing a cache service. */
+function parseCachedPbsBid(body: string): CachedPbsBid | undefined {
+  let parsed: unknown;
+  try {
+    parsed = reflectApplyIntrinsic(jsonParseIntrinsic, JSON, [body]) as unknown;
+  } catch {
+    const trimmed = reflectApplyIntrinsic(stringTrimIntrinsic, body, []) as string;
+    return trimmed.length > 0 ? Object.freeze({ adm: body }) : undefined;
+  }
+  if (!parsed || typeof parsed !== 'object' || arrayIsArrayIntrinsic(parsed)) return undefined;
+  const record = parsed as Record<string, unknown>;
+  if (typeof record.adm !== 'string' || record.adm.length === 0) return undefined;
+  const finite = (value: unknown): number | undefined =>
+    typeof value === 'number' && numberIsFiniteIntrinsic(value) ? value : undefined;
+  const dimension = (value: unknown): number | undefined => {
+    const numeric = finite(value);
+    return numeric !== undefined && numeric > 0 ? numeric : undefined;
+  };
+  const width = dimension(record.w) ?? dimension(record.width);
+  const height = dimension(record.h) ?? dimension(record.height);
+  const price = finite(record.price);
+  return Object.freeze({
+    adm: record.adm,
+    ...(width === undefined ? {} : { width }),
+    ...(height === undefined ? {} : { height }),
+    ...(price === undefined ? {} : { price }),
+  });
+}
+
+type PbsCacheBridgeFailure =
+  'cache_fetch_failed' | 'invalid_cache_payload' | 'response_post_failed';
+
+/** Install the activation-scoped current-main PBS Cache bridge owned only by GPT. */
+export function installPbsCacheBridge(
+  document: Document,
+  auction: ProductionAuctionCapability,
+  isActive: () => boolean,
+  observe: (observation: Readonly<Record<string, unknown>>) => boolean
+): () => void {
+  const view = document.defaultView;
+  if (!view) throw new TypeError('GPT PBS Cache bridge requires a browser window');
+  const inFlight = new WeakMap<object, Set<string>>();
+  let listening = true;
+
+  const publishFailure = (slot: string, reason: PbsCacheBridgeFailure): void => {
+    try {
+      observe(Object.freeze({ kind: 'pbs_cache_bridge', slotId: slot, reason }));
+    } catch {
+      // Diagnostics cannot alter cache bridge ownership.
+    }
+  };
+  const parseRequest = (candidate: unknown): Readonly<{ adId: string }> | undefined => {
+    try {
+      const value =
+        typeof candidate === 'string'
+          ? (reflectApplyIntrinsic(jsonParseIntrinsic, JSON, [candidate]) as unknown)
+          : candidate;
+      if (typeof value !== 'object' || value === null || arrayIsArrayIntrinsic(value)) {
+        return undefined;
+      }
+      const record = value as Record<string, unknown>;
+      return record.message === 'Prebid Request' &&
+        typeof record.adId === 'string' &&
+        record.adId !== ''
+        ? Object.freeze({ adId: record.adId })
+        : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  const sourceOwnsPlacement = (
+    source: MessageEventSource | null,
+    placement: Readonly<BrowserAuctionSlotV1>
+  ): boolean => {
+    if (!source) return false;
+    try {
+      const exact = document.getElementById(placement.divId);
+      const configuredContainer = document.getElementById(`${placement.divId}-container`);
+      const owns = (root: HTMLElement): boolean => {
+        const frames = root.querySelectorAll('iframe');
+        for (let index = 0; index < frames.length; index += 1) {
+          if (frames.item(index)?.contentWindow === source) return true;
+        }
+        return false;
+      };
+      return (
+        (exact instanceof HTMLElement && owns(exact)) ||
+        (configuredContainer instanceof HTMLElement &&
+          configuredContainer !== exact &&
+          owns(configuredContainer))
+      );
+    } catch {
+      return false;
+    }
+  };
+  const listener = (event: MessageEvent): void => {
+    if (!listening || !isActive()) return;
+    const request = parseRequest(event.data);
+    const port = event.ports?.[0];
+    if (!request || !port || typeof port.postMessage !== 'function') return;
+    const navigation = auction.session.currentNavigation;
+    const projection = navigation?.currentAuctionProjection as
+      Readonly<BrowserAuctionProjectionV1> | undefined;
+    if (!navigation?.isCurrent() || !projection) return;
+    let placement: BrowserAuctionSlotV1 | undefined;
+    for (let index = 0; index < projection.slots.length; index += 1) {
+      const candidate = projection.slots[index];
+      if (!candidate || !sourceOwnsPlacement(event.source, candidate)) continue;
+      if (placement) return;
+      placement = candidate;
+    }
+    if (!placement) return;
+    let bid: PbsCacheBrowserAuctionBidV1 | undefined;
+    for (let index = 0; index < projection.bids.length; index += 1) {
+      const candidate = projection.bids[index];
+      if (
+        !candidate ||
+        candidate.slot !== placement.slot ||
+        candidate.renderSource.type !== 'pbs_cache' ||
+        candidate.renderSource.cacheId !== request.adId
+      ) {
+        continue;
+      }
+      if (bid) return;
+      bid = candidate as PbsCacheBrowserAuctionBidV1;
+    }
+    if (!bid) return;
+
+    event.stopImmediatePropagation();
+    const key = `${bid.slot}\u0000${request.adId}`;
+    let generationFlights = inFlight.get(navigation.generation);
+    if (!generationFlights) {
+      generationFlights = new Set<string>();
+      inFlight.set(navigation.generation, generationFlights);
+    }
+    if (generationFlights.has(key)) return;
+    generationFlights.add(key);
+
+    const remainsCurrent = (): boolean =>
+      listening &&
+      isActive() &&
+      navigation.isCurrent() &&
+      auction.session.currentNavigation === navigation &&
+      navigation.currentAuctionProjection === projection &&
+      (() => {
+        for (let index = 0; index < projection.bids.length; index += 1) {
+          if (projection.bids[index] === bid) return true;
+        }
+        return false;
+      })();
+    const cacheUrl = `https://${bid.renderSource.cacheHost}${bid.renderSource.cachePath}?uuid=${encodeURIComponent(request.adId)}`;
+    const complete = async (): Promise<void> => {
+      try {
+        const fetcher = globalThis.fetch;
+        if (typeof fetcher !== 'function') throw new Error('fetch unavailable');
+        const response = await fetcher(cacheUrl, { mode: 'cors' });
+        if (!response.ok) throw new Error(`cache HTTP ${response.status}`);
+        const body = await response.text();
+        if (!remainsCurrent()) return;
+        const cached = parseCachedPbsBid(body);
+        if (!cached) {
+          publishFailure(bid.slot, 'invalid_cache_payload');
+          return;
+        }
+        const width = cached.width ?? (bid.renderSource.width || placement.formats[0]?.[0] || 728);
+        const height =
+          cached.height ?? (bid.renderSource.height || placement.formats[0]?.[1] || 90);
+        const adm =
+          cached.price === undefined
+            ? cached.adm
+            : expandCachedAuctionPriceMacro(cached.adm, cached.price);
+        try {
+          port.postMessage(
+            JSON.stringify({
+              message: 'Prebid Response',
+              adId: request.adId,
+              ad: adm,
+              renderer: TS_DISPLAY_RENDERER,
+              width,
+              height,
+            })
+          );
+        } catch {
+          publishFailure(bid.slot, 'response_post_failed');
+          return;
+        }
+        if (!remainsCurrent()) return;
+        resizeCollapsedPucShell({ source: event.source as object, width, height });
+      } catch {
+        if (remainsCurrent()) publishFailure(bid.slot, 'cache_fetch_failed');
+      } finally {
+        generationFlights?.delete(key);
+      }
+    };
+    void complete();
+  };
+
+  view.addEventListener('message', listener);
+  return (): void => {
+    if (!listening) return;
+    listening = false;
+    view.removeEventListener('message', listener);
+  };
+}
+
+function terminalLatch(attempt: RenderAttempt): Promise<unknown> {
+  return new Promise((resolve) => {
+    if (!attempt.onSettled(resolve)) resolve(attempt.snapshot().outcome);
+  });
+}
+
+interface PreparedInitialGptWinner {
+  readonly attempt: RenderAttempt;
+  readonly bid: OwnedBrowserAuctionBidV1;
+  readonly binding: Readonly<{ operation: 'display' | 'refresh'; slot: object }> | undefined;
+  readonly decision: Readonly<{ slot: string; outcome: 'winner'; candidateId: string }>;
+  readonly owner: RenderAttemptScope;
+  readonly placement: BrowserAuctionSlotV1;
+  readonly terminal: Promise<unknown>;
+}
+
+interface PreparedInitialPbsCacheWinner {
+  readonly bid: PbsCacheBrowserAuctionBidV1;
+  readonly binding: Readonly<{ operation: 'display' | 'refresh'; slot: object }>;
+  readonly placement: BrowserAuctionSlotV1;
+}
+
+interface InitialGptRequestParticipant {
+  readonly complete: () => void;
+  readonly request: (input: SlotRequestInput) => SlotRequestHandle;
+}
+
+function failedBatchRequestHandle(): SlotRequestHandle {
+  const outcome = Object.freeze({
+    reason: 'gpt_request_failed' as const,
+    status: 'failed' as const,
+  });
+  return Object.freeze({
+    status: 'terminal' as const,
+    result: Promise.resolve(outcome),
+    dispose: () => undefined,
+  });
+}
+
+function createInitialGptRequestBatch(
+  slots: Pick<SlotService, 'requestBatch'>,
+  participantCount: number
+): Readonly<{ participant: () => InitialGptRequestParticipant }> {
+  interface PendingRequest {
+    readonly bind: (handle: SlotRequestHandle) => void;
+    readonly fail: () => void;
+    readonly input: SlotRequestInput;
+    readonly isDisposed: () => boolean;
+  }
+
+  const pending: PendingRequest[] = [];
+  let claimedParticipants = 0;
+  let readyParticipants = 0;
+  let flushed = false;
+  const flush = (): void => {
+    if (flushed || readyParticipants !== participantCount) return;
+    flushed = true;
+    const active = pending.filter((request) => !request.isDisposed());
+    if (active.length === 0) return;
+    let handles: readonly SlotRequestHandle[] = Object.freeze([]);
+    try {
+      const inputs = Object.freeze(active.map(({ input }) => input));
+      handles = slots.requestBatch(inputs);
+      if (!Array.isArray(handles) || handles.length !== active.length) {
+        throw new Error('GPT SRA batch admission failed');
+      }
+      for (let index = 0; index < active.length; index += 1) {
+        const request = active[index];
+        const handle = handles[index];
+        if (!request || !handle) throw new Error('GPT SRA batch result is incomplete');
+        request.bind(handle);
+      }
+    } catch {
+      for (let index = 0; index < handles.length; index += 1) {
+        try {
+          handles[index]?.dispose();
+        } catch {
+          // Continue rolling back the other partially returned handles.
+        }
+      }
+      for (let index = 0; index < active.length; index += 1) active[index]?.fail();
+    }
+  };
+
+  return Object.freeze({
+    participant: (): InitialGptRequestParticipant => {
+      if (claimedParticipants >= participantCount) {
+        return Object.freeze({
+          complete: () => undefined,
+          request: () => failedBatchRequestHandle(),
+        });
+      }
+      claimedParticipants += 1;
+      let ready = false;
+      let requested = false;
+      const markReady = (): void => {
+        if (ready) return;
+        ready = true;
+        readyParticipants += 1;
+        flush();
+      };
+      return Object.freeze({
+        complete: markReady,
+        request: (input: SlotRequestInput): SlotRequestHandle => {
+          if (requested || ready) return failedBatchRequestHandle();
+          requested = true;
+          let disposed = false;
+          let terminal = false;
+          let activeHandle: SlotRequestHandle | undefined;
+          let resolve!: (outcome: SlotRequestOutcome) => void;
+          const result = new Promise<SlotRequestOutcome>((resolveResult) => {
+            resolve = resolveResult;
+          });
+          const settleFailed = (): void => {
+            if (terminal) return;
+            terminal = true;
+            resolve(Object.freeze({ reason: 'gpt_request_failed', status: 'failed' }));
+          };
+          const settleDisposed = (): void => {
+            if (terminal) return;
+            terminal = true;
+            resolve(Object.freeze({ reason: 'superseded', status: 'cancelled' }));
+          };
+          const pendingRequest: PendingRequest = {
+            bind: (handle): void => {
+              if (terminal) {
+                try {
+                  handle.dispose();
+                } catch {
+                  // The placeholder outcome already owns terminal settlement.
+                }
+                return;
+              }
+              activeHandle = handle;
+              void handle.result.then((outcome) => {
+                if (terminal) return;
+                terminal = true;
+                resolve(outcome);
+              }, settleFailed);
+              if (disposed) {
+                try {
+                  handle.dispose();
+                } catch {
+                  settleDisposed();
+                }
+              }
+            },
+            fail: settleFailed,
+            input,
+            isDisposed: () => disposed,
+          };
+          pending[pending.length] = pendingRequest;
+          const placeholder = Object.freeze({
+            get status(): 'active' | 'queued' | 'terminal' {
+              return terminal ? 'terminal' : (activeHandle?.status ?? 'active');
+            },
+            result,
+            dispose: (): void => {
+              if (disposed) return;
+              disposed = true;
+              if (activeHandle) {
+                try {
+                  activeHandle.dispose();
+                } catch {
+                  settleDisposed();
+                }
+              } else {
+                settleDisposed();
+              }
+            },
+          });
+          markReady();
+          return placeholder;
+        },
+      });
+    },
+  });
+}
+
+/** Start one immutable initial GPT winner batch and protect every terminal latch together. */
+export async function publishInitialGptProjection(
+  document: Document,
+  input: InitialProjectionServices
+): Promise<void> {
+  const { googletag, navigation, projection, render, slots } = input;
+  if (!navigation.isCurrent() || projection.slots.length === 0) return;
+  const physicalBySlot = new Map<
+    string,
+    Readonly<{ operation: 'display' | 'refresh'; slot: object }>
+  >();
+  const operation = googletag.run(
+    (gpt) => {
+      for (let index = 0; index < projection.slots.length; index += 1) {
+        const placement = projection.slots[index];
+        if (!placement || !navigation.isCurrent()) break;
+        const element = resolveProjectedSlotElement(document, placement);
+        if (!element) continue;
+        const definition = Object.freeze({
+          adUnitPath: placement.gamUnitPath,
+          elementId: element.id,
+          sizes: placement.formats,
+        });
+        const existing = gpt.slots().filter((slot) => gpt.slotElementId?.(slot) === element.id);
+        if (existing.length > 1) continue;
+        const publisherSlot = existing[0];
+        if (publisherSlot) {
+          const adopted = slots.adoptGptSlot(navigation.generation, placement.slot, {
+            definition,
+            elementIdPrefix: placement.divId,
+            ownership: 'publisher',
+            slot: publisherSlot,
+          });
+          if (adopted.ok) {
+            physicalBySlot.set(
+              placement.slot,
+              Object.freeze({ operation: 'refresh', slot: publisherSlot })
+            );
+          }
+          continue;
+        }
+        const defined = gpt.transactionalDefine(
+          definition,
+          () => navigation.isCurrent(),
+          (candidate) => {
+            let committed = false;
+            return Object.freeze({
+              commit: (): boolean => {
+                const adopted = slots.adoptGptSlot(navigation.generation, placement.slot, {
+                  definition,
+                  elementIdPrefix: placement.divId,
+                  ownership: 'trusted_server',
+                  slot: candidate,
+                });
+                committed = adopted.ok;
+                return committed;
+              },
+              rollback: (): void => {
+                if (!committed) return;
+                committed = false;
+                slots.recordPublisherDestruction(candidate);
+              },
+            });
+          }
+        );
+        if (defined.status === 'defined') {
+          physicalBySlot.set(
+            placement.slot,
+            Object.freeze({ operation: 'display', slot: defined.slot })
+          );
+        }
+      }
+    },
+    { signal: navigation.signal }
+  );
+  try {
+    await operation.result;
+  } catch (error) {
+    if (navigation.isCurrent()) log.warn('GPT projection slot binding failed', error);
+  }
+  if (!navigation.isCurrent()) return;
+
+  const batch = navigation.createAuctionBatch(`gpt:${projection.auction.auctionId}`);
+  if (!batch) return;
+  const prepared: PreparedInitialGptWinner[] = [];
+  const preparedCache: PreparedInitialPbsCacheWinner[] = [];
+  let winnerIndex = 0;
+  for (let index = 0; index < projection.auction.results.length; index += 1) {
+    const decision = projection.auction.results[index];
+    const placement = projection.slots[index];
+    if (!decision || !placement || decision.outcome !== 'winner') continue;
+    const bid = projection.bids[winnerIndex];
+    winnerIndex += 1;
+    if (!bid || !navigation.isCurrent()) continue;
+    const binding = physicalBySlot.get(decision.slot);
+    if (!('rendererReservationId' in bid)) {
+      if (binding) {
+        preparedCache.push(Object.freeze({ bid, binding, placement }));
+      }
+      continue;
+    }
+    const owner = batch.createRenderAttempt(decision.slot);
+    if (!owner.ok) continue;
+    const created = render.createAttempt(owner.value);
+    if (!created.ok) continue;
+    prepared.push(
+      Object.freeze({
+        attempt: created.value,
+        bid,
+        binding,
+        decision,
+        owner: owner.value,
+        placement,
+        terminal: terminalLatch(created.value),
+      })
+    );
+  }
+  if (prepared.length === 0 && preparedCache.length === 0) return;
+  const requestBatch = createInitialGptRequestBatch(slots, prepared.length + preparedCache.length);
+  const cachePublications = preparedCache.map(({ bid, binding, placement }) => {
+    const participant = requestBatch.participant();
+    return Promise.resolve().then(async () => {
+      try {
+        await publishPbsCacheGptWinner({
+          bid,
+          binding,
+          googletag,
+          navigation,
+          placement,
+          requestClass: input.requestClass ?? 'initial',
+          slots: Object.freeze({
+            isBoundGptSlot: slots.isBoundGptSlot,
+            request: participant.request,
+          }),
+          targeting: input.targeting,
+        });
+      } finally {
+        participant.complete();
+      }
+    });
+  });
+  input.protect(Object.freeze([...prepared.map(({ terminal }) => terminal), ...cachePublications]));
+
+  await Promise.all([
+    ...cachePublications,
+    ...prepared.map(async ({ attempt, bid, binding, decision, owner, placement }) => {
+      const participant = requestBatch.participant();
+      try {
+        if (!binding) {
+          attempt.fail('slot_unresolved');
+          return;
+        }
+        const artifact = Object.freeze({
+          kind: 'puc' as const,
+          attemptId: attempt.id,
+          slot: attempt.slot,
+          navigationGeneration: attempt.navigationGeneration,
+          dispose: () => undefined,
+        });
+        const published = await publishGptWinner({
+          artifact,
+          attempt,
+          bid,
+          createSlotOperation: render.createSlotOperation,
+          googletag,
+          navigation,
+          operation: binding.operation,
+          owner,
+          placement,
+          pucBridge: input.pucBridge,
+          requestClass: input.requestClass ?? 'initial',
+          reservations: render.reservations,
+          slot: binding.slot,
+          slots: Object.freeze({
+            isBoundGptSlot: slots.isBoundGptSlot,
+            request: participant.request,
+          }),
+          targeting: input.targeting,
+          createFallback: (parentAttemptId) => {
+            const fallbackOwner = batch.createRenderAttempt(decision.slot);
+            if (!fallbackOwner.ok) {
+              return Object.freeze({
+                ok: false as const,
+                reason:
+                  fallbackOwner.reason === 'identity_generation_failed'
+                    ? ('identity_generation_failed' as const)
+                    : fallbackOwner.reason === 'stale_owner'
+                      ? ('stale_owner' as const)
+                      : ('invalid_attempt' as const),
+              });
+            }
+            const fallback = render.createAttempt(fallbackOwner.value, parentAttemptId);
+            if (!fallback.ok) return fallback;
+            if (
+              !fallback.value.admitDirectWinner(
+                bid.renderSource,
+                Object.freeze({ selectedCpm: bid.cpm })
+              )
+            ) {
+              fallback.value.fail('winner_not_renderable');
+              return fallback;
+            }
+            if (!render.renderWinner(fallback.value)) fallback.value.fail('winner_not_renderable');
+            return fallback;
+          },
+        });
+        if (!published.ok && navigation.isCurrent()) {
+          log.warn('GPT projection winner publication failed', published.reason);
+        }
+      } finally {
+        participant.complete();
+      }
+    }),
+  ]);
+}
+
+function prepareProductionGpt(context: IntegrationPrepareContext): PreparedIntegration {
+  const runtime = exactCapability<RuntimeCapabilityV1>(context.interfaces, 'runtime.v1');
+  if (!runtime) throw new TypeError('GPT requires runtime.v1');
+  if (!isGptIntegrationConfigV1(context.config)) {
+    throw new TypeError('GPT integration config is invalid');
+  }
+  const config = context.config;
+  const auction = exactCapability<ProductionAuctionCapability>(context.interfaces, 'auction.v1');
+  const slotCapability = exactCapability<ProductionSlotsCapability>(context.interfaces, 'slots.v1');
+  const aps = exactCapability<ProductionApsCapability>(context.interfaces, 'aps.v1');
+  const render = exactCapability<ProductionRenderCapability>(context.interfaces, 'render.v1');
+  const messages = exactCapability<ProductionMessagesCapability>(context.interfaces, 'messages.v1');
+  const trace = exactCapability<ProductionTraceCapability>(context.interfaces, 'trace.v1');
+  const document = runtime.document;
+  if (
+    !auction ||
+    !slotCapability ||
+    !render ||
+    !messages ||
+    !trace ||
+    !document?.defaultView ||
+    typeof auction.session?.replaceNavigation !== 'function' ||
+    typeof runtime.protectFirstDisplayAttemptBatch !== 'function' ||
+    typeof slotCapability.attachPhysicalService !== 'function' ||
+    typeof render.attachPucGamAttemptRegistrar !== 'function' ||
+    typeof render.bindArtifactRetirement !== 'function' ||
+    typeof render.createAttempt !== 'function' ||
+    typeof render.createSlotOperation !== 'function' ||
+    typeof render.commitPageBids !== 'function' ||
+    typeof render.mintLifecycleTicket !== 'function' ||
+    typeof render.renderWinner !== 'function' ||
+    (aps !== undefined && typeof aps.renderPuc !== 'function') ||
+    typeof trace.observations?.publish !== 'function'
+  ) {
+    throw new TypeError('GPT capability graph is malformed');
+  }
+
+  const scope = new DisposableStack((error) => log.warn('GPT preparation disposal failed', error));
+  context.onDispose(() => scope.dispose());
+  let active = false;
+  scope.onDispose(() => {
+    active = false;
+  });
+  const googletag = createBrowserGoogletagAdapter(
+    document.defaultView as unknown as Parameters<typeof createBrowserGoogletagAdapter>[0],
+    {
+      reportDiagnosticsFailure: (code) => log.warn('GPT diagnostics identity unavailable', code),
+    }
+  );
+  scope.onDispose(() => googletag.dispose());
+  const diagnosticsEnabled = gptDiagnosticsActive(runtime);
+  const diagnosticsFacts = diagnosticsEnabled
+    ? createGptDiagnosticsFactBuffer({
+        onOverflow: (droppedFacts) =>
+          log.warn('GPT diagnostics fact buffer overflow', droppedFacts),
+      })
+    : undefined;
+  if (diagnosticsFacts) scope.onDispose(diagnosticsFacts.dispose);
+  const reconciliation = createBrowserSlotReconciliationBoundary(
+    document,
+    document.defaultView.MutationObserver
+  );
+  const slots = createSlotService({
+    bindCommittedArtifactRetirement: render.bindArtifactRetirement,
+    disposeCommittedArtifact: (navigationGeneration, registeredSlotId, expectedArtifact) => {
+      const artifact = render.artifacts.current(registeredSlotId);
+      if (artifact === expectedArtifact && artifact.navigationGeneration === navigationGeneration)
+        render.artifacts.release(artifact);
+    },
+    googletag,
+    ...(diagnosticsFacts
+      ? {
+          onTrustedServerRequest: ({ opportunity, registeredSlotId, slot }) => {
+            if (!opportunity) return;
+            publishTrustedServerOpportunityFact({
+              adapter: googletag,
+              buffer: diagnosticsFacts,
+              physicalSlot: slot,
+              registeredSlotId,
+              opportunity,
+            });
+          },
+        }
+      : {}),
+    ...(reconciliation ? { reconciliation } : {}),
+  });
+  scope.onDispose(() => slots.dispose());
+  const targeting = createTargetingService();
+  scope.onDispose(() => targeting.dispose());
+  const startup = createGptStartup({ googletag, slots: () => slots });
+  let pucBridge: PucBridge | undefined;
+  let takeoverReconciliationRelease: (() => void) | undefined;
+  let laterLifecycleActive = false;
+  let laterLifecycleRelease: (() => void) | undefined;
+  const gptCapability: GptCapabilityV1 = Object.freeze({
+    activateLaterLifecycle: () => {
+      if (!active || laterLifecycleActive) {
+        throw new TypeError('GPT later lifecycle is unavailable');
+      }
+      const currentBridge = pucBridge;
+      if (!currentBridge) throw new TypeError('GPT later bridge is unavailable');
+      const releaseReconciliation = takeoverReconciliationRelease;
+      if (!releaseReconciliation) {
+        throw new TypeError('GPT takeover reconciliation owner is unavailable');
+      }
+      takeoverReconciliationRelease = undefined;
+      const controllers = new Set<AbortController>();
+      let ownerActive = true;
+      laterLifecycleActive = true;
+      const rejected = (navigation?: NavigationSession): GptLaterNavigationResult => {
+        const rejectedNavigation =
+          navigation ?? auction.session.currentNavigation ?? auction.navigation;
+        return Object.freeze({
+          status: 'rejected',
+          navigationGeneration: rejectedNavigation.generation,
+          current: ownerActive && active && rejectedNavigation.isCurrent(),
+        });
+      };
+      const release = (): void => {
+        if (!ownerActive) return;
+        ownerActive = false;
+        laterLifecycleActive = false;
+        if (laterLifecycleRelease === release) laterLifecycleRelease = undefined;
+        for (const controller of controllers) controller.abort();
+        controllers.clear();
+        releaseReconciliation();
+      };
+      laterLifecycleRelease = release;
+      return Object.freeze({
+        navigate: async (path: string): Promise<GptLaterNavigationResult> => {
+          if (
+            !ownerActive ||
+            !active ||
+            typeof path !== 'string' ||
+            path.length === 0 ||
+            path.length > 4_096 ||
+            !path.startsWith('/')
+          ) {
+            return rejected();
+          }
+          const replacement = auction.session.replaceNavigation();
+          if (!replacement.ok || !ownerActive || !active) return rejected();
+          const navigation = replacement.value;
+          const controller = new AbortController();
+          controllers.add(controller);
+          const abortForNavigation = (): void => controller.abort();
+          navigation.signal.addEventListener('abort', abortForNavigation, { once: true });
+          try {
+            const fetcher = globalThis.fetch;
+            if (typeof fetcher !== 'function') return rejected(navigation);
+            const response = await fetcher(`/_ts/page-bids?path=${encodeURIComponent(path)}`, {
+              credentials: 'include',
+              headers: { 'X-TSJS-Page-Bids': '1' },
+              signal: controller.signal,
+            });
+            if (!ownerActive || !active || !navigation.isCurrent() || !response.ok) {
+              return rejected(navigation);
+            }
+            const candidate = await response.json();
+            if (!ownerActive || !active || !navigation.isCurrent()) return rejected(navigation);
+            if (
+              !render.commitPageBids(navigation, slots.projectionRegistry(navigation), candidate)
+            ) {
+              return rejected(navigation);
+            }
+            const projection = navigation.currentAuctionProjection as
+              Readonly<BrowserAuctionProjectionV1> | undefined;
+            if (!projection || !ownerActive || !active || !navigation.isCurrent()) {
+              return rejected(navigation);
+            }
+            await publishInitialGptProjection(document, {
+              googletag,
+              navigation,
+              projection,
+              protect: () => true,
+              pucBridge: currentBridge,
+              render,
+              requestClass: 'page-bids',
+              slots,
+              targeting,
+            });
+            if (!ownerActive || !active || !navigation.isCurrent()) return rejected(navigation);
+            return Object.freeze({
+              status: 'committed',
+              navigationGeneration: navigation.generation,
+              current: true,
+            });
+          } catch (error) {
+            if (!controller.signal.aborted && ownerActive && navigation.isCurrent()) {
+              log.warn('GPT page-bids navigation failed', error);
+            }
+            return rejected(navigation);
+          } finally {
+            navigation.signal.removeEventListener('abort', abortForNavigation);
+            controllers.delete(controller);
+          }
+        },
+        release,
+      });
+    },
+    adapter: googletag,
+    directAuctionUnitForSlot: (slot: object): Readonly<object> | undefined => {
+      const navigation = auction.session.currentNavigation;
+      if (!active || !navigation?.isCurrent()) return undefined;
+      const records = slots.snapshotRegisteredSlots(navigation) ?? Object.freeze([]);
+      for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (
+          record?.directAuctionUnit &&
+          slots.isBoundGptSlot(navigation.generation, record.registeredSlotId, slot)
+        ) {
+          return record.directAuctionUnit;
+        }
+      }
+      return undefined;
+    },
+    installRefreshPolicy: startup.installRefreshPolicy,
+    navigation: () => {
+      const navigation = auction.session.currentNavigation;
+      return active && navigation?.isCurrent() ? navigation : undefined;
+    },
+    slots,
+  });
+  const eventsCapability = Object.freeze({
+    subscribe: (listener: (fact: Readonly<Record<string, unknown>>) => void): (() => void) => {
+      const release =
+        active && diagnosticsFacts
+          ? diagnosticsFacts.activate(listener as Parameters<typeof diagnosticsFacts.activate>[0])
+          : undefined;
+      if (!release) {
+        throw new TypeError('GPT event subscription is unavailable');
+      }
+      return release;
+    },
+  });
+  const cacheCapability = Object.freeze({});
+
+  return Object.freeze({
+    activate: (activation: IntegrationActivationContext) => {
+      const { afterCommit, onDispose } = activation;
+      const adoptionCandidate = activation.adoption;
+      if (active) throw new Error('GPT already activated');
+      if (adoptionCandidate !== undefined) {
+        const selected = persistentFirstDisplaySliceSelectedV1(adoptionCandidate, 'gpt_initial');
+        const initialState = selected
+          ? snapshotPersistentFirstDisplaySliceStateV1(adoptionCandidate, 'gpt_initial')
+          : undefined;
+        if (
+          selected === undefined ||
+          (config.gamAttributionEnabled && !selected) ||
+          (selected &&
+            (!initialState ||
+              initialState.values.length !== 2 ||
+              initialState.values[0]?.[0] !== 'gam' ||
+              initialState.values[0][1] !== config.gamAttributionEnabled ||
+              initialState.values[1]?.[0] !== 'v' ||
+              initialState.values[1][1] !== 1))
+        ) {
+          throw new TypeError('GPT first-display parser state is invalid');
+        }
+      } else if (config.gamAttributionEnabled && !googletag.enqueueGamAttribution()) {
+        throw new TypeError('GPT GAM attribution is unavailable');
+      }
+      const diagnosticsEventRelease: { current?: () => void } = {};
+      const diagnosticsRelease: { current?: () => void } = {};
+      const pbsCacheBridgeRelease: { current?: () => void } = {};
+      const publisherRelease: { current?: () => void } = {};
+      const slotServiceRelease: { current?: () => void } = {};
+      const bridgeRelease: { current?: () => void } = {};
+      const pucRegistrarRelease: { current?: () => void } = {};
+      onDispose(resetGuardState);
+      onDispose(() => diagnosticsEventRelease.current?.());
+      onDispose(() => diagnosticsRelease.current?.());
+      onDispose(() => pbsCacheBridgeRelease.current?.());
+      onDispose(() => publisherRelease.current?.());
+      onDispose(() => slotServiceRelease.current?.());
+      onDispose(() => bridgeRelease.current?.());
+      onDispose(() => pucRegistrarRelease.current?.());
+      onDispose(() => {
+        active = false;
+        const release = laterLifecycleRelease;
+        laterLifecycleRelease = undefined;
+        release?.();
+        const releaseTakeoverReconciliation = takeoverReconciliationRelease;
+        takeoverReconciliationRelease = undefined;
+        releaseTakeoverReconciliation?.();
+      });
+
+      slotServiceRelease.current = slotCapability.attachPhysicalService(slots);
+      const diagnosticsAdoption =
+        adoptionCandidate === undefined
+          ? undefined
+          : adoptInitialGptDiagnosticsFromHandoff(adoptionCandidate, googletag);
+      const adoption =
+        adoptionCandidate === undefined
+          ? undefined
+          : adoptInitialGptSlotsFromHandoff(
+              adoptionCandidate,
+              auction.navigation.generation,
+              slots,
+              render.artifacts,
+              targeting,
+              googletag
+            );
+      if (adoptionCandidate !== undefined && (!diagnosticsAdoption || !adoption)) {
+        throw new TypeError('GPT first-display adoption is invalid');
+      }
+      const factAdoption =
+        adoptionCandidate === undefined
+          ? undefined
+          : adoptInitialGptFactsFromHandoff(
+              adoptionCandidate,
+              diagnosticsFacts,
+              googletag,
+              auction.navigation.currentAuctionProjection as
+                Readonly<BrowserAuctionProjectionV1> | undefined
+            );
+      if (adoptionCandidate !== undefined && !factAdoption) {
+        throw new TypeError('GPT first-display diagnostics facts are invalid');
+      }
+      slots.start();
+      takeoverReconciliationRelease = slots.activateReconciliation();
+      const bridge = createPucBridge({
+        messaging: messages.messaging,
+        mintLifecycleTicket: render.mintLifecycleTicket,
+        ...(aps ? { mountAps: aps.renderPuc } : {}),
+        now: () => document.defaultView!.performance.now(),
+        reservations: render.reservations,
+        resizeCollapsedShell: resizeCollapsedPucShell,
+        slots,
+      });
+      const ticketAdoption =
+        adoptionCandidate === undefined
+          ? undefined
+          : adoptInitialPucTicketsFromHandoff(adoptionCandidate, bridge);
+      if (adoptionCandidate !== undefined && !ticketAdoption) {
+        throw new TypeError('GPT first-display ticket adoption is invalid');
+      }
+      pucBridge = bridge;
+      bridgeRelease.current = () => {
+        bridge.dispose();
+        if (pucBridge === bridge) pucBridge = undefined;
+      };
+      pucRegistrarRelease.current = render.attachPucGamAttemptRegistrar((input) =>
+        bridge.registerGamAttempt(input)
+      );
+      const releaseDiagnostics = googletag.observeDiagnostics((fact) => {
+        const observation = projectGptTraceFact(fact);
+        if (observation) trace.observations.publish(observation);
+        diagnosticsFacts?.publish(fact);
+      });
+      if (!releaseDiagnostics) throw new Error('GPT diagnostics event boundary is unavailable');
+      diagnosticsRelease.current = releaseDiagnostics;
+      if (diagnosticsFacts) {
+        const releaseDiagnosticEvents = activateGptDiagnosticsEventListeners(googletag);
+        if (!releaseDiagnosticEvents) {
+          throw new Error('GPT diagnostics-only event listeners are unavailable');
+        }
+        diagnosticsEventRelease.current = releaseDiagnosticEvents;
+      }
+      pbsCacheBridgeRelease.current = installPbsCacheBridge(
+        document,
+        auction,
+        () => active,
+        trace.observations.publish
+      );
+      publisherRelease.current = startup.activate();
+      installGptGuard();
+      active = true;
+      afterCommit(() => {
+        startup.start(context.config);
+        if (adoption) return;
+        const currentBridge = pucBridge;
+        if (!active || currentBridge !== bridge) return;
+        void publishInitialGptProjection(document, {
+          googletag,
+          navigation: auction.navigation,
+          projection: auction.projection,
+          protect: runtime.protectFirstDisplayAttemptBatch,
+          pucBridge: currentBridge,
+          render,
+          slots,
+          targeting,
+        }).catch((error) => {
+          if (auction.navigation.isCurrent()) log.warn('GPT initial projection failed', error);
+        });
+      });
+    },
+    interfaces: Object.freeze({
+      'gpt.v1': gptCapability,
+      'gpt.events.v1': eventsCapability,
+      'pbs_cache.baseline.v1': cacheCapability,
+    }),
+  });
+}
+
+/** Build the release-bound GPT module registered by the coordinated runtime. */
+export function createGptIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = (context: IntegrationPrepareContext) => prepareProductionGpt(context);
+  return Object.freeze({
+    abi: 1,
+    id: GPT_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/script_guard.ts b/crates/trusted-server-js/lib/src/integrations/gpt/script_guard.ts
index c1bc89945..ab78834f1 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt/script_guard.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/script_guard.ts
@@ -1,75 +1,14 @@
-import { log } from '../../core/log';
-import {
-  DEFAULT_DOM_INSERTION_HANDLER_PRIORITY,
-  type DomInsertionCandidate,
-  registerDomInsertionHandler,
-} from '../../shared/dom_insertion_dispatcher';
+import { createScriptGuard } from '../../shared/script_guard';
 
-/**
- * GPT Script Interception Guard
- *
- * Intercepts script elements whose URLs point at Google's ad-serving domains
- * and synchronously rewrites them to the first-party proxy, preserving the
- * original path. This guard performs a *host swap*:
- *
- *   securepubads.g.doubleclick.net/pagead/managed/js/gpt/…/pubads_impl.js
- *   → publisher.com/integrations/gpt/pagead/managed/js/gpt/…/pubads_impl.js
- *
- * The server-side proxy serves script bodies verbatim, so this guard is
- * the sole mechanism that routes GPT's cascaded script loads (pubads_impl,
- * sub-modules, viewability, etc.) back through the first-party proxy.
- *
- * ## Interception layers
- *
- * 1. **`document.write` / `document.writeln`** — GPT's primary loading
- *    mechanism. When gpt.js loads synchronously it uses `document.write`
- *    to inject `<script src="...pubads_impl.js">` directly into the
- *    HTML parser stream. We intercept these calls and rewrite GPT domain
- *    URLs inside the HTML string before passing it to the native method.
- * 2. **Property descriptor** on `HTMLScriptElement.prototype.src` — catches
- *    `script.src = url` (the async fallback path GPT uses when
- *    `document.write` is unavailable).
- * 3. **`setAttribute` patch** on `HTMLScriptElement.prototype` — catches
- *    `script.setAttribute('src', url)`.
- * 4. **`document.createElement` patch** — tags every newly created
- *    `<script>` element with a per-instance `src` descriptor as a
- *    fallback when the prototype descriptor cannot be installed.
- * 5. **Shared DOM insertion dispatcher** — catches scripts and
- *    `<link rel="preload">` elements at insertion time without stacking
- *    multiple prototype wrappers across integrations.
- * 6. **`MutationObserver`** — catches elements added to the DOM via
- *    `innerHTML`, `.append()`, etc., or attribute mutations on existing
- *    elements.
- */
-
-const LOG_PREFIX = 'GPT guard';
-
-/** The Google ad-serving domain whose scripts should be proxied. */
 const GPT_DOMAIN = 'securepubads.g.doubleclick.net';
-
-/** Integration route prefix on the first-party domain. */
 const PROXY_PREFIX = '/integrations/gpt';
 
-// ---------------------------------------------------------------------------
-// URL helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Parse a URL string into a URL object, supporting protocol-relative URLs.
- */
 function parseUrl(url: string): URL | undefined {
   if (!url) return undefined;
-
   try {
-    if (typeof window !== 'undefined') {
-      return new URL(url, window.location.href);
-    }
-    return new URL(url);
+    return new URL(url, typeof window === 'undefined' ? undefined : window.location.href);
   } catch {
-    if (!url.startsWith('//')) {
-      return undefined;
-    }
-
+    if (!url.startsWith('//')) return undefined;
     try {
       return new URL(`https:${url}`);
     } catch {
@@ -78,557 +17,32 @@ function parseUrl(url: string): URL | undefined {
   }
 }
 
-/**
- * Check if a URL belongs to the GPT domain we proxy.
- */
 function isGptDomainUrl(url: string): boolean {
-  const parsed = parseUrl(url);
-  return !!parsed && parsed.hostname.toLowerCase() === GPT_DOMAIN;
+  return parseUrl(url)?.hostname.toLowerCase() === GPT_DOMAIN;
 }
 
-/**
- * Rewrite a GPT URL to the first-party proxy, preserving the path.
- *
- * ```
- * https://securepubads.g.doubleclick.net/pagead/managed/…
- * → https://publisher.com/integrations/gpt/pagead/managed/…
- * ```
- */
-function rewriteUrl(originalUrl: string): string {
+function rewriteGptUrl(originalUrl: string): string {
   const parsed = parseUrl(originalUrl);
-  if (!parsed || typeof window === 'undefined') {
-    return originalUrl;
-  }
-
-  const protocol = window.location.protocol === 'https:' ? 'https' : 'http';
-  const host = window.location.host;
-  return `${protocol}://${host}${PROXY_PREFIX}${parsed.pathname}${parsed.search}${parsed.hash}`;
-}
-
-// ---------------------------------------------------------------------------
-// Native references (captured once at install time)
-// ---------------------------------------------------------------------------
-
-let nativeDocWrite: ((this: Document, ...args: string[]) => void) | undefined;
-let nativeDocWriteln: ((this: Document, ...args: string[]) => void) | undefined;
-let nativeSrcSet: ((this: HTMLScriptElement, value: string) => void) | undefined;
-let nativeSrcGet: ((this: HTMLScriptElement) => string) | undefined;
-let nativeSrcDescriptor: PropertyDescriptor | undefined;
-let nativeSetAttribute: typeof HTMLScriptElement.prototype.setAttribute | undefined;
-let nativeCreateElement: typeof document.createElement | undefined;
-let mutationObserver: MutationObserver | undefined;
-let unregisterDomInsertionHandler: (() => void) | undefined;
-
-// ---------------------------------------------------------------------------
-// Tracking — prevent double-rewriting
-// ---------------------------------------------------------------------------
-
-/** Elements whose src we've already rewritten. Value is the rewritten URL. */
-let rewritten = new WeakMap<HTMLScriptElement | HTMLLinkElement, string>();
-
-function alreadyRewritten(element: HTMLScriptElement | HTMLLinkElement, url: string): boolean {
-  return rewritten.get(element) === url;
-}
-
-// ---------------------------------------------------------------------------
-// Core rewrite logic
-// ---------------------------------------------------------------------------
-
-/**
- * Apply a rewritten URL to a script element using the native setter,
- * bypassing our property descriptor.
- */
-function applySrc(element: HTMLScriptElement, url: string): void {
-  if (nativeSrcSet) {
-    nativeSrcSet.call(element, url);
-  } else if (nativeSetAttribute) {
-    nativeSetAttribute.call(element, 'src', url);
-  } else {
-    element.setAttribute('src', url);
-  }
-}
-
-/**
- * If the URL is a GPT domain URL, rewrite it. Returns the (possibly
- * rewritten) URL and whether a rewrite was performed.
- */
-function maybeRewrite(url: string): { url: string; didRewrite: boolean } {
-  if (!isGptDomainUrl(url)) {
-    return { url, didRewrite: false };
-  }
-  return { url: rewriteUrl(url), didRewrite: true };
-}
-
-/**
- * Attempt to rewrite a script element's src if it points at a GPT domain.
- */
-function rewriteScriptSrc(element: HTMLScriptElement, rawUrl: string): boolean {
-  const { url: finalUrl, didRewrite } = maybeRewrite(rawUrl);
-  if (!didRewrite || alreadyRewritten(element, finalUrl)) {
-    return false;
-  }
-
-  log.info(`${LOG_PREFIX}: rewriting script src`, { original: rawUrl, rewritten: finalUrl });
-  rewritten.set(element, finalUrl);
-  applySrc(element, finalUrl);
-  return true;
-}
-
-/**
- * Attempt to rewrite a link element's href if it's a preload/prefetch for
- * a GPT-domain script.
- */
-function rewriteLinkHref(
-  element: HTMLLinkElement,
-  href = element.href || element.getAttribute('href') || '',
-  rel = element.getAttribute('rel')
-): boolean {
-  if (rel !== 'preload' && rel !== 'prefetch') return false;
-  if (element.getAttribute('as') !== 'script') return false;
-
-  const { url: finalUrl, didRewrite } = maybeRewrite(href);
-  if (!didRewrite || alreadyRewritten(element, finalUrl)) return false;
-
-  log.info(`${LOG_PREFIX}: rewriting ${rel} link`, { original: href, rewritten: finalUrl });
-  rewritten.set(element, finalUrl);
-  element.href = finalUrl;
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// Layer 1: document.write / document.writeln interception
-// ---------------------------------------------------------------------------
-
-/**
- * Rewrite GPT domain URLs inside raw HTML strings passed to
- * `document.write` / `document.writeln`.
- *
- * Uses `DOMParser` for robust HTML parsing instead of regex so that
- * edge-cases (unquoted attributes, unusual spacing, mixed quote styles,
- * HTML-entity-encoded query parameters) are handled by the browser's
- * native parser. GPT script `src` attributes are mutated in the parsed
- * DOM and the result is serialized back to HTML.
- *
- * If the GPT domain is present in the HTML but `DOMParser` is
- * unavailable or throws, the function **fails closed** (returns an
- * empty string) rather than passing the unproxied URL through.
- *
- * Non-GPT HTML is always passed through unchanged regardless of
- * `DOMParser` availability.
- */
-function rewriteHtmlString(html: string): string {
-  // Fast-path: if the HTML does not reference the GPT domain at all,
-  // pass it through unchanged.  This avoids unnecessary DOMParser
-  // overhead and, critically, prevents non-GPT document.write calls
-  // from being silently dropped when DOMParser is unavailable.
-  if (!html.includes(GPT_DOMAIN)) return html;
-
-  if (typeof DOMParser === 'undefined') {
-    log.warn(
-      `${LOG_PREFIX}: DOMParser unavailable, blocking document.write HTML that references GPT domain`
-    );
-    return '';
-  }
-
-  try {
-    const doc = new DOMParser().parseFromString(html, 'text/html');
-    const scripts = doc.querySelectorAll('script[src]');
-    let didRewriteAny = false;
-
-    for (const script of scripts) {
-      const rawSrc = script.getAttribute('src') ?? '';
-      const { url: rewrittenUrl, didRewrite } = maybeRewrite(rawSrc);
-      if (!didRewrite) continue;
-
-      log.info(`${LOG_PREFIX}: rewriting document.write script src`, {
-        original: rawSrc,
-        rewritten: rewrittenUrl,
-      });
-      // Mutate the parsed DOM so that HTML-entity-encoded attribute
-      // values (e.g. `&amp;`) are handled correctly.  Serializing the
-      // DOM back to HTML avoids the mismatch between decoded
-      // `getAttribute()` values and the raw HTML string.
-      script.setAttribute('src', rewrittenUrl);
-      didRewriteAny = true;
-    }
-
-    // DOMParser wraps input in <html><head>…</head><body>…</body></html>.
-    // Bare <script> tags land in <head>, so we serialize from both.
-    return didRewriteAny ? (doc.head?.innerHTML ?? '') + (doc.body?.innerHTML ?? '') : html;
-  } catch (err) {
-    log.warn(
-      `${LOG_PREFIX}: failed to parse document.write HTML containing GPT domain, blocking`,
-      err
-    );
-    return '';
-  }
-}
-
-function installDocumentWritePatch(): void {
-  if (typeof document === 'undefined') return;
-
-  nativeDocWrite = document.write;
-  nativeDocWriteln = document.writeln;
-
-  document.write = function patchedWrite(this: Document, ...args: string[]): void {
-    const rewrittenArgs = args.map((arg) =>
-      typeof arg === 'string' ? rewriteHtmlString(arg) : arg
-    );
-    nativeDocWrite!.apply(this, rewrittenArgs);
-  };
-
-  document.writeln = function patchedWriteln(this: Document, ...args: string[]): void {
-    const rewrittenArgs = args.map((arg) =>
-      typeof arg === 'string' ? rewriteHtmlString(arg) : arg
-    );
-    nativeDocWriteln!.apply(this, rewrittenArgs);
-  };
-
-  log.info(`${LOG_PREFIX}: document.write/writeln patch installed`);
-}
-
-// ---------------------------------------------------------------------------
-// Layer 2: Property descriptor on HTMLScriptElement.prototype.src
-// ---------------------------------------------------------------------------
-
-function installSrcDescriptor(): boolean {
-  if (typeof HTMLScriptElement === 'undefined') return false;
-
-  const descriptor = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');
-  if (!descriptor || typeof descriptor.set !== 'function') {
-    log.debug(`${LOG_PREFIX}: HTMLScriptElement.prototype.src has no setter, skipping descriptor`);
-    return false;
-  }
-  if (descriptor.configurable === false) {
-    log.debug(`${LOG_PREFIX}: HTMLScriptElement.prototype.src is not configurable`);
-    return false;
-  }
-
-  nativeSrcDescriptor = descriptor;
-  nativeSrcSet = descriptor.set;
-  nativeSrcGet = typeof descriptor.get === 'function' ? descriptor.get : undefined;
-
-  try {
-    Object.defineProperty(HTMLScriptElement.prototype, 'src', {
-      configurable: true,
-      enumerable: descriptor.enumerable ?? true,
-      get(this: HTMLScriptElement): string {
-        if (nativeSrcGet) {
-          return nativeSrcGet.call(this);
-        }
-        return this.getAttribute('src') ?? '';
-      },
-      set(this: HTMLScriptElement, value: string) {
-        const raw = String(value ?? '');
-        const { url: finalUrl, didRewrite } = maybeRewrite(raw);
-        if (didRewrite && !alreadyRewritten(this, finalUrl)) {
-          log.info(`${LOG_PREFIX}: intercepted src setter`, { original: raw, rewritten: finalUrl });
-          rewritten.set(this, finalUrl);
-          applySrc(this, finalUrl);
-        } else {
-          applySrc(this, raw);
-        }
-      },
-    });
-    log.info(`${LOG_PREFIX}: src property descriptor installed`);
-    return true;
-  } catch (err) {
-    log.debug(`${LOG_PREFIX}: failed to install src descriptor`, err);
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Layer 3: setAttribute patch on HTMLScriptElement.prototype
-// ---------------------------------------------------------------------------
-
-// Track instance-level src patching to avoid redundant work.
-let instancePatched = new WeakSet<HTMLScriptElement>();
-
-/**
- * Install a per-instance `src` property descriptor on a script element.
- * Used as a fallback when the prototype-level descriptor cannot be
- * installed, or as belt-and-suspenders from `document.createElement`.
- */
-function ensureInstancePatched(element: HTMLScriptElement): void {
-  if (instancePatched.has(element)) return;
-  instancePatched.add(element);
-
-  try {
-    Object.defineProperty(element, 'src', {
-      configurable: true,
-      enumerable: true,
-      get(this: HTMLScriptElement): string {
-        if (nativeSrcGet) {
-          return nativeSrcGet.call(this);
-        }
-        return this.getAttribute('src') ?? '';
-      },
-      set(this: HTMLScriptElement, value: string) {
-        const raw = String(value ?? '');
-        const { url: finalUrl, didRewrite } = maybeRewrite(raw);
-        if (didRewrite && !alreadyRewritten(this, finalUrl)) {
-          log.info(`${LOG_PREFIX}: intercepted instance src setter`, {
-            original: raw,
-            rewritten: finalUrl,
-          });
-          rewritten.set(this, finalUrl);
-          applySrc(this, finalUrl);
-        } else {
-          applySrc(this, raw);
-        }
-      },
-    });
-  } catch {
-    // Instance-level defineProperty can fail in some environments.
-  }
-}
-
-function installSetAttributePatch(): void {
-  if (typeof HTMLScriptElement === 'undefined') return;
-
-  nativeSetAttribute = HTMLScriptElement.prototype.setAttribute;
-
-  HTMLScriptElement.prototype.setAttribute = function patchedSetAttribute(
-    this: HTMLScriptElement,
-    name: string,
-    value: string
-  ): void {
-    if (typeof name === 'string' && name.toLowerCase() === 'src') {
-      const raw = String(value ?? '');
-      const { url: finalUrl, didRewrite } = maybeRewrite(raw);
-      if (didRewrite && !alreadyRewritten(this, finalUrl)) {
-        log.info(`${LOG_PREFIX}: intercepted setAttribute('src')`, {
-          original: raw,
-          rewritten: finalUrl,
-        });
-        rewritten.set(this, finalUrl);
-        nativeSetAttribute!.call(this, name, finalUrl);
-        return;
-      }
-    }
-    nativeSetAttribute!.call(this, name, value);
-  };
-
-  log.info(`${LOG_PREFIX}: setAttribute patch installed`);
-}
-
-// ---------------------------------------------------------------------------
-// Layer 4: document.createElement patch
-// ---------------------------------------------------------------------------
-
-/**
- * Patch `document.createElement` so that every newly created `<script>`
- * element gets a per-instance `src` descriptor. This ensures coverage
- * even if the prototype-level descriptor failed to install.
- */
-function installCreateElementPatch(): void {
-  if (typeof document === 'undefined') return;
-
-  nativeCreateElement = document.createElement;
-
-  document.createElement = function patchedCreateElement(
-    this: Document,
-    tagName: string,
-    options?: ElementCreationOptions
-  ): HTMLElement {
-    const el = nativeCreateElement!.call(this, tagName, options);
-    if (typeof tagName === 'string' && tagName.toLowerCase() === 'script') {
-      ensureInstancePatched(el as HTMLScriptElement);
-    }
-    return el;
-  } as typeof document.createElement;
-
-  log.info(`${LOG_PREFIX}: document.createElement patch installed`);
-}
-
-// ---------------------------------------------------------------------------
-// Layer 5: shared DOM insertion dispatcher
-// ---------------------------------------------------------------------------
-
-/**
- * Check a node at insertion time and rewrite if it's a GPT script or
- * preload link.
- */
-function checkNodeAtInsertion(candidate: DomInsertionCandidate): boolean {
-  if (candidate.kind === 'script') {
-    return rewriteScriptSrc(candidate.element, candidate.url);
-  }
-
-  return rewriteLinkHref(candidate.element, candidate.url, candidate.rel);
-}
-
-function installDomInsertionDispatcher(): void {
-  if (typeof Element === 'undefined') return;
-
-  unregisterDomInsertionHandler = registerDomInsertionHandler({
-    handle: checkNodeAtInsertion,
-    id: 'gpt',
-    priority: DEFAULT_DOM_INSERTION_HANDLER_PRIORITY,
-  });
-
-  log.info(`${LOG_PREFIX}: DOM insertion dispatcher registered`);
-}
-
-// ---------------------------------------------------------------------------
-// Layer 6: MutationObserver
-// ---------------------------------------------------------------------------
-
-function installMutationObserver(): void {
-  if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') return;
-
-  mutationObserver?.disconnect();
-  mutationObserver = new MutationObserver((records) => {
-    for (const record of records) {
-      // Attribute mutation on an existing script element.
-      if (record.type === 'attributes' && record.attributeName === 'src') {
-        const target = record.target;
-        if (target instanceof HTMLScriptElement) {
-          const src = target.src || target.getAttribute('src') || '';
-          if (src) rewriteScriptSrc(target, src);
-        }
-        continue;
-      }
-
-      // New nodes added to the DOM (catches innerHTML, document.write, .append(), etc.)
-      if (record.type === 'childList') {
-        record.addedNodes.forEach((node) => {
-          if (node instanceof HTMLScriptElement) {
-            const src = node.src || node.getAttribute('src') || '';
-            if (src) rewriteScriptSrc(node, src);
-            return;
-          }
-          if (node instanceof HTMLLinkElement) {
-            rewriteLinkHref(node);
-            return;
-          }
-          // Check children of container nodes (e.g. innerHTML sets a subtree).
-          if (node instanceof Element) {
-            node.querySelectorAll<HTMLScriptElement>('script[src]').forEach((script) => {
-              const src = script.src || script.getAttribute('src') || '';
-              if (src) rewriteScriptSrc(script, src);
-            });
-            node
-              .querySelectorAll<HTMLLinkElement>('link[rel="preload"][as="script"]')
-              .forEach((link) => rewriteLinkHref(link));
-          }
-        });
-      }
-    }
-  });
-
-  mutationObserver.observe(document, {
-    subtree: true,
-    childList: true,
-    attributes: true,
-    attributeFilter: ['src'],
-  });
-
-  log.info(`${LOG_PREFIX}: mutation observer active`);
+  if (!parsed || typeof window === 'undefined') return originalUrl;
+  return `${window.location.origin}${PROXY_PREFIX}${parsed.pathname}${parsed.search}${parsed.hash}`;
 }
 
-// ---------------------------------------------------------------------------
-// Guard lifecycle
-// ---------------------------------------------------------------------------
-
-let installed = false;
+const guard = createScriptGuard({
+  deepInterception: { documentWriteUrlHint: GPT_DOMAIN },
+  displayName: 'GPT',
+  id: 'gpt',
+  isTargetUrl: isGptDomainUrl,
+  rewriteUrl: rewriteGptUrl,
+});
 
-/**
- * Install the GPT guard.
- *
- * Sets up six interception layers (document.write, property descriptor,
- * setAttribute, createElement, DOM insertion, MutationObserver) to catch
- * GPT script URLs regardless of how they are set or inserted.
- */
 export function installGptGuard(): void {
-  if (installed) {
-    log.debug(`${LOG_PREFIX}: already installed, skipping`);
-    return;
-  }
-
-  if (typeof window === 'undefined') {
-    log.debug(`${LOG_PREFIX}: not in browser environment, skipping`);
-    return;
-  }
-
-  log.info(`${LOG_PREFIX}: installing interception for Google ad scripts`);
-
-  // Layer 1: intercept document.write('<script src="...">') — GPT's primary path
-  installDocumentWritePatch();
-
-  // Layer 2: intercept .src = "..." on any HTMLScriptElement
-  installSrcDescriptor();
-
-  // Layer 3: intercept .setAttribute('src', "...")
-  installSetAttributePatch();
-
-  // Layer 4: intercept document.createElement('script') for instance-level patching
-  installCreateElementPatch();
-
-  // Layer 5: intercept appendChild / insertBefore (scripts + link preloads)
-  installDomInsertionDispatcher();
-
-  // Layer 6: catch anything else via MutationObserver
-  installMutationObserver();
-
-  installed = true;
-  log.info(`${LOG_PREFIX}: all interception layers installed`);
+  guard.install();
 }
 
-/**
- * Check if the guard is currently installed.
- */
 export function isGuardInstalled(): boolean {
-  return installed;
+  return guard.isInstalled();
 }
 
-/**
- * Reset the guard installation state (primarily for testing).
- */
 export function resetGuardState(): void {
-  mutationObserver?.disconnect();
-  mutationObserver = undefined;
-
-  if (typeof document !== 'undefined') {
-    if (nativeDocWrite) {
-      document.write = nativeDocWrite;
-    }
-    if (nativeDocWriteln) {
-      document.writeln = nativeDocWriteln;
-    }
-    if (nativeCreateElement) {
-      document.createElement = nativeCreateElement;
-    }
-  }
-
-  if (typeof HTMLScriptElement !== 'undefined') {
-    if (nativeSetAttribute) {
-      HTMLScriptElement.prototype.setAttribute = nativeSetAttribute;
-    }
-    if (nativeSrcDescriptor) {
-      try {
-        Object.defineProperty(HTMLScriptElement.prototype, 'src', nativeSrcDescriptor);
-      } catch {
-        // Some test environments do not allow descriptor restoration.
-      }
-    }
-  }
-
-  if (unregisterDomInsertionHandler) {
-    unregisterDomInsertionHandler();
-    unregisterDomInsertionHandler = undefined;
-  }
-
-  nativeDocWrite = undefined;
-  nativeDocWriteln = undefined;
-  nativeSrcSet = undefined;
-  nativeSrcGet = undefined;
-  nativeSrcDescriptor = undefined;
-  nativeSetAttribute = undefined;
-  nativeCreateElement = undefined;
-
-  rewritten = new WeakMap<HTMLScriptElement | HTMLLinkElement, string>();
-  instancePatched = new WeakSet<HTMLScriptElement>();
-
-  installed = false;
+  guard.reset();
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/startup.ts b/crates/trusted-server-js/lib/src/integrations/gpt/startup.ts
new file mode 100644
index 000000000..ed3399e1c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/startup.ts
@@ -0,0 +1,102 @@
+import type {
+  GoogletagAdapter,
+  GoogletagPublisherCallObserver,
+  GoogletagPublisherDefineSlotCall,
+  GoogletagPublisherDestroySlotsCall,
+  GoogletagPublisherDisplayCall,
+  GoogletagPublisherRefreshCall,
+} from '../../adapters/googletag';
+import type { SlotService } from '../../services/slots';
+
+type GptPublisherSlotBoundary = Pick<
+  SlotService,
+  | 'claimPublisherGptSlot'
+  | 'preparePublisherDisplay'
+  | 'preparePublisherRefresh'
+  | 'recordPublisherDestruction'
+  | 'start'
+>;
+
+export interface GptStartup {
+  readonly activate: () => () => void;
+  readonly installRefreshPolicy: (policy: GptRefreshPolicy) => (() => void) | undefined;
+  readonly start: (config: unknown) => void;
+}
+
+/** One optional Prebid policy composed into the sole publisher refresh observer. */
+export interface GptRefreshPolicy {
+  readonly prepare: (
+    call: Readonly<GoogletagPublisherRefreshCall>
+  ) => PromiseLike<unknown> | undefined;
+}
+
+export interface GptStartupOptions {
+  readonly googletag: Pick<GoogletagAdapter, 'observePublisherCalls'>;
+  readonly slots: () => GptPublisherSlotBoundary;
+  readonly start?: (config: unknown) => void;
+}
+
+/** Join the sole GPT interception boundary to runtime-owned slot handoff state. */
+export function createGptStartup(options: GptStartupOptions): GptStartup {
+  let refreshPolicy: GptRefreshPolicy | undefined;
+  return Object.freeze({
+    activate: (): (() => void) => {
+      const slots = options.slots();
+      const observer: GoogletagPublisherCallObserver = Object.freeze({
+        defineSlot: (call: Readonly<GoogletagPublisherDefineSlotCall>) =>
+          slots.claimPublisherGptSlot(call),
+        destroySlots: ({ slots: destroyed }: Readonly<GoogletagPublisherDestroySlotsCall>) => {
+          for (let index = 0; index < destroyed.length; index += 1) {
+            const slot = destroyed[index];
+            if (slot) slots.recordPublisherDestruction(slot);
+          }
+        },
+        display: (call: Readonly<GoogletagPublisherDisplayCall>) =>
+          slots.preparePublisherDisplay(call),
+        refresh: (call: Readonly<GoogletagPublisherRefreshCall>) => {
+          const decision = slots.preparePublisherRefresh(call);
+          const policy = refreshPolicy;
+          if (!policy || decision.action === 'suppress') return decision;
+          const policySlots = decision.action === 'replace' ? decision.slots : call.slots;
+          const policyCall =
+            decision.action === 'replace'
+              ? Object.freeze({
+                  requestedSlots:
+                    call.requestedSlots === undefined ? undefined : Object.freeze([...policySlots]),
+                  slots: Object.freeze([...policySlots]),
+                  options: call.options,
+                })
+              : call;
+          let completion: PromiseLike<unknown> | undefined;
+          try {
+            completion = policy.prepare(policyCall);
+          } catch {
+            return decision;
+          }
+          if (!completion) return decision;
+          return Object.freeze({
+            action: 'defer' as const,
+            ...(decision.admission ? { admission: decision.admission } : {}),
+            completion,
+            slots: Object.freeze([...policySlots]),
+          });
+        },
+      });
+      return options.googletag.observePublisherCalls(observer);
+    },
+    installRefreshPolicy: (policy: GptRefreshPolicy): (() => void) | undefined => {
+      if (!policy || typeof policy.prepare !== 'function' || refreshPolicy) return undefined;
+      refreshPolicy = policy;
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        if (refreshPolicy === policy) refreshPolicy = undefined;
+      };
+    },
+    start: (config: unknown): void => {
+      options.slots().start();
+      options.start?.(config);
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/api.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/api.ts
index 475bc7f93..5bcbff4ba 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/api.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/api.ts
@@ -6,13 +6,14 @@ import type {
   GptDiagnosticsSlotHandle,
   GptDiagnosticsTrustedServerOpportunity,
 } from '../../core/types';
+import { DiagnosticsSubscriberLimitError } from '../../core/trace';
 
 import type { GptDiagnosticsBindingManager } from './binding';
 import type { GptDiagnosticsStoreSnapshot } from './store';
 
 interface ApiStore {
   snapshot(): GptDiagnosticsStoreSnapshot;
-  subscribe(listener: () => void): () => void;
+  subscribeCommits(listener: () => void): () => void;
   recordTrustedServerOpportunity(
     slot: GptDiagnosticsSlotHandle,
     auctionSlotId: string,
@@ -45,51 +46,23 @@ type ApiWindow = Window & {
 };
 
 interface ApiOptions {
-  window?: ApiWindow;
-  document?: Document;
-  now?: () => Date;
-  schedule?: (callback: () => void) => void;
+  window?: ApiWindow | undefined;
+  document?: Document | undefined;
+  now?: (() => Date) | undefined;
+  schedule?: ((callback: () => void) => () => void) | undefined;
 }
 
 type ApiListener = (snapshot: GptDiagnosticsExportV1) => void;
+const MAX_API_SUBSCRIBERS = 32;
+
+interface PendingNotification {
+  readonly snapshot: GptDiagnosticsExportV1;
+  readonly subscriberIds: readonly number[];
+}
 
-function cloneExportSnapshot(snapshot: GptDiagnosticsExportV1): GptDiagnosticsExportV1 {
-  return {
-    version: snapshot.version,
-    capturedAt: snapshot.capturedAt,
-    page: { ...snapshot.page },
-    slots: snapshot.slots.map((slot) => ({
-      ...slot,
-      binding: { ...slot.binding },
-      requests: slot.requests.map((cycle) => ({
-        ...cycle,
-        durations: { ...cycle.durations },
-        requestedSlotSizes: cycle.requestedSlotSizes?.map((size) => [...size]),
-        size: cycle.size ? [...cycle.size] : undefined,
-        observedSlotSize: cycle.observedSlotSize ? [...cycle.observedSlotSize] : undefined,
-        adManager: cycle.adManager
-          ? {
-              ...cycle.adManager,
-              yieldGroupIds: cycle.adManager.yieldGroupIds
-                ? [...cycle.adManager.yieldGroupIds]
-                : undefined,
-              companyIds: cycle.adManager.companyIds ? [...cycle.adManager.companyIds] : undefined,
-            }
-          : undefined,
-        trustedServerCreativeFailures: cycle.trustedServerCreativeFailures
-          ? [...cycle.trustedServerCreativeFailures]
-          : undefined,
-      })),
-    })),
-    callbackIssues: snapshot.callbackIssues.map((issue) => ({ ...issue })),
-    ...(snapshot.attributionIssues === undefined
-      ? {}
-      : { attributionIssues: snapshot.attributionIssues.map((issue) => ({ ...issue })) }),
-    coverage: Object.fromEntries(
-      Object.entries(snapshot.coverage).map(([kind, counters]) => [kind, { ...counters }])
-    ) as GptDiagnosticsExportV1['coverage'],
-    metadata: { ...snapshot.metadata },
-  };
+function scheduleTask(callback: () => void): () => void {
+  const handle = globalThis.setTimeout(callback, 0);
+  return () => globalThis.clearTimeout(handle);
 }
 
 function safelyRecord(action: () => void): void {
@@ -120,11 +93,13 @@ export class GptDiagnosticsApiController {
   private readonly window: ApiWindow;
   private readonly document: Document;
   private readonly now: () => Date;
-  private readonly schedule: (callback: () => void) => void;
-  private readonly listeners = new Set<ApiListener>();
+  private readonly schedule: (callback: () => void) => () => void;
+  private readonly listeners = new Map<number, ApiListener>();
   private readonly unsubscribeStore: () => void;
   private readonly unsubscribeBindings: () => void;
-  private notificationScheduled = false;
+  private pending: PendingNotification | undefined;
+  private cancelScheduled: (() => void) | undefined;
+  private nextSubscriberId = 0;
   private destroyed = false;
 
   constructor(
@@ -139,19 +114,18 @@ export class GptDiagnosticsApiController {
     this.window = options.window ?? (window as unknown as ApiWindow);
     this.document = options.document ?? document;
     this.now = options.now ?? (() => new Date());
-    this.schedule = options.schedule ?? ((callback) => queueMicrotask(callback));
-    this.unsubscribeStore = this.store.subscribe(() => this.scheduleNotification());
+    this.schedule = options.schedule ?? scheduleTask;
+    this.unsubscribeStore = this.store.subscribeCommits(() => this.scheduleNotification());
     this.unsubscribeBindings = this.bindings.subscribe(() => this.scheduleNotification());
 
-    this.api = {
+    this.api = Object.freeze({
       snapshot: () => this.snapshot(),
       export: () => this.download(),
-      subscribe: (listener) => this.subscribe(listener),
+      subscribe: (listener: ApiListener) => this.subscribe(listener),
       show: () => this.presentation.show(),
       hide: () => this.presentation.hide(),
-    };
-
-    this.recorder = {
+    });
+    const recorder: GptDiagnosticsRecorder = {
       recordTrustedServerOpportunity: (
         slot,
         auctionSlotId,
@@ -176,53 +150,79 @@ export class GptDiagnosticsApiController {
       recordTrustedServerCreativeFailure: (attemptId, reason) =>
         safelyRecord(() => this.store.recordTrustedServerCreativeFailure(attemptId, reason)),
     };
+    this.recorder = Object.freeze(recorder);
   }
 
   snapshot(): GptDiagnosticsExportV1 {
     const store = this.store.snapshot();
-    return {
+    const slots = Object.freeze(
+      store.slots.map((slot) =>
+        Object.freeze({
+          runtimeSlotNumber: slot.runtimeSlotNumber,
+          slotElementId: slot.slotElementId,
+          adUnitPath: slot.adUnitPath,
+          binding: Object.freeze({ ...this.bindings.exportBinding(slot.runtimeSlotNumber) }),
+          currentVisibilityPercentage: slot.currentVisibilityPercentage,
+          maximumVisibilityPercentage: slot.maximumVisibilityPercentage,
+          requests: Object.freeze(
+            slot.requests.map((cycle) =>
+              Object.freeze({
+                ...cycle,
+                durations: Object.freeze({ ...cycle.durations }),
+                requestedSlotSizes: cycle.requestedSlotSizes
+                  ? Object.freeze(cycle.requestedSlotSizes.map((size) => Object.freeze([...size])))
+                  : undefined,
+                size: cycle.size ? Object.freeze([...cycle.size]) : undefined,
+                observedSlotSize: cycle.observedSlotSize
+                  ? Object.freeze([...cycle.observedSlotSize])
+                  : undefined,
+                adManager: cycle.adManager
+                  ? Object.freeze({
+                      ...cycle.adManager,
+                      yieldGroupIds: cycle.adManager.yieldGroupIds
+                        ? Object.freeze([...cycle.adManager.yieldGroupIds])
+                        : undefined,
+                      companyIds: cycle.adManager.companyIds
+                        ? Object.freeze([...cycle.adManager.companyIds])
+                        : undefined,
+                    })
+                  : undefined,
+                trustedServerCreativeFailures: cycle.trustedServerCreativeFailures
+                  ? Object.freeze([...cycle.trustedServerCreativeFailures])
+                  : undefined,
+              })
+            )
+          ),
+        })
+      )
+    );
+    const callbackIssues = Object.freeze(
+      store.callbackIssues.map((issue) => Object.freeze({ ...issue }))
+    );
+    const attributionIssues = Object.freeze(
+      store.attributionIssues.map((issue) => Object.freeze({ ...issue }))
+    );
+    const coverage = Object.freeze(
+      Object.fromEntries(
+        Object.entries(store.coverage).map(([kind, counters]) => [
+          kind,
+          Object.freeze({ ...counters }),
+        ])
+      )
+    ) as GptDiagnosticsExportV1['coverage'];
+    return Object.freeze({
       version: 1,
       capturedAt: this.now().toISOString(),
-      page: {
+      page: Object.freeze({
         origin: this.window.location.origin,
         pathname: this.window.location.pathname,
-      },
-      slots: store.slots.map((slot) => ({
-        runtimeSlotNumber: slot.runtimeSlotNumber,
-        slotElementId: slot.slotElementId,
-        adUnitPath: slot.adUnitPath,
-        binding: this.bindings.exportBinding(slot.runtimeSlotNumber),
-        currentVisibilityPercentage: slot.currentVisibilityPercentage,
-        maximumVisibilityPercentage: slot.maximumVisibilityPercentage,
-        requests: slot.requests.map((cycle) => ({
-          ...cycle,
-          durations: { ...cycle.durations },
-          requestedSlotSizes: cycle.requestedSlotSizes?.map((size) => [...size]),
-          size: cycle.size ? [...cycle.size] : undefined,
-          observedSlotSize: cycle.observedSlotSize ? [...cycle.observedSlotSize] : undefined,
-          adManager: cycle.adManager
-            ? {
-                ...cycle.adManager,
-                yieldGroupIds: cycle.adManager.yieldGroupIds
-                  ? [...cycle.adManager.yieldGroupIds]
-                  : undefined,
-                companyIds: cycle.adManager.companyIds
-                  ? [...cycle.adManager.companyIds]
-                  : undefined,
-              }
-            : undefined,
-          trustedServerCreativeFailures: cycle.trustedServerCreativeFailures
-            ? [...cycle.trustedServerCreativeFailures]
-            : undefined,
-        })),
-      })),
-      callbackIssues: store.callbackIssues.map((issue) => ({ ...issue })),
-      attributionIssues: store.attributionIssues.map((issue) => ({ ...issue })),
-      coverage: Object.fromEntries(
-        Object.entries(store.coverage).map(([kind, counters]) => [kind, { ...counters }])
-      ) as GptDiagnosticsExportV1['coverage'],
-      metadata: { ...store.metadata },
-    };
+      }),
+      slots,
+      callbackIssues,
+      attributionIssues,
+      coverage,
+      metadata: Object.freeze({ ...store.metadata }),
+    }) as GptDiagnosticsExportV1;
   }
 
   destroy(): void {
@@ -230,13 +230,31 @@ export class GptDiagnosticsApiController {
     this.destroyed = true;
     this.unsubscribeStore();
     this.unsubscribeBindings();
+    try {
+      this.cancelScheduled?.();
+    } catch {
+      // The destroyed latch suppresses a hostile late scheduler callback.
+    }
+    this.cancelScheduled = undefined;
+    this.pending = undefined;
     this.listeners.clear();
   }
 
   private subscribe(listener: ApiListener): () => void {
+    if (typeof listener !== 'function')
+      throw new TypeError('Diagnostics listener must be callable');
     if (this.destroyed) return () => undefined;
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
+    if (this.listeners.size >= MAX_API_SUBSCRIBERS) {
+      throw new DiagnosticsSubscriberLimitError('gpt');
+    }
+    const id = (this.nextSubscriberId += 1);
+    this.listeners.set(id, listener);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      this.listeners.delete(id);
+    };
   }
 
   private download(): void {
@@ -260,30 +278,34 @@ export class GptDiagnosticsApiController {
   }
 
   private scheduleNotification(): void {
-    if (this.destroyed || this.notificationScheduled) return;
-    this.notificationScheduled = true;
-    this.schedule(() => {
-      this.notificationScheduled = false;
-      if (this.destroyed) return;
-
-      // One snapshot per notification: every subscriber must see the same
-      // `capturedAt` and the same derived delivery states, and deriving it once
-      // keeps the cost independent of the subscriber count.
-      let snapshot: GptDiagnosticsExportV1;
-      try {
-        snapshot = this.snapshot();
-      } catch {
-        // A snapshot failure must not escape the scheduled callback.
-        return;
-      }
-
-      for (const listener of this.listeners) {
-        try {
-          listener(cloneExportSnapshot(snapshot));
-        } catch {
-          // One API subscriber must not block the rest.
-        }
-      }
+    if (this.destroyed || this.listeners.size === 0) return;
+    const pending = Object.freeze({
+      snapshot: this.snapshot(),
+      subscriberIds: Object.freeze([...this.listeners.keys()]),
     });
+    this.pending = pending;
+    if (this.cancelScheduled) return;
+    try {
+      const cancel = this.schedule(() => {
+        this.cancelScheduled = undefined;
+        const notification = this.pending;
+        this.pending = undefined;
+        if (this.destroyed || !notification) return;
+        for (const id of notification.subscriberIds) {
+          const listener = this.listeners.get(id);
+          if (!listener) continue;
+          try {
+            listener(notification.snapshot);
+          } catch {
+            // One API subscriber must not block the rest.
+          }
+        }
+      });
+      if (typeof cancel !== 'function') throw new TypeError('Invalid diagnostics scheduler');
+      if (!this.destroyed && this.pending) this.cancelScheduled = cancel;
+    } catch {
+      this.cancelScheduled = undefined;
+      this.pending = undefined;
+    }
   }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/badges.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/badges.ts
index 643dc355a..ed67c2caf 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/badges.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/badges.ts
@@ -1,4 +1,5 @@
 import type { GptDiagnosticsRequestCycle } from '../../core/types';
+import { realmOwnedElement, realmOwnedHtmlElement } from '../../shared/realm';
 
 import type { GptDiagnosticsBindingManager } from './binding';
 import { unhandledCase } from './exhaustive';
@@ -21,8 +22,8 @@ interface BadgeBindings {
 }
 
 type BadgeWindow = Window & {
-  MutationObserver?: typeof MutationObserver;
-  ResizeObserver?: typeof ResizeObserver;
+  MutationObserver?: typeof MutationObserver | undefined;
+  ResizeObserver?: typeof ResizeObserver | undefined;
 };
 
 const BADGE_MAX_WIDTH_PX = 260;
@@ -30,9 +31,9 @@ const BADGE_EDGE_GUTTER_PX = 4;
 const MAX_BADGE_REQUESTED_SLOT_SIZES = 3;
 
 interface BadgeOptions {
-  window?: BadgeWindow;
-  document?: Document;
-  scheduleFrame?: (callback: () => void) => void;
+  window?: BadgeWindow | undefined;
+  document?: Document | undefined;
+  scheduleFrame?: ((callback: () => void) => () => void) | undefined;
 }
 
 function intersectsViewport(rectangle: DOMRect, window: Window): boolean {
@@ -46,22 +47,32 @@ function intersectsViewport(rectangle: DOMRect, window: Window): boolean {
   );
 }
 
-function nodeIntersectsSlotIds(node: Node, slotElementIds: Set<string>): boolean {
-  if (!(node instanceof Element)) return false;
-  if (slotElementIds.has(node.id)) return true;
-  return Array.from(node.querySelectorAll('[id]')).some((element) =>
-    slotElementIds.has(element.id)
+function nodeIntersectsSlotIds(
+  node: Node,
+  slotElementIds: Set<string>,
+  targetWindow: BadgeWindow
+): boolean {
+  const element = realmOwnedElement(node, targetWindow);
+  if (!element) return false;
+  if (slotElementIds.has(element.id)) return true;
+  return Array.from(element.querySelectorAll('[id]')).some((descendant) =>
+    slotElementIds.has(descendant.id)
   );
 }
 
-function mutationIntersectsSlotIds(record: MutationRecord, slotElementIds: Set<string>): boolean {
+function mutationIntersectsSlotIds(
+  record: MutationRecord,
+  slotElementIds: Set<string>,
+  targetWindow: BadgeWindow
+): boolean {
+  const target = realmOwnedElement(record.target, targetWindow);
   if (record.type === 'attributes') {
-    if (!(record.target instanceof Element)) return false;
-    return slotElementIds.has(record.target.id) || slotElementIds.has(record.oldValue ?? '');
+    if (!target) return false;
+    return slotElementIds.has(target.id) || slotElementIds.has(record.oldValue ?? '');
   }
-  if (record.target instanceof Element && slotElementIds.has(record.target.id)) return true;
+  if (target && slotElementIds.has(target.id)) return true;
   return [...record.addedNodes, ...record.removedNodes].some((node) =>
-    nodeIntersectsSlotIds(node, slotElementIds)
+    nodeIntersectsSlotIds(node, slotElementIds, targetWindow)
   );
 }
 
@@ -71,13 +82,7 @@ function formatMilliseconds(value: number | undefined): string | undefined {
   return `${Math.round(value)} ms`;
 }
 
-/**
- * Label the delivery state the store already derived.
- *
- * The badge must not re-derive precedence from raw timestamps: the store owns
- * that ladder, and a second copy of it can disagree — for instance by claiming
- * a Trusted Server response on a cycle GPT reported empty.
- */
+/** Use the store's evidence ladder verbatim; presentation never re-derives ownership. */
 function deliveryLabel(cycle: GptDiagnosticsRequestCycle): string | undefined {
   switch (cycle.delivery) {
     case 'trusted_server_response_sent':
@@ -100,7 +105,8 @@ function deliveryLabel(cycle: GptDiagnosticsRequestCycle): string | undefined {
   }
 }
 
-function badgeText(cycle: GptDiagnosticsRequestCycle): string {
+/** Format one observed GPT request cycle for both badge and accessible text surfaces. */
+export function formatGptDiagnosticsBadgeText(cycle: GptDiagnosticsRequestCycle): string {
   const firstLine: string[] = [];
   if (cycle.isEmpty === true) firstLine.push('Empty');
   else if (cycle.isEmpty === false) firstLine.push('Filled');
@@ -147,22 +153,26 @@ export class GptDiagnosticsBadgeManager {
   private readonly bindings: BadgeBindings;
   private readonly window: BadgeWindow;
   private readonly document: Document;
-  private readonly scheduleFrame: (callback: () => void) => void;
+  private readonly scheduleFrame: (callback: () => void) => () => void;
   private readonly unsubscribeStore: () => void;
   private readonly unsubscribeBindings: () => void;
   private readonly slotElementIds = new Set<string>();
   private slots: GptDiagnosticsStoreSlotSnapshot[] = [];
-  private layer?: HTMLElement;
+  private layer: HTMLElement | undefined;
   private mutationObserver?: MutationObserver;
   private resizeObserver?: ResizeObserver;
+  private cancelScheduledUpdate: (() => void) | undefined;
   private scheduled = false;
   private destroyed = false;
 
   constructor(store: BadgeStore, bindings: BadgeBindings, options: BadgeOptions = {}) {
     this.store = store;
     this.bindings = bindings;
-    this.window = options.window ?? (window as unknown as BadgeWindow);
     this.document = options.document ?? document;
+    this.window =
+      options.window ??
+      (this.document.defaultView as unknown as BadgeWindow | null) ??
+      (window as unknown as BadgeWindow);
     this.scheduleFrame =
       options.scheduleFrame ?? ((callback) => scheduleFrame(this.window, callback));
     this.refreshSlotElementIds();
@@ -180,8 +190,8 @@ export class GptDiagnosticsBadgeManager {
 
   setLayer(layer: HTMLElement | undefined): void {
     if (this.destroyed) return;
-    this.layer = layer;
-    if (layer?.isConnected) this.refreshSlots();
+    this.layer = realmOwnedHtmlElement(layer, this.window);
+    if (this.layer?.isConnected) this.refreshSlots();
     this.scheduleUpdate();
   }
 
@@ -194,7 +204,7 @@ export class GptDiagnosticsBadgeManager {
       const cycle = latestCycle(slot);
       if (!cycle) continue;
       const binding = this.bindings.get(slot.runtimeSlotNumber);
-      const element = binding.element;
+      const element = realmOwnedHtmlElement(binding.element, this.window);
       if (binding.binding.status !== 'bound' || !element?.isConnected) continue;
 
       const rectangle = element.getBoundingClientRect();
@@ -204,7 +214,7 @@ export class GptDiagnosticsBadgeManager {
       const badge = this.document.createElement('div');
       badge.className = 'tsgd-badge';
       badge.dataset.runtimeSlot = String(slot.runtimeSlotNumber);
-      badge.textContent = badgeText(cycle);
+      badge.textContent = formatGptDiagnosticsBadgeText(cycle);
       badge.style.maxWidth = `${BADGE_MAX_WIDTH_PX}px`;
       badge.style.left = `${Math.max(
         BADGE_EDGE_GUTTER_PX,
@@ -230,6 +240,14 @@ export class GptDiagnosticsBadgeManager {
   destroy(): void {
     if (this.destroyed) return;
     this.destroyed = true;
+    const cancelUpdate = this.cancelScheduledUpdate;
+    this.cancelScheduledUpdate = undefined;
+    this.scheduled = false;
+    try {
+      cancelUpdate?.();
+    } catch {
+      // Continue releasing every independently owned badge resource.
+    }
     this.unsubscribeStore();
     this.unsubscribeBindings();
     this.window.removeEventListener('scroll', this.scheduleUpdate);
@@ -243,10 +261,40 @@ export class GptDiagnosticsBadgeManager {
   private readonly scheduleUpdate = (): void => {
     if (this.destroyed || this.scheduled) return;
     this.scheduled = true;
-    this.scheduleFrame(() => {
+    let active = true;
+    let cancelFrame: (() => void) | undefined;
+    const run = (): void => {
+      if (!active) return;
+      active = false;
+      this.cancelScheduledUpdate = undefined;
+      try {
+        cancelFrame?.();
+      } catch {
+        // A completed frame remains authoritative when scheduler cleanup fails.
+      }
       this.scheduled = false;
       this.update();
-    });
+    };
+    try {
+      cancelFrame = this.scheduleFrame(run);
+      if (typeof cancelFrame !== 'function') {
+        throw new TypeError('Invalid badge frame scheduler');
+      }
+      if (active) {
+        this.cancelScheduledUpdate = (): void => {
+          if (!active) return;
+          active = false;
+          this.scheduled = false;
+          cancelFrame?.();
+        };
+      } else {
+        cancelFrame();
+      }
+    } catch {
+      active = false;
+      this.cancelScheduledUpdate = undefined;
+      this.scheduled = false;
+    }
   };
 
   private refreshSlots(): void {
@@ -265,7 +313,11 @@ export class GptDiagnosticsBadgeManager {
     if (typeof Observer !== 'function' || !this.document.documentElement) return;
     this.mutationObserver = new Observer((records) => {
       if (!this.layer?.isConnected || this.slotElementIds.size === 0) return;
-      if (records.some((record) => mutationIntersectsSlotIds(record, this.slotElementIds))) {
+      if (
+        records.some((record) =>
+          mutationIntersectsSlotIds(record, this.slotElementIds, this.window)
+        )
+      ) {
         this.scheduleUpdate();
       }
     });
@@ -284,5 +336,3 @@ export class GptDiagnosticsBadgeManager {
     this.resizeObserver = new Observer(this.scheduleUpdate);
   }
 }
-
-export const gptDiagnosticsBadgeTextForTest = badgeText;
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/binding.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/binding.ts
index c6c46a727..b2c2a78d2 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/binding.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/binding.ts
@@ -1,4 +1,5 @@
 import type { GptDiagnosticsBinding, GptDiagnosticsSlotExport } from '../../core/types';
+import { realmOwnedElement, realmOwnedHtmlElement } from '../../shared/realm';
 
 import { scheduleFrame } from './presentation_helpers';
 import type { GptDiagnosticsBindingInput } from './store';
@@ -9,20 +10,20 @@ interface BindingStore {
 }
 
 type BindingWindow = Window & {
-  CSS?: typeof CSS;
+  CSS?: typeof CSS | undefined;
   HTMLElement: typeof HTMLElement;
-  MutationObserver?: typeof MutationObserver;
+  MutationObserver?: typeof MutationObserver | undefined;
 };
 
 interface BindingOptions {
-  document?: Document;
-  window?: BindingWindow;
-  scheduleFrame?: (callback: () => void) => void;
+  document?: Document | undefined;
+  window?: BindingWindow | undefined;
+  scheduleFrame?: ((callback: () => void) => () => void) | undefined;
 }
 
 export interface GptDiagnosticsBindingView {
   binding: GptDiagnosticsBinding;
-  element?: HTMLElement;
+  element?: HTMLElement | undefined;
   visible: boolean;
 }
 
@@ -40,23 +41,33 @@ function isVisibleInViewport(element: HTMLElement, window: BindingWindow): boole
   );
 }
 
-function nodeIntersectsSlotIds(node: Node, slotElementIds: Set<string>): boolean {
-  if (!(node instanceof Element)) return false;
-  if (slotElementIds.has(node.id)) return true;
-  return Array.from(node.querySelectorAll('[id]')).some((element) =>
-    slotElementIds.has(element.id)
+function nodeIntersectsSlotIds(
+  node: Node,
+  slotElementIds: Set<string>,
+  targetWindow: BindingWindow
+): boolean {
+  const element = realmOwnedElement(node, targetWindow);
+  if (!element) return false;
+  if (slotElementIds.has(element.id)) return true;
+  return Array.from(element.querySelectorAll('[id]')).some((descendant) =>
+    slotElementIds.has(descendant.id)
   );
 }
 
-function mutationIntersectsSlotIds(record: MutationRecord, slotElementIds: Set<string>): boolean {
+function mutationIntersectsSlotIds(
+  record: MutationRecord,
+  slotElementIds: Set<string>,
+  targetWindow: BindingWindow
+): boolean {
+  const target = realmOwnedElement(record.target, targetWindow);
   if (record.type === 'attributes') {
-    if (!(record.target instanceof Element)) return false;
-    return slotElementIds.has(record.target.id) || slotElementIds.has(record.oldValue ?? '');
+    if (!target) return false;
+    return slotElementIds.has(target.id) || slotElementIds.has(record.oldValue ?? '');
   }
 
-  if (record.target instanceof Element && slotElementIds.has(record.target.id)) return true;
+  if (target && slotElementIds.has(target.id)) return true;
   return [...record.addedNodes, ...record.removedNodes].some((node) =>
-    nodeIntersectsSlotIds(node, slotElementIds)
+    nodeIntersectsSlotIds(node, slotElementIds, targetWindow)
   );
 }
 
@@ -77,19 +88,23 @@ export class GptDiagnosticsBindingManager {
   private readonly store: BindingStore;
   private readonly document: Document;
   private readonly window: BindingWindow;
-  private readonly scheduleFrame: (callback: () => void) => void;
+  private readonly scheduleFrame: (callback: () => void) => () => void;
   private readonly bindings = new Map<number, GptDiagnosticsBindingView>();
   private readonly listeners = new Set<BindingListener>();
   private readonly slotElementIds = new Set<string>();
   private readonly unsubscribeStore: () => void;
   private mutationObserver?: MutationObserver;
+  private cancelScheduledRefresh: (() => void) | undefined;
   private refreshScheduled = false;
   private destroyed = false;
 
   constructor(store: BindingStore, options: BindingOptions = {}) {
     this.store = store;
     this.document = options.document ?? document;
-    this.window = options.window ?? (window as unknown as BindingWindow);
+    this.window =
+      options.window ??
+      (this.document.defaultView as unknown as BindingWindow | null) ??
+      (window as unknown as BindingWindow);
     this.scheduleFrame =
       options.scheduleFrame ?? ((callback) => scheduleFrame(this.window, callback));
     this.unsubscribeStore = this.store.subscribe(() => this.scheduleRefresh());
@@ -149,6 +164,14 @@ export class GptDiagnosticsBindingManager {
   destroy(): void {
     if (this.destroyed) return;
     this.destroyed = true;
+    const cancelRefresh = this.cancelScheduledRefresh;
+    this.cancelScheduledRefresh = undefined;
+    this.refreshScheduled = false;
+    try {
+      cancelRefresh?.();
+    } catch {
+      // Continue releasing every independently owned binding resource.
+    }
     this.unsubscribeStore();
     this.mutationObserver?.disconnect();
     this.window.removeEventListener('scroll', this.scheduleRefresh);
@@ -160,10 +183,40 @@ export class GptDiagnosticsBindingManager {
   private readonly scheduleRefresh = (): void => {
     if (this.destroyed || this.refreshScheduled) return;
     this.refreshScheduled = true;
-    this.scheduleFrame(() => {
+    let active = true;
+    let cancelFrame: (() => void) | undefined;
+    const run = (): void => {
+      if (!active) return;
+      active = false;
+      this.cancelScheduledRefresh = undefined;
+      try {
+        cancelFrame?.();
+      } catch {
+        // A completed frame remains authoritative when scheduler cleanup fails.
+      }
       this.refreshScheduled = false;
       this.refresh();
-    });
+    };
+    try {
+      cancelFrame = this.scheduleFrame(run);
+      if (typeof cancelFrame !== 'function') {
+        throw new TypeError('Invalid binding frame scheduler');
+      }
+      if (active) {
+        this.cancelScheduledRefresh = (): void => {
+          if (!active) return;
+          active = false;
+          this.refreshScheduled = false;
+          cancelFrame?.();
+        };
+      } else {
+        cancelFrame();
+      }
+    } catch {
+      active = false;
+      this.cancelScheduledRefresh = undefined;
+      this.refreshScheduled = false;
+    }
   };
 
   private resolveBinding(
@@ -184,15 +237,14 @@ export class GptDiagnosticsBindingManager {
       };
     }
 
-    const candidate = this.document.getElementById(slotElementId);
-    if (!candidate || !(candidate instanceof this.window.HTMLElement) || !candidate.isConnected) {
+    const element = realmOwnedHtmlElement(this.document.getElementById(slotElementId), this.window);
+    if (!element || !element.isConnected) {
       return {
         binding: { status: 'unbound', reason: 'missing_element' },
         visible: false,
       };
     }
 
-    const element = candidate as HTMLElement;
     const escape = this.window.CSS?.escape;
     if (typeof escape !== 'function') {
       return {
@@ -230,7 +282,9 @@ export class GptDiagnosticsBindingManager {
     const observer = new Observer((records) => {
       if (
         this.slotElementIds.size > 0 &&
-        records.some((record) => mutationIntersectsSlotIds(record, this.slotElementIds))
+        records.some((record) =>
+          mutationIntersectsSlotIds(record, this.slotElementIds, this.window)
+        )
       ) {
         this.scheduleRefresh();
       }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/data_api.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/data_api.ts
new file mode 100644
index 000000000..299eca58c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/data_api.ts
@@ -0,0 +1,332 @@
+import type {
+  GptDiagnosticsApi,
+  GptDiagnosticsBinding,
+  GptDiagnosticsExportV1,
+  Size,
+} from '../../core/types';
+import { DiagnosticsSubscriberLimitError } from '../../core/trace';
+
+import type { GptDiagnosticsBindingInput, GptDiagnosticsStoreSnapshot } from './store';
+
+interface DiagnosticsDataStore {
+  readonly bindingInputs: () => GptDiagnosticsBindingInput[];
+  readonly recordObservedSlotSize: (
+    runtimeSlotNumber: number,
+    requestNumber: number,
+    size: Size
+  ) => void;
+  readonly snapshot: () => GptDiagnosticsStoreSnapshot;
+  readonly subscribe: (listener: () => void) => () => void;
+  readonly subscribeCommits: (listener: () => void) => () => void;
+}
+
+export interface GptDiagnosticsPresentationControls {
+  readonly dispose: () => void;
+  readonly download: () => void;
+  readonly exportBinding: (runtimeSlotNumber: number) => GptDiagnosticsBinding;
+  readonly hide: () => void;
+  readonly show: () => void;
+  readonly subscribe: (listener: () => void) => () => void;
+}
+
+export interface GptDiagnosticsPresentationSource {
+  readonly bindingInputs: () => GptDiagnosticsBindingInput[];
+  readonly recordObservedSlotSize: (
+    runtimeSlotNumber: number,
+    requestNumber: number,
+    size: Size
+  ) => void;
+  readonly snapshot: () => GptDiagnosticsStoreSnapshot;
+  readonly subscribe: (listener: () => void) => () => void;
+}
+
+export type GptDiagnosticsPresentationFactory = (
+  source: GptDiagnosticsPresentationSource,
+  api: GptDiagnosticsApi
+) => GptDiagnosticsPresentationControls;
+
+interface DataApiOptions {
+  readonly location: Pick<Location, 'origin' | 'pathname'>;
+  readonly now?: (() => Date) | undefined;
+  readonly schedule?: ((callback: () => void) => () => void) | undefined;
+}
+
+type ApiListener = (snapshot: GptDiagnosticsExportV1) => void;
+
+interface PendingNotification {
+  readonly snapshot: GptDiagnosticsExportV1;
+  readonly subscriberIds: readonly number[];
+}
+
+const MAX_API_SUBSCRIBERS = 32;
+
+function scheduleTask(callback: () => void): () => void {
+  const handle = globalThis.setTimeout(callback, 0);
+  return () => globalThis.clearTimeout(handle);
+}
+
+function defaultBinding(): GptDiagnosticsBinding {
+  return Object.freeze({ status: 'unbound', reason: 'missing_element' });
+}
+
+function isolate(callback: () => void): void {
+  try {
+    callback();
+  } catch {
+    // Presentation cleanup cannot retain another independently owned resource.
+  }
+}
+
+function validPresentationControls(
+  candidate: unknown
+): candidate is GptDiagnosticsPresentationControls {
+  try {
+    if (typeof candidate !== 'object' || candidate === null || !Object.isFrozen(candidate)) {
+      return false;
+    }
+    const expected = ['dispose', 'download', 'exportBinding', 'hide', 'show', 'subscribe'];
+    const keys = Reflect.ownKeys(candidate);
+    if (keys.length !== expected.length || keys.some((key) => typeof key !== 'string'))
+      return false;
+    for (let index = 0; index < expected.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, expected[index] as string);
+      if (!descriptor || !('value' in descriptor) || typeof descriptor.value !== 'function') {
+        return false;
+      }
+    }
+    return keys.every((key) => expected.includes(key as string));
+  } catch {
+    return false;
+  }
+}
+
+function disposePresentationCandidate(candidate: unknown): void {
+  try {
+    if (typeof candidate !== 'object' || candidate === null) return;
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, 'dispose');
+    if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
+      Reflect.apply(descriptor.value, candidate, []);
+    }
+  } catch {
+    // A malformed presentation cannot block its own rollback boundary.
+  }
+}
+
+/** Owns the stable, data-only GPT diagnostics API published in the takeover barrier. */
+export class GptDiagnosticsDataApiController {
+  readonly api: GptDiagnosticsApi;
+
+  private readonly store: DiagnosticsDataStore;
+  private readonly location: Pick<Location, 'origin' | 'pathname'>;
+  private readonly now: () => Date;
+  private readonly schedule: (callback: () => void) => () => void;
+  private readonly listeners = new Map<number, ApiListener>();
+  private readonly unsubscribeStore: () => void;
+  private readonly presentationSource: GptDiagnosticsPresentationSource;
+  private presentation: GptDiagnosticsPresentationControls | undefined;
+  private unsubscribePresentation: (() => void) | undefined;
+  private pending: PendingNotification | undefined;
+  private cancelScheduled: (() => void) | undefined;
+  private nextSubscriberId = 0;
+  private presentationAttaching = false;
+  private destroyed = false;
+
+  constructor(store: DiagnosticsDataStore, options: DataApiOptions) {
+    this.store = store;
+    this.location = options.location;
+    this.now = options.now ?? (() => new Date());
+    this.schedule = options.schedule ?? scheduleTask;
+    this.unsubscribeStore = store.subscribeCommits(() => this.scheduleNotification());
+    this.presentationSource = Object.freeze({
+      bindingInputs: () => store.bindingInputs(),
+      recordObservedSlotSize: (runtimeSlotNumber: number, requestNumber: number, size: Size) =>
+        store.recordObservedSlotSize(runtimeSlotNumber, requestNumber, size),
+      snapshot: () => store.snapshot(),
+      subscribe: (listener: () => void) => store.subscribe(listener),
+    });
+    this.api = Object.freeze({
+      snapshot: () => this.snapshot(),
+      export: () => this.presentation?.download(),
+      subscribe: (listener: ApiListener) => this.subscribe(listener),
+      show: () => this.presentation?.show(),
+      hide: () => this.presentation?.hide(),
+    });
+  }
+
+  attachPresentation(factory: GptDiagnosticsPresentationFactory): () => void {
+    if (typeof factory !== 'function') {
+      throw new TypeError('GPT diagnostics presentation factory must be callable');
+    }
+    if (this.destroyed || this.presentation || this.presentationAttaching) {
+      throw new TypeError('GPT diagnostics presentation is unavailable');
+    }
+    this.presentationAttaching = true;
+    let candidate: unknown;
+    try {
+      candidate = factory(this.presentationSource, this.api);
+      if (!validPresentationControls(candidate)) {
+        throw new TypeError('GPT diagnostics presentation controls are malformed');
+      }
+      const controls = candidate;
+      const release = controls.subscribe(() => this.scheduleNotification());
+      if (typeof release !== 'function') {
+        throw new TypeError('GPT diagnostics presentation disposer is unavailable');
+      }
+      this.presentation = controls;
+      this.unsubscribePresentation = release;
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        if (this.presentation !== controls) return;
+        this.presentation = undefined;
+        this.unsubscribePresentation = undefined;
+        isolate(release);
+        isolate(() => controls.dispose());
+      };
+    } catch (error) {
+      disposePresentationCandidate(candidate);
+      throw error;
+    } finally {
+      this.presentationAttaching = false;
+    }
+  }
+
+  snapshot(): GptDiagnosticsExportV1 {
+    const store = this.store.snapshot();
+    const presentation = this.presentation;
+    return Object.freeze({
+      version: 1,
+      capturedAt: this.now().toISOString(),
+      page: Object.freeze({
+        origin: this.location.origin,
+        pathname: this.location.pathname,
+      }),
+      slots: Object.freeze(
+        store.slots.map((slot) =>
+          Object.freeze({
+            runtimeSlotNumber: slot.runtimeSlotNumber,
+            slotElementId: slot.slotElementId,
+            adUnitPath: slot.adUnitPath,
+            binding: Object.freeze(
+              presentation?.exportBinding(slot.runtimeSlotNumber) ?? defaultBinding()
+            ),
+            currentVisibilityPercentage: slot.currentVisibilityPercentage,
+            maximumVisibilityPercentage: slot.maximumVisibilityPercentage,
+            requests: Object.freeze(
+              slot.requests.map((cycle) =>
+                Object.freeze({
+                  ...cycle,
+                  durations: Object.freeze({ ...cycle.durations }),
+                  requestedSlotSizes: cycle.requestedSlotSizes
+                    ? Object.freeze(
+                        cycle.requestedSlotSizes.map((size) => Object.freeze([...size]))
+                      )
+                    : undefined,
+                  size: cycle.size ? Object.freeze([...cycle.size]) : undefined,
+                  observedSlotSize: cycle.observedSlotSize
+                    ? Object.freeze([...cycle.observedSlotSize])
+                    : undefined,
+                  adManager: cycle.adManager
+                    ? Object.freeze({
+                        ...cycle.adManager,
+                        yieldGroupIds: cycle.adManager.yieldGroupIds
+                          ? Object.freeze([...cycle.adManager.yieldGroupIds])
+                          : undefined,
+                        companyIds: cycle.adManager.companyIds
+                          ? Object.freeze([...cycle.adManager.companyIds])
+                          : undefined,
+                      })
+                    : undefined,
+                  trustedServerCreativeFailures: cycle.trustedServerCreativeFailures
+                    ? Object.freeze([...cycle.trustedServerCreativeFailures])
+                    : undefined,
+                })
+              )
+            ),
+          })
+        )
+      ),
+      callbackIssues: Object.freeze(
+        store.callbackIssues.map((issue) => Object.freeze({ ...issue }))
+      ),
+      attributionIssues: Object.freeze(
+        store.attributionIssues.map((issue) => Object.freeze({ ...issue }))
+      ),
+      coverage: Object.freeze(
+        Object.fromEntries(
+          Object.entries(store.coverage).map(([kind, counters]) => [
+            kind,
+            Object.freeze({ ...counters }),
+          ])
+        )
+      ) as GptDiagnosticsExportV1['coverage'],
+      metadata: Object.freeze({ ...store.metadata }),
+    }) as GptDiagnosticsExportV1;
+  }
+
+  destroy(): void {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    isolate(this.unsubscribeStore);
+    const releasePresentation = this.unsubscribePresentation;
+    const presentation = this.presentation;
+    this.unsubscribePresentation = undefined;
+    this.presentation = undefined;
+    if (releasePresentation) isolate(releasePresentation);
+    if (presentation) isolate(() => presentation.dispose());
+    if (this.cancelScheduled) isolate(this.cancelScheduled);
+    this.cancelScheduled = undefined;
+    this.pending = undefined;
+    this.listeners.clear();
+  }
+
+  private subscribe(listener: ApiListener): () => void {
+    if (typeof listener !== 'function') {
+      throw new TypeError('Diagnostics listener must be callable');
+    }
+    if (this.destroyed) return () => undefined;
+    if (this.listeners.size >= MAX_API_SUBSCRIBERS) {
+      throw new DiagnosticsSubscriberLimitError('gpt');
+    }
+    const id = (this.nextSubscriberId += 1);
+    this.listeners.set(id, listener);
+    let active = true;
+    return (): void => {
+      if (!active) return;
+      active = false;
+      this.listeners.delete(id);
+    };
+  }
+
+  private scheduleNotification(): void {
+    if (this.destroyed || this.listeners.size === 0) return;
+    this.pending = Object.freeze({
+      snapshot: this.snapshot(),
+      subscriberIds: Object.freeze([...this.listeners.keys()]),
+    });
+    if (this.cancelScheduled) return;
+    try {
+      const cancel = this.schedule(() => {
+        this.cancelScheduled = undefined;
+        const notification = this.pending;
+        this.pending = undefined;
+        if (this.destroyed || !notification) return;
+        for (const id of notification.subscriberIds) {
+          const listener = this.listeners.get(id);
+          if (!listener) continue;
+          try {
+            listener(notification.snapshot);
+          } catch {
+            // One public diagnostics subscriber cannot block the remaining listeners.
+          }
+        }
+      });
+      if (typeof cancel !== 'function') throw new TypeError('Invalid diagnostics scheduler');
+      if (!this.destroyed && this.pending) this.cancelScheduled = cancel;
+    } catch {
+      this.cancelScheduled = undefined;
+      this.pending = undefined;
+    }
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts
index d7271710c..414bb9ac2 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts
@@ -1,111 +1,13 @@
-import { log } from '../../core/log';
-import type { GptDiagnosticsApi, TsjsApi } from '../../core/types';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { GptDiagnosticsApiController } from './api';
-import { GptDiagnosticsBadgeManager } from './badges';
-import { GptDiagnosticsBindingManager } from './binding';
-import { GptDiagnosticsObserver } from './observer';
-import type { GptObserverWindow } from './observer';
-import { GptDiagnosticsOverlay } from './overlay';
-import { GptDiagnosticsSlotSizeObserver } from './slot_size_observer';
-import { GptDiagnosticsStore } from './store';
+import { createGptDiagnosticsIntegrationRegistration } from './module';
 
-interface GptDiagnosticsRuntime {
-  api: GptDiagnosticsApi;
-  destroy(): void;
-}
-
-type GptDiagnosticsWindow = Window &
-  typeof globalThis &
-  GptObserverWindow & {
-    __tsjs_gpt_diagnostics_active?: boolean;
-    __tsjs_gpt_diagnostics_runtime?: GptDiagnosticsRuntime;
-    tsjs?: TsjsApi;
-  };
-
-/** Whether the early bootstrap activated diagnostics for this document. */
-export function isGptDiagnosticsActive(
-  target: Pick<
-    GptDiagnosticsWindow,
-    '__tsjs_gpt_diagnostics_active'
-  > = window as GptDiagnosticsWindow
-): boolean {
-  return target.__tsjs_gpt_diagnostics_active === true;
-}
-
-/** Installs one active diagnostics runtime for the current document. */
-export function installGptDiagnosticsRuntime(
-  target: GptDiagnosticsWindow = window as GptDiagnosticsWindow
-): GptDiagnosticsApi | undefined {
-  if (!isGptDiagnosticsActive(target)) return undefined;
-  if (target.__tsjs_gpt_diagnostics_runtime) {
-    return target.__tsjs_gpt_diagnostics_runtime.api;
-  }
-
-  let bindings: GptDiagnosticsBindingManager | undefined;
-  let badges: GptDiagnosticsBadgeManager | undefined;
-  let overlay: GptDiagnosticsOverlay | undefined;
-  let slotSizeObserver: GptDiagnosticsSlotSizeObserver | undefined;
-  let apiController: GptDiagnosticsApiController | undefined;
-
-  try {
-    if (!target.tsjs) throw new Error('TSJS core API unavailable');
-
-    const store = new GptDiagnosticsStore();
-    const observer = new GptDiagnosticsObserver(store, { window: target });
-    bindings = new GptDiagnosticsBindingManager(store, {
-      window: target,
-      document: target.document,
-    });
-    badges = new GptDiagnosticsBadgeManager(store, bindings, {
-      window: target,
-      document: target.document,
-    });
-    slotSizeObserver = new GptDiagnosticsSlotSizeObserver(store, bindings, { window: target });
-    overlay = new GptDiagnosticsOverlay(store, bindings, {
-      window: target,
-      document: target.document,
-      onExport: () => apiController?.api.export(),
-      onBadgeLayerChange: (layer) => badges?.setLayer(layer),
-    });
-    apiController = new GptDiagnosticsApiController(store, bindings, overlay, {
-      window: target,
-      document: target.document,
-    });
-
-    observer.install();
-    const api = apiController.api;
-    const recorder = apiController.recorder;
-    const runtime: GptDiagnosticsRuntime = {
-      api,
-      destroy: () => {
-        if (target.tsjs?.gptDiagnostics === api) delete target.tsjs.gptDiagnostics;
-        if (target.tsjs?.gptDiagnosticsRecorder === recorder) {
-          delete target.tsjs.gptDiagnosticsRecorder;
-        }
-        apiController?.destroy();
-        overlay?.destroy();
-        badges?.destroy();
-        slotSizeObserver?.destroy();
-        bindings?.destroy();
-        delete target.__tsjs_gpt_diagnostics_runtime;
-      },
-    };
-    target.tsjs.gptDiagnostics = api;
-    target.tsjs.gptDiagnosticsRecorder = recorder;
-    target.__tsjs_gpt_diagnostics_runtime = runtime;
-    return api;
-  } catch (error) {
-    apiController?.destroy();
-    overlay?.destroy();
-    badges?.destroy();
-    slotSizeObserver?.destroy();
-    bindings?.destroy();
-    log.warn('gpt diagnostics: runtime installation failed', error);
-    return undefined;
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createGptDiagnosticsIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
   }
 }
-
-if (typeof window !== 'undefined' && isGptDiagnosticsActive(window as GptDiagnosticsWindow)) {
-  installGptDiagnosticsRuntime(window as GptDiagnosticsWindow);
-}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/module.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/module.ts
new file mode 100644
index 000000000..2ba1ba108
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/module.ts
@@ -0,0 +1,127 @@
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import { realmOwnedDocument } from '../../shared/realm';
+
+import {
+  GptDiagnosticsDataApiController,
+  type GptDiagnosticsPresentationFactory,
+} from './data_api';
+import { GptDiagnosticsObserver, type GptDiagnosticsFact } from './observer';
+import { GptDiagnosticsStore } from './store';
+
+export const GPT_DIAGNOSTICS_INTEGRATION_ID = 'gpt_diagnostics' as const;
+
+interface GptEventsCapability {
+  readonly subscribe: (listener: (fact: Readonly<GptDiagnosticsFact>) => void) => () => void;
+}
+
+function activeConfiguration(candidate: unknown): boolean {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      !Object.isFrozen(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      Reflect.ownKeys(candidate).length !== 1
+    ) {
+      return false;
+    }
+    const active = Object.getOwnPropertyDescriptor(candidate, 'active');
+    return Boolean(active?.enumerable && 'value' in active && active.value === true);
+  } catch {
+    return false;
+  }
+}
+
+function frozenCapability(
+  interfaces: Readonly<Record<string, unknown>>,
+  key: string
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(interfaces, key);
+    if (!descriptor || !('value' in descriptor)) return undefined;
+    const candidate = descriptor.value;
+    return typeof candidate === 'object' &&
+      candidate !== null &&
+      !Array.isArray(candidate) &&
+      Object.isFrozen(candidate)
+      ? (candidate as Readonly<Record<string, unknown>>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function gptEventsCapability(
+  interfaces: Readonly<Record<string, unknown>>
+): GptEventsCapability | undefined {
+  const candidate = frozenCapability(interfaces, 'gpt.events.v1');
+  if (!candidate || Reflect.ownKeys(candidate).length !== 1) return undefined;
+  return typeof candidate['subscribe'] === 'function'
+    ? (candidate as unknown as GptEventsCapability)
+    : undefined;
+}
+
+/** Build the takeover, data-only GPT diagnostics fact provider. */
+export function createGptDiagnosticsIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  const prepare = (context: IntegrationPrepareContext) => {
+    if (!activeConfiguration(context.config)) {
+      throw new TypeError('GPT diagnostics integration config is invalid');
+    }
+    const runtime = frozenCapability(context.interfaces, 'runtime.v1');
+    const runtimeDocument = realmOwnedDocument(runtime?.['document']);
+    const runtimeWindow = runtimeDocument?.defaultView;
+    if (!runtime || !runtimeWindow) {
+      throw new TypeError('GPT diagnostics requires runtime.v1');
+    }
+    const events = gptEventsCapability(context.interfaces);
+    if (!events) throw new TypeError('GPT diagnostics requires gpt.events.v1');
+
+    const store = new GptDiagnosticsStore();
+    const observer = new GptDiagnosticsObserver(store);
+    const controller = new GptDiagnosticsDataApiController(store, {
+      location: runtimeWindow.location,
+    });
+    context.onDispose(() => controller.destroy());
+    let active = false;
+    const dataCapability = Object.freeze({
+      api: controller.api,
+      attachPresentation: (factory: GptDiagnosticsPresentationFactory): (() => void) =>
+        controller.attachPresentation(factory),
+    });
+
+    return Object.freeze({
+      activate: ({ onDispose }: IntegrationActivationContext) => {
+        if (active) throw new Error('GPT diagnostics already activated');
+        const ownership: { release?: () => void } = {};
+        onDispose(() => {
+          active = false;
+          ownership.release?.();
+        });
+        active = true;
+        const release = events.subscribe((fact) => {
+          if (active) observer.consume(fact);
+        });
+        if (typeof release !== 'function') {
+          throw new TypeError('GPT diagnostics event disposer is unavailable');
+        }
+        ownership.release = release;
+      },
+      interfaces: Object.freeze({ 'gpt_diag.v1': dataCapability }),
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: GPT_DIAGNOSTICS_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/observer.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/observer.ts
index 7a19ba043..7e646d294 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/observer.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/observer.ts
@@ -1,276 +1,163 @@
+import type { GoogletagDiagnosticsFact } from '../../adapters/googletag';
 import { log } from '../../core/log';
-import type { GptDiagnosticsAdManagerIdentity, Size, TsjsApi } from '../../core/types';
+import type { Size } from '../../core/types';
+import type { GptDiagnosticsOpportunityFact } from '../../shared/gpt_diagnostics';
 
 import type { GptDiagnosticsSlotLike, GptRenderFacts } from './store';
 
-export interface GptDiagnosticsObserverStore {
-  markGptObserved(): void;
-  recordSlotRequested(slot: GptDiagnosticsSlotLike): void;
-  recordSlotResponseReceived(slot: GptDiagnosticsSlotLike): void;
-  recordSlotRenderEnded(slot: GptDiagnosticsSlotLike, facts: GptRenderFacts): void;
-  recordSlotOnload(slot: GptDiagnosticsSlotLike): void;
-  recordImpressionViewable(slot: GptDiagnosticsSlotLike): void;
-  recordSlotVisibilityChanged(slot: GptDiagnosticsSlotLike, percentage: number): void;
-  recordPublisherRefresh(slots: GptDiagnosticsSlotLike[]): void;
-}
-
-interface GptEvent {
-  slot: GptDiagnosticsSlotLike;
-}
-
-interface GptRenderEvent extends GptEvent {
-  isEmpty?: boolean;
-  size?: unknown;
-  isBackfill?: boolean;
-  slotContentChanged?: boolean;
-  lineItemId?: unknown;
-  creativeId?: unknown;
-  campaignId?: unknown;
-  advertiserId?: unknown;
-  sourceAgnosticLineItemId?: unknown;
-  sourceAgnosticCreativeId?: unknown;
-  yieldGroupIds?: unknown;
-  companyIds?: unknown;
-}
-
-interface GptVisibilityEvent extends GptEvent {
-  inViewPercentage: number;
-}
-
-type GptEventName =
-  | 'slotRequested'
-  | 'slotResponseReceived'
-  | 'slotRenderEnded'
-  | 'slotOnload'
-  | 'impressionViewable'
-  | 'slotVisibilityChanged';
-
-type GptEventListener = (event: GptEvent) => void;
-
-interface GptPubAdsService {
-  addEventListener(name: GptEventName, listener: GptEventListener): void;
-  refresh?: (...args: unknown[]) => unknown;
-  getSlots?: () => unknown;
-}
-
-interface GptCommandQueue {
-  push(...callbacks: Array<() => void>): number;
-}
-
-interface GoogletagLike {
-  cmd: GptCommandQueue;
-  pubads?: () => GptPubAdsService;
+export type GptDiagnosticsFact = GoogletagDiagnosticsFact | GptDiagnosticsOpportunityFact;
+
+function renderFacts(fact: Readonly<GoogletagDiagnosticsFact>): GptRenderFacts {
+  const adManager = fact.adManager;
+  return {
+    isEmpty: fact.isEmpty,
+    size: fact.size ? ([...fact.size] as Size) : undefined,
+    isBackfill: fact.isBackfill,
+    slotContentChanged: fact.slotContentChanged,
+    adManager: adManager
+      ? {
+          ...adManager,
+          yieldGroupIds: adManager.yieldGroupIds ? [...adManager.yieldGroupIds] : undefined,
+          companyIds: adManager.companyIds ? [...adManager.companyIds] : undefined,
+        }
+      : undefined,
+  };
 }
 
-export interface GptObserverWindow {
-  googletag?: GoogletagLike;
-  tsjs?: Pick<TsjsApi, 'adInitRefreshInProgress' | 'prebidRefreshDispatchInProgress'>;
+export interface GptDiagnosticsObserverStore {
+  markGptObserved(): void;
+  recordTrustedServerOpportunity(
+    slot: GptDiagnosticsSlotLike,
+    auctionSlotId: string,
+    opportunity: 'renderable_candidate' | 'unrenderable_candidate' | 'no_candidate',
+    trustedServerAuctionId?: string,
+    requestedSlotSizes?: ReadonlyArray<Size>
+  ): void;
+  recordSlotRequested(slot: GptDiagnosticsSlotLike, timestampMs?: number): void;
+  recordSlotResponseReceived(slot: GptDiagnosticsSlotLike, timestampMs?: number): void;
+  recordSlotRenderEnded(
+    slot: GptDiagnosticsSlotLike,
+    facts: GptRenderFacts,
+    timestampMs?: number
+  ): void;
+  recordSlotOnload(slot: GptDiagnosticsSlotLike, timestampMs?: number): void;
+  recordImpressionViewable(slot: GptDiagnosticsSlotLike, timestampMs?: number): void;
+  recordSlotVisibilityChanged(
+    slot: GptDiagnosticsSlotLike,
+    percentage: number,
+    timestampMs?: number
+  ): void;
 }
 
 interface ObserverLogger {
-  warn(...args: unknown[]): void;
+  warn(...args: unknown[]): unknown;
 }
 
 interface ObserverOptions {
-  window?: GptObserverWindow;
-  logger?: ObserverLogger;
-}
-
-function normalizeSize(value: unknown): Size | undefined {
-  if (
-    !Array.isArray(value) ||
-    value.length !== 2 ||
-    typeof value[0] !== 'number' ||
-    typeof value[1] !== 'number' ||
-    !Number.isFinite(value[0]) ||
-    !Number.isFinite(value[1])
-  ) {
-    return undefined;
-  }
-
-  return [value[0], value[1]];
-}
-
-const MAX_AD_MANAGER_ID_LIST = 8;
-const REFRESH_OBSERVER_INSTALLED = Symbol('gptDiagnosticsRefreshObserverInstalled');
-
-function normalizeAdManagerId(value: unknown): number | undefined {
-  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined;
-}
-
-function normalizeAdManagerIdList(value: unknown): number[] | undefined {
-  if (!Array.isArray(value)) return undefined;
-
-  const ids = value
-    .map(normalizeAdManagerId)
-    .filter((id): id is number => id !== undefined)
-    .slice(0, MAX_AD_MANAGER_ID_LIST);
-  return ids.length > 0 ? ids : undefined;
-}
-
-/**
- * Collects the Ad Manager identifiers `slotRenderEnded` exposes.
- *
- * GPT reports these only for reservation and backfill ads served by
- * PubAdsService, so an absent value is itself a fact about the render rather
- * than a gap in observation.
- */
-function normalizeAdManagerIdentity(
-  event: GptRenderEvent
-): GptDiagnosticsAdManagerIdentity | undefined {
-  const identity: GptDiagnosticsAdManagerIdentity = {
-    lineItemId: normalizeAdManagerId(event.lineItemId),
-    creativeId: normalizeAdManagerId(event.creativeId),
-    campaignId: normalizeAdManagerId(event.campaignId),
-    advertiserId: normalizeAdManagerId(event.advertiserId),
-    sourceAgnosticLineItemId: normalizeAdManagerId(event.sourceAgnosticLineItemId),
-    sourceAgnosticCreativeId: normalizeAdManagerId(event.sourceAgnosticCreativeId),
-    yieldGroupIds: normalizeAdManagerIdList(event.yieldGroupIds),
-    companyIds: normalizeAdManagerIdList(event.companyIds),
-  };
-
-  for (const key of Object.keys(identity) as Array<keyof GptDiagnosticsAdManagerIdentity>) {
-    if (identity[key] === undefined) delete identity[key];
-  }
-  return Object.keys(identity).length > 0 ? identity : undefined;
+  readonly logger?: ObserverLogger | undefined;
 }
 
-/** Installs documented GPT event listeners through `googletag.cmd`. */
+/** Consumes normalized facts from the sole GPT adapter without owning browser-global access. */
 export class GptDiagnosticsObserver {
   private readonly store: GptDiagnosticsObserverStore;
-  private readonly window: GptObserverWindow;
   private readonly logger: ObserverLogger;
-  private queued = false;
-  private installed = false;
+  private started = false;
+  private observed = false;
 
   constructor(store: GptDiagnosticsObserverStore, options: ObserverOptions = {}) {
     this.store = store;
-    this.window = options.window ?? (window as unknown as GptObserverWindow);
     this.logger = options.logger ?? log;
   }
 
-  install(): void {
-    if (this.queued || this.installed) return;
-    this.queued = true;
-
-    try {
-      const googletag = (this.window.googletag ??= { cmd: [] });
-      googletag.cmd ??= [];
-      googletag.cmd.push(() => this.installWhenReady(googletag));
-    } catch (error) {
-      this.queued = false;
-      this.logger.warn('gpt diagnostics: command queue installation failed', error);
-    }
+  start(): void {
+    if (this.started) return;
+    this.started = true;
   }
 
-  private installWhenReady(googletag: GoogletagLike): void {
-    if (this.installed) return;
-
-    try {
-      const pubads = googletag.pubads?.();
-      if (!pubads || typeof pubads.addEventListener !== 'function') {
-        this.logger.warn('gpt diagnostics: PubAdsService unavailable');
+  consume(fact: Readonly<GptDiagnosticsFact>): void {
+    this.start();
+    if (fact.kind === 'trustedServerOpportunity') {
+      this.handle(fact.kind, () =>
+        this.store.recordTrustedServerOpportunity(
+          fact.slot,
+          fact.auctionSlotId,
+          fact.opportunity,
+          fact.trustedServerAuctionId,
+          fact.requestedSlotSizes
+        )
+      );
+      return;
+    }
+    if (!this.observed) {
+      this.observed = true;
+      this.handle('observation', () => this.store.markGptObserved());
+    }
+    const slot = fact.slot as GptDiagnosticsSlotLike;
+    const observedAtMs =
+      typeof fact.observedAtMs === 'number' && Number.isFinite(fact.observedAtMs)
+        ? fact.observedAtMs
+        : undefined;
+    switch (fact.kind) {
+      case 'slotRequested':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordSlotRequested(slot)
+            : this.store.recordSlotRequested(slot, observedAtMs)
+        );
         return;
-      }
-
-      pubads.addEventListener('slotRequested', (event) => {
-        this.handle('slotRequested', () => this.store.recordSlotRequested(event.slot));
-      });
-      pubads.addEventListener('slotResponseReceived', (event) => {
-        this.handle('slotResponseReceived', () =>
-          this.store.recordSlotResponseReceived(event.slot)
+      case 'slotResponseReceived':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordSlotResponseReceived(slot)
+            : this.store.recordSlotResponseReceived(slot, observedAtMs)
+        );
+        return;
+      case 'slotRenderEnded':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordSlotRenderEnded(slot, renderFacts(fact))
+            : this.store.recordSlotRenderEnded(slot, renderFacts(fact), observedAtMs)
+        );
+        return;
+      case 'slotOnload':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordSlotOnload(slot)
+            : this.store.recordSlotOnload(slot, observedAtMs)
+        );
+        return;
+      case 'impressionViewable':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordImpressionViewable(slot)
+            : this.store.recordImpressionViewable(slot, observedAtMs)
+        );
+        return;
+      case 'slotVisibilityChanged':
+        this.handle(fact.kind, () =>
+          observedAtMs === undefined
+            ? this.store.recordSlotVisibilityChanged(
+                slot,
+                typeof fact.inViewPercentage === 'number' ? fact.inViewPercentage : Number.NaN
+              )
+            : this.store.recordSlotVisibilityChanged(
+                slot,
+                typeof fact.inViewPercentage === 'number' ? fact.inViewPercentage : Number.NaN,
+                observedAtMs
+              )
         );
-      });
-      pubads.addEventListener('slotRenderEnded', (event) => {
-        this.handle('slotRenderEnded', () => {
-          const renderEvent = event as GptRenderEvent;
-          this.store.recordSlotRenderEnded(renderEvent.slot, {
-            isEmpty: typeof renderEvent.isEmpty === 'boolean' ? renderEvent.isEmpty : undefined,
-            size: normalizeSize(renderEvent.size),
-            isBackfill:
-              typeof renderEvent.isBackfill === 'boolean' ? renderEvent.isBackfill : undefined,
-            slotContentChanged:
-              typeof renderEvent.slotContentChanged === 'boolean'
-                ? renderEvent.slotContentChanged
-                : undefined,
-            adManager: normalizeAdManagerIdentity(renderEvent),
-          });
-        });
-      });
-      pubads.addEventListener('slotOnload', (event) => {
-        this.handle('slotOnload', () => this.store.recordSlotOnload(event.slot));
-      });
-      pubads.addEventListener('impressionViewable', (event) => {
-        this.handle('impressionViewable', () => this.store.recordImpressionViewable(event.slot));
-      });
-      pubads.addEventListener('slotVisibilityChanged', (event) => {
-        this.handle('slotVisibilityChanged', () => {
-          const visibilityEvent = event as GptVisibilityEvent;
-          this.store.recordSlotVisibilityChanged(
-            visibilityEvent.slot,
-            visibilityEvent.inViewPercentage
-          );
-        });
-      });
-
-      try {
-        this.installRefreshObserver(pubads);
-      } catch (error) {
-        this.logger.warn('gpt diagnostics: refresh observer installation failed', error);
-      }
-
-      this.installed = true;
-      this.store.markGptObserved();
-    } catch (error) {
-      this.logger.warn('gpt diagnostics: listener installation failed', error);
     }
   }
 
-  private handle(kind: GptEventName, callback: () => void): void {
+  private handle(kind: GptDiagnosticsFact['kind'] | 'observation', callback: () => void): void {
     try {
       callback();
     } catch (error) {
-      this.logger.warn(`gpt diagnostics: ${kind} callback failed`, error);
-    }
-  }
-
-  private installRefreshObserver(pubads: GptPubAdsService): void {
-    if (
-      typeof pubads.refresh !== 'function' ||
-      (pubads as GptPubAdsService & { [REFRESH_OBSERVER_INSTALLED]?: boolean })[
-        REFRESH_OBSERVER_INSTALLED
-      ]
-    ) {
-      return;
-    }
-    const originalRefresh = pubads.refresh;
-    const { store, window: observerWindow } = this;
-    pubads.refresh = function (this: unknown, ...args: unknown[]): unknown {
       try {
-        if (
-          !(
-            observerWindow.tsjs?.adInitRefreshInProgress ||
-            observerWindow.tsjs?.prebidRefreshDispatchInProgress
-          )
-        ) {
-          // GPT treats a missing or null `slots` argument as "refresh every
-          // slot", and `refresh(null, opts)` is the documented way to pass
-          // options while doing so.
-          const rawSlots = args.length === 0 || args[0] == null ? pubads.getSlots?.() : args[0];
-          const slots = Array.isArray(rawSlots)
-            ? rawSlots.filter(
-                (slot): slot is GptDiagnosticsSlotLike => typeof slot === 'object' && slot !== null
-              )
-            : [];
-          if (slots.length > 0) store.recordPublisherRefresh(slots);
-        }
+        this.logger.warn(`gpt diagnostics: ${kind} callback failed`, error);
       } catch {
-        // Diagnostics must not affect the original refresh.
+        // Diagnostics logging cannot escape into adapter fact delivery.
       }
-      return Reflect.apply(originalRefresh, this, args);
-    };
-    (pubads as GptPubAdsService & { [REFRESH_OBSERVER_INSTALLED]?: boolean })[
-      REFRESH_OBSERVER_INSTALLED
-    ] = true;
+    }
   }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/overlay.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/overlay.ts
index 63c0b6fb3..9278ee1e7 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/overlay.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/overlay.ts
@@ -21,16 +21,16 @@ interface OverlayBindings {
 }
 
 type OverlayWindow = Window & {
-  MutationObserver?: typeof MutationObserver;
+  MutationObserver?: typeof MutationObserver | undefined;
 };
 
 interface OverlayOptions {
-  window?: OverlayWindow;
-  document?: Document;
-  scheduleFrame?: (callback: () => void) => void;
-  onExport?: () => void;
-  onShadowRoot?: (root: ShadowRoot) => void;
-  onBadgeLayerChange?: (layer: HTMLElement | undefined) => void;
+  window?: OverlayWindow | undefined;
+  document?: Document | undefined;
+  scheduleFrame?: ((callback: () => void) => () => void) | undefined;
+  onExport?: (() => void) | undefined;
+  onShadowRoot?: ((root: ShadowRoot) => void) | undefined;
+  onBadgeLayerChange?: ((layer: HTMLElement | undefined) => void) | undefined;
 }
 
 const PANEL_STYLES = `
@@ -156,6 +156,9 @@ function requestPathFact(cycle: GptDiagnosticsRequestCycle): string {
       return 'Request path: Unattributed';
     case undefined:
       return 'Request path: Unknown (not observed)';
+    default:
+      unhandledCase(cycle.requestPath);
+      return 'Request path: Unknown (not observed)';
   }
 }
 
@@ -169,6 +172,9 @@ function trustedServerOpportunityFact(cycle: GptDiagnosticsRequestCycle): string
       return 'Direct opportunity: No candidate';
     case undefined:
       return 'Direct opportunity: Unknown (not observed)';
+    default:
+      unhandledCase(cycle.trustedServerOpportunity);
+      return 'Direct opportunity: Unknown (not observed)';
   }
 }
 
@@ -333,15 +339,16 @@ export class GptDiagnosticsOverlay {
   private readonly bindings: OverlayBindings;
   private readonly window: OverlayWindow;
   private readonly document: Document;
-  private readonly scheduleFrame: (callback: () => void) => void;
+  private readonly scheduleFrame: (callback: () => void) => () => void;
   private readonly onExport: () => void;
-  private readonly onShadowRoot?: (root: ShadowRoot) => void;
-  private readonly onBadgeLayerChange?: (layer: HTMLElement | undefined) => void;
+  private readonly onShadowRoot: ((root: ShadowRoot) => void) | undefined;
+  private readonly onBadgeLayerChange: ((layer: HTMLElement | undefined) => void) | undefined;
   private readonly unsubscribeStore: () => void;
   private readonly unsubscribeBindings: () => void;
-  private host?: HTMLElement;
-  private panel?: HTMLElement;
+  private host: HTMLElement | undefined;
+  private panel: HTMLElement | undefined;
   private lifecycleObserver?: MutationObserver;
+  private readonly cancelScheduledFrames = new Set<() => void>();
   private visualReady = false;
   private mountWaitStarted = false;
   private renderScheduled = false;
@@ -385,6 +392,14 @@ export class GptDiagnosticsOverlay {
     if (this.destroyed) return;
     this.destroyed = true;
     this.dismissed = true;
+    for (const cancelFrame of [...this.cancelScheduledFrames]) {
+      this.cancelScheduledFrames.delete(cancelFrame);
+      try {
+        cancelFrame();
+      } catch {
+        // Continue releasing every independently owned overlay resource.
+      }
+    }
     this.unsubscribeStore();
     this.unsubscribeBindings();
     this.lifecycleObserver?.disconnect();
@@ -407,8 +422,8 @@ export class GptDiagnosticsOverlay {
 
     this.mountWaitStarted = true;
     this.document.removeEventListener('readystatechange', this.handleReadyStateChange);
-    this.scheduleFrame(() => {
-      this.scheduleFrame(() => {
+    this.scheduleOwnedFrame(() => {
+      this.scheduleOwnedFrame(() => {
         this.visualReady = true;
         if (!this.dismissed) this.mount();
       });
@@ -476,10 +491,14 @@ export class GptDiagnosticsOverlay {
         this.hostCollision = false;
       }
       this.remountScheduled = true;
-      this.scheduleFrame(() => {
+      if (
+        !this.scheduleOwnedFrame(() => {
+          this.remountScheduled = false;
+          this.mount();
+        })
+      ) {
         this.remountScheduled = false;
-        this.mount();
-      });
+      }
     });
     this.lifecycleObserver.observe(this.document.documentElement, {
       childList: true,
@@ -490,10 +509,50 @@ export class GptDiagnosticsOverlay {
   private scheduleRender(): void {
     if (this.destroyed || this.renderScheduled) return;
     this.renderScheduled = true;
-    this.scheduleFrame(() => {
+    if (
+      !this.scheduleOwnedFrame(() => {
+        this.renderScheduled = false;
+        this.render();
+      })
+    ) {
       this.renderScheduled = false;
-      this.render();
-    });
+    }
+  }
+
+  private scheduleOwnedFrame(callback: () => void): boolean {
+    if (this.destroyed) return false;
+    let active = true;
+    let cancelFrame: (() => void) | undefined;
+    let release: (() => void) | undefined;
+    const run = (): void => {
+      if (!active) return;
+      active = false;
+      if (release) this.cancelScheduledFrames.delete(release);
+      try {
+        cancelFrame?.();
+      } catch {
+        // A completed frame remains authoritative when scheduler cleanup fails.
+      }
+      if (!this.destroyed) callback();
+    };
+    try {
+      cancelFrame = this.scheduleFrame(run);
+      if (typeof cancelFrame !== 'function') {
+        throw new TypeError('Invalid overlay frame scheduler');
+      }
+      release = (): void => {
+        if (!active) return;
+        active = false;
+        cancelFrame?.();
+      };
+      if (active) this.cancelScheduledFrames.add(release);
+      else cancelFrame();
+      return true;
+    } catch {
+      active = false;
+      if (release) this.cancelScheduledFrames.delete(release);
+      return false;
+    }
   }
 
   private render(): void {
@@ -560,7 +619,7 @@ export class GptDiagnosticsOverlay {
 
     const summary = this.document.createElement('div');
     summary.className = 'tsgd-summary';
-    summary.textContent = `${snapshot.slots.length} slots · ${snapshot.callbackIssues.length} callback issues · ${snapshot.attributionIssues?.length ?? 0} attribution issues`;
+    summary.textContent = `${snapshot.slots.length} slots · ${snapshot.callbackIssues.length} callback issues · ${snapshot.attributionIssues.length} attribution issues`;
     const coverage = this.document.createElement('ul');
     coverage.className = 'tsgd-coverage';
     for (const [kind, counters] of Object.entries(snapshot.coverage)) {
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation.ts
new file mode 100644
index 000000000..fb461cdaf
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation.ts
@@ -0,0 +1,598 @@
+import { log } from '../../core/log';
+import type { GptDiagnosticsApi, GptDiagnosticsBinding, RenderTraceRecord } from '../../core/types';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import type {
+  RenderTracePresentationControls,
+  RenderTracePresentationFactory,
+  RenderTracePresentationSource,
+} from '../../core/trace';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import { realmOwnedDocument } from '../../shared/realm';
+
+import { GptDiagnosticsBadgeManager } from './badges';
+import { GptDiagnosticsBindingManager } from './binding';
+import type {
+  GptDiagnosticsPresentationControls,
+  GptDiagnosticsPresentationFactory,
+  GptDiagnosticsPresentationSource,
+} from './data_api';
+import { GptDiagnosticsOverlay } from './overlay';
+import { GptDiagnosticsSlotSizeObserver } from './slot_size_observer';
+
+type GptDiagnosticsWindow = Window & typeof globalThis;
+
+/** DOM id of the deferred diagnostics-owned render-trace panel. */
+export const TRACE_PANEL_ID = 'ts-render-trace-panel';
+
+/** CSS class of the deferred diagnostics-owned per-slot badge. */
+export const TRACE_BADGE_CLASS = 'ts-render-badge';
+
+type TracePanelStatus = 'ok' | 'hidden' | 'gam-only' | 'empty';
+
+const TRACE_STATUS_STYLE: Record<TracePanelStatus, { color: string; mark: string; label: string }> =
+  {
+    ok: { color: '#3fb950', mark: '✓', label: 'ok' },
+    hidden: { color: '#d29922', mark: '⚠', label: 'hidden' },
+    'gam-only': { color: '#58a6ff', mark: '◐', label: 'gam-only' },
+    empty: { color: '#f85149', mark: '✗', label: 'empty' },
+  };
+
+const RUNTIME_TRACE_ATTRIBUTES = [
+  'data-ts-slot-id',
+  'data-ts-render-path',
+  'data-ts-rendered',
+  'data-ts-auction-id',
+  'data-ts-bidder',
+  'data-ts-ad-id',
+  'data-ts-bid-id',
+  'data-ts-creative-id',
+  'data-ts-adm-hash',
+  'data-ts-served-from',
+  'data-ts-gam-empty',
+  'data-ts-injected',
+  'data-ts-visible',
+] as const;
+
+interface PresentedTraceSlot {
+  readonly element: HTMLElement;
+  readonly priorInlinePosition?: string;
+}
+
+interface RenderTracePresentationOptions {
+  readonly document: Document;
+  readonly exportRecord?: ((record: Readonly<RenderTraceRecord>) => void) | undefined;
+  readonly onError?: ((error: unknown) => void) | undefined;
+}
+
+interface TracePresentationCapability {
+  readonly attachPresentation: (factory: RenderTracePresentationFactory) => () => void;
+}
+
+function tracePanelStatus(record: Readonly<RenderTraceRecord>): TracePanelStatus {
+  if (!record.rendered || record.gamEmpty === true) return 'empty';
+  if (record.visible !== true) return 'hidden';
+  return record.injected === true ? 'ok' : 'gam-only';
+}
+
+function copiedTraceRecord(record: Readonly<RenderTraceRecord>): Readonly<RenderTraceRecord> {
+  return Object.freeze({ ...record });
+}
+
+/** Build the complete render-trace DOM/export subscriber owned by the deferred artifact. */
+export function createRenderTracePresentation(
+  source: RenderTracePresentationSource,
+  options: RenderTracePresentationOptions
+): RenderTracePresentationControls {
+  const targetDocument = options.document;
+  const presented = new Map<string, PresentedTraceSlot>();
+  const panelRecords = new Map<number, Readonly<RenderTraceRecord>>();
+  const panelRows = new Map<number, HTMLButtonElement>();
+  let panel: HTMLElement | undefined;
+  let panelHeading: HTMLElement | undefined;
+  let panelRowsHost: HTMLElement | undefined;
+  let unsubscribe: (() => void) | undefined;
+  let disposed = false;
+
+  const report = (error: unknown): void => {
+    try {
+      options.onError?.(error);
+    } catch {
+      // Deferred diagnostics reporting cannot affect trace data or ads.
+    }
+  };
+  const removeBadge = (element: HTMLElement): void => {
+    for (const badge of element.querySelectorAll(`:scope > .${TRACE_BADGE_CLASS}`)) {
+      badge.remove();
+    }
+  };
+  const clearElement = (presentedSlot: PresentedTraceSlot): void => {
+    const { element, priorInlinePosition } = presentedSlot;
+    for (const attribute of RUNTIME_TRACE_ATTRIBUTES) element.removeAttribute(attribute);
+    removeBadge(element);
+    if (priorInlinePosition !== undefined && element.style.position === 'relative') {
+      element.style.position = priorInlinePosition;
+    }
+  };
+  const createBadge = (
+    element: HTMLElement,
+    record: Readonly<RenderTraceRecord>
+  ): PresentedTraceSlot => {
+    let priorInlinePosition: string | undefined;
+    try {
+      const position = targetDocument.defaultView?.getComputedStyle(element).position;
+      if (position === 'static' || position === '') {
+        priorInlinePosition = element.style.position;
+        element.style.position = 'relative';
+      }
+    } catch {
+      // A badge remains noninteractive even if its containing block is hostile.
+    }
+    const style = TRACE_STATUS_STYLE[tracePanelStatus(record)];
+    const badge = targetDocument.createElement('div');
+    badge.className = TRACE_BADGE_CLASS;
+    badge.textContent =
+      `TS ${style.mark} #${record.seq}` +
+      `${record.bidder ? ` · ${record.bidder}` : ''}` +
+      `${style.label === 'ok' ? '' : ` · ${style.label}`}`;
+    badge.style.setProperty('position', 'absolute');
+    badge.style.setProperty('top', '4px');
+    badge.style.setProperty('left', '4px');
+    badge.style.setProperty('z-index', '2147483646');
+    badge.style.setProperty('pointer-events', 'none');
+    badge.style.setProperty('font', '10px/1.5 ui-monospace, Menlo, Consolas, monospace');
+    badge.style.setProperty('padding', '1px 5px');
+    badge.style.setProperty('color', '#fff');
+    badge.style.setProperty('background', style.color);
+    badge.style.setProperty('border-radius', '3px');
+    element.appendChild(badge);
+    return { element, ...(priorInlinePosition === undefined ? {} : { priorInlinePosition }) };
+  };
+  const exportRow = (record: Readonly<RenderTraceRecord>): void => {
+    const copied = copiedTraceRecord(record);
+    try {
+      if (options.exportRecord) {
+        options.exportRecord(copied);
+        return;
+      }
+      const clipboard = targetDocument.defaultView?.navigator.clipboard;
+      const write = clipboard?.writeText;
+      if (typeof write !== 'function') return;
+      const pending = Reflect.apply(write, clipboard, [JSON.stringify(copied, null, 2)]) as
+        Promise<void> | undefined;
+      void pending?.catch(report);
+    } catch (error) {
+      report(error);
+    }
+  };
+  const presentRecord = (record: Readonly<RenderTraceRecord>): void => {
+    const prior = presented.get(record.slotId);
+    const elementId = record.elementId ?? record.slotId;
+    const candidate = targetDocument.getElementById(elementId);
+    const ElementConstructor = targetDocument.defaultView?.HTMLElement;
+    const element =
+      typeof ElementConstructor === 'function' && candidate instanceof ElementConstructor
+        ? (candidate as HTMLElement)
+        : undefined;
+    if (prior && prior.element !== element) {
+      clearElement(prior);
+      presented.delete(record.slotId);
+    }
+    if (!element) return;
+    const retainedPosition = prior?.element === element ? prior.priorInlinePosition : undefined;
+    removeBadge(element);
+    const values: Readonly<Record<(typeof RUNTIME_TRACE_ATTRIBUTES)[number], string | undefined>> =
+      {
+        'data-ts-slot-id': record.slotId,
+        'data-ts-render-path': record.path,
+        'data-ts-rendered': String(record.rendered),
+        'data-ts-auction-id': record.auctionId,
+        'data-ts-bidder': record.bidder,
+        'data-ts-ad-id': record.adId,
+        'data-ts-bid-id': record.bidId,
+        'data-ts-creative-id': record.creativeId,
+        'data-ts-adm-hash': record.admHash,
+        'data-ts-served-from': record.servedFrom,
+        'data-ts-gam-empty': record.gamEmpty === undefined ? undefined : String(record.gamEmpty),
+        'data-ts-injected': record.injected === undefined ? undefined : String(record.injected),
+        'data-ts-visible': record.visible === undefined ? undefined : String(record.visible),
+      };
+    for (const attribute of RUNTIME_TRACE_ATTRIBUTES) {
+      const value = values[attribute];
+      if (value === undefined || value === '') element.removeAttribute(attribute);
+      else element.setAttribute(attribute, value);
+    }
+    const status = tracePanelStatus(record);
+    if (element.tagName !== 'IFRAME' && (status === 'ok' || status === 'gam-only')) {
+      const next = createBadge(element, record);
+      presented.set(record.slotId, {
+        element,
+        ...(retainedPosition === undefined
+          ? next.priorInlinePosition === undefined
+            ? {}
+            : { priorInlinePosition: next.priorInlinePosition }
+          : { priorInlinePosition: retainedPosition }),
+      });
+    } else {
+      if (retainedPosition !== undefined && element.style.position === 'relative') {
+        element.style.position = retainedPosition;
+      }
+      presented.set(record.slotId, { element });
+    }
+  };
+  const ensurePanel = (): boolean => {
+    if (!targetDocument.body) return false;
+    if (panel) return true;
+    if (targetDocument.getElementById(TRACE_PANEL_ID)) return false;
+    panel = targetDocument.createElement('div');
+    panel.id = TRACE_PANEL_ID;
+    panel.setAttribute('data-ts-render-trace-owner', '1');
+    panel.style.setProperty('position', 'fixed');
+    panel.style.setProperty('bottom', '12px');
+    panel.style.setProperty('right', '12px');
+    panel.style.setProperty('z-index', '2147483647');
+    panel.style.setProperty('max-width', '360px');
+    panel.style.setProperty('max-height', '45vh');
+    panel.style.setProperty('overflow', 'auto');
+    panel.style.setProperty('background', 'rgba(17,17,17,0.94)');
+    panel.style.setProperty('color', '#eee');
+    panel.style.setProperty('font', '11px/1.5 ui-monospace, Menlo, Consolas, monospace');
+    panel.style.setProperty('border', '1px solid #333');
+    panel.style.setProperty('border-radius', '6px');
+    panel.style.setProperty('box-shadow', '0 4px 16px rgba(0,0,0,0.4)');
+    panelHeading = targetDocument.createElement('div');
+    panelHeading.style.setProperty('padding', '6px 10px');
+    panelHeading.style.setProperty('font-weight', '700');
+    panelRowsHost = targetDocument.createElement('div');
+    panel.append(panelHeading, panelRowsHost);
+    targetDocument.body.appendChild(panel);
+    return true;
+  };
+  const renderPanel = (history: readonly Readonly<RenderTraceRecord>[]): void => {
+    if (!ensurePanel()) return;
+    panelHeading!.textContent = `TS Render Trace · ${history.length} renders`;
+    const retainedSequences = new Set(history.map(({ seq }) => seq));
+    for (const [sequence, row] of panelRows) {
+      if (retainedSequences.has(sequence)) continue;
+      row.remove();
+      panelRows.delete(sequence);
+      panelRecords.delete(sequence);
+    }
+    for (const record of history) {
+      panelRecords.set(record.seq, record);
+      let row = panelRows.get(record.seq);
+      if (!row) {
+        row = targetDocument.createElement('button');
+        row.type = 'button';
+        row.setAttribute('data-ts-trace-seq', String(record.seq));
+        row.style.setProperty('display', 'block');
+        row.style.setProperty('width', '100%');
+        row.style.setProperty('padding', '6px 10px');
+        row.style.setProperty('border', '0');
+        row.style.setProperty('border-top', '1px solid #2a2a2a');
+        row.style.setProperty('background', 'transparent');
+        row.style.setProperty('font', 'inherit');
+        row.style.setProperty('text-align', 'left');
+        row.style.setProperty('cursor', 'pointer');
+        const sequence = record.seq;
+        row.addEventListener('click', () => {
+          const exported = panelRecords.get(sequence);
+          if (exported) exportRow(exported);
+        });
+        panelRows.set(record.seq, row);
+        panelRowsHost!.prepend(row);
+      }
+      const style = TRACE_STATUS_STYLE[tracePanelStatus(record)];
+      row.textContent = `#${record.seq} ${style.mark} ${record.slotId} · ${style.label} · ${record.path}`;
+      row.style.setProperty('border-left', `3px solid ${style.color}`);
+      row.style.setProperty('color', style.color);
+    }
+  };
+  const refresh = (): void => {
+    if (disposed) return;
+    try {
+      const current = source.current();
+      const history = source.history();
+      const currentIds = new Set(Object.keys(current));
+      for (const [slotId, existing] of presented) {
+        if (currentIds.has(slotId)) continue;
+        clearElement(existing);
+        presented.delete(slotId);
+      }
+      for (const record of Object.values(current)) presentRecord(record);
+      renderPanel(history);
+    } catch (error) {
+      report(error);
+    }
+  };
+  const cleanup = (): void => {
+    if (disposed) return;
+    disposed = true;
+    isolate(() => unsubscribe?.());
+    unsubscribe = undefined;
+    for (const presentedSlot of presented.values()) isolate(() => clearElement(presentedSlot));
+    presented.clear();
+    isolate(() => panel?.remove());
+    panel = undefined;
+    panelHeading = undefined;
+    panelRowsHost = undefined;
+    panelRecords.clear();
+    panelRows.clear();
+  };
+
+  try {
+    unsubscribe = source.subscribe(refresh);
+    if (typeof unsubscribe !== 'function') {
+      throw new TypeError('render trace presentation disposer is unavailable');
+    }
+    refresh();
+    return Object.freeze({ dispose: cleanup });
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+
+interface GptDiagnosticsDataCapability {
+  readonly api: GptDiagnosticsApi;
+  readonly attachPresentation: (factory: GptDiagnosticsPresentationFactory) => () => void;
+}
+
+function isolate(callback: () => void): void {
+  try {
+    callback();
+  } catch {
+    // Diagnostics cleanup cannot retain another independently owned resource.
+  }
+}
+
+function dataCapability(
+  interfaces: Readonly<Record<string, unknown>>
+): GptDiagnosticsDataCapability | undefined {
+  try {
+    const candidate = interfaces['gpt_diag.v1'];
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      !Object.isFrozen(candidate) ||
+      Reflect.ownKeys(candidate).sort().join(',') !== 'api,attachPresentation'
+    ) {
+      return undefined;
+    }
+    const fields = candidate as Readonly<Record<string, unknown>>;
+    return typeof fields['attachPresentation'] === 'function' &&
+      typeof fields['api'] === 'object' &&
+      fields['api'] !== null &&
+      Object.isFrozen(fields['api'])
+      ? (candidate as GptDiagnosticsDataCapability)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function renderTraceCapability(
+  interfaces: Readonly<Record<string, unknown>>
+): TracePresentationCapability | undefined {
+  try {
+    const capability = Object.getOwnPropertyDescriptor(interfaces, 'trace.presentation.v1');
+    if (!capability || !('value' in capability)) return undefined;
+    const candidate = capability.value;
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      !Object.isFrozen(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      Reflect.ownKeys(candidate).length !== 1
+    ) {
+      return undefined;
+    }
+    const attach = Object.getOwnPropertyDescriptor(candidate, 'attachPresentation');
+    return attach?.enumerable && 'value' in attach && typeof attach.value === 'function'
+      ? (candidate as TracePresentationCapability)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function diagnosticsSelection(runtime: Readonly<Record<string, unknown>>):
+  | Readonly<{
+      gptActive: boolean;
+      renderTraceOverlay: boolean;
+    }>
+  | undefined {
+  try {
+    const bootDescriptor = Object.getOwnPropertyDescriptor(runtime, 'boot');
+    if (
+      !bootDescriptor ||
+      !('value' in bootDescriptor) ||
+      typeof bootDescriptor.value !== 'function'
+    ) {
+      return undefined;
+    }
+    const boot = Reflect.apply(bootDescriptor.value, runtime, []);
+    if (typeof boot !== 'object' || boot === null || !Object.isFrozen(boot)) return undefined;
+    const diagnosticsDescriptor = Object.getOwnPropertyDescriptor(boot, 'diagnostics');
+    if (!diagnosticsDescriptor || !('value' in diagnosticsDescriptor)) return undefined;
+    const diagnostics = diagnosticsDescriptor.value;
+    if (
+      typeof diagnostics !== 'object' ||
+      diagnostics === null ||
+      !Object.isFrozen(diagnostics) ||
+      Reflect.ownKeys(diagnostics).sort().join(',') !== 'gpt,renderTraceOverlay,version'
+    ) {
+      return undefined;
+    }
+    const fields = diagnostics as Readonly<Record<string, unknown>>;
+    const gpt = fields['gpt'];
+    if (
+      fields['version'] !== 1 ||
+      typeof fields['renderTraceOverlay'] !== 'boolean' ||
+      typeof gpt !== 'object' ||
+      gpt === null ||
+      !Object.isFrozen(gpt) ||
+      Reflect.ownKeys(gpt).join(',') !== 'active' ||
+      typeof (gpt as Readonly<Record<string, unknown>>)['active'] !== 'boolean'
+    ) {
+      return undefined;
+    }
+    return Object.freeze({
+      gptActive: (gpt as Readonly<Record<string, unknown>>)['active'] as boolean,
+      renderTraceOverlay: fields['renderTraceOverlay'] as boolean,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function downloadSnapshot(
+  api: GptDiagnosticsApi,
+  targetWindow: GptDiagnosticsWindow,
+  targetDocument: Document
+): void {
+  const snapshot = api.snapshot();
+  const objectUrl = targetWindow.URL.createObjectURL(
+    new targetWindow.Blob([JSON.stringify(snapshot, null, 2)], { type: 'application/json' })
+  );
+  const anchor = targetDocument.createElement('a');
+  anchor.href = objectUrl;
+  anchor.download = `trusted-server-gpt-diagnostics-${snapshot.capturedAt.replace(/[:.]/g, '-')}.json`;
+  anchor.hidden = true;
+  targetDocument.body?.append(anchor);
+  try {
+    anchor.click();
+  } finally {
+    anchor.remove();
+    targetWindow.URL.revokeObjectURL(objectUrl);
+  }
+}
+
+function createPresentationControls(
+  source: GptDiagnosticsPresentationSource,
+  api: GptDiagnosticsApi,
+  targetWindow: GptDiagnosticsWindow,
+  targetDocument: Document
+): GptDiagnosticsPresentationControls {
+  const bindings = new GptDiagnosticsBindingManager(source, {
+    window: targetWindow,
+    document: targetDocument,
+  });
+  let badges: GptDiagnosticsBadgeManager | undefined;
+  let overlay: GptDiagnosticsOverlay | undefined;
+  let slotSizeObserver: GptDiagnosticsSlotSizeObserver | undefined;
+  const cleanup = (): void => {
+    isolate(() => overlay?.destroy());
+    isolate(() => badges?.destroy());
+    isolate(() => slotSizeObserver?.destroy());
+    isolate(() => bindings.destroy());
+  };
+  try {
+    badges = new GptDiagnosticsBadgeManager(source, bindings, {
+      window: targetWindow,
+      document: targetDocument,
+    });
+    slotSizeObserver = new GptDiagnosticsSlotSizeObserver(source, bindings, {
+      window: targetWindow,
+    });
+    overlay = new GptDiagnosticsOverlay(source, bindings, {
+      window: targetWindow,
+      document: targetDocument,
+      onExport: () => api.export(),
+      onBadgeLayerChange: (layer) => badges?.setLayer(layer),
+    });
+    const controls = Object.freeze({
+      dispose: cleanup,
+      download: () => downloadSnapshot(api, targetWindow, targetDocument),
+      exportBinding: (runtimeSlotNumber: number): GptDiagnosticsBinding =>
+        bindings.exportBinding(runtimeSlotNumber),
+      hide: () => overlay?.hide(),
+      show: () => overlay?.show(),
+      subscribe: (listener: () => void) => bindings.subscribe(listener),
+    });
+    return controls;
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+
+/** Build the deferred diagnostics presentation registration. */
+export function createDiagnosticsPresentationIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'diagnostics_presentation',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const runtime = interfaces['runtime.v1'] as Readonly<Record<string, unknown>> | undefined;
+      const targetDocument = realmOwnedDocument(runtime?.['document']);
+      const targetWindow = targetDocument?.defaultView;
+      const trace = runtime ? renderTraceCapability(interfaces) : undefined;
+      const selection = runtime ? diagnosticsSelection(runtime) : undefined;
+      if (
+        config !== undefined ||
+        !runtime ||
+        !Object.isFrozen(runtime) ||
+        !targetDocument ||
+        !targetWindow ||
+        !trace ||
+        !selection
+      ) {
+        throw new TypeError('diagnostics presentation capability graph is malformed');
+      }
+      const data = dataCapability(interfaces);
+      if (
+        selection.gptActive !== Boolean(data) ||
+        (!selection.renderTraceOverlay && !selection.gptActive)
+      ) {
+        throw new TypeError('diagnostics presentation activation graph is malformed');
+      }
+      return Object.freeze({
+        activate: ({ onDispose }: IntegrationActivationContext) => {
+          const traceOwnership: { release?: () => void } = {};
+          const gptOwnership: { release?: () => void } = {};
+          onDispose(() => isolate(() => traceOwnership.release?.()));
+          onDispose(() => isolate(() => gptOwnership.release?.()));
+          if (selection.renderTraceOverlay) {
+            const release = trace.attachPresentation((source) =>
+              createRenderTracePresentation(source, {
+                document: targetDocument,
+                onError: (error) => log.warn('render trace presentation failed', error),
+              })
+            );
+            if (typeof release !== 'function') {
+              throw new TypeError('render trace presentation disposer is unavailable');
+            }
+            traceOwnership.release = release;
+          }
+          if (data) {
+            const release = data.attachPresentation((source, api) =>
+              createPresentationControls(source, api, targetWindow, targetDocument)
+            );
+            if (typeof release !== 'function') {
+              throw new TypeError('GPT diagnostics presentation disposer is unavailable');
+            }
+            gptOwnership.release = release;
+          }
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createDiagnosticsPresentationIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation_helpers.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation_helpers.ts
index b601833b8..bf35543c0 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation_helpers.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/presentation_helpers.ts
@@ -7,12 +7,27 @@ export function formatSizes(sizes: ReadonlyArray<Size>): string {
 
 /** Schedules presentation work in the target window's next animation frame. */
 export function scheduleFrame(
-  window: Pick<Window, 'requestAnimationFrame'>,
+  window: Pick<Window, 'requestAnimationFrame' | 'cancelAnimationFrame'>,
   callback: () => void
-): void {
+): () => void {
   if (typeof window.requestAnimationFrame === 'function') {
-    window.requestAnimationFrame(() => callback());
-  } else {
-    queueMicrotask(callback);
+    let active = true;
+    const frame = window.requestAnimationFrame(() => {
+      if (active) callback();
+    });
+    return () => {
+      active = false;
+      if (typeof window.cancelAnimationFrame === 'function') {
+        window.cancelAnimationFrame(frame);
+      }
+    };
   }
+
+  let active = true;
+  queueMicrotask(() => {
+    if (active) callback();
+  });
+  return () => {
+    active = false;
+  };
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/slot_size_observer.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/slot_size_observer.ts
index c3328f992..82ec68b9d 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/slot_size_observer.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/slot_size_observer.ts
@@ -1,4 +1,5 @@
 import type { Size } from '../../core/types';
+import { realmOwnedHtmlElement } from '../../shared/realm';
 
 import type { GptDiagnosticsBindingManager } from './binding';
 import { scheduleFrame } from './presentation_helpers';
@@ -96,8 +97,8 @@ export class GptDiagnosticsSlotSizeObserver {
     if (typeof ResizeObserverConstructor === 'function') {
       this.resizeObserver = new ResizeObserverConstructor((entries) => {
         for (const entry of entries) {
-          const element = entry.target;
-          if (!(element instanceof this.window.HTMLElement)) continue;
+          const element = realmOwnedHtmlElement(entry.target, this.window);
+          if (!element) continue;
           const cycle = observations.get(element);
           if (cycle) this.scheduleMeasure(element, cycle);
         }
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/store.ts b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/store.ts
index ca3348ae9..4204c6a3c 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/store.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/store.ts
@@ -12,7 +12,6 @@ import type {
   GptDiagnosticsRequestCycle,
   GptDiagnosticsRequestPath,
   GptDiagnosticsResponseClass,
-  GptDiagnosticsSlotHandle,
   GptDiagnosticsTrustedServerOpportunity,
   Size,
 } from '../../core/types';
@@ -41,32 +40,35 @@ const CALLBACK_KINDS: GptDiagnosticsCallbackKind[] = [
   'slotVisibilityChanged',
 ];
 
-/**
- * The GPT slot shape diagnostics reads. Aliased to the exported handle type so
- * the writer signatures and the store implementation cannot drift apart.
- */
-export type GptDiagnosticsSlotLike = GptDiagnosticsSlotHandle;
+export interface GptDiagnosticsSlotLike {
+  readonly token?: object | undefined;
+  readonly runtimeSlotNumber?: number | undefined;
+  readonly elementId?: string | undefined;
+  readonly adUnitPath?: string | undefined;
+  getSlotElementId?: (() => string) | undefined;
+  getAdUnitPath?: (() => string) | undefined;
+}
 
 export interface GptRenderFacts {
-  isEmpty?: boolean;
-  size?: Size;
-  isBackfill?: boolean;
-  slotContentChanged?: boolean;
-  adManager?: GptDiagnosticsAdManagerIdentity;
+  isEmpty?: boolean | undefined;
+  size?: Size | undefined;
+  isBackfill?: boolean | undefined;
+  slotContentChanged?: boolean | undefined;
+  adManager?: GptDiagnosticsAdManagerIdentity | undefined;
 }
 
 export interface GptDiagnosticsStoreSlotSnapshot {
   runtimeSlotNumber: number;
-  slotElementId?: string;
-  adUnitPath?: string;
-  currentVisibilityPercentage?: number;
-  maximumVisibilityPercentage?: number;
+  slotElementId?: string | undefined;
+  adUnitPath?: string | undefined;
+  currentVisibilityPercentage?: number | undefined;
+  maximumVisibilityPercentage?: number | undefined;
   requests: GptDiagnosticsRequestCycle[];
 }
 
 export interface GptDiagnosticsBindingInput {
   runtimeSlotNumber: number;
-  slotElementId?: string;
+  slotElementId?: string | undefined;
 }
 
 export interface GptDiagnosticsStoreSnapshot {
@@ -87,27 +89,27 @@ type MutableRequestCycle = GptDiagnosticsRequestCycle;
 
 interface MutableSlotRecord {
   runtimeSlotNumber: number;
-  slotElementId?: string;
-  adUnitPath?: string;
-  currentVisibilityPercentage?: number;
-  maximumVisibilityPercentage?: number;
+  slotElementId?: string | undefined;
+  adUnitPath?: string | undefined;
+  currentVisibilityPercentage?: number | undefined;
+  maximumVisibilityPercentage?: number | undefined;
   requests: MutableRequestCycle[];
 }
 
 interface StoreOptions {
-  now?: () => number;
-  schedule?: (callback: () => void) => void;
+  now?: (() => number) | undefined;
+  schedule?: ((callback: () => void) => void) | undefined;
   /** Deferred marker cleanup and diagnostic-window re-notification. */
-  defer?: (callback: () => void, delayMs: number) => void;
+  defer?: ((callback: () => void, delayMs: number) => void) | undefined;
 }
 
 type RequestIntentSource = 'trusted_server_direct' | 'prebid_refresh' | 'publisher_refresh';
 
 interface PendingSourceEvidence {
   observedAtMs: number;
-  trustedServerOpportunity?: GptDiagnosticsTrustedServerOpportunity;
-  trustedServerAuctionId?: string;
-  requestedSlotSizes?: ReadonlyArray<Size>;
+  trustedServerOpportunity?: GptDiagnosticsTrustedServerOpportunity | undefined;
+  trustedServerAuctionId?: string | undefined;
+  requestedSlotSizes?: ReadonlyArray<Size> | undefined;
 }
 
 interface PendingRequestIntent {
@@ -119,16 +121,19 @@ type AttemptStatus = 'live' | 'completed' | 'expired' | 'evicted';
 
 interface CreativeAttemptRecord {
   id: number;
-  cycle?: MutableRequestCycle;
-  runtimeSlotNumber?: number;
-  slotElementId?: string;
+  cycle?: MutableRequestCycle | undefined;
+  runtimeSlotNumber?: number | undefined;
+  slotElementId?: string | undefined;
   requestedAtMs: number;
   expiresAtMs: number;
   provisionalBeforeRender: boolean;
   status: AttemptStatus;
 }
 
-type AttributionIdentity = Partial<Pick<MutableSlotRecord, 'runtimeSlotNumber' | 'slotElementId'>>;
+interface AttributionIdentity {
+  readonly runtimeSlotNumber?: number | undefined;
+  readonly slotElementId?: string | undefined;
+}
 
 type StoreListener = () => void;
 
@@ -217,10 +222,12 @@ function normalizedRequestedSlotSizes(value: unknown): ReadonlyArray<Size> | und
       candidate.length !== 2 ||
       typeof candidate[0] !== 'number' ||
       typeof candidate[1] !== 'number' ||
-      !Number.isFinite(candidate[0]) ||
-      !Number.isFinite(candidate[1]) ||
-      candidate[0] <= 0 ||
-      candidate[1] <= 0
+      !Number.isInteger(candidate[0]) ||
+      !Number.isInteger(candidate[1]) ||
+      candidate[0] < 1 ||
+      candidate[0] > 4_096 ||
+      candidate[1] < 1 ||
+      candidate[1] > 4_096
     ) {
       continue;
     }
@@ -308,6 +315,7 @@ export class GptDiagnosticsStore {
   private readonly slots = new Map<number, MutableSlotRecord>();
   private readonly slotOrder: number[] = [];
   private readonly slotActivityOrder: number[] = [];
+  private readonly commitListeners = new Set<StoreListener>();
   private readonly listeners = new Set<StoreListener>();
   private readonly coverage = emptyCoverage();
   private readonly callbackIssues: GptDiagnosticsCallbackIssue[] = [];
@@ -348,6 +356,7 @@ export class GptDiagnosticsStore {
       return;
     }
 
+    const identity = slot.token ?? slot;
     this.trustedServerSlots.delete(auctionSlotId);
     this.trustedServerSlots.set(auctionSlotId, slot);
     while (this.trustedServerSlots.size > MAX_TRUSTED_SERVER_ASSOCIATIONS) {
@@ -356,7 +365,7 @@ export class GptDiagnosticsStore {
       this.trustedServerSlots.delete(oldest);
     }
 
-    this.recordRequestIntentSource(slot, 'trusted_server_direct', {
+    this.recordRequestIntentSource(identity, 'trusted_server_direct', {
       trustedServerOpportunity: opportunity,
       trustedServerAuctionId: normalizedAuctionId(trustedServerAuctionId),
       requestedSlotSizes: normalizedRequestedSlotSizes(requestedSlotSizes),
@@ -399,7 +408,7 @@ export class GptDiagnosticsStore {
     }
 
     const identity = this.attributionIdentity(slot);
-    const runtimeSlotNumber = this.slotNumbers.get(slot);
+    const runtimeSlotNumber = this.slotNumbers.get(slot.token ?? slot);
     const record = runtimeSlotNumber === undefined ? undefined : this.slots.get(runtimeSlotNumber);
     if (!record || record.requests.length === 0) {
       this.reportAttributionIssue('creative_request_without_cycle', timestampMs, identity);
@@ -577,8 +586,13 @@ export class GptDiagnosticsStore {
     return () => this.listeners.delete(listener);
   }
 
-  recordSlotRequested(slot: GptDiagnosticsSlotLike): void {
-    const timestampMs = this.timestamp();
+  subscribeCommits(listener: StoreListener): () => void {
+    this.commitListeners.add(listener);
+    return () => this.commitListeners.delete(listener);
+  }
+
+  recordSlotRequested(slot: GptDiagnosticsSlotLike, observedAtMs?: number): void {
+    const timestampMs = this.timestamp(observedAtMs);
     const record = this.prepareCallback('slotRequested', slot, timestampMs);
     if (!record) return;
 
@@ -589,9 +603,10 @@ export class GptDiagnosticsStore {
       this.metadata.evictedRequestCycles += 1;
     }
 
-    const requestNumber = (this.requestNumbers.get(slot) ?? 0) + 1;
-    this.requestNumbers.set(slot, requestNumber);
-    const intent = this.consumeRequestIntent(slot, timestampMs);
+    const identity = slot.token ?? slot;
+    const requestNumber = (this.requestNumbers.get(identity) ?? 0) + 1;
+    this.requestNumbers.set(identity, requestNumber);
+    const intent = this.consumeRequestIntent(identity, timestampMs);
     const trustedServerEvidence = intent?.sources.get('trusted_server_direct');
     const requestPath = this.requestPath(intent);
     record.requests.push({
@@ -620,8 +635,8 @@ export class GptDiagnosticsStore {
     this.notify();
   }
 
-  recordSlotResponseReceived(slot: GptDiagnosticsSlotLike): void {
-    const timestampMs = this.timestamp();
+  recordSlotResponseReceived(slot: GptDiagnosticsSlotLike, observedAtMs?: number): void {
+    const timestampMs = this.timestamp(observedAtMs);
     this.matchCycle(
       'slotResponseReceived',
       slot,
@@ -646,8 +661,12 @@ export class GptDiagnosticsStore {
     );
   }
 
-  recordSlotRenderEnded(slot: GptDiagnosticsSlotLike, facts: GptRenderFacts): void {
-    const timestampMs = this.timestamp();
+  recordSlotRenderEnded(
+    slot: GptDiagnosticsSlotLike,
+    facts: GptRenderFacts,
+    observedAtMs?: number
+  ): void {
+    const timestampMs = this.timestamp(observedAtMs);
     this.matchCycle(
       'slotRenderEnded',
       slot,
@@ -700,8 +719,8 @@ export class GptDiagnosticsStore {
 
   /**
    * Retain an outer CSS box only when this exact slot and request cycle still
-   * identify a filled render. Async DOM measurements use this guard so a prior
-   * render cannot alter a later refresh cycle.
+   * identify the latest filled render. Async DOM measurements use this guard so
+   * a prior render cannot alter a later refresh cycle.
    */
   recordObservedSlotSize(runtimeSlotNumber: number, requestNumber: number, size: Size): void {
     if (
@@ -720,6 +739,7 @@ export class GptDiagnosticsStore {
 
     const cycle = record.requests.find((candidate) => candidate.requestNumber === requestNumber);
     if (
+      !record ||
       !cycle ||
       record.requests[record.requests.length - 1] !== cycle ||
       cycle.isEmpty !== false ||
@@ -739,13 +759,14 @@ export class GptDiagnosticsStore {
     this.notify();
   }
 
-  recordSlotOnload(slot: GptDiagnosticsSlotLike): void {
-    const timestampMs = this.timestamp();
+  recordSlotOnload(slot: GptDiagnosticsSlotLike, observedAtMs?: number): void {
+    const timestampMs = this.timestamp(observedAtMs);
     this.matchCycle(
       'slotOnload',
       slot,
       timestampMs,
-      (cycle) => cycle.responseAtMs !== undefined && cycle.loadAtMs === undefined,
+      (cycle) =>
+        cycle.responseAtMs !== undefined && cycle.isEmpty !== true && cycle.loadAtMs === undefined,
       (record, cycle) => {
         cycle.loadAtMs = timestampMs;
         if (cycle.renderAtMs === undefined) {
@@ -758,8 +779,8 @@ export class GptDiagnosticsStore {
     );
   }
 
-  recordImpressionViewable(slot: GptDiagnosticsSlotLike): void {
-    const timestampMs = this.timestamp();
+  recordImpressionViewable(slot: GptDiagnosticsSlotLike, observedAtMs?: number): void {
+    const timestampMs = this.timestamp(observedAtMs);
     this.matchCycle(
       'impressionViewable',
       slot,
@@ -784,8 +805,12 @@ export class GptDiagnosticsStore {
     );
   }
 
-  recordSlotVisibilityChanged(slot: GptDiagnosticsSlotLike, percentage: number): void {
-    const timestampMs = this.timestamp();
+  recordSlotVisibilityChanged(
+    slot: GptDiagnosticsSlotLike,
+    percentage: number,
+    observedAtMs?: number
+  ): void {
+    const timestampMs = this.timestamp(observedAtMs);
     const record = this.prepareCallback('slotVisibilityChanged', slot, timestampMs);
     if (!record) return;
 
@@ -853,10 +878,14 @@ export class GptDiagnosticsStore {
   }
 
   private attributionIdentity(slot: GptDiagnosticsSlotLike & object): AttributionIdentity {
-    const runtimeSlotNumber = this.slotNumbers.get(slot);
+    const identity = slot.token ?? slot;
+    const runtimeSlotNumber = this.slotNumbers.get(identity);
     const record = runtimeSlotNumber === undefined ? undefined : this.slots.get(runtimeSlotNumber);
     const slotElementId =
       record?.slotElementId ??
+      (typeof slot.elementId === 'string' && slot.elementId.length > 0
+        ? slot.elementId
+        : undefined) ??
       optionalNonEmptyString(
         typeof slot.getSlotElementId === 'function' ? slot.getSlotElementId.bind(slot) : undefined
       );
@@ -923,14 +952,7 @@ export class GptDiagnosticsStore {
     return false;
   }
 
-  /**
-   * Record one source's evidence for the slot's next GPT request.
-   *
-   * Evidence expires lazily — on the next recording for the same slot and on
-   * consumption — so retained intents never own a timer. Pending intents are
-   * keyed weakly by GPT slot object, which bounds them by the slots the page
-   * itself still holds.
-   */
+  /** Record one source's evidence for the slot's next GPT request. */
   private recordRequestIntentSource(
     slot: object,
     source: RequestIntentSource,
@@ -943,8 +965,6 @@ export class GptDiagnosticsStore {
     let intent = this.pendingRequestIntents.get(slot);
     if (intent) {
       this.expireRequestIntentSources(intent, observedAtMs);
-      // A fully expired intent is replaced rather than revived, so its intent
-      // ID cannot outlive the observation window it was issued for.
       if (intent.sources.size === 0) intent = undefined;
     }
     if (!intent) {
@@ -974,14 +994,7 @@ export class GptDiagnosticsStore {
     return intent.sources.size > 0 ? intent : undefined;
   }
 
-  /**
-   * Keep at most one outstanding timer for the delivery-evidence boundary.
-   *
-   * Each candidate render flips from `pending` to `candidate_unconfirmed` once
-   * its window elapses, and subscribers need one notification per boundary. A
-   * single timer that re-arms from retained cycles bounds the timer queue by
-   * retained state instead of by refresh rate.
-   */
+  /** Keep at most one outstanding delivery-evidence boundary timer. */
   private scheduleDeliveryBoundaryNotification(
     delayMs: number = TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS
   ): void {
@@ -1045,9 +1058,11 @@ export class GptDiagnosticsStore {
     }
   }
 
-  private timestamp(): number {
+  private timestamp(observedAtMs?: number): number {
     this.gptObserved = true;
-    return this.now();
+    return typeof observedAtMs === 'number' && Number.isFinite(observedAtMs)
+      ? observedAtMs
+      : this.now();
   }
 
   private prepareCallback(
@@ -1056,7 +1071,8 @@ export class GptDiagnosticsStore {
     timestampMs: number
   ): MutableSlotRecord | undefined {
     this.coverage[kind].observed += 1;
-    const existingNumber = this.slotNumbers.get(slot);
+    const identity = slot.token ?? slot;
+    const existingNumber = this.slotNumbers.get(identity);
     if (existingNumber !== undefined) {
       const existingRecord = this.slots.get(existingNumber);
       if (existingRecord) {
@@ -1093,13 +1109,32 @@ export class GptDiagnosticsStore {
       }
     }
 
-    const runtimeSlotNumber = this.nextRuntimeSlotNumber;
-    this.nextRuntimeSlotNumber += 1;
+    const adoptedRuntimeSlotNumber = slot.runtimeSlotNumber;
+    if (
+      adoptedRuntimeSlotNumber !== undefined &&
+      (!Number.isInteger(adoptedRuntimeSlotNumber) ||
+        adoptedRuntimeSlotNumber < this.nextRuntimeSlotNumber ||
+        adoptedRuntimeSlotNumber > 4_294_967_295 ||
+        this.slots.has(adoptedRuntimeSlotNumber))
+    ) {
+      this.incrementDisposition(kind, 'unmatched');
+      this.addIssue(
+        kind,
+        { runtimeSlotNumber: adoptedRuntimeSlotNumber },
+        timestampMs,
+        'unmatched',
+        'invalid_slot_identity'
+      );
+      this.notify();
+      return undefined;
+    }
+    const runtimeSlotNumber = adoptedRuntimeSlotNumber ?? this.nextRuntimeSlotNumber;
+    this.nextRuntimeSlotNumber = runtimeSlotNumber + 1;
     const record: MutableSlotRecord = {
       runtimeSlotNumber,
       requests: [],
     };
-    this.slotNumbers.set(slot, runtimeSlotNumber);
+    this.slotNumbers.set(identity, runtimeSlotNumber);
     this.refreshSlotMetadata(record, slot);
     this.slots.set(runtimeSlotNumber, record);
     this.slotOrder.push(runtimeSlotNumber);
@@ -1108,12 +1143,20 @@ export class GptDiagnosticsStore {
   }
 
   private refreshSlotMetadata(record: MutableSlotRecord, slot: GptDiagnosticsSlotLike): void {
-    record.slotElementId ??= optionalNonEmptyString(
-      typeof slot.getSlotElementId === 'function' ? slot.getSlotElementId.bind(slot) : undefined
-    );
-    record.adUnitPath ??= optionalNonEmptyString(
-      typeof slot.getAdUnitPath === 'function' ? slot.getAdUnitPath.bind(slot) : undefined
-    );
+    record.slotElementId ??=
+      (typeof slot.elementId === 'string' && slot.elementId.length > 0
+        ? slot.elementId
+        : undefined) ??
+      optionalNonEmptyString(
+        typeof slot.getSlotElementId === 'function' ? slot.getSlotElementId.bind(slot) : undefined
+      );
+    record.adUnitPath ??=
+      (typeof slot.adUnitPath === 'string' && slot.adUnitPath.length > 0
+        ? slot.adUnitPath
+        : undefined) ??
+      optionalNonEmptyString(
+        typeof slot.getAdUnitPath === 'function' ? slot.getAdUnitPath.bind(slot) : undefined
+      );
   }
 
   private markRecentlyActive(runtimeSlotNumber: number): void {
@@ -1146,7 +1189,7 @@ export class GptDiagnosticsStore {
       return;
     }
 
-    attach(record, candidates[0]);
+    attach(record, candidates[0]!);
     this.incrementDisposition(kind, 'matched');
     this.notify();
   }
@@ -1181,6 +1224,13 @@ export class GptDiagnosticsStore {
   }
 
   private notify(): void {
+    for (const listener of [...this.commitListeners]) {
+      try {
+        listener();
+      } catch {
+        // One correctness observer must not block the committed store mutation.
+      }
+    }
     if (this.notificationScheduled) return;
     this.notificationScheduled = true;
     this.schedule(() => {
diff --git a/crates/trusted-server-js/lib/src/integrations/lockr/index.ts b/crates/trusted-server-js/lib/src/integrations/lockr/index.ts
index e7b98e2cf..3d94101d7 100644
--- a/crates/trusted-server-js/lib/src/integrations/lockr/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/lockr/index.ts
@@ -1,107 +1,11 @@
-import { log } from '../../core/log';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installLockrGuard } from './script_guard';
-
-// Type definition for Lockr global
-declare const identityLockr: IdentityLockr | undefined;
-
-interface IdentityLockr {
-  host: string;
-  app_id: string;
-  expiryDateKeys: string[];
-  firstPartyCookies: string[];
-  canRefreshToken: boolean;
-  macroDetectionEnabled: boolean;
-  iluiMacroDetection: boolean;
-  gdprApplies: boolean;
-  consentString: string;
-  gppString: string;
-  ccpaString: string;
-  isUTMTagsLoaded: boolean;
-  isFirstPartyCookiesLoaded: boolean;
-  allowedUTMTags: string[];
-  lockrTrackingID: string;
-  panoramaClientId: string;
-  writeToDeviceConsentEUID: boolean;
-  id5JSEnabled: boolean;
-  firstIDPassHEM: boolean;
-  panoramaPassHEM: boolean;
-  firstIDEnabled: boolean;
-  panoramaEnabled: boolean;
-  isAdelphicEnabled: boolean;
-  os: string;
-  browser: string;
-  country: string;
-  city: string;
-  latitude: string;
-  longitude: string;
-  ip: string;
-  hashedUserAgent: string;
-  tokenMappings: Record<string, string>;
-  tokenSourceMappings: Record<string, string>;
-  identitProvidersType: Record<string, string>;
-  identityIdEncryptionSalt: string;
-}
-
-/**
- * Install the Lockr shim to rewrite API endpoints to first-party domain.
- * This function is called after the Lockr SDK has loaded and initialized.
- */
-function installLockrShim() {
-  log.info('Installing Lockr shim - rewriting API host to first-party domain');
-
-  if (typeof identityLockr === 'undefined' || !identityLockr) {
-    log.warn('Lockr shim: identityLockr global not found');
-    return;
-  }
-
-  const host = window.location.host;
-  const protocol = window.location.protocol === 'https:' ? 'https' : 'http';
-
-  // Store original host for debugging
-  const originalHost = identityLockr.host;
-
-  // Rewrite to first-party domain
-  // The Lockr SDK will now make all API calls through our proxy
-  identityLockr.host = `${protocol}://${host}/integrations/lockr/api`;
-
-  log.info('Lockr shim installed', {
-    originalHost,
-    newHost: identityLockr.host,
-    appId: identityLockr.app_id,
-  });
-}
-
-/**
- * Wait for Lockr SDK to be available before installing shim.
- * Polls for SDK availability with a maximum number of attempts.
- *
- * @param callback - Function to call when SDK is available
- * @param maxAttempts - Maximum number of polling attempts (default: 50)
- */
-function waitForLockrSDK(callback: () => void, maxAttempts = 50) {
-  let attempts = 0;
-
-  const check = () => {
-    attempts++;
-
-    // Check if identityLockr global exists and is initialized with host
-    if (typeof identityLockr !== 'undefined' && identityLockr && identityLockr.host) {
-      log.info('Lockr SDK detected, installing shim');
-      callback();
-    } else if (attempts < maxAttempts) {
-      // Check again in 50ms
-      setTimeout(check, 50);
-    } else {
-      log.warn('Lockr SDK not detected after', maxAttempts * 50, 'ms');
-    }
-  };
-
-  check();
-}
+import { createLockrIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installLockrGuard();
-
-  waitForLockrSDK(() => installLockrShim());
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [createLockrIntegrationRegistration(EMBEDDED_RELEASE_ID)]);
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/lockr/module.ts b/crates/trusted-server-js/lib/src/integrations/lockr/module.ts
new file mode 100644
index 000000000..f9f8270d4
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/lockr/module.ts
@@ -0,0 +1,156 @@
+import type { IntegrationRegistration } from '../../kernel/integration_registry';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import {
+  createLifecycleIntegrationRegistration,
+  type IntegrationLifecycleRuntime,
+} from '../../kernel/lifecycle_module';
+import { log } from '../../core/log';
+
+import { installLockrGuard, resetGuardState } from './script_guard';
+
+export const LOCKR_INTEGRATION_ID = 'lockr' as const;
+
+interface LockrSdk {
+  host: string;
+}
+
+export interface LockrRuntimeDependencies {
+  readonly clearTimeout: (timer: number) => void;
+  readonly getSdk: () => LockrSdk | undefined;
+  readonly installGuard: () => void;
+  readonly location: { readonly host: string; readonly protocol: string };
+  readonly resetGuard: () => void;
+  readonly setTimeout: (callback: () => void, delay: number) => number;
+  readonly started: () => void;
+  readonly timedOut: () => void;
+}
+
+function bestEffort(action: () => void): void {
+  try {
+    action();
+  } catch {
+    // Cleanup is isolated so one hostile publisher hook cannot retain another resource.
+  }
+}
+
+/** Own the Lockr guard, bounded SDK readiness timer, and installed API host. */
+export function createLockrRuntime(
+  dependencies: LockrRuntimeDependencies = {
+    clearTimeout: (timer) => window.clearTimeout(timer),
+    getSdk: () => (globalThis as typeof globalThis & { identityLockr?: LockrSdk }).identityLockr,
+    installGuard: installLockrGuard,
+    location: window.location,
+    resetGuard: resetGuardState,
+    setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+    started: () => log.info('Lockr integration initialized'),
+    timedOut: () => log.warn('Lockr SDK not detected after', 2_500, 'ms'),
+  }
+): IntegrationLifecycleRuntime {
+  let active = false;
+  let started = false;
+  let timer: number | undefined;
+  let installedHost: string | undefined;
+  let previousHost: string | undefined;
+  let ownedSdk: LockrSdk | undefined;
+
+  const resetSdk = (): void => {
+    const sdk = ownedSdk;
+    const installed = installedHost;
+    const previous = previousHost;
+    ownedSdk = undefined;
+    installedHost = undefined;
+    previousHost = undefined;
+    if (!sdk || installed === undefined || previous === undefined) return;
+    try {
+      if (sdk.host === installed) sdk.host = previous;
+    } catch {
+      // Publisher replacement wins over cleanup.
+    }
+  };
+
+  return Object.freeze({
+    activate: (_config: unknown): (() => void) => {
+      if (active) throw new Error('Lockr runtime is already active');
+      try {
+        dependencies.installGuard();
+      } catch (error) {
+        try {
+          dependencies.resetGuard();
+        } catch {
+          // Preserve the activation failure after best-effort rollback.
+        }
+        throw error;
+      }
+      active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        started = false;
+        if (timer !== undefined) {
+          const ownedTimer = timer;
+          timer = undefined;
+          bestEffort(() => dependencies.clearTimeout(ownedTimer));
+        }
+        bestEffort(resetSdk);
+        bestEffort(dependencies.resetGuard);
+      };
+    },
+    start: (_config: unknown): void => {
+      if (!active || started) return;
+      started = true;
+      dependencies.started();
+      let attempts = 0;
+      const check = (): void => {
+        timer = undefined;
+        if (!active) return;
+        attempts += 1;
+        let sdk: LockrSdk | undefined;
+        try {
+          sdk = dependencies.getSdk();
+          if (sdk && typeof sdk.host === 'string' && sdk.host.length > 0) {
+            const protocol = dependencies.location.protocol === 'https:' ? 'https' : 'http';
+            const nextHost = `${protocol}://${dependencies.location.host}/integrations/lockr/api`;
+            const originalHost = sdk.host;
+            sdk.host = nextHost;
+            ownedSdk = sdk;
+            previousHost = originalHost;
+            installedHost = nextHost;
+            return;
+          }
+        } catch {
+          // Treat an unreadable or unwritable SDK as not ready.
+        }
+        if (attempts >= 50) {
+          dependencies.timedOut();
+          return;
+        }
+        try {
+          timer = dependencies.setTimeout(check, 50);
+        } catch {
+          dependencies.timedOut();
+        }
+      };
+      check();
+    },
+  });
+}
+
+export function createLockrIntegrationRegistration(release: string): IntegrationRegistration {
+  return createLifecycleIntegrationRegistration(LOCKR_INTEGRATION_ID, release, {
+    createOwnedRuntime: () => createLockrRuntime(),
+    firstDisplaySliceId: 'lockr_initial',
+    validateConfig: isEmptyIntegrationConfigV1,
+    validateFirstDisplayState: (state) => {
+      const readiness = state.values[1];
+      return (
+        state.values[0]?.[0] === 'route_guard' &&
+        state.values[0][1] === 'lockr' &&
+        (state.values.length === 1 ||
+          (state.values.length === 2 &&
+            (readiness?.[0] === 'sdk_host'
+              ? typeof readiness[1] === 'string' && readiness[1].length > 0
+              : readiness?.[0] === 'readiness_timeout' && readiness[1] === 50)))
+      );
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/osano/consent.ts b/crates/trusted-server-js/lib/src/integrations/osano/consent.ts
new file mode 100644
index 000000000..2724fb7af
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/osano/consent.ts
@@ -0,0 +1,11 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+
+import { createOsanoIntegrationRegistration } from './module';
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [createOsanoIntegrationRegistration(EMBEDDED_RELEASE_ID)]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/osano/consent_mirror.ts b/crates/trusted-server-js/lib/src/integrations/osano/consent_mirror.ts
new file mode 100644
index 000000000..88c6a983d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/osano/consent_mirror.ts
@@ -0,0 +1,536 @@
+import { log } from '../../core/log';
+
+const MARKER_COOKIE_NAME = '_ts_consent_src';
+const MARKER_COOKIE_VALUE = 'osano';
+const US_PRIVACY_COOKIE_NAME = 'us_privacy';
+const GPP_COOKIE_NAME = '__gpp';
+const GPP_SID_COOKIE_NAME = '__gpp_sid';
+const TCF_COOKIE_NAME = 'euconsent-v2';
+const TARGET_COOKIE_NAMES = [
+  US_PRIVACY_COOKIE_NAME,
+  GPP_COOKIE_NAME,
+  GPP_SID_COOKIE_NAME,
+  TCF_COOKIE_NAME,
+];
+const API_TIMEOUT_MS = 500;
+const OSANO_RETRY_DELAY_MS = 250;
+const OSANO_MAX_RETRIES = 20;
+const MIRROR_DEBOUNCE_MS = 0;
+
+const OSANO_EVENTS = [
+  'osano-cm-initialized',
+  'osano-cm-consent-saved',
+  'osano-cm-consent-new',
+  'osano-cm-consent-changed',
+  'osano-cm-opt-out',
+  'osano-cm-storage',
+] as const;
+const OSANO_CLEAR_READY_EVENTS = new Set<string>([
+  'osano-cm-initialized',
+  'osano-cm-consent-saved',
+  'osano-cm-consent-new',
+  'osano-cm-consent-changed',
+  'osano-cm-opt-out',
+]);
+
+interface UspData {
+  uspString?: string;
+}
+
+interface GppPingData {
+  signalStatus?: string;
+  gppString?: string;
+  applicableSections?: number[];
+}
+
+interface TcfData {
+  tcString?: string;
+  eventStatus?: string;
+}
+
+interface OsanoCm {
+  addEventListener?: (eventName: string, callback: (payload?: unknown) => void) => void;
+  removeEventListener?: (eventName: string, callback: (payload?: unknown) => void) => void;
+}
+
+type UspApi = (
+  command: 'getUSPData',
+  version: 1,
+  callback: (data?: UspData, success?: boolean) => void
+) => void;
+
+type GppApi = (command: 'ping', callback: (data?: GppPingData, success?: boolean) => void) => void;
+
+type TcfApi = (
+  command: 'getTCData',
+  version: 2,
+  callback: (data?: TcfData, success?: boolean) => void
+) => void;
+
+type OsanoWindow = Window & {
+  Osano?: {
+    cm?: OsanoCm;
+  };
+  __uspapi?: UspApi;
+  __gpp?: GppApi;
+  __tcfapi?: TcfApi;
+};
+
+interface CookieWrite {
+  name: string;
+  value: string;
+}
+
+interface SignalResult {
+  writes: CookieWrite[];
+  clears: string[];
+  pending: boolean;
+}
+
+interface MirrorPlan {
+  writes: CookieWrite[];
+  clears: string[];
+  pending: boolean;
+}
+
+let initialized = false;
+let osanoListenersInstalled = false;
+let osanoRetryCount = 0;
+let osanoReadyForClears = false;
+let osanoRetryTimer: number | undefined;
+let mirrorTimer: number | undefined;
+let mirrorGeneration = 0;
+let osanoEventHandlers: Map<string, (payload?: unknown) => void> | undefined;
+let osanoListenerOwner: OsanoCm | undefined;
+let focusHandler: (() => void) | undefined;
+let visibilityHandler: (() => void) | undefined;
+const pendingSignalCancels = new Set<() => void>();
+
+function getWindow(): OsanoWindow | undefined {
+  if (typeof window === 'undefined') return undefined;
+  return window as OsanoWindow;
+}
+
+function readCookie(name: string): string | undefined {
+  if (typeof document === 'undefined') return undefined;
+
+  const prefix = `${name}=`;
+  const cookie = document.cookie.split('; ').find((entry) => entry.startsWith(prefix));
+  return cookie?.slice(prefix.length);
+}
+
+function writeCookie(name: string, value: string): void {
+  document.cookie = `${name}=${value}; Path=/; Secure; SameSite=Lax`;
+}
+
+function clearCookie(name: string): void {
+  document.cookie = `${name}=; Path=/; Secure; SameSite=Lax; Max-Age=0`;
+}
+
+function hasAnyTargetCookie(): boolean {
+  return TARGET_COOKIE_NAMES.some((name) => readCookie(name) !== undefined);
+}
+
+function ownsConsentCookies(): boolean {
+  return readCookie(MARKER_COOKIE_NAME) === MARKER_COOKIE_VALUE;
+}
+
+function canWriteConsentCookies(): boolean {
+  const marker = readCookie(MARKER_COOKIE_NAME);
+  if (marker === MARKER_COOKIE_VALUE) return true;
+
+  if (marker !== undefined) {
+    log.debug('osano: preserving consent cookies owned by another mirror', { marker });
+    return false;
+  }
+
+  if (hasAnyTargetCookie()) {
+    log.debug('osano: preserving existing unmarked consent cookies');
+    return false;
+  }
+
+  return true;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isNumberArray(value: unknown): value is number[] {
+  return Array.isArray(value) && value.every((item) => typeof item === 'number');
+}
+
+function shouldWriteGppSid(
+  applicableSections: number[] | undefined
+): applicableSections is number[] {
+  return (
+    Array.isArray(applicableSections) &&
+    applicableSections.length > 0 &&
+    !applicableSections.includes(-1)
+  );
+}
+
+function isTcfReady(eventStatus: unknown): boolean {
+  return eventStatus === 'tcloaded' || eventStatus === 'useractioncomplete';
+}
+
+function signalResult(writes: CookieWrite[] = [], clears: string[] = []): SignalResult {
+  return { writes, clears, pending: false };
+}
+
+function pendingResult(): SignalResult {
+  return { writes: [], clears: [], pending: true };
+}
+
+function unavailableResult(): SignalResult {
+  return { writes: [], clears: [], pending: false };
+}
+
+function emptyAfterOsanoReadyResult(cookieNames: string | string[]): SignalResult {
+  if (!osanoReadyForClears) {
+    return pendingResult();
+  }
+
+  return signalResult([], Array.isArray(cookieNames) ? cookieNames : [cookieNames]);
+}
+
+function finishOnce<T>(finish: (value: T) => void): (value: T) => void {
+  let settled = false;
+  return (value: T): void => {
+    if (settled) return;
+    settled = true;
+    finish(value);
+  };
+}
+
+function readUspSignal(win: OsanoWindow): Promise<SignalResult> {
+  if (typeof win.__uspapi !== 'function') return Promise.resolve(unavailableResult());
+
+  return new Promise((resolve) => {
+    let timer: number | undefined = undefined;
+    let cancelPending = (): void => undefined;
+    const done = finishOnce((result: SignalResult) => {
+      if (timer !== undefined) window.clearTimeout(timer);
+      pendingSignalCancels.delete(cancelPending);
+      resolve(result);
+    });
+    cancelPending = () => done(pendingResult());
+    pendingSignalCancels.add(cancelPending);
+    timer = window.setTimeout(cancelPending, API_TIMEOUT_MS);
+
+    try {
+      win.__uspapi?.('getUSPData', 1, (data, success) => {
+        if (success === false || !isRecord(data)) {
+          done(pendingResult());
+          return;
+        }
+
+        if ('uspString' in data && typeof data.uspString !== 'string') {
+          done(pendingResult());
+          return;
+        }
+
+        if (typeof data.uspString === 'string' && data.uspString.length > 0) {
+          done(signalResult([{ name: US_PRIVACY_COOKIE_NAME, value: data.uspString }]));
+          return;
+        }
+
+        done(emptyAfterOsanoReadyResult(US_PRIVACY_COOKIE_NAME));
+      });
+    } catch (error) {
+      log.debug('osano: __uspapi getUSPData failed', { error });
+      done(pendingResult());
+    }
+  });
+}
+
+function readGppSignal(win: OsanoWindow): Promise<SignalResult> {
+  if (typeof win.__gpp !== 'function') return Promise.resolve(unavailableResult());
+
+  return new Promise((resolve) => {
+    let timer: number | undefined = undefined;
+    let cancelPending = (): void => undefined;
+    const done = finishOnce((result: SignalResult) => {
+      if (timer !== undefined) window.clearTimeout(timer);
+      pendingSignalCancels.delete(cancelPending);
+      resolve(result);
+    });
+    cancelPending = () => done(pendingResult());
+    pendingSignalCancels.add(cancelPending);
+    timer = window.setTimeout(cancelPending, API_TIMEOUT_MS);
+
+    try {
+      win.__gpp?.('ping', (data, success) => {
+        if (success === false || !isRecord(data)) {
+          done(pendingResult());
+          return;
+        }
+
+        if (data.signalStatus !== 'ready') {
+          done(pendingResult());
+          return;
+        }
+
+        if ('gppString' in data && typeof data.gppString !== 'string') {
+          done(pendingResult());
+          return;
+        }
+
+        if (
+          'applicableSections' in data &&
+          data.applicableSections !== undefined &&
+          !isNumberArray(data.applicableSections)
+        ) {
+          done(pendingResult());
+          return;
+        }
+
+        const applicableSections = data.applicableSections as number[] | undefined;
+        if (typeof data.gppString === 'string' && data.gppString.length > 0) {
+          const writes = [{ name: GPP_COOKIE_NAME, value: data.gppString }];
+          const clears: string[] = [];
+
+          if (shouldWriteGppSid(applicableSections)) {
+            writes.push({ name: GPP_SID_COOKIE_NAME, value: applicableSections.join(',') });
+          } else {
+            clears.push(GPP_SID_COOKIE_NAME);
+          }
+
+          done(signalResult(writes, clears));
+          return;
+        }
+
+        done(emptyAfterOsanoReadyResult([GPP_COOKIE_NAME, GPP_SID_COOKIE_NAME]));
+      });
+    } catch (error) {
+      log.debug('osano: __gpp ping failed', { error });
+      done(pendingResult());
+    }
+  });
+}
+
+function readTcfSignal(win: OsanoWindow): Promise<SignalResult> {
+  if (typeof win.__tcfapi !== 'function') return Promise.resolve(unavailableResult());
+
+  return new Promise((resolve) => {
+    let timer: number | undefined = undefined;
+    let cancelPending = (): void => undefined;
+    const done = finishOnce((result: SignalResult) => {
+      if (timer !== undefined) window.clearTimeout(timer);
+      pendingSignalCancels.delete(cancelPending);
+      resolve(result);
+    });
+    cancelPending = () => done(pendingResult());
+    pendingSignalCancels.add(cancelPending);
+    timer = window.setTimeout(cancelPending, API_TIMEOUT_MS);
+
+    try {
+      win.__tcfapi?.('getTCData', 2, (data, success) => {
+        if (success === false || !isRecord(data)) {
+          done(pendingResult());
+          return;
+        }
+
+        if (!isTcfReady(data.eventStatus)) {
+          done(pendingResult());
+          return;
+        }
+
+        if ('tcString' in data && typeof data.tcString !== 'string') {
+          done(pendingResult());
+          return;
+        }
+
+        if (typeof data.tcString === 'string' && data.tcString.length > 0) {
+          done(signalResult([{ name: TCF_COOKIE_NAME, value: data.tcString }]));
+          return;
+        }
+
+        done(emptyAfterOsanoReadyResult(TCF_COOKIE_NAME));
+      });
+    } catch (error) {
+      log.debug('osano: __tcfapi getTCData failed', { error });
+      done(pendingResult());
+    }
+  });
+}
+
+async function buildMirrorPlan(win: OsanoWindow): Promise<MirrorPlan> {
+  const results = await Promise.all([readUspSignal(win), readGppSignal(win), readTcfSignal(win)]);
+
+  return {
+    writes: results.flatMap((result) => result.writes),
+    clears: results.flatMap((result) => result.clears),
+    pending: results.some((result) => result.pending),
+  };
+}
+
+function applyMirrorPlan(plan: MirrorPlan): boolean {
+  if (plan.writes.length === 0 && plan.clears.length === 0) {
+    return false;
+  }
+
+  if (!canWriteConsentCookies()) {
+    return false;
+  }
+
+  const writeNames = new Set(plan.writes.map((write) => write.name));
+  for (const name of plan.clears) {
+    if (!writeNames.has(name)) clearCookie(name);
+  }
+
+  for (const write of plan.writes) {
+    writeCookie(write.name, write.value);
+  }
+
+  if (hasAnyTargetCookie()) {
+    writeCookie(MARKER_COOKIE_NAME, MARKER_COOKIE_VALUE);
+  } else if (ownsConsentCookies()) {
+    clearCookie(MARKER_COOKIE_NAME);
+  }
+
+  log.info('osano: mirrored consent to standard cookies', {
+    writes: plan.writes.map((write) => write.name),
+    clears: plan.clears,
+    pending: plan.pending,
+  });
+
+  return true;
+}
+
+/**
+ * Mirrors Osano's IAB API consent signals into standard first-party cookies.
+ *
+ * Returns `true` when any cookie was written or cleared, `false` otherwise.
+ */
+export async function mirrorOsanoConsent(): Promise<boolean> {
+  if (typeof document === 'undefined') return false;
+
+  const win = getWindow();
+  if (!win) return false;
+
+  const generation = (mirrorGeneration += 1);
+  const plan = await buildMirrorPlan(win);
+
+  if (generation !== mirrorGeneration) {
+    return false;
+  }
+
+  return applyMirrorPlan(plan);
+}
+
+function scheduleMirror(): void {
+  if (mirrorTimer !== undefined || typeof window === 'undefined') return;
+
+  mirrorTimer = window.setTimeout(() => {
+    mirrorTimer = undefined;
+    void mirrorOsanoConsent();
+  }, MIRROR_DEBOUNCE_MS);
+}
+
+function installOsanoListeners(): boolean {
+  const cm = getWindow()?.Osano?.cm;
+  if (!cm) return false;
+
+  if (osanoListenersInstalled) {
+    scheduleMirror();
+    return true;
+  }
+
+  if (typeof cm.addEventListener !== 'function' || typeof cm.removeEventListener !== 'function') {
+    return false;
+  }
+
+  osanoEventHandlers = new Map();
+  osanoListenerOwner = cm;
+  for (const eventName of OSANO_EVENTS) {
+    const handler = (): void => {
+      if (OSANO_CLEAR_READY_EVENTS.has(eventName)) {
+        osanoReadyForClears = true;
+      }
+      scheduleMirror();
+    };
+    osanoEventHandlers.set(eventName, handler);
+    cm.addEventListener(eventName, handler);
+  }
+  osanoListenersInstalled = true;
+
+  scheduleMirror();
+  return true;
+}
+
+function scheduleOsanoRetry(): void {
+  if (osanoRetryTimer !== undefined || osanoRetryCount >= OSANO_MAX_RETRIES) return;
+
+  osanoRetryCount += 1;
+  osanoRetryTimer = window.setTimeout(() => {
+    osanoRetryTimer = undefined;
+    if (!installOsanoListeners()) {
+      scheduleOsanoRetry();
+    }
+  }, OSANO_RETRY_DELAY_MS);
+}
+
+function mirrorOnVisible(): void {
+  if (document.visibilityState === 'visible') {
+    scheduleMirror();
+  }
+}
+
+/**
+ * Initializes the Osano consent mirror.
+ */
+export function initializeOsanoConsentMirror(): void {
+  if (initialized || typeof window === 'undefined' || typeof document === 'undefined') {
+    return;
+  }
+
+  initialized = true;
+  focusHandler = () => scheduleMirror();
+  visibilityHandler = () => mirrorOnVisible();
+  window.addEventListener('focus', focusHandler);
+  document.addEventListener('visibilitychange', visibilityHandler);
+
+  scheduleMirror();
+
+  if (!installOsanoListeners()) {
+    scheduleOsanoRetry();
+  }
+}
+
+/** Dispose every timer/listener owned by the active Osano consent mirror. */
+export function disposeOsanoConsentMirror(): void {
+  const cm = osanoListenerOwner;
+  if (
+    osanoListenersInstalled &&
+    osanoEventHandlers &&
+    cm &&
+    typeof cm.removeEventListener === 'function'
+  ) {
+    for (const [eventName, handler] of osanoEventHandlers) {
+      try {
+        cm.removeEventListener(eventName, handler);
+      } catch {
+        // One vendor listener failure cannot retain the remaining owners.
+      }
+    }
+  }
+
+  if (focusHandler) window.removeEventListener('focus', focusHandler);
+  if (visibilityHandler) document.removeEventListener('visibilitychange', visibilityHandler);
+  if (osanoRetryTimer !== undefined) window.clearTimeout(osanoRetryTimer);
+  if (mirrorTimer !== undefined) window.clearTimeout(mirrorTimer);
+  mirrorGeneration += 1;
+  for (const cancel of [...pendingSignalCancels]) cancel();
+
+  initialized = false;
+  osanoListenersInstalled = false;
+  osanoRetryCount = 0;
+  osanoReadyForClears = false;
+  osanoRetryTimer = undefined;
+  mirrorTimer = undefined;
+  osanoEventHandlers = undefined;
+  osanoListenerOwner = undefined;
+  focusHandler = undefined;
+  visibilityHandler = undefined;
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/osano/index.ts b/crates/trusted-server-js/lib/src/integrations/osano/index.ts
index 8bd3daae1..afd29ff9a 100644
--- a/crates/trusted-server-js/lib/src/integrations/osano/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/osano/index.ts
@@ -1,514 +1,17 @@
-import { log } from '../../core/log';
+export {
+  disposeOsanoConsentMirror,
+  initializeOsanoConsentMirror,
+  mirrorOsanoConsent,
+} from './consent_mirror';
 
-const MARKER_COOKIE_NAME = '_ts_consent_src';
-const MARKER_COOKIE_VALUE = 'osano';
-const US_PRIVACY_COOKIE_NAME = 'us_privacy';
-const GPP_COOKIE_NAME = '__gpp';
-const GPP_SID_COOKIE_NAME = '__gpp_sid';
-const TCF_COOKIE_NAME = 'euconsent-v2';
-const TARGET_COOKIE_NAMES = [
-  US_PRIVACY_COOKIE_NAME,
-  GPP_COOKIE_NAME,
-  GPP_SID_COOKIE_NAME,
-  TCF_COOKIE_NAME,
-];
-const API_TIMEOUT_MS = 500;
-const OSANO_RETRY_DELAY_MS = 250;
-const OSANO_MAX_RETRIES = 20;
-const MIRROR_DEBOUNCE_MS = 0;
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-const OSANO_EVENTS = [
-  'osano-cm-initialized',
-  'osano-cm-consent-saved',
-  'osano-cm-consent-new',
-  'osano-cm-consent-changed',
-  'osano-cm-opt-out',
-  'osano-cm-storage',
-] as const;
-const OSANO_CLEAR_READY_EVENTS = new Set<string>([
-  'osano-cm-initialized',
-  'osano-cm-consent-saved',
-  'osano-cm-consent-new',
-  'osano-cm-consent-changed',
-  'osano-cm-opt-out',
-]);
+import { createOsanoIntegrationRegistration } from './module';
 
-interface UspData {
-  uspString?: string;
-}
-
-interface GppPingData {
-  signalStatus?: string;
-  gppString?: string;
-  applicableSections?: number[];
-}
-
-interface TcfData {
-  tcString?: string;
-  eventStatus?: string;
-}
-
-interface OsanoCm {
-  addEventListener?: (eventName: string, callback: (payload?: unknown) => void) => void;
-  removeEventListener?: (eventName: string, callback: (payload?: unknown) => void) => void;
-}
-
-type UspApi = (
-  command: 'getUSPData',
-  version: 1,
-  callback: (data?: UspData, success?: boolean) => void
-) => void;
-
-type GppApi = (command: 'ping', callback: (data?: GppPingData, success?: boolean) => void) => void;
-
-type TcfApi = (
-  command: 'getTCData',
-  version: 2,
-  callback: (data?: TcfData, success?: boolean) => void
-) => void;
-
-type OsanoWindow = Window & {
-  Osano?: {
-    cm?: OsanoCm;
-  };
-  __uspapi?: UspApi;
-  __gpp?: GppApi;
-  __tcfapi?: TcfApi;
-};
-
-interface CookieWrite {
-  name: string;
-  value: string;
-}
-
-interface SignalResult {
-  writes: CookieWrite[];
-  clears: string[];
-  pending: boolean;
-}
-
-interface MirrorPlan {
-  writes: CookieWrite[];
-  clears: string[];
-  pending: boolean;
-}
-
-let initialized = false;
-let osanoListenersInstalled = false;
-let osanoRetryCount = 0;
-let osanoReadyForClears = false;
-let osanoRetryTimer: number | undefined;
-let mirrorTimer: number | undefined;
-let mirrorGeneration = 0;
-let osanoEventHandlers: Map<string, (payload?: unknown) => void> | undefined;
-let focusHandler: (() => void) | undefined;
-let visibilityHandler: (() => void) | undefined;
-
-function getWindow(): OsanoWindow | undefined {
-  if (typeof window === 'undefined') return undefined;
-  return window as OsanoWindow;
-}
-
-function readCookie(name: string): string | undefined {
-  if (typeof document === 'undefined') return undefined;
-
-  const prefix = `${name}=`;
-  const cookie = document.cookie.split('; ').find((entry) => entry.startsWith(prefix));
-  return cookie?.slice(prefix.length);
-}
-
-function writeCookie(name: string, value: string): void {
-  document.cookie = `${name}=${value}; Path=/; Secure; SameSite=Lax`;
-}
-
-function clearCookie(name: string): void {
-  document.cookie = `${name}=; Path=/; Secure; SameSite=Lax; Max-Age=0`;
-}
-
-function hasAnyTargetCookie(): boolean {
-  return TARGET_COOKIE_NAMES.some((name) => readCookie(name) !== undefined);
-}
-
-function ownsConsentCookies(): boolean {
-  return readCookie(MARKER_COOKIE_NAME) === MARKER_COOKIE_VALUE;
-}
-
-function canWriteConsentCookies(): boolean {
-  const marker = readCookie(MARKER_COOKIE_NAME);
-  if (marker === MARKER_COOKIE_VALUE) return true;
-
-  if (marker !== undefined) {
-    log.debug('osano: preserving consent cookies owned by another mirror', { marker });
-    return false;
-  }
-
-  if (hasAnyTargetCookie()) {
-    log.debug('osano: preserving existing unmarked consent cookies');
-    return false;
-  }
-
-  return true;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function isNumberArray(value: unknown): value is number[] {
-  return Array.isArray(value) && value.every((item) => typeof item === 'number');
-}
-
-function shouldWriteGppSid(
-  applicableSections: number[] | undefined
-): applicableSections is number[] {
-  return (
-    Array.isArray(applicableSections) &&
-    applicableSections.length > 0 &&
-    !applicableSections.includes(-1)
-  );
-}
-
-function isTcfReady(eventStatus: unknown): boolean {
-  return eventStatus === 'tcloaded' || eventStatus === 'useractioncomplete';
-}
-
-function signalResult(writes: CookieWrite[] = [], clears: string[] = []): SignalResult {
-  return { writes, clears, pending: false };
-}
-
-function pendingResult(): SignalResult {
-  return { writes: [], clears: [], pending: true };
-}
-
-function unavailableResult(): SignalResult {
-  return { writes: [], clears: [], pending: false };
-}
-
-function emptyAfterOsanoReadyResult(cookieNames: string | string[]): SignalResult {
-  if (!osanoReadyForClears) {
-    return pendingResult();
-  }
-
-  return signalResult([], Array.isArray(cookieNames) ? cookieNames : [cookieNames]);
-}
-
-function finishOnce<T>(finish: (value: T) => void): (value: T) => void {
-  let settled = false;
-  return (value: T): void => {
-    if (settled) return;
-    settled = true;
-    finish(value);
-  };
-}
-
-function readUspSignal(win: OsanoWindow): Promise<SignalResult> {
-  if (typeof win.__uspapi !== 'function') return Promise.resolve(unavailableResult());
-
-  return new Promise((resolve) => {
-    const done = finishOnce((result: SignalResult) => {
-      window.clearTimeout(timer);
-      resolve(result);
-    });
-    const timer = window.setTimeout(() => done(pendingResult()), API_TIMEOUT_MS);
-
-    try {
-      win.__uspapi?.('getUSPData', 1, (data, success) => {
-        if (success === false || !isRecord(data)) {
-          done(pendingResult());
-          return;
-        }
-
-        if ('uspString' in data && typeof data.uspString !== 'string') {
-          done(pendingResult());
-          return;
-        }
-
-        if (typeof data.uspString === 'string' && data.uspString.length > 0) {
-          done(signalResult([{ name: US_PRIVACY_COOKIE_NAME, value: data.uspString }]));
-          return;
-        }
-
-        done(emptyAfterOsanoReadyResult(US_PRIVACY_COOKIE_NAME));
-      });
-    } catch (error) {
-      log.debug('osano: __uspapi getUSPData failed', { error });
-      done(pendingResult());
-    }
-  });
-}
-
-function readGppSignal(win: OsanoWindow): Promise<SignalResult> {
-  if (typeof win.__gpp !== 'function') return Promise.resolve(unavailableResult());
-
-  return new Promise((resolve) => {
-    const done = finishOnce((result: SignalResult) => {
-      window.clearTimeout(timer);
-      resolve(result);
-    });
-    const timer = window.setTimeout(() => done(pendingResult()), API_TIMEOUT_MS);
-
-    try {
-      win.__gpp?.('ping', (data, success) => {
-        if (success === false || !isRecord(data)) {
-          done(pendingResult());
-          return;
-        }
-
-        if (data.signalStatus !== 'ready') {
-          done(pendingResult());
-          return;
-        }
-
-        if ('gppString' in data && typeof data.gppString !== 'string') {
-          done(pendingResult());
-          return;
-        }
-
-        if (
-          'applicableSections' in data &&
-          data.applicableSections !== undefined &&
-          !isNumberArray(data.applicableSections)
-        ) {
-          done(pendingResult());
-          return;
-        }
-
-        const applicableSections = data.applicableSections;
-        if (typeof data.gppString === 'string' && data.gppString.length > 0) {
-          const writes = [{ name: GPP_COOKIE_NAME, value: data.gppString }];
-          const clears: string[] = [];
-
-          if (shouldWriteGppSid(applicableSections)) {
-            writes.push({ name: GPP_SID_COOKIE_NAME, value: applicableSections.join(',') });
-          } else {
-            clears.push(GPP_SID_COOKIE_NAME);
-          }
-
-          done(signalResult(writes, clears));
-          return;
-        }
-
-        done(emptyAfterOsanoReadyResult([GPP_COOKIE_NAME, GPP_SID_COOKIE_NAME]));
-      });
-    } catch (error) {
-      log.debug('osano: __gpp ping failed', { error });
-      done(pendingResult());
-    }
-  });
-}
-
-function readTcfSignal(win: OsanoWindow): Promise<SignalResult> {
-  if (typeof win.__tcfapi !== 'function') return Promise.resolve(unavailableResult());
-
-  return new Promise((resolve) => {
-    const done = finishOnce((result: SignalResult) => {
-      window.clearTimeout(timer);
-      resolve(result);
-    });
-    const timer = window.setTimeout(() => done(pendingResult()), API_TIMEOUT_MS);
-
-    try {
-      win.__tcfapi?.('getTCData', 2, (data, success) => {
-        if (success === false || !isRecord(data)) {
-          done(pendingResult());
-          return;
-        }
-
-        if (!isTcfReady(data.eventStatus)) {
-          done(pendingResult());
-          return;
-        }
-
-        if ('tcString' in data && typeof data.tcString !== 'string') {
-          done(pendingResult());
-          return;
-        }
-
-        if (typeof data.tcString === 'string' && data.tcString.length > 0) {
-          done(signalResult([{ name: TCF_COOKIE_NAME, value: data.tcString }]));
-          return;
-        }
-
-        done(emptyAfterOsanoReadyResult(TCF_COOKIE_NAME));
-      });
-    } catch (error) {
-      log.debug('osano: __tcfapi getTCData failed', { error });
-      done(pendingResult());
-    }
-  });
-}
-
-async function buildMirrorPlan(win: OsanoWindow): Promise<MirrorPlan> {
-  const results = await Promise.all([readUspSignal(win), readGppSignal(win), readTcfSignal(win)]);
-
-  return {
-    writes: results.flatMap((result) => result.writes),
-    clears: results.flatMap((result) => result.clears),
-    pending: results.some((result) => result.pending),
-  };
-}
-
-function applyMirrorPlan(plan: MirrorPlan): boolean {
-  if (plan.writes.length === 0 && plan.clears.length === 0) {
-    return false;
-  }
-
-  if (!canWriteConsentCookies()) {
-    return false;
-  }
-
-  const writeNames = new Set(plan.writes.map((write) => write.name));
-  for (const name of plan.clears) {
-    if (!writeNames.has(name)) clearCookie(name);
-  }
-
-  for (const write of plan.writes) {
-    writeCookie(write.name, write.value);
-  }
-
-  if (hasAnyTargetCookie()) {
-    writeCookie(MARKER_COOKIE_NAME, MARKER_COOKIE_VALUE);
-  } else if (ownsConsentCookies()) {
-    clearCookie(MARKER_COOKIE_NAME);
-  }
-
-  log.info('osano: mirrored consent to standard cookies', {
-    writes: plan.writes.map((write) => write.name),
-    clears: plan.clears,
-    pending: plan.pending,
-  });
-
-  return true;
-}
-
-/**
- * Mirrors Osano's IAB API consent signals into standard first-party cookies.
- *
- * Returns `true` when any cookie was written or cleared, `false` otherwise.
- */
-export async function mirrorOsanoConsent(): Promise<boolean> {
-  if (typeof document === 'undefined') return false;
-
-  const win = getWindow();
-  if (!win) return false;
-
-  const generation = (mirrorGeneration += 1);
-  const plan = await buildMirrorPlan(win);
-
-  if (generation !== mirrorGeneration) {
-    return false;
-  }
-
-  return applyMirrorPlan(plan);
-}
-
-function scheduleMirror(): void {
-  if (mirrorTimer !== undefined || typeof window === 'undefined') return;
-
-  mirrorTimer = window.setTimeout(() => {
-    mirrorTimer = undefined;
-    void mirrorOsanoConsent();
-  }, MIRROR_DEBOUNCE_MS);
-}
-
-function installOsanoListeners(): boolean {
-  const cm = getWindow()?.Osano?.cm;
-  if (!cm) return false;
-
-  if (osanoListenersInstalled) {
-    scheduleMirror();
-    return true;
-  }
-
-  if (typeof cm.addEventListener !== 'function') {
-    return false;
-  }
-
-  osanoEventHandlers = new Map();
-  for (const eventName of OSANO_EVENTS) {
-    const handler = (): void => {
-      if (OSANO_CLEAR_READY_EVENTS.has(eventName)) {
-        osanoReadyForClears = true;
-      }
-      scheduleMirror();
-    };
-    osanoEventHandlers.set(eventName, handler);
-    cm.addEventListener(eventName, handler);
-  }
-  osanoListenersInstalled = true;
-
-  scheduleMirror();
-  return true;
-}
-
-function scheduleOsanoRetry(): void {
-  if (osanoRetryTimer !== undefined || osanoRetryCount >= OSANO_MAX_RETRIES) return;
-
-  osanoRetryCount += 1;
-  osanoRetryTimer = window.setTimeout(() => {
-    osanoRetryTimer = undefined;
-    if (!installOsanoListeners()) {
-      scheduleOsanoRetry();
-    }
-  }, OSANO_RETRY_DELAY_MS);
-}
-
-function mirrorOnVisible(): void {
-  if (document.visibilityState === 'visible') {
-    scheduleMirror();
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [createOsanoIntegrationRegistration(EMBEDDED_RELEASE_ID)]);
   }
 }
-
-/**
- * Initializes the Osano consent mirror.
- */
-export function initializeOsanoConsentMirror(): void {
-  if (initialized || typeof window === 'undefined' || typeof document === 'undefined') {
-    return;
-  }
-
-  initialized = true;
-  focusHandler = () => scheduleMirror();
-  visibilityHandler = () => mirrorOnVisible();
-  window.addEventListener('focus', focusHandler);
-  document.addEventListener('visibilitychange', visibilityHandler);
-
-  scheduleMirror();
-
-  if (!installOsanoListeners()) {
-    scheduleOsanoRetry();
-  }
-}
-
-/** Resets module state for unit tests. */
-export function resetOsanoConsentMirrorForTest(): void {
-  const cm = getWindow()?.Osano?.cm;
-  if (
-    osanoListenersInstalled &&
-    osanoEventHandlers &&
-    cm &&
-    typeof cm.removeEventListener === 'function'
-  ) {
-    for (const [eventName, handler] of osanoEventHandlers) {
-      cm.removeEventListener(eventName, handler);
-    }
-  }
-
-  if (focusHandler) window.removeEventListener('focus', focusHandler);
-  if (visibilityHandler) document.removeEventListener('visibilitychange', visibilityHandler);
-  if (osanoRetryTimer !== undefined) window.clearTimeout(osanoRetryTimer);
-  if (mirrorTimer !== undefined) window.clearTimeout(mirrorTimer);
-
-  initialized = false;
-  osanoListenersInstalled = false;
-  osanoRetryCount = 0;
-  osanoReadyForClears = false;
-  mirrorGeneration = 0;
-  osanoRetryTimer = undefined;
-  mirrorTimer = undefined;
-  osanoEventHandlers = undefined;
-  focusHandler = undefined;
-  visibilityHandler = undefined;
-}
-
-initializeOsanoConsentMirror();
diff --git a/crates/trusted-server-js/lib/src/integrations/osano/lifecycle.ts b/crates/trusted-server-js/lib/src/integrations/osano/lifecycle.ts
new file mode 100644
index 000000000..50e0caea5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/osano/lifecycle.ts
@@ -0,0 +1,54 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+
+interface OsanoConsentCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly startLifecycle: () => void;
+}
+
+/** Build the release-bound later Osano lifecycle registration. */
+export function createOsanoLifecycleIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'osano_lifecycle',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const capability = interfaces['osano_consent.v1'] as OsanoConsentCapabilityV1 | undefined;
+      if (
+        !isEmptyIntegrationConfigV1(config) ||
+        !capability ||
+        !Object.isFrozen(capability) ||
+        typeof capability.activateLifecycle !== 'function' ||
+        typeof capability.startLifecycle !== 'function'
+      ) {
+        throw new TypeError('Osano lifecycle capability graph is invalid');
+      }
+      return Object.freeze({
+        activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+          const ownership: { release?: () => void } = {};
+          onDispose(() => ownership.release?.());
+          ownership.release = capability.activateLifecycle();
+          afterCommit(capability.startLifecycle);
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createOsanoLifecycleIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/osano/module.ts b/crates/trusted-server-js/lib/src/integrations/osano/module.ts
new file mode 100644
index 000000000..01333d533
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/osano/module.ts
@@ -0,0 +1,139 @@
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type { IntegrationLifecycleRuntime } from '../../kernel/lifecycle_module';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import { validatePersistentFirstDisplaySliceAdoptionV1 } from '../../shared/takeover';
+
+import {
+  disposeOsanoConsentMirror,
+  initializeOsanoConsentMirror,
+  mirrorOsanoConsent,
+} from './consent_mirror';
+
+export const OSANO_INTEGRATION_ID = 'osano_consent' as const;
+
+export interface OsanoRuntimeDependencies {
+  readonly initialize: () => void;
+  readonly reset: () => void;
+}
+
+export interface OsanoConsentCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly startLifecycle: () => void;
+}
+
+function runtimeCapability(interfaces: Readonly<Record<string, unknown>>): boolean {
+  const runtime = interfaces['runtime.v1'];
+  return typeof runtime === 'object' && runtime !== null && Object.isFrozen(runtime);
+}
+
+/** Bind the existing consent mirror's complete lifecycle to one release. */
+export function createOsanoRuntime(
+  dependencies: OsanoRuntimeDependencies = {
+    initialize: initializeOsanoConsentMirror,
+    reset: disposeOsanoConsentMirror,
+  }
+): IntegrationLifecycleRuntime {
+  let active = false;
+  let started = false;
+  return Object.freeze({
+    activate: (_config: unknown) => {
+      if (active) throw new Error('Osano runtime is already active');
+      active = true;
+      started = false;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        started = false;
+        dependencies.reset();
+      };
+    },
+    start: (_config: unknown) => {
+      if (!active || started) return;
+      started = true;
+      dependencies.initialize();
+    },
+  });
+}
+
+export function createOsanoIntegrationRegistration(release: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces, onDispose }: IntegrationPrepareContext) => {
+    if (!isEmptyIntegrationConfigV1(config) || !runtimeCapability(interfaces)) {
+      throw new TypeError('Osano takeover capability graph is invalid');
+    }
+    const lifecycle = createOsanoRuntime();
+    let takeoverActive = false;
+    let lifecycleRelease: (() => void) | undefined;
+    const capability: OsanoConsentCapabilityV1 = Object.freeze({
+      activateLifecycle: () => {
+        if (!takeoverActive || lifecycleRelease) {
+          throw new TypeError('Osano lifecycle is unavailable');
+        }
+        lifecycleRelease = lifecycle.activate(config);
+        return (): void => {
+          const releaseLifecycle = lifecycleRelease;
+          lifecycleRelease = undefined;
+          releaseLifecycle?.();
+        };
+      },
+      startLifecycle: () => {
+        if (!takeoverActive || !lifecycleRelease) {
+          throw new TypeError('Osano lifecycle is not active');
+        }
+        lifecycle.start(config);
+      },
+    });
+    onDispose(() => {
+      takeoverActive = false;
+      const releaseLifecycle = lifecycleRelease;
+      lifecycleRelease = undefined;
+      releaseLifecycle?.();
+      disposeOsanoConsentMirror();
+    });
+    return Object.freeze({
+      activate: ({
+        adoption,
+        afterCommit,
+        onDispose: onActivationDispose,
+      }: IntegrationActivationContext) => {
+        if (takeoverActive) throw new Error('Osano takeover slice is already active');
+        if (
+          adoption !== undefined &&
+          !validatePersistentFirstDisplaySliceAdoptionV1(
+            adoption,
+            'osano_initial',
+            (state) =>
+              state.values.length === 0 ||
+              (state.values.length === 1 &&
+                state.values[0]?.[0] === 'consent_snapshot' &&
+                typeof state.values[0][1] === 'number' &&
+                Number.isInteger(state.values[0][1]) &&
+                state.values[0][1] >= 0)
+          )
+        ) {
+          throw new TypeError('Osano first-display parser state is invalid');
+        }
+        takeoverActive = true;
+        onActivationDispose(() => {
+          takeoverActive = false;
+          disposeOsanoConsentMirror();
+        });
+        afterCommit(() => {
+          void mirrorOsanoConsent();
+        });
+      },
+      interfaces: Object.freeze({ 'osano_consent.v1': capability }),
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: OSANO_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId: release,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/context.ts b/crates/trusted-server-js/lib/src/integrations/permutive/context.ts
new file mode 100644
index 000000000..6385eac8a
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/context.ts
@@ -0,0 +1,13 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+
+import { createPermutiveIntegrationRegistration } from './module';
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createPermutiveIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/index.ts b/crates/trusted-server-js/lib/src/integrations/permutive/index.ts
index 60eb5134a..6385eac8a 100644
--- a/crates/trusted-server-js/lib/src/integrations/permutive/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/index.ts
@@ -1,114 +1,13 @@
-import { log } from '../../core/log';
-import { registerContextProvider } from '../../core/context';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installPermutiveGuard } from './script_guard';
-import { getPermutiveSegments } from './segments';
-
-declare const permutive: {
-  config: {
-    advertiserApiVersion: string;
-    apiHost: string;
-    apiKey: string;
-    apiProtocol: string;
-    apiVersion: string;
-    cdnBaseUrl: string;
-    cdnProtocol: string;
-    classificationModelsApiVersion: string;
-    consentRequired: boolean;
-    cookieDomain: string;
-    cookieExpiry: string;
-    cookieName: string;
-    environment: string;
-    eventsCacheLimitBytes: number;
-    eventsTTLInDays: number | null;
-    localStorageDebouncedKeys: string[];
-    localStorageWriteDelay: number;
-    localStorageWriteMaxDelay: number;
-    loggingEnabled: boolean;
-    metricsSamplingPercentage: number;
-    permutiveDataMiscKey: string;
-    permutiveDataQueriesKey: string;
-    prebidAuctionsRandomDownsamplingThreshold: number;
-    pxidHost: string;
-    requestTimeout: number;
-    sdkErrorsApiVersion: string;
-    sdkType: string;
-    secureSignalsApiHost: string;
-    segmentSyncApiHost: string;
-    sendClientErrors: boolean;
-    stateNamespace: string;
-    tracingEnabled: boolean;
-    viewId: string;
-    watson: {
-      enabled: boolean;
-    };
-    windowKey: string;
-    workspaceId: string;
-  };
-};
-
-function installPermutiveShim() {
-  log.info('Installing Permutive shim - rewriting API hosts to first-party domain');
-
-  const host = window.location.host;
-  const protocol = window.location.protocol === 'https:' ? 'https' : 'http';
-
-  permutive.config.apiHost = host + '/integrations/permutive/api';
-  permutive.config.apiProtocol = protocol;
-
-  permutive.config.secureSignalsApiHost = host + '/integrations/permutive/secure-signal';
-
-  permutive.config.segmentSyncApiHost = host + '/integrations/permutive/sync';
-
-  permutive.config.cdnBaseUrl = host + '/integrations/permutive/cdn';
-  permutive.config.cdnProtocol = protocol;
-
-  log.info('Permutive shim installed', {
-    apiHost: permutive.config.apiHost,
-    secureSignalsApiHost: permutive.config.secureSignalsApiHost,
-    segmentSyncApiHost: permutive.config.segmentSyncApiHost,
-    cdnBaseUrl: permutive.config.cdnBaseUrl,
-  });
-}
-
-/**
- * Wait for Permutive SDK to be available before installing shim.
- * Polls for SDK availability with a maximum number of attempts.
- *
- * @param callback - Function to call when SDK is available
- * @param maxAttempts - Maximum number of polling attempts (default: 50)
- */
-function waitForPermutiveSDK(callback: () => void, maxAttempts = 50) {
-  let attempts = 0;
-
-  const check = () => {
-    attempts++;
-
-    // Check if permutive global exists and is initialized with config
-    if (typeof permutive !== 'undefined' && permutive?.config) {
-      log.info('Permutive SDK detected, installing shim');
-      callback();
-    } else if (attempts < maxAttempts) {
-      // Check again in 50ms
-      setTimeout(check, 50);
-    } else {
-      log.warn('Permutive SDK not detected after', maxAttempts * 50, 'ms');
-    }
-  };
-
-  check();
-}
+import { createPermutiveIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installPermutiveGuard();
-
-  // Register a context provider so Permutive segments are included in auction
-  // requests. Core calls collectContext() before every /auction POST — this
-  // keeps all Permutive localStorage knowledge inside this integration.
-  registerContextProvider('permutive', () => {
-    const segments = getPermutiveSegments();
-    return segments.length > 0 ? { permutive_segments: segments } : undefined;
-  });
-
-  waitForPermutiveSDK(() => installPermutiveShim());
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createPermutiveIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/lifecycle.ts b/crates/trusted-server-js/lib/src/integrations/permutive/lifecycle.ts
new file mode 100644
index 000000000..83e69b06c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/lifecycle.ts
@@ -0,0 +1,55 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+
+interface PermutiveContextCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly startLifecycle: () => void;
+}
+
+/** Build the release-bound later Permutive lifecycle registration. */
+export function createPermutiveLifecycleIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'permutive_lifecycle',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const capability = interfaces['permutive_context.v1'] as
+        PermutiveContextCapabilityV1 | undefined;
+      if (
+        !isEmptyIntegrationConfigV1(config) ||
+        !capability ||
+        !Object.isFrozen(capability) ||
+        typeof capability.activateLifecycle !== 'function' ||
+        typeof capability.startLifecycle !== 'function'
+      ) {
+        throw new TypeError('Permutive lifecycle capability graph is invalid');
+      }
+      return Object.freeze({
+        activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+          const ownership: { release?: () => void } = {};
+          onDispose(() => ownership.release?.());
+          ownership.release = capability.activateLifecycle();
+          afterCommit(capability.startLifecycle);
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createPermutiveLifecycleIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/module.ts b/crates/trusted-server-js/lib/src/integrations/permutive/module.ts
new file mode 100644
index 000000000..db4f5dffd
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/module.ts
@@ -0,0 +1,375 @@
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type { IntegrationLifecycleRuntime } from '../../kernel/lifecycle_module';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type { RuntimeCapabilityV1 } from '../../kernel/runtime';
+import { log } from '../../core/log';
+import {
+  snapshotPersistentFirstDisplaySliceStateV1,
+  validatePersistentFirstDisplaySliceAdoptionV1,
+  type PersistentFirstDisplaySliceStateV1,
+} from '../../shared/takeover';
+
+import { installPermutiveGuard, resetGuardState } from './script_guard';
+import { getPermutiveSegments } from './segments';
+
+export const PERMUTIVE_INTEGRATION_ID = 'permutive_context' as const;
+
+const PERMUTIVE_CONFIG_FIELDS = [
+  'apiHost',
+  'apiProtocol',
+  'cdnBaseUrl',
+  'cdnProtocol',
+  'secureSignalsApiHost',
+  'segmentSyncApiHost',
+] as const;
+
+type PermutiveConfigField = (typeof PERMUTIVE_CONFIG_FIELDS)[number];
+type PermutiveConfig = Record<PermutiveConfigField, string>;
+
+interface PermutiveSdk {
+  readonly config: PermutiveConfig;
+}
+
+type ContextContributor = () => Readonly<Record<string, unknown>> | undefined;
+
+export interface PermutiveRuntimeDependencies {
+  readonly clearTimeout: (timer: number) => void;
+  readonly getSdk: () => PermutiveSdk | undefined;
+  readonly getSegments: () => readonly string[];
+  readonly installGuard: () => void;
+  readonly location: { readonly host: string; readonly protocol: string };
+  readonly registerContext: (contributor: ContextContributor) => (() => void) | undefined;
+  readonly resetGuard: () => void;
+  readonly setTimeout: (callback: () => void, delay: number) => number;
+  readonly started: () => void;
+  readonly timedOut: () => void;
+}
+
+export interface PermutiveContextCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly segments: () => readonly string[];
+  readonly startLifecycle: () => void;
+}
+
+function bestEffort(action: () => void): void {
+  try {
+    action();
+  } catch {
+    // Cleanup is intentionally isolated so one failed release cannot retain another resource.
+  }
+}
+
+function snapshotSegments(candidate: readonly string[]): readonly string[] {
+  const segments: string[] = [];
+  try {
+    const length = Math.min(candidate.length, 100);
+    for (let index = 0; index < length; index += 1) {
+      const segment = candidate[index];
+      if (typeof segment === 'string') segments.push(segment);
+    }
+  } catch {
+    return Object.freeze([]);
+  }
+  return Object.freeze(segments);
+}
+
+function snapshotAdoptedSegments(
+  state: Readonly<PersistentFirstDisplaySliceStateV1>
+): readonly string[] | undefined {
+  const row = state.values.find(([key]) => key === 'segments');
+  if (!row || typeof row[1] !== 'string' || row[1].length > 4_096) return undefined;
+  try {
+    const parsed = JSON.parse(row[1]);
+    if (!Array.isArray(parsed) || parsed.length === 0 || parsed.length > 100) return undefined;
+    const segments = snapshotSegments(parsed);
+    if (
+      segments.length !== parsed.length ||
+      segments.some((segment) => segment.length === 0 || segment.length > 256) ||
+      JSON.stringify(segments) !== row[1]
+    ) {
+      return undefined;
+    }
+    return segments;
+  } catch {
+    return undefined;
+  }
+}
+
+function validatePermutiveAdoptionState(
+  state: Readonly<PersistentFirstDisplaySliceStateV1>
+): boolean {
+  if (state.values.length > 2) return false;
+  let hasSegments = false;
+  let hasReadiness = false;
+  for (const [key, value] of state.values) {
+    if (key === 'segments') {
+      if (hasSegments || !snapshotAdoptedSegments(state)) return false;
+      hasSegments = true;
+      continue;
+    }
+    if (
+      hasReadiness ||
+      !(
+        (key === 'sdk_config' && typeof value === 'string' && value.length > 0) ||
+        (key === 'readiness_timeout' && value === 50)
+      )
+    ) {
+      return false;
+    }
+    hasReadiness = true;
+  }
+  return true;
+}
+
+/** Own the Permutive guard, auction context, SDK readiness timer, and rewritten config. */
+export function createPermutiveRuntime(
+  overrides: Partial<PermutiveRuntimeDependencies> = {}
+): IntegrationLifecycleRuntime {
+  const dependencies: PermutiveRuntimeDependencies = {
+    clearTimeout: (timer) => window.clearTimeout(timer),
+    getSdk: () => (globalThis as typeof globalThis & { permutive?: PermutiveSdk }).permutive,
+    getSegments: getPermutiveSegments,
+    installGuard: installPermutiveGuard,
+    location: window.location,
+    registerContext: () => undefined,
+    resetGuard: resetGuardState,
+    setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+    started: () => log.info('Permutive integration initialized'),
+    timedOut: () => log.warn('Permutive SDK not detected after', 2_500, 'ms'),
+    ...overrides,
+  };
+  let active = false;
+  let started = false;
+  let timer: number | undefined;
+  let releaseContext: (() => void) | undefined;
+  let ownedConfig: PermutiveConfig | undefined;
+  let installedValues: Readonly<PermutiveConfig> | undefined;
+  let previousValues: Readonly<PermutiveConfig> | undefined;
+
+  const resetSdk = (): void => {
+    const config = ownedConfig;
+    const installed = installedValues;
+    const previous = previousValues;
+    ownedConfig = undefined;
+    installedValues = undefined;
+    previousValues = undefined;
+    if (!config || !installed || !previous) return;
+
+    for (const field of PERMUTIVE_CONFIG_FIELDS) {
+      bestEffort(() => {
+        if (config[field] === installed[field]) config[field] = previous[field];
+      });
+    }
+  };
+
+  const installSdkConfig = (config: PermutiveConfig): boolean => {
+    const protocol = dependencies.location.protocol === 'https:' ? 'https' : 'http';
+    const host = dependencies.location.host;
+    const next: PermutiveConfig = {
+      apiHost: `${host}/integrations/permutive/api`,
+      apiProtocol: protocol,
+      cdnBaseUrl: `${host}/integrations/permutive/cdn`,
+      cdnProtocol: protocol,
+      secureSignalsApiHost: `${host}/integrations/permutive/secure-signal`,
+      segmentSyncApiHost: `${host}/integrations/permutive/sync`,
+    };
+    const previous = {} as PermutiveConfig;
+    const written: PermutiveConfigField[] = [];
+    try {
+      for (const field of PERMUTIVE_CONFIG_FIELDS) previous[field] = config[field];
+      for (const field of PERMUTIVE_CONFIG_FIELDS) {
+        config[field] = next[field];
+        written.push(field);
+      }
+    } catch {
+      for (const field of written.reverse()) {
+        bestEffort(() => {
+          if (config[field] === next[field]) config[field] = previous[field];
+        });
+      }
+      return false;
+    }
+    ownedConfig = config;
+    previousValues = Object.freeze({ ...previous });
+    installedValues = Object.freeze({ ...next });
+    return true;
+  };
+
+  return Object.freeze({
+    activate: (_config: unknown): (() => void) => {
+      if (active) throw new Error('Permutive runtime is already active');
+      try {
+        dependencies.installGuard();
+        releaseContext = dependencies.registerContext(() => {
+          try {
+            const segments = snapshotSegments(dependencies.getSegments());
+            if (segments.length === 0) return undefined;
+            return Object.freeze({ permutive_segments: segments });
+          } catch {
+            return undefined;
+          }
+        });
+        if (!releaseContext) throw new Error('Permutive context registration failed');
+      } catch (error) {
+        releaseContext = undefined;
+        bestEffort(dependencies.resetGuard);
+        throw error;
+      }
+      active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        started = false;
+        if (timer !== undefined) {
+          bestEffort(() => dependencies.clearTimeout(timer as number));
+          timer = undefined;
+        }
+        resetSdk();
+        const release = releaseContext;
+        releaseContext = undefined;
+        if (release) bestEffort(release);
+        bestEffort(dependencies.resetGuard);
+      };
+    },
+    start: (_config: unknown): void => {
+      if (!active || started) return;
+      started = true;
+      dependencies.started();
+      let attempts = 0;
+      const check = (): void => {
+        timer = undefined;
+        if (!active) return;
+        attempts += 1;
+        try {
+          const sdk = dependencies.getSdk();
+          if (sdk?.config && installSdkConfig(sdk.config)) return;
+        } catch {
+          // Treat an unreadable SDK as not ready.
+        }
+        if (attempts >= 50) {
+          dependencies.timedOut();
+          return;
+        }
+        try {
+          timer = dependencies.setTimeout(check, 50);
+        } catch {
+          dependencies.timedOut();
+        }
+      };
+      check();
+    },
+  });
+}
+
+export function createPermutiveIntegrationRegistration(release: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces, onDispose }: IntegrationPrepareContext) => {
+    const runtimeCapability = interfaces['runtime.v1'];
+    if (
+      !isEmptyIntegrationConfigV1(config) ||
+      typeof runtimeCapability !== 'object' ||
+      runtimeCapability === null ||
+      !Object.isFrozen(runtimeCapability) ||
+      typeof (runtimeCapability as RuntimeCapabilityV1).registerAuctionContext !== 'function'
+    ) {
+      throw new TypeError('Permutive context capability graph is invalid');
+    }
+    const runtime = runtimeCapability as RuntimeCapabilityV1;
+    const lifecycle = createPermutiveRuntime({
+      installGuard: () => undefined,
+      registerContext: () => () => undefined,
+      resetGuard: () => undefined,
+    });
+    let takeoverActive = false;
+    let adoptedSegments: readonly string[] | undefined;
+    let releaseContext: (() => void) | undefined;
+    let lifecycleRelease: (() => void) | undefined;
+    const capability: PermutiveContextCapabilityV1 = Object.freeze({
+      activateLifecycle: () => {
+        if (!takeoverActive || lifecycleRelease) {
+          throw new TypeError('Permutive lifecycle is unavailable');
+        }
+        lifecycleRelease = lifecycle.activate(config);
+        return (): void => {
+          const releaseLifecycle = lifecycleRelease;
+          lifecycleRelease = undefined;
+          releaseLifecycle?.();
+        };
+      },
+      segments: () =>
+        takeoverActive ? snapshotSegments(getPermutiveSegments()) : Object.freeze([]),
+      startLifecycle: () => {
+        if (!takeoverActive || !lifecycleRelease) {
+          throw new TypeError('Permutive lifecycle is not active');
+        }
+        lifecycle.start(config);
+      },
+    });
+    onDispose(() => {
+      takeoverActive = false;
+      const releaseLifecycle = lifecycleRelease;
+      lifecycleRelease = undefined;
+      releaseLifecycle?.();
+      const release = releaseContext;
+      releaseContext = undefined;
+      release?.();
+      resetGuardState();
+    });
+    return Object.freeze({
+      activate: ({ adoption, onDispose: onActivationDispose }: IntegrationActivationContext) => {
+        if (takeoverActive) throw new Error('Permutive context is already active');
+        if (
+          adoption !== undefined &&
+          !validatePersistentFirstDisplaySliceAdoptionV1(
+            adoption,
+            'permutive_initial',
+            validatePermutiveAdoptionState
+          )
+        ) {
+          throw new TypeError('Permutive first-display parser state is invalid');
+        }
+        const adoptedState = snapshotPersistentFirstDisplaySliceStateV1(
+          adoption,
+          'permutive_initial'
+        );
+        adoptedSegments = adoptedState ? snapshotAdoptedSegments(adoptedState) : undefined;
+        try {
+          installPermutiveGuard();
+          releaseContext = runtime.registerAuctionContext(PERMUTIVE_INTEGRATION_ID, () => {
+            const segments = adoptedSegments ?? snapshotSegments(getPermutiveSegments());
+            adoptedSegments = undefined;
+            return segments.length === 0
+              ? undefined
+              : Object.freeze({ permutive_segments: segments });
+          });
+          if (!releaseContext) throw new Error('Permutive context registration failed');
+        } catch (error) {
+          releaseContext = undefined;
+          resetGuardState();
+          throw error;
+        }
+        takeoverActive = true;
+        onActivationDispose(() => {
+          takeoverActive = false;
+          adoptedSegments = undefined;
+          const release = releaseContext;
+          releaseContext = undefined;
+          release?.();
+          resetGuardState();
+        });
+      },
+      interfaces: Object.freeze({ 'permutive_context.v1': capability }),
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: PERMUTIVE_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId: release,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts b/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
index 31891db9b..59d63162b 100644
--- a/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
+++ b/crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts
@@ -6,12 +6,19 @@ import { createScriptGuard } from '../../shared/script_guard';
  */
 function isPermutiveSdkUrl(url: string): boolean {
   if (!url) return false;
-
-  const lower = url.toLowerCase();
-  return (
-    (lower.includes('.edge.permutive.app') || lower.includes('cdn.permutive.com')) &&
-    lower.endsWith('-web.js')
-  );
+  try {
+    const parsed = new URL(url);
+    const hostname = parsed.hostname.toLowerCase();
+    return (
+      parsed.protocol === 'https:' &&
+      (hostname === 'cdn.permutive.com' || hostname.endsWith('.edge.permutive.app')) &&
+      parsed.pathname.toLowerCase().endsWith('-web.js') &&
+      parsed.search === '' &&
+      parsed.hash === ''
+    );
+  } catch {
+    return false;
+  }
 }
 
 const guard = createScriptGuard({
diff --git a/crates/trusted-server-js/lib/src/integrations/prebid/index.ts b/crates/trusted-server-js/lib/src/integrations/prebid/index.ts
index ca822bd60..c52b1e407 100644
--- a/crates/trusted-server-js/lib/src/integrations/prebid/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/prebid/index.ts
@@ -1,2020 +1,13 @@
-// Prebid.js bundle with a custom "trustedServer" bid adapter that routes all
-// bid requests through the Trusted Server /auction orchestrator endpoint.
-//
-// Instead of using prebidServerBidAdapter (which sends OpenRTB directly to PBS),
-// we register a client-side adapter that:
-//   1. Converts Prebid bid requests → AdRequest format via core/auction
-//   2. POSTs to /auction (the Trusted Server orchestrator)
-//   3. Parses the OpenRTB seatbid response via core/auction
-//   4. Maps parsed AuctionBids into Prebid bid response objects
-//
-// The shim on requestBids injects "trustedServer" into every ad unit so all
-// bids flow through the orchestrator.
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import type _pbjsDefault from 'prebid.js';
+import { createPrebidIntegrationRegistration } from './module';
 
-import {
-  consumePublisherFirstImpressionDelivery,
-  FIRST_IMPRESSION_LEASE_MS,
-  firstImpressionClaim,
-  markPublisherFirstImpressionDeliveryPending,
-  registerPublisherFirstImpressionAuctions,
-  releasePublisherFirstImpressionAuction,
-  resolveFirstImpressionElement,
-} from '../../core/first_impression';
-import { log } from '../../core/log';
-import { buildAdRequest, parseAuctionResponse } from '../../core/auction';
-import { registerApsPrebidRenderer, validateApsRenderer } from '../aps/render';
-import type { AuctionBid, AuctionEid } from '../../core/auction';
-import type { AuctionSlot, TsjsApi } from '../../core/types';
-
-import { PREBID_USER_ID_MODULE_REGISTRY } from './user_id_modules';
-
-/**
- * Prebid.js public API surface (type-only; erased at build time).
- *
- * `getUserIdsAsEids` is added by the userId module at runtime, which the base
- * package typing does not model.
- */
-type PbjsGlobal = typeof _pbjsDefault & {
-  getUserIdsAsEids?: () => unknown[];
-};
-
-// Prebid.js itself is NOT bundled into this module. It is served as the
-// external bundle configured via `integrations.prebid.external_bundle_url`
-// (required whenever the prebid integration is enabled) and owns the
-// `window.pbjs` global. The Rust head injector emits a stub
-// (`window.pbjs = window.pbjs || {que:[],cmd:[]}`) before any script runs and
-// Prebid.js installs its API onto that same object, so capturing the reference
-// at module scope is safe regardless of evaluation order.
-const pbjs: PbjsGlobal = (
-  typeof window !== 'undefined'
-    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ((window as any).pbjs ??= { que: [], cmd: [] })
-    : { que: [], cmd: [] }
-) as PbjsGlobal;
-
-/**
- * Manifest stamped on `window.__tsjs_prebid_bundle` by the external Prebid.js
- * bundle (see build-prebid-external.mjs): which client-side bid adapters and
- * user ID modules were compiled into it.
- */
-interface ExternalPrebidBundleManifest {
-  adapters?: string[];
-  bidderCodes?: string[];
-  userIdModules?: string[];
-}
-
-function sanitizeManifestList(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  return value.filter((entry): entry is string => typeof entry === 'string');
-}
-
-function getExternalBundleManifest(): ExternalPrebidBundleManifest | undefined {
-  if (typeof window === 'undefined') {
-    return undefined;
-  }
-  // The manifest is a plain window global any page script can overwrite, so
-  // validate its shape instead of trusting the declared type: a non-array
-  // field must degrade to "not stamped" diagnostics, not a TypeError.
-  const raw = (window as { __tsjs_prebid_bundle?: unknown }).__tsjs_prebid_bundle;
-  if (raw === null || typeof raw !== 'object') {
-    return undefined;
-  }
-  const manifest = raw as Record<string, unknown>;
-  return {
-    adapters: sanitizeManifestList(manifest.adapters),
-    bidderCodes: sanitizeManifestList(manifest.bidderCodes),
-    userIdModules: sanitizeManifestList(manifest.userIdModules),
-  };
-}
-
-/**
- * Whether the captured `window.pbjs` carries the real Prebid.js API rather
- * than the head-injected `{ que, cmd }` stub left behind when the external
- * bundle fails to load.
- */
-function hasPrebidJsApi(): boolean {
-  return typeof (pbjs as { registerBidAdapter?: unknown }).registerBidAdapter === 'function';
-}
-
-function hasApsRendererApi(): boolean {
-  return typeof (pbjs as { markWinningBidAsUsed?: unknown }).markWinningBidAsUsed === 'function';
-}
-
-const ADAPTER_CODE = 'trustedServer';
-const APS_BIDDER_CODE = 'aps';
-// Carrier field for the APS bid-by-reference renderer descriptor: set by
-// `auctionBidsToPrebidBids` (interpretResponse), consumed and scrubbed by the
-// registry listener installed in `installApsBidResponseRegistry`.
-//
-// The descriptor is deliberately carried twice on each built bid — as this
-// custom top-level field and as `meta[APS_RENDERER_FIELD]`:
-// - `meta` is a first-class Prebid bid field (bidderFactory assigns
-//   `bid.meta = bidResponse.meta` onto the normalized bid, the same guarantee
-//   `requestId` has), so it survives builds whose normalization drops unknown
-//   top-level fields (observed in production: the top-level field was absent
-//   as early as `bidAccepted`).
-// - The top-level copy is kept as belt-and-braces for builds that preserve it
-//   (the vendored prebid.js does) against a future build filtering `meta`
-//   sub-keys instead.
-// The listener registers whichever copy it finds and unconditionally scrubs
-// both after the registration attempt.
-const APS_RENDERER_FIELD = 'trustedServerRenderer';
-const APS_BID_RESPONSE_LISTENER_SENTINEL = '__tsApsBidResponseListenerInstalled';
-// OpenRTB permits vendor-specific agent types; PAIR uses 571187.
-// Keep this range aligned with the signed 32-bit Rust/OpenRTB representation.
-const MAX_OPENRTB_ATYPE = 2_147_483_647;
-const BIDDER_PARAMS_KEY = 'bidderParams';
-const ZONE_KEY = 'zone';
-const TS_REFRESH_TARGETING_KEYS = [
-  'ts_initial',
-  'hb_pb',
-  'hb_bidder',
-  'hb_adid',
-  'hb_cache_host',
-  'hb_cache_path',
-] as const;
-const MAX_PUBLISHER_AD_UNIT_SNAPSHOTS = 256;
-const MAX_PENDING_PUBLISHER_BIDS = 2048;
-const PENDING_PUBLISHER_DELIVERY_TTL_MS = FIRST_IMPRESSION_LEASE_MS;
-
-/** Configuration options for the Prebid integration. */
-export interface PrebidNpmConfig {
-  /** Auction endpoint path. Defaults to '/auction'. */
-  endpoint?: string;
-  /** Server-side bid timeout in milliseconds. Defaults to 1000. */
-  timeout?: number;
-  /** Enable Prebid.js debug logging. Defaults to false. */
-  debug?: boolean;
-}
-
-/**
- * Shape of the server-injected config at `window.__tsjs_prebid`.
- * Set by the Rust IntegrationHeadInjector from trusted-server.toml values.
- */
-interface InjectedPrebidConfig {
-  accountId?: string;
-  timeout?: number;
-  debug?: boolean;
-  /** Validated browser bidder route codes owned by the server auction plan. */
-  serverSideBidders?: string[];
-  /** Bidders that run client-side via native Prebid.js adapters. */
-  clientSideBidders?: string[];
-  /** GAM ad-unit-path suffixes excluded from refresh auctions. */
-  excludedGamAdUnitPathSuffixes?: string[];
-}
-
-interface PrebidUserIdDiagnostics {
-  includedModules: string[];
-  configuredUserIdNames: string[];
-  missingConfiguredUserIdNames: string[];
-}
-
-/** Read server-injected config from window.__tsjs_prebid, if present. */
-export function getInjectedConfig(): InjectedPrebidConfig | undefined {
-  if (typeof window !== 'undefined') {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (window as any).__tsjs_prebid as InjectedPrebidConfig | undefined;
-  }
-  return undefined;
-}
-
-function injectedServerSideBidderCodes(config = getInjectedConfig()): string[] {
-  return config?.serverSideBidders ?? [];
-}
-
-/** Collect all unique bidder codes from the provided ad units. */
-export function collectBidders(adUnits: Array<{ bids?: Array<{ bidder?: string }> }>): string[] {
-  const bidders = new Set<string>();
-  for (const unit of adUnits) {
-    if (unit.bids) {
-      for (const bid of unit.bids) {
-        if (bid.bidder) {
-          bidders.add(bid.bidder);
-        }
-      }
-    }
-  }
-  return [...bidders];
-}
-
-function configuredUserIdNamesFromConfig(config: unknown): string[] {
-  const userIds = Array.isArray(config)
-    ? config
-    : config && typeof config === 'object'
-      ? ((
-          config as {
-            userSync?: { userIds?: Array<{ name?: unknown }> };
-            userIds?: Array<{ name?: unknown }>;
-          }
-        ).userSync?.userIds ?? (config as { userIds?: Array<{ name?: unknown }> }).userIds)
-      : undefined;
-
-  if (!Array.isArray(userIds)) {
-    return [];
-  }
-
-  return [
-    ...new Set(
-      userIds
-        .map((entry) => entry?.name)
-        .filter((name): name is string => typeof name === 'string' && name.length > 0)
-    ),
-  ].sort();
-}
-
-function readConfiguredUserIdNames(): string[] {
-  const getConfig = (pbjs as unknown as { getConfig?: (key?: string) => unknown }).getConfig;
-  if (typeof getConfig !== 'function') {
-    return [];
-  }
-
-  return configuredUserIdNamesFromConfig(getConfig('userSync.userIds')).concat(
-    configuredUserIdNamesFromConfig(getConfig())
-  );
-}
-
-/** Warn-once flag for an unstamped User ID manifest; reset by installPrebidNpm. */
-let warnedMissingUserIdManifest = false;
-
-function recordUserIdModuleDiagnostics(): PrebidUserIdDiagnostics {
-  const manifestUserIdModules = getExternalBundleManifest()?.userIdModules;
-  const includedUserIdModules = manifestUserIdModules ?? [];
-  const configuredUserIdNames = [...new Set(readConfiguredUserIdNames())].sort();
-  const coveredConfigNames = new Set(
-    PREBID_USER_ID_MODULE_REGISTRY.filter((entry) =>
-      includedUserIdModules.includes(entry.moduleName)
-    ).flatMap((entry) => entry.configNames)
-  );
-  // An older or unstamped bundle must not make every configured module look
-  // absent: warn once about the missing manifest instead of once per module,
-  // mirroring the client-side adapter validation in installPrebidNpm.
-  const missingConfiguredUserIdNames =
-    manifestUserIdModules === undefined
-      ? []
-      : configuredUserIdNames.filter((name) => !coveredConfigNames.has(name));
-  if (
-    manifestUserIdModules === undefined &&
-    configuredUserIdNames.length > 0 &&
-    !warnedMissingUserIdManifest
-  ) {
-    warnedMissingUserIdManifest = true;
-    log.warn(
-      '[tsjs-prebid] external Prebid bundle did not stamp a User ID module manifest; ' +
-        'cannot verify configured User ID modules'
-    );
-  }
-
-  const diagnostics: PrebidUserIdDiagnostics = {
-    includedModules: [...includedUserIdModules],
-    configuredUserIdNames,
-    missingConfiguredUserIdNames,
-  };
-
-  const previouslyMissingConfiguredUserIdNames = new Set<string>();
-  if (typeof window !== 'undefined') {
-    const tsjsWindow = window as typeof window & {
-      __tsjs_prebid_diagnostics?: { userIdModules?: PrebidUserIdDiagnostics };
-    };
-    for (const name of tsjsWindow.__tsjs_prebid_diagnostics?.userIdModules
-      ?.missingConfiguredUserIdNames ?? []) {
-      previouslyMissingConfiguredUserIdNames.add(name);
-    }
-    tsjsWindow.__tsjs_prebid_diagnostics = {
-      ...(tsjsWindow.__tsjs_prebid_diagnostics ?? {}),
-      userIdModules: diagnostics,
-    };
-  }
-
-  for (const name of missingConfiguredUserIdNames) {
-    if (!previouslyMissingConfiguredUserIdNames.has(name)) {
-      log.warn(
-        `[tsjs-prebid] configured User ID module "${name}" is not included in the external bundle`
-      );
-    }
-  }
-
-  return diagnostics;
-}
-
-// ---------------------------------------------------------------------------
-// trustedServer bid adapter helpers
-// ---------------------------------------------------------------------------
-
-/** Resolved endpoint — set by installPrebidNpm, read by the adapter. */
-let auctionEndpoint = '/auction';
-
-/**
- * Convert parsed {@link AuctionBid}s into Prebid bid response objects,
- * linking each bid back to the original BidRequest via `requestId`.
- */
-export function auctionBidsToPrebidBids(
-  auctionBids: AuctionBid[],
-  bidRequests: Array<{ adUnitCode?: string; code?: string; bidId?: string }>,
-  apsRendererSupported: boolean
-) {
-  // Build a lookup from impid (adUnitCode) → original bidRequest
-  const requestsByCode = new Map<string, (typeof bidRequests)[number]>();
-  for (const br of bidRequests) {
-    const code = br.adUnitCode ?? br.code ?? '';
-    if (!requestsByCode.has(code)) {
-      requestsByCode.set(code, br);
-    }
-  }
-
-  return auctionBids.flatMap((bid) => {
-    // A renderer bid cannot be delivered safely without Prebid's public
-    // lifecycle API. Ordinary Trusted Server bids remain eligible.
-    if (bid.renderer && !apsRendererSupported) {
-      return [];
-    }
-
-    // Prebid admission is the last point before the descriptor becomes a bid
-    // capability. Drop malformed APS bids rather than letting them participate
-    // in the auction without a render path.
-    const renderer = bid.renderer ? validateApsRenderer(bid.renderer) : undefined;
-    if (bid.renderer && !renderer) {
-      log.warn(`[tsjs-prebid] dropped invalid APS renderer bid for '${bid.impid}'`);
-      return [];
-    }
-
-    const origReq = requestsByCode.get(bid.impid);
-    return [
-      {
-        requestId: origReq?.bidId ?? bid.impid,
-        cpm: bid.price,
-        width: bid.width,
-        height: bid.height,
-        ad: renderer ? '' : bid.adm,
-        ...(renderer ? { [APS_RENDERER_FIELD]: renderer } : {}),
-        ttl: 300,
-        creativeId: bid.creativeId,
-        netRevenue: true,
-        currency: 'USD',
-        bidderCode: bid.seat,
-        meta: {
-          advertiserDomains: bid.adomain,
-          // Second descriptor carrier. See APS_RENDERER_FIELD for the rationale.
-          ...(renderer ? { [APS_RENDERER_FIELD]: renderer } : {}),
-        },
-      },
-    ];
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Installation / shim
-// ---------------------------------------------------------------------------
-
-type PbjsConfig = Parameters<typeof pbjs.setConfig>[0];
-
-type TrustedServerBid = { bidder?: string; params?: Record<string, unknown> };
-type BannerSize = [number, number];
-type TrustedServerBanner = { sizes: BannerSize[]; name?: string };
-type TrustedServerAdUnit = {
-  code?: string;
-  mediaTypes?: { banner?: TrustedServerBanner };
-  bids?: TrustedServerBid[];
-};
-type ClientSideBidSnapshot = { bidder: string; params: Record<string, unknown> };
-type PublisherAdUnitSnapshot = {
-  bidderParams: Record<string, Record<string, unknown>>;
-  clientSideBids: ClientSideBidSnapshot[];
-  zone?: string;
-};
-type PendingPublisherBid = {
-  adUnitCode: string;
-  expiresAt: number;
-  registrationId: number;
-  generation: number;
-  element: HTMLElement;
-  retainUntilContextChange: boolean;
-  firstImpressionToken?: string;
-};
-type PendingPublisherCode = {
-  adUnitCode: string;
-  expiresAt: number;
-  registrationId: number;
-  generation: number;
-  element: HTMLElement;
-  retainUntilContextChange: boolean;
-  firstImpressionToken?: string;
-};
-type RemoveAdUnit = (adUnitCode?: string | string[]) => unknown;
-type PrebidWithRemoveAdUnit = {
-  removeAdUnit?: RemoveAdUnit;
-  __tsRemoveAdUnitWrapped?: boolean;
-};
-
-let publisherAdUnitSnapshots = new Map<string, PublisherAdUnitSnapshot>();
-let pendingPublisherBids = new Map<string, PendingPublisherBid>();
-let pendingPublisherCodes = new Map<string, Map<number, PendingPublisherCode>>();
-let pendingPublisherRegistrationId = 0;
-let publisherFirstImpressionTokens = new Map<string, Set<string>>();
-let syntheticRefreshAdUnits = new WeakSet<TrustedServerAdUnit>();
-type TrustedServerBidRequest = {
-  adUnitCode?: string;
-  code?: string;
-  bidId?: string;
-};
-type TrustedServerRequest = {
-  method: 'POST';
-  url: string;
-  data: string;
-  options: { contentType: 'application/json' };
-  bidRequests: TrustedServerBidRequest[];
-  tsjsBidRequests: TrustedServerBidRequest[];
-};
-
-type PrebidUserIdEid = {
-  source?: unknown;
-  uids?: Array<{ id?: unknown; atype?: unknown; ext?: unknown }>;
-};
-
-type RefreshGptSlot = {
-  getSlotElementId?: () => string;
-  getAdUnitPath?: () => string;
-  getTargeting?: (key: string) => string[];
-  setTargeting?: (key: string, value: string | string[]) => RefreshGptSlot;
-  clearTargeting?: (key?: string) => RefreshGptSlot;
-  getSizes?: () => unknown[];
-};
-
-function recordPrebidRefreshForDiagnostics(slots: RefreshGptSlot[]): void {
-  try {
-    window.tsjs?.gptDiagnosticsRecorder?.recordPrebidRefresh(slots);
-  } catch {
-    // Diagnostics must not suppress the GAM request.
-  }
-}
-
-function dispatchPrebidRefresh<T>(
-  refresh: (slots?: unknown[], opts?: unknown) => T,
-  slots: unknown[] | undefined,
-  opts: unknown
-): T {
-  let tsjs: TsjsApi | undefined;
-  let hadOwnContext = false;
-  let previousContext: boolean | undefined;
-  let shouldRestoreContext = false;
-  try {
-    tsjs = window.tsjs;
-    if (tsjs) {
-      hadOwnContext = Object.prototype.hasOwnProperty.call(tsjs, 'prebidRefreshDispatchInProgress');
-      previousContext = tsjs.prebidRefreshDispatchInProgress;
-      shouldRestoreContext = true;
-      tsjs.prebidRefreshDispatchInProgress = true;
-    }
-  } catch {
-    // Diagnostics context must not affect refresh delegation.
-  }
-  try {
-    return refresh(slots, opts);
-  } finally {
-    if (shouldRestoreContext && tsjs) {
-      try {
-        if (hadOwnContext) {
-          tsjs.prebidRefreshDispatchInProgress = previousContext;
-        } else {
-          delete tsjs.prebidRefreshDispatchInProgress;
-        }
-      } catch {
-        // Diagnostics context restoration must not mask a refresh result or throw.
-      }
-    }
-  }
-}
-
-const DEFAULT_REFRESH_SIZES: BannerSize[] = [
-  [728, 90],
-  [300, 250],
-];
-
-function sanitizeAuctionUid(uid: {
-  id?: unknown;
-  atype?: unknown;
-  ext?: unknown;
-}): AuctionEid['uids'][number] | undefined {
-  if (typeof uid?.id !== 'string' || uid.id.length === 0) {
-    return undefined;
-  }
-
-  const sanitizedUid: AuctionEid['uids'][number] = { id: uid.id };
-
-  if (
-    typeof uid.atype === 'number' &&
-    Number.isInteger(uid.atype) &&
-    uid.atype >= 0 &&
-    uid.atype <= MAX_OPENRTB_ATYPE
-  ) {
-    sanitizedUid.atype = uid.atype;
-  }
-
-  if (uid.ext && typeof uid.ext === 'object' && !Array.isArray(uid.ext)) {
-    sanitizedUid.ext = uid.ext as Record<string, unknown>;
-  }
-
-  return sanitizedUid;
-}
-
-function isDefined<T>(value: T | undefined): value is T {
-  return value !== undefined;
-}
-
-function isPositiveFiniteNumber(value: unknown): value is number {
-  return typeof value === 'number' && Number.isFinite(value) && value > 0;
-}
-
-function parseBannerSize(size: unknown): BannerSize | undefined {
-  if (Array.isArray(size) && isPositiveFiniteNumber(size[0]) && isPositiveFiniteNumber(size[1])) {
-    return [size[0], size[1]];
-  }
-
-  const gptSize = size as { getWidth?: () => unknown; getHeight?: () => unknown };
-  const width = gptSize?.getWidth?.();
-  const height = gptSize?.getHeight?.();
-  if (isPositiveFiniteNumber(width) && isPositiveFiniteNumber(height)) {
-    return [width, height];
-  }
-
-  return undefined;
-}
-
-function bannerSizesFromGptSlot(slot: RefreshGptSlot): BannerSize[] | undefined {
-  const sizes = slot.getSizes?.();
-  if (!Array.isArray(sizes)) {
-    return undefined;
-  }
-
-  const parsedSizes = sizes.map(parseBannerSize).filter(isDefined);
-  return parsedSizes.length > 0 ? parsedSizes : undefined;
-}
-
-function bannerSizesFromInjectedSlot(slot: AuctionSlot | undefined): BannerSize[] | undefined {
-  const parsedSizes = slot?.formats?.map(parseBannerSize).filter(isDefined) ?? [];
-  return parsedSizes.length > 0 ? parsedSizes : undefined;
-}
-
-function refreshSlotElementId(slot: RefreshGptSlot): string | undefined {
-  const elementId = slot.getSlotElementId?.();
-  return elementId && elementId.length > 0 ? elementId : undefined;
-}
-
-function findInjectedSlotForRefresh(slot: RefreshGptSlot): AuctionSlot | undefined {
-  const elementId = refreshSlotElementId(slot);
-  if (!elementId) {
-    return undefined;
-  }
-
-  const slots = window.tsjs?.adSlots;
-  if (!slots) {
-    return undefined;
-  }
-
-  // Prefer an exact (or container) match across all slots before the prefix
-  // fallback, so prefix-overlapping div_ids (e.g. "ad" and "ad-header") resolve
-  // to the correct slot instead of the first slot whose div_id is a prefix.
-  return (
-    slots.find(
-      (adSlot) => elementId === adSlot.div_id || elementId === `${adSlot.div_id}-container`
-    ) ?? slots.find((adSlot) => adSlot.div_id.length > 0 && elementId.startsWith(adSlot.div_id))
-  );
-}
-
-function firstTargetingValue(values: string[] | undefined): string | undefined {
-  return values?.find((value) => value.length > 0);
-}
-
-/** Store a snapshot and evict the least-recently used entry when capacity is exceeded. */
-function storePublisherAdUnitSnapshot(code: string, snapshot: PublisherAdUnitSnapshot): void {
-  publisherAdUnitSnapshots.delete(code);
-  publisherAdUnitSnapshots.set(code, snapshot);
-
-  if (publisherAdUnitSnapshots.size > MAX_PUBLISHER_AD_UNIT_SNAPSHOTS) {
-    const oldestCode = publisherAdUnitSnapshots.keys().next().value;
-    if (oldestCode !== undefined) publisherAdUnitSnapshots.delete(oldestCode);
-  }
-}
-
-/** Find and touch a request-scoped publisher snapshot by candidate code. */
-function findRefreshSnapshot(
-  candidateCodes: Array<string | undefined>
-): PublisherAdUnitSnapshot | undefined {
-  for (const code of candidateCodes) {
-    if (!code) continue;
-    const snapshot = publisherAdUnitSnapshots.get(code);
-    if (!snapshot) continue;
-    publisherAdUnitSnapshots.delete(code);
-    publisherAdUnitSnapshots.set(code, snapshot);
-    return snapshot;
-  }
-  return undefined;
-}
-
-/**
- * Find the publisher's live `pbjs.adUnits` entry for a refreshing slot.
- *
- * A TS-owned GPT slot may be defined on `${div_id}-container`, so the GPT
- * element id used as the synthetic refresh ad unit code can differ from the
- * inner `div_id` the publisher keyed their Prebid ad unit by. Try each candidate
- * code in order and return the first matching ad unit, so container-backed slots
- * still recover the publisher's configured params and bidders.
- */
-function findRefreshAdUnit(
-  candidateCodes: Array<string | undefined>
-): TrustedServerAdUnit | undefined {
-  const adUnits = (pbjs.adUnits ?? []) as TrustedServerAdUnit[];
-  for (const code of candidateCodes) {
-    if (!code) continue;
-    const match = adUnits.find((unit) => unit.code === code);
-    if (match) return match;
-  }
-  return undefined;
-}
-
-/** Deep-copy plain publisher params while preserving cycles and non-plain values. */
-function copyParamValue(value: unknown, seen = new WeakMap<object, unknown>()): unknown {
-  if (Array.isArray(value)) {
-    const existing = seen.get(value);
-    if (existing) return existing;
-    const copy: unknown[] = [];
-    seen.set(value, copy);
-    value.forEach((entry) => copy.push(copyParamValue(entry, seen)));
-    return copy;
-  }
-
-  if (value && typeof value === 'object') {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) return value;
-
-    const existing = seen.get(value);
-    if (existing) return existing;
-    const copy = Object.create(prototype) as Record<string, unknown>;
-    seen.set(value, copy);
-    for (const [key, entry] of Object.entries(value)) {
-      Object.defineProperty(copy, key, {
-        value: copyParamValue(entry, seen),
-        enumerable: true,
-        configurable: true,
-        writable: true,
-      });
-    }
-    return copy;
-  }
-
-  return value;
-}
-
-function copyParams(params: Record<string, unknown> | undefined): Record<string, unknown> {
-  return copyParamValue(params ?? {}) as Record<string, unknown>;
-}
-
-/** Copy only plan-owned bidder params previously folded into a `trustedServer` bid. */
-function foldedBidderParams(
-  bid: TrustedServerBid | undefined,
-  serverSideBidders: Set<string>
-): Record<string, Record<string, unknown>> {
-  const folded = (bid?.params?.[BIDDER_PARAMS_KEY] ?? {}) as Record<
-    string,
-    Record<string, unknown>
-  >;
-  return Object.fromEntries(
-    Object.entries(folded)
-      .filter(([bidder]) => serverSideBidders.has(bidder))
-      .map(([bidder, params]) => [bidder, copyParams(params)])
-  );
-}
-
-/** Capture immutable request-scoped bidder and zone data before the shim mutates an ad unit. */
-function capturePublisherAdUnitSnapshot(
-  unit: TrustedServerAdUnit,
-  clientSideBidders: Set<string>,
-  serverSideBidders: Set<string>
-): PublisherAdUnitSnapshot | undefined {
-  if (typeof unit.code !== 'string' || unit.code.length === 0) return undefined;
-
-  const rawBidderParams = Object.create(null) as Record<string, Record<string, unknown>>;
-  const clientSideBids: ClientSideBidSnapshot[] = [];
-  let existingTsBid: TrustedServerBid | undefined;
-
-  const bids = Array.isArray(unit.bids) ? unit.bids : [];
-  for (const bid of bids) {
-    if (!bid?.bidder) continue;
-    if (bid.bidder === ADAPTER_CODE) {
-      existingTsBid ??= bid;
-      continue;
-    }
-    if (!serverSideBidders.has(bid.bidder)) {
-      if (clientSideBidders.has(bid.bidder)) {
-        clientSideBids.push({ bidder: bid.bidder, params: copyParams(bid.params) });
-      }
-      continue;
-    }
-    rawBidderParams[bid.bidder] = copyParams(bid.params);
-  }
-
-  const bidderParams =
-    Object.keys(rawBidderParams).length > 0
-      ? rawBidderParams
-      : foldedBidderParams(existingTsBid, serverSideBidders);
-  const zone = unit.mediaTypes?.banner?.name;
-
-  return {
-    bidderParams,
-    clientSideBids,
-    ...(zone ? { zone } : {}),
-  };
-}
-
-/**
- * Collect the configured client-side bidder entries for a refreshing slot.
- *
- * Synthetic refresh ad units carry only the `trustedServer` bid. The
- * `requestBids` shim preserves a client-side bidder only when its bid entry is
- * already present on the ad unit, so without re-attaching them here publishers
- * that split demand between server-side and native Prebid adapters would lose
- * all client-side demand on refresh/scroll impressions. A live exact
- * `pbjs.adUnits` match is authoritative; request-scoped snapshots are used only
- * when no live unit exists.
- */
-function clientSideBidsForRefresh(
-  candidateCodes: Array<string | undefined>
-): Array<{ bidder: string; params: Record<string, unknown> }> {
-  const clientSideBidders = new Set(getInjectedConfig()?.clientSideBidders ?? []);
-  const match = findRefreshAdUnit(candidateCodes);
-  if (match) {
-    if (clientSideBidders.size === 0 || !Array.isArray(match.bids)) return [];
-
-    const bids: Array<{ bidder: string; params: Record<string, unknown> }> = [];
-    for (const bid of match.bids) {
-      if (bid?.bidder && clientSideBidders.has(bid.bidder)) {
-        bids.push({ bidder: bid.bidder, params: copyParams(bid.params) });
-      }
-    }
-    return bids;
-  }
-
-  const snapshot = findRefreshSnapshot(candidateCodes);
-  return (
-    snapshot?.clientSideBids.map((bid) => ({
-      bidder: bid.bidder,
-      params: copyParams(bid.params),
-    })) ?? []
-  );
-}
-
-/**
- * Recover the publisher's inline server-side (PBS) bidder params for a slot.
- *
- * The synthetic refresh ad unit carries only the `trustedServer` bid, so the
- * `requestBids` shim has no original server-side bidder entries to collect into
- * `bidderParams` — without this, refresh/scroll `/auction` requests send `{}`
- * and lose demand the publisher configured only on the initial ad unit. A live
- * exact `pbjs.adUnits` match is authoritative and covers both raw bidder entries
- * and params already folded into a `trustedServer` bid. A request-scoped
- * snapshot is used only when no live unit exists.
- */
-function serverSideBidderParamsForRefresh(
-  candidateCodes: Array<string | undefined>
-): Record<string, Record<string, unknown>> {
-  const match = findRefreshAdUnit(candidateCodes);
-  if (match) {
-    if (!Array.isArray(match.bids)) return {};
-
-    const serverSideBidders = new Set(injectedServerSideBidderCodes());
-    const params = Object.create(null) as Record<string, Record<string, unknown>>;
-
-    for (const bid of match.bids) {
-      if (!bid?.bidder) continue;
-      if (bid.bidder === ADAPTER_CODE) {
-        Object.assign(params, foldedBidderParams(bid, serverSideBidders));
-        continue;
-      }
-      if (!serverSideBidders.has(bid.bidder)) continue;
-      params[bid.bidder] = copyParams(bid.params);
-    }
-
-    return params;
-  }
-
-  const snapshot = findRefreshSnapshot(candidateCodes);
-  return snapshot
-    ? Object.fromEntries(
-        Object.entries(snapshot.bidderParams).map(([bidder, params]) => [
-          bidder,
-          copyParams(params),
-        ])
-      )
-    : {};
-}
-
-/** Return a live publisher zone, falling back to a request-scoped snapshot. */
-function publisherZoneForRefresh(candidateCodes: Array<string | undefined>): string | undefined {
-  const match = findRefreshAdUnit(candidateCodes);
-  return match ? match.mediaTypes?.banner?.name : findRefreshSnapshot(candidateCodes)?.zone;
-}
-
-function isUsableRefreshAuctionExclusionSuffix(suffix: unknown): suffix is string {
-  return typeof suffix === 'string' && suffix.startsWith('/') && suffix.length > 1;
-}
-
-function refreshAuctionExclusionSuffixes(value: unknown): string[] {
-  return Array.isArray(value) ? value.filter(isUsableRefreshAuctionExclusionSuffix) : [];
-}
-
-function isExcludedFromRefreshAuction(
-  slot: RefreshGptSlot,
-  excludedGamAdUnitPathSuffixes: readonly string[]
-): boolean {
-  if (excludedGamAdUnitPathSuffixes.length === 0) return false;
-
-  try {
-    const adUnitPath = slot.getAdUnitPath?.();
-    return (
-      typeof adUnitPath === 'string' &&
-      excludedGamAdUnitPathSuffixes.some((suffix) => adUnitPath.endsWith(suffix))
-    );
-  } catch {
-    // GPT path metadata is optional for this optimization. If it is unavailable,
-    // preserve normal refresh-auction behavior rather than suppressing demand.
-    return false;
-  }
-}
-
-function clearRefreshTargeting(slot: RefreshGptSlot): void {
-  if (typeof slot.clearTargeting !== 'function') return;
-
-  for (const key of TS_REFRESH_TARGETING_KEYS) {
-    slot.clearTargeting(key);
-  }
-}
-
-function restoreTrustedServerFirstImpressionTargeting(slot: RefreshGptSlot): void {
-  const ts = window.tsjs;
-  const injectedSlot = findInjectedSlotForRefresh(slot);
-  const element = [refreshSlotElementId(slot), injectedSlot?.div_id]
-    .filter((elementId): elementId is string => Boolean(elementId))
-    .map((elementId) => document.getElementById(elementId))
-    .find((candidate): candidate is HTMLElement =>
-      Boolean(candidate && ts && firstImpressionClaim(ts, candidate)?.owner === 'trusted_server')
-    );
-  const claim = ts && element ? firstImpressionClaim(ts, element) : undefined;
-  if (claim?.owner !== 'trusted_server' || !claim.targeting || !slot.setTargeting) return;
-  clearRefreshTargeting(slot);
-  for (const [key, value] of Object.entries(claim.targeting)) slot.setTargeting(key, value);
-}
-
-/** Track a first-impression token until its exact auction is consumed or abandoned. */
-function trackPublisherFirstImpressionToken(adUnitCode: string, token: string): void {
-  const tokens = publisherFirstImpressionTokens.get(adUnitCode) ?? new Set<string>();
-  tokens.add(token);
-  publisherFirstImpressionTokens.set(adUnitCode, tokens);
-}
-
-function forgetPublisherFirstImpressionToken(adUnitCode: string, token?: string): void {
-  const tokens = publisherFirstImpressionTokens.get(adUnitCode);
-  if (!tokens) return;
-  if (token === undefined) {
-    if (window.tsjs) {
-      for (const current of tokens) releasePublisherFirstImpressionAuction(window.tsjs, current);
-    }
-    publisherFirstImpressionTokens.delete(adUnitCode);
-    return;
-  }
-  tokens.delete(token);
-  if (tokens.size === 0) publisherFirstImpressionTokens.delete(adUnitCode);
-}
-
-/** Remove pending delivery state for an ad unit, optionally from one registration only. */
-function removePendingPublisherBidsForCode(adUnitCode: string, registrationId?: number): void {
-  const registrations = pendingPublisherCodes.get(adUnitCode);
-  if (registrations) {
-    if (registrationId === undefined) {
-      pendingPublisherCodes.delete(adUnitCode);
-    } else {
-      const pending = registrations.get(registrationId);
-      if (!pending?.retainUntilContextChange) registrations.delete(registrationId);
-      if (registrations.size === 0) pendingPublisherCodes.delete(adUnitCode);
-    }
-  }
-
-  for (const [adId, pendingBid] of pendingPublisherBids) {
-    if (
-      pendingBid.adUnitCode === adUnitCode &&
-      (registrationId === undefined || pendingBid.registrationId === registrationId) &&
-      (registrationId === undefined || !pendingBid.retainUntilContextChange)
-    ) {
-      pendingPublisherBids.delete(adId);
-      if (pendingBid.firstImpressionToken) {
-        forgetPublisherFirstImpressionToken(adUnitCode, pendingBid.firstImpressionToken);
-      }
-    }
-  }
-}
-
-function removeConsumedPublisherRegistration(adUnitCode: string, registrationId: number): void {
-  const registrations = pendingPublisherCodes.get(adUnitCode);
-  const pendingCode = registrations?.get(registrationId);
-  registrations?.delete(registrationId);
-  if (registrations?.size === 0) pendingPublisherCodes.delete(adUnitCode);
-
-  const tokens = new Set<string>();
-  if (pendingCode?.firstImpressionToken) tokens.add(pendingCode.firstImpressionToken);
-  for (const [adId, pendingBid] of pendingPublisherBids) {
-    if (pendingBid.adUnitCode !== adUnitCode || pendingBid.registrationId !== registrationId) {
-      continue;
-    }
-    pendingPublisherBids.delete(adId);
-    if (pendingBid.firstImpressionToken) tokens.add(pendingBid.firstImpressionToken);
-  }
-  for (const token of tokens) forgetPublisherFirstImpressionToken(adUnitCode, token);
-}
-
-function pendingPublisherContextIsCurrent(
-  pending: PendingPublisherBid | PendingPublisherCode
-): boolean {
-  return (
-    pending.generation === (window.tsjs?.navGeneration ?? 0) &&
-    pending.element.isConnected &&
-    document.getElementById(pending.element.id) === pending.element &&
-    resolvePublisherDeliveryElement(pending.adUnitCode) === pending.element
-  );
-}
-
-function resolvePublisherDeliveryElement(adUnitCode: string): HTMLElement | undefined {
-  const direct = resolveFirstImpressionElement(adUnitCode);
-  if (direct) return direct;
-
-  const gpt = (
-    window as unknown as {
-      googletag?: { pubads?(): { getSlots?(): RefreshGptSlot[] } };
-    }
-  ).googletag;
-  const matches = (gpt?.pubads?.().getSlots?.() ?? [])
-    .filter((slot) => {
-      const injectedSlot = findInjectedSlotForRefresh(slot);
-      return refreshSlotElementId(slot) === adUnitCode || injectedSlot?.div_id === adUnitCode;
-    })
-    .map((slot) => {
-      const elementId = refreshSlotElementId(slot);
-      return elementId ? document.getElementById(elementId) : null;
-    })
-    .filter((element): element is HTMLElement => Boolean(element?.isConnected));
-  return matches.length === 1 ? matches[0] : undefined;
-}
-
-function pendingPublisherContextMatchesSlot(
-  pending: PendingPublisherBid | PendingPublisherCode,
-  slot: RefreshGptSlot
-): boolean {
-  if (!pendingPublisherContextIsCurrent(pending)) return false;
-  const injectedSlot = findInjectedSlotForRefresh(slot);
-  return [refreshSlotElementId(slot), injectedSlot?.div_id]
-    .filter((code): code is string => typeof code === 'string' && code.length > 0)
-    .some((code) => {
-      const exact = document.getElementById(code);
-      return (
-        exact === pending.element ||
-        Boolean(exact && (pending.element.contains(exact) || exact.contains(pending.element))) ||
-        resolvePublisherDeliveryElement(code) === pending.element
-      );
-    });
-}
-
-/** Discard delivery state that outlived the publisher auction which created it. */
-function prunePendingPublisherBids(now = Date.now()): void {
-  for (const [adUnitCode, registrations] of pendingPublisherCodes) {
-    for (const [registrationId, pendingCode] of registrations) {
-      if (
-        !pendingPublisherContextIsCurrent(pendingCode) ||
-        (pendingCode.expiresAt <= now && !pendingCode.retainUntilContextChange)
-      ) {
-        registrations.delete(registrationId);
-      }
-    }
-    if (registrations.size === 0) pendingPublisherCodes.delete(adUnitCode);
-  }
-
-  for (const [adId, pendingBid] of pendingPublisherBids) {
-    if (
-      !pendingPublisherContextIsCurrent(pendingBid) ||
-      (pendingBid.expiresAt <= now && !pendingBid.retainUntilContextChange)
-    ) {
-      pendingPublisherBids.delete(adId);
-    }
-  }
-}
-
-/** Store a short-lived pending publisher ad-unit code without erasing overlaps. */
-function storePendingPublisherCode(pendingCode: PendingPublisherCode): void {
-  const registrations = pendingPublisherCodes.get(pendingCode.adUnitCode) ?? new Map();
-  registrations.set(pendingCode.registrationId, pendingCode);
-  pendingPublisherCodes.set(pendingCode.adUnitCode, registrations);
-
-  let registrationCount = 0;
-  for (const pending of pendingPublisherCodes.values()) registrationCount += pending.size;
-  if (registrationCount > MAX_PENDING_PUBLISHER_BIDS) {
-    for (const [adUnitCode, pendingRegistrations] of pendingPublisherCodes) {
-      const evictable = [...pendingRegistrations.values()].find(
-        (pending) => !pending.retainUntilContextChange
-      );
-      if (!evictable) continue;
-      removePendingPublisherBidsForCode(adUnitCode, evictable.registrationId);
-      break;
-    }
-  }
-}
-
-/** Store an auction-local bid ID for precise one-shot GPT delivery correlation. */
-function storePendingPublisherBid(adId: string, pendingBid: PendingPublisherBid): void {
-  pendingPublisherBids.delete(adId);
-  pendingPublisherBids.set(adId, pendingBid);
-
-  if (pendingPublisherBids.size > MAX_PENDING_PUBLISHER_BIDS) {
-    const oldestAdId = pendingPublisherBids.keys().next().value;
-    if (oldestAdId !== undefined) pendingPublisherBids.delete(oldestAdId);
-  }
-}
-
-function publisherResponseAdIds(
-  publisherAdUnitCodes: Set<string>,
-  bidResponses: unknown
-): Map<string, string[]> {
-  const adIds = new Map<string, string[]>();
-  if (!bidResponses || typeof bidResponses !== 'object' || Array.isArray(bidResponses))
-    return adIds;
-
-  for (const [responseCode, responseGroup] of Object.entries(bidResponses)) {
-    if (!responseGroup || typeof responseGroup !== 'object') continue;
-    const bids = (responseGroup as { bids?: unknown }).bids;
-    if (!Array.isArray(bids)) continue;
-    for (const bid of bids) {
-      if (!bid || typeof bid !== 'object') continue;
-      const response = bid as { adId?: unknown; adUnitCode?: unknown };
-      const adId = typeof response.adId === 'string' ? response.adId : undefined;
-      const adUnitCode =
-        typeof response.adUnitCode === 'string' ? response.adUnitCode : responseCode;
-      if (!adId || !adUnitCode || !publisherAdUnitCodes.has(adUnitCode)) continue;
-      adIds.set(adUnitCode, [...(adIds.get(adUnitCode) ?? []), adId]);
-    }
-  }
-  return adIds;
-}
-
-/** Register every requested publisher code and any bid IDs returned for that auction. */
-function registerPendingPublisherBids(
-  publisherAdUnitCodes: Set<string>,
-  bidResponses: unknown,
-  firstImpressionTokens: Map<string, string>
-): number {
-  prunePendingPublisherBids();
-  const registrationId = ++pendingPublisherRegistrationId;
-  const expiresAt = Date.now() + PENDING_PUBLISHER_DELIVERY_TTL_MS;
-  const responseAdIds = publisherResponseAdIds(publisherAdUnitCodes, bidResponses);
-
-  for (const adUnitCode of publisherAdUnitCodes) {
-    const element = resolvePublisherDeliveryElement(adUnitCode);
-    if (!element) continue;
-    const firstImpressionToken = firstImpressionTokens.get(adUnitCode);
-    const retainUntilContextChange = Boolean(
-      firstImpressionToken &&
-      window.tsjs &&
-      firstImpressionClaim(window.tsjs, element)?.owner === 'trusted_server'
-    );
-    storePendingPublisherCode({
-      adUnitCode,
-      expiresAt,
-      registrationId,
-      generation: window.tsjs?.navGeneration ?? 0,
-      element,
-      retainUntilContextChange,
-      firstImpressionToken,
-    });
-    if (firstImpressionToken && window.tsjs) {
-      markPublisherFirstImpressionDeliveryPending(
-        window.tsjs,
-        firstImpressionToken,
-        responseAdIds.get(adUnitCode) ?? []
-      );
-    }
-  }
-
-  for (const [adUnitCode, adIds] of responseAdIds) {
-    const element = resolvePublisherDeliveryElement(adUnitCode);
-    if (!element) continue;
-    const firstImpressionToken = firstImpressionTokens.get(adUnitCode);
-    const retainUntilContextChange = Boolean(
-      firstImpressionToken &&
-      window.tsjs &&
-      firstImpressionClaim(window.tsjs, element)?.owner === 'trusted_server'
-    );
-    for (const adId of adIds) {
-      storePendingPublisherBid(adId, {
-        adUnitCode,
-        expiresAt,
-        registrationId,
-        generation: window.tsjs?.navGeneration ?? 0,
-        element,
-        retainUntilContextChange,
-        firstImpressionToken,
-      });
-    }
-  }
-
-  return registrationId;
-}
-
-interface PublisherDeliveryPartition {
-  deliverySlots: Set<RefreshGptSlot>;
-  suppressedSlots: Set<RefreshGptSlot>;
-}
-
-/** Consume the equivalent one-shot suppression owned by the inner GPT wrapper. */
-function consumeGptPublisherRefreshSuppression(slot: RefreshGptSlot): void {
-  const elementId = refreshSlotElementId(slot);
-  const handoff = elementId ? window.tsjs?.gptSlotHandoffs?.[elementId] : undefined;
-  if (handoff?.suppressPublisherRefresh) handoff.suppressPublisherRefresh = false;
-}
-
-/** Restore TS targeting and consume any equivalent GPT-wrapper handoff. */
-function prepareSuppressedPublisherSlot(slot: RefreshGptSlot): void {
-  restoreTrustedServerFirstImpressionTargeting(slot);
-  consumeGptPublisherRefreshSuppression(slot);
-}
-
-/** Partition correlated publisher deliveries from one losing first-impression delivery. */
-function publisherDeliverySlots(targetSlots: RefreshGptSlot[]): PublisherDeliveryPartition {
-  prunePendingPublisherBids();
-  const deliverySlots = new Set<RefreshGptSlot>();
-  const suppressedSlots = new Set<RefreshGptSlot>();
-
-  for (const slot of targetSlots) {
-    const adIds = slot.getTargeting?.('hb_adid');
-    const pendingBid = Array.isArray(adIds)
-      ? adIds
-          .filter((adId): adId is string => typeof adId === 'string' && adId.length > 0)
-          .map((adId) => pendingPublisherBids.get(adId))
-          .find(
-            (bid): bid is PendingPublisherBid =>
-              bid !== undefined && pendingPublisherContextMatchesSlot(bid, slot)
-          )
-      : undefined;
-    const hasAdId =
-      Array.isArray(adIds) && adIds.some((adId) => typeof adId === 'string' && adId.length > 0);
-    const injectedSlot = findInjectedSlotForRefresh(slot);
-    const pendingCodeCandidates = [
-      ...new Map(
-        [refreshSlotElementId(slot), injectedSlot?.div_id]
-          .filter((code): code is string => typeof code === 'string' && code.length > 0)
-          .flatMap((code) => [...(pendingPublisherCodes.get(code)?.values() ?? [])])
-          .filter(
-            (pending) =>
-              pendingPublisherContextMatchesSlot(pending, slot) &&
-              (!hasAdId || pending.retainUntilContextChange)
-          )
-          .map((pending) => [pending.registrationId, pending] as const)
-      ).values(),
-    ].sort((left, right) => left.registrationId - right.registrationId);
-    const pendingCode = pendingCodeCandidates.length === 1 ? pendingCodeCandidates[0] : undefined;
-    const pending = pendingBid ?? pendingCode;
-    if (!pending) {
-      if (pendingCodeCandidates.some((candidate) => candidate.retainUntilContextChange)) {
-        suppressedSlots.add(slot);
-      }
-      continue;
-    }
-
-    const suppress =
-      pending.firstImpressionToken && window.tsjs
-        ? consumePublisherFirstImpressionDelivery(window.tsjs, pending.firstImpressionToken)
-        : false;
-    removeConsumedPublisherRegistration(pending.adUnitCode, pending.registrationId);
-    (suppress ? suppressedSlots : deliverySlots).add(slot);
-  }
-
-  return { deliverySlots, suppressedSlots };
-}
-
-/** Evict publisher state after Prebid removes one or more ad units. */
-function removePublisherState(adUnitCode?: string | string[]): void {
-  if (!adUnitCode) {
-    publisherAdUnitSnapshots.clear();
-    pendingPublisherBids.clear();
-    pendingPublisherCodes.clear();
-    for (const code of publisherFirstImpressionTokens.keys()) {
-      forgetPublisherFirstImpressionToken(code);
-    }
-    return;
-  }
-
-  const adUnitCodes = Array.isArray(adUnitCode) ? adUnitCode : [adUnitCode];
-  for (const code of adUnitCodes) {
-    publisherAdUnitSnapshots.delete(code);
-    removePendingPublisherBidsForCode(code);
-    forgetPublisherFirstImpressionToken(code);
-  }
-}
-
-function collectAuctionEids(): AuctionEid[] | undefined {
-  if (typeof pbjs.getUserIdsAsEids !== 'function') {
-    return undefined;
-  }
-
-  const rawEids = (pbjs.getUserIdsAsEids() ?? []) as PrebidUserIdEid[];
-  const eids: AuctionEid[] = [];
-
-  for (const eid of rawEids) {
-    if (typeof eid?.source !== 'string' || eid.source.length === 0) {
-      continue;
-    }
-
-    const uids = Array.isArray(eid.uids) ? eid.uids.map(sanitizeAuctionUid).filter(isDefined) : [];
-
-    if (uids.length === 0) {
-      continue;
-    }
-
-    eids.push({ source: eid.source, uids });
-  }
-
-  return eids.length > 0 ? eids : undefined;
-}
-
-/**
- * Install the Prebid integration.
- *
- * Registers the "trustedServer" bid adapter and shims `requestBids` so every
- * ad unit is also bid on by that adapter, routing through /auction.
- *
- * Config resolution (values from later sources override earlier ones):
- * 1. `window.__tsjs_prebid` — injected by the server from trusted-server.toml
- * 2. `config` argument — explicit overrides from the publisher's JS
- *
- * Idempotent per page: a `window.__tsjsPrebidShimInstalled` sentinel makes
- * repeat calls (double script inclusion, a bundle that still carries a
- * baked-in shim) a no-op instead of a double adapter registration.
- */
-function apsRendererCarrier(bid: Record<string, unknown>): unknown {
-  const renderer = bid[APS_RENDERER_FIELD];
-  if (renderer !== undefined) return renderer;
-  const meta = bid['meta'];
-  if (meta !== null && typeof meta === 'object') {
-    return (meta as Record<string, unknown>)[APS_RENDERER_FIELD];
-  }
-  return undefined;
-}
-
-function scrubApsRendererCarrier(bid: Record<string, unknown>): void {
-  delete bid[APS_RENDERER_FIELD];
-  const meta = bid['meta'];
-  if (meta !== null && typeof meta === 'object') {
-    delete (meta as Record<string, unknown>)[APS_RENDERER_FIELD];
-  }
-}
-
-function installApsBidResponseRegistry(): void {
-  const prebid = pbjs as typeof pbjs & Record<string, unknown>;
-  if (prebid[APS_BID_RESPONSE_LISTENER_SENTINEL] === true) return;
-
-  const registerRenderer = (rawBid: unknown): void => {
-    const bid = rawBid as Record<string, unknown>;
-    if (bid['adapterCode'] !== ADAPTER_CODE || bid['bidderCode'] !== APS_BIDDER_CODE) {
-      return;
-    }
-    const renderer = apsRendererCarrier(bid);
-    const adId = bid['adId'];
-    if (renderer === undefined || typeof adId !== 'string') {
-      return;
-    }
-
-    const registered = registerApsPrebidRenderer(adId, bid['adUnitCode'], renderer, bid['ttl'], {
-      // Prebid exposes only a public combined winner/rendered API. Keep it
-      // at the existing rendered lifecycle point so the bid is not reported
-      // rendered before Universal Creative receives its response.
-      markUsed: () => pbjs.markWinningBidAsUsed({ adId, events: true }),
-    });
-    // Keep the executable capability only in the bounded, one-time registry. Prebid
-    // still owns the generated ad ID and ordinary GAM targeting on this bid object.
-    scrubApsRendererCarrier(bid);
-    if (!registered) {
-      // Prebid can admit zero-CPM bids when `allowZeroCpmBids` is enabled.
-      // Its targeting selection rejects every negative CPM, so this bid cannot
-      // displace a renderable GAM candidate after registration fails.
-      bid['cpm'] = -1;
-      log.warn('[tsjs-prebid] rejected APS renderer capability that failed registration');
-    }
-  };
-
-  // Register on `bidAccepted`, the first event after Prebid assigns `adId`, so
-  // later event consumers cannot observe the executable descriptor. The
-  // `bidResponse` pass is a compatibility fallback.
-  pbjs.onEvent('bidAccepted', registerRenderer);
-  pbjs.onEvent('bidResponse', registerRenderer);
-  prebid[APS_BID_RESPONSE_LISTENER_SENTINEL] = true;
-}
-
-export function installPrebidNpm(config?: Partial<PrebidNpmConfig>): typeof pbjs {
-  // The prebid integration requires the external Prebid.js bundle
-  // (integrations.prebid.external_bundle_url). When it failed to load (network
-  // error, SRI mismatch) window.pbjs is still the head-injected stub with no
-  // API — installing the adapter is impossible, so bail out loudly.
-  if (!hasPrebidJsApi()) {
-    log.error(
-      '[tsjs-prebid] window.pbjs is missing the required Prebid.js API — the external ' +
-        'bundle failed to load or is incompatible. Prebid integration disabled.'
-    );
-    return pbjs;
-  }
-
-  const sentinelWindow =
-    typeof window === 'undefined' ? undefined : (window as { __tsjsPrebidShimInstalled?: boolean });
-  if (sentinelWindow?.__tsjsPrebidShimInstalled) {
-    return pbjs;
-  }
-  if (sentinelWindow) {
-    sentinelWindow.__tsjsPrebidShimInstalled = true;
-  }
-
-  warnedMissingUserIdManifest = false;
-  publisherAdUnitSnapshots = new Map();
-  pendingPublisherBids = new Map();
-  pendingPublisherCodes = new Map();
-  pendingPublisherRegistrationId = 0;
-  publisherFirstImpressionTokens = new Map();
-  syntheticRefreshAdUnits = new WeakSet();
-
-  const prebidWithRemoveAdUnit = pbjs as unknown as PrebidWithRemoveAdUnit;
-  if (!prebidWithRemoveAdUnit.__tsRemoveAdUnitWrapped) {
-    const originalRemoveAdUnit = prebidWithRemoveAdUnit.removeAdUnit;
-    if (typeof originalRemoveAdUnit === 'function') {
-      prebidWithRemoveAdUnit.removeAdUnit = function (adUnitCode?: string | string[]) {
-        const result = originalRemoveAdUnit.call(this, adUnitCode);
-        removePublisherState(adUnitCode);
-        return result;
-      };
-      prebidWithRemoveAdUnit.__tsRemoveAdUnitWrapped = true;
-    }
-  }
-
-  const injected = getInjectedConfig();
-  const merged: PrebidNpmConfig = {
-    endpoint: config?.endpoint,
-    timeout: config?.timeout ?? injected?.timeout,
-    debug: config?.debug ?? injected?.debug,
-  };
-
-  auctionEndpoint = merged.endpoint ?? '/auction';
-  const apsRendererSupported = hasApsRendererApi();
-  if (apsRendererSupported) {
-    installApsBidResponseRegistry();
-  } else {
-    log.warn('[tsjs-prebid] Prebid bundle lacks markWinningBidAsUsed; APS renderer bids disabled');
-  }
-
-  // Register the trustedServer adapter using pbjs.registerBidAdapter(null, code, spec)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  (pbjs as any).registerBidAdapter(undefined, ADAPTER_CODE, {
-    code: ADAPTER_CODE,
-    supportedMediaTypes: ['banner'],
-
-    isBidRequestValid(): boolean {
-      return true; // All requests are valid — orchestrator handles filtering
-    },
-
-    buildRequests(validBidRequests: TrustedServerBidRequest[]): TrustedServerRequest {
-      log.debug('[tsjs-prebid] buildRequests', { count: validBidRequests.length });
-      const requestScopedBidRequests = [...validBidRequests];
-      const hasUserIdApi = typeof pbjs.getUserIdsAsEids === 'function';
-      const auctionEids = collectAuctionEids();
-      if (hasUserIdApi && !auctionEids) {
-        clearPrebidEidsCookie();
-      }
-      const payload = buildAdRequest(validBidRequests, { eids: auctionEids });
-      return {
-        method: 'POST',
-        url: auctionEndpoint,
-        data: JSON.stringify(payload),
-        options: { contentType: 'application/json' },
-        // Keep bid requests on the request object so interpretResponse can
-        // map bids without relying on shared mutable adapter state.
-        bidRequests: requestScopedBidRequests,
-        tsjsBidRequests: requestScopedBidRequests,
-      };
-    },
-
-    interpretResponse(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      serverResponse: any,
-      request?: Partial<TrustedServerRequest>
-    ) {
-      const body = serverResponse?.body;
-      log.debug('[tsjs-prebid] interpretResponse', { hasSeatbid: !!body?.seatbid });
-      const auctionBids = parseAuctionResponse(body);
-      const bidRequests = request?.tsjsBidRequests ?? request?.bidRequests ?? [];
-      return auctionBidsToPrebidBids(auctionBids, bidRequests, apsRendererSupported);
-    },
-  });
-
-  const originalRequestBids = pbjs.requestBids.bind(pbjs);
-
-  // Browser demand ownership is explicit. Only validated auction-plan route
-  // codes are folded; every other publisher bidder entry remains in Prebid.js.
-  const clientSideBidders = new Set(injected?.clientSideBidders ?? []);
-  const serverSideBidders = new Set(injectedServerSideBidderCodes(injected));
-  if (clientSideBidders.size > 0) {
-    log.info('[tsjs-prebid] client-side bidders:', [...clientSideBidders]);
-  }
-  if (serverSideBidders.size > 0) {
-    log.info('[tsjs-prebid] server-side bidders:', [...serverSideBidders]);
-  }
-
-  // Shim requestBids to inject the trustedServer bidder into every ad unit
-  // so plan-owned server-side bids flow through the /auction orchestrator while
-  // every unowned bidder is left untouched.
-  pbjs.requestBids = function (requestObj?: Parameters<typeof originalRequestBids>[0]) {
-    log.debug('[tsjs-prebid] requestBids called');
-    recordUserIdModuleDiagnostics();
-
-    const opts = { ...(requestObj ?? {}) };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const explicitAdUnits = (opts as any).adUnits as TrustedServerAdUnit[] | undefined;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const requestedAdUnitCodes = Array.isArray((opts as any).adUnitCodes)
-      ? new Set(
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ((opts as any).adUnitCodes as unknown[]).filter(
-            (code): code is string => typeof code === 'string'
-          )
-        )
-      : undefined;
-    const adUnits = (explicitAdUnits ?? (pbjs.adUnits as TrustedServerAdUnit[]) ?? []).filter(
-      (unit) =>
-        explicitAdUnits !== undefined ||
-        requestedAdUnitCodes === undefined ||
-        requestedAdUnitCodes.has(unit.code ?? '')
-    );
-    const isSyntheticRefresh =
-      adUnits.length > 0 && adUnits.every((unit) => syntheticRefreshAdUnits.has(unit));
-    const publisherAdUnitCodes = new Set(
-      adUnits
-        .filter((unit) => !syntheticRefreshAdUnits.has(unit))
-        .map((unit) => unit.code)
-        .filter((code): code is string => typeof code === 'string' && code.length > 0)
-    );
-    const firstImpressionTokens =
-      !isSyntheticRefresh && !window.tsjs?.adInitRefreshInProgress
-        ? registerPublisherFirstImpressionAuctions(
-            (window.tsjs ??= {} as TsjsApi),
-            publisherAdUnitCodes
-          )
-        : new Map<string, string>();
-    for (const [adUnitCode, token] of firstImpressionTokens) {
-      trackPublisherFirstImpressionToken(adUnitCode, token);
-      window.setTimeout(
-        () => forgetPublisherFirstImpressionToken(adUnitCode, token),
-        PENDING_PUBLISHER_DELIVERY_TTL_MS
-      );
-    }
-
-    // Ensure every ad unit has a trustedServer bid entry
-    for (const unit of adUnits) {
-      if (!syntheticRefreshAdUnits.has(unit)) {
-        const snapshot = capturePublisherAdUnitSnapshot(unit, clientSideBidders, serverSideBidders);
-        if (snapshot && unit.code) {
-          storePublisherAdUnitSnapshot(unit.code, snapshot);
-        }
-      }
-
-      if (!Array.isArray(unit.bids)) {
-        unit.bids = [];
-      }
-
-      // Preserve params only for bidder codes owned by the validated auction
-      // plan. Provider IDs, returned seat aliases, APS renderer identity, and
-      // ordinary browser demand cannot enter the trustedServer envelope.
-      const bidderParams = Object.create(null) as Record<string, Record<string, unknown>>;
-      for (const bid of unit.bids) {
-        if (!bid?.bidder || !serverSideBidders.has(bid.bidder)) {
-          continue;
-        }
-        bidderParams[bid.bidder] = bid.params ?? {};
-      }
-
-      // Keep every unowned bid in browser demand, including configured native
-      // adapters and standard entries not claimed by the plan.
-      unit.bids = unit.bids.filter(
-        (bid) => bid?.bidder === ADAPTER_CODE || !serverSideBidders.has(bid?.bidder ?? '')
-      );
-
-      // WORKAROUND: Read the zone from mediaTypes.banner.name. This is NOT a
-      // standard Prebid.js field — publishers must add it as a custom property
-      // in their ad unit config. The server uses it to apply zone-specific
-      // bid-param overrides (e.g. mapping zones to s2s placement IDs).
-      // TODO: Replace with a proper zone signal once available.
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const zone = (unit as any).mediaTypes?.banner?.name as string | undefined;
-
-      const existingTsBid = unit.bids.find((b) => b.bidder === ADAPTER_CODE);
-      if (existingTsBid) {
-        const prevParams = { ...(existingTsBid.params ?? {}) };
-        delete prevParams[ZONE_KEY];
-
-        // On a second requestBids() with the same ad unit object, the
-        // server-side bidder entries were already filtered out of unit.bids
-        // by the prior call, so `bidderParams` is now empty. Retain the
-        // params captured on the first call instead of overwriting them with
-        // `{}`, which would drop the publisher's inline PBS params on refresh.
-        const prevBidderParams = foldedBidderParams(existingTsBid, serverSideBidders);
-        const effectiveBidderParams =
-          Object.keys(bidderParams).length > 0 ? bidderParams : prevBidderParams;
-
-        existingTsBid.params = {
-          ...prevParams,
-          [BIDDER_PARAMS_KEY]: effectiveBidderParams,
-          ...(zone ? { [ZONE_KEY]: zone } : {}),
-        };
-      } else {
-        unit.bids.push({
-          bidder: ADAPTER_CODE,
-          params: {
-            [BIDDER_PARAMS_KEY]: bidderParams,
-            ...(zone ? { [ZONE_KEY]: zone } : {}),
-          },
-        });
-      }
-    }
-
-    // Ensure the trustedServer adapter is allowed to return bids under any
-    // bidder code (e.g. "mocktioneer", "appnexus") from the server-side seat.
-    // Re-applied on every requestBids call so that publisher code that
-    // overwrites pbjs.bidderSettings doesn't drop our setting.
-    pbjs.bidderSettings = {
-      ...(pbjs.bidderSettings || {}),
-      [ADAPTER_CODE]: {
-        ...(pbjs.bidderSettings?.[ADAPTER_CODE] || {}),
-        allowAlternateBidderCodes: true,
-        allowedAlternateBidderCodes: ['*'],
-      },
-    };
-
-    // Chain a bidsBackHandler to collect Prebid User ID Module EIDs
-    // and persist them as a cookie for backend sync.
-    const originalBidsBack = opts.bidsBackHandler;
-    opts.bidsBackHandler = function (...args: unknown[]) {
-      syncPrebidEidsCookie();
-      const registrationId = isSyntheticRefresh
-        ? undefined
-        : registerPendingPublisherBids(publisherAdUnitCodes, args[0], firstImpressionTokens);
-      if (typeof originalBidsBack !== 'function') return;
-
-      try {
-        originalBidsBack.apply(this, args as Parameters<typeof originalBidsBack>);
-      } catch (error) {
-        if (registrationId !== undefined) {
-          publisherAdUnitCodes.forEach((code) =>
-            removePendingPublisherBidsForCode(code, registrationId)
-          );
-        }
-        for (const [adUnitCode, token] of firstImpressionTokens) {
-          releasePublisherFirstImpressionAuction(window.tsjs!, token);
-          forgetPublisherFirstImpressionToken(adUnitCode, token);
-        }
-        throw error;
-      }
-    };
-
-    try {
-      return originalRequestBids(opts);
-    } catch (error) {
-      for (const [adUnitCode, token] of firstImpressionTokens) {
-        releasePublisherFirstImpressionAuction(window.tsjs!, token);
-        forgetPublisherFirstImpressionToken(adUnitCode, token);
-      }
-      throw error;
-    }
-  };
-
-  // Apply initial configuration
-  const pbjsConfig: PbjsConfig & { bidderTimeout?: number } = {
-    debug: merged.debug ?? false,
-  };
-  if (typeof merged.timeout === 'number') {
-    pbjsConfig.bidderTimeout = merged.timeout;
-  }
-  pbjs.setConfig(pbjsConfig as PbjsConfig);
-
-  // processQueue() must be called after all modules are loaded when using
-  // prebid.js via NPM.
-  pbjs.processQueue();
-  recordUserIdModuleDiagnostics();
-
-  // Validate that every client-side bidder has its adapter compiled into the
-  // external Prebid.js bundle. The bundle stamps the registered bidder codes
-  // (including aliases such as adform/adformOpenRTB for the adf module) on
-  // window.__tsjs_prebid_bundle; a missing code means the bidder was listed
-  // in client_side_bidders but not included in the generated bundle, so it is
-  // silently dropped from both server-side and client-side auctions. Fall
-  // back to the module-name list for bundles stamped before bidderCodes.
-  const manifest = getExternalBundleManifest();
-  const bundledBidderCodes = manifest?.bidderCodes ?? manifest?.adapters;
-  if (bundledBidderCodes === undefined) {
-    if (clientSideBidders.size > 0) {
-      log.warn(
-        '[tsjs-prebid] external Prebid bundle did not stamp an adapter manifest; ' +
-          'cannot verify client_side_bidders adapters'
-      );
-    }
-  } else {
-    for (const bidder of clientSideBidders) {
-      if (!bundledBidderCodes.includes(bidder)) {
-        log.error(
-          `[tsjs-prebid] client-side bidder "${bidder}" has no adapter in the external ` +
-            'Prebid bundle. Add its adapter to [integrations.prebid.bundle].adapters in ' +
-            'trusted-server.toml and rebuild it with `ts prebid bundle`.'
-        );
-      }
-    }
-  }
-
-  log.info('[tsjs-prebid] prebid initialized with trustedServer adapter');
-
-  return pbjs;
-}
-
-// ─── Phase B: GPT scroll/refresh auction handler ──────────────────────────
-
-/**
- * Install the scroll/refresh auction handler.
- *
- * Wraps `googletag.pubads().refresh()` so that when the publisher's GPT
- * refresh policy fires (sticky anchor, viewability dwell, infinite scroll),
- * Prebid runs a fresh client-side auction for the refreshing slots before
- * the GAM call. TS-owned first-impression slots (`ts_initial=1`) are included
- * on later publisher refreshes, but stale TS server-side targeting is cleared
- * before fresh Prebid targeting is applied.
- *
- * Must be called after `installPrebidNpm()` and after GPT is loaded.
- * Idempotent: safe to call multiple times — wraps only once via a sentinel.
- */
-export function installRefreshHandler(timeoutMs = 1500): void {
-  if (typeof window === 'undefined') return;
-  const g = (
-    window as unknown as {
-      googletag?: {
-        cmd?: { push(fn: () => void): void };
-        pubads?(): {
-          refresh(slots?: unknown[], opts?: unknown): void;
-          getTargeting?(key: string): string[];
-        };
-      };
-    }
-  ).googletag;
-  if (!g?.cmd) return;
-
-  g.cmd.push(() => {
-    const pubads = g.pubads?.();
-    if (!pubads || (pubads as { __tsRefreshWrapped?: boolean }).__tsRefreshWrapped) return;
-    (pubads as { __tsRefreshWrapped?: boolean }).__tsRefreshWrapped = true;
-
-    const originalRefresh = pubads.refresh.bind(pubads);
-    pubads.refresh = function (slots?: unknown[], opts?: unknown) {
-      // For bare refresh() calls (no slots arg), get all registered slots from GPT
-      // so we can auction the same concrete slot list and avoid stale targeting.
-      const targetSlots = (
-        slots ??
-        (pubads as { getSlots?: () => unknown[] }).getSlots?.() ??
-        []
-      ).filter((slot): slot is RefreshGptSlot => typeof slot === 'object' && slot !== null);
-
-      // One-shot bypass for adInit()'s internal refresh: that refresh delivers
-      // freshly applied server-side targeting to GAM and must not be turned
-      // into a client-side auction (which would clear the TS targeting).
-      // Publisher-initiated refreshes of the same slots are not flagged and
-      // still run a fresh client-side auction below.
-      if (window.tsjs?.adInitRefreshInProgress) {
-        return originalRefresh(slots, opts);
-      }
-
-      if (!targetSlots.length || (slots !== undefined && targetSlots.length !== slots.length)) {
-        return originalRefresh(slots, opts);
-      }
-
-      const { deliverySlots, suppressedSlots } = publisherDeliverySlots(targetSlots);
-      suppressedSlots.forEach(prepareSuppressedPublisherSlot);
-      const remainingSlots = targetSlots.filter((slot) => !suppressedSlots.has(slot));
-      if (remainingSlots.length === 0) return;
-      const forwardedSlots = suppressedSlots.size > 0 ? remainingSlots : slots;
-      const independentSlots = remainingSlots.filter((slot) => !deliverySlots.has(slot));
-      if (independentSlots.length === 0) {
-        remainingSlots.forEach(consumeGptPublisherRefreshSuppression);
-        recordPrebidRefreshForDiagnostics(remainingSlots);
-        return dispatchPrebidRefresh(originalRefresh, forwardedSlots, opts);
-      }
-
-      // Clear stale Trusted Server/Prebid targeting from independent slots before
-      // filtering so excluded slots still receive a clean GAM refresh.
-      independentSlots.forEach(clearRefreshTargeting);
-
-      const excludedGamAdUnitPathSuffixes = refreshAuctionExclusionSuffixes(
-        getInjectedConfig()?.excludedGamAdUnitPathSuffixes
-      );
-      const auctionSlots = independentSlots.filter(
-        (slot) => !isExcludedFromRefreshAuction(slot, excludedGamAdUnitPathSuffixes)
-      );
-      if (!auctionSlots.length) {
-        const immediateSlotCodes = new Map<RefreshGptSlot, string>();
-        remainingSlots.forEach((slot) => {
-          const elementId = refreshSlotElementId(slot);
-          if (elementId) immediateSlotCodes.set(slot, elementId);
-        });
-        const immediateTokens = registerPublisherFirstImpressionAuctions(
-          (window.tsjs ??= {} as TsjsApi),
-          immediateSlotCodes.values()
-        );
-        const immediateSuppressedSlots = new Set<RefreshGptSlot>();
-        for (const [slot, elementId] of immediateSlotCodes) {
-          const token = immediateTokens.get(elementId);
-          if (token && window.tsjs && consumePublisherFirstImpressionDelivery(window.tsjs, token)) {
-            immediateSuppressedSlots.add(slot);
-          }
-        }
-        immediateSuppressedSlots.forEach(prepareSuppressedPublisherSlot);
-        const immediateSlots = remainingSlots.filter((slot) => !immediateSuppressedSlots.has(slot));
-        if (immediateSlots.length === 0) return;
-        immediateSlots.forEach(consumeGptPublisherRefreshSuppression);
-        const immediateForwardedSlots =
-          immediateSuppressedSlots.size > 0 ? immediateSlots : forwardedSlots;
-        return originalRefresh(immediateForwardedSlots, opts);
-      }
-
-      const adUnits = auctionSlots.map((slot) => {
-        const injectedSlot = findInjectedSlotForRefresh(slot);
-        const code = refreshSlotElementId(slot) ?? 'refresh-slot';
-        // A TS-owned slot may be defined on `${div_id}-container`, so the GPT
-        // element id used as the synthetic refresh code can differ from the
-        // inner `div_id` the publisher keyed their ad unit by. Recover from both.
-        const candidateCodes = [code, injectedSlot?.div_id];
-        const zone =
-          injectedSlot?.targeting?.[ZONE_KEY] ??
-          firstTargetingValue(slot.getTargeting?.(ZONE_KEY)) ??
-          publisherZoneForRefresh(candidateCodes);
-        const banner: TrustedServerBanner = {
-          sizes:
-            bannerSizesFromInjectedSlot(injectedSlot) ??
-            bannerSizesFromGptSlot(slot) ??
-            DEFAULT_REFRESH_SIZES,
-          ...(zone ? { name: zone } : {}),
-        };
-        const tsParams: Record<string, unknown> = zone ? { [ZONE_KEY]: zone } : {};
-        // Carry the publisher's inline server-side (PBS) bidder params captured
-        // on the initial ad unit so refresh/scroll auctions don't drop them.
-        const serverSideParams = serverSideBidderParamsForRefresh(candidateCodes);
-        if (Object.keys(serverSideParams).length > 0) {
-          tsParams[BIDDER_PARAMS_KEY] = serverSideParams;
-        }
-        return {
-          code,
-          mediaTypes: { banner },
-          bids: [
-            { bidder: ADAPTER_CODE, params: tsParams },
-            ...clientSideBidsForRefresh(candidateCodes),
-          ],
-        };
-      });
-
-      // Scope GPT targeting to just the synthetic refresh ad units. An unscoped
-      // call would set hb_* targeting on every ad unit with known bids, mutating
-      // unrelated GPT slots whose targeting this wrapper only cleared for
-      // `targetSlots` — leaving their next request dependent on stale state.
-      const refreshAdUnitCodes = adUnits.map((unit) => unit.code);
-      const refreshTs = (window.tsjs ??= {} as TsjsApi);
-      const refreshGeneration = refreshTs.navGeneration ?? 0;
-      const delayedRefreshCodes = new Map<RefreshGptSlot, string>();
-      const delayedRefreshElements = new Map<RefreshGptSlot, HTMLElement>();
-      remainingSlots.forEach((slot) => {
-        const elementId = refreshSlotElementId(slot);
-        if (elementId) delayedRefreshCodes.set(slot, elementId);
-        const element = elementId ? resolveFirstImpressionElement(elementId) : undefined;
-        if (element) delayedRefreshElements.set(slot, element);
-      });
-      const refreshFirstImpressionTokens = registerPublisherFirstImpressionAuctions(
-        refreshTs,
-        delayedRefreshCodes.values()
-      );
-      adUnits.forEach((unit) => syntheticRefreshAdUnits.add(unit));
-
-      // Preserve GPT Single Request Architecture: when a publisher refresh
-      // includes both already-targeted delivery slots and independent slots,
-      // delay the whole original list until the independent auction completes.
-      // A one-shot fallback prevents a failed Prebid callback from dropping any
-      // slots, and a late callback cannot issue a second GAM request.
-      let completed = false;
-      let fallbackTimer: ReturnType<typeof setTimeout> | undefined;
-      function completeRefresh(applyTargeting: boolean): void {
-        if (completed) return;
-        completed = true;
-        if (fallbackTimer !== undefined) clearTimeout(fallbackTimer);
-
-        // The publisher refresh itself started before this asynchronous auction.
-        // Reconcile its per-slot token only when the callback is ready to issue
-        // GPT: TS may have won an already-overlapping first impression while the
-        // auction was pending, while a publisher-first token prevents TS from
-        // claiming the slot midway through the same refresh.
-        const callbackFilteredSlots = new Set<RefreshGptSlot>();
-        const callbackSuppressedSlots = new Set<RefreshGptSlot>();
-        for (const slot of remainingSlots) {
-          const elementId = delayedRefreshCodes.get(slot);
-          const token = elementId ? refreshFirstImpressionTokens.get(elementId) : undefined;
-          const element = delayedRefreshElements.get(slot);
-          const contextIsStale = Boolean(
-            element &&
-            ((window.tsjs?.navGeneration ?? 0) !== refreshGeneration ||
-              !element.isConnected ||
-              document.getElementById(element.id) !== element)
-          );
-          const suppress = Boolean(
-            token && window.tsjs && consumePublisherFirstImpressionDelivery(window.tsjs, token)
-          );
-          if (contextIsStale) {
-            callbackFilteredSlots.add(slot);
-          } else if (suppress) {
-            callbackFilteredSlots.add(slot);
-            callbackSuppressedSlots.add(slot);
-          }
-        }
-        callbackSuppressedSlots.forEach(prepareSuppressedPublisherSlot);
-
-        const completedSlots = remainingSlots.filter((slot) => !callbackFilteredSlots.has(slot));
-        if (completedSlots.length === 0) return;
-        const completedAdUnitCodes = refreshAdUnitCodes.filter(
-          (_code, index) => !callbackFilteredSlots.has(auctionSlots[index])
-        );
-        if (applyTargeting) {
-          try {
-            pbjs.setTargetingForGPTAsync?.(completedAdUnitCodes);
-          } catch (error) {
-            log.error('[tsjs-prebid] refresh targeting failed', error);
-          }
-        }
-        completedSlots.forEach(consumeGptPublisherRefreshSuppression);
-        recordPrebidRefreshForDiagnostics(completedSlots);
-        // Preserve the publisher's original refresh form unless one losing
-        // first-impression slot was filtered. A delayed bare call must also
-        // become explicit so slots added after the auction snapshot cannot join.
-        const completedForwardedSlots =
-          slots === undefined || callbackFilteredSlots.size > 0 ? completedSlots : forwardedSlots;
-        dispatchPrebidRefresh(originalRefresh, completedForwardedSlots, opts);
-      }
-
-      try {
-        pbjs.requestBids({
-          adUnits,
-          bidsBackHandler: () => completeRefresh(true),
-          timeout: timeoutMs,
-        });
-        // A one-shot watchdog completes the GAM request even if Prebid never
-        // invokes its callback. Apply any bids available at that point before
-        // refreshing because Prebid's own timeout completion may run later.
-        if (!completed) {
-          fallbackTimer = setTimeout(() => completeRefresh(true), timeoutMs);
-        }
-      } catch (error) {
-        log.error('[tsjs-prebid] refresh auction failed', error);
-        completeRefresh(false);
-      }
-    };
-
-    log.info('[tsjs-prebid] GPT refresh handler installed');
-  });
-}
-
-/**
- * Configure identity sync behavior for the generated Prebid User ID modules.
- *
- * The external bundle generator statically imports the selected modules into
- * its generated entry. This post-window-load configuration controls when
- * those modules synchronize identities; it does not select or register modules.
- */
-export function installUserIdModules(): void {
-  try {
-    pbjs.setConfig({
-      userSync: {
-        syncEnabled: true,
-        filterSettings: {
-          all: { bidders: '*', filter: 'include' },
-        },
-        auctionDelay: 0,
-        syncsPerBidder: 5,
-        syncDelay: 3000,
-      },
-    });
-    log.info('[tsjs-prebid] userID modules configured');
-  } catch {
-    // pbjs not ready — userID modules will use defaults
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Prebid EID cookie sync
-// ---------------------------------------------------------------------------
-
-/** Maximum cookie payload size in bytes (leave room for other cookies). */
-const MAX_EID_COOKIE_BYTES = 3072;
-
-/** Cookie name for persisted Prebid EIDs. */
-const EID_COOKIE_NAME = 'ts-eids';
-
-/** Cookie max-age in seconds (1 day). */
-const EID_COOKIE_MAX_AGE = 86400;
-
-/** Clears any previously persisted Prebid EIDs cookie. */
-function clearPrebidEidsCookie(): void {
-  document.cookie = `${EID_COOKIE_NAME}=; Path=/; Secure; SameSite=Lax; Max-Age=0`;
-}
-
-function fitAuctionEidsToCookie(eids: AuctionEid[]): AuctionEid[] | undefined {
-  let payload = eids.map((eid) => ({ source: eid.source, uids: [...eid.uids] }));
-
-  while (payload.length > 0) {
-    const encoded = btoa(JSON.stringify(payload));
-    if (encoded.length <= MAX_EID_COOKIE_BYTES) {
-      return payload;
-    }
-
-    const last = payload[payload.length - 1];
-    if (last && last.uids.length > 1) {
-      last.uids = last.uids.slice(0, last.uids.length - 1);
-      continue;
-    }
-
-    payload = payload.slice(0, payload.length - 1);
-  }
-
-  return undefined;
-}
-
-/**
- * Collects EIDs from Prebid's User ID Module and writes them as a
- * base64-encoded OpenRTB-style JSON cookie (`ts-eids`) for backend ingestion
- * and auction fallback on later requests.
- */
-function syncPrebidEidsCookie(): void {
-  try {
-    if (typeof pbjs.getUserIdsAsEids !== 'function') {
-      // Without Prebid EIDs to forward, stale auction fallback IDs must not persist.
-      clearPrebidEidsCookie();
-      return;
-    }
-
-    const eids = collectAuctionEids();
-    if (!eids) {
-      clearPrebidEidsCookie();
-      return;
-    }
-
-    const payload = fitAuctionEidsToCookie(eids);
-    if (!payload) {
-      clearPrebidEidsCookie();
-      return;
-    }
-
-    const encoded = btoa(JSON.stringify(payload));
-    document.cookie = `${EID_COOKIE_NAME}=${encoded}; Path=/; Secure; SameSite=Lax; Max-Age=${EID_COOKIE_MAX_AGE}`;
-
-    log.debug(`[tsjs-prebid] synced ${payload.length} EID sources to cookie`);
-  } catch (err) {
-    log.warn('[tsjs-prebid] failed to sync EIDs cookie', err);
-  }
-}
-
-// Self-initialize when loaded in a browser (same pattern as other integrations).
 if (typeof window !== 'undefined') {
-  installPrebidNpm();
-  // When the external bundle failed to load, installPrebidNpm bailed out and
-  // pbjs.requestBids is undefined. Installing the refresh handler anyway
-  // would clear TS-applied GPT targeting on every publisher refresh and then
-  // fail to run the replacement auction — leave GPT untouched instead.
-  if (hasPrebidJsApi()) {
-    installRefreshHandler();
-    // The slim-Prebid lazy loader appends this bundle from a window.load
-    // handler, so `load` may already have fired by the time this code runs —
-    // waiting for it again would skip user ID setup entirely on that path.
-    if (document.readyState === 'complete') {
-      installUserIdModules();
-    } else {
-      window.addEventListener(
-        'load',
-        () => {
-          installUserIdModules();
-        },
-        { once: true }
-      );
-    }
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createPrebidIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
   }
 }
-
-export { pbjs };
-export default installPrebidNpm;
diff --git a/crates/trusted-server-js/lib/src/integrations/prebid/later.ts b/crates/trusted-server-js/lib/src/integrations/prebid/later.ts
new file mode 100644
index 000000000..954e746c7
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/prebid/later.ts
@@ -0,0 +1,103 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import { isPrebidIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type { NavigationSession } from '../../kernel/sessions';
+
+import {
+  createPrebidRefreshPolicy,
+  createPrebidSyntheticRefreshRunner,
+  preparePrebidRegisteredRefreshAuction,
+  type DeferredGoogletagRunner,
+  type DeferredPrebidRunner,
+  type PrebidRefreshPolicy,
+} from './refresh';
+
+interface GptLaterCapabilityV1 {
+  readonly adapter: DeferredGoogletagRunner;
+  readonly directAuctionUnitForSlot: (slot: object) => Readonly<object> | undefined;
+  readonly installRefreshPolicy: (policy: PrebidRefreshPolicy) => (() => void) | undefined;
+  readonly navigation: () => NavigationSession | undefined;
+}
+
+interface PrebidLaterCapabilityV1 {
+  readonly adapter: DeferredPrebidRunner;
+  readonly clientSideBidders: readonly string[];
+  readonly excludedGamAdUnitPathSuffixes: readonly string[];
+}
+
+/** Build the release-bound synthetic-refresh Prebid registration. */
+export function createPrebidLaterIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'prebid_later',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const runtime = interfaces['runtime.v1'];
+      const slots = interfaces['slots.v1'];
+      const gpt = interfaces['gpt.v1'] as GptLaterCapabilityV1 | undefined;
+      const prebid = interfaces['prebid.v1'] as PrebidLaterCapabilityV1 | undefined;
+      if (
+        !isPrebidIntegrationConfigV1(config) ||
+        typeof runtime !== 'object' ||
+        runtime === null ||
+        !Object.isFrozen(runtime) ||
+        typeof slots !== 'object' ||
+        slots === null ||
+        !Object.isFrozen(slots) ||
+        !gpt ||
+        !Object.isFrozen(gpt) ||
+        typeof gpt.installRefreshPolicy !== 'function' ||
+        typeof gpt.navigation !== 'function' ||
+        typeof gpt.directAuctionUnitForSlot !== 'function' ||
+        !prebid ||
+        !Object.isFrozen(prebid)
+      ) {
+        throw new TypeError('Prebid later capability graph is invalid');
+      }
+      const runner = createPrebidSyntheticRefreshRunner({
+        prebid: prebid.adapter,
+        prepareAuction: (physicalSlots) =>
+          preparePrebidRegisteredRefreshAuction({
+            clientSideBidders: prebid.clientSideBidders,
+            resolveAdUnit: gpt.directAuctionUnitForSlot,
+            slots: physicalSlots,
+          }),
+      });
+      const policy = createPrebidRefreshPolicy({
+        currentNavigation: gpt.navigation,
+        excludedGamAdUnitPathSuffixes: prebid.excludedGamAdUnitPathSuffixes,
+        googletag: gpt.adapter,
+        runSyntheticAuction: runner,
+      });
+      return Object.freeze({
+        activate: ({ onDispose }: IntegrationActivationContext) => {
+          const ownership: { release?: () => void } = {};
+          onDispose(() => {
+            ownership.release?.();
+            policy.dispose();
+          });
+          const release = gpt.installRefreshPolicy(policy);
+          if (!release) throw new TypeError('Prebid refresh policy is duplicated');
+          ownership.release = release;
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createPrebidLaterIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/prebid/module.ts b/crates/trusted-server-js/lib/src/integrations/prebid/module.ts
new file mode 100644
index 000000000..7baba131f
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/prebid/module.ts
@@ -0,0 +1,275 @@
+import type { BrowserAuctionBidV1, BrowserAuctionProjectionV1 } from '../../core/types';
+import {
+  createBrowserPrebidAdapter,
+  type PrebidAdapter,
+  type PrebidEventFacade,
+  type PrebidTrustedServerAuctionV1,
+  type PreparedTrustedBidV1,
+} from '../../adapters/prebid';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import {
+  persistentFirstDisplaySliceSelectedV1,
+  snapshotPersistentFirstDisplaySliceStateV1,
+} from '../../shared/takeover';
+import type { NavigationSession } from '../../kernel/sessions';
+import type { RuntimeCapabilityV1 } from '../../kernel/runtime';
+import { isPrebidIntegrationConfigV1 } from '../../shared/integration_config_validators';
+
+import { createPrebidStartup } from './startup';
+
+export const PREBID_INTEGRATION_ID = 'prebid' as const;
+export type { PreparedTrustedBidV1 } from '../../adapters/prebid';
+
+const arrayIsArrayIntrinsic = Array.isArray;
+const objectGetOwnPropertyDescriptorIntrinsic = Object.getOwnPropertyDescriptor;
+export interface PrebidCapabilityV1 {
+  readonly adapter: PrebidAdapter;
+  readonly clientSideBidders: readonly string[];
+  readonly excludedGamAdUnitPathSuffixes: readonly string[];
+}
+
+interface ProductionPrebidSelectionCoordinator {
+  readonly track: (
+    preparedBid: Readonly<PreparedTrustedBidV1>,
+    navigation: NavigationSession
+  ) => boolean;
+  readonly auctionEnded: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void;
+  readonly settlePublicationFailure: (
+    navigation: NavigationSession,
+    auctionId: string,
+    adUnitCode: string,
+    reason: 'prebid_admission_failed' | 'prebid_contract_violation'
+  ) => boolean;
+  readonly dispose: () => void;
+}
+
+interface ProductionPrebidPublicationInput {
+  readonly admitTrustedBid: (preparedBid: Readonly<PreparedTrustedBidV1>) => unknown;
+  readonly auctionId: string;
+  readonly adUnitCode: string;
+  readonly bid: BrowserAuctionBidV1;
+  readonly generatedBid: unknown;
+  readonly trackAdmittedBid: (
+    preparedBid: Readonly<PreparedTrustedBidV1>,
+    navigation: NavigationSession
+  ) => boolean;
+}
+
+type ProductionPrebidPublicationResult =
+  | Readonly<{ ok: true; bid: Readonly<PreparedTrustedBidV1> }>
+  | Readonly<{
+      ok: false;
+      reason:
+        | 'descriptor_invalid'
+        | 'prebid_admission_failed'
+        | 'prebid_contract_violation'
+        | 'registry_full'
+        | 'reservation_collision'
+        | 'winner_not_renderable';
+    }>;
+
+interface ProductionRenderCapability {
+  readonly createPrebidSelectionCoordinator: () => ProductionPrebidSelectionCoordinator;
+  readonly navigation: NavigationSession;
+  readonly publishPrebidBid: (
+    input: ProductionPrebidPublicationInput
+  ) => ProductionPrebidPublicationResult;
+  readonly projection: Readonly<BrowserAuctionProjectionV1>;
+}
+
+function configStringArray(config: unknown, key: string): readonly string[] {
+  if (typeof config !== 'object' || config === null) return Object.freeze([]);
+  const descriptor = objectGetOwnPropertyDescriptorIntrinsic(config, key);
+  if (!descriptor || !('value' in descriptor) || !arrayIsArrayIntrinsic(descriptor.value)) {
+    return Object.freeze([]);
+  }
+  const accepted: string[] = [];
+  for (const value of descriptor.value as readonly unknown[]) {
+    if (typeof value === 'string') accepted.push(value);
+  }
+  return Object.freeze(accepted);
+}
+
+function exactCapability<Value extends object>(
+  interfaces: Readonly<Record<string, unknown>>,
+  key: string
+): Value {
+  const value = interfaces[key];
+  if (typeof value !== 'object' || value === null || !Object.isFrozen(value)) {
+    throw new TypeError(`Prebid requires ${key}`);
+  }
+  return value as Value;
+}
+
+/** Build the release-bound Prebid module registered by the coordinated runtime. */
+export function createPrebidIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces, onDispose }: IntegrationPrepareContext) => {
+    if (!isPrebidIntegrationConfigV1(config)) {
+      throw new TypeError('Prebid integration config is invalid');
+    }
+    const runtime = exactCapability<RuntimeCapabilityV1>(interfaces, 'runtime.v1');
+    const render = exactCapability<ProductionRenderCapability>(interfaces, 'render.v1');
+    exactCapability(interfaces, 'slots.v1');
+    exactCapability(interfaces, 'messages.v1');
+    const runtimeWindow = runtime?.document?.defaultView;
+    if (
+      !runtimeWindow ||
+      typeof render.navigation?.isCurrent !== 'function' ||
+      !Object.isFrozen(render.projection) ||
+      typeof render.createPrebidSelectionCoordinator !== 'function' ||
+      typeof render.publishPrebidBid !== 'function'
+    ) {
+      throw new TypeError('Prebid capability graph is malformed');
+    }
+    const clientSideBidders = configStringArray(config, 'clientSideBidders');
+    const excludedGamAdUnitPathSuffixes = configStringArray(
+      config,
+      'excludedGamAdUnitPathSuffixes'
+    );
+    const adapter = createBrowserPrebidAdapter(
+      runtimeWindow as unknown as Parameters<typeof createBrowserPrebidAdapter>[0],
+      { configuredClientSideBidders: clientSideBidders, requiredUserIdModules: Object.freeze([]) }
+    );
+    let active = false;
+    let runtimeRelease: (() => void) | undefined;
+    const coordinator = render.createPrebidSelectionCoordinator();
+    const completeAuction = (auctionRequest: Readonly<PrebidTrustedServerAuctionV1>): void => {
+      try {
+        auctionRequest.complete();
+      } catch {
+        // Publisher completion remains isolated from the owned auction transaction.
+      }
+    };
+    const publishAuction = (auctionRequest: Readonly<PrebidTrustedServerAuctionV1>): void => {
+      const navigation = render.navigation;
+      if (!active || !navigation.isCurrent()) {
+        completeAuction(auctionRequest);
+        return;
+      }
+      try {
+        const projection = navigation.currentAuctionProjection as
+          Readonly<BrowserAuctionProjectionV1> | undefined;
+        if (!projection || projection !== render.projection) return;
+        if (projection.auction.auctionId !== auctionRequest.auctionId) return;
+        for (let index = 0; index < auctionRequest.bids.length; index += 1) {
+          const request = auctionRequest.bids[index];
+          if (!request) continue;
+          const winners = projection.auction.results.filter(
+            (result) => result.slot === request.adUnitCode && result.outcome === 'winner'
+          );
+          if (winners.length !== 1) continue;
+          const winner = winners[0];
+          if (!winner || winner.outcome !== 'winner') continue;
+          const bids = projection.bids.filter(
+            (bid) => bid.slot === request.adUnitCode && bid.candidateId === winner.candidateId
+          );
+          if (bids.length !== 1) continue;
+          const bid = bids[0];
+          if (!bid) continue;
+          const publication = render.publishPrebidBid({
+            admitTrustedBid: adapter.admitTrustedBid,
+            auctionId: auctionRequest.auctionId,
+            adUnitCode: request.adUnitCode,
+            bid,
+            generatedBid: Object.freeze({
+              requestId: request.requestId,
+              adId: request.requestId,
+              cpm: bid.cpm,
+              width: bid.renderSource.width,
+              height: bid.renderSource.height,
+            }),
+            trackAdmittedBid: coordinator.track,
+          });
+          if (
+            !publication.ok &&
+            (publication.reason === 'prebid_admission_failed' ||
+              publication.reason === 'prebid_contract_violation')
+          ) {
+            coordinator.settlePublicationFailure(
+              navigation,
+              auctionRequest.auctionId,
+              request.adUnitCode,
+              publication.reason
+            );
+          }
+        }
+      } catch {
+        // Invalid or stale projection state publishes no TS bid.
+      } finally {
+        completeAuction(auctionRequest);
+      }
+    };
+    const startup = createPrebidStartup({
+      dispose: () => undefined,
+      onAuction: publishAuction,
+      onAuctionEnd: coordinator.auctionEnded,
+      prebid: adapter,
+    });
+    const dispose = (): void => {
+      active = false;
+      const release = runtimeRelease;
+      runtimeRelease = undefined;
+      release?.();
+      coordinator.dispose();
+      adapter.dispose();
+    };
+    onDispose(dispose);
+    const capability: PrebidCapabilityV1 = Object.freeze({
+      adapter,
+      clientSideBidders,
+      excludedGamAdUnitPathSuffixes,
+    });
+
+    return Object.freeze({
+      activate: ({ adoption, afterCommit, onDispose }: IntegrationActivationContext) => {
+        if (active) throw new Error('Prebid integration is already active');
+        if (adoption !== undefined) {
+          const selected = persistentFirstDisplaySliceSelectedV1(adoption, 'prebid_initial');
+          const initialState = selected
+            ? snapshotPersistentFirstDisplaySliceStateV1(adoption, 'prebid_initial')
+            : undefined;
+          if (
+            selected === undefined ||
+            (selected &&
+              (!initialState ||
+                initialState.values.length !== 1 ||
+                initialState.values[0]?.[0] !== 'protocol_version' ||
+                initialState.values[0][1] !== 1))
+          ) {
+            throw new TypeError('Prebid first-display adoption is invalid');
+          }
+        }
+        active = true;
+        onDispose(dispose);
+        afterCommit(() => {
+          if (!active) return;
+          runtimeRelease = startup.activate();
+          startup.start(config);
+        });
+      },
+      interfaces: Object.freeze({ 'prebid.v1': capability }),
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: PREBID_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
+
+export type {
+  PrebidRefreshAuctionOperation,
+  PrebidRefreshAuctionPreparation,
+  PrebidRefreshPolicy,
+  PrebidRefreshPolicyOptions,
+  PrebidRegisteredRefreshAuctionOptions,
+  PrebidSyntheticRefreshRunner,
+  PrebidSyntheticRefreshRunnerOptions,
+} from './refresh';
diff --git a/crates/trusted-server-js/lib/src/integrations/prebid/refresh.ts b/crates/trusted-server-js/lib/src/integrations/prebid/refresh.ts
new file mode 100644
index 000000000..a804c29e9
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/prebid/refresh.ts
@@ -0,0 +1,605 @@
+import {
+  ownDataArray,
+  ownDataObject,
+  validBoundedString,
+} from '../../core/contracts/auction_projection';
+import type { NavigationSession } from '../../kernel/sessions';
+
+interface DeferredOperation<T> {
+  readonly result: Promise<T>;
+  readonly dispose: () => void;
+}
+
+interface DeferredGoogletagFacade {
+  readonly adUnitPath?: (slot: object) => unknown;
+  readonly clearTargeting: (slot: object, key?: string) => unknown;
+}
+
+export interface DeferredGoogletagRunner {
+  readonly run: <T>(command: (googletag: DeferredGoogletagFacade) => T) => DeferredOperation<T>;
+}
+
+interface DeferredPrebidFacade {
+  readonly requestBids: (request: Readonly<Record<string, unknown>>) => unknown;
+  readonly setTargetingForGpt: (adUnitCodes: readonly string[]) => unknown;
+}
+
+export interface DeferredPrebidRunner {
+  readonly run: <T>(
+    command: (prebid: DeferredPrebidFacade) => T,
+    options?: Readonly<{ signal?: AbortSignal }>
+  ) => DeferredOperation<T>;
+}
+
+interface DeferredPublisherRefreshCall {
+  readonly slots: readonly object[];
+}
+
+interface RefreshScheduler {
+  readonly clear: (handle: unknown) => void;
+  readonly set: (callback: () => void, milliseconds: number) => unknown;
+}
+
+const TRUSTED_SERVER_PREBID_BIDDER = 'trustedServer';
+const MAX_CONFIG_MEMBERS = 256;
+const PREBID_REFRESH_TIMEOUT_MS = 1_500;
+const MAX_PREBID_REFRESH_AD_UNITS = 64;
+const PREBID_REFRESH_TARGETING_KEYS = Object.freeze([
+  'ts_initial',
+  'hb_pb',
+  'hb_bidder',
+  'hb_adid',
+  'hb_cache_host',
+  'hb_cache_path',
+]);
+
+export interface PrebidRefreshPolicyOptions {
+  readonly currentNavigation: () => NavigationSession | undefined;
+  readonly excludedGamAdUnitPathSuffixes: readonly string[] | (() => readonly string[]);
+  readonly googletag: DeferredGoogletagRunner;
+  readonly runSyntheticAuction: (
+    slots: readonly object[],
+    navigation: NavigationSession
+  ) => PrebidRefreshAuctionOperation;
+}
+
+export interface PrebidRefreshAuctionPreparation {
+  readonly adUnitCodes: readonly string[];
+  readonly adUnits: readonly object[];
+}
+
+export interface PrebidRegisteredRefreshAuctionOptions {
+  readonly clientSideBidders: readonly string[];
+  readonly resolveAdUnit: (slot: object) => unknown;
+  readonly slots: readonly object[];
+}
+
+export interface PrebidRefreshAuctionOperation {
+  readonly completion: Promise<void>;
+  readonly dispose: () => void;
+}
+
+export interface PrebidSyntheticRefreshRunnerOptions {
+  readonly prebid: DeferredPrebidRunner;
+  readonly prepareAuction: (slots: readonly object[], navigation: NavigationSession) => unknown;
+  readonly scheduler?: RefreshScheduler;
+}
+
+export type PrebidSyntheticRefreshRunner = (
+  slots: readonly object[],
+  navigation: NavigationSession
+) => PrebidRefreshAuctionOperation;
+
+export interface PrebidRefreshPolicy {
+  readonly dispose: () => void;
+  readonly prepare: (
+    call: Readonly<DeferredPublisherRefreshCall>
+  ) => PromiseLike<unknown> | undefined;
+}
+
+interface PrebidRefreshNavigationOwner {
+  active: boolean;
+  readonly navigation: NavigationSession;
+  readonly pending: Set<PrebidPendingRefresh>;
+}
+
+interface PrebidPendingRefresh {
+  active: boolean;
+  auctionOperation: PrebidRefreshAuctionOperation | undefined;
+  readonly owner: PrebidRefreshNavigationOwner;
+  operation: DeferredOperation<readonly object[]> | undefined;
+  readonly resolve: () => void;
+  readonly settle: () => void;
+}
+
+function defaultRefreshScheduler(): RefreshScheduler {
+  return Object.freeze({
+    clear: (handle: unknown): void => {
+      globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>);
+    },
+    set: (callback: () => void, milliseconds: number): unknown =>
+      globalThis.setTimeout(callback, milliseconds),
+  });
+}
+
+function validRefreshAuctionPreparation(
+  candidate: unknown
+): PrebidRefreshAuctionPreparation | undefined {
+  try {
+    const record = ownDataObject(candidate);
+    if (!record || !Array.isArray(record.adUnits) || !Array.isArray(record.adUnitCodes)) {
+      return undefined;
+    }
+    if (
+      !Object.isFrozen(record.adUnits) ||
+      !Object.isFrozen(record.adUnitCodes) ||
+      record.adUnits.length === 0 ||
+      record.adUnits.length > MAX_PREBID_REFRESH_AD_UNITS ||
+      record.adUnits.length !== record.adUnitCodes.length
+    ) {
+      return undefined;
+    }
+    const codes = new Set<string>();
+    for (let index = 0; index < record.adUnits.length; index += 1) {
+      const code = record.adUnitCodes[index];
+      const adUnit = ownDataObject(record.adUnits[index]);
+      if (!validBoundedString(code, 128) || codes.has(code) || !adUnit || adUnit.code !== code) {
+        return undefined;
+      }
+      codes.add(code);
+    }
+    return record as unknown as PrebidRefreshAuctionPreparation;
+  } catch {
+    return undefined;
+  }
+}
+
+function defineDataProperty(target: Record<string, unknown>, key: string, value: unknown): void {
+  Object.defineProperty(target, key, {
+    configurable: false,
+    enumerable: true,
+    value,
+    writable: false,
+  });
+}
+
+/** Rebuild synthetic Prebid units from detached runtime-owned registrations. */
+export function preparePrebidRegisteredRefreshAuction(
+  options: PrebidRegisteredRefreshAuctionOptions
+): PrebidRefreshAuctionPreparation | undefined {
+  try {
+    if (
+      options.slots.length === 0 ||
+      options.slots.length > MAX_PREBID_REFRESH_AD_UNITS ||
+      !Object.isFrozen(options.slots)
+    ) {
+      return undefined;
+    }
+    const clientSideBidders = new Set<string>();
+    for (let index = 0; index < options.clientSideBidders.length; index += 1) {
+      const bidder = options.clientSideBidders[index];
+      if (!validBoundedString(bidder, 64)) return undefined;
+      clientSideBidders.add(bidder);
+    }
+
+    const adUnitCodes: string[] = [];
+    const adUnits: object[] = [];
+    const seenCodes = new Set<string>();
+    for (let slotIndex = 0; slotIndex < options.slots.length; slotIndex += 1) {
+      const slot = options.slots[slotIndex];
+      if (!slot) return undefined;
+      const source = ownDataObject(options.resolveAdUnit(slot));
+      if (!source || !validBoundedString(source.code, 128) || seenCodes.has(source.code)) {
+        return undefined;
+      }
+      const mediaTypes = ownDataObject(source.mediaTypes);
+      if (!mediaTypes || !Object.isFrozen(source.mediaTypes)) return undefined;
+      const rawBids =
+        source.bids === undefined ? [] : ownDataArray(source.bids, MAX_CONFIG_MEMBERS);
+      if (!rawBids || (source.bids !== undefined && !Object.isFrozen(source.bids))) {
+        return undefined;
+      }
+
+      const bidderParamEntries = new Map<string, unknown>();
+      const trustedParams: Record<string, unknown> = {};
+      const clientBids: object[] = [];
+      let foundTrustedBid = false;
+      for (let bidIndex = 0; bidIndex < rawBids.length; bidIndex += 1) {
+        const bid = ownDataObject(rawBids[bidIndex]);
+        if (!bid || !validBoundedString(bid.bidder, 64)) return undefined;
+        const params = bid.params === undefined ? Object.freeze({}) : bid.params;
+        if (!ownDataObject(params) || !Object.isFrozen(params)) return undefined;
+        if (bid.bidder === TRUSTED_SERVER_PREBID_BIDDER) {
+          if (foundTrustedBid) return undefined;
+          foundTrustedBid = true;
+          const existingParams = ownDataObject(params);
+          if (!existingParams) return undefined;
+          for (const [key, value] of Object.entries(existingParams)) {
+            if (key !== 'bidderParams') defineDataProperty(trustedParams, key, value);
+          }
+          const folded = existingParams['bidderParams'];
+          if (folded !== undefined) {
+            const foldedRecord = ownDataObject(folded);
+            if (!foldedRecord || !Object.isFrozen(folded)) return undefined;
+            for (const [bidder, bidderValue] of Object.entries(foldedRecord)) {
+              if (!validBoundedString(bidder, 64) || !ownDataObject(bidderValue)) return undefined;
+              if (!clientSideBidders.has(bidder)) bidderParamEntries.set(bidder, bidderValue);
+            }
+          }
+          continue;
+        }
+        if (clientSideBidders.has(bid.bidder)) {
+          clientBids.push(Object.freeze({ bidder: bid.bidder, params }));
+          continue;
+        }
+        bidderParamEntries.set(bid.bidder, params);
+      }
+
+      const bidderParams: Record<string, unknown> = {};
+      for (const [bidder, params] of bidderParamEntries) {
+        defineDataProperty(bidderParams, bidder, params);
+      }
+      defineDataProperty(trustedParams, 'bidderParams', Object.freeze(bidderParams));
+      const synthetic = Object.freeze({
+        code: source.code,
+        mediaTypes: source.mediaTypes,
+        bids: Object.freeze([
+          Object.freeze({
+            bidder: TRUSTED_SERVER_PREBID_BIDDER,
+            params: Object.freeze(trustedParams),
+          }),
+          ...clientBids,
+        ]),
+      });
+      seenCodes.add(source.code);
+      adUnitCodes.push(source.code);
+      adUnits.push(synthetic);
+    }
+    return Object.freeze({
+      adUnitCodes: Object.freeze(adUnitCodes),
+      adUnits: Object.freeze(adUnits),
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+/** Run one synthetic refresh auction through the exact current Prebid adapter binding. */
+export function createPrebidSyntheticRefreshRunner(
+  options: PrebidSyntheticRefreshRunnerOptions
+): PrebidSyntheticRefreshRunner {
+  const scheduler = options.scheduler ?? defaultRefreshScheduler();
+  return (slots, navigation): PrebidRefreshAuctionOperation => {
+    let active = true;
+    let adapterOperation: DeferredOperation<unknown> | undefined;
+    let timer: unknown;
+    let timerArmed = false;
+    let resolveCompletion!: () => void;
+    const completion = new Promise<void>((resolve) => {
+      resolveCompletion = resolve;
+    });
+    const settle = (): void => {
+      if (!active) return;
+      active = false;
+      if (timerArmed) {
+        timerArmed = false;
+        try {
+          scheduler.clear(timer);
+        } catch {
+          // The runner's logical completion remains terminal.
+        }
+      }
+      const operation = adapterOperation;
+      adapterOperation = undefined;
+      try {
+        operation?.dispose();
+      } catch {
+        // Adapter cleanup cannot prevent the deferred GPT call from resuming.
+      }
+      resolveCompletion();
+    };
+    const handle = Object.freeze({ completion, dispose: settle });
+
+    let prepared: PrebidRefreshAuctionPreparation | undefined;
+    try {
+      if (!navigation.isCurrent()) {
+        settle();
+        return handle;
+      }
+      prepared = validRefreshAuctionPreparation(
+        options.prepareAuction(Object.freeze([...slots]), navigation)
+      );
+    } catch {
+      prepared = undefined;
+    }
+    if (!prepared) {
+      settle();
+      return handle;
+    }
+
+    try {
+      const codes = Object.freeze([...prepared.adUnitCodes]);
+      const adUnits = Object.freeze([...prepared.adUnits]);
+      const operation = options.prebid.run(
+        (prebid) =>
+          new Promise<void>((resolveRequest) => {
+            let requestActive = true;
+            const finishRequest = (applyTargeting: boolean): void => {
+              if (!requestActive) return;
+              requestActive = false;
+              if (timerArmed) {
+                timerArmed = false;
+                try {
+                  scheduler.clear(timer);
+                } catch {
+                  // The request completion latch remains terminal.
+                }
+              }
+              if (active && applyTargeting) {
+                try {
+                  prebid.setTargetingForGpt(codes);
+                } catch {
+                  // Targeting failure still resumes the exact deferred GPT request.
+                }
+              }
+              resolveRequest();
+            };
+            try {
+              prebid.requestBids(
+                Object.freeze({
+                  adUnits,
+                  bidsBackHandler: () => finishRequest(true),
+                  timeout: PREBID_REFRESH_TIMEOUT_MS,
+                })
+              );
+            } catch {
+              finishRequest(false);
+              return;
+            }
+            if (!requestActive || !active) return;
+            let installedTimer: unknown;
+            try {
+              installedTimer = scheduler.set(() => finishRequest(true), PREBID_REFRESH_TIMEOUT_MS);
+              if (requestActive && active) {
+                timer = installedTimer;
+                timerArmed = true;
+              } else {
+                try {
+                  scheduler.clear(installedTimer);
+                } catch {
+                  // A synchronously-fired timeout is already terminal.
+                }
+              }
+            } catch {
+              finishRequest(true);
+            }
+          }),
+        Object.freeze({ signal: navigation.signal })
+      );
+      adapterOperation = operation;
+      if (!active) {
+        try {
+          operation.dispose();
+        } catch {
+          // The runner's exact completion latch has already settled.
+        }
+      } else {
+        void operation.result.then(settle, settle);
+      }
+    } catch {
+      settle();
+    }
+    return handle;
+  };
+}
+
+/** Defer one publisher refresh through navigation-owned targeting cleanup and Prebid work. */
+export function createPrebidRefreshPolicy(
+  options: PrebidRefreshPolicyOptions
+): PrebidRefreshPolicy {
+  const owners = new WeakMap<NavigationSession, PrebidRefreshNavigationOwner>();
+  const pending = new Set<PrebidPendingRefresh>();
+  let disposed = false;
+
+  const currentNavigation = (): NavigationSession | undefined => {
+    try {
+      const navigation = options.currentNavigation();
+      return navigation?.isCurrent() ? navigation : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const ownerFor = (navigation: NavigationSession): PrebidRefreshNavigationOwner | undefined => {
+    const current = owners.get(navigation);
+    if (current?.active) return current;
+    const owner: PrebidRefreshNavigationOwner = {
+      active: true,
+      navigation,
+      pending: new Set(),
+    };
+    try {
+      navigation.onDispose('prebid-refresh-policy', () => {
+        owner.active = false;
+        owners.delete(navigation);
+        const snapshot = [...owner.pending];
+        for (let index = 0; index < snapshot.length; index += 1) snapshot[index]?.settle();
+      });
+    } catch {
+      return undefined;
+    }
+    if (!navigation.isCurrent()) return undefined;
+    owners.set(navigation, owner);
+    return owner;
+  };
+
+  const prepare = (
+    call: Readonly<DeferredPublisherRefreshCall>
+  ): PromiseLike<unknown> | undefined => {
+    if (disposed) return undefined;
+    const navigation = currentNavigation();
+    if (!navigation) return undefined;
+    let slots: readonly object[];
+    let suffixes: readonly string[];
+    try {
+      if (!Array.isArray(call.slots)) return undefined;
+      const snapshot: object[] = [];
+      for (let index = 0; index < call.slots.length; index += 1) {
+        const slot = call.slots[index];
+        if ((typeof slot !== 'object' && typeof slot !== 'function') || slot === null) {
+          return undefined;
+        }
+        snapshot.push(slot);
+      }
+      slots = Object.freeze(snapshot);
+    } catch {
+      return undefined;
+    }
+    try {
+      const configuredSuffixes =
+        typeof options.excludedGamAdUnitPathSuffixes === 'function'
+          ? options.excludedGamAdUnitPathSuffixes()
+          : options.excludedGamAdUnitPathSuffixes;
+      suffixes = Object.freeze([...configuredSuffixes]);
+    } catch {
+      suffixes = Object.freeze([]);
+    }
+    const owner = ownerFor(navigation);
+    if (!owner) return undefined;
+
+    let resolveCompletion!: () => void;
+    const completion = new Promise<void>((resolve) => {
+      resolveCompletion = resolve;
+    });
+    const requestReference: { value?: PrebidPendingRefresh } = {};
+    const settle = (): void => {
+      const request = requestReference.value;
+      if (!request?.active) return;
+      request.active = false;
+      pending.delete(request);
+      request.owner.pending.delete(request);
+      const operation = request.operation;
+      request.operation = undefined;
+      try {
+        operation?.dispose();
+      } catch {
+        // GPT cleanup failure cannot prevent the publisher refresh from resuming.
+      }
+      const auctionOperation = request.auctionOperation;
+      request.auctionOperation = undefined;
+      try {
+        auctionOperation?.dispose();
+      } catch {
+        // Prebid cleanup failure cannot prevent the publisher refresh from resuming.
+      }
+      request.resolve();
+    };
+    const request: PrebidPendingRefresh = {
+      active: true,
+      auctionOperation: undefined,
+      operation: undefined,
+      owner,
+      resolve: resolveCompletion,
+      settle,
+    };
+    requestReference.value = request;
+    pending.add(request);
+    owner.pending.add(request);
+
+    try {
+      const operation = options.googletag.run((gpt) => {
+        const eligible: object[] = [];
+        for (let slotIndex = 0; slotIndex < slots.length; slotIndex += 1) {
+          const slot = slots[slotIndex];
+          if (!slot) continue;
+          let clearFailed = false;
+          for (let keyIndex = 0; keyIndex < PREBID_REFRESH_TARGETING_KEYS.length; keyIndex += 1) {
+            try {
+              gpt.clearTargeting(slot, PREBID_REFRESH_TARGETING_KEYS[keyIndex]);
+            } catch {
+              clearFailed = true;
+            }
+          }
+          if (clearFailed) {
+            eligible.push(slot);
+            continue;
+          }
+          let adUnitPath: unknown;
+          try {
+            adUnitPath = gpt.adUnitPath?.(slot);
+          } catch {
+            eligible.push(slot);
+            continue;
+          }
+          if (typeof adUnitPath !== 'string') {
+            eligible.push(slot);
+            continue;
+          }
+          let excluded = false;
+          for (let suffixIndex = 0; suffixIndex < suffixes.length; suffixIndex += 1) {
+            if (adUnitPath.endsWith(suffixes[suffixIndex] as string)) {
+              excluded = true;
+              break;
+            }
+          }
+          if (!excluded) eligible.push(slot);
+        }
+        return Object.freeze(eligible);
+      });
+      request.operation = operation;
+      if (!request.active) {
+        try {
+          operation.dispose();
+        } catch {
+          // The terminal request already resumed GPT.
+        }
+        return completion;
+      }
+      void operation.result.then((eligible) => {
+        if (
+          !request.active ||
+          !owner.active ||
+          currentNavigation() !== navigation ||
+          !navigation.isCurrent()
+        ) {
+          settle();
+          return;
+        }
+        if (eligible.length === 0) {
+          settle();
+          return;
+        }
+        let auction: PrebidRefreshAuctionOperation;
+        try {
+          auction = options.runSyntheticAuction(Object.freeze([...eligible]), navigation);
+        } catch {
+          settle();
+          return;
+        }
+        request.auctionOperation = auction;
+        if (!request.active) {
+          try {
+            auction.dispose();
+          } catch {
+            // The policy's completion latch has already settled.
+          }
+          return;
+        }
+        void auction.completion.then(settle, settle);
+      }, settle);
+    } catch {
+      settle();
+    }
+    return completion;
+  };
+
+  return Object.freeze({
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      const snapshot = [...pending];
+      for (let index = 0; index < snapshot.length; index += 1) snapshot[index]?.settle();
+    },
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/prebid/startup.ts b/crates/trusted-server-js/lib/src/integrations/prebid/startup.ts
new file mode 100644
index 000000000..2a7cff812
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/prebid/startup.ts
@@ -0,0 +1,137 @@
+import type {
+  PrebidAdapter,
+  PrebidEventFacade,
+  PrebidTrustedServerAuctionV1,
+} from '../../adapters/prebid';
+import type { GoogletagPublisherRefreshCall } from '../../adapters/googletag';
+
+interface RefreshPolicyCapability {
+  readonly prepare: (
+    call: Readonly<GoogletagPublisherRefreshCall>
+  ) => PromiseLike<unknown> | undefined;
+}
+
+export interface PrebidStartup {
+  readonly activate: () => () => void;
+  readonly start: (config: unknown) => void;
+}
+
+export interface PrebidStartupOptions {
+  readonly dispose: () => void;
+  readonly onAuction: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void;
+  readonly onAuctionEnd: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void;
+  readonly prebid: Pick<PrebidAdapter, 'notifyReady' | 'run'>;
+  readonly refresh?: Readonly<{
+    readonly configure?: (config: unknown) => void;
+    readonly install: (policy: RefreshPolicyCapability) => (() => void) | undefined;
+    readonly policy: RefreshPolicyCapability & Readonly<{ dispose: () => void }>;
+  }>;
+  readonly start?: (config: unknown) => void;
+}
+
+/** Join the private bidder and early winner observer to one reversible runtime owner. */
+export function createPrebidStartup(options: PrebidStartupOptions): PrebidStartup {
+  let activated = false;
+  let released = false;
+  let started = false;
+  let activationOperation: ReturnType<PrebidStartupOptions['prebid']['run']> | undefined;
+  let activationEffects: (() => void) | undefined;
+  let bidderOperation: ReturnType<PrebidStartupOptions['prebid']['run']> | undefined;
+  let bidderEffects: (() => void) | undefined;
+  let refreshPolicyRelease: (() => void) | undefined;
+
+  const retainEffects = (
+    result: Promise<unknown>,
+    publish: (release: () => void) => void
+  ): void => {
+    void result.then(
+      (candidate) => {
+        if (typeof candidate !== 'function') return;
+        if (released) candidate();
+        else publish(candidate as () => void);
+      },
+      () => undefined
+    );
+  };
+
+  const disposeOwnedOperation = (
+    operation: ReturnType<PrebidStartupOptions['prebid']['run']> | undefined,
+    releaseEffects: (() => void) | undefined
+  ): void => {
+    try {
+      operation?.dispose();
+    } finally {
+      releaseEffects?.();
+    }
+  };
+
+  return Object.freeze({
+    activate: (): (() => void) => {
+      if (activated || released) throw new Error('Prebid startup is already activated');
+      activated = true;
+      activationOperation = options.prebid.run((prebid) => {
+        const releaseAuctionEnd = prebid.subscribe('auctionEnd', options.onAuctionEnd);
+        return releaseAuctionEnd;
+      });
+      retainEffects(activationOperation.result, (release) => {
+        activationEffects = release;
+      });
+      const refresh = options.refresh;
+      if (refresh) {
+        try {
+          refreshPolicyRelease = refresh.install(refresh.policy);
+          if (!refreshPolicyRelease) throw new Error('Prebid refresh policy is unavailable');
+        } catch (error) {
+          released = true;
+          try {
+            disposeOwnedOperation(activationOperation, activationEffects);
+          } finally {
+            try {
+              refresh.policy.dispose();
+            } finally {
+              options.dispose();
+            }
+          }
+          throw error;
+        }
+      }
+      return (): void => {
+        if (released) return;
+        released = true;
+        try {
+          disposeOwnedOperation(bidderOperation, bidderEffects);
+        } finally {
+          try {
+            disposeOwnedOperation(activationOperation, activationEffects);
+          } finally {
+            try {
+              options.refresh?.policy.dispose();
+            } finally {
+              try {
+                refreshPolicyRelease?.();
+              } finally {
+                options.dispose();
+              }
+            }
+          }
+        }
+      };
+    },
+    start: (config: unknown): void => {
+      if (!activated || released || started) throw new Error('Prebid startup is unavailable');
+      started = true;
+      try {
+        options.refresh?.configure?.(config);
+        bidderOperation = options.prebid.run((prebid) =>
+          prebid.registerTrustedServerBidder(options.onAuction)
+        );
+        retainEffects(bidderOperation.result, (release) => {
+          bidderEffects = release;
+        });
+        options.start?.(config);
+      } finally {
+        options.prebid.notifyReady();
+      }
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/render_runtime/index.ts b/crates/trusted-server-js/lib/src/integrations/render_runtime/index.ts
new file mode 100644
index 000000000..5e5a0386e
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/render_runtime/index.ts
@@ -0,0 +1,13 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+
+import { createRenderRuntimeIntegrationRegistration } from './module';
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createRenderRuntimeIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/render_runtime/module.ts b/crates/trusted-server-js/lib/src/integrations/render_runtime/module.ts
new file mode 100644
index 000000000..16318f267
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/render_runtime/module.ts
@@ -0,0 +1,1293 @@
+import {
+  createBrowserMessagingAdapter,
+  type MessagingValidationOptions,
+} from '../../adapters/messaging';
+import { parseTrustedServerAuctionResponseV1 } from '../../core/auction';
+import {
+  parseBidRenderSourceV1,
+  parseBrowserAuctionProjectionV1,
+} from '../../core/contracts/auction_projection';
+import { validateRequestAdsOptions } from '../../core/contracts/request_ads';
+import { log } from '../../core/log';
+import { prepareAdmIframe } from '../../core/render';
+import { createRenderTraceStore, type RenderTraceRuntimeOwner } from '../../core/trace';
+import type { BootManifestV1, BrowserAuctionProjectionV1 } from '../../core/types';
+import { DisposableStack } from '../../kernel/disposable';
+import {
+  createBrowserNavigationIdentityIssuer,
+  mintBrowserLifecycleTicket,
+} from '../../kernel/identity';
+import {
+  snapshotPersistentFirstDisplayAdoptionV1,
+  type PersistentFirstDisplayAdoptionV1,
+} from '../../shared/takeover';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type {
+  RuntimeAuctionContextContributor,
+  RuntimeAuctionContextService,
+  RuntimeCapabilityV1,
+} from '../../kernel/runtime';
+import { createDiagnosticsIngress } from '../../kernel/diagnostics';
+import {
+  createRuntimeSession,
+  type NavigationSession,
+  type RuntimeSession,
+} from '../../kernel/sessions';
+import {
+  AdUnitRegistrationError,
+  addAdUnitsResult,
+  prepareProgrammaticAdUnits,
+  serializeAuctionRequestBody,
+} from '../../core/registry';
+import { createAuctionBatchService } from '../../services/auction_batch';
+import {
+  createAuctionContextRegistry,
+  type AuctionContextContributor,
+  type AuctionContextRegistry,
+  type ContextContributorOwner,
+} from '../../services/context';
+import {
+  createPageBidsController,
+  prepareInitialAuctionProjection,
+  type ProjectionSlotRegistry,
+} from '../../services/projections';
+import { createReservationService, type ReservationService } from '../../services/reservations';
+import type { PucGamAttemptInput } from '../../services/puc_bridge';
+import {
+  bindCommittedArtifactGuard,
+  bindCommittedArtifactRetirement,
+  createArtifactHostPositionLeaseRegistry,
+  createCommittedArtifactStore,
+  createBootstrapNonceRegistry,
+  createRenderAttempt,
+  createRendererNonceRegistry,
+  createSlotOperation,
+  renderDirectAdmAttempt,
+  type ArtifactHostPositionLeaseRegistry,
+  type CommittedArtifactStore,
+  type CommittedRenderArtifact,
+  type RenderAttempt,
+} from '../../services/render';
+import type { SlotRecord, SlotService } from '../../services/slots';
+import { trustedDocumentHttpOrigin } from '../../shared/origin';
+
+import {
+  createPrebidSelectionCoordinator,
+  publishPrebidBid,
+  type PrebidBidPublicationInput,
+  type PrebidSelectionCoordinator,
+} from './prebid_selection';
+
+interface AcceptedBoot {
+  readonly auctionProjection: unknown;
+  readonly diagnostics: Readonly<{
+    version: 1;
+    renderTraceOverlay: boolean;
+  }>;
+  readonly manifest: Readonly<BootManifestV1>;
+}
+
+export type RegisteredRenderSource = 'aps';
+export type RegisteredRenderer = (attempt: RenderAttempt, container: HTMLElement) => boolean;
+
+function adoptionArray(candidate: unknown): readonly unknown[] | undefined {
+  return Array.isArray(candidate) && Object.isFrozen(candidate) ? candidate : undefined;
+}
+
+function adoptionField(candidate: unknown, key: string): unknown {
+  if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+    return undefined;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+  return descriptor?.enumerable && 'value' in descriptor ? descriptor.value : undefined;
+}
+
+export interface AdoptedInitialRenderArtifactsV1 {
+  readonly adoption: PersistentFirstDisplayAdoptionV1;
+  readonly arm: () => void;
+}
+
+/** Adopt serialized replay suppression and diagnostics counters before new-epoch activity. */
+export function adoptInitialRenderStateFromHandoff(
+  candidate: unknown,
+  navigation: Pick<NavigationSession, 'adoptFirstDisplayIdentityState' | 'generation'>,
+  reservations: Pick<ReservationService, 'adoptFirstDisplayTombstones'>,
+  trace: Pick<RenderTraceRuntimeOwner, 'adoptFirstDisplay'>
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  if (!adoption) return undefined;
+  const highWater = adoptionField(adoption.handoff, 'highWater');
+  const tombstones = adoptionArray(adoptionField(adoption.handoff, 'tombstones'));
+  const traceState = adoptionField(adoption.handoff, 'trace');
+  const handoffSlots = adoptionArray(adoptionField(adoption.handoff, 'slots'));
+  const cycles = adoptionArray(adoptionField(adoption.handoff, 'cycles'));
+  const clockEpochMs = adoptionField(highWater, 'reservationClockEpochMs');
+  const nextNavigationAttemptOrdinal = adoptionField(highWater, 'nextNavigationAttemptOrdinal');
+  const nextAttemptOrdinal = adoptionField(highWater, 'nextAttemptOrdinal');
+  const navigationAttemptPrefix = adoptionField(highWater, 'navigationAttemptPrefix');
+  const nextSequence = adoptionField(traceState, 'nextSequence');
+  const traceSlots = adoptionArray(adoptionField(traceState, 'slots'));
+  if (
+    typeof clockEpochMs !== 'number' ||
+    typeof nextNavigationAttemptOrdinal !== 'number' ||
+    typeof nextAttemptOrdinal !== 'number' ||
+    typeof navigationAttemptPrefix !== 'string' ||
+    typeof nextSequence !== 'number' ||
+    !tombstones ||
+    !traceSlots ||
+    !handoffSlots ||
+    !cycles
+  ) {
+    return undefined;
+  }
+  if (
+    !navigation.adoptFirstDisplayIdentityState(
+      navigationAttemptPrefix,
+      Math.max(nextNavigationAttemptOrdinal, nextAttemptOrdinal)
+    )
+  ) {
+    return undefined;
+  }
+  const reservationTombstones: Array<{
+    expiresAtMs: number;
+    reservationId: string;
+  }> = [];
+  for (const tombstone of tombstones) {
+    const kind = adoptionField(tombstone, 'kind');
+    if (kind !== 'reservation') continue;
+    const reservationId = adoptionField(tombstone, 'value');
+    const expiresAtMs = adoptionField(tombstone, 'expiresAtMs');
+    if (typeof reservationId !== 'string' || typeof expiresAtMs !== 'number') return undefined;
+    reservationTombstones.push({ expiresAtMs, reservationId });
+  }
+  const slots: Array<{
+    bindings: readonly Readonly<{
+      cycleOrdinal: number;
+      historySequence: number;
+      state: 'completed' | 'retired';
+      token: string;
+    }>[];
+    impressions: number;
+    records: readonly Readonly<{
+      at: number;
+      count: number;
+      elementId: string;
+      injected: true;
+      path: 'ssat';
+      rendered: true;
+      seq: number;
+      servedFrom: 'inline';
+      slotId: string;
+    }>[];
+    slotId: string;
+  }> = [];
+  for (const slot of traceSlots) {
+    const slotId = adoptionField(slot, 'slotId');
+    const impressions = adoptionField(slot, 'impressions');
+    const rawBindings = adoptionArray(adoptionField(slot, 'bindings'));
+    const handoffSlot = handoffSlots.find((entry) => adoptionField(entry, 'id') === slotId);
+    const cycle = cycles.find((entry) => adoptionField(entry, 'slotId') === slotId);
+    const domId = adoptionField(handoffSlot, 'domId');
+    if (
+      typeof slotId !== 'string' ||
+      typeof impressions !== 'number' ||
+      !rawBindings ||
+      !handoffSlot ||
+      (rawBindings.length > 0 && (!cycle || typeof domId !== 'string'))
+    ) {
+      return undefined;
+    }
+    const bindings: Array<{
+      cycleOrdinal: number;
+      historySequence: number;
+      state: 'completed' | 'retired';
+      token: string;
+    }> = [];
+    const records: Array<{
+      at: number;
+      count: number;
+      elementId: string;
+      injected: true;
+      path: 'ssat';
+      rendered: true;
+      seq: number;
+      servedFrom: 'inline';
+      slotId: string;
+    }> = [];
+    for (let index = 0; index < rawBindings.length; index += 1) {
+      const binding = rawBindings[index];
+      const atMs = adoptionField(binding, 'atMs');
+      const cycleOrdinal = adoptionField(binding, 'cycleOrdinal');
+      const historySequence = adoptionField(binding, 'historySequence');
+      const state = adoptionField(binding, 'state');
+      const token = adoptionField(binding, 'token');
+      const cycleToken = adoptionField(cycle, 'token');
+      const cycleRecords = adoptionArray(adoptionField(cycle, 'records'));
+      if (
+        typeof atMs !== 'number' ||
+        typeof cycleOrdinal !== 'number' ||
+        typeof historySequence !== 'number' ||
+        (state !== 'completed' && state !== 'retired') ||
+        typeof token !== 'string' ||
+        cycleToken !== token ||
+        !cycleRecords?.some(
+          (record) =>
+            adoptionField(record, 'ordinal') === cycleOrdinal &&
+            adoptionField(record, 'state') === state
+        )
+      ) {
+        return undefined;
+      }
+      bindings.push({ cycleOrdinal, historySequence, state, token });
+      records.push({
+        at: atMs,
+        count: impressions - rawBindings.length + index + 1,
+        elementId: domId as string,
+        injected: true,
+        path: 'ssat',
+        rendered: true,
+        seq: historySequence,
+        servedFrom: 'inline',
+        slotId,
+      });
+    }
+    slots.push({ bindings, impressions, records, slotId });
+  }
+  if (
+    !trace.adoptFirstDisplay({
+      navigationGeneration: navigation.generation,
+      nextSequence,
+      slots,
+    })
+  ) {
+    return undefined;
+  }
+  if (
+    !reservations.adoptFirstDisplayTombstones({
+      clockEpochMs,
+      tombstones: reservationTombstones,
+    })
+  ) {
+    return undefined;
+  }
+  return adoption;
+}
+
+/** Stage transferred frames in the persistent artifact store without arming rollback disposal. */
+export function adoptInitialRenderArtifactsFromHandoff(
+  candidate: unknown,
+  navigation: NavigationSession,
+  store: CommittedArtifactStore,
+  hostPositions: ArtifactHostPositionLeaseRegistry,
+  document: Document
+): AdoptedInitialRenderArtifactsV1 | undefined {
+  const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+  if (!adoption) return undefined;
+  const cycles = adoptionArray(adoptionField(adoption.handoff, 'cycles'));
+  const artifacts = adoptionArray(adoptionField(adoption.handoff, 'artifacts'));
+  const handoffSlots = adoptionArray(adoptionField(adoption.handoff, 'slots'));
+  if (
+    !cycles ||
+    !artifacts ||
+    !handoffSlots ||
+    adoption.identities.length !== cycles.length + artifacts.length ||
+    new Set(adoption.identities).size !== adoption.identities.length
+  ) {
+    return undefined;
+  }
+  if (artifacts.length === 0) {
+    return Object.freeze({ adoption, arm: () => undefined });
+  }
+  const Frame = document.defaultView?.HTMLIFrameElement;
+  const Element = document.defaultView?.HTMLElement;
+  const batch = navigation.createAuctionBatch('first-display-adoption');
+  if (!Frame || !Element || !batch) return undefined;
+  const promoted: CommittedRenderArtifact[] = [];
+  let armed = false;
+  try {
+    for (let index = 0; index < artifacts.length; index += 1) {
+      const record = artifacts[index];
+      const slotId = adoptionField(record, 'slotId');
+      const kind = adoptionField(record, 'kind');
+      const owner = adoptionField(record, 'owner');
+      const token = adoptionField(record, 'token');
+      const hostPosition = adoptionField(record, 'hostPosition');
+      const hostPositionPriority = adoptionField(record, 'hostPositionPriority');
+      const identity = adoption.identities[cycles.length + index];
+      const matchingSlots = handoffSlots.filter((entry) => adoptionField(entry, 'id') === slotId);
+      const matchingCycles = cycles.filter((entry) => adoptionField(entry, 'slotId') === slotId);
+      const domId = adoptionField(matchingSlots[0], 'domId');
+      const host = typeof domId === 'string' ? document.getElementById(domId) : null;
+      if (
+        typeof slotId !== 'string' ||
+        (kind !== 'aps' && kind !== 'gpt_adm') ||
+        (owner !== 'trusted_server' && owner !== 'publisher') ||
+        (owner === 'publisher' && kind !== 'gpt_adm') ||
+        typeof token !== 'string' ||
+        !/^r1_[A-Za-z0-9_-]{22}$/.test(token) ||
+        (hostPosition === null && hostPositionPriority !== null) ||
+        (hostPosition !== null &&
+          (typeof hostPosition !== 'string' ||
+            (hostPositionPriority !== '' && hostPositionPriority !== 'important'))) ||
+        (kind === 'gpt_adm' && hostPosition !== null) ||
+        matchingSlots.length !== 1 ||
+        matchingCycles.length !== 1 ||
+        !(host instanceof Element) ||
+        !(identity instanceof Frame)
+      ) {
+        return undefined;
+      }
+      const previousHostPosition = hostPosition as string | null;
+      const previousHostPositionPriority = hostPositionPriority as '' | 'important' | null;
+      const frame = identity;
+      const expectedParent = frame.parentNode;
+      const expectedContentWindow = frame.contentWindow;
+      const expectedSourceAttribute = frame.getAttribute('src');
+      const expectedSource = frame.src;
+      const expectedSourceDocumentAttribute = frame.getAttribute('srcdoc');
+      const expectedSourceDocument = frame.srcdoc;
+      const expectedSandbox = frame.getAttribute('sandbox');
+      const expectedStyle = frame.getAttribute('style');
+      if (
+        !host.isConnected ||
+        host.ownerDocument !== document ||
+        !expectedParent ||
+        (owner === 'trusted_server' && expectedParent !== host) ||
+        !frame.isConnected ||
+        frame.ownerDocument !== document ||
+        !expectedContentWindow ||
+        (kind === 'aps' &&
+          hostPosition !== null &&
+          (host.style.getPropertyValue('position') !== 'relative' ||
+            host.style.getPropertyPriority('position') !== ''))
+      ) {
+        return undefined;
+      }
+      const attempt = batch.createRenderAttempt(slotId);
+      if (!attempt.ok) return undefined;
+      let disposed = false;
+      const artifact: CommittedRenderArtifact = Object.freeze({
+        kind: kind === 'aps' ? ('aps_mount' as const) : ('direct_iframe' as const),
+        attemptId: attempt.value.id,
+        slot: slotId,
+        navigationGeneration: navigation.generation,
+        dispose: (): void => {
+          if (disposed) return;
+          disposed = true;
+          if (!armed || owner === 'publisher') return;
+          try {
+            frame.remove();
+          } catch {
+            // A publisher DOM replacement wins over persistent artifact retirement.
+          }
+          hostPositions.release(artifact);
+        },
+      });
+      if (
+        kind === 'aps' &&
+        previousHostPosition !== null &&
+        !hostPositions.bindOwned(
+          artifact,
+          host,
+          previousHostPosition,
+          previousHostPositionPriority ?? ''
+        )
+      ) {
+        return undefined;
+      }
+      if (
+        !bindCommittedArtifactGuard(artifact, () => {
+          try {
+            return (
+              !disposed &&
+              navigation.isCurrent() &&
+              document.getElementById(domId as string) === host &&
+              host.isConnected &&
+              host.ownerDocument === document &&
+              frame.parentNode === expectedParent &&
+              frame.isConnected &&
+              frame.ownerDocument === document &&
+              frame.contentWindow === expectedContentWindow &&
+              frame.getAttribute('src') === expectedSourceAttribute &&
+              frame.src === expectedSource &&
+              frame.getAttribute('srcdoc') === expectedSourceDocumentAttribute &&
+              frame.srcdoc === expectedSourceDocument &&
+              frame.getAttribute('sandbox') === expectedSandbox &&
+              frame.getAttribute('style') === expectedStyle &&
+              (kind !== 'aps' || previousHostPosition === null || hostPositions.current(artifact))
+            );
+          } catch {
+            return false;
+          }
+        })
+      ) {
+        return undefined;
+      }
+      if (!store.promote(artifact, () => navigation.isCurrent())) return undefined;
+      promoted.push(artifact);
+    }
+    return Object.freeze({
+      adoption,
+      arm: (): void => {
+        armed = true;
+      },
+    });
+  } finally {
+    batch.dispose();
+    if (promoted.length !== artifacts.length) {
+      for (let index = promoted.length - 1; index >= 0; index -= 1) {
+        const artifact = promoted[index];
+        if (artifact) store.release(artifact);
+      }
+    }
+  }
+}
+
+interface LocalSlotRecord {
+  readonly directAuctionUnit?: Readonly<object>;
+  readonly domAliases: readonly string[];
+  readonly navigationGeneration: object;
+  readonly registeredSlotId: string;
+  readonly source: 'programmatic' | 'server';
+}
+
+interface RuntimeSlotBroker {
+  readonly attach: (service: SlotService) => (() => void) | undefined;
+  readonly register: SlotService['register'];
+  readonly resolveDomAlias: SlotService['resolveDomAlias'];
+  readonly resolveRegisteredSlot: SlotService['resolveRegisteredSlot'];
+  readonly snapshotRegisteredSlots: SlotService['snapshotRegisteredSlots'];
+  readonly dispose: () => void;
+}
+
+interface ApsMessagingValidationRegistration {
+  readonly expectedPublisherOrigin: string;
+  readonly expectedRendererUrl: string;
+  readonly validateApsRenderer: (candidate: unknown) => boolean;
+}
+
+const APS_RENDERER_PATH = '/integrations/aps/renderer/v2';
+
+function exactRuntimeCapability(
+  interfaces: Readonly<Record<string, unknown>>
+): RuntimeCapabilityV1 {
+  const candidate = interfaces['runtime.v1'];
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    !Object.isFrozen(candidate) ||
+    typeof (candidate as RuntimeCapabilityV1).attachAuctionContextService !== 'function' ||
+    typeof (candidate as RuntimeCapabilityV1).boot !== 'function' ||
+    typeof (candidate as RuntimeCapabilityV1).protectFirstDisplayAttemptBatch !== 'function' ||
+    typeof (candidate as RuntimeCapabilityV1).registerAuctionContext !== 'function'
+  ) {
+    throw new TypeError('render_runtime requires runtime.v1');
+  }
+  return candidate as RuntimeCapabilityV1;
+}
+
+function acceptedBoot(runtime: RuntimeCapabilityV1): AcceptedBoot {
+  const boot = runtime.boot();
+  if (typeof boot !== 'object' || boot === null || !Object.isFrozen(boot)) {
+    throw new TypeError('render_runtime boot is unavailable');
+  }
+  return boot as unknown as AcceptedBoot;
+}
+
+function slotResult(value: Record<string, unknown>): Readonly<Record<string, unknown>> {
+  return Object.freeze(value);
+}
+
+function registerScopedContextContributor(
+  registry: AuctionContextRegistry,
+  runtimeOwner: RuntimeSession,
+  integrationId: string,
+  contributor: AuctionContextContributor
+): (() => void) | undefined {
+  let active = true;
+  let releaseRegistration: (() => void) | undefined;
+  const owner: ContextContributorOwner = Object.freeze({
+    generation: Object.freeze({}),
+    isCurrent: () => active && runtimeOwner.isCurrent(),
+    onDispose: (kind: string, callback: () => void) => {
+      if (kind !== 'auction-context-contributor' || !active || releaseRegistration) {
+        throw new Error('Auction context contributor disposer is unavailable');
+      }
+      releaseRegistration = callback;
+    },
+  });
+  if (!registry.register(integrationId, contributor, owner)) {
+    active = false;
+    releaseRegistration?.();
+    return undefined;
+  }
+  return (): void => {
+    if (!active) return;
+    active = false;
+    const release = releaseRegistration;
+    releaseRegistration = undefined;
+    release?.();
+  };
+}
+
+function createRuntimeSlotBroker(): RuntimeSlotBroker {
+  const local = new Map<string, LocalSlotRecord>();
+  let localOwner: Parameters<SlotService['register']>[0] | undefined;
+  let attached: SlotService | undefined;
+  let disposed = false;
+  const localSnapshot = (owner: Parameters<SlotService['snapshotRegisteredSlots']>[0]) =>
+    !disposed && owner.isCurrent()
+      ? (Object.freeze([...local.values()]) as unknown as readonly SlotRecord[])
+      : undefined;
+  return Object.freeze({
+    attach: (service: SlotService): (() => void) | undefined => {
+      if (disposed || attached || typeof service?.register !== 'function') return undefined;
+      const records = [...local.values()];
+      if (records.length > 0 && localOwner) {
+        const transferred = service.register(
+          localOwner,
+          records.map((record) =>
+            Object.freeze({
+              ...(record.directAuctionUnit === undefined
+                ? {}
+                : { directAuctionUnit: record.directAuctionUnit }),
+              domAliases: record.domAliases,
+              registeredSlotId: record.registeredSlotId,
+              source: record.source,
+            })
+          )
+        );
+        if (!transferred.ok) return undefined;
+      }
+      attached = service;
+      local.clear();
+      let released = false;
+      return (): void => {
+        if (released) return;
+        released = true;
+        if (attached !== service) return;
+        const restored = localOwner
+          ? (service.snapshotRegisteredSlots(localOwner) ??
+            (records as unknown as readonly SlotRecord[]))
+          : (records as unknown as readonly SlotRecord[]);
+        attached = undefined;
+        if (!disposed) {
+          local.clear();
+          for (const record of restored) {
+            local.set(
+              record.registeredSlotId,
+              Object.freeze({
+                ...(record.directAuctionUnit === undefined
+                  ? {}
+                  : { directAuctionUnit: record.directAuctionUnit }),
+                domAliases: Object.freeze([...record.domAliases]),
+                navigationGeneration: record.navigationGeneration,
+                registeredSlotId: record.registeredSlotId,
+                source: record.source,
+              })
+            );
+          }
+        }
+      };
+    },
+    register: (
+      owner: Parameters<SlotService['register']>[0],
+      registrations: Parameters<SlotService['register']>[1]
+    ) => {
+      if (attached) {
+        localOwner = owner;
+        return attached.register(owner, registrations);
+      }
+      if (disposed || !owner.isCurrent()) {
+        return Object.freeze({ ok: false as const, reason: 'stale_owner' as const });
+      }
+      if (localOwner && localOwner !== owner) {
+        return Object.freeze({ ok: false as const, reason: 'stale_owner' as const });
+      }
+      if (local.size + registrations.length > 256) {
+        return Object.freeze({ ok: false as const, reason: 'registry_capacity' as const });
+      }
+      const seen = new Set<string>();
+      for (const registration of registrations) {
+        if (
+          typeof registration.registeredSlotId !== 'string' ||
+          registration.registeredSlotId === '' ||
+          local.has(registration.registeredSlotId) ||
+          seen.has(registration.registeredSlotId)
+        ) {
+          return Object.freeze({ ok: false as const, reason: 'duplicate_slot' as const });
+        }
+        seen.add(registration.registeredSlotId);
+      }
+      const records = registrations.map((registration: (typeof registrations)[number]) =>
+        Object.freeze({
+          ...(registration.directAuctionUnit === undefined
+            ? {}
+            : { directAuctionUnit: registration.directAuctionUnit }),
+          domAliases: Object.freeze([...(registration.domAliases ?? [])]),
+          navigationGeneration: owner.generation,
+          registeredSlotId: registration.registeredSlotId,
+          source: registration.source,
+        })
+      );
+      localOwner = owner;
+      for (const record of records) local.set(record.registeredSlotId, record);
+      return Object.freeze({
+        ok: true as const,
+        records: records as unknown as readonly SlotRecord[],
+      });
+    },
+    resolveDomAlias: (alias: string) => {
+      if (attached) return attached.resolveDomAlias(alias);
+      let match: LocalSlotRecord | undefined;
+      for (const record of local.values()) {
+        if (!record.domAliases.includes(alias)) continue;
+        if (match) return undefined;
+        match = record;
+      }
+      return match as unknown as SlotRecord | undefined;
+    },
+    resolveRegisteredSlot: (id: string) =>
+      attached?.resolveRegisteredSlot(id) ?? (local.get(id) as unknown as SlotRecord | undefined),
+    snapshotRegisteredSlots: (owner: Parameters<SlotService['snapshotRegisteredSlots']>[0]) =>
+      attached?.snapshotRegisteredSlots(owner) ?? localSnapshot(owner),
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      attached = undefined;
+      localOwner = undefined;
+      local.clear();
+    },
+  });
+}
+
+function exactApsMessagingValidation(
+  candidate: unknown,
+  publisherOrigin: string
+): Readonly<ApsMessagingValidationRegistration> {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      !Object.isFrozen(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      Object.getOwnPropertySymbols(candidate).length !== 0 ||
+      Object.getOwnPropertyNames(candidate).sort().join(',') !==
+        'expectedPublisherOrigin,expectedRendererUrl,validateApsRenderer'
+    ) {
+      throw new TypeError('APS message validation is malformed');
+    }
+    const validation = candidate as ApsMessagingValidationRegistration;
+    const rendererUrl = new URL(validation.expectedRendererUrl);
+    if (
+      validation.expectedPublisherOrigin !== publisherOrigin ||
+      rendererUrl.origin !== publisherOrigin ||
+      rendererUrl.pathname !== APS_RENDERER_PATH ||
+      rendererUrl.search !== '' ||
+      rendererUrl.hash !== '' ||
+      rendererUrl.href !== validation.expectedRendererUrl ||
+      typeof validation.validateApsRenderer !== 'function'
+    ) {
+      throw new TypeError('APS message validation is malformed');
+    }
+    return Object.freeze({
+      expectedPublisherOrigin: validation.expectedPublisherOrigin,
+      expectedRendererUrl: validation.expectedRendererUrl,
+      validateApsRenderer: validation.validateApsRenderer,
+    });
+  } catch (error) {
+    if (error instanceof TypeError && error.message === 'APS message validation is malformed') {
+      throw error;
+    }
+    const malformed = new TypeError('APS message validation is malformed');
+    Object.defineProperty(malformed, 'cause', {
+      configurable: true,
+      value: error,
+      writable: true,
+    });
+    throw malformed;
+  }
+}
+
+/** Mandatory concrete provider for the shared browser runtime capabilities. */
+export function createRenderRuntimeIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  const prepare = (context: IntegrationPrepareContext) => {
+    if (context.config !== undefined) {
+      throw new TypeError('render_runtime does not accept integration config');
+    }
+    const runtime = exactRuntimeCapability(context.interfaces);
+    const boot = acceptedBoot(runtime);
+    const document = runtime.document;
+    const view = document?.defaultView;
+    if (!document || !view) throw new TypeError('render_runtime requires a browser document');
+    const origin = trustedDocumentHttpOrigin(view.location.origin);
+    if (!origin) throw new TypeError('render_runtime requires a trusted HTTP origin');
+    const projection = prepareInitialAuctionProjection(boot.auctionProjection, (candidate) =>
+      parseBrowserAuctionProjectionV1(candidate)
+    ) as Readonly<BrowserAuctionProjectionV1> | undefined;
+    if (!projection) throw new TypeError('render_runtime projection is invalid');
+
+    const scope = new DisposableStack((error) => log.warn('render_runtime disposal failed', error));
+    context.onDispose(() => scope.dispose());
+    let active = false;
+    scope.onDispose(() => {
+      active = false;
+    });
+
+    const artifacts = createCommittedArtifactStore();
+    scope.onDispose(() => artifacts.dispose());
+    const hostPositions = createArtifactHostPositionLeaseRegistry();
+    const ArtifactMutationObserver = view.MutationObserver;
+    if (typeof ArtifactMutationObserver !== 'function') {
+      throw new TypeError('render_runtime requires artifact DOM observation');
+    }
+    const artifactObserver = new ArtifactMutationObserver(() => {
+      artifacts.sweep();
+    });
+    artifactObserver.observe(document, {
+      attributeFilter: ['id', 'sandbox', 'src', 'srcdoc', 'style'],
+      attributes: true,
+      childList: true,
+      subtree: true,
+    });
+    scope.onDispose(() => artifactObserver.disconnect());
+    const slots = createRuntimeSlotBroker();
+    scope.onDispose(() => slots.dispose());
+
+    const renderTrace = createRenderTraceStore({
+      onPresentationError: (error) => log.warn('render diagnostics presentation failed', error),
+      onSubscriberError: (error) => log.warn('render diagnostics subscriber failed', error),
+    });
+    scope.onDispose(() => renderTrace.dispose());
+    const consumeCoreObservation = (observation: Readonly<Record<string, unknown>>): void => {
+      if (
+        observation['kind'] === 'slotRequested' ||
+        observation['kind'] === 'slotResponseReceived' ||
+        observation['kind'] === 'slotRenderEnded' ||
+        observation['kind'] === 'slotOnload' ||
+        observation['kind'] === 'impressionViewable' ||
+        observation['kind'] === 'slotVisibilityChanged'
+      ) {
+        renderTrace.observeGptFact(observation as never, (elementId) => {
+          if (typeof elementId !== 'string' || elementId === '') return undefined;
+          const slot = slots.resolveDomAlias(elementId) ?? slots.resolveRegisteredSlot(elementId);
+          return slot?.traceToken
+            ? Object.freeze({
+                slotId: slot.registeredSlotId,
+                elementId,
+                navigationGeneration: slot.navigationGeneration,
+                traceToken: slot.traceToken,
+              })
+            : undefined;
+        });
+        return;
+      }
+      if (
+        observation['kind'] !== 'render_attempt' ||
+        typeof observation['slotId'] !== 'string' ||
+        (observation['path'] !== 'auction' && observation['path'] !== 'ssat') ||
+        typeof observation['rendered'] !== 'boolean' ||
+        typeof observation['injected'] !== 'boolean'
+      ) {
+        return;
+      }
+      const terminal = observation['outcome'];
+      const terminalRecord =
+        typeof terminal === 'object' && terminal !== null
+          ? (terminal as Readonly<Record<string, unknown>>)
+          : undefined;
+      const attributableEmpty =
+        observation['state'] === 'failed' &&
+        terminalRecord?.['outcome'] === 'failed' &&
+        terminalRecord['reason'] === 'gam_empty';
+      if (observation['state'] !== 'accepted' && !attributableEmpty) return;
+      if ((observation['state'] === 'accepted') !== observation['rendered']) return;
+      const servedFrom = observation['servedFrom'];
+      if (servedFrom !== undefined && servedFrom !== 'inline' && servedFrom !== 'pbs-cache') {
+        return;
+      }
+      const slotId = observation['slotId'];
+      const slot = slots.resolveRegisteredSlot(slotId);
+      const optionalString = (name: 'adId' | 'bidId' | 'creativeId'): string | undefined => {
+        const value = observation[name];
+        return typeof value === 'string' && value !== '' ? value : undefined;
+      };
+      const adId = optionalString('adId');
+      const bidId = optionalString('bidId');
+      const creativeId = optionalString('creativeId');
+      renderTrace.record({
+        slotId,
+        path: observation['path'],
+        rendered: observation['rendered'],
+        injected: observation['injected'],
+        ...(slot?.domAliases[0] === undefined ? {} : { elementId: slot.domAliases[0] }),
+        ...(adId === undefined ? {} : { adId }),
+        ...(bidId === undefined ? {} : { bidId }),
+        ...(creativeId === undefined ? {} : { creativeId }),
+        ...(servedFrom === undefined ? {} : { servedFrom }),
+      });
+    };
+    const diagnostics = createDiagnosticsIngress({
+      reduce: consumeCoreObservation,
+      reportError: (error) => log.warn('diagnostics reducer failed', error),
+    });
+    scope.onDispose(() => diagnostics.dispose());
+    let apsValidation: Readonly<ApsMessagingValidationRegistration> | undefined;
+    const messagingValidation: MessagingValidationOptions = Object.freeze({
+      get expectedPublisherOrigin(): string {
+        return apsValidation?.expectedPublisherOrigin ?? '';
+      },
+      get expectedRendererUrl(): string {
+        return apsValidation?.expectedRendererUrl ?? '';
+      },
+      validateApsRenderer: (candidate: unknown): boolean =>
+        apsValidation?.validateApsRenderer(candidate) === true,
+    });
+    const messaging = createBrowserMessagingAdapter(
+      view as unknown as Parameters<typeof createBrowserMessagingAdapter>[0],
+      messagingValidation
+    );
+    scope.onDispose(() => {
+      apsValidation = undefined;
+    });
+    const reservations = createReservationService({
+      now: () => view.performance.now(),
+      prepareRenderSource: (candidate) => {
+        const source = parseBidRenderSourceV1(candidate);
+        return source?.type === 'pbs_cache' ? undefined : source;
+      },
+    });
+    scope.onDispose(() => reservations.dispose());
+    const bootstrapNonces = createBootstrapNonceRegistry();
+    scope.onDispose(() => bootstrapNonces.dispose());
+    const rendererNonces = createRendererNonceRegistry();
+    scope.onDispose(() => rendererNonces.dispose());
+    const session = createRuntimeSession({
+      createIdentityIssuer: createBrowserNavigationIdentityIssuer,
+      interfaces: Object.freeze({}),
+      onNavigationDispose: (generation) => {
+        artifacts.disposeNavigation(generation);
+        renderTrace.pruneNavigation(generation);
+        for (const slotId of Object.keys(renderTrace.diagnostics.current())) {
+          renderTrace.prune(slotId);
+        }
+      },
+    });
+    scope.onDispose(() => session.dispose());
+    const contextRegistry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(boot.manifest.integrations.map(({ id }) => id)),
+      onContributorFailure: (failure) => log.warn('auction context contributor failed', failure),
+      runtimeOwner: session,
+    });
+    scope.onDispose(() => contextRegistry.dispose());
+    const auctionContextService: RuntimeAuctionContextService = Object.freeze({
+      register: (integrationId: string, contributor: RuntimeAuctionContextContributor) =>
+        registerScopedContextContributor(contextRegistry, session, integrationId, contributor),
+    });
+    const navigationResult = session.startInitialNavigation(projection);
+    if (!navigationResult.ok) throw new TypeError(navigationResult.reason);
+    const navigation = navigationResult.value;
+    if (
+      !slots.register(
+        navigation,
+        projection.slots.map((placement) =>
+          Object.freeze({
+            domAliases: Object.freeze([placement.divId]),
+            registeredSlotId: placement.slot,
+            source: 'server' as const,
+          })
+        )
+      ).ok
+    ) {
+      throw new TypeError('render_runtime projection slots are invalid');
+    }
+    const registeredRenderers = new Map<RegisteredRenderSource, RegisteredRenderer>();
+    scope.onDispose(() => registeredRenderers.clear());
+    let pucGamAttemptRegistrar: ((input: PucGamAttemptInput) => boolean) | undefined;
+    scope.onDispose(() => {
+      pucGamAttemptRegistrar = undefined;
+    });
+    const createAttempt = (
+      owner: Parameters<typeof createRenderAttempt>[0]['owner'],
+      parentAttemptId?: string
+    ) =>
+      createRenderAttempt({
+        artifacts,
+        owner,
+        ...(parentAttemptId === undefined ? {} : { parentAttemptId }),
+        prepareRenderSource: (candidate) => {
+          const source = parseBidRenderSourceV1(candidate);
+          return source?.type === 'pbs_cache' ? undefined : source;
+        },
+        publishDiagnostics: diagnostics.publish,
+        reservations,
+      });
+    const resolveContainer = (slot: string): HTMLElement | undefined => {
+      const record = slots.resolveRegisteredSlot(slot);
+      if (!record) return undefined;
+      const identifiers =
+        record.source === 'programmatic'
+          ? new Set([record.registeredSlotId])
+          : new Set(record.domAliases);
+      const matches = [...document.querySelectorAll<HTMLElement>('[id]')].filter((element) =>
+        identifiers.has(element.id)
+      );
+      return matches.length === 1 ? matches[0] : undefined;
+    };
+    const renderWinner = (attempt: RenderAttempt): boolean => {
+      const container = resolveContainer(attempt.slot);
+      if (!container) {
+        attempt.fail('slot_unresolved');
+        return false;
+      }
+      if (attempt.renderSource?.type === 'adm') {
+        return renderDirectAdmAttempt({
+          attempt,
+          container,
+          prepareIframe: prepareAdmIframe,
+          publisherOrigin: origin,
+        });
+      }
+      if (attempt.renderSource?.type === 'aps') {
+        const renderer = registeredRenderers.get('aps');
+        if (renderer) return renderer(attempt, container);
+      }
+      attempt.fail('descriptor_invalid');
+      return false;
+    };
+    const batches = createAuctionBatchService({
+      createAttempt,
+      fetcher: (input, init) => globalThis.fetch(input, init),
+      parseResponse: parseTrustedServerAuctionResponseV1,
+      renderWinner,
+    });
+    scope.onDispose(() => batches.dispose());
+
+    const addAdUnits = (candidate: unknown): unknown => {
+      if (!active || !navigation.isCurrent()) throw new AdUnitRegistrationError('slot_collision');
+      const snapshot = slots.snapshotRegisteredSlots(navigation);
+      if (!snapshot) throw new AdUnitRegistrationError('slot_collision');
+      const prepared = prepareProgrammaticAdUnits(
+        candidate,
+        new Set(snapshot.map(({ registeredSlotId }) => registeredSlotId))
+      );
+      const registration = slots.register(
+        navigation,
+        prepared.map((unit) =>
+          Object.freeze({
+            directAuctionUnit: unit,
+            registeredSlotId: unit.code,
+            source: 'programmatic' as const,
+          })
+        )
+      );
+      if (!registration.ok) {
+        throw new AdUnitRegistrationError(
+          registration.reason === 'registry_capacity' ? 'registry_capacity' : 'slot_collision'
+        );
+      }
+      return addAdUnitsResult(prepared);
+    };
+
+    const requestAds = async (candidate?: unknown): Promise<unknown> => {
+      const validated = validateRequestAdsOptions(candidate);
+      const snapshot = slots.snapshotRegisteredSlots(navigation);
+      const requested = Object.freeze(
+        validated.slots
+          ? [...validated.slots]
+          : (snapshot ?? []).map(({ registeredSlotId }) => registeredSlotId)
+      );
+      if (!active || !navigation.isCurrent()) {
+        return Object.freeze({
+          slots: Object.freeze(
+            requested.map((slot) =>
+              slotResult({
+                slot,
+                path: 'primary',
+                outcome: 'cancelled',
+                reason: 'navigation_disposed',
+              })
+            )
+          ),
+        });
+      }
+      const recordsById = new Map(
+        (snapshot ?? []).map((record) => [record.registeredSlotId, record])
+      );
+      const admitted = requested
+        .map((slot) => recordsById.get(slot))
+        .filter((record): record is NonNullable<typeof record> => record !== undefined);
+      if (admitted.length === 0) {
+        return Object.freeze({
+          slots: Object.freeze(
+            requested.map((slot) =>
+              slotResult({
+                slot,
+                path: 'primary',
+                outcome: 'failed',
+                reason: 'slot_unresolved',
+              })
+            )
+          ),
+        });
+      }
+      const adUnits = admitted.map((record) => {
+        return (
+          record?.directAuctionUnit ??
+          Object.freeze({
+            code: record.registeredSlotId,
+            mediaTypes: Object.freeze({}),
+            bids: Object.freeze([]),
+          })
+        );
+      });
+      const requestBody = serializeAuctionRequestBody(adUnits, contextRegistry.snapshot());
+      if (!requestBody) {
+        return Object.freeze({
+          slots: Object.freeze(
+            requested.map((slot) =>
+              slotResult({ slot, path: 'primary', outcome: 'failed', reason: 'internal_error' })
+            )
+          ),
+        });
+      }
+      const batch = batches.create({
+        navigation,
+        requestBody,
+        ...(validated.signal ? { signal: validated.signal } : {}),
+        slots: Object.freeze(admitted.map(({ registeredSlotId }) => registeredSlotId)),
+        timeoutMs: validated.timeoutMs,
+      });
+      runtime.protectFirstDisplayAttemptBatch([batch.result]);
+      const result = await batch.result;
+      const bySlot = new Map(result.slots.map((entry) => [entry.slot, entry]));
+      return Object.freeze({
+        slots: Object.freeze(
+          requested.map(
+            (slot) =>
+              bySlot.get(slot) ??
+              slotResult({
+                slot,
+                path: 'primary',
+                outcome: 'failed',
+                reason: 'slot_unresolved',
+              })
+          )
+        ),
+      });
+    };
+
+    const slotsCapability = Object.freeze({
+      attachPhysicalService: (candidate: unknown): (() => void) => {
+        if (!active) throw new TypeError('GPT slot service provider is inactive');
+        const service = candidate as SlotService;
+        if (
+          typeof service !== 'object' ||
+          service === null ||
+          !Object.isFrozen(service) ||
+          typeof service.register !== 'function'
+        ) {
+          throw new TypeError('GPT slot service provider is invalid');
+        }
+        const release = slots.attach(service);
+        if (!release) throw new TypeError('GPT slot service provider is duplicated');
+        return release;
+      },
+      resolve: (id: string) => slots.resolveRegisteredSlot(id),
+      snapshot: () => slots.snapshotRegisteredSlots(navigation) ?? Object.freeze([]),
+    });
+    const auctionCapability = Object.freeze({ batches, navigation, projection, session });
+    const renderCapability = Object.freeze({
+      attachPucGamAttemptRegistrar: (
+        registrar: (input: PucGamAttemptInput) => boolean
+      ): (() => void) => {
+        if (!active || typeof registrar !== 'function' || pucGamAttemptRegistrar) {
+          throw new TypeError('PUC GAM attempt registrar is unavailable or duplicated');
+        }
+        pucGamAttemptRegistrar = registrar;
+        let released = false;
+        return (): void => {
+          if (released) return;
+          released = true;
+          if (pucGamAttemptRegistrar === registrar) pucGamAttemptRegistrar = undefined;
+        };
+      },
+      artifacts,
+      bindArtifactGuard: bindCommittedArtifactGuard,
+      bindArtifactRetirement: bindCommittedArtifactRetirement,
+      bootstrapNonces,
+      hostPositions,
+      createAttempt,
+      createPrebidSelectionCoordinator: (): PrebidSelectionCoordinator =>
+        createPrebidSelectionCoordinator({
+          activateAttempt: ({ attempt, owner, preparedBid }): boolean => {
+            if (!active) return false;
+            const registrar = pucGamAttemptRegistrar;
+            if (!registrar) return false;
+            try {
+              return (
+                registrar(
+                  Object.freeze({
+                    artifact: Object.freeze({
+                      kind: 'puc' as const,
+                      attemptId: attempt.id,
+                      slot: attempt.slot,
+                      navigationGeneration: attempt.navigationGeneration,
+                      dispose: () => undefined,
+                    }),
+                    attempt,
+                    owner,
+                    reservationId: preparedBid.bid.adId,
+                  })
+                ) === true
+              );
+            } catch {
+              return false;
+            }
+          },
+          createAttempt,
+          reservations,
+        }),
+      createSlotOperation,
+      commitPageBids: (
+        owner: NavigationSession,
+        slotRegistry: ProjectionSlotRegistry,
+        candidate: unknown
+      ): boolean =>
+        createPageBidsController({
+          navigation: owner,
+          parseProjection: (value) => parseBrowserAuctionProjectionV1(value),
+          slotRegistry,
+        }).commit(candidate).status === 'committed',
+      navigation,
+      mintLifecycleTicket: mintBrowserLifecycleTicket,
+      projection,
+      prepareAdmIframe,
+      renderWinner,
+      rendererNonces,
+      reservations,
+      publisherOrigin: origin,
+      publishPrebidBid: (input: Omit<PrebidBidPublicationInput, 'navigation' | 'reservations'>) =>
+        publishPrebidBid({ ...input, navigation, reservations }),
+      registerRenderer: (type: RegisteredRenderSource, renderer: RegisteredRenderer) => {
+        if (!active) throw new TypeError('render source provider is inactive');
+        if (type !== 'aps' || typeof renderer !== 'function' || registeredRenderers.has(type)) {
+          throw new TypeError('render source provider is invalid or duplicated');
+        }
+        registeredRenderers.set(type, renderer);
+        let released = false;
+        return (): void => {
+          if (released) return;
+          released = true;
+          if (registeredRenderers.get(type) === renderer) registeredRenderers.delete(type);
+        };
+      },
+      registerPucGamAttempt: (input: PucGamAttemptInput): boolean => {
+        if (!active) return false;
+        const registrar = pucGamAttemptRegistrar;
+        if (!registrar) return false;
+        try {
+          return registrar(input) === true;
+        } catch {
+          return false;
+        }
+      },
+    });
+    const messagesCapability = Object.freeze({
+      messaging,
+      registerApsValidation: (candidate: unknown): (() => void) => {
+        if (!active) throw new TypeError('APS message validation provider is inactive');
+        if (apsValidation) throw new TypeError('APS message validation provider is duplicated');
+        const validation = exactApsMessagingValidation(candidate, origin);
+        apsValidation = validation;
+        let released = false;
+        return (): void => {
+          if (released) return;
+          released = true;
+          if (apsValidation === validation) apsValidation = undefined;
+        };
+      },
+    });
+    const traceCapability = Object.freeze({
+      record: renderTrace.record,
+      enrich: renderTrace.enrich,
+      prune: renderTrace.prune,
+      diagnostics: renderTrace.diagnostics,
+      observations: Object.freeze({
+        publish: diagnostics.publish,
+      }),
+    });
+    const tracePresentationCapability = Object.freeze({
+      attachPresentation: renderTrace.attachPresentation,
+    });
+    const directCapability = Object.freeze({
+      addAdUnits,
+      requestAds,
+      diagnostics: Object.freeze({ renderTrace: renderTrace.diagnostics }),
+    });
+
+    return Object.freeze({
+      activate: (activation: IntegrationActivationContext) => {
+        if (active) throw new Error('render_runtime already activated');
+        const adoptedState =
+          activation.adoption === undefined
+            ? undefined
+            : adoptInitialRenderStateFromHandoff(
+                activation.adoption,
+                navigation,
+                reservations,
+                renderTrace
+              );
+        const adoptedArtifacts =
+          activation.adoption === undefined
+            ? undefined
+            : adoptInitialRenderArtifactsFromHandoff(
+                activation.adoption,
+                navigation,
+                artifacts,
+                hostPositions,
+                document
+              );
+        if (activation.adoption !== undefined && (!adoptedState || !adoptedArtifacts)) {
+          throw new TypeError('render_runtime first-display adoption is invalid');
+        }
+        const releaseAuctionContext = runtime.attachAuctionContextService(auctionContextService);
+        if (!releaseAuctionContext) {
+          throw new TypeError('render_runtime auction context service is duplicated');
+        }
+        active = true;
+        if (adoptedArtifacts) activation.afterCommit(adoptedArtifacts.arm);
+        activation.onDispose(releaseAuctionContext);
+        activation.onDispose(() => {
+          active = false;
+          apsValidation = undefined;
+          pucGamAttemptRegistrar = undefined;
+          registeredRenderers.clear();
+        });
+      },
+      interfaces: Object.freeze({
+        'slots.v1': slotsCapability,
+        'auction.v1': auctionCapability,
+        'render.v1': renderCapability,
+        'messages.v1': messagesCapability,
+        'trace.v1': traceCapability,
+        'trace.presentation.v1': tracePresentationCapability,
+        'direct.v1': directCapability,
+      }),
+    });
+  };
+  return Object.freeze({
+    abi: 1 as const,
+    id: 'render_runtime',
+    phase: 'takeover' as const,
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/render_runtime/prebid_selection.ts b/crates/trusted-server-js/lib/src/integrations/render_runtime/prebid_selection.ts
new file mode 100644
index 000000000..99f8c03ab
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/render_runtime/prebid_selection.ts
@@ -0,0 +1,726 @@
+import {
+  isRendererReservationIdV1,
+  ownDataObject,
+  validBoundedString,
+  validDimension,
+} from '../../core/contracts/auction_projection';
+import type { BrowserAuctionBidV1, BrowserAuctionProjectionV1 } from '../../core/types';
+import type {
+  AuctionBatchScope,
+  NavigationSession,
+  RenderAttemptScope,
+} from '../../kernel/sessions';
+import type {
+  RenderAttempt,
+  RenderAttemptCreationResult,
+  RenderScheduler,
+} from '../../services/render';
+import type { ReservationService } from '../../services/reservations';
+
+/** Capability-free trusted bid used by the render-owned Prebid selection service. */
+export interface PreparedTrustedBidV1 {
+  readonly auctionId: string;
+  readonly adUnitCode: string;
+  readonly bid: Readonly<{
+    readonly requestId: string;
+    readonly adId: string;
+    readonly cpm: number;
+    readonly width: number;
+    readonly height: number;
+    readonly ad: '';
+    readonly ttl: 300;
+    readonly creativeId: string;
+    readonly netRevenue: true;
+    readonly currency: 'USD';
+    readonly bidderCode: 'trustedServer';
+    readonly meta: Readonly<{
+      readonly advertiserDomains: readonly string[];
+      readonly tsAuctionId: string;
+      readonly tsBidId: string;
+      readonly tsAdmHash?: string;
+    }>;
+  }>;
+}
+
+/** Read-only Prebid query surface used only during an auction-end callback. */
+export interface PrebidEventFacade {
+  highestBids(adUnitCode?: string): readonly object[];
+}
+
+const objectIsFrozenIntrinsic = Object.isFrozen;
+
+function isPrebidAdmissionContractError(candidate: unknown): boolean {
+  try {
+    return (
+      candidate instanceof Error && Reflect.get(candidate, 'code') === 'prebid_partial_publication'
+    );
+  } catch {
+    return false;
+  }
+}
+
+export type PrebidBidPublicationFailureReason =
+  | 'descriptor_invalid'
+  | 'prebid_admission_failed'
+  | 'prebid_contract_violation'
+  | 'registry_full'
+  | 'reservation_collision'
+  | 'winner_not_renderable';
+
+export type PrebidBidPublicationResult =
+  | Readonly<{ ok: true; bid: Readonly<PreparedTrustedBidV1> }>
+  | Readonly<{ ok: false; reason: PrebidBidPublicationFailureReason }>;
+
+export type PrebidPublicationLifecycleFailureReason = Extract<
+  PrebidBidPublicationFailureReason,
+  'prebid_admission_failed' | 'prebid_contract_violation'
+>;
+
+type PrebidPublicationNavigation = NavigationSession;
+
+export interface PrebidBidPublicationInput {
+  readonly admitTrustedBid: (preparedBid: Readonly<PreparedTrustedBidV1>) => unknown;
+  readonly auctionId: string;
+  readonly adUnitCode: string;
+  readonly bid: BrowserAuctionBidV1;
+  readonly generatedBid: unknown;
+  readonly navigation: PrebidPublicationNavigation;
+  readonly reservations: Pick<ReservationService, 'registerPrebidLease' | 'tombstonePrebidLease'>;
+  readonly trackAdmittedBid: (
+    preparedBid: Readonly<PreparedTrustedBidV1>,
+    navigation: PrebidPublicationNavigation
+  ) => boolean;
+}
+
+type OwnedBrowserAuctionBidV1 = Extract<
+  BrowserAuctionBidV1,
+  { readonly rendererReservationId: string }
+>;
+
+function isOwnedBrowserAuctionBidV1(bid: BrowserAuctionBidV1): bid is OwnedBrowserAuctionBidV1 {
+  return 'rendererReservationId' in bid;
+}
+
+type OwnedPrebidBidPublicationInput = PrebidBidPublicationInput & {
+  readonly bid: OwnedBrowserAuctionBidV1;
+};
+
+function isCurrentProjectedWinner(
+  input: PrebidBidPublicationInput
+): input is OwnedPrebidBidPublicationInput {
+  const bid = input.bid;
+  if (!isOwnedBrowserAuctionBidV1(bid)) return false;
+  try {
+    const projection = input.navigation.currentAuctionProjection as
+      Readonly<BrowserAuctionProjectionV1> | undefined;
+    if (
+      !projection ||
+      !objectIsFrozenIntrinsic(projection) ||
+      !objectIsFrozenIntrinsic(projection.auction) ||
+      !objectIsFrozenIntrinsic(projection.auction.results) ||
+      !objectIsFrozenIntrinsic(projection.bids) ||
+      !objectIsFrozenIntrinsic(bid) ||
+      !objectIsFrozenIntrinsic(bid.targeting) ||
+      !objectIsFrozenIntrinsic(bid.renderSource) ||
+      !input.navigation.isCurrent() ||
+      input.auctionId !== projection.auction.auctionId ||
+      input.adUnitCode !== bid.slot ||
+      !isRendererReservationIdV1(bid.rendererReservationId)
+    ) {
+      return false;
+    }
+
+    let bidMatches = 0;
+    for (let index = 0; index < projection.bids.length; index += 1) {
+      if (projection.bids[index] === bid) bidMatches += 1;
+    }
+    if (bidMatches !== 1) return false;
+
+    let winnerMatches = 0;
+    for (let index = 0; index < projection.auction.results.length; index += 1) {
+      const result = projection.auction.results[index];
+      if (
+        result?.outcome === 'winner' &&
+        result.slot === bid.slot &&
+        result.candidateId === bid.candidateId
+      ) {
+        winnerMatches += 1;
+      }
+    }
+    return winnerMatches === 1;
+  } catch {
+    return false;
+  }
+}
+
+function prepareTrustedBid(
+  input: OwnedPrebidBidPublicationInput
+): Readonly<PreparedTrustedBidV1> | undefined {
+  try {
+    const generated = ownDataObject(input.generatedBid);
+    const width = input.bid.renderSource.width;
+    const height = input.bid.renderSource.height;
+    if (
+      !generated ||
+      !validBoundedString(generated.requestId, 64) ||
+      !validBoundedString(generated.adId, 128) ||
+      !Object.is(generated.cpm, input.bid.cpm) ||
+      generated.width !== width ||
+      generated.height !== height ||
+      !validDimension(width) ||
+      !validDimension(height)
+    ) {
+      return undefined;
+    }
+
+    const advertiserDomains = Object.freeze([] as string[]);
+    const meta = Object.freeze({
+      advertiserDomains,
+      tsAuctionId: input.auctionId,
+      tsBidId: input.bid.upstreamBidId,
+    });
+    const creativeId =
+      input.bid.renderSource.type === 'aps' && input.bid.renderSource.creativeId
+        ? input.bid.renderSource.creativeId
+        : input.bid.upstreamBidId;
+    const bid = Object.freeze({
+      requestId: generated.requestId,
+      adId: input.bid.rendererReservationId,
+      cpm: input.bid.cpm,
+      width,
+      height,
+      ad: '' as const,
+      ttl: 300 as const,
+      creativeId,
+      netRevenue: true as const,
+      currency: 'USD' as const,
+      bidderCode: 'trustedServer' as const,
+      meta,
+    });
+    return Object.freeze({ auctionId: input.auctionId, adUnitCode: input.adUnitCode, bid });
+  } catch {
+    return undefined;
+  }
+}
+
+function registrationFailure(reason: string): PrebidBidPublicationFailureReason {
+  if (reason === 'reservation_collision') return 'reservation_collision';
+  if (reason === 'registry_full') return 'registry_full';
+  if (reason === 'stale_owner' || reason === 'service_disposed') {
+    return 'winner_not_renderable';
+  }
+  if (
+    reason === 'invalid_reservation_id' ||
+    reason === 'invalid_slot' ||
+    reason === 'invalid_render_source' ||
+    reason === 'invalid_winner_context' ||
+    reason === 'prebid_cpm_mismatch'
+  ) {
+    return 'descriptor_invalid';
+  }
+  return 'prebid_admission_failed';
+}
+
+/** Register before exposing one TS-owned bid through the version-pinned Prebid boundary. */
+export function publishPrebidBid(input: PrebidBidPublicationInput): PrebidBidPublicationResult {
+  if (input.bid.renderSource.type === 'pbs_cache') {
+    return Object.freeze({ ok: false, reason: 'winner_not_renderable' });
+  }
+  if (!isCurrentProjectedWinner(input)) {
+    return Object.freeze({ ok: false, reason: 'winner_not_renderable' });
+  }
+  const preparedBid = prepareTrustedBid(input);
+  if (!preparedBid) return Object.freeze({ ok: false, reason: 'descriptor_invalid' });
+
+  const registration = (() => {
+    try {
+      return input.reservations.registerPrebidLease({
+        reservationId: input.bid.rendererReservationId,
+        slot: input.bid.slot,
+        navigation: input.navigation,
+        auctionId: input.auctionId,
+        adUnitCode: input.adUnitCode,
+        renderSource: input.bid.renderSource,
+        winnerContext: Object.freeze({ selectedCpm: input.bid.cpm }),
+        prebidBid: preparedBid.bid,
+      });
+    } catch {
+      return Object.freeze({ ok: false as const, reason: 'service_disposed' as const });
+    }
+  })();
+  if (!registration.ok) {
+    return Object.freeze({ ok: false, reason: registrationFailure(registration.reason) });
+  }
+
+  let failure: 'prebid_admission_failed' | 'prebid_contract_violation' | undefined;
+  try {
+    const admission = input.admitTrustedBid(preparedBid);
+    if (admission === 'not_admitted') failure = 'prebid_admission_failed';
+    else if (admission !== 'admitted') failure = 'prebid_contract_violation';
+  } catch (error) {
+    failure = isPrebidAdmissionContractError(error)
+      ? 'prebid_contract_violation'
+      : 'prebid_admission_failed';
+  }
+  if (!failure) {
+    try {
+      if (input.trackAdmittedBid(preparedBid, input.navigation)) {
+        return Object.freeze({ ok: true, bid: preparedBid });
+      }
+    } catch {
+      // A published bid without selection ownership must stay suppress-only.
+    }
+    failure = 'prebid_contract_violation';
+  }
+
+  const tombstoned = (() => {
+    try {
+      return input.reservations.tombstonePrebidLease(
+        {
+          reservationId: input.bid.rendererReservationId,
+          auctionId: input.auctionId,
+          adUnitCode: input.adUnitCode,
+          navigationGeneration: input.navigation.generation,
+        },
+        failure
+      );
+    } catch {
+      return false;
+    }
+  })();
+  return Object.freeze({
+    ok: false,
+    reason: tombstoned ? failure : 'prebid_contract_violation',
+  });
+}
+
+export interface PrebidSelectionCoordinatorOptions {
+  readonly activateAttempt: (
+    input: Readonly<{
+      attempt: RenderAttempt;
+      owner: RenderAttemptScope;
+      preparedBid: Readonly<PreparedTrustedBidV1>;
+    }>
+  ) => boolean;
+  readonly createAttempt: (owner: RenderAttemptScope) => RenderAttemptCreationResult;
+  readonly reservations: Pick<
+    ReservationService,
+    'promotePrebidSelection' | 'tombstone' | 'tombstonePrebidGroup'
+  >;
+  readonly scheduler?: RenderScheduler;
+}
+
+export interface PrebidSelectionCoordinator {
+  readonly track: (
+    preparedBid: Readonly<PreparedTrustedBidV1>,
+    navigation: NavigationSession
+  ) => boolean;
+  readonly auctionEnded: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void;
+  readonly settlePublicationFailure: (
+    navigation: NavigationSession,
+    auctionId: string,
+    adUnitCode: string,
+    reason: PrebidPublicationLifecycleFailureReason
+  ) => boolean;
+  readonly abort: (navigation: NavigationSession, auctionId: string) => void;
+  readonly dispose: () => void;
+}
+
+interface TrackedPrebidGroup {
+  readonly adUnitCode: string;
+  readonly auction: TrackedPrebidAuction;
+  readonly bids: Map<string, Readonly<PreparedTrustedBidV1>>;
+  active: boolean;
+  timer: unknown;
+}
+
+interface TrackedPrebidAuction {
+  readonly auctionId: string;
+  readonly batch: AuctionBatchScope;
+  readonly groups: Map<string, TrackedPrebidGroup>;
+  readonly navigation: NavigationSession;
+  active: boolean;
+  promotedAttempts: number;
+}
+
+const PREBID_SELECTION_TIMEOUT_MS = 10_000;
+
+function defaultSelectionScheduler(): RenderScheduler {
+  return Object.freeze({
+    clear: (handle: unknown): void => {
+      globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>);
+    },
+    set: (callback: () => void, milliseconds: number): unknown =>
+      globalThis.setTimeout(callback, milliseconds),
+  });
+}
+
+function exactSelectedBid(
+  candidate: unknown,
+  group: TrackedPrebidGroup
+): Readonly<PreparedTrustedBidV1> | undefined {
+  const record = ownDataObject(candidate);
+  if (
+    !record ||
+    record.auctionId !== group.auction.auctionId ||
+    record.adUnitCode !== group.adUnitCode ||
+    typeof record.adId !== 'string'
+  ) {
+    return undefined;
+  }
+  const prepared = group.bids.get(record.adId);
+  if (!prepared) return undefined;
+  const meta = ownDataObject(record.meta);
+  return record.requestId === prepared.bid.requestId &&
+    Object.is(record.cpm, prepared.bid.cpm) &&
+    record.bidderCode === prepared.bid.bidderCode &&
+    meta?.tsAuctionId === prepared.auctionId &&
+    meta.tsBidId === prepared.bid.meta.tsBidId
+    ? prepared
+    : undefined;
+}
+
+/** Own short Prebid-selection leases without exposing reservation state to the artifact. */
+export function createPrebidSelectionCoordinator(
+  options: PrebidSelectionCoordinatorOptions
+): PrebidSelectionCoordinator {
+  const scheduler = options.scheduler ?? defaultSelectionScheduler();
+  const auctions: TrackedPrebidAuction[] = [];
+  let disposed = false;
+
+  const removeAuction = (auction: TrackedPrebidAuction): void => {
+    const index = auctions.indexOf(auction);
+    if (index >= 0) auctions.splice(index, 1);
+    auction.active = false;
+  };
+
+  const clearGroupTimer = (group: TrackedPrebidGroup): void => {
+    if (group.timer === undefined) return;
+    const timer = group.timer;
+    group.timer = undefined;
+    try {
+      scheduler.clear(timer);
+    } catch {
+      // Timer cleanup cannot weaken reservation suppression.
+    }
+  };
+
+  const finishGroup = (
+    group: TrackedPrebidGroup,
+    state?: 'aborted' | 'prebid_selection_timeout' | 'unselected'
+  ): void => {
+    if (!group.active) return;
+    group.active = false;
+    clearGroupTimer(group);
+    if (state) {
+      try {
+        options.reservations.tombstonePrebidGroup(
+          {
+            auctionId: group.auction.auctionId,
+            adUnitCode: group.adUnitCode,
+            navigationGeneration: group.auction.navigation.generation,
+          },
+          state
+        );
+      } catch {
+        // The bounded reservation service remains the suppression authority.
+      }
+    }
+    group.auction.groups.delete(group.adUnitCode);
+    if (group.auction.groups.size !== 0) return;
+    if (group.auction.promotedAttempts === 0) {
+      try {
+        group.auction.batch.dispose();
+      } catch {
+        // Navigation disposal remains the final owner of a hostile batch.
+      }
+    }
+    removeAuction(group.auction);
+  };
+
+  const findAuction = (
+    navigation: NavigationSession,
+    auctionId: string
+  ): TrackedPrebidAuction | undefined => {
+    for (let index = 0; index < auctions.length; index += 1) {
+      const auction = auctions[index];
+      if (auction?.active && auction.navigation === navigation && auction.auctionId === auctionId) {
+        return auction;
+      }
+    }
+    return undefined;
+  };
+
+  const track = (
+    preparedBid: Readonly<PreparedTrustedBidV1>,
+    navigation: NavigationSession
+  ): boolean => {
+    try {
+      if (
+        disposed ||
+        !navigation.isCurrent() ||
+        !Object.isFrozen(preparedBid) ||
+        !Object.isFrozen(preparedBid.bid) ||
+        !isRendererReservationIdV1(preparedBid.bid.adId)
+      ) {
+        return false;
+      }
+      let auction = findAuction(navigation, preparedBid.auctionId);
+      let createdAuction = false;
+      if (!auction) {
+        const batch = navigation.createAuctionBatch(`prebid:${preparedBid.auctionId}`);
+        if (!batch) return false;
+        auction = {
+          auctionId: preparedBid.auctionId,
+          batch,
+          groups: new Map(),
+          navigation,
+          active: true,
+          promotedAttempts: 0,
+        };
+        createdAuction = true;
+      }
+      let group = auction.groups.get(preparedBid.adUnitCode);
+      if (group?.bids.has(preparedBid.bid.adId)) return false;
+      if (!group) {
+        group = {
+          adUnitCode: preparedBid.adUnitCode,
+          auction,
+          bids: new Map(),
+          active: true,
+          timer: undefined,
+        };
+        group.bids.set(preparedBid.bid.adId, preparedBid);
+        auction.groups.set(preparedBid.adUnitCode, group);
+        if (createdAuction) auctions.push(auction);
+        let timer: unknown;
+        try {
+          timer = scheduler.set(
+            () => finishGroup(group as TrackedPrebidGroup, 'prebid_selection_timeout'),
+            PREBID_SELECTION_TIMEOUT_MS
+          );
+          if (!group.active) {
+            try {
+              scheduler.clear(timer);
+            } catch {
+              // The synchronously-fired logical deadline remains terminal.
+            }
+            return false;
+          }
+          group.timer = timer;
+          navigation.onDispose('prebid-selection', () =>
+            finishGroup(group as TrackedPrebidGroup, 'aborted')
+          );
+          if (!group.active || !navigation.isCurrent()) {
+            finishGroup(group, 'aborted');
+            return false;
+          }
+        } catch {
+          if (timer !== undefined && group.timer === undefined) {
+            try {
+              scheduler.clear(timer);
+            } catch {
+              // Failed publication retains no live logical deadline.
+            }
+          }
+          finishGroup(group);
+          return false;
+        }
+        return true;
+      }
+      group.bids.set(preparedBid.bid.adId, preparedBid);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const settlePublicationFailure = (
+    navigation: NavigationSession,
+    auctionId: string,
+    adUnitCode: string,
+    reason: PrebidPublicationLifecycleFailureReason
+  ): boolean => {
+    let ephemeralBatch: AuctionBatchScope | undefined;
+    try {
+      if (
+        disposed ||
+        !navigation.isCurrent() ||
+        !validBoundedString(auctionId, 128) ||
+        !validBoundedString(adUnitCode, 256)
+      ) {
+        return false;
+      }
+      const tracked = findAuction(navigation, auctionId);
+      const batch = tracked?.batch ?? navigation.createAuctionBatch(`prebid:${auctionId}`);
+      if (!batch) return false;
+      if (!tracked) ephemeralBatch = batch;
+      const owner = batch.createRenderAttempt(adUnitCode);
+      if (!owner.ok) return false;
+      let created: RenderAttemptCreationResult;
+      try {
+        created = options.createAttempt(owner.value);
+      } catch {
+        owner.value.dispose();
+        return false;
+      }
+      if (!created.ok) {
+        owner.value.dispose();
+        return false;
+      }
+      return created.value.fail(reason);
+    } catch {
+      return false;
+    } finally {
+      try {
+        ephemeralBatch?.dispose();
+      } catch {
+        // The failed attempt is already terminal; navigation remains the final owner.
+      }
+    }
+  };
+
+  const auctionEnded = (event: unknown, prebid: Readonly<PrebidEventFacade>): void => {
+    if (disposed) return;
+    const record = ownDataObject(event);
+    if (!record || !validBoundedString(record.auctionId, 128)) return;
+    const snapshot = auctions.slice();
+    for (let auctionIndex = 0; auctionIndex < snapshot.length; auctionIndex += 1) {
+      const auction = snapshot[auctionIndex];
+      if (!auction?.active || auction.auctionId !== record.auctionId) continue;
+      const groups = [...auction.groups.values()];
+      for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+        const group = groups[groupIndex];
+        if (!group?.active) continue;
+        let highest: readonly object[];
+        try {
+          highest = prebid.highestBids(group.adUnitCode);
+        } catch {
+          continue;
+        }
+        if (highest.length !== 1) {
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        const selected: Readonly<PreparedTrustedBidV1>[] = [];
+        for (let bidIndex = 0; bidIndex < highest.length; bidIndex += 1) {
+          const match = exactSelectedBid(highest[bidIndex], group);
+          if (match) selected.push(match);
+        }
+        if (selected.length !== 1) {
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        const prepared = selected[0];
+        if (!prepared) {
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        const owner = auction.batch.createRenderAttempt(group.adUnitCode);
+        if (!owner.ok) {
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        let created: RenderAttemptCreationResult;
+        try {
+          created = options.createAttempt(owner.value);
+        } catch {
+          owner.value.dispose();
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        if (!created.ok) {
+          owner.value.dispose();
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        let promotion: ReturnType<ReservationService['promotePrebidSelection']>;
+        try {
+          promotion = options.reservations.promotePrebidSelection({
+            reservationId: prepared.bid.adId,
+            auctionId: prepared.auctionId,
+            adUnitCode: prepared.adUnitCode,
+            navigationGeneration: auction.navigation.generation,
+            attempt: owner.value,
+            prebidBid: prepared.bid,
+          });
+        } catch {
+          created.value.fail('prebid_contract_violation');
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        if (!promotion.ok) {
+          created.value.fail('prebid_contract_violation');
+          finishGroup(group, 'unselected');
+          continue;
+        }
+        let activated: boolean;
+        try {
+          activated =
+            options.activateAttempt(
+              Object.freeze({ attempt: created.value, owner: owner.value, preparedBid: prepared })
+            ) === true;
+        } catch {
+          activated = false;
+        }
+        if (!activated) {
+          try {
+            options.reservations.tombstone(
+              {
+                reservationId: prepared.bid.adId,
+                slot: prepared.adUnitCode,
+                navigationGeneration: auction.navigation.generation,
+                attemptId: owner.value.id,
+              },
+              'stale'
+            );
+          } catch {
+            // A failed PUC activation remains terminal at the attempt boundary.
+          }
+          created.value.fail('prebid_contract_violation');
+          finishGroup(group);
+          continue;
+        }
+        auction.promotedAttempts += 1;
+        finishGroup(group);
+      }
+    }
+  };
+
+  const abort = (navigation: NavigationSession, auctionId: string): void => {
+    const auction = findAuction(navigation, auctionId);
+    if (!auction) return;
+    const groups = [...auction.groups.values()];
+    for (let index = 0; index < groups.length; index += 1) {
+      const group = groups[index];
+      if (group) finishGroup(group, 'aborted');
+    }
+  };
+
+  return Object.freeze({
+    track,
+    auctionEnded,
+    settlePublicationFailure,
+    abort,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      const snapshot = auctions.slice();
+      for (let index = 0; index < snapshot.length; index += 1) {
+        const auction = snapshot[index];
+        if (!auction) continue;
+        const groups = [...auction.groups.values()];
+        for (let groupIndex = 0; groupIndex < groups.length; groupIndex += 1) {
+          const group = groups[groupIndex];
+          if (group) finishGroup(group, 'aborted');
+        }
+        try {
+          auction.batch.dispose();
+        } catch {
+          // Runtime disposal remains terminal under hostile callbacks.
+        }
+      }
+      auctions.length = 0;
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/render_runtime/transport_marker.ts b/crates/trusted-server-js/lib/src/integrations/render_runtime/transport_marker.ts
new file mode 100644
index 000000000..c47de412d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/render_runtime/transport_marker.ts
@@ -0,0 +1 @@
+// The mandatory render owner is co-bundled with the persistent runtime transport.
diff --git a/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent.ts b/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent.ts
new file mode 100644
index 000000000..9274327df
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent.ts
@@ -0,0 +1,13 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+
+import { createSourcepointIntegrationRegistration } from './module';
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createSourcepointIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent_mirror.ts b/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent_mirror.ts
new file mode 100644
index 000000000..7dc6e6b3a
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/sourcepoint/consent_mirror.ts
@@ -0,0 +1,299 @@
+import { log } from '../../core/log';
+
+const SP_CONSENT_PREFIX = '_sp_user_consent_';
+const GPP_COOKIE_NAME = '__gpp';
+const GPP_SID_COOKIE_NAME = '__gpp_sid';
+const GPP_SOURCE_COOKIE_NAME = '_ts_gpp_src';
+const GPP_SOURCE_SOURCEPOINT = 'sp';
+const INITIAL_RETRY_DELAY_MS = 500;
+
+interface SourcepointGppData {
+  gppString?: string | undefined;
+  applicableSections?: number[] | undefined;
+}
+
+interface SourcepointConsentStringEntry {
+  sectionId?: number | undefined;
+}
+
+interface SourcepointSectionPayload {
+  consentString?: string | undefined;
+  applicableSections?: number[] | undefined;
+  consentStrings?: SourcepointConsentStringEntry[] | undefined;
+}
+
+interface SourcepointConsentPayload {
+  gppData?: SourcepointGppData | undefined;
+  [key: string]: unknown;
+}
+
+interface MirroredSourcepointConsent {
+  gppString: string;
+  applicableSections?: number[] | undefined;
+}
+
+let initialized = false;
+let initialRetryDone = false;
+let retryTimer: number | undefined;
+let domContentLoadedHandler: (() => void) | undefined;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isNumberArray(value: unknown): value is number[] {
+  return Array.isArray(value) && value.every((item) => typeof item === 'number');
+}
+
+function isConsentStringEntryArray(value: unknown): value is SourcepointConsentStringEntry[] {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (item) =>
+        isRecord(item) &&
+        (typeof item.sectionId === 'number' || typeof item.sectionId === 'undefined')
+    )
+  );
+}
+
+function normalizeSectionPayload(value: unknown): SourcepointSectionPayload | null {
+  if (!isRecord(value)) return null;
+
+  return {
+    consentString: typeof value.consentString === 'string' ? value.consentString : undefined,
+    applicableSections: isNumberArray(value.applicableSections)
+      ? value.applicableSections
+      : undefined,
+    consentStrings: isConsentStringEntryArray(value.consentStrings)
+      ? value.consentStrings
+      : undefined,
+  };
+}
+
+function sectionIdsFromConsentStrings(
+  consentStrings: SourcepointConsentStringEntry[] | undefined
+): number[] | undefined {
+  const ids = consentStrings
+    ?.map((entry) => entry.sectionId)
+    .filter((sectionId): sectionId is number => typeof sectionId === 'number');
+
+  return ids && ids.length > 0 ? ids : undefined;
+}
+
+function looksLikeGpp(consentString: string): boolean {
+  return consentString.includes('~');
+}
+
+function extractMirroredConsent(
+  payload: SourcepointConsentPayload
+): MirroredSourcepointConsent | null {
+  if (payload.gppData?.gppString) {
+    return {
+      gppString: payload.gppData.gppString,
+      applicableSections: payload.gppData.applicableSections,
+    };
+  }
+
+  for (const [sectionName, rawSection] of Object.entries(payload)) {
+    if (sectionName === 'gppData') continue;
+
+    const section = normalizeSectionPayload(rawSection);
+    if (!section?.consentString || !looksLikeGpp(section.consentString)) continue;
+
+    return {
+      gppString: section.consentString,
+      applicableSections:
+        section.applicableSections ?? sectionIdsFromConsentStrings(section.consentStrings),
+    };
+  }
+
+  return null;
+}
+
+function findSourcepointConsent(): MirroredSourcepointConsent | null {
+  // Sourcepoint stores one consent payload per property under `_sp_user_consent_*`.
+  // We intentionally take the first valid match and mirror that origin-scoped payload.
+  for (let i = 0; i < localStorage.length; i++) {
+    const key = localStorage.key(i);
+    if (!key?.startsWith(SP_CONSENT_PREFIX)) continue;
+
+    const raw = localStorage.getItem(key);
+    if (!raw) continue;
+
+    try {
+      const payload = JSON.parse(raw) as SourcepointConsentPayload;
+      const consent = extractMirroredConsent(payload);
+      if (consent) {
+        return consent;
+      }
+    } catch {
+      log.debug('sourcepoint: failed to parse localStorage value', { key });
+    }
+  }
+  return null;
+}
+
+function readCookie(name: string): string | undefined {
+  const prefix = `${name}=`;
+  const cookie = document.cookie.split('; ').find((entry) => entry.startsWith(prefix));
+  return cookie?.slice(prefix.length);
+}
+
+function hasSourcepointMarker(): boolean {
+  return readCookie(GPP_SOURCE_COOKIE_NAME) === GPP_SOURCE_SOURCEPOINT;
+}
+
+function writeCookie(name: string, value: string): void {
+  document.cookie = `${name}=${value}; path=/; Secure; SameSite=Lax`;
+}
+
+function clearCookie(name: string): void {
+  document.cookie = `${name}=; path=/; Secure; SameSite=Lax; Max-Age=0`;
+}
+
+function clearSourcepointCookies(): void {
+  if (!hasSourcepointMarker()) {
+    return;
+  }
+
+  clearCookie(GPP_COOKIE_NAME);
+  clearCookie(GPP_SID_COOKIE_NAME);
+  clearCookie(GPP_SOURCE_COOKIE_NAME);
+}
+
+function mirrorOnVisible(): void {
+  if (document.visibilityState === 'visible') {
+    mirrorSourcepointConsent();
+  }
+}
+
+function clearInitialRetryTimer(): void {
+  if (retryTimer === undefined) {
+    return;
+  }
+
+  window.clearTimeout(retryTimer);
+  retryTimer = undefined;
+}
+
+function clearDomContentLoadedHandler(): void {
+  if (!domContentLoadedHandler) return;
+  document.removeEventListener('DOMContentLoaded', domContentLoadedHandler);
+  domContentLoadedHandler = undefined;
+}
+
+function scheduleInitialRetry(): void {
+  if (initialRetryDone || retryTimer !== undefined) {
+    return;
+  }
+
+  const retry = (): void => {
+    if (initialRetryDone) {
+      return;
+    }
+
+    initialRetryDone = true;
+    clearInitialRetryTimer();
+    clearDomContentLoadedHandler();
+    mirrorSourcepointConsent();
+  };
+
+  if (document.readyState === 'loading') {
+    domContentLoadedHandler = retry;
+    document.addEventListener('DOMContentLoaded', retry, { once: true });
+  }
+
+  retryTimer = window.setTimeout(retry, INITIAL_RETRY_DELAY_MS);
+}
+
+/**
+ * Reads Sourcepoint consent from localStorage and mirrors it into
+ * `__gpp` and `__gpp_sid` cookies for Trusted Server to read.
+ *
+ * Sourcepoint stores different shapes depending on the campaign/module. US
+ * National data is commonly stored under `usnat.consentString` and
+ * `usnat.applicableSections`, while some setups expose `gppData.gppString`.
+ *
+ * Returns `true` if cookies were written, `false` otherwise.
+ */
+export function mirrorSourcepointConsent(): boolean {
+  if (typeof localStorage === 'undefined' || typeof document === 'undefined') {
+    return false;
+  }
+
+  const consent = findSourcepointConsent();
+  if (!consent) {
+    clearSourcepointCookies();
+    log.debug('sourcepoint: no GPP data found in localStorage');
+    return false;
+  }
+
+  const { gppString, applicableSections } = consent;
+  if (!gppString) {
+    clearSourcepointCookies();
+    log.debug('sourcepoint: gppString is empty');
+    return false;
+  }
+
+  const existingGppCookie = readCookie(GPP_COOKIE_NAME);
+  if (existingGppCookie && existingGppCookie !== gppString && !hasSourcepointMarker()) {
+    log.debug('sourcepoint: preserving existing __gpp cookie from another writer');
+    return false;
+  }
+
+  writeCookie(GPP_SOURCE_COOKIE_NAME, GPP_SOURCE_SOURCEPOINT);
+  writeCookie(GPP_COOKIE_NAME, gppString);
+
+  if (Array.isArray(applicableSections) && applicableSections.length > 0) {
+    writeCookie(GPP_SID_COOKIE_NAME, applicableSections.join(','));
+  } else {
+    clearCookie(GPP_SID_COOKIE_NAME);
+  }
+
+  initialRetryDone = true;
+  clearInitialRetryTimer();
+  clearDomContentLoadedHandler();
+
+  log.info('sourcepoint: mirrored GPP consent to cookies', {
+    gppLength: gppString.length,
+    sections: applicableSections,
+  });
+
+  return true;
+}
+
+/**
+ * Initializes Sourcepoint consent mirroring and bounded refresh hooks.
+ */
+export function initializeSourcepointConsentMirror(): void {
+  if (initialized || typeof window === 'undefined' || typeof document === 'undefined') {
+    return;
+  }
+
+  initialized = true;
+
+  if (!mirrorSourcepointConsent()) {
+    scheduleInitialRetry();
+  }
+
+  // Sourcepoint persists consent changes to localStorage. Re-mirror when a
+  // user returns to the page so session cookies do not remain stale.
+  document.addEventListener('visibilitychange', mirrorOnVisible);
+  window.addEventListener('focus', mirrorSourcepointConsent);
+}
+
+/** Dispose every timer/listener owned by the active Sourcepoint consent mirror. */
+export function disposeSourcepointConsentMirror(): void {
+  if (typeof window !== 'undefined') {
+    window.removeEventListener('focus', mirrorSourcepointConsent);
+    clearInitialRetryTimer();
+  }
+  if (typeof document !== 'undefined') {
+    document.removeEventListener('visibilitychange', mirrorOnVisible);
+    clearDomContentLoadedHandler();
+  }
+  initialized = false;
+  initialRetryDone = false;
+  retryTimer = undefined;
+  domContentLoadedHandler = undefined;
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts b/crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts
index f323468bb..9274327df 100644
--- a/crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts
@@ -1,297 +1,13 @@
-import { log } from '../../core/log';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-import { installSourcepointGuard } from './script_guard';
+import { createSourcepointIntegrationRegistration } from './module';
 
-type SourcepointWindow = Window & {
-  __tsjs_sourcepoint?: {
-    rewriteSdk?: boolean;
-  };
-};
-
-function shouldInstallSourcepointGuard(): boolean {
-  if (typeof window === 'undefined') {
-    return false;
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createSourcepointIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
   }
-
-  const config = (window as SourcepointWindow).__tsjs_sourcepoint;
-  return config?.rewriteSdk !== false;
-}
-
-if (typeof window !== 'undefined' && shouldInstallSourcepointGuard()) {
-  installSourcepointGuard();
-  log.info('Sourcepoint integration initialized');
-}
-
-const SP_CONSENT_PREFIX = '_sp_user_consent_';
-const GPP_COOKIE_NAME = '__gpp';
-const GPP_SID_COOKIE_NAME = '__gpp_sid';
-const GPP_SOURCE_COOKIE_NAME = '_ts_gpp_src';
-const GPP_SOURCE_SOURCEPOINT = 'sp';
-const INITIAL_RETRY_DELAY_MS = 500;
-
-interface SourcepointGppData {
-  gppString?: string;
-  applicableSections?: number[];
-}
-
-interface SourcepointConsentStringEntry {
-  sectionId?: number;
-}
-
-interface SourcepointSectionPayload {
-  consentString?: string;
-  applicableSections?: number[];
-  consentStrings?: SourcepointConsentStringEntry[];
-}
-
-interface SourcepointConsentPayload {
-  gppData?: SourcepointGppData;
-  [key: string]: unknown;
-}
-
-interface MirroredSourcepointConsent {
-  gppString: string;
-  applicableSections?: number[];
-}
-
-let initialized = false;
-let initialRetryDone = false;
-let retryTimer: ReturnType<typeof window.setTimeout> | undefined;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function isNumberArray(value: unknown): value is number[] {
-  return Array.isArray(value) && value.every((item) => typeof item === 'number');
-}
-
-function isConsentStringEntryArray(value: unknown): value is SourcepointConsentStringEntry[] {
-  return (
-    Array.isArray(value) &&
-    value.every(
-      (item) =>
-        isRecord(item) &&
-        (typeof item.sectionId === 'number' || typeof item.sectionId === 'undefined')
-    )
-  );
-}
-
-function normalizeSectionPayload(value: unknown): SourcepointSectionPayload | null {
-  if (!isRecord(value)) return null;
-
-  return {
-    consentString: typeof value.consentString === 'string' ? value.consentString : undefined,
-    applicableSections: isNumberArray(value.applicableSections)
-      ? value.applicableSections
-      : undefined,
-    consentStrings: isConsentStringEntryArray(value.consentStrings)
-      ? value.consentStrings
-      : undefined,
-  };
-}
-
-function sectionIdsFromConsentStrings(
-  consentStrings: SourcepointConsentStringEntry[] | undefined
-): number[] | undefined {
-  const ids = consentStrings
-    ?.map((entry) => entry.sectionId)
-    .filter((sectionId): sectionId is number => typeof sectionId === 'number');
-
-  return ids && ids.length > 0 ? ids : undefined;
-}
-
-function looksLikeGpp(consentString: string): boolean {
-  return consentString.includes('~');
-}
-
-function extractMirroredConsent(
-  payload: SourcepointConsentPayload
-): MirroredSourcepointConsent | null {
-  if (payload.gppData?.gppString) {
-    return {
-      gppString: payload.gppData.gppString,
-      applicableSections: payload.gppData.applicableSections,
-    };
-  }
-
-  for (const [sectionName, rawSection] of Object.entries(payload)) {
-    if (sectionName === 'gppData') continue;
-
-    const section = normalizeSectionPayload(rawSection);
-    if (!section?.consentString || !looksLikeGpp(section.consentString)) continue;
-
-    return {
-      gppString: section.consentString,
-      applicableSections:
-        section.applicableSections ?? sectionIdsFromConsentStrings(section.consentStrings),
-    };
-  }
-
-  return null;
-}
-
-function findSourcepointConsent(): MirroredSourcepointConsent | null {
-  // Sourcepoint stores one consent payload per property under `_sp_user_consent_*`.
-  // We intentionally take the first valid match and mirror that origin-scoped payload.
-  for (let i = 0; i < localStorage.length; i++) {
-    const key = localStorage.key(i);
-    if (!key?.startsWith(SP_CONSENT_PREFIX)) continue;
-
-    const raw = localStorage.getItem(key);
-    if (!raw) continue;
-
-    try {
-      const payload = JSON.parse(raw) as SourcepointConsentPayload;
-      const consent = extractMirroredConsent(payload);
-      if (consent) {
-        return consent;
-      }
-    } catch {
-      log.debug('sourcepoint: failed to parse localStorage value', { key });
-    }
-  }
-  return null;
-}
-
-function readCookie(name: string): string | undefined {
-  const prefix = `${name}=`;
-  const cookie = document.cookie.split('; ').find((entry) => entry.startsWith(prefix));
-  return cookie?.slice(prefix.length);
-}
-
-function hasSourcepointMarker(): boolean {
-  return readCookie(GPP_SOURCE_COOKIE_NAME) === GPP_SOURCE_SOURCEPOINT;
 }
-
-function writeCookie(name: string, value: string): void {
-  document.cookie = `${name}=${value}; path=/; Secure; SameSite=Lax`;
-}
-
-function clearCookie(name: string): void {
-  document.cookie = `${name}=; path=/; Secure; SameSite=Lax; Max-Age=0`;
-}
-
-function clearSourcepointCookies(): void {
-  if (!hasSourcepointMarker()) {
-    return;
-  }
-
-  clearCookie(GPP_COOKIE_NAME);
-  clearCookie(GPP_SID_COOKIE_NAME);
-  clearCookie(GPP_SOURCE_COOKIE_NAME);
-}
-
-function mirrorOnVisible(): void {
-  if (document.visibilityState === 'visible') {
-    mirrorSourcepointConsent();
-  }
-}
-
-function clearInitialRetryTimer(): void {
-  if (retryTimer === undefined) {
-    return;
-  }
-
-  window.clearTimeout(retryTimer);
-  retryTimer = undefined;
-}
-
-function scheduleInitialRetry(): void {
-  if (initialRetryDone || retryTimer !== undefined) {
-    return;
-  }
-
-  const retry = (): void => {
-    if (initialRetryDone) {
-      return;
-    }
-
-    initialRetryDone = true;
-    clearInitialRetryTimer();
-    mirrorSourcepointConsent();
-  };
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', retry, { once: true });
-  }
-
-  retryTimer = window.setTimeout(retry, INITIAL_RETRY_DELAY_MS);
-}
-
-/**
- * Reads Sourcepoint consent from localStorage and mirrors it into
- * `__gpp` and `__gpp_sid` cookies for Trusted Server to read.
- *
- * Sourcepoint stores different shapes depending on the campaign/module. US
- * National data is commonly stored under `usnat.consentString` and
- * `usnat.applicableSections`, while some setups expose `gppData.gppString`.
- *
- * Returns `true` if cookies were written, `false` otherwise.
- */
-export function mirrorSourcepointConsent(): boolean {
-  if (typeof localStorage === 'undefined' || typeof document === 'undefined') {
-    return false;
-  }
-
-  const consent = findSourcepointConsent();
-  if (!consent) {
-    clearSourcepointCookies();
-    log.debug('sourcepoint: no GPP data found in localStorage');
-    return false;
-  }
-
-  const { gppString, applicableSections } = consent;
-  if (!gppString) {
-    clearSourcepointCookies();
-    log.debug('sourcepoint: gppString is empty');
-    return false;
-  }
-
-  const existingGppCookie = readCookie(GPP_COOKIE_NAME);
-  if (existingGppCookie && existingGppCookie !== gppString && !hasSourcepointMarker()) {
-    log.debug('sourcepoint: preserving existing __gpp cookie from another writer');
-    return false;
-  }
-
-  writeCookie(GPP_SOURCE_COOKIE_NAME, GPP_SOURCE_SOURCEPOINT);
-  writeCookie(GPP_COOKIE_NAME, gppString);
-
-  if (Array.isArray(applicableSections) && applicableSections.length > 0) {
-    writeCookie(GPP_SID_COOKIE_NAME, applicableSections.join(','));
-  } else {
-    clearCookie(GPP_SID_COOKIE_NAME);
-  }
-
-  initialRetryDone = true;
-  clearInitialRetryTimer();
-
-  log.info('sourcepoint: mirrored GPP consent to cookies', {
-    gppLength: gppString.length,
-    sections: applicableSections,
-  });
-
-  return true;
-}
-
-/**
- * Initializes Sourcepoint consent mirroring and bounded refresh hooks.
- */
-export function initializeSourcepointConsentMirror(): void {
-  if (initialized || typeof window === 'undefined' || typeof document === 'undefined') {
-    return;
-  }
-
-  initialized = true;
-
-  if (!mirrorSourcepointConsent()) {
-    scheduleInitialRetry();
-  }
-
-  // Sourcepoint persists consent changes to localStorage. Re-mirror when a
-  // user returns to the page so session cookies do not remain stale.
-  document.addEventListener('visibilitychange', mirrorOnVisible);
-  window.addEventListener('focus', mirrorSourcepointConsent);
-}
-
-initializeSourcepointConsentMirror();
diff --git a/crates/trusted-server-js/lib/src/integrations/sourcepoint/lifecycle.ts b/crates/trusted-server-js/lib/src/integrations/sourcepoint/lifecycle.ts
new file mode 100644
index 000000000..9fcb2ea88
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/sourcepoint/lifecycle.ts
@@ -0,0 +1,55 @@
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
+import { isSourcepointIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+
+interface SourcepointConsentCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly startLifecycle: () => void;
+}
+
+/** Build the release-bound later Sourcepoint lifecycle registration. */
+export function createSourcepointLifecycleIntegrationRegistration(
+  releaseId: string
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id: 'sourcepoint_lifecycle',
+    phase: 'deferred',
+    releaseId,
+    prepare: ({ config, interfaces }: IntegrationPrepareContext) => {
+      const capability = interfaces['sourcepoint_consent.v1'] as
+        SourcepointConsentCapabilityV1 | undefined;
+      if (
+        !isSourcepointIntegrationConfigV1(config) ||
+        !capability ||
+        !Object.isFrozen(capability) ||
+        typeof capability.activateLifecycle !== 'function' ||
+        typeof capability.startLifecycle !== 'function'
+      ) {
+        throw new TypeError('Sourcepoint lifecycle capability graph is invalid');
+      }
+      return Object.freeze({
+        activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+          const ownership: { release?: () => void } = {};
+          onDispose(() => ownership.release?.());
+          ownership.release = capability.activateLifecycle();
+          afterCommit(capability.startLifecycle);
+        },
+      });
+    },
+  });
+}
+
+if (typeof window !== 'undefined') {
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createSourcepointLifecycleIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/sourcepoint/module.ts b/crates/trusted-server-js/lib/src/integrations/sourcepoint/module.ts
new file mode 100644
index 000000000..c6ee9ffa3
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/sourcepoint/module.ts
@@ -0,0 +1,191 @@
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../kernel/integration_registry';
+import type { IntegrationLifecycleRuntime } from '../../kernel/lifecycle_module';
+import { isSourcepointIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import { validatePersistentFirstDisplaySliceAdoptionV1 } from '../../shared/takeover';
+
+import {
+  disposeSourcepointConsentMirror,
+  initializeSourcepointConsentMirror,
+  mirrorSourcepointConsent,
+} from './consent_mirror';
+import { installSourcepointGuard, resetGuardState } from './script_guard';
+
+export const SOURCEPOINT_INTEGRATION_ID = 'sourcepoint_consent' as const;
+
+interface SourcepointBootConfig {
+  readonly rewriteSdk: boolean;
+}
+
+export interface SourcepointRuntimeDependencies {
+  readonly initializeConsentMirror: () => void;
+  readonly installGuard: () => void;
+  readonly resetConsentMirror: () => void;
+  readonly resetGuard: () => void;
+}
+
+export interface SourcepointConsentCapabilityV1 {
+  readonly activateLifecycle: () => () => void;
+  readonly startLifecycle: () => void;
+}
+
+const sourcepointBootConfig = (candidate: unknown): candidate is SourcepointBootConfig =>
+  isSourcepointIntegrationConfigV1(candidate);
+
+/** Own Sourcepoint's optional guard and consent mirror as one release-bound unit. */
+export function createSourcepointRuntime(
+  dependencies: SourcepointRuntimeDependencies = {
+    initializeConsentMirror: initializeSourcepointConsentMirror,
+    installGuard: installSourcepointGuard,
+    resetConsentMirror: disposeSourcepointConsentMirror,
+    resetGuard: resetGuardState,
+  }
+): IntegrationLifecycleRuntime {
+  let active = false;
+  let guardInstalled = false;
+  let started = false;
+  return Object.freeze({
+    activate: (candidate: unknown) => {
+      if (!sourcepointBootConfig(candidate)) {
+        throw new TypeError('Sourcepoint integration config is invalid');
+      }
+      if (active) throw new Error('Sourcepoint runtime is already active');
+      if (candidate.rewriteSdk) {
+        try {
+          dependencies.installGuard();
+          guardInstalled = true;
+        } catch (error) {
+          try {
+            dependencies.resetGuard();
+          } catch {
+            // Preserve the activation failure after best-effort rollback.
+          }
+          throw error;
+        }
+      }
+      active = true;
+      started = false;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        started = false;
+        try {
+          dependencies.resetConsentMirror();
+        } finally {
+          if (guardInstalled) {
+            guardInstalled = false;
+            dependencies.resetGuard();
+          }
+        }
+      };
+    },
+    start: (_config: unknown) => {
+      if (!active || started) return;
+      started = true;
+      dependencies.initializeConsentMirror();
+    },
+  });
+}
+
+export function createSourcepointIntegrationRegistration(release: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces, onDispose }: IntegrationPrepareContext) => {
+    const runtimeCapability = interfaces['runtime.v1'];
+    if (
+      !sourcepointBootConfig(config) ||
+      typeof runtimeCapability !== 'object' ||
+      runtimeCapability === null ||
+      !Object.isFrozen(runtimeCapability)
+    ) {
+      throw new TypeError('Sourcepoint consent capability graph is invalid');
+    }
+    const lifecycle = createSourcepointRuntime({
+      initializeConsentMirror: initializeSourcepointConsentMirror,
+      installGuard: () => undefined,
+      resetConsentMirror: disposeSourcepointConsentMirror,
+      resetGuard: () => undefined,
+    });
+    let takeoverActive = false;
+    let guardInstalled = false;
+    let lifecycleRelease: (() => void) | undefined;
+    const capability: SourcepointConsentCapabilityV1 = Object.freeze({
+      activateLifecycle: () => {
+        if (!takeoverActive || lifecycleRelease) {
+          throw new TypeError('Sourcepoint lifecycle is unavailable');
+        }
+        lifecycleRelease = lifecycle.activate(config);
+        return (): void => {
+          const releaseLifecycle = lifecycleRelease;
+          lifecycleRelease = undefined;
+          releaseLifecycle?.();
+        };
+      },
+      startLifecycle: () => {
+        if (!takeoverActive || !lifecycleRelease) {
+          throw new TypeError('Sourcepoint lifecycle is not active');
+        }
+        lifecycle.start(config);
+      },
+    });
+    const releaseOwnedState = (): void => {
+      takeoverActive = false;
+      const releaseLifecycle = lifecycleRelease;
+      lifecycleRelease = undefined;
+      releaseLifecycle?.();
+      disposeSourcepointConsentMirror();
+      if (guardInstalled) {
+        guardInstalled = false;
+        resetGuardState();
+      }
+    };
+    onDispose(releaseOwnedState);
+    return Object.freeze({
+      activate: ({
+        adoption,
+        afterCommit,
+        onDispose: onActivationDispose,
+      }: IntegrationActivationContext) => {
+        if (takeoverActive) throw new Error('Sourcepoint consent is already active');
+        if (
+          adoption !== undefined &&
+          !validatePersistentFirstDisplaySliceAdoptionV1(
+            adoption,
+            'sourcepoint_initial',
+            (state) => {
+              const value = state.values[0]?.[1];
+              return (
+                state.values.length === 1 &&
+                state.values[0]?.[0] === 'gpp_snapshot' &&
+                typeof value === 'number' &&
+                Number.isInteger(value) &&
+                value >= 0
+              );
+            }
+          )
+        ) {
+          throw new TypeError('Sourcepoint first-display parser state is invalid');
+        }
+        if (config.rewriteSdk) {
+          installSourcepointGuard();
+          guardInstalled = true;
+        }
+        takeoverActive = true;
+        onActivationDispose(releaseOwnedState);
+        afterCommit(() => {
+          mirrorSourcepointConsent();
+        });
+      },
+      interfaces: Object.freeze({ 'sourcepoint_consent.v1': capability }),
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: SOURCEPOINT_INTEGRATION_ID,
+    phase: 'takeover',
+    releaseId: release,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/integrations/testlight/index.ts b/crates/trusted-server-js/lib/src/integrations/testlight/index.ts
index 3db00ce05..450d54663 100644
--- a/crates/trusted-server-js/lib/src/integrations/testlight/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/testlight/index.ts
@@ -1,81 +1,13 @@
-import type { TsjsApi } from '../../core/types';
-import { installQueue } from '../../core/queue';
-import { log } from '../../core/log';
-import { resolvePrebidWindow, PrebidWindow } from '../../shared/globals';
+import { EMBEDDED_RELEASE_ID } from '../../core/release';
 
-type TestlightCallback = () => void;
-
-type TestlightGlobal = {
-  que?: TestlightCallback[];
-};
-
-type TestlightWindow = PrebidWindow & {
-  testlight?: TestlightGlobal;
-};
-
-function ensureTsjsApi(win: TestlightWindow): TsjsApi {
-  if (win.tsjs) return win.tsjs;
-  const stub: TsjsApi = {
-    version: '0.0.0',
-    que: [],
-    addAdUnits: () => undefined,
-    renderAdUnit: () => undefined,
-    renderAllAdUnits: () => undefined,
-  };
-  win.tsjs = stub;
-  return stub;
-}
-
-function installTestlightQueue(api: TsjsApi, win: TestlightWindow): void {
-  if (!Array.isArray(api.que)) {
-    installQueue(api, win);
-  }
-}
-
-function flushCallbacks(queue: TestlightCallback[], api: TsjsApi): void {
-  while (queue.length > 0) {
-    const fn = queue.shift();
-    if (typeof fn !== 'function') {
-      continue;
-    }
-    try {
-      if (Array.isArray(api.que)) {
-        api.que.push(fn);
-      } else {
-        fn.call(api);
-      }
-      log.debug('testlight shim: flushed callback');
-    } catch (err) {
-      log.debug('testlight shim: queued callback threw', err);
-    }
-  }
-}
-
-export function installTestlightShim(): boolean {
-  const win = resolvePrebidWindow() as TestlightWindow;
-  const api = ensureTsjsApi(win);
-  installTestlightQueue(api, win);
-
-  const testlight = (win.testlight = win.testlight ?? {});
-  const pending: TestlightCallback[] = Array.isArray(testlight.que) ? [...testlight.que] : [];
-  const queue: TestlightCallback[] = [];
-  testlight.que = queue;
-
-  const originalPush = queue.push.bind(queue);
-  queue.push = function (...callbacks: TestlightCallback[]): number {
-    const len = originalPush(...callbacks);
-    flushCallbacks(queue, api);
-    return len;
-  };
-
-  if (pending.length > 0) {
-    queue.push(...pending);
-  }
-
-  log.info('testlight shim installed', { queuedCallbacks: queue.length });
-  return true;
-}
+import { createTestlightIntegrationRegistration } from './module';
 
 if (typeof window !== 'undefined') {
-  installTestlightShim();
+  const register = (window.tsjs as unknown as { _registerIntegration?: unknown } | undefined)
+    ?._registerIntegration;
+  if (typeof register === 'function') {
+    Reflect.apply(register, window.tsjs, [
+      createTestlightIntegrationRegistration(EMBEDDED_RELEASE_ID),
+    ]);
+  }
 }
diff --git a/crates/trusted-server-js/lib/src/integrations/testlight/module.ts b/crates/trusted-server-js/lib/src/integrations/testlight/module.ts
new file mode 100644
index 000000000..3f8bc4e19
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/integrations/testlight/module.ts
@@ -0,0 +1,260 @@
+import type { IntegrationRegistration } from '../../kernel/integration_registry';
+import { isEmptyIntegrationConfigV1 } from '../../shared/integration_config_validators';
+import type { RuntimeCapabilityV1 } from '../../kernel/runtime';
+import {
+  createLifecycleIntegrationRegistration,
+  type IntegrationLifecycleRuntime,
+} from '../../kernel/lifecycle_module';
+import { log } from '../../core/log';
+
+export const TESTLIGHT_INTEGRATION_ID = 'testlight' as const;
+
+interface TestlightGlobal {
+  que?: unknown[] | undefined;
+}
+
+interface TestlightTarget {
+  testlight?: TestlightGlobal | undefined;
+}
+
+export interface TestlightRuntimeDependencies {
+  readonly enqueue: (callback: () => void) => void;
+  readonly started: () => void;
+  readonly target: TestlightTarget;
+}
+
+function callableQueue(candidate: unknown): candidate is { push: (entry: unknown) => number } {
+  return (
+    (typeof candidate === 'object' || typeof candidate === 'function') &&
+    candidate !== null &&
+    typeof (candidate as { push?: unknown }).push === 'function'
+  );
+}
+
+function ownQueueValues(candidate: unknown): unknown[] {
+  if (!Array.isArray(candidate)) return [];
+  const entries: Array<readonly [number, unknown]> = [];
+  try {
+    for (const key of Reflect.ownKeys(candidate)) {
+      if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/.test(key)) continue;
+      const index = Number(key);
+      if (!Number.isSafeInteger(index) || index < 0 || index >= 4_294_967_295) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (descriptor && descriptor.enumerable && 'value' in descriptor) {
+        entries.push([index, descriptor.value]);
+      }
+    }
+  } catch {
+    return [];
+  }
+  entries.sort(([left], [right]) => left - right);
+  return entries.map(([, value]) => value);
+}
+
+/** Own Testlight's callback bridge without retaining callbacks after TSJS commit. */
+export function createTestlightRuntime(
+  dependencies: TestlightRuntimeDependencies = {
+    enqueue: (callback) => {
+      const queue = (window as typeof window & { tsjs?: { que?: unknown } }).tsjs?.que;
+      if (!callableQueue(queue)) throw new Error('Testlight TSJS queue is unavailable');
+      queue.push(callback);
+    },
+    started: () => log.info('Testlight integration initialized'),
+    target: window as typeof window & TestlightTarget,
+  }
+): IntegrationLifecycleRuntime {
+  let active = false;
+  let started = false;
+  let ownedGlobal: TestlightGlobal | undefined;
+  let installedQueue: unknown[] | undefined;
+  let previousQueueDescriptor: PropertyDescriptor | undefined;
+  let previousTargetDescriptor: PropertyDescriptor | undefined;
+  let createdGlobal = false;
+  let forwarding = false;
+  let originalQueue: unknown[] | undefined;
+  let originalQueueLength = 0;
+
+  const releaseOwnership = (): void => {
+    const global = ownedGlobal;
+    const queue = installedQueue;
+    const queueDescriptor = previousQueueDescriptor;
+    const targetDescriptor = previousTargetDescriptor;
+    const removeGlobal = createdGlobal;
+    const restoreQueue = originalQueue;
+    const restoreQueueLength = originalQueueLength;
+    const shouldReturnPending = !forwarding;
+    ownedGlobal = undefined;
+    installedQueue = undefined;
+    previousQueueDescriptor = undefined;
+    previousTargetDescriptor = undefined;
+    createdGlobal = false;
+    forwarding = false;
+    originalQueue = undefined;
+    originalQueueLength = 0;
+
+    if (global && queue) {
+      try {
+        if (Object.getOwnPropertyDescriptor(global, 'que')?.value === queue) {
+          if (shouldReturnPending && restoreQueue) {
+            const later = ownQueueValues(queue).slice(restoreQueueLength);
+            Array.prototype.push.apply(restoreQueue, later);
+          }
+          if (queueDescriptor) Object.defineProperty(global, 'que', queueDescriptor);
+          else Reflect.deleteProperty(global, 'que');
+        }
+      } catch {
+        // Publisher replacement wins over cleanup.
+      }
+    }
+    if (removeGlobal) {
+      try {
+        if (
+          Object.getOwnPropertyDescriptor(dependencies.target, 'testlight')?.value === global &&
+          global &&
+          Reflect.ownKeys(global).length === 0
+        ) {
+          if (targetDescriptor) {
+            Object.defineProperty(dependencies.target, 'testlight', targetDescriptor);
+          } else {
+            Reflect.deleteProperty(dependencies.target, 'testlight');
+          }
+        }
+      } catch {
+        // Publisher replacement wins over cleanup.
+      }
+    }
+  };
+
+  return Object.freeze({
+    activate: (_config: unknown): (() => void) => {
+      if (active) throw new Error('Testlight runtime is already active');
+      try {
+        previousTargetDescriptor = Object.getOwnPropertyDescriptor(
+          dependencies.target,
+          'testlight'
+        );
+        if (previousTargetDescriptor && !('value' in previousTargetDescriptor)) {
+          throw new TypeError('Testlight publisher global accessor is unsupported');
+        }
+        const currentGlobal = previousTargetDescriptor?.value;
+        const global =
+          typeof currentGlobal === 'object' && currentGlobal !== null ? currentGlobal : {};
+        createdGlobal = global !== currentGlobal;
+        if (createdGlobal) dependencies.target.testlight = global;
+        ownedGlobal = global;
+
+        previousQueueDescriptor = Object.getOwnPropertyDescriptor(global, 'que');
+        if (previousQueueDescriptor && !('value' in previousQueueDescriptor)) {
+          throw new TypeError('Testlight publisher queue accessor is unsupported');
+        }
+        originalQueue =
+          previousQueueDescriptor &&
+          'value' in previousQueueDescriptor &&
+          Array.isArray(previousQueueDescriptor.value)
+            ? previousQueueDescriptor.value
+            : undefined;
+        const queue = ownQueueValues(originalQueue);
+        originalQueueLength = queue.length;
+        Object.defineProperty(global, 'que', {
+          configurable: true,
+          enumerable: true,
+          value: queue,
+          writable: true,
+        });
+        installedQueue = queue;
+        forwarding = false;
+        active = true;
+        started = false;
+      } catch (error) {
+        releaseOwnership();
+        throw error;
+      }
+      return (): void => {
+        if (!active) return;
+        active = false;
+        started = false;
+        releaseOwnership();
+      };
+    },
+    start: (_config: unknown): void => {
+      if (!active || started) return;
+      started = true;
+      dependencies.started();
+
+      try {
+        const queue = installedQueue;
+        if (
+          !queue ||
+          !ownedGlobal ||
+          Object.getOwnPropertyDescriptor(ownedGlobal, 'que')?.value !== queue
+        ) {
+          return;
+        }
+        const pending = ownQueueValues(queue);
+        queue.length = 0;
+        const nativePush = queue.push.bind(queue);
+        Object.defineProperty(queue, 'push', {
+          configurable: true,
+          enumerable: false,
+          value: (...candidates: unknown[]): number => {
+            const length = nativePush(...candidates);
+            const forwarded = ownQueueValues(queue);
+            queue.length = 0;
+            for (const candidate of forwarded) {
+              if (typeof candidate !== 'function') continue;
+              try {
+                dependencies.enqueue(candidate as () => void);
+                log.debug('testlight shim: flushed callback');
+              } catch (error) {
+                log.debug('testlight shim: queued callback threw', error);
+              }
+            }
+            return length;
+          },
+          writable: false,
+        });
+        forwarding = true;
+        for (const candidate of pending) queue.push(candidate);
+      } catch (error) {
+        releaseOwnership();
+        throw error;
+      }
+    },
+  });
+}
+
+export function createTestlightIntegrationRegistration(release: string): IntegrationRegistration {
+  return createLifecycleIntegrationRegistration(TESTLIGHT_INTEGRATION_ID, release, {
+    createOwnedRuntime: ({ interfaces }) => {
+      const runtime = interfaces['runtime.v1'] as RuntimeCapabilityV1 | undefined;
+      const target = runtime?.document?.defaultView;
+      if (
+        !runtime ||
+        !Object.isFrozen(runtime) ||
+        typeof runtime.enqueue !== 'function' ||
+        !target
+      ) {
+        throw new TypeError('Testlight runtime capability is unavailable');
+      }
+      return createTestlightRuntime({
+        enqueue: (callback) => {
+          if (!runtime.enqueue(callback)) throw new Error('Testlight TSJS queue is unavailable');
+        },
+        started: () => log.info('Testlight integration initialized'),
+        target: target as Window & TestlightTarget,
+      });
+    },
+    firstDisplaySliceId: 'testlight_initial',
+    validateConfig: isEmptyIntegrationConfigV1,
+    validateFirstDisplayState: (state) => {
+      const value = state.values[0]?.[1];
+      return (
+        state.values.length === 1 &&
+        state.values[0]?.[0] === 'callback_count' &&
+        typeof value === 'number' &&
+        Number.isInteger(value) &&
+        value >= 0
+      );
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/contracts/message_protocol.ts b/crates/trusted-server-js/lib/src/kernel/contracts/message_protocol.ts
new file mode 100644
index 000000000..759449541
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/contracts/message_protocol.ts
@@ -0,0 +1,44 @@
+/** Every protocol literal shared by the version-1 browser message channels. */
+export const TSJS_MESSAGE_PROTOCOL_V1 = Object.freeze({
+  version: 1 as const,
+  rendererVersion: '4' as const,
+  message: Object.freeze({
+    prebidRequest: 'Prebid Request' as const,
+    prebidResponse: 'Prebid Response' as const,
+    ownerRegister: 'TS Render Owner Register' as const,
+    ownerRegistered: 'TS Render Owner Registered' as const,
+    ownerRefused: 'TS Render Owner Refused' as const,
+    apsTopMountStarted: 'TS APS Top Mount Started' as const,
+    admStart: 'TS ADM Start' as const,
+    ownerInserted: 'TS Owner Inserted' as const,
+    ownerSettled: 'TS Owner Settled' as const,
+    admLoaded: 'TS ADM Loaded' as const,
+    admFailed: 'TS ADM Failed' as const,
+    apsBootstrapReady: 'TS APS Bootstrap Ready' as const,
+    apsBootstrapConfigure: 'TS APS Bootstrap Configure' as const,
+    apsInnerReady: 'TS APS Inner Ready' as const,
+    apsInnerBind: 'TS APS Inner Bind' as const,
+    apsContainerReady: 'TS APS Container Ready' as const,
+    apsDocumentAccepted: 'TS APS Document Accepted' as const,
+    apsRunnerLoaded: 'TS APS Runner Loaded' as const,
+    apsRenderCompleted: 'TS APS Render Completed' as const,
+    apsRenderFailed: 'TS APS Render Failed' as const,
+  }),
+  status: Object.freeze({ ready: 'ready' as const, refused: 'refused' as const }),
+  kind: Object.freeze({ aps: 'aps' as const, adm: 'adm' as const }),
+  outcome: Object.freeze({
+    accepted: 'accepted' as const,
+    failed: 'failed' as const,
+    cancelled: 'cancelled' as const,
+  }),
+  runnerFailure: Object.freeze({
+    descriptorInvalid: 'descriptor_invalid' as const,
+    runnerNoLoad: 'runner_no_load' as const,
+    runnerFailed: 'runner_failed' as const,
+  }),
+  cancellation: Object.freeze({
+    callerAborted: 'caller_aborted' as const,
+    superseded: 'superseded' as const,
+    navigationDisposed: 'navigation_disposed' as const,
+  }),
+});
diff --git a/crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts b/crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts
new file mode 100644
index 000000000..29f664a7e
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts
@@ -0,0 +1,473 @@
+/**
+ * Install the self-contained renderer that PUC evaluates in its hidden frame.
+ *
+ * This function deliberately closes over nothing: its serialized source is the
+ * exact program returned in the successful outer PUC response.
+ */
+function installPucDynamicOwner(): void {
+  const ownerWindow = window as Window & {
+    render?: (data: unknown, helper: unknown, creativeWindow: Window) => Promise<void>;
+  };
+  const ticketPattern = /^t1_[A-Za-z0-9_-]{22}$/;
+  const reservationPattern = /^r1_[A-Za-z0-9_-]{22}$/;
+  const admSandbox =
+    'allow-forms allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation';
+  const ownerError = 'TS render owner ';
+  const messageEventDataGetter = Object.getOwnPropertyDescriptor(MessageEvent.prototype, 'data')
+    ?.get as ((this: MessageEvent) => unknown) | undefined;
+  const messageEventPortsGetter = Object.getOwnPropertyDescriptor(MessageEvent.prototype, 'ports')
+    ?.get as ((this: MessageEvent) => readonly MessagePort[]) | undefined;
+
+  const attempt = <T>(callback: () => T): T | undefined => {
+    try {
+      return callback();
+    } catch {
+      return undefined;
+    }
+  };
+  const closePort = (port: MessagePort | undefined): void => {
+    attempt(() => port?.close());
+  };
+
+  const ownDataValue = (candidate: unknown, name: string): unknown => {
+    return attempt(() => {
+      if (typeof candidate !== 'object' || candidate === null) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, name);
+      return descriptor && 'value' in descriptor ? descriptor.value : undefined;
+    });
+  };
+  const eventDataValue = (event: unknown): unknown => {
+    return attempt(() => {
+      if (typeof event !== 'object' || event === null) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(event, 'data');
+      if (descriptor) return 'value' in descriptor ? descriptor.value : undefined;
+      return messageEventDataGetter ? Reflect.apply(messageEventDataGetter, event, []) : undefined;
+    });
+  };
+
+  const exactRecord = (
+    candidate: unknown,
+    keys: readonly string[]
+  ): Record<string, unknown> | undefined => {
+    return attempt(() => {
+      if (
+        typeof candidate !== 'object' ||
+        candidate === null ||
+        Array.isArray(candidate) ||
+        Object.getPrototypeOf(candidate) !== Object.prototype ||
+        Object.getOwnPropertySymbols(candidate).length !== 0 ||
+        Object.getOwnPropertyNames(candidate).length !== keys.length
+      ) {
+        return undefined;
+      }
+      for (let index = 0; index < keys.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(candidate, keys[index] as string);
+        if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+      }
+      return candidate as Record<string, unknown>;
+    });
+  };
+  const inspectEventPorts = (
+    event: unknown
+  ):
+    | Readonly<{
+        exactShape: boolean;
+        originalCount: number;
+        ports: readonly MessagePort[];
+      }>
+    | undefined => {
+    return attempt(() => {
+      if (typeof event !== 'object' || event === null) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(event, 'ports');
+      const ports = descriptor
+        ? 'value' in descriptor
+          ? descriptor.value
+          : undefined
+        : messageEventPortsGetter
+          ? Reflect.apply(messageEventPortsGetter, event, [])
+          : undefined;
+      if (!Array.isArray(ports)) return undefined;
+      const length = Object.getOwnPropertyDescriptor(ports, 'length');
+      if (
+        !length ||
+        !('value' in length) ||
+        !Number.isSafeInteger(length.value) ||
+        length.value < 0
+      ) {
+        return undefined;
+      }
+      let exactShape =
+        Object.getPrototypeOf(ports) === Array.prototype &&
+        Object.getOwnPropertySymbols(ports).length === 0 &&
+        Object.getOwnPropertyNames(ports).length === length.value + 1;
+      const snapshot: MessagePort[] = [];
+      const seen = new Set<MessagePort>();
+      for (let index = 0; index < length.value; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(ports, String(index));
+        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
+          exactShape = false;
+          continue;
+        }
+        const port = descriptor.value as Partial<MessagePort> | undefined;
+        const validPort =
+          attempt(
+            () =>
+              !!port &&
+              typeof Reflect.get(port, 'postMessage') === 'function' &&
+              typeof Reflect.get(port, 'close') === 'function'
+          ) === true;
+        if (!port || !validPort) {
+          exactShape = false;
+          continue;
+        }
+        const accepted = port as MessagePort;
+        if (seen.has(accepted)) {
+          exactShape = false;
+          continue;
+        }
+        seen.add(accepted);
+        snapshot[snapshot.length] = accepted;
+      }
+      return { exactShape, originalCount: length.value, ports: snapshot };
+    });
+  };
+  const eventPorts = (event: unknown, count: number): MessagePort[] | undefined => {
+    const inspection = inspectEventPorts(event);
+    return inspection?.exactShape === true &&
+      inspection.originalCount === count &&
+      inspection.ports.length === count
+      ? (inspection.ports as MessagePort[])
+      : undefined;
+  };
+  const closeEventPorts = (event: unknown): void => {
+    const inspection = inspectEventPorts(event);
+    if (!inspection) return;
+    for (let index = 0; index < inspection.ports.length; index += 1) {
+      closePort(inspection.ports[index]);
+    }
+  };
+  const validDimension = (value: unknown): value is number =>
+    typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 4096;
+  const validAdmSource = (value: unknown): value is Record<string, unknown> => {
+    const source = exactRecord(value, ['type', 'version', 'adm', 'width', 'height']);
+    if (
+      !source ||
+      source['type'] !== 'adm' ||
+      source['version'] !== 1 ||
+      typeof source['adm'] !== 'string' ||
+      source['adm'].trim().length === 0 ||
+      new TextEncoder().encode(source['adm']).byteLength > 512 * 1024 ||
+      !validDimension(source['width']) ||
+      !validDimension(source['height'])
+    ) {
+      return false;
+    }
+    return true;
+  };
+  ownerWindow.render = (data, helper, creativeWindow) =>
+    new Promise<void>((resolve, reject) => {
+      let outer: Record<string, unknown> | undefined;
+      let owner: Record<string, unknown> | undefined;
+      let sendMessage: unknown;
+      try {
+        outer = exactRecord(data, ['adId', 'message', 'renderer', 'rendererVersion', 'tsOwner']);
+        owner = outer
+          ? exactRecord(outer['tsOwner'], ['version', 'status', 'kind', 'lifecycleTicket'])
+          : undefined;
+        sendMessage =
+          typeof helper === 'object' && helper !== null
+            ? Reflect.get(helper, 'sendMessage')
+            : undefined;
+      } catch {
+        outer = undefined;
+      }
+      const adId = outer?.['adId'];
+      const lifecycleTicket = owner?.['lifecycleTicket'];
+      const ownerKind = owner?.['kind'];
+      if (
+        !outer ||
+        !owner ||
+        outer['message'] !== 'Prebid Response' ||
+        outer['rendererVersion'] !== '4' ||
+        typeof adId !== 'string' ||
+        !reservationPattern.test(adId) ||
+        owner['version'] !== 1 ||
+        owner['status'] !== 'ready' ||
+        (owner['kind'] !== 'aps' && owner['kind'] !== 'adm') ||
+        typeof lifecycleTicket !== 'string' ||
+        !ticketPattern.test(lifecycleTicket) ||
+        typeof sendMessage !== 'function' ||
+        !creativeWindow ||
+        !creativeWindow.document
+      ) {
+        reject(new Error(`${ownerError}input refused`));
+        return;
+      }
+
+      let settled = false;
+      let registrationFinished = false;
+      let helperDisposer: (() => void) | undefined;
+      let ownerTimer: number | undefined;
+      let controlPort: MessagePort | undefined;
+      let frame: HTMLIFrameElement | undefined;
+      let ownerFrameCurrent: (() => boolean) | undefined;
+      let frameCommitted = false;
+      let started = false;
+
+      const removeFrameHandlers = (): void => {
+        if (!frame) return;
+        attempt(() => (frame!.onload = null));
+        attempt(() => (frame!.onerror = null));
+      };
+      const clearTimer = (handle: number | undefined): void => {
+        if (handle !== undefined) attempt(() => creativeWindow.clearTimeout(handle));
+      };
+      const removeFrame = (candidate: HTMLIFrameElement | undefined): void => {
+        attempt(() => candidate?.remove());
+      };
+      const stopHelper = (): void => {
+        const dispose = helperDisposer;
+        helperDisposer = undefined;
+        attempt(() => dispose?.());
+      };
+      const finish = (accepted: boolean, reason: string): void => {
+        if (settled) return;
+        settled = true;
+        clearTimer(registrationTimer);
+        clearTimer(ownerTimer);
+        stopHelper();
+        removeFrameHandlers();
+        if (!accepted && frame && !frameCommitted) removeFrame(frame);
+        if (controlPort) {
+          attempt(() => (controlPort!.onmessage = null));
+          attempt(() => (controlPort!.onmessageerror = null));
+        }
+        closePort(controlPort);
+        controlPort = undefined;
+        ownerFrameCurrent = undefined;
+        if (accepted) resolve();
+        else reject(new Error(reason));
+      };
+      const fail = (reason: string): void => finish(false, `${ownerError}${reason}`);
+      const postControl = (message: Record<string, unknown>): boolean => {
+        try {
+          if (!controlPort || settled) return false;
+          controlPort.postMessage(message);
+          return true;
+        } catch {
+          fail('control post failed');
+          return false;
+        }
+      };
+      const configureFrame = (
+        source: Record<string, unknown>,
+        sandbox: string
+      ): HTMLIFrameElement => {
+        const width = source['width'] as number;
+        const height = source['height'] as number;
+        const next = creativeWindow.document.createElement('iframe');
+        const attributes = [
+          'sandbox',
+          sandbox,
+          'referrerpolicy',
+          'no-referrer',
+          'width',
+          String(width),
+          'height',
+          String(height),
+          'scrolling',
+          'no',
+          'frameborder',
+          '0',
+          'marginwidth',
+          '0',
+          'marginheight',
+          '0',
+          'title',
+          'Ad content',
+          'aria-label',
+          'Advertisement',
+          'style',
+          `border: 0; margin: 0; overflow: hidden; display: block; width: ${width}px; height: ${height}px;`,
+        ];
+        for (let index = 0; index < attributes.length; index += 2) {
+          next.setAttribute(attributes[index]!, attributes[index + 1]!);
+        }
+        return next;
+      };
+      const prepareDocument = (): void => {
+        const document = creativeWindow.document;
+        document.documentElement.style.margin = '0';
+        document.documentElement.style.padding = '0';
+        document.documentElement.style.overflow = 'hidden';
+        if (document.body) {
+          document.body.style.margin = '0';
+          document.body.style.padding = '0';
+          document.body.style.overflow = 'hidden';
+        }
+      };
+      const insertAdm = (source: Record<string, unknown>): void => {
+        if (!validAdmSource(source) || !creativeWindow.document.body) {
+          finish(false, 'TS ADM source refused');
+          return;
+        }
+        prepareDocument();
+        const next = configureFrame(source, admSandbox);
+        const intendedSource = `<!doctype html><html><head><meta charset="utf-8"><meta name="referrer" content="no-referrer"><style>html,body{border:0;margin:0;padding:0;overflow:hidden}</style></head><body>${source['adm'] as string}</body></html>`;
+        ownerFrameCurrent = () =>
+          frame === next &&
+          next.parentNode === creativeWindow.document.body &&
+          next.srcdoc === intendedSource &&
+          next.getAttribute('src') === null;
+        next.onload = () => {
+          if (!settled && ownerFrameCurrent?.() === true) {
+            postControl({
+              message: 'TS ADM Loaded',
+              version: 1,
+              lifecycleTicket,
+            });
+          }
+        };
+        next.onerror = () => {
+          if (!settled && frame === next) {
+            postControl({
+              message: 'TS ADM Failed',
+              version: 1,
+              lifecycleTicket,
+            });
+          }
+        };
+        next.srcdoc = intendedSource;
+        frame = next;
+        creativeWindow.document.body.appendChild(next);
+        postControl({
+          message: 'TS Owner Inserted',
+          version: 1,
+          lifecycleTicket,
+        });
+      };
+      const receiveControl = (event: MessageEvent): void => {
+        if (settled) {
+          closeEventPorts(event);
+          return;
+        }
+        const ports = eventPorts(event, 0);
+        const dataValue = eventDataValue(event);
+        const routedMessage = ownDataValue(dataValue, 'message');
+        const routedOutcome = ownDataValue(dataValue, 'outcome');
+        const message = exactRecord(dataValue, [
+          'message',
+          'version',
+          'lifecycleTicket',
+          ...(routedMessage === 'TS ADM Start'
+            ? ['source']
+            : routedMessage === 'TS Owner Settled' && routedOutcome !== undefined
+              ? ['outcome']
+              : []),
+        ]);
+        if (
+          !message ||
+          !ports ||
+          message['version'] !== 1 ||
+          message['lifecycleTicket'] !== lifecycleTicket
+        ) {
+          closeEventPorts(event);
+          fail('control refused');
+          return;
+        }
+        if (message['message'] === 'TS ADM Start' && ownerKind === 'adm' && !started) {
+          started = true;
+          insertAdm(message['source'] as Record<string, unknown>);
+          return;
+        }
+        if (message['message'] === 'TS APS Top Mount Started' && ownerKind === 'aps' && !started) {
+          started = true;
+          return;
+        }
+        if (message['message'] === 'TS Owner Settled') {
+          if (
+            message['outcome'] === 'accepted' &&
+            started &&
+            (ownerKind === 'aps' || ownerFrameCurrent?.() === true)
+          ) {
+            frameCommitted = true;
+            finish(true, '');
+            return;
+          }
+          if (message['outcome'] === 'failed' || message['outcome'] === 'cancelled') {
+            finish(false, String(message['outcome']));
+            return;
+          }
+        }
+        closeEventPorts(event);
+        fail('control refused');
+      };
+      const receiveRegistration = (event: unknown): void => {
+        if (settled || registrationFinished) {
+          closeEventPorts(event);
+          return;
+        }
+        registrationFinished = true;
+        stopHelper();
+        clearTimer(registrationTimer);
+        const ports = eventPorts(event, 1);
+        const dataValue = eventDataValue(event);
+        const response =
+          typeof dataValue === 'string' &&
+          dataValue ===
+            JSON.stringify({
+              message: 'TS Render Owner Registered',
+              adId,
+              version: 1,
+              lifecycleTicket,
+            });
+        if (
+          !ports ||
+          !response ||
+          typeof adId !== 'string' ||
+          typeof lifecycleTicket !== 'string'
+        ) {
+          closeEventPorts(event);
+          fail('registration refused');
+          return;
+        }
+        const registeredPort = ports[0];
+        if (!registeredPort) {
+          fail('registration refused');
+          return;
+        }
+        controlPort = registeredPort;
+        ownerTimer = creativeWindow.setTimeout(() => fail('settlement timeout'), 20_000);
+        registeredPort.onmessage = receiveControl;
+        registeredPort.onmessageerror = () => fail('channel failed');
+        try {
+          registeredPort.start();
+        } catch {
+          fail('channel failed');
+        }
+      };
+
+      const registrationTimer = creativeWindow.setTimeout(
+        () => fail('registration timeout'),
+        3_000
+      );
+      try {
+        const disposer = Reflect.apply(sendMessage, helper, [
+          'TS Render Owner Register',
+          { version: 1, lifecycleTicket },
+          receiveRegistration,
+        ]) as unknown;
+        if (typeof disposer !== 'function') {
+          fail('registration failed');
+          return;
+        }
+        helperDisposer = disposer as () => void;
+        if (registrationFinished) stopHelper();
+      } catch {
+        fail('registration failed');
+      }
+    });
+}
+
+/** Exact checked-in program returned through PUC's dynamic renderer field. */
+export const PUC_DYNAMIC_OWNER = `(${String(installPucDynamicOwner)})();`;
diff --git a/crates/trusted-server-js/lib/src/kernel/contracts/release_capacity.ts b/crates/trusted-server-js/lib/src/kernel/contracts/release_capacity.ts
new file mode 100644
index 000000000..6a2fe10c9
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/contracts/release_capacity.ts
@@ -0,0 +1,9 @@
+declare const __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__: number;
+
+/** Build-generated bounded manifest capacity without importing the product catalog. */
+export const EMBEDDED_MAX_MANIFEST_MODULES =
+  Number.isSafeInteger(__TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__) &&
+  __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__ >= 1 &&
+  __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__ <= 256
+    ? __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__
+    : 0;
diff --git a/crates/trusted-server-js/lib/src/kernel/diagnostics.ts b/crates/trusted-server-js/lib/src/kernel/diagnostics.ts
new file mode 100644
index 000000000..36275dd30
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/diagnostics.ts
@@ -0,0 +1,146 @@
+const MAX_DIAGNOSTICS_OBSERVATION_DEPTH = 16;
+const MAX_DIAGNOSTICS_OBSERVATION_NODES = 512;
+const MAX_DIAGNOSTICS_PROPERTY_NAME_BYTES = 128;
+const MAX_DIAGNOSTICS_STRING_BYTES = 4096;
+
+export type DiagnosticsObservation = Readonly<Record<string, unknown>>;
+
+export interface DiagnosticsIngressOptions {
+  /** Closure-private core reducer; never included in the returned facade. */
+  readonly reduce: (observation: DiagnosticsObservation) => void;
+  readonly reportError?: (error: unknown) => void;
+}
+
+export interface DiagnosticsIngress {
+  readonly publish: (candidate: unknown) => boolean;
+  readonly dispose: () => void;
+}
+
+class InvalidDiagnosticsObservation extends Error {}
+
+function utf8Bytes(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function copyDiagnosticsObservation(candidate: unknown): DiagnosticsObservation | undefined {
+  const seen = new Set<object>();
+  let nodes = 0;
+
+  const copy = (value: unknown, depth: number): unknown => {
+    nodes += 1;
+    if (nodes > MAX_DIAGNOSTICS_OBSERVATION_NODES) {
+      throw new InvalidDiagnosticsObservation();
+    }
+    if (depth > MAX_DIAGNOSTICS_OBSERVATION_DEPTH) {
+      throw new InvalidDiagnosticsObservation();
+    }
+    if (value === null || typeof value === 'boolean') return value;
+    if (typeof value === 'number') {
+      if (!Number.isFinite(value)) throw new InvalidDiagnosticsObservation();
+      return value;
+    }
+    if (typeof value === 'string') {
+      if (utf8Bytes(value) > MAX_DIAGNOSTICS_STRING_BYTES) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      return value;
+    }
+    if (typeof value !== 'object') {
+      throw new InvalidDiagnosticsObservation();
+    }
+    if (seen.has(value)) throw new InvalidDiagnosticsObservation();
+    seen.add(value);
+
+    if (Array.isArray(value)) {
+      if (Object.getPrototypeOf(value) !== Array.prototype) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+      if (!lengthDescriptor || !('value' in lengthDescriptor)) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      const length = lengthDescriptor.value;
+      if (!Number.isSafeInteger(length) || length < 0) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      const keys = Reflect.ownKeys(value);
+      if (keys.length !== length + 1 || keys.some((key) => typeof key !== 'string')) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      const result: unknown[] = [];
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor?.enumerable || !('value' in descriptor)) {
+          throw new InvalidDiagnosticsObservation();
+        }
+        result.push(copy(descriptor.value, depth + 1));
+      }
+      return Object.freeze(result);
+    }
+
+    const prototype = Object.getPrototypeOf(value) as unknown;
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new InvalidDiagnosticsObservation();
+    }
+    const result = Object.create(null) as Record<string, unknown>;
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key !== 'string' || utf8Bytes(key) > MAX_DIAGNOSTICS_PROPERTY_NAME_BYTES) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) {
+        throw new InvalidDiagnosticsObservation();
+      }
+      Object.defineProperty(result, key, {
+        configurable: true,
+        enumerable: true,
+        value: copy(descriptor.value, depth + 1),
+        writable: true,
+      });
+    }
+    return Object.freeze(result) as DiagnosticsObservation;
+  };
+
+  try {
+    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+      return undefined;
+    }
+    return copy(candidate, 0) as DiagnosticsObservation;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Create the closure-private, synchronous diagnostics ingress for one runtime. */
+export function createDiagnosticsIngress(options: DiagnosticsIngressOptions): DiagnosticsIngress {
+  if (typeof options.reduce !== 'function') {
+    throw new TypeError('diagnostics reducer must be callable');
+  }
+  let reduce: DiagnosticsIngressOptions['reduce'] | undefined = options.reduce;
+  let reportError: DiagnosticsIngressOptions['reportError'] = options.reportError;
+  let disposed = false;
+
+  return Object.freeze({
+    publish: (candidate: unknown): boolean => {
+      if (disposed) return false;
+      const observation = copyDiagnosticsObservation(candidate);
+      if (!observation || disposed || !reduce) return false;
+      try {
+        reduce(observation);
+      } catch (error) {
+        try {
+          reportError?.(error);
+        } catch {
+          // Local diagnostics reporting cannot affect an accepted publication.
+        }
+      }
+      return true;
+    },
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      reduce = undefined;
+      reportError = undefined;
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/disposable.ts b/crates/trusted-server-js/lib/src/kernel/disposable.ts
new file mode 100644
index 000000000..52c6cf411
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/disposable.ts
@@ -0,0 +1,119 @@
+export type DisposeCallback = () => void;
+export type DisposalErrorHandler = (error: unknown) => void;
+
+const ignoreDisposalError: DisposalErrorHandler = () => undefined;
+
+function isThenable(value: unknown): value is PromiseLike<unknown> {
+  return (
+    (typeof value === 'object' || typeof value === 'function') &&
+    value !== null &&
+    typeof (value as { then?: unknown }).then === 'function'
+  );
+}
+
+/**
+ * A synchronous, owned disposer stack for browser targets that do not provide the
+ * TC39 DisposableStack proposal.
+ */
+export class DisposableStack {
+  private readonly abortController = new AbortController();
+  private readonly callbacks: DisposeCallback[] = [];
+  private isDisposed = false;
+
+  public constructor(private readonly onError: DisposalErrorHandler = ignoreDisposalError) {}
+
+  public get disposed(): boolean {
+    return this.isDisposed;
+  }
+
+  public get signal(): AbortSignal {
+    return this.abortController.signal;
+  }
+
+  public onDispose(callback: DisposeCallback): void {
+    if (typeof callback !== 'function') {
+      throw new TypeError('A disposer must be a function');
+    }
+
+    if (this.isDisposed) {
+      this.run(callback);
+      return;
+    }
+
+    this.callbacks.push(callback);
+  }
+
+  public dispose(): void {
+    if (this.isDisposed) return;
+    this.isDisposed = true;
+    this.abortController.abort();
+
+    for (let index = this.callbacks.length - 1; index >= 0; index -= 1) {
+      const callback = this.callbacks[index];
+      if (callback) this.run(callback);
+    }
+    this.callbacks.length = 0;
+  }
+
+  private run(callback: DisposeCallback): void {
+    try {
+      const returned = callback() as unknown;
+      if (isThenable(returned)) {
+        void Promise.resolve(returned).catch((error: unknown) => this.report(error));
+      }
+    } catch (error) {
+      this.report(error);
+    }
+  }
+
+  private report(error: unknown): void {
+    try {
+      this.onError(error);
+    } catch {
+      // Error reporting is observational and must not break remaining cleanup.
+    }
+  }
+}
+
+/** First-terminal-wins settlement coupled to synchronous resource disposal. */
+export class TerminalLatch<T> {
+  private readonly disposables: DisposableStack;
+  private readonly resolveCompletion: (value: T | PromiseLike<T>) => void;
+  private isTerminal = false;
+  private terminalValue: T | undefined;
+  public readonly completion: Promise<T>;
+
+  public constructor(onDisposalError: DisposalErrorHandler = ignoreDisposalError) {
+    this.disposables = new DisposableStack(onDisposalError);
+    let resolveCompletion: ((value: T | PromiseLike<T>) => void) | undefined;
+    this.completion = new Promise<T>((resolve) => {
+      resolveCompletion = resolve;
+    });
+    this.resolveCompletion = resolveCompletion as (value: T | PromiseLike<T>) => void;
+  }
+
+  public get terminal(): boolean {
+    return this.isTerminal;
+  }
+
+  public get value(): T | undefined {
+    return this.terminalValue;
+  }
+
+  public get signal(): AbortSignal {
+    return this.disposables.signal;
+  }
+
+  public onDispose(callback: DisposeCallback): void {
+    this.disposables.onDispose(callback);
+  }
+
+  public trySettle(value: T): boolean {
+    if (this.isTerminal) return false;
+    this.isTerminal = true;
+    this.terminalValue = value;
+    this.disposables.dispose();
+    this.resolveCompletion(value);
+    return true;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/fallback.ts b/crates/trusted-server-js/lib/src/kernel/fallback.ts
new file mode 100644
index 000000000..576ccd701
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/fallback.ts
@@ -0,0 +1,229 @@
+import { validateRequestAdsOptions } from '../core/contracts/request_ads';
+import { ownDataObject } from '../core/contracts/auction_projection';
+import { prepareProgrammaticAdUnits } from '../core/registry';
+import type { BootManifestV1, TsjsBootV1 } from '../core/types';
+
+import { publicLog, TsjsUnavailableError, type BootFailureReason } from './fallback_surface';
+
+export { AdUnitRegistrationError, type AdUnitRegistrationErrorCode } from '../core/registry';
+export { RequestAdsInputError, type RequestAdsInputErrorCode } from '../core/contracts/request_ads';
+export { publicLog, TsjsUnavailableError, type BootFailureReason } from './fallback_surface';
+
+const SAFE_PROJECTION = {
+  version: 1,
+  auction: { version: 1, auctionId: 'fallback', results: [] },
+  slots: [],
+  bids: [],
+} as const;
+const RUNTIME_SRC_PATTERN = /^\/static\/tsjs=tsjs-unified\.min\.js\?v=[0-9a-f]{64}$/;
+
+function exactHttpOrigin(candidate: unknown): string | undefined {
+  if (typeof candidate !== 'string') return undefined;
+  try {
+    const parsed = new URL(candidate);
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') &&
+      parsed.username === '' &&
+      parsed.password === '' &&
+      parsed.origin === candidate
+      ? parsed.origin
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve the document's authentication origin, including stamped opaque creatives. */
+export function trustedArtifactOrigin(runtimeDocument: Document): string | undefined {
+  try {
+    const view = runtimeDocument.defaultView;
+    const documentOrigin = exactHttpOrigin(view?.location.origin);
+    if (documentOrigin) return documentOrigin;
+    if (view?.location.origin !== 'null') return undefined;
+    const stamp = Object.getOwnPropertyDescriptor(view, '__tsCreativeOrigin');
+    if (!stamp || stamp.configurable || stamp.enumerable || !('value' in stamp) || stamp.writable) {
+      return undefined;
+    }
+    return exactHttpOrigin(stamp.value);
+  } catch {
+    return undefined;
+  }
+}
+
+function deepFreeze<T>(value: T): Readonly<T> {
+  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) return value;
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && 'value' in descriptor) deepFreeze(descriptor.value);
+  }
+  return Object.freeze(value);
+}
+
+function captureTrustedArtifactSrc(
+  runtimeDocument: Document,
+  script: HTMLScriptElement,
+  expectedId: 'trustedserver-js' | 'trustedserver-js-runtime'
+): string | undefined {
+  try {
+    const Script = runtimeDocument.defaultView?.HTMLScriptElement;
+    const origin = trustedArtifactOrigin(runtimeDocument);
+    if (
+      !Script ||
+      !origin ||
+      !(script instanceof Script) ||
+      script.ownerDocument !== runtimeDocument ||
+      script.id !== expectedId ||
+      !script.isConnected
+    ) {
+      return undefined;
+    }
+    const matches = runtimeDocument.querySelectorAll(`script#${expectedId}`);
+    if (matches.length !== 1 || matches[0] !== script) return undefined;
+    const absolute = new URL(script.src);
+    const runtimeSrc = `${absolute.pathname}${absolute.search}`;
+    if (
+      absolute.origin !== origin ||
+      absolute.hash !== '' ||
+      !RUNTIME_SRC_PATTERN.test(runtimeSrc) ||
+      new URL(runtimeSrc, origin).href !== absolute.href
+    ) {
+      return undefined;
+    }
+    return runtimeSrc;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Capture the canonical source owned by one parser-inserted persistent artifact tag. */
+export function captureTrustedSelectedRuntimeSrc(
+  runtimeDocument: Document,
+  script: HTMLScriptElement
+): string | undefined {
+  return captureTrustedArtifactSrc(runtimeDocument, script, 'trustedserver-js');
+}
+
+/** Capture the canonical source owned by the one post-paint runtime artifact tag. */
+export function captureTrustedRuntimeSrc(
+  runtimeDocument: Document,
+  script: HTMLScriptElement
+): string | undefined {
+  return captureTrustedArtifactSrc(runtimeDocument, script, 'trustedserver-js-runtime');
+}
+
+/** Validate and freeze the complete boot snapshot used by a committed kernel. */
+export function buildKernelBoot(
+  releaseId: string,
+  manifest: BootManifestV1,
+  candidate: unknown
+): Readonly<TsjsBootV1> | undefined {
+  try {
+    const record = ownDataObject(candidate, [
+      'abi',
+      'releaseId',
+      'manifest',
+      'auctionProjection',
+      'integrations',
+      'creative',
+      'diagnostics',
+    ]);
+    if (
+      !record ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate) ||
+      record.abi !== 1 ||
+      record.releaseId !== releaseId ||
+      record.manifest !== manifest ||
+      !Object.isFrozen(manifest) ||
+      !Object.isFrozen(record.auctionProjection) ||
+      !Object.isFrozen(record.integrations) ||
+      !Object.isFrozen(record.creative) ||
+      !Object.isFrozen(record.diagnostics)
+    ) {
+      return undefined;
+    }
+    return candidate as Readonly<TsjsBootV1>;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Build the immutable boot snapshot shared by every terminal fallback. */
+export function buildFallbackBoot(
+  releaseId: string,
+  trustedRuntimeSrc: string
+): Readonly<object> | undefined {
+  if (!RUNTIME_SRC_PATTERN.test(trustedRuntimeSrc)) {
+    return undefined;
+  }
+  const manifest: BootManifestV1 = {
+    version: 1,
+    releaseId,
+    firstDisplay: null,
+    runtimeSrc: trustedRuntimeSrc,
+    integrations: [],
+  };
+  return deepFreeze({
+    abi: 1,
+    releaseId,
+    manifest,
+    auctionProjection: SAFE_PROJECTION,
+    integrations: { version: 1, entries: [] },
+    creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+    diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+  });
+}
+
+export interface FallbackFieldsOptions {
+  readonly releaseId: string;
+  readonly reason: BootFailureReason;
+  readonly trustedRuntimeSrc: string;
+}
+
+/** Construct the complete, non-rendering public shell without runtime services. */
+export function createFallbackFields(
+  options: FallbackFieldsOptions
+): Readonly<Record<string, unknown>> | undefined {
+  const boot = buildFallbackBoot(options.releaseId, options.trustedRuntimeSrc);
+  if (!boot) return undefined;
+  const knownSlots = Object.freeze([] as string[]);
+  const known = new Set<string>();
+  const fields: Record<string, unknown> = {};
+  Object.defineProperties(fields, {
+    version: { enumerable: true, value: '1.0.0' },
+    releaseId: { enumerable: true, value: options.releaseId },
+    boot: { enumerable: true, value: boot },
+    log: { enumerable: true, value: publicLog },
+    _registerIntegration: { enumerable: true, value: () => false },
+    addAdUnits: {
+      enumerable: true,
+      value: (units: unknown) => {
+        prepareProgrammaticAdUnits(units, known);
+        throw new TsjsUnavailableError(options.releaseId, options.reason);
+      },
+    },
+    requestAds: {
+      enumerable: true,
+      value: async (requestOptions?: unknown) => {
+        const validated = validateRequestAdsOptions(requestOptions);
+        const selected = validated.slots ?? knownSlots;
+        return deepFreeze({
+          slots: selected.map((slot) =>
+            validated.aborted
+              ? { slot, path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' }
+              : { slot, path: 'primary', outcome: 'failed', reason: 'slot_unresolved' }
+          ),
+        });
+      },
+    },
+    _internal: {
+      enumerable: false,
+      value: Object.freeze({
+        state: 'fallback',
+        releaseId: options.releaseId,
+        reason: options.reason,
+        initialDisplayCommitted: false,
+      }),
+    },
+  });
+  return Object.freeze(fields);
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/fallback_surface.ts b/crates/trusted-server-js/lib/src/kernel/fallback_surface.ts
new file mode 100644
index 000000000..4e12cf396
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/fallback_surface.ts
@@ -0,0 +1,45 @@
+import { log } from '../core/log';
+
+export type BootFailureReason = 'abi_mismatch' | 'bundle_partial';
+
+export class TsjsUnavailableError extends Error {
+  public readonly code = 'runtime_unavailable' as const;
+
+  public constructor(
+    public readonly releaseId: string,
+    public readonly reason: BootFailureReason
+  ) {
+    super('TSJS runtime is unavailable');
+    this.name = 'TsjsUnavailableError';
+  }
+}
+
+const LOG_LEVELS = Object.freeze({
+  silent: true,
+  error: true,
+  warn: true,
+  info: true,
+  debug: true,
+});
+
+function observeLog(callback: () => void): void {
+  try {
+    callback();
+  } catch {
+    // The public logger is observation only.
+  }
+}
+
+export const publicLog = Object.freeze({
+  setLevel: (level: Parameters<typeof log.setLevel>[0]) => {
+    if (!Object.prototype.hasOwnProperty.call(LOG_LEVELS, level)) {
+      throw new TypeError('Invalid TSJS log level');
+    }
+    log.setLevel(level);
+  },
+  getLevel: () => log.getLevel(),
+  error: (...values: readonly unknown[]) => observeLog(() => log.error(...values)),
+  warn: (...values: readonly unknown[]) => observeLog(() => log.warn(...values)),
+  info: (...values: readonly unknown[]) => observeLog(() => log.info(...values)),
+  debug: (...values: readonly unknown[]) => observeLog(() => log.debug(...values)),
+});
diff --git a/crates/trusted-server-js/lib/src/kernel/identity.ts b/crates/trusted-server-js/lib/src/kernel/identity.ts
new file mode 100644
index 000000000..a3538914f
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/identity.ts
@@ -0,0 +1,350 @@
+const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const IDENTITY_FAILURE = Object.freeze({
+  ok: false as const,
+  reason: 'identity_generation_failed' as const,
+});
+
+/** Browser-compatible source for cryptographically secure random bytes. */
+export type RandomValuesSource = (target: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+
+/** The sole failure reported when secure identity generation is unavailable. */
+export type IdentityGenerationFailure = typeof IDENTITY_FAILURE;
+
+/** Result of creating or minting one browser identity. */
+export type IdentityGenerationResult<T> =
+  Readonly<{ ok: true; value: T }> | IdentityGenerationFailure;
+
+/** Observational identity failure callback that never receives identity material. */
+export type IdentityFailureObserver = (reason: 'identity_generation_failed') => void;
+
+/** Navigation-local issuer for non-repeating attempt identities. */
+export interface NavigationIdentityIssuer {
+  readonly adoptFirstDisplayState: (prefix: string, nextOrdinal: number) => boolean;
+  readonly adoptNextAttemptOrdinal: (nextOrdinal: number) => boolean;
+  readonly mintAttemptId: () => IdentityGenerationResult<string>;
+  readonly snapshotPrefix: () => string;
+  /** Return a frozen ordinal copy for deterministic tests. */
+  readonly snapshotOrdinalForTest: () => readonly [number, number];
+}
+
+/** Initial-display-only issuer; the projected batch is bounded to 256 attempts. */
+export interface FirstDisplayNavigationIdentityIssuer {
+  readonly mintAttemptId: () => IdentityGenerationResult<string>;
+  readonly snapshotPrefix: () => string;
+}
+
+/** Test-only controls for a deterministic navigation identity issuer. */
+export interface TestNavigationIdentityIssuerOptions {
+  readonly getRandomValues?: RandomValuesSource;
+  readonly initialOrdinal?: readonly [number, number];
+  readonly onFailure?: IdentityFailureObserver;
+}
+
+function reportFailure(observer?: IdentityFailureObserver): IdentityGenerationFailure {
+  try {
+    observer?.('identity_generation_failed');
+  } catch {
+    // Identity failure observation cannot change the typed failure.
+  }
+  return IDENTITY_FAILURE;
+}
+
+function randomBytes(
+  length: number,
+  source: RandomValuesSource | undefined,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<Uint8Array> {
+  if (!source) return reportFailure(observer);
+  try {
+    const bytes = new Uint8Array(new ArrayBuffer(length));
+    const returned = source(bytes);
+    if (returned !== bytes || bytes.length !== length) return reportFailure(observer);
+    return Object.freeze({ ok: true as const, value: bytes });
+  } catch {
+    return reportFailure(observer);
+  }
+}
+
+function encodeBase64Url(bytes: Uint8Array): string {
+  let encoded = '';
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index] ?? 0;
+    const second = bytes[index + 1] ?? 0;
+    const third = bytes[index + 2] ?? 0;
+    const remaining = bytes.length - index;
+    const combined = (first << 16) | (second << 8) | third;
+    encoded += BASE64URL_ALPHABET[(combined >>> 18) & 63];
+    encoded += BASE64URL_ALPHABET[(combined >>> 12) & 63];
+    if (remaining > 1) encoded += BASE64URL_ALPHABET[(combined >>> 6) & 63];
+    if (remaining > 2) encoded += BASE64URL_ALPHABET[combined & 63];
+  }
+  return encoded;
+}
+
+function decodeBase64UrlPrefix(value: string): Uint8Array<ArrayBuffer> | undefined {
+  if (!/^[A-Za-z0-9_-]{11}$/.test(value)) return undefined;
+  const bytes = new Uint8Array(new ArrayBuffer(8));
+  let byteIndex = 0;
+  let bits = 0;
+  let buffer = 0;
+  for (const character of value) {
+    const code = BASE64URL_ALPHABET.indexOf(character);
+    if (code < 0) return undefined;
+    buffer = (buffer << 6) | code;
+    bits += 6;
+    while (bits >= 8) {
+      bits -= 8;
+      if (byteIndex >= bytes.length) return undefined;
+      bytes[byteIndex] = (buffer >>> bits) & 0xff;
+      byteIndex += 1;
+      buffer &= bits === 0 ? 0 : (1 << bits) - 1;
+    }
+  }
+  if (byteIndex !== bytes.length || bits !== 2 || buffer !== 0) return undefined;
+  return bytes;
+}
+
+function validUnsignedWord(value: number): boolean {
+  return Number.isInteger(value) && value >= 0 && value <= 0xffff_ffff;
+}
+
+function createNavigationIdentityIssuer(
+  source: RandomValuesSource | undefined,
+  initialOrdinal: readonly [number, number],
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<NavigationIdentityIssuer> {
+  if (!validUnsignedWord(initialOrdinal[0]) || !validUnsignedWord(initialOrdinal[1])) {
+    return reportFailure(observer);
+  }
+  const prefixResult = randomBytes(8, source, observer);
+  if (!prefixResult.ok) return prefixResult;
+  let prefix: Uint8Array<ArrayBuffer>;
+  try {
+    prefix = new Uint8Array(new ArrayBuffer(8));
+    prefix.set(prefixResult.value);
+  } catch {
+    return reportFailure(observer);
+  }
+  let highWord = initialOrdinal[0] >>> 0;
+  let lowWord = initialOrdinal[1] >>> 0;
+  let adoptionOpen = highWord === 0 && lowWord === 0;
+
+  const issuer: NavigationIdentityIssuer = Object.freeze({
+    adoptFirstDisplayState(prefixValue: string, nextOrdinal: number): boolean {
+      const adoptedPrefix = decodeBase64UrlPrefix(prefixValue);
+      if (
+        !adoptionOpen ||
+        highWord !== 0 ||
+        lowWord !== 0 ||
+        !adoptedPrefix ||
+        !Number.isInteger(nextOrdinal) ||
+        nextOrdinal < 1 ||
+        nextOrdinal > 0xffff_ffff
+      ) {
+        return false;
+      }
+      prefix = adoptedPrefix;
+      lowWord = (nextOrdinal - 1) >>> 0;
+      adoptionOpen = false;
+      return true;
+    },
+    adoptNextAttemptOrdinal(nextOrdinal: number): boolean {
+      if (
+        !adoptionOpen ||
+        highWord !== 0 ||
+        lowWord !== 0 ||
+        !Number.isInteger(nextOrdinal) ||
+        nextOrdinal < 1 ||
+        nextOrdinal > 0xffff_ffff
+      ) {
+        return false;
+      }
+      lowWord = (nextOrdinal - 1) >>> 0;
+      adoptionOpen = false;
+      return true;
+    },
+    mintAttemptId(): IdentityGenerationResult<string> {
+      adoptionOpen = false;
+      if (highWord === 0xffff_ffff && lowWord === 0xffff_ffff) {
+        return reportFailure(observer);
+      }
+      try {
+        const nextHighWord = lowWord === 0xffff_ffff ? (highWord + 1) >>> 0 : highWord;
+        const nextLowWord = lowWord === 0xffff_ffff ? 0 : (lowWord + 1) >>> 0;
+        const identity = new Uint8Array(16);
+        identity.set(prefix, 0);
+        const view = new DataView(identity.buffer);
+        view.setUint32(8, nextHighWord, false);
+        view.setUint32(12, nextLowWord, false);
+        if (identity.byteLength !== 16) return reportFailure(observer);
+        for (let index = 0; index < prefix.length; index += 1) {
+          if (identity[index] !== prefix[index]) return reportFailure(observer);
+        }
+        if (
+          identity[8] !== nextHighWord >>> 24 ||
+          identity[9] !== ((nextHighWord >>> 16) & 0xff) ||
+          identity[10] !== ((nextHighWord >>> 8) & 0xff) ||
+          identity[11] !== (nextHighWord & 0xff) ||
+          identity[12] !== nextLowWord >>> 24 ||
+          identity[13] !== ((nextLowWord >>> 16) & 0xff) ||
+          identity[14] !== ((nextLowWord >>> 8) & 0xff) ||
+          identity[15] !== (nextLowWord & 0xff)
+        ) {
+          return reportFailure(observer);
+        }
+        const encoded = encodeBase64Url(identity);
+        if (encoded.length !== 22) return reportFailure(observer);
+        const result = Object.freeze({ ok: true as const, value: `a1_${encoded}` });
+        highWord = nextHighWord;
+        lowWord = nextLowWord;
+        return result;
+      } catch {
+        return reportFailure(observer);
+      }
+    },
+    snapshotOrdinalForTest: () => Object.freeze([highWord, lowWord] as const),
+    snapshotPrefix: () => encodeBase64Url(prefix),
+  });
+  return Object.freeze({ ok: true, value: issuer });
+}
+
+/** Create one navigation issuer from an explicitly scoped secure-random source. */
+export function createNavigationIdentityIssuerFromSource(
+  source: RandomValuesSource,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<NavigationIdentityIssuer> {
+  return createNavigationIdentityIssuer(source, [0, 0], observer);
+}
+
+/**
+ * Mint the same wire identities without bundling persistent adoption and u64
+ * rollover machinery into the protected first-display artifact.
+ */
+export function createFirstDisplayNavigationIdentityIssuerFromSource(
+  source: RandomValuesSource,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<FirstDisplayNavigationIdentityIssuer> {
+  const prefixResult = randomBytes(8, source, observer);
+  if (!prefixResult.ok) return prefixResult;
+  let prefix: Uint8Array<ArrayBuffer>;
+  try {
+    prefix = new Uint8Array(8);
+    prefix.set(prefixResult.value);
+  } catch {
+    return reportFailure(observer);
+  }
+  let ordinal = 0;
+  return Object.freeze({
+    ok: true,
+    value: Object.freeze({
+      mintAttemptId: (): IdentityGenerationResult<string> => {
+        if (ordinal >= 256) return reportFailure(observer);
+        try {
+          const next = ordinal + 1;
+          const identity = new Uint8Array(16);
+          identity.set(prefix);
+          new DataView(identity.buffer).setUint32(12, next, false);
+          if (
+            identity.byteLength !== 16 ||
+            identity[12] !== 0 ||
+            identity[13] !== 0 ||
+            identity[14] !== next >>> 8 ||
+            identity[15] !== (next & 0xff)
+          ) {
+            return reportFailure(observer);
+          }
+          for (let index = 0; index < prefix.length; index += 1) {
+            if (identity[index] !== prefix[index]) return reportFailure(observer);
+          }
+          const encoded = encodeBase64Url(identity);
+          if (encoded.length !== 22) return reportFailure(observer);
+          ordinal = next;
+          return Object.freeze({ ok: true, value: `a1_${encoded}` });
+        } catch {
+          return reportFailure(observer);
+        }
+      },
+      snapshotPrefix: () => encodeBase64Url(prefix),
+    }),
+  });
+}
+
+function browserRandomSource(): RandomValuesSource | undefined {
+  try {
+    if (typeof crypto !== 'object' || typeof crypto.getRandomValues !== 'function') {
+      return undefined;
+    }
+    return (target: Uint8Array<ArrayBuffer>) => {
+      crypto.getRandomValues(target);
+      return target;
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Create a production navigation issuer from browser Web Crypto only. */
+export function createBrowserNavigationIdentityIssuer(): IdentityGenerationResult<NavigationIdentityIssuer> {
+  const source = browserRandomSource();
+  return source ? createNavigationIdentityIssuerFromSource(source) : IDENTITY_FAILURE;
+}
+
+/** Create a deterministic navigation issuer for tests only. */
+export function createTestNavigationIdentityIssuer(
+  options: TestNavigationIdentityIssuerOptions
+): IdentityGenerationResult<NavigationIdentityIssuer> {
+  return createNavigationIdentityIssuer(
+    options.getRandomValues,
+    options.initialOrdinal ?? [0, 0],
+    options.onFailure
+  );
+}
+
+function mintFreshIdentity(
+  prefix: 't1_' | 'b1_' | 'n1_',
+  source: RandomValuesSource | undefined,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<string> {
+  const bytes = randomBytes(16, source, observer);
+  if (!bytes.ok) return bytes;
+  return Object.freeze({ ok: true, value: `${prefix}${encodeBase64Url(bytes.value)}` });
+}
+
+/** Mint one production lifecycle ticket from sixteen browser Web Crypto bytes. */
+export function mintBrowserLifecycleTicket(): IdentityGenerationResult<string> {
+  return mintFreshIdentity('t1_', browserRandomSource());
+}
+
+/** Mint one production bootstrap nonce from sixteen browser Web Crypto bytes. */
+export function mintBrowserBootstrapNonce(): IdentityGenerationResult<string> {
+  return mintFreshIdentity('b1_', browserRandomSource());
+}
+
+/** Mint one production renderer nonce from sixteen browser Web Crypto bytes. */
+export function mintBrowserRendererNonce(): IdentityGenerationResult<string> {
+  return mintFreshIdentity('n1_', browserRandomSource());
+}
+
+/** Mint one deterministic lifecycle ticket for tests only. */
+export function mintTestLifecycleTicket(
+  source: RandomValuesSource,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<string> {
+  return mintFreshIdentity('t1_', source, observer);
+}
+
+/** Mint one deterministic bootstrap nonce for tests only. */
+export function mintTestBootstrapNonce(
+  source: RandomValuesSource,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<string> {
+  return mintFreshIdentity('b1_', source, observer);
+}
+
+/** Mint one deterministic renderer nonce for tests only. */
+export function mintTestRendererNonce(
+  source: RandomValuesSource,
+  observer?: IdentityFailureObserver
+): IdentityGenerationResult<string> {
+  return mintFreshIdentity('n1_', source, observer);
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/integration_registry.ts b/crates/trusted-server-js/lib/src/kernel/integration_registry.ts
new file mode 100644
index 000000000..14e221920
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/integration_registry.ts
@@ -0,0 +1,1690 @@
+import type { BootManifestV1 } from '../core/types';
+import {
+  snapshotOutlinedFirstDisplayCaptureV1,
+  type FirstDisplayHandoffV1,
+} from '../shared/first_display_contracts';
+import { snapshotPersistentFirstDisplayAdoptionV1 } from '../shared/takeover';
+
+import type { ReleaseConfigSourceV1 } from './release_catalog';
+import { EMBEDDED_MAX_MANIFEST_MODULES } from './contracts/release_capacity';
+import { DisposableStack, type DisposeCallback } from './disposable';
+import { trustedArtifactOrigin, type BootFailureReason } from './fallback';
+import { createBrowserNavigationIdentityIssuer } from './identity';
+
+const INTEGRATION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const RELEASE_ID = /^[0-9a-f]{64}$/;
+const MAX_INTEGRATIONS = EMBEDDED_MAX_MANIFEST_MODULES;
+const MAX_KNOWN_INTEGRATIONS = 256;
+const BOOT_DEADLINE_MS = 10_000;
+const EMPTY_BINDING = Object.freeze({});
+const ABORTED = Symbol('aborted');
+
+export type IntegrationRegistryState =
+  'collecting' | 'preparing' | 'activating' | 'publishing' | 'committed' | 'failed' | 'disposed';
+
+export interface IntegrationBindings {
+  readonly config: unknown;
+  readonly interfaces: Readonly<Record<string, unknown>>;
+}
+
+export interface IntegrationPrepareContext extends IntegrationBindings {
+  readonly signal: AbortSignal;
+  readonly onDispose: (callback: DisposeCallback) => void;
+}
+
+export interface IntegrationActivationContext {
+  readonly signal: AbortSignal;
+  readonly onDispose: (callback: DisposeCallback) => void;
+  readonly afterCommit: (callback: () => void) => void;
+  /** Closure-private first-display state, present only during an atomic takeover activation. */
+  readonly adoption?: unknown;
+}
+
+export interface CoreActivationContext {
+  readonly signal: AbortSignal;
+  readonly onDispose: (callback: DisposeCallback) => void;
+}
+
+export interface CorePreparationContext {
+  readonly signal: AbortSignal;
+  readonly onDispose: (callback: DisposeCallback) => void;
+}
+
+export interface PreparedIntegration {
+  readonly activate: (context: IntegrationActivationContext) => void;
+  /** Exact catalog-declared capability facades owned by this provider. */
+  readonly interfaces?: Readonly<Record<string, unknown>>;
+}
+
+export interface TakeoverIntegrationRegistration {
+  readonly abi: 1;
+  readonly id: string;
+  readonly phase: 'takeover';
+  readonly releaseId: string;
+  readonly prepareSync: (context: IntegrationPrepareContext) => PreparedIntegration;
+  readonly prepare: (
+    context: IntegrationPrepareContext
+  ) => PreparedIntegration | PromiseLike<PreparedIntegration>;
+}
+
+export interface DeferredIntegrationRegistration {
+  readonly abi: 1;
+  readonly id: string;
+  readonly phase: 'deferred';
+  readonly releaseId: string;
+  readonly prepare: (
+    context: IntegrationPrepareContext
+  ) => PreparedIntegration | PromiseLike<PreparedIntegration>;
+}
+
+export type IntegrationRegistration =
+  TakeoverIntegrationRegistration | DeferredIntegrationRegistration;
+
+export interface IntegrationRuntimeFailure {
+  readonly id: string;
+  readonly phase: 'after_commit';
+}
+
+/** One-use, non-yielding barrier exposed only after every inert preparation succeeds. */
+export interface PreparedKernelTakeover {
+  /** Validate and freeze the complete handoff before either owner mutates state. */
+  readonly validateHandoff: (
+    handoff: unknown,
+    outline: unknown,
+    boot?: unknown
+  ) => FirstDisplayHandoffV1 | undefined;
+  readonly activate: (adoption?: unknown) => void;
+  readonly commit: () => void;
+  readonly rollback: () => void;
+}
+
+export interface IntegrationInstallCallbacks {
+  /** Allocates inert composition-owned services before integration preparation. */
+  readonly prepareCore?: (context: CorePreparationContext) => void;
+  /** Installs reversible core listeners before any integration module activation. */
+  readonly activateCore: (context: CoreActivationContext) => void;
+  /** Installs the complete API synchronously. It must not yield or invoke publisher code. */
+  readonly publish: () => void;
+  /** Drains the already-committed preload queue. Callback isolation belongs to the queue. */
+  readonly drainPreload: () => void;
+  /** Coordinates an old-owner handoff around the synchronous activation and publication barrier. */
+  readonly coordinateTakeover?: (prepared: PreparedKernelTakeover) => void;
+}
+
+export interface IntegrationKernelResult {
+  readonly state: 'kernel';
+  readonly runtimeFailures: readonly IntegrationRuntimeFailure[];
+  readonly dispose: () => void;
+}
+
+export interface IntegrationFallbackResult {
+  readonly state: 'fallback';
+  readonly reason: BootFailureReason;
+}
+
+export type IntegrationInstallResult = IntegrationKernelResult | IntegrationFallbackResult;
+
+export interface IntegrationRegistryOptions {
+  readonly manifest: unknown;
+  readonly releaseId: string;
+  /** Frozen build/composition inventory of integration ids this core release knows. */
+  readonly knownIntegrationIds: readonly string[];
+  /** Exact release-owned phase/order authority; production uses the embedded catalog. */
+  readonly catalog?: readonly IntegrationCatalogEntry[];
+  /** Kernel-owned root capability; never published or returned by the registry facade. */
+  readonly runtimeCapability?: Readonly<Record<string, unknown>>;
+  /** Captured parser-inserted takeover script; required by production runtime. */
+  readonly takeoverScript?: HTMLScriptElement;
+  readonly takeoverScriptId?: 'trustedserver-js' | 'trustedserver-js-runtime';
+  readonly document?: Document;
+  readonly currentScript?: () => HTMLScriptElement | null;
+  readonly startedAtMs: number;
+  readonly now?: () => number;
+  readonly signal?: AbortSignal;
+  readonly getBindings?: (id: string) => IntegrationBindings;
+  /** Monotonic bootstrap-generation guard supplied by the composition owner. */
+  readonly isCurrentOwner?: () => boolean;
+  readonly onDisposalError?: (error: unknown) => void;
+  readonly onCapabilityStaged?: (
+    key: string,
+    facade: Readonly<Record<string, unknown>>
+  ) => void | DisposeCallback;
+  readonly onRuntimeFailure?: (failure: IntegrationRuntimeFailure) => void;
+  /** Production transport hook; invoked inline after the final takeover registration. */
+  readonly onTakeoverRegistrationsReady?: () => void;
+}
+
+export interface IntegrationCatalogEntry {
+  readonly id: string;
+  readonly phase: 'takeover' | 'deferred';
+  readonly trigger: 'first_display_or_idle' | null;
+  readonly config?: ReleaseConfigSourceV1;
+  readonly consumes: readonly string[];
+  readonly provides: readonly string[];
+}
+
+export interface IntegrationRegistry {
+  readonly state: IntegrationRegistryState;
+  readonly manifest: BootManifestV1 | undefined;
+  readonly register: (candidate: unknown) => boolean;
+  readonly prepareDeferred: (
+    registration: DeferredIntegrationRegistration,
+    owner: Readonly<{
+      signal: AbortSignal;
+      onDispose: (callback: DisposeCallback) => void;
+    }>
+  ) => PreparedIntegration | PromiseLike<PreparedIntegration>;
+  readonly installSync: (callbacks: IntegrationInstallCallbacks) => IntegrationInstallResult;
+  readonly install: (callbacks: IntegrationInstallCallbacks) => Promise<IntegrationInstallResult>;
+  readonly dispose: () => void;
+}
+
+interface PreparedRecord {
+  readonly id: string;
+  readonly scope: DisposableStack;
+  readonly module: PreparedIntegration;
+  afterCommit: (() => void) | undefined;
+}
+
+function isRecord(value: unknown): value is Record<PropertyKey, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value) as unknown;
+  return prototype === Object.prototype || prototype === null;
+}
+
+function readExactDataFields(
+  value: unknown,
+  expected: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  if (!isRecord(value)) return undefined;
+  const keys = Reflect.ownKeys(value);
+  if (
+    keys.length !== expected.length ||
+    !keys.every((key) => typeof key === 'string' && expected.includes(key))
+  ) {
+    return undefined;
+  }
+
+  const fields: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const key of expected) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+    fields[key] = descriptor.value;
+  }
+  return fields;
+}
+
+/** Snapshot the exact phase-discriminated registrar value without invoking bundle code. */
+export function snapshotIntegrationRegistration(
+  candidate: unknown
+): IntegrationRegistration | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    const phaseDescriptor = Object.getOwnPropertyDescriptor(candidate, 'phase');
+    if (!phaseDescriptor?.enumerable || !('value' in phaseDescriptor)) return undefined;
+    const phase = phaseDescriptor.value;
+    const fields = readExactDataFields(
+      candidate,
+      phase === 'takeover'
+        ? ['abi', 'id', 'phase', 'releaseId', 'prepareSync', 'prepare']
+        : phase === 'deferred'
+          ? ['abi', 'id', 'phase', 'releaseId', 'prepare']
+          : []
+    );
+    if (!fields) return undefined;
+    const { abi, id, releaseId, prepare } = fields;
+    if (
+      abi !== 1 ||
+      typeof id !== 'string' ||
+      !INTEGRATION_ID.test(id) ||
+      typeof releaseId !== 'string' ||
+      !RELEASE_ID.test(releaseId) ||
+      typeof prepare !== 'function' ||
+      (phase === 'takeover' && typeof fields.prepareSync !== 'function')
+    ) {
+      return undefined;
+    }
+    return phase === 'takeover'
+      ? Object.freeze({
+          abi: 1,
+          id,
+          phase,
+          releaseId,
+          prepareSync: fields.prepareSync as TakeoverIntegrationRegistration['prepareSync'],
+          prepare: prepare as TakeoverIntegrationRegistration['prepare'],
+        })
+      : Object.freeze({
+          abi: 1,
+          id,
+          phase,
+          releaseId,
+          prepare: prepare as DeferredIntegrationRegistration['prepare'],
+        });
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotExactArray(value: unknown, maximumLength: number): readonly unknown[] | undefined {
+  if (!Array.isArray(value) || value.length > maximumLength) return undefined;
+  const expectedKeys = Array.from({ length: value.length }, (_, index) => String(index));
+  expectedKeys.push('length');
+  const actualKeys = Reflect.ownKeys(value);
+  if (
+    actualKeys.length !== expectedKeys.length ||
+    !actualKeys.every((key) => typeof key === 'string' && expectedKeys.includes(key))
+  ) {
+    return undefined;
+  }
+
+  const snapshot: unknown[] = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !('value' in descriptor)) return undefined;
+    snapshot.push(descriptor.value);
+  }
+  return Object.freeze(snapshot);
+}
+
+function validateKnownIntegrationIds(candidate: unknown): ReadonlySet<string> | undefined {
+  if (!Object.isFrozen(candidate)) return undefined;
+  const ids = snapshotExactArray(candidate, MAX_KNOWN_INTEGRATIONS);
+  if (!ids) return undefined;
+
+  const known = new Set<string>();
+  for (const id of ids) {
+    if (typeof id !== 'string' || !INTEGRATION_ID.test(id) || known.has(id)) return undefined;
+    known.add(id);
+  }
+  return known;
+}
+
+const CAPABILITY = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/;
+const CONDITIONAL_CAPABILITY = /^([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+)\?([a-z][a-z0-9_]*)$/;
+
+function capabilityKey(declaration: string): string | undefined {
+  if (CAPABILITY.test(declaration)) return declaration;
+  return CONDITIONAL_CAPABILITY.exec(declaration)?.[1];
+}
+
+function validateCapabilityList(
+  candidate: unknown,
+  allowConditional: boolean
+): readonly string[] | undefined {
+  const declarations = snapshotExactArray(candidate, MAX_INTEGRATIONS);
+  if (!declarations || !Object.isFrozen(candidate)) return undefined;
+  const seen = new Set<string>();
+  const accepted: string[] = [];
+  for (const declaration of declarations) {
+    if (
+      typeof declaration !== 'string' ||
+      (!CAPABILITY.test(declaration) &&
+        !(allowConditional && CONDITIONAL_CAPABILITY.test(declaration))) ||
+      seen.has(declaration)
+    ) {
+      return undefined;
+    }
+    seen.add(declaration);
+    accepted.push(declaration);
+  }
+  return Object.freeze(accepted);
+}
+
+function validateCatalog(
+  candidate: unknown,
+  knownIntegrationIds: ReadonlySet<string>
+): readonly IntegrationCatalogEntry[] | undefined {
+  const entries = snapshotExactArray(candidate, MAX_INTEGRATIONS);
+  if (!entries || entries.length !== knownIntegrationIds.size) return undefined;
+  const seen = new Set<string>();
+  const catalog: IntegrationCatalogEntry[] = [];
+  let sawDeferred = false;
+  let takeoverCount = 0;
+  const providerIndex = new Map<string, number>();
+  for (const entry of entries) {
+    const keys = Reflect.ownKeys(entry as object);
+    const hasConfig = keys.includes('config');
+    const fields = readExactDataFields(entry, [
+      'id',
+      'phase',
+      'trigger',
+      ...(hasConfig ? ['config'] : []),
+      'consumes',
+      'provides',
+    ]);
+    if (!fields || typeof fields.id !== 'string' || !knownIntegrationIds.has(fields.id)) {
+      return undefined;
+    }
+    const consumes = validateCapabilityList(fields.consumes, true);
+    const provides = validateCapabilityList(fields.provides, false);
+    if (!consumes || !provides) return undefined;
+    if (
+      hasConfig &&
+      fields.config !== null &&
+      ![
+        'aps',
+        'datadome',
+        'didomi',
+        'google_tag_manager',
+        'gpt',
+        'lockr',
+        'osano',
+        'permutive',
+        'prebid',
+        'sourcepoint',
+        'testlight',
+        'creative',
+        'diagnostics',
+      ].includes(fields.config as string)
+    ) {
+      return undefined;
+    }
+    if (seen.has(fields.id)) return undefined;
+    seen.add(fields.id);
+    if (fields.phase === 'takeover') {
+      if (fields.trigger !== null || sawDeferred || ++takeoverCount > 14) return undefined;
+    } else if (fields.phase === 'deferred') {
+      sawDeferred = true;
+      if (fields.trigger !== 'first_display_or_idle' || provides.length !== 0) return undefined;
+    } else {
+      return undefined;
+    }
+    const index = catalog.length;
+    for (const capability of provides) {
+      if (capability === 'runtime.v1' || providerIndex.has(capability)) return undefined;
+      providerIndex.set(capability, index);
+    }
+    catalog.push(
+      Object.freeze({
+        id: fields.id,
+        phase: fields.phase,
+        trigger: fields.trigger,
+        ...(hasConfig ? { config: fields.config as ReleaseConfigSourceV1 } : {}),
+        consumes,
+        provides,
+      }) as IntegrationCatalogEntry
+    );
+  }
+  for (let index = 0; index < catalog.length; index += 1) {
+    const entry = catalog[index];
+    if (!entry) return undefined;
+    for (const declaration of entry.consumes) {
+      const key = capabilityKey(declaration);
+      const provider = key === 'runtime.v1' ? -1 : key ? providerIndex.get(key) : undefined;
+      if (provider === undefined || provider >= index) return undefined;
+    }
+  }
+  return Object.freeze(catalog);
+}
+
+export function validateRuntimeManifestV1(
+  candidate: unknown,
+  embeddedReleaseId: string,
+  catalog: readonly IntegrationCatalogEntry[],
+  requireRenderRuntime: boolean
+): BootManifestV1 | undefined {
+  try {
+    if (!RELEASE_ID.test(embeddedReleaseId)) return undefined;
+    const manifestFields = readExactDataFields(candidate, [
+      'version',
+      'releaseId',
+      'firstDisplay',
+      'runtimeSrc',
+      'integrations',
+    ]);
+    if (!manifestFields) return undefined;
+    if (manifestFields.version !== 1 || manifestFields.releaseId !== embeddedReleaseId) {
+      return undefined;
+    }
+    const manifestIntegrations = snapshotExactArray(manifestFields.integrations, MAX_INTEGRATIONS);
+    if (!manifestIntegrations) return undefined;
+
+    let firstDisplay: BootManifestV1['firstDisplay'];
+    if (manifestFields.firstDisplay === null) {
+      firstDisplay = null;
+    } else {
+      const fields = readExactDataFields(manifestFields.firstDisplay, ['src', 'slices']);
+      const slices = snapshotExactArray(fields?.slices, 14);
+      if (
+        !fields ||
+        typeof fields.src !== 'string' ||
+        !/^\/static\/tsjs=tsjs-first-display\.min\.js\?m=[0-9a-f]{4}&v=[0-9a-f]{64}$/.test(
+          fields.src
+        ) ||
+        !slices ||
+        slices.length === 0 ||
+        slices[0] !== 'first_display' ||
+        slices.some((id) => typeof id !== 'string') ||
+        new Set(slices).size !== slices.length
+      ) {
+        return undefined;
+      }
+      firstDisplay = Object.freeze({
+        src: fields.src,
+        slices: Object.freeze([...slices] as string[]),
+      });
+    }
+
+    if (
+      typeof manifestFields.runtimeSrc !== 'string' ||
+      !/^\/static\/tsjs=tsjs-unified\.min\.js\?v=[0-9a-f]{64}$/.test(manifestFields.runtimeSrc)
+    ) {
+      return undefined;
+    }
+
+    const seen = new Set<string>();
+    const integrations: BootManifestV1['integrations'][number][] = [];
+    let sawDeferred = false;
+    let takeoverCount = 0;
+    let previousCatalogIndex = -1;
+    for (const entry of manifestIntegrations) {
+      const phaseDescriptor = isRecord(entry) && Object.getOwnPropertyDescriptor(entry, 'phase');
+      if (!phaseDescriptor || !('value' in phaseDescriptor)) return undefined;
+      const phase = phaseDescriptor.value;
+      const entryFields = readExactDataFields(
+        entry,
+        phase === 'takeover' ? ['id', 'phase'] : ['id', 'phase', 'trigger', 'src']
+      );
+      if (!entryFields || (phase !== 'takeover' && phase !== 'deferred')) return undefined;
+      if (typeof entryFields.id !== 'string' || !INTEGRATION_ID.test(entryFields.id)) {
+        return undefined;
+      }
+      const catalogIndex = catalog.findIndex(({ id }) => id === entryFields.id);
+      const catalogEntry = catalog[catalogIndex];
+      if (!catalogEntry || catalogIndex <= previousCatalogIndex || catalogEntry.phase !== phase) {
+        return undefined;
+      }
+      previousCatalogIndex = catalogIndex;
+      if (seen.has(entryFields.id) || (sawDeferred && phase === 'takeover')) return undefined;
+      seen.add(entryFields.id);
+      if (phase === 'takeover') {
+        takeoverCount += 1;
+        if (takeoverCount > 14 || catalogEntry.trigger !== null) return undefined;
+        integrations.push(Object.freeze({ id: entryFields.id, phase }));
+        continue;
+      }
+      sawDeferred = true;
+      if (
+        catalogEntry.trigger !== 'first_display_or_idle' ||
+        entryFields.trigger !== 'first_display_or_idle' ||
+        typeof entryFields.src !== 'string' ||
+        !new RegExp(`^/static/tsjs=tsjs-${entryFields.id}\\.min\\.js\\?v=[0-9a-f]{64}$`).test(
+          entryFields.src
+        )
+      ) {
+        return undefined;
+      }
+      integrations.push(
+        Object.freeze({
+          id: entryFields.id,
+          phase,
+          trigger: 'first_display_or_idle',
+          src: entryFields.src,
+        })
+      );
+    }
+    if (requireRenderRuntime && integrations[0]?.id !== 'render_runtime') return undefined;
+
+    const selected = new Set(integrations.map(({ id }) => id));
+    for (const integration of integrations) {
+      const catalogEntry = catalog.find(({ id }) => id === integration.id);
+      if (!catalogEntry) return undefined;
+      for (const declaration of catalogEntry.consumes) {
+        const conditional = CONDITIONAL_CAPABILITY.test(declaration);
+        const key = capabilityKey(declaration);
+        if (!key || key === 'runtime.v1') continue;
+        const provider = catalog.find(({ provides }) => provides.includes(key));
+        if (!provider || (!conditional && !selected.has(provider.id))) return undefined;
+      }
+    }
+
+    return Object.freeze({
+      version: 1,
+      releaseId: embeddedReleaseId,
+      firstDisplay,
+      runtimeSrc: manifestFields.runtimeSrc,
+      integrations: Object.freeze(integrations),
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function isFrozenBinding(value: unknown): boolean {
+  return (
+    value === null ||
+    (typeof value !== 'object' && typeof value !== 'function') ||
+    Object.isFrozen(value)
+  );
+}
+
+function hasOnlyFrozenDataValues(value: Record<PropertyKey, unknown>): boolean {
+  return Reflect.ownKeys(value).every((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && 'value' in descriptor && isFrozenBinding(descriptor.value);
+  });
+}
+
+function isCapabilityFacade(value: unknown): value is Readonly<Record<string, unknown>> {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    Array.isArray(value) ||
+    Object.getPrototypeOf(value) !== Object.prototype ||
+    !Object.isFrozen(value)
+  ) {
+    return false;
+  }
+  return Reflect.ownKeys(value).every((key) => {
+    if (typeof key !== 'string') return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && descriptor.enumerable && 'value' in descriptor;
+  });
+}
+
+function isThenable(value: unknown): value is PromiseLike<unknown> {
+  return (
+    (typeof value === 'object' || typeof value === 'function') &&
+    value !== null &&
+    typeof (value as { then?: unknown }).then === 'function'
+  );
+}
+
+function observeThenableRejection(
+  value: PromiseLike<unknown>,
+  onRejected: (error: unknown) => void = () => undefined
+): void {
+  try {
+    void Promise.resolve(value).catch((error: unknown) => {
+      try {
+        onRejected(error);
+      } catch {
+        // Rejection observation must never create another unhandled rejection.
+      }
+    });
+  } catch (error) {
+    try {
+      onRejected(error);
+    } catch {
+      // Rejection observation is bounded and never changes registry control flow.
+    }
+  }
+}
+
+class IntegrationRegistryOwner {
+  private readonly manifestValue: BootManifestV1 | undefined;
+  private readonly catalog: readonly IntegrationCatalogEntry[];
+  private readonly takeoverScript: HTMLScriptElement | undefined;
+  private readonly takeoverScriptId: 'trustedserver-js' | 'trustedserver-js-runtime';
+  private readonly currentScript: (() => HTMLScriptElement | null) | undefined;
+  private readonly document: Document | undefined;
+  private readonly registrations = new Map<string, TakeoverIntegrationRegistration>();
+  private readonly capabilities = new Map<string, Readonly<Record<string, unknown>>>();
+  private readonly prepared: PreparedRecord[] = [];
+  private readonly abortController = new AbortController();
+  private readonly coreScope: DisposableStack;
+  private readonly now: () => number;
+  private readonly getBindings: (id: string) => IntegrationBindings;
+  private readonly isCurrentOwner: () => boolean;
+  private readonly startedAtMs: number;
+  private readonly releaseId: string;
+  private readonly ownerSignal: AbortSignal | undefined;
+  private readonly onDisposalError: (error: unknown) => void;
+  private readonly onCapabilityStaged: NonNullable<
+    IntegrationRegistryOptions['onCapabilityStaged']
+  >;
+  private readonly onRuntimeFailure: (failure: IntegrationRuntimeFailure) => void;
+  private readonly onTakeoverRegistrationsReady: () => void;
+  private deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+  private failureReason: BootFailureReason | undefined;
+  private installPromise: Promise<IntegrationInstallResult> | undefined;
+  private installResult: IntegrationInstallResult | undefined;
+  private installSyncInProgress = false;
+  private registrationWaiter: (() => void) | undefined;
+  private registryState: IntegrationRegistryState = 'collecting';
+  private nextTakeoverRegistrationIndex = 0;
+  private ownedCallbackDepth = 0;
+  private unwindPending = false;
+
+  public constructor(options: IntegrationRegistryOptions) {
+    this.releaseId = options.releaseId;
+    this.takeoverScript = options.takeoverScript;
+    this.takeoverScriptId = options.takeoverScriptId ?? 'trustedserver-js';
+    this.currentScript = options.currentScript;
+    this.document = options.document;
+    this.startedAtMs = options.startedAtMs;
+    this.now = options.now ?? (() => performance.now());
+    this.getBindings =
+      options.getBindings ??
+      (() => ({
+        config: EMPTY_BINDING,
+        interfaces: EMPTY_BINDING,
+      }));
+    this.isCurrentOwner = options.isCurrentOwner ?? (() => true);
+    this.ownerSignal = options.signal;
+    this.onDisposalError = options.onDisposalError ?? (() => undefined);
+    this.onCapabilityStaged = options.onCapabilityStaged ?? (() => undefined);
+    this.onRuntimeFailure = options.onRuntimeFailure ?? (() => undefined);
+    this.onTakeoverRegistrationsReady = options.onTakeoverRegistrationsReady ?? (() => undefined);
+    this.coreScope = new DisposableStack(this.onDisposalError);
+    const knownIntegrationIds = validateKnownIntegrationIds(options.knownIntegrationIds);
+    const catalogCandidate =
+      options.catalog ??
+      Object.freeze(
+        options.knownIntegrationIds.map((id) =>
+          Object.freeze({
+            id,
+            phase: 'takeover' as const,
+            trigger: null,
+            consumes: Object.freeze([]),
+            provides: Object.freeze([]),
+          })
+        )
+      );
+    const catalog = knownIntegrationIds
+      ? validateCatalog(catalogCandidate, knownIntegrationIds)
+      : undefined;
+    this.catalog = catalog ?? Object.freeze([]);
+    this.manifestValue = catalog
+      ? validateRuntimeManifestV1(
+          options.manifest,
+          options.releaseId,
+          catalog,
+          catalog.length === MAX_INTEGRATIONS
+        )
+      : undefined;
+
+    const runtimeCapability = options.runtimeCapability ?? EMPTY_BINDING;
+    if (catalog && isCapabilityFacade(runtimeCapability)) {
+      this.capabilities.set('runtime.v1', runtimeCapability);
+    } else if (catalog) {
+      this.manifestValue = undefined;
+    }
+
+    if (!this.manifestValue) {
+      this.fail('abi_mismatch');
+      return;
+    }
+    if (!Number.isFinite(this.startedAtMs) || this.deadlineExpired()) {
+      this.fail('bundle_partial');
+      return;
+    }
+    if (this.ownerSignal?.aborted) {
+      this.fail('bundle_partial');
+      return;
+    }
+
+    this.ownerSignal?.addEventListener('abort', this.onOwnerAbort, { once: true });
+    const remaining = Math.max(0, BOOT_DEADLINE_MS - (this.now() - this.startedAtMs));
+    this.deadlineTimer = setTimeout(() => this.fail('bundle_partial'), remaining);
+  }
+
+  public get state(): IntegrationRegistryState {
+    return this.registryState;
+  }
+
+  public get manifest(): BootManifestV1 | undefined {
+    return this.manifestValue;
+  }
+
+  public register(candidate: unknown): boolean {
+    if (!this.ownerIsCurrent()) {
+      this.fail('bundle_partial');
+      return false;
+    }
+    if (this.registryState === 'preparing' || this.registryState === 'activating') {
+      this.fail('abi_mismatch');
+      return false;
+    }
+    if (this.registryState !== 'collecting') return false;
+    if (this.deadlineExpired()) {
+      this.fail('bundle_partial');
+      return false;
+    }
+    try {
+      const registration = snapshotIntegrationRegistration(candidate);
+      if (!registration) {
+        this.fail('abi_mismatch');
+        return false;
+      }
+      const { id, phase, releaseId } = registration;
+      const takeoverIntegrations = this.manifestValue?.integrations.filter(
+        (entry) => entry.phase === 'takeover'
+      );
+      const nextTakeover = takeoverIntegrations?.[this.nextTakeoverRegistrationIndex];
+      if (
+        releaseId !== this.releaseId ||
+        !this.manifestValue?.integrations.some(
+          (entry) => entry.id === id && entry.phase === phase
+        ) ||
+        phase !== 'takeover' ||
+        nextTakeover?.id !== id ||
+        this.registrations.has(id) ||
+        !this.ownsTakeoverScript()
+      ) {
+        this.fail('abi_mismatch');
+        return false;
+      }
+
+      if (!this.ownerIsCurrent()) {
+        this.fail('bundle_partial');
+        return false;
+      }
+      if (this.registryState !== 'collecting') return false;
+
+      this.registrations.set(
+        id,
+        Object.freeze({
+          abi: 1,
+          id,
+          phase,
+          releaseId,
+          prepareSync: registration.prepareSync,
+          prepare: registration.prepare,
+        })
+      );
+      this.nextTakeoverRegistrationIndex += 1;
+      if (this.hasEveryRequiredRegistration()) {
+        this.wakeRegistrationWaiter();
+        this.onTakeoverRegistrationsReady();
+      }
+      return true;
+    } catch {
+      this.fail('abi_mismatch');
+      return false;
+    }
+  }
+
+  private ownsTakeoverScript(): boolean {
+    if (!this.takeoverScript && !this.document) return true;
+    const script = this.takeoverScript;
+    const document = this.document;
+    const Script = document?.defaultView?.HTMLScriptElement;
+    const manifest = this.manifestValue;
+    if (!script || !document || !Script || !manifest) return false;
+    try {
+      const origin = trustedArtifactOrigin(document);
+      if (!origin) return false;
+      const expected = new URL(manifest.runtimeSrc, origin);
+      const matches = document.querySelectorAll(`script#${this.takeoverScriptId}`);
+      return (
+        script instanceof Script &&
+        script.id === this.takeoverScriptId &&
+        script.isConnected &&
+        matches.length === 1 &&
+        matches[0] === script &&
+        (this.currentScript
+          ? this.currentScript() === script
+          : document.currentScript === script) &&
+        expected.origin === origin &&
+        expected.hash === '' &&
+        `${expected.pathname}${expected.search}` === manifest.runtimeSrc &&
+        script.src === expected.href
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  public install(callbacks: IntegrationInstallCallbacks): Promise<IntegrationInstallResult> {
+    if (this.installResult) return Promise.resolve(this.installResult);
+    if (this.installPromise) return this.installPromise;
+
+    let resolveInstall: ((result: IntegrationInstallResult) => void) | undefined;
+    this.installPromise = new Promise<IntegrationInstallResult>((resolve) => {
+      resolveInstall = resolve;
+    });
+
+    const acceptedCallbacks = this.snapshotInstallCallbacks(callbacks);
+    if (!acceptedCallbacks) {
+      this.fail('bundle_partial');
+      resolveInstall?.(this.fallbackResult());
+      return this.installPromise;
+    }
+
+    void this.installTransaction(acceptedCallbacks).then(
+      (result) => {
+        this.installResult = result;
+        resolveInstall?.(result);
+      },
+      () => {
+        this.fail('bundle_partial');
+        const result = this.fallbackResult();
+        this.installResult = result;
+        resolveInstall?.(result);
+      }
+    );
+    return this.installPromise;
+  }
+
+  public installSync(callbacks: IntegrationInstallCallbacks): IntegrationInstallResult {
+    if (this.installResult) return this.installResult;
+    if (this.installPromise || this.installSyncInProgress) {
+      this.fail('bundle_partial');
+      return this.fallbackResult();
+    }
+    this.installSyncInProgress = true;
+    try {
+      const acceptedCallbacks = this.snapshotInstallCallbacks(callbacks);
+      if (!acceptedCallbacks) {
+        this.fail('bundle_partial');
+        return (this.installResult = this.fallbackResult());
+      }
+      return (this.installResult = this.installSyncTransaction(acceptedCallbacks));
+    } finally {
+      this.installSyncInProgress = false;
+      if (this.installResult) this.installPromise = Promise.resolve(this.installResult);
+    }
+  }
+
+  private snapshotInstallCallbacks(
+    callbacks: IntegrationInstallCallbacks
+  ): IntegrationInstallCallbacks | undefined {
+    try {
+      return Object.freeze({
+        ...(callbacks.prepareCore ? { prepareCore: callbacks.prepareCore } : {}),
+        activateCore: callbacks.activateCore,
+        publish: callbacks.publish,
+        drainPreload: callbacks.drainPreload,
+        ...(callbacks.coordinateTakeover
+          ? { coordinateTakeover: callbacks.coordinateTakeover }
+          : {}),
+      });
+    } catch {
+      return undefined;
+    }
+  }
+
+  public prepareDeferred(
+    registration: DeferredIntegrationRegistration,
+    owner: Readonly<{
+      signal: AbortSignal;
+      onDispose: (callback: DisposeCallback) => void;
+    }>
+  ): PreparedIntegration | PromiseLike<PreparedIntegration> {
+    const manifestEntry = this.manifestValue?.integrations.find(
+      (entry) => entry.id === registration.id && entry.phase === 'deferred'
+    );
+    if (
+      this.registryState !== 'committed' ||
+      !manifestEntry ||
+      registration.phase !== 'deferred' ||
+      registration.releaseId !== this.releaseId ||
+      owner.signal.aborted
+    ) {
+      throw new TypeError('Deferred integration is not admitted by the committed runtime');
+    }
+    const bindings = this.resolveBindings(registration.id);
+    let open = true;
+    const context: IntegrationPrepareContext = Object.freeze({
+      config: bindings.config,
+      interfaces: bindings.interfaces,
+      signal: owner.signal,
+      onDispose: (callback: DisposeCallback) => {
+        if (!open && !owner.signal.aborted) {
+          throw new Error('Deferred preparation disposal registration is closed');
+        }
+        owner.onDispose(callback);
+      },
+    });
+    let prepared: PreparedIntegration | PromiseLike<PreparedIntegration>;
+    try {
+      prepared = registration.prepare(context);
+    } catch (error) {
+      open = false;
+      throw error;
+    }
+    if (!isThenable(prepared)) {
+      open = false;
+      return prepared;
+    }
+    return Promise.resolve(prepared).finally(() => {
+      open = false;
+    });
+  }
+
+  public dispose(): void {
+    if (this.registryState === 'disposed') return;
+    if (this.registryState !== 'failed') this.registryState = 'disposed';
+    this.abortController.abort();
+    this.clearBootOwnership();
+    this.wakeRegistrationWaiter();
+    this.requestUnwind();
+  }
+
+  private readonly onOwnerAbort = (): void => {
+    this.fail('bundle_partial');
+  };
+
+  private deadlineExpired(): boolean {
+    const elapsed = this.now() - this.startedAtMs;
+    return !Number.isFinite(elapsed) || elapsed >= BOOT_DEADLINE_MS;
+  }
+
+  private ownerIsCurrent(): boolean {
+    try {
+      return this.isCurrentOwner();
+    } catch {
+      return false;
+    }
+  }
+
+  private canContinue(phase: 'preparing' | 'activating'): boolean {
+    if (this.registryState !== phase) return false;
+    if (!this.ownerIsCurrent() || this.deadlineExpired()) {
+      this.fail('bundle_partial');
+      return false;
+    }
+    return true;
+  }
+
+  private fail(reason: BootFailureReason): void {
+    if (
+      this.registryState === 'committed' ||
+      this.registryState === 'failed' ||
+      this.registryState === 'disposed'
+    ) {
+      return;
+    }
+    this.failureReason = reason;
+    this.registryState = 'failed';
+    this.abortController.abort();
+    this.clearBootOwnership();
+    this.wakeRegistrationWaiter();
+    this.requestUnwind();
+  }
+
+  private hasEveryRequiredRegistration(): boolean {
+    return Boolean(
+      this.manifestValue?.integrations
+        .filter((entry) => entry.phase === 'takeover')
+        .every((entry) => this.registrations.has(entry.id))
+    );
+  }
+
+  private wakeRegistrationWaiter(): void {
+    const wake = this.registrationWaiter;
+    this.registrationWaiter = undefined;
+    wake?.();
+  }
+
+  private waitForRequiredRegistrations(): Promise<void> {
+    if (this.registryState !== 'collecting' || this.hasEveryRequiredRegistration()) {
+      return Promise.resolve();
+    }
+    return new Promise<void>((resolve) => {
+      this.registrationWaiter = resolve;
+      if (this.registryState !== 'collecting' || this.hasEveryRequiredRegistration()) {
+        this.wakeRegistrationWaiter();
+      }
+    });
+  }
+
+  private enterOwnedCallback(): void {
+    this.ownedCallbackDepth += 1;
+  }
+
+  private leaveOwnedCallback(): void {
+    this.ownedCallbackDepth -= 1;
+    if (this.ownedCallbackDepth === 0 && this.unwindPending) {
+      this.unwindPending = false;
+      this.disposePrepared();
+    }
+  }
+
+  private requestUnwind(): void {
+    if (this.ownedCallbackDepth > 0) {
+      this.unwindPending = true;
+      return;
+    }
+    this.disposePrepared();
+  }
+
+  private clearBootOwnership(): void {
+    if (this.deadlineTimer !== undefined) {
+      clearTimeout(this.deadlineTimer);
+      this.deadlineTimer = undefined;
+    }
+    this.ownerSignal?.removeEventListener('abort', this.onOwnerAbort);
+  }
+
+  private disposePrepared(): void {
+    for (let index = this.prepared.length - 1; index >= 0; index -= 1) {
+      this.prepared[index]?.scope.dispose();
+    }
+    this.coreScope.dispose();
+  }
+
+  private fallbackResult(): IntegrationFallbackResult {
+    return Object.freeze({
+      state: 'fallback',
+      reason: this.failureReason ?? 'bundle_partial',
+    });
+  }
+
+  private async awaitPreparation(
+    promise: PromiseLike<PreparedIntegration>
+  ): Promise<PreparedIntegration | typeof ABORTED> {
+    const observed = Promise.resolve(promise);
+    if (this.abortController.signal.aborted) {
+      observeThenableRejection(observed);
+      return ABORTED;
+    }
+
+    let removeAbortListener: () => void = () => undefined;
+    const aborted = new Promise<typeof ABORTED>((resolve) => {
+      const onAbort = () => resolve(ABORTED);
+      this.abortController.signal.addEventListener('abort', onAbort, { once: true });
+      removeAbortListener = () => this.abortController.signal.removeEventListener('abort', onAbort);
+    });
+
+    try {
+      return await Promise.race([observed, aborted]);
+    } finally {
+      removeAbortListener();
+    }
+  }
+
+  private createPreparationContext(
+    id: string,
+    scope: DisposableStack
+  ): { readonly context: IntegrationPrepareContext; readonly close: () => void } {
+    const bindings = this.resolveBindings(id);
+    let open = true;
+    const context: IntegrationPrepareContext = Object.freeze({
+      config: bindings.config,
+      interfaces: bindings.interfaces,
+      signal: this.abortController.signal,
+      onDispose: (callback: DisposeCallback) => {
+        if (!open && !scope.disposed) {
+          throw new Error('Preparation disposal registration is closed');
+        }
+        scope.onDispose(callback);
+      },
+    });
+    return Object.freeze({
+      context,
+      close: () => {
+        open = false;
+      },
+    });
+  }
+
+  private resolveBindings(id: string): IntegrationBindings {
+    const bindings = this.getBindings(id);
+    const fields = readExactDataFields(bindings, ['config', 'interfaces']);
+    if (
+      !fields ||
+      !isFrozenBinding(fields.config) ||
+      !isRecord(fields.interfaces) ||
+      !Object.isFrozen(fields.interfaces) ||
+      !hasOnlyFrozenDataValues(fields.interfaces)
+    ) {
+      throw new TypeError('Integration bindings must expose exact frozen values');
+    }
+
+    const catalogEntry = this.catalog.find((entry) => entry.id === id);
+    if (!catalogEntry) throw new TypeError('Integration catalog entry is unavailable');
+    const brokerInterfaces: Record<string, unknown> = {};
+    for (const declaration of catalogEntry.consumes) {
+      const key = capabilityKey(declaration);
+      const value = key ? this.capabilities.get(key) : undefined;
+      if (!key || (!value && !CONDITIONAL_CAPABILITY.test(declaration))) {
+        throw new TypeError('Required integration capability is unavailable');
+      }
+      if (value) brokerInterfaces[key] = value;
+    }
+    const interfaces =
+      catalogEntry.consumes.length === 0 && catalogEntry.provides.length === 0
+        ? fields.interfaces
+        : Object.freeze(brokerInterfaces);
+
+    return Object.freeze({
+      config: fields.config,
+      interfaces,
+    });
+  }
+
+  private snapshotPreparedIntegration(
+    id: string,
+    candidate: unknown,
+    scope: DisposableStack
+  ): PreparedIntegration | undefined {
+    const catalogEntry = this.catalog.find((entry) => entry.id === id);
+    if (!catalogEntry) return undefined;
+    const expectedFields =
+      catalogEntry.provides.length === 0 &&
+      isRecord(candidate) &&
+      !Object.prototype.hasOwnProperty.call(candidate, 'interfaces')
+        ? ['activate']
+        : ['activate', 'interfaces'];
+    const fields = readExactDataFields(candidate, expectedFields);
+    if (!fields || typeof fields.activate !== 'function') return undefined;
+
+    if (catalogEntry.provides.length === 0) {
+      if (
+        'interfaces' in fields &&
+        (!isRecord(fields.interfaces) ||
+          !Object.isFrozen(fields.interfaces) ||
+          Reflect.ownKeys(fields.interfaces).length !== 0)
+      ) {
+        return undefined;
+      }
+      return Object.freeze({ activate: fields.activate as PreparedIntegration['activate'] });
+    }
+
+    if (!isRecord(fields.interfaces) || !Object.isFrozen(fields.interfaces)) return undefined;
+    const providerInterfaces = fields.interfaces;
+    const keys = Reflect.ownKeys(providerInterfaces);
+    if (
+      keys.length !== catalogEntry.provides.length ||
+      !keys.every(
+        (key) =>
+          typeof key === 'string' &&
+          catalogEntry.provides.includes(key) &&
+          isCapabilityFacade(providerInterfaces[key])
+      )
+    ) {
+      return undefined;
+    }
+    for (const key of catalogEntry.provides) {
+      const facade = providerInterfaces[key];
+      if (!isCapabilityFacade(facade) || this.capabilities.has(key)) return undefined;
+      this.capabilities.set(key, facade);
+      scope.onDispose(() => {
+        if (this.capabilities.get(key) === facade) this.capabilities.delete(key);
+      });
+      const release = this.onCapabilityStaged(key, facade);
+      if (release !== undefined) scope.onDispose(release);
+    }
+    return Object.freeze({
+      activate: fields.activate as PreparedIntegration['activate'],
+      interfaces: providerInterfaces as Readonly<Record<string, unknown>>,
+    });
+  }
+
+  private installSyncTransaction(callbacks: IntegrationInstallCallbacks): IntegrationInstallResult {
+    if (callbacks.coordinateTakeover) {
+      this.fail('bundle_partial');
+      return this.fallbackResult();
+    }
+    if (this.registryState === 'failed' || this.registryState === 'disposed') {
+      return this.fallbackResult();
+    }
+    if (
+      !this.manifestValue ||
+      !this.ownerIsCurrent() ||
+      this.deadlineExpired() ||
+      !this.hasEveryRequiredRegistration()
+    ) {
+      this.fail('bundle_partial');
+      return this.fallbackResult();
+    }
+
+    this.registryState = 'preparing';
+    if (callbacks.prepareCore) {
+      let corePreparationOpen = true;
+      const corePreparationContext: CorePreparationContext = Object.freeze({
+        signal: this.abortController.signal,
+        onDispose: (callback: DisposeCallback) => {
+          if (!corePreparationOpen && !this.coreScope.disposed) {
+            throw new Error('Core preparation disposal registration is closed');
+          }
+          this.coreScope.onDispose(callback);
+        },
+      });
+      this.enterOwnedCallback();
+      try {
+        const returned = callbacks.prepareCore(corePreparationContext);
+        if (isThenable(returned)) {
+          observeThenableRejection(returned);
+          throw new TypeError('Core preparation must be synchronous');
+        }
+      } catch {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      } finally {
+        corePreparationOpen = false;
+        this.leaveOwnedCallback();
+      }
+      if (!this.canContinue('preparing')) return this.fallbackResult();
+    }
+
+    for (const entry of this.manifestValue.integrations) {
+      if (entry.phase !== 'takeover') continue;
+      if (!this.canContinue('preparing')) return this.fallbackResult();
+      const scope = new DisposableStack(this.onDisposalError);
+      const registration = this.registrations.get(entry.id);
+      if (!registration) {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      }
+      this.prepared.push({
+        id: entry.id,
+        scope,
+        module: Object.freeze({ activate: () => undefined }),
+        afterCommit: undefined,
+      });
+      const recordIndex = this.prepared.length - 1;
+      const { context, close } = this.createPreparationContext(entry.id, scope);
+      try {
+        if (!this.canContinue('preparing')) return this.fallbackResult();
+        this.enterOwnedCallback();
+        let candidate: PreparedIntegration;
+        try {
+          candidate = registration.prepareSync(context);
+        } finally {
+          this.leaveOwnedCallback();
+        }
+        if (isThenable(candidate)) {
+          observeThenableRejection(candidate);
+          throw new TypeError('prepareSync must be synchronous');
+        }
+        if (!this.canContinue('preparing')) return this.fallbackResult();
+        const acceptedPrepared = this.snapshotPreparedIntegration(entry.id, candidate, scope);
+        if (!acceptedPrepared) {
+          throw new TypeError('prepareSync must return one exact activation module');
+        }
+        if (!this.canContinue('preparing')) return this.fallbackResult();
+        this.prepared[recordIndex] = {
+          id: entry.id,
+          scope,
+          module: acceptedPrepared,
+          afterCommit: undefined,
+        };
+      } catch {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      } finally {
+        close();
+      }
+    }
+
+    if (!this.canContinue('preparing')) return this.fallbackResult();
+    return this.finishPreparedTransaction(callbacks);
+  }
+
+  private async installTransaction(
+    callbacks: IntegrationInstallCallbacks
+  ): Promise<IntegrationInstallResult> {
+    if (this.registryState === 'failed' || this.registryState === 'disposed') {
+      return this.fallbackResult();
+    }
+    if (!this.manifestValue || !this.ownerIsCurrent() || this.deadlineExpired()) {
+      this.fail('bundle_partial');
+      return this.fallbackResult();
+    }
+    if (!this.hasEveryRequiredRegistration()) {
+      await this.waitForRequiredRegistrations();
+      if (
+        this.registryState !== 'collecting' ||
+        !this.ownerIsCurrent() ||
+        this.deadlineExpired() ||
+        !this.hasEveryRequiredRegistration()
+      ) {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      }
+    }
+
+    this.registryState = 'preparing';
+    if (callbacks.prepareCore) {
+      let corePreparationOpen = true;
+      const corePreparationContext: CorePreparationContext = Object.freeze({
+        signal: this.abortController.signal,
+        onDispose: (callback: DisposeCallback) => {
+          if (!corePreparationOpen && !this.coreScope.disposed) {
+            throw new Error('Core preparation disposal registration is closed');
+          }
+          this.coreScope.onDispose(callback);
+        },
+      });
+      this.enterOwnedCallback();
+      try {
+        const returned = callbacks.prepareCore(corePreparationContext);
+        if (isThenable(returned)) {
+          observeThenableRejection(returned);
+          throw new TypeError('Core preparation must be synchronous');
+        }
+      } catch {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      } finally {
+        corePreparationOpen = false;
+        this.leaveOwnedCallback();
+      }
+
+      if (!this.canContinue('preparing')) return this.fallbackResult();
+    }
+    for (const entry of this.manifestValue.integrations) {
+      if (entry.phase !== 'takeover') continue;
+      if (!this.canContinue('preparing')) return this.fallbackResult();
+
+      const scope = new DisposableStack(this.onDisposalError);
+      const registration = this.registrations.get(entry.id);
+      if (!registration) {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      }
+
+      this.prepared.push({
+        id: entry.id,
+        scope,
+        module: Object.freeze({ activate: () => undefined }),
+        afterCommit: undefined,
+      });
+      const recordIndex = this.prepared.length - 1;
+
+      try {
+        const { context, close } = this.createPreparationContext(entry.id, scope);
+        if (!this.canContinue('preparing')) {
+          close();
+          return this.fallbackResult();
+        }
+        let pending: PreparedIntegration | PromiseLike<PreparedIntegration>;
+        this.enterOwnedCallback();
+        try {
+          pending = registration.prepare(context);
+        } finally {
+          this.leaveOwnedCallback();
+        }
+        let prepared: PreparedIntegration | typeof ABORTED;
+        if (isThenable(pending)) {
+          prepared = await this.awaitPreparation(pending as PromiseLike<PreparedIntegration>);
+          close();
+        } else {
+          close();
+          prepared = pending;
+        }
+        if (prepared === ABORTED || !this.canContinue('preparing')) {
+          this.fail('bundle_partial');
+          return this.fallbackResult();
+        }
+        const acceptedPrepared = this.snapshotPreparedIntegration(entry.id, prepared, scope);
+        if (!acceptedPrepared) {
+          throw new TypeError('prepare must return one exact activation module');
+        }
+        if (!this.canContinue('preparing')) return this.fallbackResult();
+        this.prepared[recordIndex] = {
+          id: entry.id,
+          scope,
+          module: acceptedPrepared,
+          afterCommit: undefined,
+        };
+      } catch {
+        this.fail('bundle_partial');
+        return this.fallbackResult();
+      }
+
+      if (!this.canContinue('preparing')) return this.fallbackResult();
+    }
+
+    if (!this.canContinue('preparing')) return this.fallbackResult();
+
+    return this.finishPreparedTransaction(callbacks);
+  }
+
+  private finishPreparedTransaction(
+    callbacks: IntegrationInstallCallbacks
+  ): IntegrationInstallResult {
+    let activated = false;
+    let committed: IntegrationKernelResult | undefined;
+    let validatedHandoff: FirstDisplayHandoffV1 | undefined;
+    const prepared: PreparedKernelTakeover = Object.freeze({
+      validateHandoff: (candidate: unknown, outlineCandidate: unknown, bootCandidate?: unknown) => {
+        if (activated || committed || validatedHandoff) return undefined;
+        const identityIssuer = createBrowserNavigationIdentityIssuer();
+        if (!identityIssuer.ok) return undefined;
+        const handoff = snapshotOutlinedFirstDisplayCaptureV1(
+          candidate,
+          outlineCandidate,
+          bootCandidate,
+          identityIssuer.value
+        );
+        if (!handoff) return undefined;
+        validatedHandoff = handoff;
+        return handoff;
+      },
+      activate: (adoption?: unknown): void => {
+        if (callbacks.coordinateTakeover) {
+          const accepted = snapshotPersistentFirstDisplayAdoptionV1(adoption);
+          const handoff = validatedHandoff;
+          if (
+            !accepted ||
+            !handoff ||
+            !Object.is(accepted.handoff, handoff) ||
+            accepted.identities.length !== handoff.cycles.length + handoff.artifacts.length
+          ) {
+            throw new Error('Prepared kernel adoption is unavailable');
+          }
+        }
+        if (activated || committed || !this.activatePrepared(callbacks, adoption)) {
+          throw new Error('Prepared kernel activation is unavailable');
+        }
+        activated = true;
+      },
+      commit: (): void => {
+        if (!activated || committed) throw new Error('Prepared kernel commit is unavailable');
+        const result = this.commitPrepared(callbacks);
+        if (!result) throw new Error('Prepared kernel commit failed');
+        committed = result;
+      },
+      rollback: (): void => {
+        if (committed) throw new Error('Committed kernel cannot be rolled back');
+        this.fail('bundle_partial');
+      },
+    });
+
+    try {
+      if (callbacks.coordinateTakeover) {
+        this.enterOwnedCallback();
+        try {
+          const returned = callbacks.coordinateTakeover(prepared);
+          if (isThenable(returned)) {
+            observeThenableRejection(returned);
+            throw new TypeError('Takeover coordination must be synchronous');
+          }
+        } finally {
+          this.leaveOwnedCallback();
+        }
+        if (!committed) throw new Error('Takeover coordinator did not commit');
+      } else {
+        prepared.activate();
+        prepared.commit();
+      }
+    } catch {
+      this.fail('bundle_partial');
+      return this.fallbackResult();
+    }
+
+    return committed ?? this.fallbackResult();
+  }
+
+  private activatePrepared(callbacks: IntegrationInstallCallbacks, adoption?: unknown): boolean {
+    if (this.registryState !== 'preparing') return false;
+    const acceptedAdoption =
+      adoption === undefined ? undefined : snapshotPersistentFirstDisplayAdoptionV1(adoption);
+    if (adoption !== undefined && !acceptedAdoption) {
+      this.fail('bundle_partial');
+      return false;
+    }
+    this.registryState = 'activating';
+    if (!this.canContinue('activating')) return false;
+
+    let coreActivationOpen = true;
+    const coreContext: CoreActivationContext = Object.freeze({
+      signal: this.abortController.signal,
+      onDispose: (callback: DisposeCallback) => {
+        if (!coreActivationOpen && !this.coreScope.disposed) {
+          throw new Error('Core activation disposal registration is closed');
+        }
+        this.coreScope.onDispose(callback);
+      },
+    });
+    this.enterOwnedCallback();
+    try {
+      const returned = callbacks.activateCore(coreContext);
+      if (isThenable(returned)) {
+        observeThenableRejection(returned);
+        throw new TypeError('Core activation must be synchronous');
+      }
+    } catch {
+      this.fail('bundle_partial');
+      return false;
+    } finally {
+      coreActivationOpen = false;
+      this.leaveOwnedCallback();
+    }
+
+    if (!this.canContinue('activating')) return false;
+    for (const record of this.prepared) {
+      if (!this.canContinue('activating')) return false;
+      let activationOpen = true;
+      let afterCommitRegistered = false;
+      let activationInvalid = false;
+      const context: IntegrationActivationContext = Object.freeze({
+        signal: this.abortController.signal,
+        onDispose: (callback: DisposeCallback) => {
+          if (!activationOpen && !record.scope.disposed) {
+            throw new Error('Activation disposal registration is closed');
+          }
+          record.scope.onDispose(callback);
+        },
+        afterCommit: (callback: () => void) => {
+          if (!activationOpen) throw new Error('Activation is closed');
+          if (typeof callback !== 'function') throw new TypeError('afterCommit must be a function');
+          if (afterCommitRegistered) {
+            activationInvalid = true;
+            throw new Error('afterCommit may be registered only once');
+          }
+          afterCommitRegistered = true;
+          record.afterCommit = callback;
+        },
+        ...(acceptedAdoption === undefined ? {} : { adoption: acceptedAdoption }),
+      });
+
+      this.enterOwnedCallback();
+      try {
+        const returned = record.module.activate(context);
+        if (isThenable(returned)) {
+          observeThenableRejection(returned);
+          throw new TypeError('Integration activation must be synchronous');
+        }
+        if (activationInvalid) {
+          throw new Error('Integration activation violated the afterCommit contract');
+        }
+      } catch {
+        this.fail('bundle_partial');
+        return false;
+      } finally {
+        activationOpen = false;
+        this.leaveOwnedCallback();
+      }
+
+      if (!this.canContinue('activating')) return false;
+    }
+
+    // This final monotonic check closes the timer-task delay gap. A same-thread
+    // activation that never returns cannot be preempted by JavaScript.
+    return this.canContinue('activating');
+  }
+
+  private commitPrepared(
+    callbacks: IntegrationInstallCallbacks
+  ): IntegrationKernelResult | undefined {
+    if (this.registryState !== 'activating' || !this.canContinue('activating')) return undefined;
+    this.registryState = 'publishing';
+    this.enterOwnedCallback();
+    try {
+      const published = callbacks.publish();
+      if (isThenable(published)) {
+        observeThenableRejection(published);
+        throw new TypeError('Kernel publication must be synchronous');
+      }
+    } catch {
+      this.fail('bundle_partial');
+      return undefined;
+    } finally {
+      this.leaveOwnedCallback();
+    }
+
+    if (this.registryState !== 'publishing') {
+      this.fail('bundle_partial');
+      return undefined;
+    }
+
+    this.registryState = 'committed';
+    this.clearBootOwnership();
+    const runtimeFailures: IntegrationRuntimeFailure[] = [];
+    for (const record of this.prepared) {
+      if (!record.afterCommit) continue;
+      try {
+        record.afterCommit();
+      } catch {
+        record.scope.dispose();
+        const failure = Object.freeze({ id: record.id, phase: 'after_commit' as const });
+        runtimeFailures.push(failure);
+        try {
+          this.onRuntimeFailure(failure);
+        } catch {
+          // Runtime failure reporting is bounded observation, never control flow.
+        }
+      }
+    }
+
+    try {
+      const drained = callbacks.drainPreload();
+      if (isThenable(drained)) {
+        observeThenableRejection(drained, (error) => this.reportDisposalError(error));
+      }
+    } catch (error) {
+      this.reportDisposalError(error);
+    }
+
+    return Object.freeze({
+      state: 'kernel',
+      runtimeFailures: Object.freeze(runtimeFailures),
+      dispose: () => this.dispose(),
+    });
+  }
+
+  private reportDisposalError(error: unknown): void {
+    try {
+      this.onDisposalError(error);
+    } catch {
+      // The queue owns per-callback isolation; an observer cannot undo commit.
+    }
+  }
+}
+
+export function createIntegrationRegistry(
+  options: IntegrationRegistryOptions
+): IntegrationRegistry {
+  const owner = new IntegrationRegistryOwner(options);
+  return Object.freeze({
+    get state() {
+      return owner.state;
+    },
+    get manifest() {
+      return owner.manifest;
+    },
+    register: (candidate: unknown) => owner.register(candidate),
+    prepareDeferred: (
+      registration: DeferredIntegrationRegistration,
+      deferredOwner: Readonly<{
+        signal: AbortSignal;
+        onDispose: (callback: DisposeCallback) => void;
+      }>
+    ) => owner.prepareDeferred(registration, deferredOwner),
+    installSync: (callbacks: IntegrationInstallCallbacks) => owner.installSync(callbacks),
+    install: (callbacks: IntegrationInstallCallbacks) => owner.install(callbacks),
+    dispose: () => owner.dispose(),
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/lifecycle_module.ts b/crates/trusted-server-js/lib/src/kernel/lifecycle_module.ts
new file mode 100644
index 000000000..1081f1d49
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/lifecycle_module.ts
@@ -0,0 +1,169 @@
+import {
+  type PersistentFirstDisplaySliceStateV1,
+  validatePersistentFirstDisplaySliceAdoptionV1,
+} from '../shared/takeover';
+import { EMBEDDED_RUNTIME_CATALOG } from '../core/release';
+
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from './integration_registry';
+
+const MAX_CONFIG_DEPTH = 16;
+const MAX_CONFIG_NODES = 512;
+const MAX_CONFIG_MEMBERS = 256;
+
+export interface IntegrationLifecycleRuntime {
+  readonly activate: (config: unknown) => () => void;
+  readonly start: (config: unknown) => void;
+}
+
+export interface LifecycleIntegrationRegistrationOptions {
+  readonly createOwnedRuntime?: (context: IntegrationPrepareContext) => IntegrationLifecycleRuntime;
+  readonly firstDisplaySliceId?: string;
+  readonly validateConfig?: (candidate: unknown) => boolean;
+  readonly validateFirstDisplayState?: (
+    candidate: Readonly<PersistentFirstDisplaySliceStateV1>
+  ) => boolean;
+}
+
+function validFrozenConfig(candidate: unknown): boolean {
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    Array.isArray(candidate) ||
+    !Object.isFrozen(candidate) ||
+    Object.getPrototypeOf(candidate) !== Object.prototype
+  ) {
+    return false;
+  }
+  const visited = new Set<object>();
+  let nodes = 0;
+  const visit = (value: unknown, depth: number): boolean => {
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function')) return true;
+    if (typeof value === 'function' || depth > MAX_CONFIG_DEPTH || visited.has(value)) return false;
+    if (nodes >= MAX_CONFIG_NODES || !Object.isFrozen(value)) return false;
+    nodes += 1;
+    visited.add(value);
+    const isArray = Array.isArray(value);
+    if (!isArray && Object.getPrototypeOf(value) !== Object.prototype) return false;
+    const keys = Reflect.ownKeys(value);
+    if (keys.length > MAX_CONFIG_MEMBERS + (isArray ? 1 : 0)) return false;
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      if (typeof key !== 'string') return false;
+      if (isArray && key === 'length') continue;
+      if (isArray && key !== String(index)) return false;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return false;
+      if (!visit(descriptor.value, depth + 1)) return false;
+    }
+    return true;
+  };
+  try {
+    return visit(candidate, 0);
+  } catch {
+    return false;
+  }
+}
+
+function readRuntime(
+  id: string,
+  interfaces: Readonly<Record<string, unknown>>
+): IntegrationLifecycleRuntime | undefined {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(interfaces, id);
+    if (!descriptor || !('value' in descriptor)) return undefined;
+    const runtime = descriptor.value;
+    if (
+      typeof runtime !== 'object' ||
+      runtime === null ||
+      Array.isArray(runtime) ||
+      !Object.isFrozen(runtime) ||
+      Reflect.ownKeys(runtime).length !== 2
+    ) {
+      return undefined;
+    }
+    const activate = Object.getOwnPropertyDescriptor(runtime, 'activate');
+    const start = Object.getOwnPropertyDescriptor(runtime, 'start');
+    if (
+      !activate ||
+      !('value' in activate) ||
+      typeof activate.value !== 'function' ||
+      !start ||
+      !('value' in start) ||
+      typeof start.value !== 'function'
+    ) {
+      return undefined;
+    }
+    return runtime as IntegrationLifecycleRuntime;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Build a release-bound registration around one exact composition-owned runtime. */
+export function createLifecycleIntegrationRegistration(
+  id: string,
+  releaseId: string,
+  options: LifecycleIntegrationRegistrationOptions = {}
+): IntegrationRegistration {
+  const catalogEntry = EMBEDDED_RUNTIME_CATALOG.find((entry) => entry.id === id);
+  if (!catalogEntry) throw new TypeError(`Unknown release catalog module: ${id}`);
+  const prepare = (context: IntegrationPrepareContext) => {
+    const { config, interfaces } = context;
+    const validateConfig = options.validateConfig ?? validFrozenConfig;
+    let configValid: boolean;
+    try {
+      configValid = validateConfig(config);
+    } catch {
+      configValid = false;
+    }
+    if (!configValid) {
+      throw new TypeError(`${id} integration config is invalid`);
+    }
+    const runtime = options.createOwnedRuntime?.(context) ?? readRuntime(id, interfaces);
+    if (!runtime) throw new TypeError(`${id} integration runtime is unavailable`);
+
+    return Object.freeze({
+      activate: ({ adoption, afterCommit, onDispose }: IntegrationActivationContext) => {
+        if (adoption !== undefined && options.firstDisplaySliceId !== undefined) {
+          if (
+            !validatePersistentFirstDisplaySliceAdoptionV1(
+              adoption,
+              options.firstDisplaySliceId,
+              options.validateFirstDisplayState
+            )
+          ) {
+            throw new TypeError(`${id} first-display parser state is invalid`);
+          }
+        }
+        const runtimeRelease: { value?: () => void } = {};
+        onDispose(() => runtimeRelease.value?.());
+        const releaseRuntime = runtime.activate(config);
+        if (typeof releaseRuntime !== 'function') {
+          throw new TypeError(`${id} integration disposer is unavailable`);
+        }
+        runtimeRelease.value = releaseRuntime;
+        afterCommit(() => runtime.start(config));
+      },
+    });
+  };
+  return catalogEntry.phase === 'takeover'
+    ? Object.freeze({
+        abi: 1,
+        id,
+        phase: catalogEntry.phase,
+        releaseId,
+        prepareSync: prepare,
+        prepare,
+      })
+    : Object.freeze({
+        abi: 1,
+        id,
+        phase: catalogEntry.phase,
+        releaseId,
+        prepare,
+      });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/phase_loader.ts b/crates/trusted-server-js/lib/src/kernel/phase_loader.ts
new file mode 100644
index 000000000..6bf8b7846
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/phase_loader.ts
@@ -0,0 +1,624 @@
+import type { BootManifestDeferredIntegrationV1, BootManifestV1 } from '../core/types';
+
+import { DisposableStack, type DisposeCallback } from './disposable';
+import type {
+  DeferredIntegrationRegistration,
+  IntegrationActivationContext,
+  PreparedIntegration,
+} from './integration_registry';
+import { snapshotIntegrationRegistration } from './integration_registry';
+
+const ATTEMPT_CREATION_GUARD_MS = 10_000;
+const HIDDEN_PAINT_TIMEOUT_MS = 2_000;
+const IDLE_TIMEOUT_MS = 2_000;
+const IDLE_FALLBACK_MS = 50;
+const MODULE_TRANSACTION_TIMEOUT_MS = 10_000;
+const RELEASE_ID = /^[0-9a-f]{64}$/;
+
+type TimerHandle = ReturnType<typeof setTimeout>;
+
+export interface PhaseScheduler {
+  readonly setTimeout: (callback: () => void, delayMs: number) => TimerHandle;
+  readonly clearTimeout: (handle: TimerHandle) => void;
+  readonly requestAnimationFrame: (callback: FrameRequestCallback) => number;
+  readonly cancelAnimationFrame: (handle: number) => void;
+  readonly requestIdleCallback?: (
+    callback: () => void,
+    options: Readonly<{ timeout: number }>
+  ) => number;
+  readonly cancelIdleCallback?: (handle: number) => void;
+}
+
+export interface ProtectedFirstDisplayGate {
+  readonly ready: Promise<boolean>;
+  readonly commit: () => void;
+  readonly protectAttemptBatch: (terminalLatches: readonly PromiseLike<unknown>[]) => boolean;
+  readonly dispose: () => void;
+}
+
+export interface ProtectedFirstDisplayGateOptions {
+  readonly document: Document;
+  readonly scheduler?: PhaseScheduler;
+  readonly markPaint?: () => void;
+  /** The provisional agent already completed the terminal/two-frame paint gate. */
+  readonly paintAlreadyRecorded?: boolean;
+}
+
+function browserScheduler(document: Document): PhaseScheduler {
+  const view = document.defaultView;
+  if (!view) throw new TypeError('Phase scheduler requires a browser window');
+  const idle = view as Window & {
+    cancelIdleCallback?: (handle: number) => void;
+    requestIdleCallback?: (callback: () => void, options: { timeout: number }) => number;
+  };
+  return Object.freeze({
+    cancelAnimationFrame: (handle: number) => view.cancelAnimationFrame(handle),
+    clearTimeout: (handle: TimerHandle) => clearTimeout(handle),
+    requestAnimationFrame: (callback: FrameRequestCallback) => view.requestAnimationFrame(callback),
+    ...(typeof idle.requestIdleCallback === 'function'
+      ? {
+          cancelIdleCallback: (handle: number) => idle.cancelIdleCallback?.(handle),
+          requestIdleCallback: (callback: () => void, options: { timeout: number }) =>
+            idle.requestIdleCallback?.(callback, options) ?? 0,
+        }
+      : {}),
+    setTimeout: (callback: () => void, delayMs: number) => setTimeout(callback, delayMs),
+  });
+}
+
+/** Own the only attempt-terminal, paint, and idle gate for deferred work. */
+export function createProtectedFirstDisplayGate(
+  options: ProtectedFirstDisplayGateOptions
+): ProtectedFirstDisplayGate {
+  const scheduler = options.scheduler ?? browserScheduler(options.document);
+  let committed = false;
+  let disposed = false;
+  let protectedBatch = false;
+  let releasedFromAttemptGuard = false;
+  let attemptTimer: TimerHandle | undefined;
+  let hiddenTimer: TimerHandle | undefined;
+  let idleTimer: TimerHandle | undefined;
+  let frameOne: number | undefined;
+  let frameTwo: number | undefined;
+  let idleHandle: number | undefined;
+  let resolveReady: ((ready: boolean) => void) | undefined;
+  const ready = new Promise<boolean>((resolve) => {
+    resolveReady = resolve;
+  });
+
+  const clearOwnedScheduling = (): void => {
+    if (attemptTimer !== undefined) scheduler.clearTimeout(attemptTimer);
+    if (hiddenTimer !== undefined) scheduler.clearTimeout(hiddenTimer);
+    if (idleTimer !== undefined) scheduler.clearTimeout(idleTimer);
+    if (frameOne !== undefined) scheduler.cancelAnimationFrame(frameOne);
+    if (frameTwo !== undefined) scheduler.cancelAnimationFrame(frameTwo);
+    if (idleHandle !== undefined) scheduler.cancelIdleCallback?.(idleHandle);
+    attemptTimer = undefined;
+    hiddenTimer = undefined;
+    idleTimer = undefined;
+    frameOne = undefined;
+    frameTwo = undefined;
+    idleHandle = undefined;
+  };
+
+  const finish = (): void => {
+    if (disposed) return;
+    clearOwnedScheduling();
+    resolveReady?.(true);
+    resolveReady = undefined;
+  };
+
+  const scheduleIdle = (): void => {
+    if (disposed) return;
+    if (scheduler.requestIdleCallback) {
+      idleHandle = scheduler.requestIdleCallback(finish, { timeout: IDLE_TIMEOUT_MS });
+      return;
+    }
+    idleTimer = scheduler.setTimeout(finish, IDLE_FALLBACK_MS);
+  };
+
+  const markAndScheduleIdle = (): void => {
+    if (disposed) return;
+    try {
+      options.markPaint?.();
+    } finally {
+      scheduleIdle();
+    }
+  };
+
+  const waitForTwoFrames = (): void => {
+    if (disposed) return;
+    frameOne = scheduler.requestAnimationFrame(() => {
+      frameOne = undefined;
+      if (disposed) return;
+      frameTwo = scheduler.requestAnimationFrame(() => {
+        frameTwo = undefined;
+        markAndScheduleIdle();
+      });
+    });
+  };
+
+  const onVisibility = (): void => {
+    if (options.document.visibilityState !== 'visible' || disposed) return;
+    options.document.removeEventListener('visibilitychange', onVisibility);
+    if (hiddenTimer !== undefined) scheduler.clearTimeout(hiddenTimer);
+    hiddenTimer = undefined;
+    waitForTwoFrames();
+  };
+
+  const enterPaintGate = (): void => {
+    if (releasedFromAttemptGuard || disposed) return;
+    releasedFromAttemptGuard = true;
+    if (options.document.visibilityState === 'hidden') {
+      options.document.addEventListener('visibilitychange', onVisibility);
+      hiddenTimer = scheduler.setTimeout(() => {
+        hiddenTimer = undefined;
+        options.document.removeEventListener('visibilitychange', onVisibility);
+        markAndScheduleIdle();
+      }, HIDDEN_PAINT_TIMEOUT_MS);
+      return;
+    }
+    waitForTwoFrames();
+  };
+
+  return Object.freeze({
+    ready,
+    commit: () => {
+      if (committed || disposed) return;
+      committed = true;
+      if (options.paintAlreadyRecorded) {
+        releasedFromAttemptGuard = true;
+        scheduleIdle();
+        return;
+      }
+      attemptTimer = scheduler.setTimeout(() => {
+        attemptTimer = undefined;
+        enterPaintGate();
+      }, ATTEMPT_CREATION_GUARD_MS);
+    },
+    protectAttemptBatch: (terminalLatches: readonly PromiseLike<unknown>[]) => {
+      if (!committed || disposed || protectedBatch || releasedFromAttemptGuard) return false;
+      protectedBatch = true;
+      if (attemptTimer !== undefined) scheduler.clearTimeout(attemptTimer);
+      attemptTimer = undefined;
+      void Promise.allSettled([...terminalLatches]).then(enterPaintGate);
+      return true;
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      options.document.removeEventListener('visibilitychange', onVisibility);
+      clearOwnedScheduling();
+      resolveReady?.(false);
+      resolveReady = undefined;
+    },
+  });
+}
+
+export type DeferredModuleState =
+  'not_triggered' | 'loading' | 'registered' | 'preparing' | 'activating' | 'ready' | 'unavailable';
+
+export type DeferredModuleUnavailableReason =
+  | 'load_error'
+  | 'load_without_registration'
+  | 'registration_rejected'
+  | 'prepare_failed'
+  | 'activation_failed'
+  | 'after_commit_failed'
+  | 'policy_blocked'
+  | 'module_timeout'
+  | 'disposed';
+
+export interface DeferredPhaseLoader {
+  readonly register: (candidate: unknown) => boolean;
+  readonly state: (id: string) => DeferredModuleState | undefined;
+  readonly reason: (id: string) => DeferredModuleUnavailableReason | undefined;
+  readonly waitFor: (
+    id: string,
+    timeoutMs: number
+  ) => Promise<'ready' | 'unavailable' | 'caller_timeout'>;
+  readonly dispose: () => void;
+}
+
+export interface DeferredPhaseLoaderOptions {
+  readonly runtimeScript: HTMLScriptElement;
+  /** Bootstrap-captured native current-script observation for registration authentication. */
+  readonly currentScript?: () => HTMLScriptElement | null;
+  readonly document: Document;
+  readonly prepare: (
+    registration: DeferredIntegrationRegistration,
+    owner: Readonly<{
+      signal: AbortSignal;
+      onDispose: (callback: DisposeCallback) => void;
+    }>
+  ) => PreparedIntegration | PromiseLike<PreparedIntegration>;
+  readonly gate: PromiseLike<boolean | void>;
+  readonly manifest: BootManifestV1;
+  readonly releaseId: string;
+  readonly scheduler?: Pick<PhaseScheduler, 'clearTimeout' | 'setTimeout'>;
+  readonly trustedScriptUrl?: (value: string) => unknown;
+}
+
+interface DeferredTransaction {
+  readonly entry: BootManifestDeferredIntegrationV1;
+  readonly expectedUrl: string;
+  readonly abortController: AbortController;
+  readonly scope: DisposableStack;
+  script: HTMLScriptElement | undefined;
+  registration: DeferredIntegrationRegistration | undefined;
+  state: DeferredModuleState;
+  reason: DeferredModuleUnavailableReason | undefined;
+  timeout: TimerHandle | undefined;
+  readonly waiters: Set<{
+    readonly resolve: (result: 'ready' | 'unavailable') => void;
+    readonly timer: TimerHandle;
+  }>;
+}
+
+function manifestDeferredTransactions(
+  manifest: BootManifestV1,
+  releaseId: string,
+  document: Document
+): readonly DeferredTransaction[] {
+  if (manifest.releaseId !== releaseId || !RELEASE_ID.test(releaseId)) return Object.freeze([]);
+  const origin = document.defaultView?.location.origin;
+  if (!origin || origin === 'null') return Object.freeze([]);
+  const transactions: DeferredTransaction[] = [];
+  for (const entry of manifest.integrations) {
+    if (entry.phase !== 'deferred') continue;
+    try {
+      const expectedUrl: URL = new URL(entry.src, origin);
+      if (
+        expectedUrl.origin !== origin ||
+        expectedUrl.hash !== '' ||
+        `${expectedUrl.pathname}${expectedUrl.search}` !== entry.src
+      ) {
+        return Object.freeze([]);
+      }
+      transactions.push({
+        entry,
+        expectedUrl: expectedUrl.href,
+        abortController: new AbortController(),
+        scope: new DisposableStack(),
+        script: undefined,
+        registration: undefined,
+        state: 'not_triggered',
+        reason: undefined,
+        timeout: undefined,
+        waiters: new Set(),
+      });
+    } catch {
+      return Object.freeze([]);
+    }
+  }
+  return Object.freeze(transactions);
+}
+
+/** Load and authenticate every deferred classic IIFE after the shared paint gate. */
+export function createDeferredPhaseLoader(
+  options: DeferredPhaseLoaderOptions
+): DeferredPhaseLoader {
+  const scheduler =
+    options.scheduler ??
+    Object.freeze({
+      clearTimeout: (handle: TimerHandle) => clearTimeout(handle),
+      setTimeout: (callback: () => void, delayMs: number) => setTimeout(callback, delayMs),
+    });
+  const transactions = manifestDeferredTransactions(
+    options.manifest,
+    options.releaseId,
+    options.document
+  );
+  const byId = new Map(transactions.map((transaction) => [transaction.entry.id, transaction]));
+  let disposed = false;
+  let privatePolicy: Readonly<{ createScriptURL: (value: string) => unknown }> | null | undefined;
+  const exactUrls = new Set(transactions.map(({ expectedUrl }) => expectedUrl));
+  const trustedCurrentScript = (): HTMLScriptElement | null => {
+    try {
+      if (options.currentScript) return options.currentScript();
+      const candidate = options.document.currentScript;
+      const Script = options.document.defaultView?.HTMLScriptElement;
+      return Script && candidate instanceof Script ? candidate : null;
+    } catch {
+      return null;
+    }
+  };
+
+  const removeNode = (transaction: DeferredTransaction): void => {
+    const script = transaction.script;
+    if (!script) return;
+    script.onload = null;
+    script.onerror = null;
+    try {
+      script.remove();
+    } catch {
+      // A hostile publisher mutation cannot prevent transaction retirement.
+    }
+    transaction.script = undefined;
+  };
+
+  const settleWaiters = (
+    transaction: DeferredTransaction,
+    result: 'ready' | 'unavailable'
+  ): void => {
+    for (const waiter of transaction.waiters) {
+      scheduler.clearTimeout(waiter.timer);
+      waiter.resolve(result);
+    }
+    transaction.waiters.clear();
+  };
+
+  const settleUnavailable = (
+    transaction: DeferredTransaction,
+    reason: DeferredModuleUnavailableReason
+  ): void => {
+    if (transaction.state === 'ready' || transaction.state === 'unavailable') return;
+    transaction.state = 'unavailable';
+    transaction.reason = reason;
+    transaction.abortController.abort();
+    transaction.scope.dispose();
+    if (transaction.timeout !== undefined) scheduler.clearTimeout(transaction.timeout);
+    transaction.timeout = undefined;
+    removeNode(transaction);
+    settleWaiters(transaction, 'unavailable');
+  };
+
+  const exactPreparedIntegration = (candidate: unknown): PreparedIntegration | undefined => {
+    try {
+      if (
+        typeof candidate !== 'object' ||
+        candidate === null ||
+        Array.isArray(candidate) ||
+        Object.getPrototypeOf(candidate) !== Object.prototype ||
+        Reflect.ownKeys(candidate).length !== 1
+      ) {
+        return undefined;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, 'activate');
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      if (typeof descriptor.value !== 'function') return undefined;
+      return Object.freeze({ activate: descriptor.value as PreparedIntegration['activate'] });
+    } catch {
+      return undefined;
+    }
+  };
+
+  const finishExecution = async (transaction: DeferredTransaction): Promise<void> => {
+    const registration = transaction.registration;
+    if (!registration) {
+      settleUnavailable(transaction, 'load_without_registration');
+      return;
+    }
+    if (!transaction.script?.isConnected) {
+      settleUnavailable(transaction, 'registration_rejected');
+      return;
+    }
+    removeNode(transaction);
+    transaction.state = 'preparing';
+    let pending: PreparedIntegration | PromiseLike<PreparedIntegration>;
+    try {
+      pending = options.prepare(
+        registration,
+        Object.freeze({
+          signal: transaction.abortController.signal,
+          onDispose: (callback: DisposeCallback) => transaction.scope.onDispose(callback),
+        })
+      );
+    } catch {
+      settleUnavailable(transaction, 'prepare_failed');
+      return;
+    }
+    let prepared: PreparedIntegration | undefined;
+    try {
+      prepared = exactPreparedIntegration(await pending);
+    } catch {
+      settleUnavailable(transaction, 'prepare_failed');
+      return;
+    }
+    if (!prepared) {
+      settleUnavailable(transaction, 'prepare_failed');
+      return;
+    }
+    if (transaction.abortController.signal.aborted) return;
+    transaction.state = 'activating';
+    let afterCommit: (() => void) | undefined;
+    let afterCommitRegistered = false;
+    let activationOpen = true;
+    const activationContext: IntegrationActivationContext = Object.freeze({
+      signal: transaction.abortController.signal,
+      onDispose: (callback: DisposeCallback) => {
+        if (!activationOpen && !transaction.scope.disposed) {
+          throw new Error('Deferred activation disposal registration is closed');
+        }
+        transaction.scope.onDispose(callback);
+      },
+      afterCommit: (callback: () => void) => {
+        if (!activationOpen || afterCommitRegistered || typeof callback !== 'function') {
+          throw new Error('Deferred afterCommit may be registered exactly once');
+        }
+        afterCommitRegistered = true;
+        afterCommit = callback;
+      },
+    });
+    try {
+      const returned = prepared.activate(activationContext) as unknown;
+      if (
+        (typeof returned === 'object' || typeof returned === 'function') &&
+        returned !== null &&
+        typeof (returned as { then?: unknown }).then === 'function'
+      ) {
+        void Promise.resolve(returned).catch(() => undefined);
+        throw new TypeError('Deferred activation must be synchronous');
+      }
+    } catch {
+      settleUnavailable(transaction, 'activation_failed');
+      return;
+    } finally {
+      activationOpen = false;
+    }
+    if (transaction.abortController.signal.aborted) return;
+    try {
+      afterCommit?.();
+    } catch {
+      settleUnavailable(transaction, 'after_commit_failed');
+      return;
+    }
+    if (transaction.abortController.signal.aborted) return;
+    transaction.state = 'ready';
+    if (transaction.timeout !== undefined) scheduler.clearTimeout(transaction.timeout);
+    transaction.timeout = undefined;
+    settleWaiters(transaction, 'ready');
+  };
+
+  const createPolicy = (): typeof privatePolicy => {
+    if (privatePolicy !== undefined) return privatePolicy;
+    privatePolicy = null;
+    try {
+      if (options.trustedScriptUrl) {
+        privatePolicy = Object.freeze({ createScriptURL: options.trustedScriptUrl });
+        return privatePolicy;
+      }
+      const trustedTypes = options.document.defaultView as
+        | (Window & {
+            trustedTypes?: {
+              createPolicy: (
+                name: string,
+                rules: Readonly<{ createScriptURL: (value: string) => string }>
+              ) => Readonly<{ createScriptURL: (value: string) => unknown }>;
+            };
+          })
+        | null;
+      if (!trustedTypes?.trustedTypes) return privatePolicy;
+      privatePolicy = trustedTypes.trustedTypes.createPolicy('trusted-server#tsjs-v1', {
+        createScriptURL: (value: string) => {
+          if (!exactUrls.has(value)) throw new TypeError('Deferred script URL is not admitted');
+          return value;
+        },
+      });
+    } catch {
+      privatePolicy = null;
+    }
+    return privatePolicy;
+  };
+
+  const start = (transaction: DeferredTransaction): void => {
+    if (disposed || transaction.state !== 'not_triggered') return;
+    transaction.state = 'loading';
+    transaction.timeout = scheduler.setTimeout(
+      () => settleUnavailable(transaction, 'module_timeout'),
+      MODULE_TRANSACTION_TIMEOUT_MS
+    );
+    const script = options.document.createElement('script');
+    script.async = true;
+    const nonce = options.runtimeScript.nonce;
+    if (nonce !== '') script.nonce = nonce;
+    transaction.script = script;
+    try {
+      const policy = createPolicy();
+      const assigned = policy
+        ? policy.createScriptURL(transaction.expectedUrl)
+        : transaction.expectedUrl;
+      script.src = assigned as string;
+      if (script.src !== transaction.expectedUrl) {
+        settleUnavailable(transaction, 'policy_blocked');
+        return;
+      }
+    } catch {
+      settleUnavailable(transaction, 'policy_blocked');
+      return;
+    }
+    script.onload = () => {
+      void finishExecution(transaction);
+    };
+    script.onerror = () => settleUnavailable(transaction, 'load_error');
+    try {
+      (options.document.head ?? options.document.documentElement).append(script);
+    } catch {
+      settleUnavailable(transaction, 'load_error');
+    }
+  };
+
+  void Promise.resolve(options.gate).then(
+    (gateReady) => {
+      if (disposed || gateReady === false) {
+        for (const transaction of transactions) settleUnavailable(transaction, 'disposed');
+        return;
+      }
+      for (const transaction of transactions) start(transaction);
+    },
+    () => {
+      for (const transaction of transactions) settleUnavailable(transaction, 'disposed');
+    }
+  );
+
+  return Object.freeze({
+    register: (candidate: unknown) => {
+      const registration = snapshotIntegrationRegistration(candidate);
+      if (
+        !registration ||
+        registration.phase !== 'deferred' ||
+        registration.releaseId !== options.releaseId
+      ) {
+        return false;
+      }
+      const transaction = byId.get(registration.id);
+      if (!transaction) return false;
+      const currentScript = trustedCurrentScript();
+      if (currentScript !== transaction.script) return false;
+      if (transaction.state !== 'loading' || transaction.registration) {
+        settleUnavailable(transaction, 'registration_rejected');
+        return false;
+      }
+      if (!currentScript.isConnected || currentScript.src !== transaction.expectedUrl) {
+        settleUnavailable(transaction, 'registration_rejected');
+        return false;
+      }
+      transaction.registration = registration;
+      transaction.state = 'registered';
+      return true;
+    },
+    state: (id: string) => byId.get(id)?.state,
+    reason: (id: string) => byId.get(id)?.reason,
+    waitFor: (
+      id: string,
+      timeoutMs: number
+    ): Promise<'ready' | 'unavailable' | 'caller_timeout'> => {
+      const transaction = byId.get(id);
+      if (!transaction || transaction.state === 'unavailable') {
+        return Promise.resolve('unavailable');
+      }
+      if (transaction.state === 'ready') return Promise.resolve('ready');
+      if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return Promise.resolve('caller_timeout');
+      }
+      return new Promise<'ready' | 'unavailable' | 'caller_timeout'>((resolve) => {
+        const waiter: {
+          resolve: (result: 'ready' | 'unavailable') => void;
+          timer: TimerHandle;
+        } = {
+          resolve,
+          timer: undefined as unknown as TimerHandle,
+        };
+        waiter.timer = scheduler.setTimeout(() => {
+          transaction.waiters.delete(waiter);
+          resolve('caller_timeout');
+        }, timeoutMs);
+        transaction.waiters.add(waiter);
+      });
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      for (let index = transactions.length - 1; index >= 0; index -= 1) {
+        const transaction = transactions[index];
+        if (!transaction) continue;
+        if (transaction.state === 'ready') {
+          transaction.abortController.abort();
+          transaction.scope.dispose();
+          continue;
+        }
+        settleUnavailable(transaction, 'disposed');
+      }
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/release_catalog.ts b/crates/trusted-server-js/lib/src/kernel/release_catalog.ts
new file mode 100644
index 000000000..3b9c885e0
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/release_catalog.ts
@@ -0,0 +1,776 @@
+export type ReleasePhase = 'takeover' | 'deferred';
+export type ReleaseTrigger = 'first_display_or_idle';
+export type ReleaseConfigSourceV1 =
+  | 'aps'
+  | 'datadome'
+  | 'didomi'
+  | 'google_tag_manager'
+  | 'gpt'
+  | 'lockr'
+  | 'osano'
+  | 'permutive'
+  | 'prebid'
+  | 'sourcepoint'
+  | 'testlight'
+  | 'creative'
+  | 'diagnostics'
+  | null;
+export type ReleaseIncludePredicate =
+  | 'always'
+  | 'creative_guard'
+  | 'gpt_diagnostics_active'
+  | 'diagnostics_presentation'
+  | 'prebid_and_gpt'
+  | `integration:${
+      | 'aps'
+      | 'datadome'
+      | 'didomi'
+      | 'google_tag_manager'
+      | 'gpt'
+      | 'lockr'
+      | 'osano'
+      | 'permutive'
+      | 'prebid'
+      | 'sourcepoint'
+      | 'testlight'}`;
+
+export interface ReleaseCatalogEntry {
+  readonly order: number;
+  readonly id: string;
+  readonly product: string;
+  readonly phase: ReleasePhase;
+  readonly trigger: ReleaseTrigger | null;
+  readonly include: ReleaseIncludePredicate;
+  readonly config: ReleaseConfigSourceV1;
+  /** A conditional edge uses `<capability>?<predicate>` and no other grammar. */
+  readonly consumes: readonly string[];
+  readonly provides: readonly string[];
+  readonly obligation: string;
+}
+
+export interface ReleaseCatalogSelection {
+  readonly integrations: readonly string[];
+  readonly creative?: Readonly<{
+    enabled: boolean;
+    clickGuard: boolean;
+    renderGuard: boolean;
+  }>;
+  readonly gptDiagnosticsActive?: boolean;
+  readonly renderTraceOverlay?: boolean;
+}
+
+export type FirstDisplaySliceId =
+  | 'first_display'
+  | 'render_owner_initial'
+  | 'aps_initial'
+  | 'creative_initial'
+  | 'datadome_initial'
+  | 'didomi_initial'
+  | 'google_tag_manager_initial'
+  | 'gpt_initial'
+  | 'lockr_initial'
+  | 'osano_initial'
+  | 'permutive_initial'
+  | 'sourcepoint_initial'
+  | 'prebid_initial'
+  | 'testlight_initial';
+
+export type FirstDisplayIncludePredicate =
+  | 'eligible_batch'
+  | 'render_owner_participates'
+  | 'aps_participates'
+  | 'creative_guard'
+  | 'gpt_initial'
+  | 'prebid_participates'
+  | `integration:${
+      | 'datadome'
+      | 'didomi'
+      | 'google_tag_manager'
+      | 'lockr'
+      | 'osano'
+      | 'permutive'
+      | 'sourcepoint'
+      | 'testlight'}`;
+
+export interface FirstDisplayCatalogEntry {
+  readonly order: number;
+  readonly id: FirstDisplaySliceId;
+  readonly include: FirstDisplayIncludePredicate;
+  readonly allowedImports: readonly string[];
+  readonly inputs: readonly string[];
+  readonly outputs: readonly string[];
+  readonly obligation: string;
+}
+
+export interface FirstDisplayCatalogSelection {
+  readonly eligibleBatch: boolean;
+  readonly integrations: readonly string[];
+  readonly apsParticipates?: boolean;
+  readonly renderOwnerParticipates?: boolean;
+  readonly prebidParticipates?: boolean;
+  readonly creative?: Readonly<{
+    enabled: boolean;
+    clickGuard: boolean;
+    renderGuard: boolean;
+  }>;
+}
+
+const firstDisplayRow = (entry: FirstDisplayCatalogEntry): FirstDisplayCatalogEntry =>
+  Object.freeze({
+    ...entry,
+    allowedImports: Object.freeze([...entry.allowedImports]),
+    inputs: Object.freeze([...entry.inputs]),
+    outputs: Object.freeze([...entry.outputs]),
+  });
+
+/** Closed build catalog for the one provisional first-display artifact. */
+export const FIRST_DISPLAY_CATALOG: readonly FirstDisplayCatalogEntry[] = Object.freeze([
+  firstDisplayRow({
+    order: 1,
+    id: 'first_display',
+    include: 'eligible_batch',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'shared/first_display_handoff',
+      'shared/first_display_registration',
+      'shared/first_display_transaction',
+      'shared/integration_config_validators',
+      'first_display/driver',
+      'first_display/leaf/projection',
+      'first_display/registration_client',
+      'kernel/identity',
+    ],
+    inputs: ['boot.v1', 'projection.v1'],
+    outputs: ['first_display.control.v1'],
+    obligation:
+      'Validate the immutable batch and own provisional lifetime, timing, ingress, and transfer',
+  }),
+  firstDisplayRow({
+    order: 2,
+    id: 'render_owner_initial',
+    include: 'render_owner_participates',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/render_journal',
+      'kernel/contracts/puc_dynamic_owner',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['render_owner.initial.v1'],
+    obligation:
+      'Own source-neutral reservation, ticket, v4 PUC, render journal, handoff, and retirement state',
+  }),
+  firstDisplayRow({
+    order: 3,
+    id: 'aps_initial',
+    include: 'aps_participates',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/aps_protocol',
+      'first_display/render_bridge',
+    ],
+    inputs: ['first_display.control.v1', 'render_owner.initial.v1'],
+    outputs: ['aps.initial.v1'],
+    obligation: 'Own APS URL, nonce, renderer-document, and top-mount authority',
+  }),
+  firstDisplayRow({
+    order: 4,
+    id: 'creative_initial',
+    include: 'creative_guard',
+    allowedImports: [
+      'core/log',
+      'shared/async',
+      'shared/first_display_contracts',
+      'shared/globals',
+      'shared/origin',
+      'shared/scheduler',
+      'first_display/registration_client',
+      'first_display/leaf/creative_guard',
+      'integrations/creative/click',
+      'integrations/creative/dynamic_src_guard',
+      'integrations/creative/iframe',
+      'integrations/creative/image',
+      'integrations/creative/proxy_sign',
+      'integrations/creative/startup',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['creative.initial.v1'],
+    obligation: 'Install current parser-time creative guards and record initial observations only',
+  }),
+  firstDisplayRow({
+    order: 5,
+    id: 'datadome_initial',
+    include: 'integration:datadome',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/route_guard',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['datadome.initial.v1'],
+    obligation: 'Install the initial DataDome script and preload route guard',
+  }),
+  firstDisplayRow({
+    order: 6,
+    id: 'didomi_initial',
+    include: 'integration:didomi',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/config_guard',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['didomi.initial.v1'],
+    obligation: 'Install the configured Didomi SDK path before SDK evaluation',
+  }),
+  firstDisplayRow({
+    order: 7,
+    id: 'google_tag_manager_initial',
+    include: 'integration:google_tag_manager',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/route_guard',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['google_tag_manager.initial.v1'],
+    obligation: 'Install initial GTM script, preload, beacon, and fetch guards',
+  }),
+  firstDisplayRow({
+    order: 8,
+    id: 'gpt_initial',
+    include: 'gpt_initial',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/adapters/googletag',
+      'first_display/leaf/gpt_protocol',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['gpt.initial.v1'],
+    obligation: 'Sole provisional GPT adapter, listeners, targeting, request, and handoff capture',
+  }),
+  firstDisplayRow({
+    order: 9,
+    id: 'lockr_initial',
+    include: 'integration:lockr',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/route_guard',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['lockr.initial.v1'],
+    obligation: 'Install the initial Lockr script guard and bounded readiness observation',
+  }),
+  firstDisplayRow({
+    order: 10,
+    id: 'osano_initial',
+    include: 'integration:osano',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/consent_snapshot',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['osano.initial.v1'],
+    obligation: 'Capture the initial consent mirrors required by the protected batch',
+  }),
+  firstDisplayRow({
+    order: 11,
+    id: 'permutive_initial',
+    include: 'integration:permutive',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/context_snapshot',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['permutive.initial.v1'],
+    obligation: 'Install initial guard/readiness and capture normalized segments',
+  }),
+  firstDisplayRow({
+    order: 12,
+    id: 'sourcepoint_initial',
+    include: 'integration:sourcepoint',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/consent_snapshot',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['sourcepoint.initial.v1'],
+    obligation: 'Install the initial SDK guard and capture the GPP mirror',
+  }),
+  firstDisplayRow({
+    order: 13,
+    id: 'prebid_initial',
+    include: 'prebid_participates',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/prebid_protocol',
+    ],
+    inputs: ['first_display.control.v1', 'gpt.initial.v1'],
+    outputs: ['prebid.initial.v1'],
+    obligation:
+      'Own initial artifact admission, queue, bidder, identity, EID, TS bid, and PUC setup',
+  }),
+  firstDisplayRow({
+    order: 14,
+    id: 'testlight_initial',
+    include: 'integration:testlight',
+    allowedImports: [
+      'shared/first_display_contracts',
+      'first_display/registration_client',
+      'first_display/leaf/callback_capture',
+    ],
+    inputs: ['first_display.control.v1'],
+    outputs: ['testlight.initial.v1'],
+    obligation: 'Capture preexisting callbacks before publisher replacement or drain',
+  }),
+]);
+
+const FIRST_DISPLAY_KNOWN_INTEGRATIONS = new Set([
+  'aps',
+  'creative',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'sourcepoint',
+  'testlight',
+]);
+
+/** Select the exact ordered provisional slices from trusted server-owned facts. */
+export function selectFirstDisplayCatalog(
+  selection: FirstDisplayCatalogSelection
+): readonly FirstDisplayCatalogEntry[] {
+  const integrations = new Set<string>();
+  for (const id of selection.integrations) {
+    if (!FIRST_DISPLAY_KNOWN_INTEGRATIONS.has(id)) {
+      throw new TypeError(`Unknown first-display integration: ${id}`);
+    }
+    integrations.add(id);
+  }
+  if (!selection.eligibleBatch) return Object.freeze([]);
+
+  const include = (predicate: FirstDisplayIncludePredicate): boolean => {
+    if (predicate === 'eligible_batch') return true;
+    if (predicate === 'render_owner_participates') {
+      return (
+        selection.renderOwnerParticipates === true ||
+        (selection.apsParticipates === true && integrations.has('aps'))
+      );
+    }
+    if (predicate === 'aps_participates') {
+      return selection.apsParticipates === true && integrations.has('aps');
+    }
+    if (predicate === 'prebid_participates') {
+      return selection.prebidParticipates === true && integrations.has('prebid');
+    }
+    if (predicate === 'gpt_initial') return integrations.has('gpt');
+    if (predicate === 'creative_guard') {
+      const creative = selection.creative;
+      return Boolean(creative?.enabled && (creative.clickGuard || creative.renderGuard));
+    }
+    return integrations.has(predicate.slice('integration:'.length));
+  };
+
+  const selected = FIRST_DISPLAY_CATALOG.filter((entry) => include(entry.include));
+  if (!selected.some(({ id }) => id === 'gpt_initial')) return Object.freeze([]);
+  return Object.freeze(selected);
+}
+
+export const MAX_FIRST_DISPLAY_SLICES = FIRST_DISPLAY_CATALOG.length;
+
+const row = (entry: ReleaseCatalogEntry): ReleaseCatalogEntry =>
+  Object.freeze({
+    ...entry,
+    consumes: Object.freeze([...entry.consumes]),
+    provides: Object.freeze([...entry.provides]),
+  });
+
+/** The only production TSJS integration-module catalog and injection order. */
+export const RELEASE_CATALOG: readonly ReleaseCatalogEntry[] = Object.freeze([
+  row({
+    order: 1,
+    id: 'render_runtime',
+    product: 'runtime',
+    phase: 'takeover',
+    trigger: null,
+    include: 'always',
+    config: null,
+    provides: [
+      'slots.v1',
+      'auction.v1',
+      'render.v1',
+      'messages.v1',
+      'trace.v1',
+      'trace.presentation.v1',
+      'direct.v1',
+    ],
+    consumes: ['runtime.v1'],
+    obligation: 'Public direct first display, projection, one lifecycle/dispatcher/trace owner',
+  }),
+  row({
+    order: 2,
+    id: 'aps',
+    product: 'APS',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:aps',
+    config: 'aps',
+    provides: ['aps.v1'],
+    consumes: ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'trace.v1'],
+    obligation: 'Any initial APS winner and PUC claim must render',
+  }),
+  row({
+    order: 3,
+    id: 'creative',
+    product: 'creative',
+    phase: 'takeover',
+    trigger: null,
+    include: 'creative_guard',
+    config: 'creative',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'Guards must observe parser-time DOM/constructor activity',
+  }),
+  row({
+    order: 4,
+    id: 'datadome',
+    product: 'DataDome',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:datadome',
+    config: 'datadome',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'Script/preload rewriting must precede publisher SDK insertion',
+  }),
+  row({
+    order: 5,
+    id: 'didomi',
+    product: 'Didomi',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:didomi',
+    config: 'didomi',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'didomiConfig.sdkPath must exist before SDK evaluation',
+  }),
+  row({
+    order: 6,
+    id: 'google_tag_manager',
+    product: 'GTM/GA',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:google_tag_manager',
+    config: 'google_tag_manager',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'Script/preload/beacon/fetch guards must precede matching traffic',
+  }),
+  row({
+    order: 7,
+    id: 'gpt',
+    product: 'GPT',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:gpt',
+    config: 'gpt',
+    provides: ['gpt.v1', 'gpt.events.v1', 'pbs_cache.baseline.v1'],
+    consumes: [
+      'runtime.v1',
+      'slots.v1',
+      'auction.v1',
+      'render.v1',
+      'messages.v1',
+      'trace.v1',
+      'aps.v1?aps',
+    ],
+    obligation:
+      'Sole GPT adapter/listeners plus every initial handoff/hydration/reconciliation path',
+  }),
+  row({
+    order: 8,
+    id: 'gpt_diagnostics',
+    product: 'diagnostics',
+    phase: 'takeover',
+    trigger: null,
+    include: 'gpt_diagnostics_active',
+    config: 'diagnostics',
+    provides: ['gpt_diag.v1'],
+    consumes: ['runtime.v1', 'gpt.events.v1'],
+    obligation:
+      'Consume the GPT-owned bounded fact stream and commit the final data-only public API',
+  }),
+  row({
+    order: 9,
+    id: 'lockr',
+    product: 'Lockr',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:lockr',
+    config: 'lockr',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'Script guard/readiness/API-host rewrite may precede first display',
+  }),
+  row({
+    order: 10,
+    id: 'osano_consent',
+    product: 'Osano',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:osano',
+    config: 'osano',
+    provides: ['osano_consent.v1'],
+    consumes: ['runtime.v1'],
+    obligation: 'Initial USP/GPP/TCF mirror must precede consent-dependent auction work',
+  }),
+  row({
+    order: 11,
+    id: 'permutive_context',
+    product: 'Permutive',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:permutive',
+    config: 'permutive',
+    provides: ['permutive_context.v1'],
+    consumes: ['runtime.v1'],
+    obligation: 'Guard/readiness and initial normalized segments feed first auction context',
+  }),
+  row({
+    order: 12,
+    id: 'sourcepoint_consent',
+    product: 'Sourcepoint',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:sourcepoint',
+    config: 'sourcepoint',
+    provides: ['sourcepoint_consent.v1'],
+    consumes: ['runtime.v1'],
+    obligation: 'Initial GPP/localStorage mirror and optional SDK guard precede consent use',
+  }),
+  row({
+    order: 13,
+    id: 'prebid',
+    product: 'Prebid',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:prebid',
+    config: 'prebid',
+    provides: ['prebid.v1'],
+    consumes: ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'aps.v1?aps'],
+    obligation:
+      'External-artifact readiness, bidder aliases, user-ID/EIDs, publisher queue, initial auction, and TS bidder/PUC admission',
+  }),
+  row({
+    order: 14,
+    id: 'testlight',
+    product: 'Testlight',
+    phase: 'takeover',
+    trigger: null,
+    include: 'integration:testlight',
+    config: 'testlight',
+    provides: [],
+    consumes: ['runtime.v1'],
+    obligation: 'Preexisting callbacks must bridge before publisher code can replace/drain them',
+  }),
+  row({
+    order: 15,
+    id: 'diagnostics_presentation',
+    product: 'diagnostics',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'diagnostics_presentation',
+    config: null,
+    provides: [],
+    consumes: ['runtime.v1', 'trace.presentation.v1', 'gpt_diag.v1?gpt_diagnostics_active'],
+    obligation: 'DOM overlay, badges, formatting, clipboard/download interaction',
+  }),
+  row({
+    order: 16,
+    id: 'gpt_later',
+    product: 'GPT',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'integration:gpt',
+    config: 'gpt',
+    provides: [],
+    consumes: ['runtime.v1', 'slots.v1', 'auction.v1', 'render.v1', 'gpt.v1', 'trace.v1'],
+    obligation: 'Post-first-display refresh, SPA navigation, and later reconciliation only',
+  }),
+  row({
+    order: 17,
+    id: 'osano_lifecycle',
+    product: 'Osano',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'integration:osano',
+    config: 'osano',
+    provides: [],
+    consumes: ['runtime.v1', 'osano_consent.v1'],
+    obligation: 'Later retry/event/focus/visibility/clear maintenance',
+  }),
+  row({
+    order: 18,
+    id: 'permutive_lifecycle',
+    product: 'Permutive',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'integration:permutive',
+    config: 'permutive',
+    provides: [],
+    consumes: ['runtime.v1', 'permutive_context.v1'],
+    obligation: 'Later SDK/segment refresh maintenance',
+  }),
+  row({
+    order: 19,
+    id: 'prebid_later',
+    product: 'Prebid',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'prebid_and_gpt',
+    config: 'prebid',
+    provides: [],
+    consumes: ['runtime.v1', 'slots.v1', 'gpt.v1', 'prebid.v1'],
+    obligation: 'Synthetic refresh and GAM-path exclusion; never initial admission',
+  }),
+  row({
+    order: 20,
+    id: 'sourcepoint_lifecycle',
+    product: 'Sourcepoint',
+    phase: 'deferred',
+    trigger: 'first_display_or_idle',
+    include: 'integration:sourcepoint',
+    config: 'sourcepoint',
+    provides: [],
+    consumes: ['runtime.v1', 'sourcepoint_consent.v1'],
+    obligation: 'Later retry/visibility/focus/update/safe-clear maintenance',
+  }),
+]);
+
+const unconditionalCapability = (edge: string): string => edge.split('?', 1)[0]!;
+
+/** Validate ordering and capability invariants for a catalog or selected prefix. */
+export function validateReleaseCatalog(entries: readonly ReleaseCatalogEntry[]): void {
+  if (entries.length > 20) throw new TypeError('Release catalog exceeds manifest capacity');
+  const ids = new Set<string>();
+  const providers = new Map<string, number>([['runtime.v1', 0]]);
+  let sawDeferred = false;
+  let takeoverCount = 0;
+
+  for (const [index, entry] of entries.entries()) {
+    if (entry.order !== index + 1) throw new TypeError('Release catalog order is invalid');
+    const canonical = RELEASE_CATALOG[index];
+    if (
+      !canonical ||
+      entry.id !== canonical.id ||
+      entry.phase !== canonical.phase ||
+      entry.trigger !== canonical.trigger ||
+      entry.include !== canonical.include ||
+      entry.config !== canonical.config
+    ) {
+      throw new TypeError('Release catalog id, phase override, trigger, or predicate is invalid');
+    }
+    if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(entry.id) || ids.has(entry.id)) {
+      throw new TypeError('Release catalog id is invalid or duplicated');
+    }
+    ids.add(entry.id);
+    if (entry.phase === 'takeover') {
+      takeoverCount += 1;
+      if (takeoverCount > 14) throw new TypeError('Release catalog exceeds takeover capacity');
+      if (sawDeferred || entry.trigger !== null)
+        throw new TypeError('Takeover phase order is invalid');
+    } else {
+      sawDeferred = true;
+      if (entry.trigger !== 'first_display_or_idle') {
+        throw new TypeError('Deferred phase trigger is invalid');
+      }
+      if (entry.provides.length !== 0) throw new TypeError('Deferred provider is forbidden');
+    }
+    for (const capability of entry.provides) {
+      if (providers.has(capability)) throw new TypeError('Capability has multiple providers');
+      providers.set(capability, entry.order);
+    }
+  }
+
+  for (const entry of entries) {
+    for (const edge of entry.consumes) {
+      const conditionalParts = edge.split('?');
+      if (
+        conditionalParts.length > 2 ||
+        (conditionalParts.length === 2 &&
+          !['aps.v1?aps', 'gpt_diag.v1?gpt_diagnostics_active'].includes(edge))
+      ) {
+        throw new TypeError(`Invalid conditional capability edge: ${edge}`);
+      }
+      const capability = unconditionalCapability(edge);
+      const providerOrder = providers.get(capability);
+      if (providerOrder === undefined)
+        throw new TypeError(`Unknown capability edge: ${capability}`);
+      if (providerOrder >= entry.order) {
+        throw new TypeError('Capability provider order creates an order violation or cycle');
+      }
+    }
+  }
+}
+
+const KNOWN_INTEGRATIONS = new Set(
+  RELEASE_CATALOG.flatMap(({ include }) =>
+    include.startsWith('integration:') ? [include.slice('integration:'.length)] : []
+  )
+);
+
+/** Select immutable manifest rows from trusted server-owned page configuration. */
+export function selectReleaseCatalog(
+  selection: ReleaseCatalogSelection
+): readonly ReleaseCatalogEntry[] {
+  const integrations = new Set<string>();
+  for (const id of selection.integrations) {
+    if (!KNOWN_INTEGRATIONS.has(id)) throw new TypeError(`Unknown integration: ${id}`);
+    integrations.add(id);
+  }
+  const include = (predicate: ReleaseIncludePredicate): boolean => {
+    if (predicate === 'always') return true;
+    if (predicate === 'creative_guard') {
+      const creative = selection.creative;
+      return Boolean(creative?.enabled && (creative.clickGuard || creative.renderGuard));
+    }
+    if (predicate === 'gpt_diagnostics_active') return selection.gptDiagnosticsActive === true;
+    if (predicate === 'diagnostics_presentation') {
+      return selection.renderTraceOverlay === true || selection.gptDiagnosticsActive === true;
+    }
+    if (predicate === 'prebid_and_gpt') {
+      return integrations.has('prebid') && integrations.has('gpt');
+    }
+    return integrations.has(predicate.slice('integration:'.length));
+  };
+
+  return Object.freeze(RELEASE_CATALOG.filter((entry) => include(entry.include)));
+}
+
+validateReleaseCatalog(RELEASE_CATALOG);
+
+export const MAX_TAKEOVER_MODULES = RELEASE_CATALOG.filter(
+  ({ phase }) => phase === 'takeover'
+).length;
+export const MAX_MANIFEST_MODULES = RELEASE_CATALOG.length;
+export const MINIMAL_TAKEOVER_IDS = Object.freeze(['core', 'render_runtime'] as const);
+export const REFERENCE_TAKEOVER_IDS = Object.freeze([
+  'core',
+  'render_runtime',
+  'creative',
+  'gpt',
+  'prebid',
+  'datadome',
+] as const);
diff --git a/crates/trusted-server-js/lib/src/kernel/runtime.ts b/crates/trusted-server-js/lib/src/kernel/runtime.ts
new file mode 100644
index 000000000..ccd781e53
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/runtime.ts
@@ -0,0 +1,870 @@
+import { prepareQueue, publishQueue, type PublishedQueue } from '../core/queue';
+import { EMBEDDED_RELEASE_ID, EMBEDDED_RUNTIME_CATALOG } from '../core/release';
+import type { GptDiagnosticsApi, IntegrationConfigIdV1, TsjsBootV1 } from '../core/types';
+
+import {
+  buildFallbackBoot,
+  buildKernelBoot,
+  captureTrustedSelectedRuntimeSrc,
+  captureTrustedRuntimeSrc,
+  createFallbackFields,
+  publicLog,
+  type BootFailureReason,
+} from './fallback';
+import {
+  createIntegrationRegistry,
+  type CoreActivationContext,
+  type CorePreparationContext,
+  type IntegrationBindings,
+  type IntegrationCatalogEntry,
+  type IntegrationInstallCallbacks,
+  type IntegrationInstallResult,
+  type IntegrationRegistry,
+  type PreparedKernelTakeover,
+} from './integration_registry';
+import {
+  createDeferredPhaseLoader,
+  createProtectedFirstDisplayGate,
+  type DeferredPhaseLoader,
+  type PhaseScheduler,
+  type ProtectedFirstDisplayGate,
+} from './phase_loader';
+
+export type RuntimeState = 'unclaimed' | 'installing' | 'kernel' | 'failed' | 'fallback';
+
+type RuntimeTarget = object & { que?: unknown; boot?: unknown };
+
+const TERMINAL_FIELDS = Object.freeze([
+  'version',
+  'releaseId',
+  'boot',
+  'log',
+  'addAdUnits',
+  'requestAds',
+  'diagnostics',
+  '_registerIntegration',
+  '_internal',
+  'que',
+]);
+
+function retainedProductConfig(
+  boot: Readonly<TsjsBootV1>,
+  id: IntegrationConfigIdV1
+): TsjsBootV1['integrations']['entries'][number]['config'] | undefined {
+  for (const entry of boot.integrations.entries) {
+    if (entry.id === id) return entry.config;
+  }
+  return undefined;
+}
+
+function canClaimRuntimeTarget(target: RuntimeTarget): boolean {
+  try {
+    if (Object.getOwnPropertyDescriptor(target, '_registerIntegration')) return false;
+    for (const key of TERMINAL_FIELDS) {
+      const descriptor = Object.getOwnPropertyDescriptor(target, key);
+      if (descriptor && !descriptor.configurable) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function restoreOwnProperty(
+  target: RuntimeTarget,
+  key: string,
+  descriptor: PropertyDescriptor | undefined
+): void {
+  try {
+    if (descriptor) Object.defineProperty(target, key, descriptor);
+    else Reflect.deleteProperty(target, key);
+  } catch {
+    // A hostile publisher Proxy cannot escape startup or block the remaining cleanup.
+  }
+}
+
+export interface RuntimeKernel {
+  readonly addAdUnits: (units: unknown) => unknown;
+  readonly requestAds: (options?: unknown) => Promise<unknown>;
+  readonly diagnostics: Readonly<object>;
+}
+
+/** Frozen activation boundary for document-lifetime owners created after preparation. */
+export interface RuntimeOwnerActivationContext extends CoreActivationContext {
+  readonly boot: Readonly<object>;
+  readonly generation: object;
+}
+
+/** Frozen preparation boundary for inert document-lifetime owners. */
+export interface RuntimeOwnerPreparationContext extends CorePreparationContext {
+  readonly boot: Readonly<object>;
+  readonly generation: object;
+}
+
+export interface RuntimeOptions {
+  readonly target: RuntimeTarget;
+  /** Server assertion only; every decision and published value is bound to the build stamp. */
+  readonly releaseId: string;
+  readonly manifest: unknown;
+  readonly knownIntegrationIds: readonly string[];
+  readonly catalog?: readonly IntegrationCatalogEntry[];
+  readonly document?: Document;
+  readonly phaseScheduler?: PhaseScheduler;
+  readonly trustedScriptUrl?: (value: string) => unknown;
+  readonly currentScript?: () => HTMLScriptElement | null;
+  readonly boot?: unknown;
+  readonly now?: () => number;
+  readonly getBindings?: (id: string) => IntegrationBindings;
+  /** Resolve the complete frozen namespace after every diagnostics module activates. */
+  readonly getDiagnosticsForPublish?: () => Readonly<object>;
+  readonly prepareOwner?: (context: RuntimeOwnerPreparationContext) => void;
+  readonly activateOwner?: (context: RuntimeOwnerActivationContext) => void;
+  readonly activateCore?: (context: CoreActivationContext) => void;
+  /** Runs the prepared persistent activation and publication inside an old-owner handoff. */
+  readonly coordinateTakeover?: (prepared: PreparedKernelTakeover) => void;
+  /** Production monolith hook: install inline when its final registration arrives. */
+  readonly autoInstall?: boolean;
+  readonly onInstallComplete?: (result: IntegrationInstallResult) => void;
+  readonly kernel: RuntimeKernel;
+}
+
+export interface Runtime {
+  readonly state: RuntimeState;
+  readonly generation: object;
+  readonly start: () => boolean;
+  readonly registerIntegration: (registration: unknown) => boolean;
+  readonly install: () => Promise<IntegrationInstallResult>;
+  readonly protectFirstDisplayAttemptBatch: (
+    terminalLatches: readonly PromiseLike<unknown>[]
+  ) => boolean;
+  readonly dispose: () => void;
+}
+
+/** Closure-private kernel capability consumed only by release-bound providers. */
+export interface RuntimeCapabilityV1 {
+  readonly attachAuctionContextService: (
+    service: RuntimeAuctionContextService
+  ) => (() => void) | undefined;
+  readonly boot: () => Readonly<object> | undefined;
+  readonly document: Document | undefined;
+  readonly enqueue: (callback: () => void) => boolean;
+  readonly generation: object;
+  readonly protectFirstDisplayAttemptBatch: (
+    terminalLatches: readonly PromiseLike<unknown>[]
+  ) => boolean;
+  readonly registerAuctionContext: (
+    integrationId: string,
+    contributor: RuntimeAuctionContextContributor
+  ) => (() => void) | undefined;
+}
+
+export type RuntimeAuctionContextContributor = () => Readonly<Record<string, unknown>> | undefined;
+
+/** Sole runtime-private bridge between the render owner and context contributors. */
+export interface RuntimeAuctionContextService {
+  readonly register: (
+    integrationId: string,
+    contributor: RuntimeAuctionContextContributor
+  ) => (() => void) | undefined;
+}
+
+interface DirectCapabilityV1 {
+  readonly addAdUnits: RuntimeKernel['addAdUnits'];
+  readonly requestAds: RuntimeKernel['requestAds'];
+  readonly diagnostics: Readonly<object>;
+}
+
+interface GptDiagnosticsCapabilityV1 {
+  readonly api: GptDiagnosticsApi;
+  readonly attachPresentation: (controls: Readonly<Record<string, unknown>>) => () => void;
+}
+
+function snapshotGptDiagnosticsCapability(
+  candidate: unknown
+): GptDiagnosticsCapabilityV1 | undefined {
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    Array.isArray(candidate) ||
+    Object.getPrototypeOf(candidate) !== Object.prototype ||
+    !Object.isFrozen(candidate) ||
+    Reflect.ownKeys(candidate).sort().join(',') !== 'api,attachPresentation'
+  ) {
+    return undefined;
+  }
+  const fields = candidate as Readonly<Record<string, unknown>>;
+  const api = fields['api'];
+  if (
+    typeof fields['attachPresentation'] !== 'function' ||
+    typeof api !== 'object' ||
+    api === null ||
+    !Object.isFrozen(api) ||
+    Reflect.ownKeys(api).sort().join(',') !== 'export,hide,show,snapshot,subscribe' ||
+    !Reflect.ownKeys(api).every(
+      (key) => typeof (api as Record<PropertyKey, unknown>)[key] === 'function'
+    )
+  ) {
+    return undefined;
+  }
+  return candidate as GptDiagnosticsCapabilityV1;
+}
+
+function snapshotDirectCapability(candidate: unknown): DirectCapabilityV1 | undefined {
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    Array.isArray(candidate) ||
+    Object.getPrototypeOf(candidate) !== Object.prototype ||
+    !Object.isFrozen(candidate)
+  ) {
+    return undefined;
+  }
+  const keys = Reflect.ownKeys(candidate);
+  if (
+    keys.length !== 3 ||
+    !['addAdUnits', 'requestAds', 'diagnostics'].every((key) => keys.includes(key))
+  ) {
+    return undefined;
+  }
+  const values: Record<string, unknown> = {};
+  for (const key of keys) {
+    if (typeof key !== 'string') return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+    if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+    values[key] = descriptor.value;
+  }
+  if (
+    typeof values['addAdUnits'] !== 'function' ||
+    typeof values['requestAds'] !== 'function' ||
+    typeof values['diagnostics'] !== 'object' ||
+    values['diagnostics'] === null ||
+    !Object.isFrozen(values['diagnostics'])
+  ) {
+    return undefined;
+  }
+  return Object.freeze({
+    addAdUnits: values['addAdUnits'] as RuntimeKernel['addAdUnits'],
+    requestAds: values['requestAds'] as RuntimeKernel['requestAds'],
+    diagnostics: values['diagnostics'] as Readonly<object>,
+  });
+}
+
+class RuntimeOwner implements Runtime {
+  public readonly generation = Object.freeze({});
+  private readonly options: RuntimeOptions;
+  private readonly registrationHandshake = (candidate: unknown): boolean =>
+    this.registerIntegration(candidate);
+  private runtimeState: RuntimeState = 'unclaimed';
+  private registry: IntegrationRegistry | undefined;
+  private ingress: unknown[] | undefined;
+  private installPromise: Promise<IntegrationInstallResult> | undefined;
+  private kernelBoot: Readonly<TsjsBootV1> | undefined;
+  private fallbackBoot: Readonly<object> | undefined;
+  private selectedScript: HTMLScriptElement | undefined;
+  private trustedRuntimeSrc: string | undefined;
+  private phaseGate: ProtectedFirstDisplayGate | undefined;
+  private phaseLoader: DeferredPhaseLoader | undefined;
+  private auctionContextService: RuntimeAuctionContextService | undefined;
+  private directProvider: DirectCapabilityV1 | undefined;
+  private gptDiagnosticsProvider: GptDiagnosticsCapabilityV1 | undefined;
+
+  public constructor(options: RuntimeOptions) {
+    this.options = options;
+  }
+
+  public get state(): RuntimeState {
+    return this.runtimeState;
+  }
+
+  public start(): boolean {
+    if (this.runtimeState !== 'unclaimed') return false;
+    let queueDescriptor: PropertyDescriptor | undefined;
+    let bootDescriptor: PropertyDescriptor | undefined;
+    let registrationDescriptor: PropertyDescriptor | undefined;
+    let claimMutationStarted = false;
+    try {
+      if (!canClaimRuntimeTarget(this.options.target)) return false;
+      const runtimeDocument = this.runtimeDocument();
+      const Script = runtimeDocument?.defaultView?.HTMLScriptElement;
+      const currentScript = this.options.currentScript
+        ? this.options.currentScript()
+        : runtimeDocument?.currentScript;
+      this.selectedScript = Script && currentScript instanceof Script ? currentScript : undefined;
+      const takeoverMode = this.options.coordinateTakeover !== undefined;
+      const capturedRuntimeSrc =
+        runtimeDocument && this.selectedScript
+          ? takeoverMode
+            ? captureTrustedRuntimeSrc(runtimeDocument, this.selectedScript)
+            : captureTrustedSelectedRuntimeSrc(runtimeDocument, this.selectedScript)
+          : undefined;
+      if (!capturedRuntimeSrc) return false;
+      this.trustedRuntimeSrc = capturedRuntimeSrc;
+      const startedAtMs = (this.options.now ?? (() => performance.now()))();
+      queueDescriptor = Object.getOwnPropertyDescriptor(this.options.target, 'que');
+      bootDescriptor = Object.getOwnPropertyDescriptor(this.options.target, 'boot');
+      registrationDescriptor = Object.getOwnPropertyDescriptor(
+        this.options.target,
+        '_registerIntegration'
+      );
+      if (registrationDescriptor) return false;
+      claimMutationStarted = true;
+      if (
+        !bootDescriptor ||
+        !('value' in bootDescriptor) ||
+        typeof bootDescriptor.value !== 'object' ||
+        bootDescriptor.value === null
+      ) {
+        Object.defineProperty(this.options.target, 'boot', {
+          configurable: true,
+          enumerable: true,
+          value: {},
+          writable: true,
+        });
+      }
+      this.ingress = prepareQueue(this.options.target);
+      const bootCandidate = this.bootCandidate();
+      this.registry = createIntegrationRegistry({
+        // The manifest validator binds releaseId directly to the embedded build
+        // stamp, so a separate comparison would duplicate the stamp in minified
+        // core output without strengthening the ABI check.
+        manifest: this.options.manifest,
+        releaseId: EMBEDDED_RELEASE_ID,
+        knownIntegrationIds: this.options.knownIntegrationIds,
+        catalog:
+          this.options.catalog ??
+          Object.freeze(
+            this.options.knownIntegrationIds.map((id) =>
+              Object.freeze({
+                id,
+                phase: 'takeover' as const,
+                trigger: null,
+                config: EMBEDDED_RUNTIME_CATALOG.find((entry) => entry.id === id)?.config ?? null,
+                consumes: Object.freeze([]),
+                provides: Object.freeze([]),
+              })
+            )
+          ),
+        runtimeCapability: Object.freeze({
+          attachAuctionContextService: (service: RuntimeAuctionContextService) => {
+            if (
+              this.auctionContextService ||
+              typeof service !== 'object' ||
+              service === null ||
+              !Object.isFrozen(service) ||
+              typeof service.register !== 'function'
+            ) {
+              return undefined;
+            }
+            this.auctionContextService = service;
+            let released = false;
+            return () => {
+              if (released) return;
+              released = true;
+              if (this.auctionContextService === service) this.auctionContextService = undefined;
+            };
+          },
+          boot: () => this.kernelBoot,
+          document: runtimeDocument,
+          enqueue: (callback: () => void) => {
+            if (typeof callback !== 'function') return false;
+            try {
+              const queue = Object.getOwnPropertyDescriptor(this.options.target, 'que');
+              const queueValue = queue && 'value' in queue ? queue.value : undefined;
+              const push =
+                queueValue !== undefined && queueValue !== null
+                  ? Object.getOwnPropertyDescriptor(queueValue, 'push')
+                  : undefined;
+              if (!push || !('value' in push) || typeof push.value !== 'function') return false;
+              Reflect.apply(push.value, queueValue, [callback]);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          generation: this.generation,
+          protectFirstDisplayAttemptBatch: (terminalLatches: readonly PromiseLike<unknown>[]) =>
+            this.protectFirstDisplayAttemptBatch(terminalLatches),
+          registerAuctionContext: (integrationId, contributor) => {
+            try {
+              return this.auctionContextService?.register(integrationId, contributor);
+            } catch {
+              return undefined;
+            }
+          },
+        } satisfies RuntimeCapabilityV1),
+        onCapabilityStaged: (key, facade) => {
+          if (key === 'direct.v1') {
+            const direct = snapshotDirectCapability(facade);
+            if (!direct) throw new TypeError('direct.v1 capability is malformed');
+            if (this.directProvider) throw new TypeError('direct.v1 capability is already staged');
+            this.directProvider = direct;
+            return () => {
+              if (this.directProvider === direct) this.directProvider = undefined;
+            };
+          }
+          if (key === 'gpt_diag.v1') {
+            const diagnostics = snapshotGptDiagnosticsCapability(facade);
+            if (!diagnostics) throw new TypeError('gpt_diag.v1 capability is malformed');
+            if (this.gptDiagnosticsProvider) {
+              throw new TypeError('gpt_diag.v1 capability is already staged');
+            }
+            this.gptDiagnosticsProvider = diagnostics;
+            return () => {
+              if (this.gptDiagnosticsProvider === diagnostics) {
+                this.gptDiagnosticsProvider = undefined;
+              }
+            };
+          }
+          return undefined;
+        },
+        ...(this.selectedScript && runtimeDocument
+          ? {
+              takeoverScript: this.selectedScript,
+              takeoverScriptId: takeoverMode
+                ? ('trustedserver-js-runtime' as const)
+                : ('trustedserver-js' as const),
+              document: runtimeDocument,
+              ...(this.options.currentScript ? { currentScript: this.options.currentScript } : {}),
+            }
+          : {}),
+        startedAtMs,
+        ...(this.options.now ? { now: this.options.now } : {}),
+        getBindings: (id) => this.integrationBindings(id),
+        isCurrentOwner: () => this.ownsRegistrationHandshake(),
+        onTakeoverRegistrationsReady: () => {
+          if (this.options.autoInstall && !this.installPromise) void this.install();
+        },
+      });
+      this.fallbackBoot = buildFallbackBoot(EMBEDDED_RELEASE_ID, this.trustedRuntimeSrc);
+      if (!this.fallbackBoot) throw new Error('Trusted runtime artifact source is unavailable');
+      if (this.registry.manifest) {
+        this.kernelBoot = buildKernelBoot(
+          EMBEDDED_RELEASE_ID,
+          this.options.manifest as TsjsBootV1['manifest'],
+          bootCandidate
+        );
+      }
+      Object.defineProperty(this.options.target, '_registerIntegration', {
+        configurable: true,
+        enumerable: false,
+        value: this.registrationHandshake,
+        writable: false,
+      });
+      if (!this.ownsRegistrationHandshake()) {
+        throw new Error('Runtime owner handshake changed during claim');
+      }
+      this.runtimeState = 'installing';
+      if (
+        this.options.autoInstall &&
+        !this.registry.manifest?.integrations.some((entry) => entry.phase === 'takeover')
+      ) {
+        void this.install();
+      }
+      return true;
+    } catch {
+      try {
+        this.registry?.dispose();
+      } catch {
+        // Disposal is best-effort while unwinding a failed claim.
+      }
+      if (claimMutationStarted) {
+        restoreOwnProperty(this.options.target, 'que', queueDescriptor);
+        restoreOwnProperty(this.options.target, 'boot', bootDescriptor);
+        restoreOwnProperty(this.options.target, '_registerIntegration', registrationDescriptor);
+      }
+      this.runtimeState = 'unclaimed';
+      this.registry = undefined;
+      this.ingress = undefined;
+      this.kernelBoot = undefined;
+      this.fallbackBoot = undefined;
+      this.selectedScript = undefined;
+      this.trustedRuntimeSrc = undefined;
+      return false;
+    }
+  }
+
+  public registerIntegration(registration: unknown): boolean {
+    if (this.runtimeState === 'installing') {
+      if (!this.ownsRegistrationHandshake()) return false;
+      return this.registry?.register(registration) ?? false;
+    }
+    if (this.runtimeState === 'kernel' && this.ownsTerminalRegistrationHandshake()) {
+      return this.phaseLoader?.register(registration) ?? false;
+    }
+    return false;
+  }
+
+  public install(): Promise<IntegrationInstallResult> {
+    if (this.installPromise) return this.installPromise;
+    if (!this.registry || !this.ingress || this.runtimeState !== 'installing') {
+      return Promise.resolve(Object.freeze({ state: 'fallback', reason: 'bundle_partial' }));
+    }
+    const notifyInstallComplete = (result: IntegrationInstallResult): void => {
+      try {
+        this.options.onInstallComplete?.(result);
+      } catch {
+        // Completion observation cannot change the already committed terminal state.
+      }
+    };
+    if (!this.kernelBoot) {
+      this.registry.dispose();
+      const result = Object.freeze({ state: 'fallback' as const, reason: 'abi_mismatch' as const });
+      this.runtimeState = 'failed';
+      if (!this.options.coordinateTakeover) this.commitFallback(result.reason);
+      notifyInstallComplete(result);
+      this.installPromise = Promise.resolve(result);
+      return this.installPromise;
+    }
+    let published: PublishedQueue | undefined;
+    const callbacks: IntegrationInstallCallbacks = {
+      prepareCore: (context) => {
+        if (!this.ownsInstallingPreparation(context)) {
+          throw new Error('Runtime owner generation changed');
+        }
+        const ownerContext: RuntimeOwnerPreparationContext = Object.freeze({
+          boot: this.kernelBoot as Readonly<object>,
+          generation: this.generation,
+          onDispose: context.onDispose,
+          signal: context.signal,
+        });
+        this.invokeSynchronousActivation(this.options.prepareOwner, ownerContext);
+        if (!this.ownsInstallingPreparation(context)) {
+          throw new Error('Runtime owner generation changed');
+        }
+      },
+      activateCore: (context) => {
+        if (!this.ownsInstallingActivation(context)) {
+          throw new Error('Runtime owner generation changed');
+        }
+        const ownerContext: RuntimeOwnerActivationContext = Object.freeze({
+          boot: this.kernelBoot as Readonly<object>,
+          generation: this.generation,
+          onDispose: context.onDispose,
+          signal: context.signal,
+        });
+        this.invokeSynchronousActivation(this.options.activateOwner, ownerContext);
+        if (!this.ownsInstallingActivation(context)) {
+          throw new Error('Runtime owner generation changed');
+        }
+        this.invokeSynchronousActivation(this.options.activateCore, context);
+        if (!this.ownsInstallingActivation(context)) {
+          throw new Error('Runtime owner generation changed');
+        }
+      },
+      publish: () => {
+        if (!this.ownsRegistrationHandshake()) {
+          throw new Error('Runtime owner generation changed');
+        }
+        published = publishQueue(
+          this.options.target,
+          this.ingress as unknown[],
+          this.kernelFields()
+        );
+        this.startDeferredPhase();
+      },
+      drainPreload: () => published?.drain(),
+      ...(this.options.coordinateTakeover
+        ? { coordinateTakeover: this.options.coordinateTakeover }
+        : {}),
+    };
+    let resolveInstall: ((result: IntegrationInstallResult) => void) | undefined;
+    this.installPromise = new Promise<IntegrationInstallResult>((resolve) => {
+      resolveInstall = resolve;
+    });
+    const settle = (result: IntegrationInstallResult): void => {
+      if (result.state === 'kernel') {
+        this.runtimeState = 'kernel';
+      } else {
+        this.runtimeState = 'failed';
+        if (!this.options.coordinateTakeover) this.commitFallback(result.reason);
+      }
+      notifyInstallComplete(result);
+      resolveInstall?.(result);
+    };
+    if (!this.options.coordinateTakeover) {
+      settle(this.registry.installSync(callbacks));
+      return this.installPromise;
+    }
+    void this.registry.install(callbacks).then(settle, () => {
+      settle(Object.freeze({ state: 'fallback', reason: 'bundle_partial' }));
+    });
+    return this.installPromise;
+  }
+
+  public dispose(): void {
+    this.phaseLoader?.dispose();
+    this.phaseGate?.dispose();
+    this.registry?.dispose();
+  }
+
+  public protectFirstDisplayAttemptBatch(
+    terminalLatches: readonly PromiseLike<unknown>[]
+  ): boolean {
+    return this.phaseGate?.protectAttemptBatch(terminalLatches) ?? false;
+  }
+
+  private kernelFields(): Readonly<Record<string, unknown>> {
+    const direct = this.directProvider;
+    const requiresDirect = this.options.catalog?.some(
+      ({ id, provides }) => id === 'render_runtime' && provides.includes('direct.v1')
+    );
+    if (requiresDirect && !direct) {
+      throw new Error('Mandatory direct.v1 provider is unavailable');
+    }
+    const baseDiagnostics =
+      direct?.diagnostics ??
+      this.options.getDiagnosticsForPublish?.() ??
+      this.options.kernel.diagnostics;
+    const addAdUnits = direct?.addAdUnits ?? this.options.kernel.addAdUnits;
+    const requestAds = direct?.requestAds ?? this.options.kernel.requestAds;
+    if (
+      (typeof baseDiagnostics !== 'object' && typeof baseDiagnostics !== 'function') ||
+      baseDiagnostics === null ||
+      !Object.isFrozen(baseDiagnostics)
+    ) {
+      throw new Error('Published diagnostics namespace must be frozen');
+    }
+    let diagnostics = baseDiagnostics;
+    const gptDiagnostics = this.gptDiagnosticsProvider?.api;
+    if (gptDiagnostics) {
+      const descriptors = Object.getOwnPropertyDescriptors(baseDiagnostics);
+      if (
+        Object.getOwnPropertySymbols(baseDiagnostics).length !== 0 ||
+        Object.prototype.hasOwnProperty.call(descriptors, 'gpt') ||
+        !Object.values(descriptors).every(
+          (descriptor) => descriptor.enumerable && 'value' in descriptor
+        )
+      ) {
+        throw new Error('Published diagnostics namespace is malformed');
+      }
+      diagnostics = Object.freeze(
+        Object.defineProperties(
+          {},
+          {
+            ...descriptors,
+            gpt: { enumerable: true, value: gptDiagnostics },
+          }
+        )
+      );
+    }
+    const fields: Record<string, unknown> = {};
+    Object.defineProperties(fields, {
+      version: { enumerable: true, value: '1.0.0' },
+      releaseId: { enumerable: true, value: EMBEDDED_RELEASE_ID },
+      boot: {
+        enumerable: true,
+        value: this.kernelBoot,
+      },
+      log: { enumerable: true, value: publicLog },
+      _registerIntegration: { enumerable: true, value: this.registrationHandshake },
+      addAdUnits: { enumerable: true, value: addAdUnits },
+      requestAds: { enumerable: true, value: requestAds },
+      diagnostics: { enumerable: true, value: diagnostics },
+      _internal: {
+        enumerable: false,
+        value: Object.freeze({ state: 'kernel', releaseId: EMBEDDED_RELEASE_ID }),
+      },
+    });
+    return Object.freeze(fields);
+  }
+
+  private commitFallback(reason: BootFailureReason): void {
+    if (!this.ownsRegistrationHandshake() || !this.ingress || !this.trustedRuntimeSrc) return;
+    const fields = createFallbackFields({
+      releaseId: EMBEDDED_RELEASE_ID,
+      reason,
+      trustedRuntimeSrc: this.trustedRuntimeSrc,
+    });
+    if (!fields) return;
+    const published = publishQueue(this.options.target, this.ingress, fields);
+    this.runtimeState = 'fallback';
+    published.drain();
+  }
+
+  private ownsRegistrationHandshake(): boolean {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        this.options.target,
+        '_registerIntegration'
+      );
+      return (
+        descriptor !== undefined &&
+        'value' in descriptor &&
+        descriptor.value === this.registrationHandshake &&
+        descriptor.configurable === true &&
+        descriptor.enumerable === false &&
+        descriptor.writable === false
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  private ownsTerminalRegistrationHandshake(): boolean {
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        this.options.target,
+        '_registerIntegration'
+      );
+      return (
+        descriptor !== undefined &&
+        'value' in descriptor &&
+        descriptor.value === this.registrationHandshake &&
+        descriptor.configurable === false &&
+        descriptor.enumerable === true &&
+        descriptor.writable === false
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  private runtimeDocument(): Document | undefined {
+    if (this.options.document) return this.options.document;
+    return typeof document === 'undefined' ? undefined : document;
+  }
+
+  private startDeferredPhase(): void {
+    const runtimeDocument = this.runtimeDocument();
+    const manifest = this.registry?.manifest;
+    if (!runtimeDocument || !manifest) return;
+    const gate = createProtectedFirstDisplayGate({
+      document: runtimeDocument,
+      ...(this.options.coordinateTakeover ? { paintAlreadyRecorded: true } : {}),
+      ...(this.options.phaseScheduler ? { scheduler: this.options.phaseScheduler } : {}),
+      markPaint: () => {
+        try {
+          runtimeDocument.defaultView?.performance.mark('tsjs:first-display-paint');
+        } catch {
+          // A publisher performance shim cannot block the protected phase gate.
+        }
+      },
+    });
+    this.phaseGate = gate;
+    const runtimeScript = this.selectedScript;
+    if (runtimeScript) {
+      this.phaseLoader = createDeferredPhaseLoader({
+        runtimeScript,
+        ...(this.options.currentScript ? { currentScript: this.options.currentScript } : {}),
+        document: runtimeDocument,
+        gate: gate.ready,
+        manifest,
+        prepare: (registration, owner) =>
+          this.registry?.prepareDeferred(registration, owner) ?? {
+            activate: () => undefined,
+          },
+        releaseId: EMBEDDED_RELEASE_ID,
+        ...(this.options.trustedScriptUrl
+          ? { trustedScriptUrl: this.options.trustedScriptUrl }
+          : {}),
+        ...(this.options.phaseScheduler
+          ? {
+              scheduler: {
+                clearTimeout: this.options.phaseScheduler.clearTimeout,
+                setTimeout: this.options.phaseScheduler.setTimeout,
+              },
+            }
+          : {}),
+      });
+    }
+    gate.commit();
+  }
+
+  private ownsInstallingActivation(context: CoreActivationContext): boolean {
+    return (
+      this.runtimeState === 'installing' &&
+      !context.signal.aborted &&
+      this.registry?.state === 'activating' &&
+      this.ownsRegistrationHandshake()
+    );
+  }
+
+  private ownsInstallingPreparation(context: CorePreparationContext): boolean {
+    return (
+      this.runtimeState === 'installing' &&
+      !context.signal.aborted &&
+      this.registry?.state === 'preparing' &&
+      this.ownsRegistrationHandshake()
+    );
+  }
+
+  private bootCandidate(): unknown {
+    return this.options.boot;
+  }
+
+  private integrationBindings(id: string): IntegrationBindings {
+    const fallback = Object.freeze({ config: undefined, interfaces: Object.freeze({}) });
+    const bindings = this.options.getBindings?.(id) ?? fallback;
+    const source = this.options.catalog?.find((entry) => entry.id === id)?.config;
+    if (source === undefined) {
+      if (id !== 'creative' && id !== 'gpt_diagnostics') return bindings;
+    } else if (source === null) {
+      return Object.freeze({ config: undefined, interfaces: bindings.interfaces });
+    }
+    const boot = this.kernelBoot;
+    if (!boot) return bindings;
+    try {
+      if (source === 'creative' || (source === undefined && id === 'creative')) {
+        const creative = Object.getOwnPropertyDescriptor(boot, 'creative');
+        return creative && 'value' in creative
+          ? Object.freeze({ config: creative.value, interfaces: bindings.interfaces })
+          : bindings;
+      }
+      if (source && source !== 'diagnostics') {
+        const integrations = Object.getOwnPropertyDescriptor(boot, 'integrations');
+        const config =
+          integrations && 'value' in integrations
+            ? retainedProductConfig(boot, source as IntegrationConfigIdV1)
+            : undefined;
+        return Object.freeze({ config, interfaces: bindings.interfaces });
+      }
+      const diagnostics = Object.getOwnPropertyDescriptor(boot, 'diagnostics');
+      const gpt =
+        diagnostics && 'value' in diagnostics
+          ? Object.getOwnPropertyDescriptor(diagnostics.value, 'gpt')
+          : undefined;
+      return gpt && 'value' in gpt
+        ? Object.freeze({ config: gpt.value, interfaces: bindings.interfaces })
+        : bindings;
+    } catch {
+      return bindings;
+    }
+  }
+
+  private invokeSynchronousActivation<Context>(
+    activation: ((context: Context) => void) | undefined,
+    context: Context
+  ): void {
+    if (!activation) return;
+    const returned = activation(context) as unknown;
+    if (
+      (typeof returned === 'object' || typeof returned === 'function') &&
+      returned !== null &&
+      typeof (returned as { then?: unknown }).then === 'function'
+    ) {
+      try {
+        void Promise.resolve(returned).catch(() => undefined);
+      } catch {
+        // Rejection observation cannot make an asynchronous activation valid.
+      }
+      throw new TypeError('Runtime activation must be synchronous');
+    }
+  }
+}
+
+/** Create one dormant runtime owner; `start` performs the test-only claim. */
+export function createRuntime(options: RuntimeOptions): Runtime {
+  const owner = new RuntimeOwner(options);
+  return Object.freeze({
+    get state() {
+      return owner.state;
+    },
+    generation: owner.generation,
+    start: () => owner.start(),
+    registerIntegration: (registration: unknown) => owner.registerIntegration(registration),
+    install: () => owner.install(),
+    protectFirstDisplayAttemptBatch: (terminalLatches: readonly PromiseLike<unknown>[]) =>
+      owner.protectFirstDisplayAttemptBatch(terminalLatches),
+    dispose: () => owner.dispose(),
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/kernel/sessions.ts b/crates/trusted-server-js/lib/src/kernel/sessions.ts
new file mode 100644
index 000000000..50f7cbba6
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/kernel/sessions.ts
@@ -0,0 +1,770 @@
+import { DisposableStack, type DisposeCallback, type DisposalErrorHandler } from './disposable';
+import type { IdentityGenerationResult, NavigationIdentityIssuer } from './identity';
+
+const objectFreezeIntrinsic = Object.freeze;
+
+function freezeValue<Value extends object>(value: Value): Readonly<Value> {
+  return Reflect.apply(objectFreezeIntrinsic, Object, [value]) as Readonly<Value>;
+}
+
+/** Immutable price authority transferred from winner admission into one attempt. */
+export interface WinnerContext {
+  readonly selectedCpm: number;
+}
+
+/** Reversible admission of one exact winner context into an attempt. */
+export interface WinnerContextAdmission {
+  readonly commit: () => boolean;
+  readonly rollback: () => boolean;
+}
+
+/** Factory that obtains one fresh eight-byte identity prefix per navigation. */
+export type NavigationIdentityIssuerFactory =
+  () => IdentityGenerationResult<NavigationIdentityIssuer>;
+
+/** Immutable interfaces injected by the composition root for the runtime lifetime. */
+export type RuntimeInterfaces = Readonly<Record<string, unknown>>;
+
+/** Options used to construct one document-lifetime runtime session. */
+export interface RuntimeSessionOptions {
+  readonly createIdentityIssuer: NavigationIdentityIssuerFactory;
+  readonly interfaces?: RuntimeInterfaces;
+  readonly onNavigationDispose?: (navigationGeneration: object) => void;
+  readonly onDisposalError?: DisposalErrorHandler;
+}
+
+/** Result of creating the initial navigation or replacing the current navigation. */
+export type NavigationSessionResult =
+  | Readonly<{ ok: true; value: NavigationSession }>
+  | Readonly<{
+      ok: false;
+      reason:
+        | 'identity_generation_failed'
+        | 'invalid_projection'
+        | 'navigation_already_started'
+        | 'navigation_transition_in_progress'
+        | 'runtime_disposed';
+    }>;
+
+/** Result of creating one render attempt. */
+export type RenderAttemptResult =
+  | Readonly<{ ok: true; value: RenderAttemptScope }>
+  | Readonly<{
+      ok: false;
+      reason: 'identity_generation_failed' | 'attempt_exists' | 'stale_owner';
+    }>;
+
+/** Frozen runtime inventory intended only for ownership tests. */
+export interface RuntimeInventorySnapshot {
+  readonly activeDisposers: number;
+  readonly currentNavigationGeneration: object | undefined;
+  readonly disposed: boolean;
+  readonly disposedByKind: Readonly<Record<string, number>>;
+  readonly disposedNavigations: number;
+  readonly navigationCount: number;
+}
+
+/** Frozen navigation inventory intended only for ownership tests. */
+export interface NavigationInventorySnapshot {
+  readonly activeDisposers: number;
+  readonly aliases: number;
+  readonly attempts: number;
+  readonly batches: number;
+  readonly disposed: boolean;
+  readonly disposedByKind: Readonly<Record<string, number>>;
+  readonly hasAuctionProjection: boolean;
+  readonly intents: number;
+  readonly retainedAttemptScopes: number;
+  readonly retainedBatchScopes: number;
+  readonly targetingOwners: number;
+}
+
+/** A document-lifetime owner that atomically replaces route-local sessions. */
+export interface RuntimeSession {
+  readonly generation: object;
+  readonly interfaces: RuntimeInterfaces;
+  readonly disposed: boolean;
+  readonly currentNavigation: NavigationSession | undefined;
+  readonly startInitialNavigation: (projection?: Readonly<object>) => NavigationSessionResult;
+  readonly replaceNavigation: () => NavigationSessionResult;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: DisposeCallback) => void;
+  readonly dispose: () => void;
+  readonly snapshotInventoryForTest: () => RuntimeInventorySnapshot;
+}
+
+/** One route-local owner for aliases, intent, targeting, batches, attempts, and projection. */
+export interface NavigationSession {
+  readonly generation: object;
+  readonly interfaces: RuntimeInterfaces;
+  readonly disposed: boolean;
+  readonly currentAuctionProjection: Readonly<object> | undefined;
+  readonly signal: AbortSignal;
+  readonly capture: <Arguments extends readonly unknown[]>(
+    callback: (...arguments_: Arguments) => unknown
+  ) => (...arguments_: Arguments) => boolean;
+  readonly adoptNextAttemptOrdinal: (nextOrdinal: number) => boolean;
+  readonly adoptFirstDisplayIdentityState: (prefix: string, nextOrdinal: number) => boolean;
+  readonly claimAlias: (alias: string) => boolean;
+  readonly claimIntent: (slot: string) => boolean;
+  readonly claimTargeting: (slot: string) => boolean;
+  readonly createAuctionBatch: (key: string) => AuctionBatchScope | undefined;
+  readonly installAuctionProjection: (projection: Readonly<object>) => boolean;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: DisposeCallback) => void;
+  readonly dispose: () => void;
+  readonly snapshotInventoryForTest: () => NavigationInventorySnapshot;
+}
+
+/** Navigation-owned scope for one shared auction request and its child attempts. */
+export interface AuctionBatchScope {
+  readonly generation: object;
+  readonly interfaces: RuntimeInterfaces;
+  readonly disposed: boolean;
+  readonly signal: AbortSignal;
+  readonly createRenderAttempt: (slot: string) => RenderAttemptResult;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: DisposeCallback) => void;
+  readonly dispose: () => void;
+}
+
+/** Attempt-owned scope for timers, listeners, ports, and one terminal lifecycle. */
+export interface RenderAttemptScope {
+  readonly generation: object;
+  readonly navigationGeneration: object;
+  readonly interfaces: RuntimeInterfaces;
+  readonly id: string;
+  readonly slot: string;
+  readonly winnerContext: WinnerContext | undefined;
+  readonly disposed: boolean;
+  readonly signal: AbortSignal;
+  readonly capture: <Arguments extends readonly unknown[]>(
+    callback: (...arguments_: Arguments) => unknown
+  ) => (...arguments_: Arguments) => boolean;
+  readonly isCurrent: () => boolean;
+  readonly prepareWinnerContext: (context: WinnerContext) => WinnerContextAdmission | undefined;
+  readonly onDispose: (kind: string, callback: DisposeCallback) => void;
+  readonly dispose: () => void;
+}
+
+const EMPTY_INTERFACES = Object.freeze({});
+
+function frozenRecord(source: ReadonlyMap<string, number>): Readonly<Record<string, number>> {
+  const output: Record<string, number> = {};
+  for (const [key, value] of source) output[key] = value;
+  return Object.freeze(output);
+}
+
+function recursivelyFrozen(value: unknown, visited = new Set<object>()): boolean {
+  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) return true;
+  if (visited.has(value)) return true;
+  visited.add(value);
+  try {
+    if (!Object.isFrozen(value)) return false;
+    for (const key of Reflect.ownKeys(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        !descriptor ||
+        !('value' in descriptor) ||
+        !recursivelyFrozen(descriptor.value, visited)
+      ) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class OwnerScope {
+  public readonly generation = Object.freeze({});
+  private readonly disposables: DisposableStack;
+  private readonly activeByKind = new Map<string, number>();
+  private readonly disposedByKind = new Map<string, number>();
+
+  public constructor(onDisposalError?: DisposalErrorHandler) {
+    this.disposables = new DisposableStack(onDisposalError);
+  }
+
+  public get disposed(): boolean {
+    return this.disposables.disposed;
+  }
+
+  public get signal(): AbortSignal {
+    return this.disposables.signal;
+  }
+
+  public onDispose(kind: string, callback: DisposeCallback): void {
+    if (typeof kind !== 'string' || kind.length === 0)
+      throw new TypeError('Disposer kind required');
+    if (typeof callback !== 'function') throw new TypeError('A disposer must be a function');
+    this.activeByKind.set(kind, (this.activeByKind.get(kind) ?? 0) + 1);
+    this.disposables.onDispose(() => {
+      const remaining = (this.activeByKind.get(kind) ?? 1) - 1;
+      if (remaining === 0) this.activeByKind.delete(kind);
+      else this.activeByKind.set(kind, remaining);
+      this.disposedByKind.set(kind, (this.disposedByKind.get(kind) ?? 0) + 1);
+      callback();
+    });
+  }
+
+  public dispose(): void {
+    this.disposables.dispose();
+  }
+
+  public activeDisposerCount(): number {
+    let total = 0;
+    for (const count of this.activeByKind.values()) total += count;
+    return total;
+  }
+
+  public disposedInventory(): Readonly<Record<string, number>> {
+    return frozenRecord(this.disposedByKind);
+  }
+}
+
+class RenderAttemptOwner implements RenderAttemptScope {
+  private readonly scope: OwnerScope;
+  private acceptedWinnerContext: WinnerContext | undefined;
+  private pendingWinnerAdmission: object | undefined;
+
+  public constructor(
+    public readonly id: string,
+    public readonly slot: string,
+    public readonly navigationGeneration: object,
+    public readonly interfaces: RuntimeInterfaces,
+    private readonly ownerIsCurrent: () => boolean,
+    onDisposalError?: DisposalErrorHandler
+  ) {
+    this.scope = new OwnerScope(onDisposalError);
+  }
+
+  public get generation(): object {
+    return this.scope.generation;
+  }
+
+  public get disposed(): boolean {
+    return this.scope.disposed;
+  }
+
+  public get signal(): AbortSignal {
+    return this.scope.signal;
+  }
+
+  public get winnerContext(): WinnerContext | undefined {
+    return this.acceptedWinnerContext;
+  }
+
+  public prepareWinnerContext(context: WinnerContext): WinnerContextAdmission | undefined {
+    if (!this.isCurrent() || this.pendingWinnerAdmission !== undefined) return undefined;
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(context, 'selectedCpm');
+      if (
+        !Object.isFrozen(context) ||
+        Object.getPrototypeOf(context) !== Object.prototype ||
+        Object.getOwnPropertyNames(context).length !== 1 ||
+        Object.getOwnPropertySymbols(context).length !== 0 ||
+        !descriptor ||
+        !descriptor.enumerable ||
+        !('value' in descriptor) ||
+        typeof descriptor.value !== 'number' ||
+        !Number.isFinite(descriptor.value) ||
+        descriptor.value < 0
+      ) {
+        return undefined;
+      }
+      const previous = this.acceptedWinnerContext;
+      if (previous !== undefined && previous !== context) return undefined;
+      const token = freezeValue({});
+      this.pendingWinnerAdmission = token;
+      let committed = false;
+      return freezeValue({
+        commit: (): boolean => {
+          if (committed) return this.acceptedWinnerContext === context;
+          if (
+            this.pendingWinnerAdmission !== token ||
+            !this.isCurrent() ||
+            this.acceptedWinnerContext !== previous
+          ) {
+            return false;
+          }
+          this.acceptedWinnerContext = context;
+          this.pendingWinnerAdmission = undefined;
+          committed = true;
+          return true;
+        },
+        rollback: (): boolean => {
+          if (this.pendingWinnerAdmission === token) this.pendingWinnerAdmission = undefined;
+          if (committed && previous === undefined && this.acceptedWinnerContext === context) {
+            this.acceptedWinnerContext = undefined;
+            committed = false;
+            return true;
+          }
+          committed = false;
+          return this.acceptedWinnerContext === previous;
+        },
+      });
+    } catch {
+      return undefined;
+    }
+  }
+
+  public capture<Arguments extends readonly unknown[]>(
+    callback: (...arguments_: Arguments) => unknown
+  ): (...arguments_: Arguments) => boolean {
+    return (...arguments_: Arguments): boolean => {
+      if (!this.isCurrent()) return false;
+      callback(...arguments_);
+      return true;
+    };
+  }
+
+  public isCurrent(): boolean {
+    return !this.disposed && this.ownerIsCurrent();
+  }
+
+  public onDispose(kind: string, callback: DisposeCallback): void {
+    this.scope.onDispose(kind, callback);
+  }
+
+  public dispose(): void {
+    this.pendingWinnerAdmission = undefined;
+    this.scope.dispose();
+  }
+}
+
+class AuctionBatchOwner implements AuctionBatchScope {
+  private readonly scope: OwnerScope;
+  private readonly attempts = new Map<string, RenderAttemptOwner>();
+  private readonly attemptOrder: RenderAttemptOwner[] = [];
+  private isDisposing = false;
+
+  public constructor(
+    private readonly issuer: NavigationIdentityIssuer,
+    private readonly navigationGeneration: object,
+    public readonly interfaces: RuntimeInterfaces,
+    private readonly ownerIsCurrent: () => boolean,
+    private readonly attemptExists: (slot: string) => boolean,
+    private readonly registerAttempt: (slot: string, attempt: RenderAttemptOwner) => boolean,
+    private readonly releaseAttempt: (slot: string, attempt: RenderAttemptOwner) => void,
+    private readonly onDisposalError?: DisposalErrorHandler
+  ) {
+    this.scope = new OwnerScope(onDisposalError);
+  }
+
+  public get generation(): object {
+    return this.scope.generation;
+  }
+
+  public get disposed(): boolean {
+    return this.isDisposing || this.scope.disposed;
+  }
+
+  public get signal(): AbortSignal {
+    return this.scope.signal;
+  }
+
+  public createRenderAttempt(slot: string): RenderAttemptResult {
+    if (!this.isCurrent()) return Object.freeze({ ok: false, reason: 'stale_owner' });
+    if (this.attempts.has(slot) || this.attemptExists(slot)) {
+      return Object.freeze({ ok: false, reason: 'attempt_exists' });
+    }
+    const identity = this.issuer.mintAttemptId();
+    if (!identity.ok) return identity;
+    const attemptReference: { current?: RenderAttemptOwner } = {};
+    const attempt = new RenderAttemptOwner(
+      identity.value,
+      slot,
+      this.navigationGeneration,
+      this.interfaces,
+      (): boolean => this.isCurrent() && this.attempts.get(slot) === attemptReference.current,
+      this.onDisposalError
+    );
+    attemptReference.current = attempt;
+    if (!this.registerAttempt(slot, attempt)) {
+      attempt.dispose();
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+    this.attempts.set(slot, attempt);
+    this.attemptOrder.push(attempt);
+    attempt.onDispose('attempt-index', () => {
+      this.attempts.delete(slot);
+      this.releaseAttempt(slot, attempt);
+      const orderIndex = this.attemptOrder.indexOf(attempt);
+      if (orderIndex >= 0) this.attemptOrder.splice(orderIndex, 1);
+    });
+    return Object.freeze({ ok: true, value: attempt });
+  }
+
+  public isCurrent(): boolean {
+    return !this.disposed && this.ownerIsCurrent();
+  }
+
+  public retainedAttemptCount(): number {
+    return this.attemptOrder.length;
+  }
+
+  public onDispose(kind: string, callback: DisposeCallback): void {
+    this.scope.onDispose(kind, callback);
+  }
+
+  public dispose(): void {
+    if (this.disposed) return;
+    this.isDisposing = true;
+    for (let index = this.attemptOrder.length - 1; index >= 0; index -= 1) {
+      this.attemptOrder[index]?.dispose();
+    }
+    this.attemptOrder.length = 0;
+    this.attempts.clear();
+    this.scope.dispose();
+  }
+}
+
+class NavigationSessionOwner implements NavigationSession {
+  private readonly scope: OwnerScope;
+  private readonly aliases = new Set<string>();
+  private readonly intents = new Set<string>();
+  private readonly targetingOwners = new Set<string>();
+  private readonly batches = new Map<string, AuctionBatchOwner>();
+  private readonly attempts = new Map<string, RenderAttemptOwner>();
+  private readonly batchOrder: AuctionBatchOwner[] = [];
+  private issuer: NavigationIdentityIssuer | undefined;
+  private ownerIsCurrentCallback: (() => boolean) | undefined;
+  private onDisposingCallback: (() => DisposeCallback | undefined) | undefined;
+  private onDisposedCallback: (() => void) | undefined;
+  private projection: Readonly<object> | undefined;
+  private isDisposing = false;
+
+  public constructor(
+    issuer: NavigationIdentityIssuer,
+    initialProjection: Readonly<object> | undefined,
+    public readonly interfaces: RuntimeInterfaces,
+    ownerIsCurrent: () => boolean,
+    onDisposing: () => DisposeCallback | undefined,
+    onDisposed: () => void,
+    private readonly onDisposalError?: DisposalErrorHandler
+  ) {
+    this.scope = new OwnerScope(onDisposalError);
+    this.issuer = issuer;
+    this.ownerIsCurrentCallback = ownerIsCurrent;
+    this.onDisposingCallback = onDisposing;
+    this.onDisposedCallback = onDisposed;
+    this.projection = initialProjection;
+  }
+
+  public get generation(): object {
+    return this.scope.generation;
+  }
+
+  public get disposed(): boolean {
+    return this.isDisposing || this.scope.disposed;
+  }
+
+  public get signal(): AbortSignal {
+    return this.scope.signal;
+  }
+
+  public adoptNextAttemptOrdinal(nextOrdinal: number): boolean {
+    if (!this.isCurrent() || !this.issuer) return false;
+    return this.issuer.adoptNextAttemptOrdinal(nextOrdinal);
+  }
+
+  public adoptFirstDisplayIdentityState(prefix: string, nextOrdinal: number): boolean {
+    if (!this.isCurrent() || !this.issuer) return false;
+    return this.issuer.adoptFirstDisplayState(prefix, nextOrdinal);
+  }
+
+  public get currentAuctionProjection(): Readonly<object> | undefined {
+    return this.projection;
+  }
+
+  public capture<Arguments extends readonly unknown[]>(
+    callback: (...arguments_: Arguments) => unknown
+  ): (...arguments_: Arguments) => boolean {
+    return (...arguments_: Arguments): boolean => {
+      if (!this.isCurrent()) return false;
+      callback(...arguments_);
+      return true;
+    };
+  }
+
+  public claimAlias(alias: string): boolean {
+    return this.claim(this.aliases, alias);
+  }
+
+  public claimIntent(slot: string): boolean {
+    return this.claim(this.intents, slot);
+  }
+
+  public claimTargeting(slot: string): boolean {
+    return this.claim(this.targetingOwners, slot);
+  }
+
+  public createAuctionBatch(key: string): AuctionBatchScope | undefined {
+    const issuer = this.issuer;
+    if (!issuer || !this.isCurrent() || this.batches.has(key)) return undefined;
+    const batchReference: { current?: AuctionBatchOwner } = {};
+    const batch = new AuctionBatchOwner(
+      issuer,
+      this.generation,
+      this.interfaces,
+      (): boolean => this.isCurrent() && this.batches.get(key) === batchReference.current,
+      (slot) => this.attempts.has(slot),
+      (slot, attempt) => {
+        if (!this.isCurrent() || this.attempts.has(slot)) return false;
+        this.attempts.set(slot, attempt);
+        return true;
+      },
+      (slot, attempt) => {
+        if (this.attempts.get(slot) === attempt) this.attempts.delete(slot);
+      },
+      this.onDisposalError
+    );
+    batchReference.current = batch;
+    this.batches.set(key, batch);
+    this.batchOrder.push(batch);
+    batch.onDispose('batch-index', () => {
+      this.batches.delete(key);
+      const orderIndex = this.batchOrder.indexOf(batch);
+      if (orderIndex >= 0) this.batchOrder.splice(orderIndex, 1);
+    });
+    return batch;
+  }
+
+  public installAuctionProjection(projection: Readonly<object>): boolean {
+    if (!this.isCurrent() || this.projection !== undefined || !recursivelyFrozen(projection)) {
+      return false;
+    }
+    this.projection = projection;
+    return true;
+  }
+
+  public isCurrent(): boolean {
+    return !this.disposed && (this.ownerIsCurrentCallback?.() ?? false);
+  }
+
+  public onDispose(kind: string, callback: DisposeCallback): void {
+    this.scope.onDispose(kind, callback);
+  }
+
+  public dispose(): void {
+    if (this.disposed) return;
+    this.isDisposing = true;
+    const releaseTransition = this.onDisposingCallback?.();
+    try {
+      for (let index = this.batchOrder.length - 1; index >= 0; index -= 1) {
+        this.batchOrder[index]?.dispose();
+      }
+      this.batchOrder.length = 0;
+      this.batches.clear();
+      this.attempts.clear();
+      this.scope.dispose();
+      this.aliases.clear();
+      this.intents.clear();
+      this.targetingOwners.clear();
+      this.projection = undefined;
+    } finally {
+      const onDisposed = this.onDisposedCallback;
+      this.issuer = undefined;
+      this.ownerIsCurrentCallback = undefined;
+      this.onDisposingCallback = undefined;
+      this.onDisposedCallback = undefined;
+      try {
+        onDisposed?.();
+      } finally {
+        releaseTransition?.();
+      }
+    }
+  }
+
+  public snapshotInventoryForTest(): NavigationInventorySnapshot {
+    let retainedAttemptScopes = 0;
+    for (const batch of this.batchOrder) {
+      retainedAttemptScopes += batch.retainedAttemptCount();
+    }
+    return Object.freeze({
+      activeDisposers: this.scope.activeDisposerCount(),
+      aliases: this.aliases.size,
+      attempts: this.attempts.size,
+      batches: this.batches.size,
+      disposed: this.disposed,
+      disposedByKind: this.scope.disposedInventory(),
+      hasAuctionProjection: this.projection !== undefined,
+      intents: this.intents.size,
+      retainedAttemptScopes,
+      retainedBatchScopes: this.batchOrder.length,
+      targetingOwners: this.targetingOwners.size,
+    });
+  }
+
+  private claim(index: Set<string>, key: string): boolean {
+    if (!this.isCurrent() || index.has(key)) return false;
+    index.add(key);
+    return true;
+  }
+}
+
+class RuntimeSessionOwner implements RuntimeSession {
+  public readonly generation = Object.freeze({});
+  public readonly interfaces: RuntimeInterfaces;
+  private readonly scope: OwnerScope;
+  private readonly createIdentityIssuer: NavigationIdentityIssuerFactory;
+  private readonly onNavigationDispose: ((navigationGeneration: object) => void) | undefined;
+  private readonly onDisposalError: DisposalErrorHandler | undefined;
+  private navigation: NavigationSessionOwner | undefined;
+  private started = false;
+  private disposedNavigations = 0;
+  private isDisposing = false;
+  private navigationTransitionInProgress = false;
+
+  public constructor(options: RuntimeSessionOptions) {
+    this.createIdentityIssuer = options.createIdentityIssuer;
+    this.onNavigationDispose =
+      typeof options.onNavigationDispose === 'function' ? options.onNavigationDispose : undefined;
+    this.onDisposalError = options.onDisposalError;
+    this.scope = new OwnerScope(options.onDisposalError);
+    this.interfaces = options.interfaces ?? EMPTY_INTERFACES;
+  }
+
+  public get disposed(): boolean {
+    return this.isDisposing || this.scope.disposed;
+  }
+
+  public get currentNavigation(): NavigationSession | undefined {
+    return this.navigation;
+  }
+
+  public startInitialNavigation(projection?: Readonly<object>): NavigationSessionResult {
+    if (this.disposed) return Object.freeze({ ok: false, reason: 'runtime_disposed' });
+    if (this.started) return Object.freeze({ ok: false, reason: 'navigation_already_started' });
+    if (this.navigationTransitionInProgress) {
+      return Object.freeze({ ok: false, reason: 'navigation_transition_in_progress' });
+    }
+    if (projection !== undefined && !recursivelyFrozen(projection)) {
+      return Object.freeze({ ok: false, reason: 'invalid_projection' });
+    }
+    this.navigationTransitionInProgress = true;
+    try {
+      const result = this.createNavigation(projection);
+      if (result.ok) this.started = true;
+      return result;
+    } finally {
+      this.navigationTransitionInProgress = false;
+    }
+  }
+
+  public replaceNavigation(): NavigationSessionResult {
+    if (this.disposed) return Object.freeze({ ok: false, reason: 'runtime_disposed' });
+    if (this.navigationTransitionInProgress) {
+      return Object.freeze({ ok: false, reason: 'navigation_transition_in_progress' });
+    }
+    this.navigationTransitionInProgress = true;
+    try {
+      const identity = this.obtainIdentityIssuer();
+      if (!identity.ok) return identity;
+      if (this.disposed) return Object.freeze({ ok: false, reason: 'runtime_disposed' });
+
+      const previous = this.navigation;
+      this.navigation = undefined;
+      previous?.dispose();
+      if (this.disposed) return Object.freeze({ ok: false, reason: 'runtime_disposed' });
+
+      const next = this.buildNavigation(identity.value, undefined);
+      this.navigation = next;
+      this.started = true;
+      return Object.freeze({ ok: true, value: next });
+    } finally {
+      this.navigationTransitionInProgress = false;
+    }
+  }
+
+  public isCurrent(): boolean {
+    return !this.disposed;
+  }
+
+  public onDispose(kind: string, callback: DisposeCallback): void {
+    this.scope.onDispose(kind, callback);
+  }
+
+  public dispose(): void {
+    if (this.disposed) return;
+    this.isDisposing = true;
+    this.navigation?.dispose();
+    this.navigation = undefined;
+    this.scope.dispose();
+  }
+
+  public snapshotInventoryForTest(): RuntimeInventorySnapshot {
+    return Object.freeze({
+      activeDisposers: this.scope.activeDisposerCount(),
+      currentNavigationGeneration: this.navigation?.generation,
+      disposed: this.disposed,
+      disposedByKind: this.scope.disposedInventory(),
+      disposedNavigations: this.disposedNavigations,
+      navigationCount: this.navigation && !this.navigation.disposed ? 1 : 0,
+    });
+  }
+
+  private createNavigation(projection?: Readonly<object>): NavigationSessionResult {
+    const identity = this.obtainIdentityIssuer();
+    if (!identity.ok) return identity;
+    if (this.disposed) return Object.freeze({ ok: false, reason: 'runtime_disposed' });
+    const navigation = this.buildNavigation(identity.value, projection);
+    this.navigation = navigation;
+    return Object.freeze({ ok: true, value: navigation });
+  }
+
+  private buildNavigation(
+    identityIssuer: NavigationIdentityIssuer,
+    projection: Readonly<object> | undefined
+  ): NavigationSessionOwner {
+    const navigationReference: { current?: NavigationSessionOwner } = {};
+    const navigation = new NavigationSessionOwner(
+      identityIssuer,
+      projection,
+      this.interfaces,
+      () => !this.disposed && this.navigation === navigationReference.current,
+      () => {
+        const disposingNavigation = navigationReference.current;
+        const ownsCurrent =
+          disposingNavigation !== undefined && this.navigation === disposingNavigation;
+        if (ownsCurrent) this.navigation = undefined;
+        if (!ownsCurrent || this.navigationTransitionInProgress || this.disposed) return undefined;
+        this.navigationTransitionInProgress = true;
+        return () => {
+          this.navigationTransitionInProgress = false;
+        };
+      },
+      () => {
+        const disposedNavigation = navigationReference.current;
+        if (disposedNavigation && this.navigation === disposedNavigation) {
+          this.navigation = undefined;
+        }
+        delete navigationReference.current;
+        this.disposedNavigations += 1;
+      },
+      this.onDisposalError
+    );
+    const onNavigationDispose = this.onNavigationDispose;
+    if (onNavigationDispose) {
+      const navigationGeneration = navigation.generation;
+      navigation.onDispose('navigation-lifecycle', () => onNavigationDispose(navigationGeneration));
+    }
+    navigationReference.current = navigation;
+    return navigation;
+  }
+
+  private obtainIdentityIssuer(): IdentityGenerationResult<NavigationIdentityIssuer> {
+    try {
+      return this.createIdentityIssuer();
+    } catch {
+      return Object.freeze({ ok: false, reason: 'identity_generation_failed' });
+    }
+  }
+}
+
+/** Construct one document-lifetime runtime session from injected interfaces only. */
+export function createRuntimeSession(options: RuntimeSessionOptions): RuntimeSession {
+  return new RuntimeSessionOwner(options);
+}
diff --git a/crates/trusted-server-js/lib/src/services/auction_batch.ts b/crates/trusted-server-js/lib/src/services/auction_batch.ts
new file mode 100644
index 000000000..2f33f4e99
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/auction_batch.ts
@@ -0,0 +1,622 @@
+import type { NavigationSession, RenderAttemptScope, WinnerContext } from '../kernel/sessions';
+
+import type {
+  RenderAttempt,
+  RenderAttemptCreationResult,
+  RenderCancellationReason,
+  RenderFailureReason,
+  RenderOutcome,
+} from './render';
+
+const DEFAULT_AUCTION_ENDPOINT = '/auction';
+const reflectApplyIntrinsic = Reflect.apply;
+function captureAbortSignalMethod(name: 'addEventListener' | 'removeEventListener'): unknown {
+  if (typeof AbortSignal === 'undefined') return undefined;
+  let prototype: object | null = AbortSignal.prototype;
+  while (prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    if (descriptor && 'value' in descriptor) return descriptor.value;
+    prototype = Object.getPrototypeOf(prototype) as object | null;
+  }
+  return undefined;
+}
+const abortSignalAbortedGetter =
+  typeof AbortSignal === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(AbortSignal.prototype, 'aborted')?.get;
+const abortSignalAddEventListener = captureAbortSignalMethod('addEventListener');
+const abortSignalRemoveEventListener = captureAbortSignalMethod('removeEventListener');
+
+export type AuctionBatchFetcher = (input: string, init: RequestInit) => Promise<unknown>;
+
+interface AuctionBatchBidBase {
+  readonly candidateId: string;
+  readonly impid: string;
+  readonly provider: string;
+  readonly price: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export type AuctionBatchBid =
+  | (AuctionBatchBidBase & {
+      readonly rendererReservationId: string;
+      readonly renderSource: Readonly<{ readonly type: 'aps' | 'adm' }>;
+      readonly adm?: string | undefined;
+    })
+  | (AuctionBatchBidBase & {
+      readonly renderSource: Readonly<{ readonly type: 'pbs_cache' }>;
+    });
+
+export type AuctionBatchDecision =
+  | Readonly<{ slot: string; outcome: 'winner'; candidateId: string }>
+  | Readonly<{ slot: string; outcome: 'no_bid' }>
+  | Readonly<{ slot: string; outcome: 'failed'; reason: RenderFailureReason }>;
+
+export interface ParsedAuctionBatchResponse {
+  readonly auction: Readonly<{
+    readonly results: readonly AuctionBatchDecision[];
+  }>;
+  readonly bids: readonly AuctionBatchBid[];
+}
+
+export interface AuctionBatchScheduler {
+  readonly clear: (handle: unknown) => void;
+  readonly set: (callback: () => void, milliseconds: number) => unknown;
+}
+
+export type AuctionBatchSlotResult = Readonly<{ slot: string; path: 'primary' } & RenderOutcome>;
+
+export interface AuctionBatchResult {
+  readonly slots: readonly AuctionBatchSlotResult[];
+}
+
+export interface AuctionBatch {
+  readonly result: Promise<Readonly<AuctionBatchResult>>;
+  readonly cancel: () => void;
+}
+
+export interface AuctionBatchInput {
+  readonly navigation: NavigationSession;
+  readonly requestBody: string;
+  readonly signal?: AbortSignal;
+  readonly slots: readonly string[];
+  readonly timeoutMs: number;
+}
+
+export interface AuctionBatchServiceOptions {
+  readonly createAttempt: (owner: RenderAttemptScope) => RenderAttemptCreationResult;
+  readonly endpoint?: string;
+  readonly fetcher: AuctionBatchFetcher;
+  readonly parseResponse: (value: unknown) => ParsedAuctionBatchResponse | undefined;
+  readonly renderWinner: (attempt: RenderAttempt, bid: AuctionBatchBid) => boolean;
+  readonly scheduler?: AuctionBatchScheduler;
+}
+
+export interface AuctionBatchService {
+  readonly create: (input: AuctionBatchInput) => AuctionBatch;
+  readonly dispose: () => void;
+}
+
+interface ActiveChild {
+  readonly attempt: RenderAttempt;
+  readonly navigationGeneration: object;
+  terminal: boolean;
+}
+
+interface BatchChild extends ActiveChild {
+  readonly index: number;
+  readonly slot: string;
+}
+
+function frozen<Value extends object>(value: Value): Readonly<Value> {
+  return Object.freeze(value);
+}
+
+function defaultScheduler(): AuctionBatchScheduler {
+  return frozen({
+    clear: (handle: unknown): void =>
+      globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>),
+    set: (callback: () => void, milliseconds: number): unknown =>
+      globalThis.setTimeout(callback, milliseconds),
+  });
+}
+
+function terminalResult(slot: string, outcome: RenderOutcome): AuctionBatchSlotResult {
+  return frozen({ slot, path: 'primary' as const, ...outcome });
+}
+
+function failedResult(slot: string, reason: RenderFailureReason): AuctionBatchSlotResult {
+  return terminalResult(slot, frozen({ outcome: 'failed' as const, reason }));
+}
+
+function cancelledResult(slot: string, reason: RenderCancellationReason): AuctionBatchSlotResult {
+  return terminalResult(slot, frozen({ outcome: 'cancelled' as const, reason }));
+}
+
+function signalAborted(signal: AbortSignal): boolean | undefined {
+  if (typeof abortSignalAbortedGetter !== 'function') return undefined;
+  try {
+    return reflectApplyIntrinsic(abortSignalAbortedGetter, signal, []) as boolean;
+  } catch {
+    return undefined;
+  }
+}
+
+function addAbortListener(signal: AbortSignal, listener: () => void): boolean {
+  if (typeof abortSignalAddEventListener !== 'function') return false;
+  try {
+    reflectApplyIntrinsic(abortSignalAddEventListener, signal, ['abort', listener, { once: true }]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeAbortListener(signal: AbortSignal, listener: () => void): void {
+  if (typeof abortSignalRemoveEventListener !== 'function') return;
+  try {
+    reflectApplyIntrinsic(abortSignalRemoveEventListener, signal, ['abort', listener]);
+  } catch {
+    // Logical cancellation authority is already detached.
+  }
+}
+
+function responseMembershipIsExact(
+  parsed: ParsedAuctionBatchResponse,
+  slots: readonly string[]
+): boolean {
+  const decisions = parsed.auction.results;
+  if (decisions.length !== slots.length) return false;
+  const membership = new Set(slots);
+  if (membership.size !== slots.length) return false;
+  for (let index = 0; index < decisions.length; index += 1) {
+    const slot = decisions[index]?.slot;
+    if (!slot || slot !== slots[index]) return false;
+  }
+  return true;
+}
+
+/** Runtime-owned coordinator for navigation-scoped one-fetch auction batches. */
+export function createAuctionBatchService(
+  options: AuctionBatchServiceOptions
+): AuctionBatchService {
+  const endpoint = options.endpoint ?? DEFAULT_AUCTION_ENDPOINT;
+  const parseResponse = options.parseResponse;
+  const scheduler = options.scheduler ?? defaultScheduler();
+  const activeByNavigation = new Map<object, Map<string, ActiveChild>>();
+  const batches = new Set<Readonly<{ cancel: (reason: RenderCancellationReason) => void }>>();
+  let nextBatchOrdinal = 0;
+  let disposed = false;
+
+  const activeSlots = (generation: object): Map<string, ActiveChild> => {
+    const existing = activeByNavigation.get(generation);
+    if (existing) return existing;
+    const created = new Map<string, ActiveChild>();
+    activeByNavigation.set(generation, created);
+    return created;
+  };
+
+  const create = (input: AuctionBatchInput): AuctionBatch => {
+    const slots = frozen(Array.from(input.slots));
+    const results: Array<AuctionBatchSlotResult | undefined> = new Array(slots.length);
+    let resolveResult: (value: Readonly<AuctionBatchResult>) => void = () => undefined;
+    const result = new Promise<Readonly<AuctionBatchResult>>((resolve) => {
+      resolveResult = resolve;
+    });
+    const immediate = (reason: RenderCancellationReason): AuctionBatch => {
+      const terminal = frozen({
+        slots: frozen(slots.map((slot) => cancelledResult(slot, reason))),
+      });
+      resolveResult(terminal);
+      return frozen({ result, cancel: () => undefined });
+    };
+
+    if (disposed || !input.navigation.isCurrent()) return immediate('navigation_disposed');
+    nextBatchOrdinal += 1;
+    const owner = input.navigation.createAuctionBatch(`auction-batch-${nextBatchOrdinal}`);
+    if (!owner) return immediate('navigation_disposed');
+
+    const children: Array<BatchChild | undefined> = new Array(slots.length);
+    const navigationGeneration = input.navigation.generation;
+    const navigationSlots = activeSlots(navigationGeneration);
+    const controller = new AbortController();
+    let callerListener: (() => void) | undefined;
+    let deadlineHandle: unknown;
+    let deadlineArmed = false;
+    let fetchPending = false;
+    let finished = false;
+    let building = true;
+    let remaining = slots.length;
+
+    const clearDeadline = (): void => {
+      if (!deadlineArmed) return;
+      deadlineArmed = false;
+      const handle = deadlineHandle;
+      deadlineHandle = undefined;
+      try {
+        scheduler.clear(handle);
+      } catch {
+        // The logical deadline is already inert.
+      }
+    };
+
+    const abortFetch = (): void => {
+      if (!fetchPending) return;
+      fetchPending = false;
+      try {
+        controller.abort();
+      } catch {
+        // Child outcomes remain authoritative if host abort throws.
+      }
+    };
+
+    const cleanupSignal = (): void => {
+      if (!callerListener || !input.signal) return;
+      removeAbortListener(input.signal, callerListener);
+      callerListener = undefined;
+    };
+
+    const finishIfComplete = (): void => {
+      if (finished || building || remaining !== 0) return;
+      finished = true;
+      clearDeadline();
+      abortFetch();
+      cleanupSignal();
+      const membership = activeByNavigation.get(navigationGeneration);
+      if (membership?.size === 0) activeByNavigation.delete(navigationGeneration);
+      batches.delete(batchControl);
+      try {
+        owner.dispose();
+      } catch {
+        // All public children are already terminal.
+      }
+      resolveResult(
+        frozen({
+          slots: frozen(
+            results.map(
+              (entry, index) => entry ?? failedResult(slots[index] ?? '', 'internal_error')
+            )
+          ),
+        })
+      );
+    };
+
+    const settleIndex = (index: number, terminal: AuctionBatchSlotResult): void => {
+      if (results[index]) return;
+      results[index] = terminal;
+      remaining -= 1;
+      const child = children[index];
+      if (child) {
+        child.terminal = true;
+        if (navigationSlots.get(child.slot) === child) navigationSlots.delete(child.slot);
+      }
+      finishIfComplete();
+    };
+
+    const containCancellation = (child: BatchChild, reason: RenderCancellationReason): void => {
+      try {
+        child.attempt.cancel(reason);
+      } catch {
+        // Synthetic public settlement below contains a broken attempt implementation.
+      }
+      if (!child.terminal) settleIndex(child.index, cancelledResult(child.slot, reason));
+    };
+
+    const containFailure = (child: BatchChild, reason: RenderFailureReason): void => {
+      try {
+        child.attempt.fail(reason);
+      } catch {
+        // Synthetic public settlement below contains a broken attempt implementation.
+      }
+      if (!child.terminal) settleIndex(child.index, failedResult(child.slot, reason));
+    };
+
+    const containNoBid = (child: BatchChild): void => {
+      try {
+        child.attempt.noBid();
+      } catch {
+        // Synthetic public settlement below contains a broken attempt implementation.
+      }
+      if (!child.terminal) {
+        settleIndex(
+          child.index,
+          terminalResult(child.slot, frozen({ outcome: 'no_bid' as const }))
+        );
+      }
+    };
+
+    const cancelLive = (reason: RenderCancellationReason): void => {
+      for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (!child || child.terminal) continue;
+        containCancellation(child, reason);
+      }
+      finishIfComplete();
+    };
+
+    const batchControl = frozen({ cancel: cancelLive });
+    batches.add(batchControl);
+
+    for (let index = 0; index < slots.length; index += 1) {
+      const slot = slots[index];
+      if (!slot) {
+        settleIndex(index, failedResult('', 'internal_error'));
+        continue;
+      }
+      const previous = navigationSlots.get(slot);
+      if (previous && !previous.terminal) {
+        try {
+          previous.attempt.cancel('superseded');
+        } catch {
+          // Exact removal below decides whether the new child may proceed.
+        }
+      }
+      if (navigationSlots.get(slot) === previous && previous && !previous.terminal) {
+        settleIndex(index, failedResult(slot, 'internal_error'));
+        continue;
+      }
+
+      const issued = owner.createRenderAttempt(slot);
+      if (!issued.ok) {
+        settleIndex(
+          index,
+          issued.reason === 'identity_generation_failed'
+            ? failedResult(slot, 'identity_generation_failed')
+            : issued.reason === 'stale_owner'
+              ? cancelledResult(slot, 'navigation_disposed')
+              : failedResult(slot, 'internal_error')
+        );
+        continue;
+      }
+      let created: RenderAttemptCreationResult;
+      try {
+        created = options.createAttempt(issued.value);
+      } catch {
+        created = frozen({ ok: false, reason: 'invalid_attempt' as const });
+      }
+      if (!created.ok) {
+        try {
+          issued.value.dispose();
+        } catch {
+          // The failed construction owns no public result authority.
+        }
+        settleIndex(
+          index,
+          created.reason === 'identity_generation_failed'
+            ? failedResult(slot, 'identity_generation_failed')
+            : created.reason === 'stale_owner'
+              ? cancelledResult(slot, 'navigation_disposed')
+              : failedResult(slot, 'internal_error')
+        );
+        continue;
+      }
+      const child: BatchChild = {
+        attempt: created.value,
+        index,
+        navigationGeneration,
+        slot,
+        terminal: false,
+      };
+      children[index] = child;
+      navigationSlots.set(slot, child);
+      let observing: boolean;
+      try {
+        observing =
+          created.value.onSettled((outcome) =>
+            settleIndex(index, terminalResult(slot, outcome))
+          ) === true;
+      } catch {
+        observing = false;
+      }
+      if (!observing && !child.terminal) {
+        containFailure(child, 'internal_error');
+      }
+    }
+    building = false;
+
+    const publicBatch = frozen({
+      result,
+      cancel: (): void => cancelLive('caller_aborted'),
+    });
+
+    if (remaining === 0) {
+      finishIfComplete();
+      return publicBatch;
+    }
+    if (input.signal) {
+      if (signalAborted(input.signal) !== false) {
+        cancelLive('caller_aborted');
+        return publicBatch;
+      }
+      callerListener = (): void => cancelLive('caller_aborted');
+      if (!addAbortListener(input.signal, callerListener)) {
+        cancelLive('caller_aborted');
+        return publicBatch;
+      }
+      if (signalAborted(input.signal) !== false) {
+        cancelLive('caller_aborted');
+        return publicBatch;
+      }
+    }
+
+    const failLive = (reason: RenderFailureReason): void => {
+      for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (!child || child.terminal) continue;
+        containFailure(child, reason);
+      }
+      finishIfComplete();
+    };
+
+    const completeTransport = (): void => {
+      fetchPending = false;
+      clearDeadline();
+    };
+
+    const applyResponse = (parsed: ParsedAuctionBatchResponse): void => {
+      const bids = new Map(parsed.bids.map((bid) => [bid.candidateId, bid]));
+      const decisions = new Map(
+        parsed.auction.results.map((decision) => [decision.slot, decision])
+      );
+      for (let index = 0; index < children.length; index += 1) {
+        const child = children[index];
+        if (!child || child.terminal) continue;
+        const decision = decisions.get(child.slot);
+        if (!decision) {
+          containFailure(child, 'invalid_response');
+          continue;
+        }
+        if (decision.outcome === 'no_bid') {
+          containNoBid(child);
+          continue;
+        }
+        if (decision.outcome === 'failed') {
+          containFailure(child, decision.reason);
+          continue;
+        }
+        const bid = bids.get(decision.candidateId);
+        if (bid?.renderSource.type === 'pbs_cache') {
+          containFailure(child, 'winner_not_renderable');
+          continue;
+        }
+        const context: WinnerContext | undefined = bid
+          ? frozen({ selectedCpm: bid.price })
+          : undefined;
+        let admitted: boolean;
+        try {
+          admitted =
+            !!bid &&
+            !!context &&
+            child.attempt.admitDirectWinner(bid.renderSource, context) === true;
+        } catch {
+          admitted = false;
+        }
+        if (!admitted || !bid) {
+          if (!child.terminal) containFailure(child, 'winner_not_renderable');
+          continue;
+        }
+        let rendering: boolean;
+        try {
+          rendering = options.renderWinner(child.attempt, bid) === true;
+        } catch {
+          rendering = false;
+        }
+        if (!rendering && !child.terminal) containFailure(child, 'winner_not_renderable');
+      }
+    };
+
+    const processFetch = async (fetchResult: Promise<unknown>): Promise<void> => {
+      let response: unknown;
+      try {
+        response = await fetchResult;
+      } catch {
+        if (finished) return;
+        completeTransport();
+        failLive('network_error');
+        return;
+      }
+      if (finished) return;
+      let ok: unknown;
+      let json: unknown;
+      try {
+        ok = Reflect.get(response as object, 'ok');
+        json = Reflect.get(response as object, 'json');
+      } catch {
+        completeTransport();
+        failLive('invalid_response');
+        return;
+      }
+      if (ok !== true) {
+        completeTransport();
+        failLive('http_error');
+        return;
+      }
+      if (typeof json !== 'function') {
+        completeTransport();
+        failLive('invalid_response');
+        return;
+      }
+      let body: unknown;
+      try {
+        body = await Reflect.apply(json, response, []);
+      } catch {
+        if (finished) return;
+        completeTransport();
+        failLive('invalid_response');
+        return;
+      }
+      if (finished) return;
+      let parsed: ParsedAuctionBatchResponse | undefined;
+      try {
+        parsed = parseResponse(body);
+      } catch {
+        parsed = undefined;
+      }
+      completeTransport();
+      if (!parsed || !responseMembershipIsExact(parsed, slots)) {
+        failLive('invalid_response');
+        return;
+      }
+      applyResponse(parsed);
+    };
+
+    fetchPending = true;
+    try {
+      deadlineArmed = true;
+      const handle = scheduler.set(() => {
+        if (finished || !fetchPending) return;
+        abortFetch();
+        clearDeadline();
+        failLive('auction_timeout');
+      }, input.timeoutMs);
+      if (deadlineArmed && !finished) deadlineHandle = handle;
+      else {
+        try {
+          scheduler.clear(handle);
+        } catch {
+          // A synchronously terminal batch cannot regain deadline authority.
+        }
+      }
+    } catch {
+      deadlineArmed = false;
+      fetchPending = false;
+      failLive('internal_error');
+      return publicBatch;
+    }
+    if (finished) return publicBatch;
+
+    let fetchResult: Promise<unknown>;
+    try {
+      fetchResult = options.fetcher(
+        endpoint,
+        frozen({
+          body: input.requestBody,
+          headers: frozen({ 'content-type': 'application/json' }),
+          method: 'POST',
+          signal: controller.signal,
+        })
+      );
+    } catch {
+      completeTransport();
+      failLive('network_error');
+      return publicBatch;
+    }
+    void processFetch(fetchResult);
+    return publicBatch;
+  };
+
+  return frozen({
+    create,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      const active = Array.from(batches);
+      batches.clear();
+      for (let index = 0; index < active.length; index += 1) {
+        active[index]?.cancel('navigation_disposed');
+      }
+      activeByNavigation.clear();
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/services/context.ts b/crates/trusted-server-js/lib/src/services/context.ts
new file mode 100644
index 000000000..98966c2c2
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/context.ts
@@ -0,0 +1,580 @@
+import type { DisposeCallback } from '../kernel/disposable';
+import { EMBEDDED_MAX_MANIFEST_MODULES } from '../kernel/contracts/release_capacity';
+
+const INTEGRATION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+// Context shares the existing /auction request-body ceiling. The structural
+// bound follows from the smallest repeated JSON unit (`0,`), and the key bound
+// reserves the seven bytes required by a one-property `{<key>:null}` object.
+const MAX_CONTEXT_JSON_BYTES = 256 * 1024;
+const MAX_CONTEXT_STRUCTURE_ENTRIES = Math.floor((MAX_CONTEXT_JSON_BYTES - 1) / 2);
+const MAX_CONTEXT_ENCODED_KEY_BYTES = MAX_CONTEXT_JSON_BYTES - 7;
+
+/** Owner boundary required for generation-scoped contributor registration. */
+export interface ContextContributorOwner {
+  readonly generation: object;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: DisposeCallback) => void;
+}
+
+/** One integration's document-scoped contribution to an auction request. */
+export type AuctionContextContributor = () => Readonly<Record<string, unknown>> | undefined;
+
+/** Sanitized observation emitted when one contributor cannot be copied. */
+export interface AuctionContextContributorFailure {
+  readonly integrationId: string;
+  readonly reason: 'contributor_failed';
+}
+
+/** Runtime-owned contributor registry options. */
+export interface AuctionContextRegistryOptions {
+  readonly manifestIntegrationIds: readonly string[];
+  readonly runtimeOwner: ContextContributorOwner;
+  readonly onContributorFailure?: (failure: AuctionContextContributorFailure) => void;
+}
+
+/** Frozen test-only inventory for the runtime-owned registry. */
+export interface AuctionContextRegistryInventory {
+  readonly disposed: boolean;
+  readonly registrations: readonly string[];
+}
+
+/** Runtime-owned registry that snapshots contributors in manifest order. */
+export interface AuctionContextRegistry {
+  readonly register: (
+    integrationId: string,
+    contributor: AuctionContextContributor,
+    owner: ContextContributorOwner
+  ) => boolean;
+  readonly snapshot: () => Readonly<Record<string, unknown>>;
+  readonly dispose: () => void;
+  readonly snapshotInventoryForTest: () => AuctionContextRegistryInventory;
+}
+
+interface ContributorRecord {
+  readonly contributor: AuctionContextContributor;
+  readonly owner: ContextContributorOwner;
+  readonly ownerGeneration: object;
+}
+
+type JsonPrimitive = null | boolean | number | string;
+
+interface ContextMeasurement {
+  readonly jsonBytes: number;
+  readonly keyBytes: number;
+  readonly structureEntries: number;
+}
+
+interface PrimitiveSnapshot {
+  readonly kind: 'primitive';
+  readonly measurement: ContextMeasurement;
+  readonly value: JsonPrimitive;
+}
+
+interface ContextSnapshotEntry {
+  readonly encodedKeyBytes: number;
+  readonly key: string;
+  readonly sourceValue: unknown;
+  snapshot: ContextSnapshotNode | PrimitiveSnapshot | undefined;
+}
+
+interface ContextSnapshotNode {
+  readonly array: boolean;
+  readonly entries: readonly ContextSnapshotEntry[];
+  readonly kind: 'node';
+  readonly source: object;
+}
+
+interface ContextSnapshotGraph {
+  readonly nodes: readonly ContextSnapshotNode[];
+  readonly root: ContextSnapshotNode;
+}
+
+interface ClonedContextValue {
+  readonly measurement: ContextMeasurement;
+  readonly value: unknown;
+}
+
+interface CopiedContributionEntry extends ContextMeasurement {
+  readonly key: string;
+  readonly value: unknown;
+}
+
+interface CopiedContribution {
+  readonly entries: readonly CopiedContributionEntry[];
+}
+
+interface AcceptedContributionEntry {
+  readonly contribution: CopiedContributionEntry;
+  readonly integrationId: string;
+  readonly record: ContributorRecord;
+}
+
+interface TraversalBudget {
+  keyBytes: number;
+  structureEntries: number;
+}
+
+interface TraversalFrame {
+  readonly node: ContextSnapshotNode;
+  index: number;
+}
+
+function snapshotManifest(candidate: readonly string[]): readonly string[] {
+  if (!Object.isFrozen(candidate) || candidate.length > EMBEDDED_MAX_MANIFEST_MODULES) {
+    throw new TypeError('Auction context manifest must be frozen and bounded');
+  }
+  const seen = new Set<string>();
+  const snapshot: string[] = [];
+  for (const id of candidate) {
+    if (typeof id !== 'string' || !INTEGRATION_ID.test(id) || seen.has(id)) {
+      throw new TypeError('Auction context manifest contains an invalid integration id');
+    }
+    seen.add(id);
+    snapshot.push(id);
+  }
+  return Object.freeze(snapshot);
+}
+
+function boundedSum(left: number, right: number, maximum: number): number {
+  return left > maximum - right ? maximum + 1 : left + right;
+}
+
+function encodedJsonStringBytes(value: string, maximum: number): number {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    let encodedBytes: number;
+    if (code === 0x22 || code === 0x5c) encodedBytes = 2;
+    else if (code <= 0x1f) {
+      encodedBytes =
+        code === 0x08 || code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d ? 2 : 6;
+    } else if (code <= 0x7f) encodedBytes = 1;
+    else if (code <= 0x7ff) encodedBytes = 2;
+    else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        encodedBytes = 4;
+        index += 1;
+      } else encodedBytes = 6;
+    } else if (code >= 0xdc00 && code <= 0xdfff) encodedBytes = 6;
+    else encodedBytes = 3;
+    bytes = boundedSum(bytes, encodedBytes, maximum);
+    if (bytes > maximum) return bytes;
+  }
+  return bytes;
+}
+
+function snapshotPrimitive(value: unknown): PrimitiveSnapshot | undefined {
+  let jsonBytes: number;
+  if (value === null) jsonBytes = 4;
+  else if (typeof value === 'boolean') jsonBytes = value ? 4 : 5;
+  else if (typeof value === 'number' && Number.isFinite(value)) jsonBytes = `${value}`.length;
+  else if (typeof value === 'string') {
+    jsonBytes = encodedJsonStringBytes(value, MAX_CONTEXT_JSON_BYTES);
+    if (jsonBytes > MAX_CONTEXT_JSON_BYTES) return undefined;
+  } else return undefined;
+  return Object.freeze({
+    kind: 'primitive',
+    measurement: Object.freeze({ jsonBytes, keyBytes: 0, structureEntries: 0 }),
+    value,
+  }) as PrimitiveSnapshot;
+}
+
+function spendStructure(budget: TraversalBudget): boolean {
+  budget.structureEntries += 1;
+  return budget.structureEntries <= MAX_CONTEXT_STRUCTURE_ENTRIES;
+}
+
+function snapshotNode(source: object, budget: TraversalBudget): ContextSnapshotNode | undefined {
+  if (!spendStructure(budget)) return undefined;
+  const prototype = Object.getPrototypeOf(source) as unknown;
+  const array = Array.isArray(source);
+  if ((array && prototype !== Array.prototype) || (!array && prototype !== Object.prototype)) {
+    return undefined;
+  }
+  const entries: ContextSnapshotEntry[] = [];
+  if (array) {
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(source, 'length');
+    if (
+      !lengthDescriptor ||
+      !('value' in lengthDescriptor) ||
+      !Number.isSafeInteger(lengthDescriptor.value) ||
+      lengthDescriptor.value < 0 ||
+      lengthDescriptor.value > MAX_CONTEXT_STRUCTURE_ENTRIES
+    ) {
+      return undefined;
+    }
+    for (let index = 0; index < lengthDescriptor.value; index += 1) {
+      if (!spendStructure(budget)) return undefined;
+      const key = `${index}`;
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      entries.push({ encodedKeyBytes: 0, key, snapshot: undefined, sourceValue: descriptor.value });
+    }
+  } else {
+    for (const key in source as Record<string, unknown>) {
+      const descriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (!descriptor) continue;
+      if (!descriptor.enumerable || !('value' in descriptor) || !spendStructure(budget)) {
+        return undefined;
+      }
+      const encodedKeyBytes = encodedJsonStringBytes(key, MAX_CONTEXT_ENCODED_KEY_BYTES);
+      budget.keyBytes = boundedSum(budget.keyBytes, encodedKeyBytes, MAX_CONTEXT_ENCODED_KEY_BYTES);
+      if (budget.keyBytes > MAX_CONTEXT_ENCODED_KEY_BYTES) return undefined;
+      entries.push({ encodedKeyBytes, key, snapshot: undefined, sourceValue: descriptor.value });
+    }
+  }
+  return { array, entries, kind: 'node', source };
+}
+
+function snapshotContextGraph(value: unknown): ContextSnapshotGraph | undefined {
+  if (typeof value !== 'object' || value === null) return undefined;
+  const budget: TraversalBudget = { keyBytes: 0, structureEntries: 0 };
+  try {
+    const root = snapshotNode(value, budget);
+    if (!root || root.array) return undefined;
+    const active = new Set<object>([value]);
+    const nodes: ContextSnapshotNode[] = [root];
+    const stack: TraversalFrame[] = [{ index: 0, node: root }];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (!frame) return undefined;
+      if (frame.index >= frame.node.entries.length) {
+        active.delete(frame.node.source);
+        stack.pop();
+        continue;
+      }
+      const entry = frame.node.entries[frame.index];
+      frame.index += 1;
+      if (!entry) return undefined;
+      const primitive = snapshotPrimitive(entry.sourceValue);
+      if (primitive) {
+        entry.snapshot = primitive;
+        continue;
+      }
+      if (
+        typeof entry.sourceValue !== 'object' ||
+        entry.sourceValue === null ||
+        active.has(entry.sourceValue)
+      ) {
+        return undefined;
+      }
+      const child = snapshotNode(entry.sourceValue, budget);
+      if (!child) return undefined;
+      entry.snapshot = child;
+      nodes.push(child);
+      active.add(entry.sourceValue);
+      stack.push({ index: 0, node: child });
+    }
+    return Object.freeze({ nodes: Object.freeze(nodes), root });
+  } catch {
+    return undefined;
+  }
+}
+
+function cloneSnapshotGraph(graph: ContextSnapshotGraph): CopiedContribution | undefined {
+  const completed = new Map<ContextSnapshotNode, ClonedContextValue>();
+  try {
+    for (let nodeIndex = graph.nodes.length - 1; nodeIndex >= 0; nodeIndex -= 1) {
+      const node = graph.nodes[nodeIndex];
+      if (!node) return undefined;
+      const output: Record<string, unknown> | unknown[] = node.array ? [] : {};
+      let jsonBytes = 2;
+      let keyBytes = 0;
+      let structureEntries = 1;
+      for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+        const entry = node.entries[entryIndex];
+        if (!entry?.snapshot) return undefined;
+        const child =
+          entry.snapshot.kind === 'node' ? completed.get(entry.snapshot) : entry.snapshot;
+        if (!child) return undefined;
+        const prefixBytes =
+          (entryIndex === 0 ? 0 : 1) + (node.array ? 0 : entry.encodedKeyBytes + 1);
+        jsonBytes = boundedSum(jsonBytes, prefixBytes, MAX_CONTEXT_JSON_BYTES);
+        jsonBytes = boundedSum(jsonBytes, child.measurement.jsonBytes, MAX_CONTEXT_JSON_BYTES);
+        keyBytes = boundedSum(
+          keyBytes,
+          entry.encodedKeyBytes + child.measurement.keyBytes,
+          MAX_CONTEXT_ENCODED_KEY_BYTES
+        );
+        structureEntries = boundedSum(
+          structureEntries,
+          1 + child.measurement.structureEntries,
+          MAX_CONTEXT_STRUCTURE_ENTRIES
+        );
+        if (
+          jsonBytes > MAX_CONTEXT_JSON_BYTES ||
+          keyBytes > MAX_CONTEXT_ENCODED_KEY_BYTES ||
+          structureEntries > MAX_CONTEXT_STRUCTURE_ENTRIES
+        ) {
+          return undefined;
+        }
+        Object.defineProperty(output, entry.key, {
+          configurable: true,
+          enumerable: true,
+          value: child.value,
+          writable: true,
+        });
+      }
+      completed.set(
+        node,
+        Object.freeze({
+          measurement: Object.freeze({ jsonBytes, keyBytes, structureEntries }),
+          value: Object.freeze(output),
+        })
+      );
+    }
+
+    const entries = graph.root.entries.map((entry): CopiedContributionEntry | undefined => {
+      if (!entry.snapshot) return undefined;
+      const child = entry.snapshot.kind === 'node' ? completed.get(entry.snapshot) : entry.snapshot;
+      if (!child) return undefined;
+      return Object.freeze({
+        jsonBytes: entry.encodedKeyBytes + 1 + child.measurement.jsonBytes,
+        key: entry.key,
+        keyBytes: entry.encodedKeyBytes + child.measurement.keyBytes,
+        structureEntries: 1 + child.measurement.structureEntries,
+        value: child.value,
+      });
+    });
+    return entries.some((entry) => entry === undefined)
+      ? undefined
+      : Object.freeze({ entries: Object.freeze(entries as CopiedContributionEntry[]) });
+  } catch {
+    return undefined;
+  }
+}
+
+function copyContribution(value: unknown): CopiedContribution | undefined {
+  const graph = snapshotContextGraph(value);
+  return graph ? cloneSnapshotGraph(graph) : undefined;
+}
+
+class AuctionContextRegistryOwner implements AuctionContextRegistry {
+  private readonly manifestIntegrationIds: readonly string[];
+  private readonly manifestSet: ReadonlySet<string>;
+  private readonly runtimeGeneration: object | undefined;
+  private readonly registrations = new Map<string, ContributorRecord>();
+  private readonly runtimeOwner: ContextContributorOwner;
+  private readonly onContributorFailure:
+    ((failure: AuctionContextContributorFailure) => void) | undefined;
+  private isDisposed = false;
+
+  public constructor(options: AuctionContextRegistryOptions) {
+    this.manifestIntegrationIds = snapshotManifest(options.manifestIntegrationIds);
+    this.manifestSet = new Set(this.manifestIntegrationIds);
+    this.runtimeOwner = options.runtimeOwner;
+    this.runtimeGeneration = this.snapshotCurrentOwnerGeneration(options.runtimeOwner);
+    this.onContributorFailure = options.onContributorFailure;
+    if (this.runtimeGeneration === undefined) {
+      this.dispose();
+      return;
+    }
+    try {
+      options.runtimeOwner.onDispose('auction-context-registry', () => this.dispose());
+    } catch {
+      this.dispose();
+    }
+    if (!this.runtimeIsCurrent()) this.dispose();
+  }
+
+  public register(
+    integrationId: string,
+    contributor: AuctionContextContributor,
+    owner: ContextContributorOwner
+  ): boolean {
+    const ownerGeneration = this.snapshotCurrentOwnerGeneration(owner);
+    if (
+      !this.runtimeIsCurrent() ||
+      !this.manifestSet.has(integrationId) ||
+      this.registrations.has(integrationId) ||
+      typeof contributor !== 'function' ||
+      ownerGeneration === undefined
+    ) {
+      return false;
+    }
+    const record: ContributorRecord = Object.freeze({
+      contributor,
+      owner,
+      ownerGeneration,
+    });
+    this.registrations.set(integrationId, record);
+    try {
+      owner.onDispose('auction-context-contributor', () => {
+        this.deleteRegistration(integrationId, record);
+      });
+    } catch {
+      this.deleteRegistration(integrationId, record);
+      return false;
+    }
+    const runtimeIsCurrent = this.runtimeIsCurrent();
+    const recordSurvivedRuntimeReflection = this.registrations.get(integrationId) === record;
+    if (!runtimeIsCurrent || !recordSurvivedRuntimeReflection) {
+      this.deleteRegistration(integrationId, record);
+      return false;
+    }
+    const ownerIsCurrent = this.ownerIsCurrent(owner, ownerGeneration);
+    const recordSurvivedOwnerReflection = this.registrations.get(integrationId) === record;
+    if (!ownerIsCurrent || !recordSurvivedOwnerReflection) {
+      this.deleteRegistration(integrationId, record);
+      return false;
+    }
+    return true;
+  }
+
+  public snapshot(): Readonly<Record<string, unknown>> {
+    if (!this.runtimeIsCurrent()) {
+      this.dispose();
+      return Object.freeze({});
+    }
+    const accepted = new Map<string, AcceptedContributionEntry>();
+    let acceptedEntryBytes = 0;
+    let acceptedKeyBytes = 0;
+    let acceptedStructureEntries = 1;
+    for (const integrationId of this.manifestIntegrationIds) {
+      const record = this.registrations.get(integrationId);
+      if (!record) continue;
+      const ownerIsCurrentBeforeInvocation = this.ownerIsCurrent(
+        record.owner,
+        record.ownerGeneration
+      );
+      const recordSurvivedOwnerReflection = this.registrations.get(integrationId) === record;
+      if (!ownerIsCurrentBeforeInvocation || !recordSurvivedOwnerReflection) continue;
+      let contribution: CopiedContribution | undefined;
+      let contributorReturnedUndefined = false;
+      try {
+        const candidate = record.contributor();
+        contributorReturnedUndefined = candidate === undefined;
+        if (!contributorReturnedUndefined) contribution = copyContribution(candidate);
+      } catch {
+        contribution = undefined;
+      }
+      if (this.registrations.get(integrationId) !== record) continue;
+      if (contributorReturnedUndefined) continue;
+      if (!contribution) {
+        this.reportFailure(integrationId);
+        continue;
+      }
+      const runtimeIsCurrent = this.runtimeIsCurrent();
+      const recordSurvivedRuntimeReflection = this.registrations.get(integrationId) === record;
+      if (!runtimeIsCurrent) return Object.freeze({});
+      if (!recordSurvivedRuntimeReflection) continue;
+      const ownerIsCurrentBeforeMerge = this.ownerIsCurrent(record.owner, record.ownerGeneration);
+      const recordSurvivedOwnerReflectionBeforeMerge =
+        this.registrations.get(integrationId) === record;
+      if (!ownerIsCurrentBeforeMerge || !recordSurvivedOwnerReflectionBeforeMerge) continue;
+      let prospectiveEntryBytes = acceptedEntryBytes;
+      let prospectiveKeyBytes = acceptedKeyBytes;
+      let prospectiveStructureEntries = acceptedStructureEntries;
+      let prospectiveEntryCount = accepted.size;
+      for (const entry of contribution.entries) {
+        const predecessor = accepted.get(entry.key);
+        if (predecessor) {
+          prospectiveEntryBytes -= predecessor.contribution.jsonBytes;
+          prospectiveKeyBytes -= predecessor.contribution.keyBytes;
+          prospectiveStructureEntries -= predecessor.contribution.structureEntries;
+        } else prospectiveEntryCount += 1;
+        prospectiveEntryBytes += entry.jsonBytes;
+        prospectiveKeyBytes += entry.keyBytes;
+        prospectiveStructureEntries += entry.structureEntries;
+      }
+      const prospectiveJsonBytes =
+        2 + Math.max(0, prospectiveEntryCount - 1) + prospectiveEntryBytes;
+      if (
+        prospectiveJsonBytes > MAX_CONTEXT_JSON_BYTES ||
+        prospectiveKeyBytes > MAX_CONTEXT_ENCODED_KEY_BYTES ||
+        prospectiveStructureEntries > MAX_CONTEXT_STRUCTURE_ENTRIES
+      ) {
+        this.reportFailure(integrationId);
+        continue;
+      }
+      if (this.registrations.get(integrationId) !== record) continue;
+      for (const entry of contribution.entries) {
+        accepted.set(entry.key, Object.freeze({ contribution: entry, integrationId, record }));
+      }
+      acceptedEntryBytes = prospectiveEntryBytes;
+      acceptedKeyBytes = prospectiveKeyBytes;
+      acceptedStructureEntries = prospectiveStructureEntries;
+    }
+    try {
+      const output: Record<string, unknown> = {};
+      for (const [key, entry] of accepted) {
+        Object.defineProperty(output, key, {
+          configurable: true,
+          enumerable: true,
+          value: entry.contribution.value,
+          writable: true,
+        });
+      }
+      if (!this.runtimeIsCurrent()) return Object.freeze({});
+      for (const entry of accepted.values()) {
+        if (this.registrations.get(entry.integrationId) !== entry.record) {
+          return Object.freeze({});
+        }
+      }
+      return Object.freeze(output);
+    } catch {
+      return Object.freeze({});
+    }
+  }
+
+  public dispose(): void {
+    if (this.isDisposed) return;
+    this.isDisposed = true;
+    this.registrations.clear();
+  }
+
+  public snapshotInventoryForTest(): AuctionContextRegistryInventory {
+    return Object.freeze({
+      disposed: this.isDisposed,
+      registrations: Object.freeze(
+        this.manifestIntegrationIds.filter((id) => this.registrations.has(id))
+      ),
+    });
+  }
+
+  private runtimeIsCurrent(): boolean {
+    const generation = this.runtimeGeneration;
+    if (this.isDisposed || generation === undefined) return false;
+    return this.ownerIsCurrent(this.runtimeOwner, generation) && !this.isDisposed;
+  }
+
+  private ownerIsCurrent(owner: ContextContributorOwner, generation: object): boolean {
+    try {
+      return owner.generation === generation && owner.isCurrent();
+    } catch {
+      return false;
+    }
+  }
+
+  private snapshotCurrentOwnerGeneration(owner: ContextContributorOwner): object | undefined {
+    try {
+      const generation = owner.generation;
+      if (typeof generation !== 'object' || generation === null) return undefined;
+      return owner.isCurrent() ? generation : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private deleteRegistration(integrationId: string, record: ContributorRecord): void {
+    if (this.registrations.get(integrationId) === record) {
+      this.registrations.delete(integrationId);
+    }
+  }
+
+  private reportFailure(integrationId: string): void {
+    try {
+      this.onContributorFailure?.(Object.freeze({ integrationId, reason: 'contributor_failed' }));
+    } catch {
+      // Observational reporting cannot affect the remaining manifest contributors.
+    }
+  }
+}
+
+/** Construct one manifest-bounded, runtime-owned context contributor registry. */
+export function createAuctionContextRegistry(
+  options: AuctionContextRegistryOptions
+): AuctionContextRegistry {
+  return new AuctionContextRegistryOwner(options);
+}
diff --git a/crates/trusted-server-js/lib/src/services/projections.ts b/crates/trusted-server-js/lib/src/services/projections.ts
new file mode 100644
index 000000000..2199b211f
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/projections.ts
@@ -0,0 +1,200 @@
+import type { NavigationSession } from '../kernel/sessions';
+
+/** Shared maximum across server-projected and programmatically admitted slots. */
+export const MAX_ACTIVE_SLOT_RECORDS = 256;
+
+/** Exact projection parser injected by the composition root. */
+export type AuctionProjectionParser = (candidate: unknown) => object | undefined;
+
+/** A reversible reservation prepared without mutating the live slot registry. */
+export interface PreparedProjectionSlots {
+  readonly ownerGeneration: object;
+  readonly commit: () => boolean;
+  readonly rollback: () => void;
+}
+
+/** Exact slot identity and DOM aliases reserved with one admitted projection. */
+export interface ProjectionSlotRegistration {
+  readonly registeredSlotId: string;
+  readonly domAliases: readonly string[];
+}
+
+/** Slot-registry transaction boundary consumed by the page-bids controller. */
+export interface ProjectionSlotRegistry {
+  readonly prepareProjectionSlots: (
+    ownerGeneration: object,
+    slots: readonly ProjectionSlotRegistration[],
+    maximumActiveSlots: number
+  ) => PreparedProjectionSlots | undefined;
+}
+
+/** Result of one current-generation page-bids response. */
+export type PageBidsCommitResult =
+  | Readonly<{ status: 'committed' }>
+  | Readonly<{
+      status: 'rejected';
+      reason: 'capacity' | 'duplicate' | 'malformed' | 'stale';
+    }>;
+
+/** One-response controller bound to a single navigation generation. */
+export interface PageBidsController {
+  readonly commit: (candidate: unknown) => PageBidsCommitResult;
+}
+
+/** Dependencies for one navigation-bound page-bids controller. */
+export interface PageBidsControllerOptions {
+  readonly navigation: NavigationSession;
+  readonly parseProjection: AuctionProjectionParser;
+  readonly slotRegistry: ProjectionSlotRegistry;
+}
+
+const COMMITTED = Object.freeze({ status: 'committed' as const });
+const rejected = {
+  capacity: Object.freeze({ status: 'rejected' as const, reason: 'capacity' as const }),
+  duplicate: Object.freeze({ status: 'rejected' as const, reason: 'duplicate' as const }),
+  malformed: Object.freeze({ status: 'rejected' as const, reason: 'malformed' as const }),
+  stale: Object.freeze({ status: 'rejected' as const, reason: 'stale' as const }),
+};
+
+function recursivelyFreeze(value: unknown, visited = new Set<object>()): boolean {
+  if ((typeof value !== 'object' && typeof value !== 'function') || value === null) return true;
+  if (visited.has(value)) return true;
+  visited.add(value);
+  try {
+    for (const key of Reflect.ownKeys(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        !descriptor ||
+        !('value' in descriptor) ||
+        !recursivelyFreeze(descriptor.value, visited)
+      ) {
+        return false;
+      }
+    }
+    Object.freeze(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function projectedSlots(projection: object): readonly ProjectionSlotRegistration[] | undefined {
+  try {
+    const slotsDescriptor = Object.getOwnPropertyDescriptor(projection, 'slots');
+    if (!slotsDescriptor || !('value' in slotsDescriptor)) return undefined;
+    const projected = slotsDescriptor.value;
+    if (!Array.isArray(projected) || projected.length > MAX_ACTIVE_SLOT_RECORDS) return undefined;
+    const slots: ProjectionSlotRegistration[] = [];
+    const seen = new Set<string>();
+    for (const placement of projected) {
+      if (typeof placement !== 'object' || placement === null) return undefined;
+      const slotDescriptor = Object.getOwnPropertyDescriptor(placement, 'slot');
+      const divDescriptor = Object.getOwnPropertyDescriptor(placement, 'divId');
+      if (
+        !slotDescriptor ||
+        !('value' in slotDescriptor) ||
+        typeof slotDescriptor.value !== 'string' ||
+        !divDescriptor ||
+        !('value' in divDescriptor) ||
+        typeof divDescriptor.value !== 'string'
+      ) {
+        return undefined;
+      }
+      if (seen.has(slotDescriptor.value)) return undefined;
+      seen.add(slotDescriptor.value);
+      slots.push(
+        Object.freeze({
+          registeredSlotId: slotDescriptor.value,
+          domAliases: Object.freeze([divDescriptor.value]),
+        })
+      );
+    }
+    return Object.freeze(slots);
+  } catch {
+    return undefined;
+  }
+}
+
+function rollback(reservation: PreparedProjectionSlots): void {
+  try {
+    reservation.rollback();
+  } catch {
+    // Rollback is best-effort; a conforming slot transaction is reversibly prepared.
+  }
+}
+
+/** Parse, deep-copy through the injected parser, and recursively freeze initial boot input. */
+export function prepareInitialAuctionProjection(
+  candidate: unknown,
+  parseProjection: AuctionProjectionParser
+): Readonly<object> | undefined {
+  try {
+    const parsed = parseProjection(candidate);
+    if (!parsed || !recursivelyFreeze(parsed)) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Construct one transactional page-bids controller for a navigation generation. */
+export function createPageBidsController(options: PageBidsControllerOptions): PageBidsController {
+  const ownerGeneration = options.navigation.generation;
+  let didCommit = options.navigation.currentAuctionProjection !== undefined;
+
+  return Object.freeze({
+    commit(candidate: unknown): PageBidsCommitResult {
+      if (!options.navigation.isCurrent() || options.navigation.generation !== ownerGeneration) {
+        return rejected.stale;
+      }
+      if (didCommit || options.navigation.currentAuctionProjection !== undefined) {
+        return rejected.duplicate;
+      }
+
+      const projection = prepareInitialAuctionProjection(candidate, options.parseProjection);
+      if (!projection) return rejected.malformed;
+      const slots = projectedSlots(projection);
+      if (!slots) return rejected.malformed;
+      if (!options.navigation.isCurrent()) return rejected.stale;
+
+      let reservation: PreparedProjectionSlots | undefined;
+      try {
+        reservation = options.slotRegistry.prepareProjectionSlots(
+          ownerGeneration,
+          slots,
+          MAX_ACTIVE_SLOT_RECORDS
+        );
+      } catch {
+        return rejected.capacity;
+      }
+      if (!reservation || reservation.ownerGeneration !== ownerGeneration) {
+        if (reservation) rollback(reservation);
+        return rejected.capacity;
+      }
+      if (!options.navigation.isCurrent()) {
+        rollback(reservation);
+        return rejected.stale;
+      }
+
+      try {
+        if (!reservation.commit()) {
+          rollback(reservation);
+          return rejected.capacity;
+        }
+      } catch {
+        rollback(reservation);
+        return rejected.capacity;
+      }
+      if (!options.navigation.isCurrent()) {
+        rollback(reservation);
+        return rejected.stale;
+      }
+      if (!options.navigation.installAuctionProjection(projection)) {
+        rollback(reservation);
+        return options.navigation.isCurrent() ? rejected.duplicate : rejected.stale;
+      }
+      didCommit = true;
+      return COMMITTED;
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/services/puc_bridge.ts b/crates/trusted-server-js/lib/src/services/puc_bridge.ts
new file mode 100644
index 000000000..078909c8d
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/puc_bridge.ts
@@ -0,0 +1,1630 @@
+import type { MessagingAdapter, MessagingPort } from '../adapters/messaging';
+import { TSJS_MESSAGE_PROTOCOL_V1 } from '../kernel/contracts/message_protocol';
+import { PUC_DYNAMIC_OWNER } from '../kernel/contracts/puc_dynamic_owner';
+import type { IdentityGenerationResult } from '../kernel/identity';
+
+import type {
+  CommittedRenderArtifact,
+  RenderAttempt,
+  RenderFailureReason,
+  RenderOutcome,
+} from './render';
+import type { ApsSlotMountBinding, SlotService } from './slots';
+import type {
+  ReservationAttempt,
+  ReservationRecognition,
+  ReservationRenderSource,
+  ReservationService,
+} from './reservations';
+
+export { PUC_DYNAMIC_OWNER };
+
+interface CollapsedPucShellResizeInput {
+  readonly source: object;
+  readonly width: number;
+  readonly height: number;
+}
+
+const CLAIM_DEADLINE_MS = 3_000;
+const LIFECYCLE_TICKET_TTL_MS = 3_000;
+const MAX_DYNAMIC_OWNER_BYTES = 64 * 1_024;
+const MAX_OUTER_RESPONSE_BYTES = 72 * 1_024;
+const MAX_TICKET_DRAWS = 8;
+const MAX_TICKETS = 320;
+const RESERVATION_ID = /^r1_[A-Za-z0-9_-]{22}$/;
+const ATTEMPT_ID = /^a1_[A-Za-z0-9_-]{22}$/;
+const LIFECYCLE_TICKET = /^t1_[A-Za-z0-9_-]{22}$/;
+const textEncoder = new TextEncoder();
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+const mapGetIntrinsic = Map.prototype.get;
+const mapSetIntrinsic = Map.prototype.set;
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapClearIntrinsic = Map.prototype.clear;
+const mapEntriesIntrinsic = Map.prototype.entries;
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size')?.get as (
+  this: Map<unknown, unknown>
+) => number;
+const mapValuesIntrinsic = Map.prototype.values;
+const mapEntryIteratorNextIntrinsic = Object.getPrototypeOf(new Map().entries()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const mapIteratorNextIntrinsic = Object.getPrototypeOf(new Map().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const jsonStringifyIntrinsic = JSON.stringify;
+const objectFreezeIntrinsic = Object.freeze;
+
+interface PendingClaim {
+  readonly port: MessagingPort;
+  readonly source: object;
+}
+
+export interface PucRenderAttempt {
+  readonly id: string;
+  readonly slot: string;
+  readonly generation: object;
+  readonly navigationGeneration: object;
+  readonly renderSource: ReservationRenderSource | undefined;
+  readonly beginGamClaim: () => boolean;
+  readonly admitClaimedWinner: (claim: unknown) => boolean;
+  readonly ownerClaimed: () => boolean;
+  readonly ownerRegistered: () => boolean;
+  readonly beginApsDocument: (artifact: CommittedRenderArtifact) => boolean;
+  readonly beginAdm: (artifact: CommittedRenderArtifact) => boolean;
+  readonly apsDocumentAccepted: () => boolean;
+  readonly accept: () => boolean;
+  readonly cancel: (reason: 'caller_aborted' | 'superseded' | 'navigation_disposed') => boolean;
+  readonly fail: (reason: RenderFailureReason) => boolean;
+  readonly onSettled: (callback: (outcome: RenderOutcome) => void) => boolean;
+  readonly snapshot: () => Readonly<{
+    state: string;
+    outcome: Readonly<object> | undefined;
+  }>;
+}
+
+export interface PucGamAttemptInput {
+  readonly attempt: PucRenderAttempt;
+  readonly artifact: CommittedRenderArtifact;
+  readonly owner: ReservationAttempt &
+    Readonly<{ generation: object; navigationGeneration: object }>;
+  readonly reservationId: string;
+}
+
+export interface PucBridgeScheduler {
+  readonly set: (callback: () => void, milliseconds: number) => unknown;
+  readonly clear: (handle: unknown) => void;
+}
+
+export interface PucBridgeOptions {
+  readonly messaging: MessagingAdapter;
+  readonly reservations: Pick<ReservationService, 'claim' | 'recognize'> &
+    Partial<Pick<ReservationService, 'tombstone'>>;
+  readonly mintLifecycleTicket: () => IdentityGenerationResult<string>;
+  readonly mountAps?: (input: PucApsMountInput) => boolean;
+  readonly now?: () => number;
+  readonly resizeCollapsedShell?: (input: CollapsedPucShellResizeInput) => boolean;
+  readonly slots?: Pick<SlotService, 'resolveApsMountBinding'>;
+  readonly scheduler?: PucBridgeScheduler;
+}
+
+export interface PucApsMountInput {
+  readonly attempt: RenderAttempt;
+  readonly baseArtifact: CommittedRenderArtifact;
+  readonly bindArtifact: ApsSlotMountBinding['bindArtifact'];
+  readonly container: HTMLElement;
+  readonly isBindingCurrent: () => boolean;
+  readonly messaging: MessagingAdapter;
+  readonly onArtifactTransferred: () => void;
+}
+
+export interface PucBridgeInventory {
+  readonly attempts: number;
+  readonly disposed: boolean;
+  readonly liveTickets: number;
+  readonly pendingClaims: number;
+  readonly ticketTombstones: number;
+}
+
+export interface PucBridge {
+  adoptFirstDisplayTickets(
+    input: Readonly<{
+      clockEpochMs: number;
+      nextTicketOrdinal: number;
+      tombstones: readonly Readonly<{ expiresAtMs: number; ticket: string }>[];
+    }>
+  ): boolean;
+  registerGamAttempt(input: PucGamAttemptInput): boolean;
+  recordNonemptyGam(input: PucGamAttemptInput): boolean;
+  dispose(): void;
+  snapshotInventoryForTest(): PucBridgeInventory;
+}
+
+interface GamAttemptBinding {
+  readonly reservationId: string;
+  readonly attempt: PucRenderAttempt;
+  readonly artifact: CommittedRenderArtifact;
+  readonly owner: PucGamAttemptInput['owner'];
+  readonly attemptId: string;
+  readonly slot: string;
+  readonly navigationGeneration: object;
+  artifactOwned: boolean;
+  active: boolean;
+  claim: PendingClaim | undefined;
+  claimDeadlineHandle: unknown;
+  claimDeadlineToken: object | undefined;
+  controlListenerDispose: (() => void) | undefined;
+  controlPort: MessagingPort | undefined;
+  controlStarted: boolean;
+  gamReady: boolean;
+  joining: boolean;
+  lifecycleTicket: string | undefined;
+  ownerInserted: boolean;
+  pucSource: object | undefined;
+  ticket: string | undefined;
+}
+
+interface LiveTicket {
+  readonly state: 'live';
+  readonly binding: GamAttemptBinding;
+  readonly expiresAt: number;
+  expiryHandle: unknown;
+}
+
+interface PendingTicket {
+  readonly state: 'pending';
+  readonly binding: GamAttemptBinding;
+}
+
+interface TicketTombstone {
+  readonly state: 'tombstone';
+  readonly expiresAt: number;
+  expiryHandle: unknown;
+}
+
+type TicketEntry = LiveTicket | PendingTicket | TicketTombstone;
+
+function mapValue<Key, Value>(map: Map<Key, Value>, key: Key): Value | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setMapValue<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void {
+  Reflect.apply(mapSetIntrinsic, map, [key, value]);
+}
+
+function deleteMapValue<Key, Value>(map: Map<Key, Value>, key: Key): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function mapSize<Key, Value>(map: Map<Key, Value>): number {
+  return Reflect.apply(mapSizeGetter, map, []) as number;
+}
+
+function snapshotMapEntries<Key, Value>(map: Map<Key, Value>): readonly [Key, Value][] {
+  const iterator = Reflect.apply(mapEntriesIntrinsic, map, []) as IterableIterator<[Key, Value]>;
+  const entries: Array<[Key, Value]> = [];
+  while (true) {
+    const step = Reflect.apply(mapEntryIteratorNextIntrinsic, iterator, []) as IteratorResult<
+      [Key, Value]
+    >;
+    if (step.done) return entries;
+    entries[entries.length] = step.value;
+  }
+}
+
+function snapshotMapValues<Key, Value>(map: Map<Key, Value>): readonly Value[] {
+  const iterator = Reflect.apply(mapValuesIntrinsic, map, []) as IterableIterator<Value>;
+  const values: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(mapIteratorNextIntrinsic, iterator, []) as IteratorResult<Value>;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function frozen<Value extends object>(value: Value): Readonly<Value> {
+  return Reflect.apply(objectFreezeIntrinsic, Object, [value]) as Readonly<Value>;
+}
+
+function utf8Length(value: string): number {
+  return (Reflect.apply(textEncoderEncodeIntrinsic, textEncoder, [value]) as Uint8Array).byteLength;
+}
+
+function defaultNow(): number {
+  return Date.now();
+}
+
+function defaultScheduler(): PucBridgeScheduler {
+  return frozen({
+    set: (callback: () => void, milliseconds: number): unknown =>
+      globalThis.setTimeout(callback, milliseconds),
+    clear: (handle: unknown): void => {
+      globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>);
+    },
+  });
+}
+
+function validTicket(value: unknown): value is string {
+  return typeof value === 'string' && LIFECYCLE_TICKET.test(value);
+}
+
+function readMintedTicket(value: unknown): string | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || !Object.isFrozen(value)) return undefined;
+    if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = Object.getOwnPropertyNames(value).sort();
+    const ok = Object.getOwnPropertyDescriptor(value, 'ok');
+    if (!ok || !ok.enumerable || !('value' in ok)) return undefined;
+    if (ok.value === true && names.length === 2 && names[0] === 'ok' && names[1] === 'value') {
+      const ticket = Object.getOwnPropertyDescriptor(value, 'value');
+      return ticket && ticket.enumerable && 'value' in ticket && validTicket(ticket.value)
+        ? ticket.value
+        : undefined;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function recognizedReservation(
+  reservations: Pick<ReservationService, 'recognize'>,
+  reservationId: string
+): ReservationRecognition | undefined {
+  try {
+    return reservations.recognize(reservationId);
+  } catch {
+    return undefined;
+  }
+}
+
+function suppress(event: unknown): boolean {
+  try {
+    if (typeof event !== 'object' || event === null) return false;
+    const stop = Reflect.get(event, 'stopImmediatePropagation');
+    if (typeof stop !== 'function') return false;
+    Reflect.apply(stop, event, []);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function eventData(event: unknown): unknown {
+  try {
+    return typeof event === 'object' && event !== null ? Reflect.get(event, 'data') : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function eventSource(event: unknown): object | undefined {
+  try {
+    if (typeof event !== 'object' || event === null) return undefined;
+    const source = Reflect.get(event, 'source');
+    return (typeof source === 'object' || typeof source === 'function') && source !== null
+      ? source
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function refusedResponse(adId: string): string | undefined {
+  try {
+    const owner = Object.create(null) as Record<string, unknown>;
+    owner['version'] = 1;
+    owner['status'] = TSJS_MESSAGE_PROTOCOL_V1.status.refused;
+    const response = Object.create(null) as Record<string, unknown>;
+    response['message'] = TSJS_MESSAGE_PROTOCOL_V1.message.prebidResponse;
+    response['adId'] = adId;
+    response['rendererVersion'] = TSJS_MESSAGE_PROTOCOL_V1.rendererVersion;
+    response['tsOwner'] = owner;
+    const serialized = Reflect.apply(jsonStringifyIntrinsic, JSON, [response]) as unknown;
+    return typeof serialized === 'string' ? serialized : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function refuse(port: MessagingPort, adId: string): void {
+  try {
+    const response = refusedResponse(adId);
+    if (response !== undefined) port.post(response, []);
+  } catch {
+    // Refusal transport is best-effort; endpoint closure remains mandatory.
+  } finally {
+    try {
+      port.close();
+    } catch {
+      // The adapter contains raw close failures, but keep this boundary fail-closed.
+    }
+  }
+}
+
+function closePort(port: MessagingPort): void {
+  try {
+    port.close();
+  } catch {
+    // The adapter facade contains raw close failures and is exact-once.
+  }
+}
+
+function closeChannel(
+  channel: Readonly<{ retained: MessagingPort; transferred: MessagingPort }>
+): void {
+  closePort(channel.retained);
+  closePort(channel.transferred);
+}
+
+function readyResponse(
+  adId: string,
+  dynamicOwner: string,
+  kind: 'aps' | 'adm',
+  lifecycleTicket: string
+): string | undefined {
+  try {
+    const owner = Object.create(null) as Record<string, unknown>;
+    owner['version'] = 1;
+    owner['status'] = TSJS_MESSAGE_PROTOCOL_V1.status.ready;
+    owner['kind'] = kind;
+    owner['lifecycleTicket'] = lifecycleTicket;
+    const response = Object.create(null) as Record<string, unknown>;
+    response['message'] = TSJS_MESSAGE_PROTOCOL_V1.message.prebidResponse;
+    response['adId'] = adId;
+    response['renderer'] = dynamicOwner;
+    response['rendererVersion'] = TSJS_MESSAGE_PROTOCOL_V1.rendererVersion;
+    response['tsOwner'] = owner;
+    const serialized = Reflect.apply(jsonStringifyIntrinsic, JSON, [response]) as unknown;
+    return typeof serialized === 'string' && utf8Length(serialized) <= MAX_OUTER_RESPONSE_BYTES
+      ? serialized
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownerResponse(adId: string, lifecycleTicket: string | undefined): string | undefined {
+  try {
+    const response = Object.create(null) as Record<string, unknown>;
+    response['message'] =
+      lifecycleTicket === undefined
+        ? TSJS_MESSAGE_PROTOCOL_V1.message.ownerRefused
+        : TSJS_MESSAGE_PROTOCOL_V1.message.ownerRegistered;
+    response['adId'] = adId;
+    response['version'] = 1;
+    if (lifecycleTicket !== undefined) response['lifecycleTicket'] = lifecycleTicket;
+    const serialized = Reflect.apply(jsonStringifyIntrinsic, JSON, [response]) as unknown;
+    return typeof serialized === 'string' ? serialized : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function ownerSettlement(
+  lifecycleTicket: string,
+  outcome: RenderOutcome
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const message = Object.create(null) as Record<string, unknown>;
+    message['message'] = TSJS_MESSAGE_PROTOCOL_V1.message.ownerSettled;
+    message['version'] = 1;
+    message['lifecycleTicket'] = lifecycleTicket;
+    if (outcome.outcome === 'accepted') {
+      message['outcome'] = TSJS_MESSAGE_PROTOCOL_V1.outcome.accepted;
+      return frozen(message);
+    }
+    if (outcome.outcome === 'failed') {
+      message['outcome'] = TSJS_MESSAGE_PROTOCOL_V1.outcome.failed;
+      message['reason'] = outcome.reason;
+      return frozen(message);
+    }
+    if (outcome.outcome === 'cancelled') {
+      message['outcome'] = TSJS_MESSAGE_PROTOCOL_V1.outcome.cancelled;
+      message['reason'] = outcome.reason;
+      return frozen(message);
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function refuseOwner(port: MessagingPort, adId: string): void {
+  try {
+    const response = ownerResponse(adId, undefined);
+    if (response !== undefined) port.post(response, []);
+  } catch {
+    // Refusal transport is best-effort; endpoint closure remains mandatory.
+  } finally {
+    closePort(port);
+  }
+}
+
+/**
+ * Own the runtime-wide Universal Creative capture dispatcher.
+ *
+ * Request recognition deliberately precedes exact parsing and port inspection so
+ * malformed or replayed TS capabilities cannot fall through to native Prebid.
+ */
+export function createPucBridge(options: PucBridgeOptions): PucBridge {
+  let messaging: MessagingAdapter;
+  let reservations: PucBridgeOptions['reservations'];
+  let mintLifecycleTicket: () => IdentityGenerationResult<string>;
+  let nowSource: () => number;
+  let mountAps: PucBridgeOptions['mountAps'];
+  let slots: PucBridgeOptions['slots'];
+  let resizeCollapsedShell: PucBridgeOptions['resizeCollapsedShell'];
+  let scheduler: PucBridgeScheduler;
+  try {
+    messaging = options.messaging;
+    reservations = options.reservations;
+    mintLifecycleTicket = options.mintLifecycleTicket;
+    nowSource = options.now ?? defaultNow;
+    mountAps = options.mountAps;
+    slots = options.slots;
+    resizeCollapsedShell = options.resizeCollapsedShell;
+    scheduler = options.scheduler ?? defaultScheduler();
+  } catch {
+    messaging = options.messaging;
+    reservations = options.reservations;
+    mintLifecycleTicket = () => frozen({ ok: false, reason: 'identity_generation_failed' });
+    nowSource = () => Number.NaN;
+    mountAps = undefined;
+    slots = undefined;
+    resizeCollapsedShell = undefined;
+    scheduler = defaultScheduler();
+  }
+  let schedulerSet: PucBridgeScheduler['set'];
+  let schedulerClear: PucBridgeScheduler['clear'];
+  try {
+    schedulerSet = scheduler.set;
+    schedulerClear = scheduler.clear;
+  } catch {
+    schedulerSet = () => undefined;
+    schedulerClear = () => undefined;
+  }
+  const dynamicOwnerValid = utf8Length(PUC_DYNAMIC_OWNER) <= MAX_DYNAMIC_OWNER_BYTES;
+  const attempts = new Map<string, GamAttemptBinding>();
+  const tickets = new Map<string, TicketEntry>();
+  let pendingTicketIssues = 0;
+  let ticketAdoptionOpen = true;
+  let ticketOrdinalHighWater = 1;
+  let lastNow = Number.NEGATIVE_INFINITY;
+  let disposed = false;
+
+  const readNow = (): number | undefined => {
+    try {
+      const value = Reflect.apply(nowSource, undefined, []) as number;
+      if (!Number.isFinite(value) || value < 0 || value < lastNow) return undefined;
+      lastNow = value;
+      return value;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const clearScheduled = (handle: unknown): void => {
+    if (handle === undefined) return;
+    try {
+      Reflect.apply(schedulerClear, scheduler, [handle]);
+    } catch {
+      // Timer cleanup is best-effort after state is already made inert.
+    }
+  };
+
+  const exactInput = (input: PucGamAttemptInput): PucGamAttemptInput | undefined => {
+    try {
+      const reservationId = input.reservationId;
+      const attempt = input.attempt;
+      const artifact = input.artifact;
+      const owner = input.owner;
+      if (
+        typeof reservationId !== 'string' ||
+        !RESERVATION_ID.test(reservationId) ||
+        !ATTEMPT_ID.test(attempt.id) ||
+        attempt.id !== owner.id ||
+        attempt.slot !== owner.slot ||
+        attempt.generation !== owner.generation ||
+        attempt.navigationGeneration !== owner.navigationGeneration ||
+        artifact.kind !== 'puc' ||
+        artifact.attemptId !== attempt.id ||
+        artifact.slot !== owner.slot ||
+        artifact.navigationGeneration !== owner.navigationGeneration ||
+        typeof artifact.dispose !== 'function' ||
+        typeof attempt.beginGamClaim !== 'function' ||
+        typeof attempt.admitClaimedWinner !== 'function' ||
+        typeof attempt.ownerClaimed !== 'function' ||
+        typeof attempt.ownerRegistered !== 'function' ||
+        typeof attempt.beginApsDocument !== 'function' ||
+        typeof attempt.beginAdm !== 'function' ||
+        typeof attempt.apsDocumentAccepted !== 'function' ||
+        typeof attempt.accept !== 'function' ||
+        typeof attempt.cancel !== 'function' ||
+        typeof attempt.fail !== 'function' ||
+        typeof attempt.onSettled !== 'function' ||
+        typeof attempt.snapshot !== 'function' ||
+        typeof owner.isCurrent !== 'function' ||
+        typeof owner.prepareWinnerContext !== 'function'
+      ) {
+        return undefined;
+      }
+      return frozen({ reservationId, attempt, artifact, owner });
+    } catch {
+      return undefined;
+    }
+  };
+
+  const bindingMatches = (binding: GamAttemptBinding, input: PucGamAttemptInput): boolean =>
+    binding.active &&
+    binding.reservationId === input.reservationId &&
+    binding.attempt === input.attempt &&
+    binding.artifact === input.artifact &&
+    binding.owner === input.owner &&
+    binding.attemptId === input.attempt.id &&
+    binding.slot === input.owner.slot &&
+    binding.navigationGeneration === input.owner.navigationGeneration;
+
+  const currentBindingState = (binding: GamAttemptBinding, expectedState: string): boolean => {
+    try {
+      const snapshot = Reflect.apply(binding.attempt.snapshot, binding.attempt, []);
+      return (
+        binding.active &&
+        mapValue(attempts, binding.reservationId) === binding &&
+        binding.attempt.id === binding.attemptId &&
+        binding.attempt.slot === binding.slot &&
+        binding.attempt.navigationGeneration === binding.navigationGeneration &&
+        binding.owner.id === binding.attemptId &&
+        binding.owner.slot === binding.slot &&
+        binding.owner.navigationGeneration === binding.navigationGeneration &&
+        Reflect.apply(binding.owner.isCurrent, binding.owner, []) === true &&
+        snapshot.outcome === undefined &&
+        snapshot.state === expectedState
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const tombstoneReservation = (binding: GamAttemptBinding): void => {
+    try {
+      const tombstone = reservations.tombstone;
+      if (typeof tombstone !== 'function') return;
+      Reflect.apply(tombstone, reservations, [
+        frozen({
+          reservationId: binding.reservationId,
+          slot: binding.slot,
+          navigationGeneration: binding.navigationGeneration,
+          attemptId: binding.attemptId,
+        }),
+        'stale',
+      ]);
+    } catch {
+      // Attempt settlement stays authoritative if suppression publication fails.
+    }
+  };
+
+  const retireTicket = (binding: GamAttemptBinding): void => {
+    const ticket = binding.ticket;
+    if (!ticket) return;
+    const entry = mapValue(tickets, ticket);
+    if (entry?.state === 'live' && entry.binding === binding) {
+      clearScheduled(entry.expiryHandle);
+      const tombstone: TicketTombstone = {
+        state: 'tombstone',
+        expiresAt: entry.expiresAt,
+        expiryHandle: undefined,
+      };
+      setMapValue(tickets, ticket, tombstone);
+      const retiredAt = readNow();
+      if (retiredAt !== undefined && retiredAt >= tombstone.expiresAt) {
+        expireTicket(ticket, tombstone, retiredAt);
+      } else if (retiredAt !== undefined) {
+        let handle: unknown;
+        try {
+          handle = Reflect.apply(schedulerSet, scheduler, [
+            () => expireTicket(ticket, tombstone),
+            tombstone.expiresAt - retiredAt,
+          ]);
+        } catch {
+          handle = undefined;
+        }
+        if (mapValue(tickets, ticket) !== tombstone) clearScheduled(handle);
+        else tombstone.expiryHandle = handle;
+      }
+    } else if (entry?.state === 'pending' && entry.binding === binding) {
+      const retiredAt = readNow();
+      if (retiredAt === undefined) {
+        deleteMapValue(tickets, ticket);
+      } else {
+        const tombstone: TicketTombstone = {
+          state: 'tombstone',
+          expiresAt: retiredAt + LIFECYCLE_TICKET_TTL_MS,
+          expiryHandle: undefined,
+        };
+        setMapValue(tickets, ticket, tombstone);
+        let handle: unknown;
+        try {
+          handle = Reflect.apply(schedulerSet, scheduler, [
+            () => expireTicket(ticket, tombstone),
+            LIFECYCLE_TICKET_TTL_MS,
+          ]);
+        } catch {
+          handle = undefined;
+        }
+        if (mapValue(tickets, ticket) !== tombstone) {
+          clearScheduled(handle);
+        } else {
+          tombstone.expiryHandle = handle;
+        }
+      }
+    }
+    binding.ticket = undefined;
+  };
+
+  const clearClaimDeadline = (binding: GamAttemptBinding): void => {
+    const handle = binding.claimDeadlineHandle;
+    binding.claimDeadlineHandle = undefined;
+    binding.claimDeadlineToken = undefined;
+    clearScheduled(handle);
+  };
+
+  const disposeOwnedArtifact = (binding: GamAttemptBinding): void => {
+    if (!binding.artifactOwned) return;
+    binding.artifactOwned = false;
+    try {
+      Reflect.apply(binding.artifact.dispose, binding.artifact, []);
+    } catch {
+      // The bridge has already relinquished authority; disposal remains exact-once.
+    }
+  };
+
+  const cleanupBinding = (binding: GamAttemptBinding): void => {
+    if (!binding.active) return;
+    binding.active = false;
+    binding.joining = false;
+    disposeOwnedArtifact(binding);
+    clearClaimDeadline(binding);
+    if (mapValue(attempts, binding.reservationId) === binding) {
+      deleteMapValue(attempts, binding.reservationId);
+    }
+    const claim = binding.claim;
+    binding.claim = undefined;
+    if (claim) closePort(claim.port);
+    const disposeControlListener = binding.controlListenerDispose;
+    binding.controlListenerDispose = undefined;
+    if (disposeControlListener) {
+      try {
+        disposeControlListener();
+      } catch {
+        // Listener disposal is best-effort after the binding is already inert.
+      }
+    }
+    const controlPort = binding.controlPort;
+    binding.controlPort = undefined;
+    if (controlPort) closePort(controlPort);
+    binding.lifecycleTicket = undefined;
+    binding.pucSource = undefined;
+    retireTicket(binding);
+    tombstoneReservation(binding);
+  };
+
+  const failBinding = (
+    binding: GamAttemptBinding,
+    reason: RenderFailureReason,
+    refusePending: boolean
+  ): void => {
+    if (!binding.active) return;
+    if (binding.controlPort && binding.lifecycleTicket) {
+      try {
+        Reflect.apply(binding.attempt.fail, binding.attempt, [reason]);
+      } catch {
+        // The binding cleanup below remains authoritative.
+      }
+      if (binding.active) cleanupBinding(binding);
+      return;
+    }
+    const claim = binding.claim;
+    binding.claim = undefined;
+    if (claim) {
+      if (refusePending) refuse(claim.port, binding.reservationId);
+      else closePort(claim.port);
+    }
+    cleanupBinding(binding);
+    try {
+      Reflect.apply(binding.attempt.fail, binding.attempt, [reason]);
+    } catch {
+      // The binding is already inert and all owned endpoints are closed.
+    }
+  };
+
+  const settleBinding = (binding: GamAttemptBinding, outcome: RenderOutcome): void => {
+    if (!binding.active) return;
+    const controlPort = binding.controlPort;
+    const lifecycleTicket = binding.lifecycleTicket;
+    if (controlPort && lifecycleTicket) {
+      const settlement = ownerSettlement(lifecycleTicket, outcome);
+      if (settlement) {
+        try {
+          controlPort.post(settlement, []);
+        } catch {
+          // The remote owner's fixed watchdog contains settlement transport loss.
+        }
+      }
+    }
+    cleanupBinding(binding);
+  };
+
+  const expireTicket = (
+    ticket: string,
+    expected: LiveTicket | TicketTombstone,
+    observedAt?: number
+  ): void => {
+    const entry = mapValue(tickets, ticket);
+    if (entry !== expected) return;
+    const now = observedAt ?? readNow();
+    if (now === undefined || now < expected.expiresAt) return;
+    deleteMapValue(tickets, ticket);
+    if (entry.state === 'live') {
+      entry.binding.ticket = undefined;
+      if (entry.binding.active) {
+        failBinding(entry.binding, 'owner_registration_timeout', false);
+      }
+    }
+  };
+
+  const pruneExpiredTickets = (now: number): void => {
+    const entries = snapshotMapEntries(tickets);
+    for (let index = 0; index < entries.length; index += 1) {
+      const pair = entries[index];
+      if (
+        pair &&
+        pair[1].state !== 'pending' &&
+        pair[1].expiresAt <= now &&
+        mapValue(tickets, pair[0]) === pair[1]
+      ) {
+        clearScheduled(pair[1].expiryHandle);
+        expireTicket(pair[0], pair[1], now);
+      }
+    }
+  };
+
+  const issueTicket = (
+    binding: GamAttemptBinding
+  ):
+    | Readonly<{ ok: true; ticket: string }>
+    | Readonly<{ ok: false; reason: RenderFailureReason }> => {
+    const failure = (
+      reason: RenderFailureReason
+    ): Readonly<{ ok: false; reason: RenderFailureReason }> =>
+      frozen({ ok: false as const, reason });
+    const pruneAt = readNow();
+    if (pruneAt === undefined) return failure('identity_generation_failed');
+    pruneExpiredTickets(pruneAt);
+    if (mapSize(tickets) + pendingTicketIssues >= MAX_TICKETS) {
+      return failure('capability_registry_full');
+    }
+    pendingTicketIssues += 1;
+    try {
+      for (let draw = 0; draw < MAX_TICKET_DRAWS; draw += 1) {
+        let minted: unknown;
+        try {
+          minted = Reflect.apply(mintLifecycleTicket, undefined, []);
+        } catch {
+          return failure('identity_generation_failed');
+        }
+        const ticket = readMintedTicket(minted);
+        if (!binding.active || disposed) {
+          return failure('internal_error');
+        }
+        if (!ticket) return failure('identity_generation_failed');
+        if (mapValue(tickets, ticket) !== undefined) continue;
+        if (mapSize(tickets) + pendingTicketIssues > MAX_TICKETS) {
+          return failure('capability_registry_full');
+        }
+        const entry = frozen<PendingTicket>({ state: 'pending', binding });
+        binding.ticket = ticket;
+        setMapValue(tickets, ticket, entry);
+        if (!binding.active || mapValue(tickets, ticket) !== entry || binding.ticket !== ticket) {
+          if (mapValue(tickets, ticket) === entry) deleteMapValue(tickets, ticket);
+          if (binding.ticket === ticket) binding.ticket = undefined;
+          return failure('internal_error');
+        }
+        return frozen({ ok: true, ticket });
+      }
+      return failure('identity_generation_failed');
+    } finally {
+      pendingTicketIssues -= 1;
+    }
+  };
+
+  const activateTicket = (binding: GamAttemptBinding, ticket: string): boolean => {
+    const pending = mapValue(tickets, ticket);
+    const postedAt = readNow();
+    if (
+      pending?.state !== 'pending' ||
+      pending.binding !== binding ||
+      binding.ticket !== ticket ||
+      postedAt === undefined
+    ) {
+      return false;
+    }
+    const expiresAt = postedAt + LIFECYCLE_TICKET_TTL_MS;
+    if (!Number.isFinite(expiresAt) || expiresAt <= postedAt) return false;
+    const live: LiveTicket = {
+      state: 'live',
+      binding,
+      expiresAt,
+      expiryHandle: undefined,
+    };
+    setMapValue(tickets, ticket, live);
+    let expiryHandle: unknown;
+    try {
+      expiryHandle = Reflect.apply(schedulerSet, scheduler, [
+        () => expireTicket(ticket, live),
+        LIFECYCLE_TICKET_TTL_MS,
+      ]);
+    } catch {
+      expiryHandle = undefined;
+    }
+    if (
+      expiryHandle === undefined ||
+      !binding.active ||
+      mapValue(tickets, ticket) !== live ||
+      binding.ticket !== ticket
+    ) {
+      clearScheduled(expiryHandle);
+      if (binding.active && binding.ticket === ticket && mapValue(tickets, ticket) === live) {
+        setMapValue(tickets, ticket, pending);
+      } else {
+        if (mapValue(tickets, ticket) === live) deleteMapValue(tickets, ticket);
+        if (binding.ticket === ticket) binding.ticket = undefined;
+      }
+      return false;
+    }
+    live.expiryHandle = expiryHandle;
+    return true;
+  };
+
+  const join = (binding: GamAttemptBinding): boolean => {
+    if (
+      !binding.active ||
+      !binding.gamReady ||
+      !binding.claim ||
+      binding.joining ||
+      !currentBindingState(binding, 'waiting_for_gam_and_claim')
+    ) {
+      return false;
+    }
+    binding.joining = true;
+    clearClaimDeadline(binding);
+    const pending = binding.claim;
+    try {
+      let claimed: unknown;
+      try {
+        claimed = Reflect.apply(reservations.claim, reservations, [
+          frozen({
+            reservationId: binding.reservationId,
+            slot: binding.slot,
+            navigationGeneration: binding.navigationGeneration,
+            attempt: binding.owner,
+            pucSource: pending.source,
+          }),
+        ]);
+      } catch {
+        claimed = undefined;
+      }
+      let claimedSuccessfully = false;
+      try {
+        claimedSuccessfully =
+          typeof claimed === 'object' &&
+          claimed !== null &&
+          (claimed as { recognized?: unknown }).recognized === true &&
+          (claimed as { claimed?: unknown }).claimed === true;
+      } catch {
+        claimedSuccessfully = false;
+      }
+      if (
+        !claimedSuccessfully ||
+        Reflect.apply(binding.attempt.admitClaimedWinner, binding.attempt, [claimed]) !== true ||
+        Reflect.apply(binding.attempt.ownerClaimed, binding.attempt, []) !== true ||
+        !currentBindingState(binding, 'waiting_for_owner')
+      ) {
+        failBinding(binding, 'bridge_id_mismatch', true);
+        return false;
+      }
+      binding.pucSource = pending.source;
+      let kind: 'aps' | 'adm';
+      try {
+        const sourceType = binding.attempt.renderSource?.type;
+        if (sourceType === 'aps') kind = 'aps';
+        else if (sourceType === 'adm') kind = 'adm';
+        else throw new Error('claimed source is unavailable');
+      } catch {
+        failBinding(binding, 'bridge_id_mismatch', true);
+        return false;
+      }
+      const issued = issueTicket(binding);
+      if (!issued.ok) {
+        failBinding(binding, issued.reason, true);
+        return false;
+      }
+      const response = readyResponse(binding.reservationId, PUC_DYNAMIC_OWNER, kind, issued.ticket);
+      if (!response) {
+        failBinding(binding, 'internal_error', true);
+        return false;
+      }
+      binding.claim = undefined;
+      let posted = false;
+      try {
+        posted = pending.port.post(response, []) === true;
+      } catch {
+        posted = false;
+      }
+      closePort(pending.port);
+      if (!posted || !binding.active || !activateTicket(binding, issued.ticket)) {
+        if (binding.active) failBinding(binding, 'internal_error', false);
+        return false;
+      }
+      if (resizeCollapsedShell && currentBindingState(binding, 'waiting_for_owner')) {
+        try {
+          const renderSource = binding.attempt.renderSource;
+          const width = renderSource && Reflect.get(renderSource, 'width');
+          const height = renderSource && Reflect.get(renderSource, 'height');
+          if (
+            typeof width === 'number' &&
+            typeof height === 'number' &&
+            Number.isFinite(width) &&
+            Number.isFinite(height) &&
+            width > 0 &&
+            height > 0
+          ) {
+            Reflect.apply(resizeCollapsedShell, undefined, [
+              frozen({
+                source: pending.source,
+                width,
+                height,
+              }),
+            ]);
+          }
+        } catch {
+          // Shell correction is best-effort and cannot affect render authority.
+        }
+      }
+      return true;
+    } finally {
+      if (binding.active) binding.joining = false;
+    }
+  };
+
+  const armClaimDeadline = (binding: GamAttemptBinding): boolean => {
+    if (!binding.active || binding.claimDeadlineToken !== undefined) return false;
+    const token = frozen({});
+    binding.claimDeadlineToken = token;
+    let handle: unknown;
+    try {
+      handle = Reflect.apply(schedulerSet, scheduler, [
+        () => {
+          if (binding.claimDeadlineToken !== token) return;
+          binding.claimDeadlineToken = undefined;
+          binding.claimDeadlineHandle = undefined;
+          if (
+            binding.active &&
+            binding.gamReady &&
+            !binding.claim &&
+            currentBindingState(binding, 'waiting_for_gam_and_claim')
+          ) {
+            failBinding(binding, 'bridge_claim_timeout', false);
+          }
+        },
+        CLAIM_DEADLINE_MS,
+      ]);
+    } catch {
+      handle = undefined;
+    }
+    if (handle === undefined || !binding.active || binding.claimDeadlineToken !== token) {
+      clearScheduled(handle);
+      if (binding.active && binding.claimDeadlineToken === token) {
+        binding.claimDeadlineToken = undefined;
+        failBinding(binding, 'internal_error', false);
+      }
+      return false;
+    }
+    binding.claimDeadlineHandle = handle;
+    return true;
+  };
+
+  const startAdmOwner = (binding: GamAttemptBinding, lifecycleTicket: string): boolean => {
+    const controlPort = binding.controlPort;
+    if (!controlPort || binding.controlStarted || !binding.active) return false;
+    let source: unknown;
+    try {
+      source = binding.attempt.renderSource;
+    } catch {
+      source = undefined;
+    }
+    const start = messaging.parseProtocolMessage('admStart', {
+      message: TSJS_MESSAGE_PROTOCOL_V1.message.admStart,
+      version: 1,
+      lifecycleTicket,
+      source,
+    });
+    if (!start) {
+      failBinding(binding, 'winner_not_renderable', false);
+      return false;
+    }
+    const receive = (event: unknown): void => {
+      if (!binding.active || binding.controlPort !== controlPort || !binding.controlStarted) return;
+      if (!messaging.extractTransferredPorts(event, 0)) {
+        failBinding(binding, 'internal_error', false);
+        return;
+      }
+      const data = eventData(event);
+      const inserted = messaging.parseProtocolMessage('ownerInserted', data);
+      if (inserted?.['lifecycleTicket'] === lifecycleTicket) {
+        if (binding.ownerInserted) return;
+        binding.artifactOwned = false;
+        const began = (() => {
+          try {
+            return (
+              Reflect.apply(binding.attempt.beginAdm, binding.attempt, [binding.artifact]) === true
+            );
+          } catch {
+            return false;
+          }
+        })();
+        if (!began) {
+          if (binding.active) binding.artifactOwned = true;
+          failBinding(binding, 'internal_error', false);
+          return;
+        }
+        binding.ownerInserted = true;
+        return;
+      }
+      const loaded = messaging.parseProtocolMessage('admLoaded', data);
+      if (loaded?.['lifecycleTicket'] === lifecycleTicket) {
+        if (!binding.ownerInserted) {
+          failBinding(binding, 'adm_document_no_load', false);
+          return;
+        }
+        const accepted = (() => {
+          try {
+            return Reflect.apply(binding.attempt.accept, binding.attempt, []) === true;
+          } catch {
+            return false;
+          }
+        })();
+        if (!accepted && binding.active) failBinding(binding, 'internal_error', false);
+        return;
+      }
+      const failed = messaging.parseProtocolMessage('admFailed', data);
+      if (failed?.['lifecycleTicket'] === lifecycleTicket) {
+        failBinding(binding, 'adm_document_no_load', false);
+        return;
+      }
+      failBinding(binding, 'internal_error', false);
+    };
+    const receiveError = (): void => failBinding(binding, 'adm_document_no_load', false);
+    try {
+      binding.controlListenerDispose = controlPort.listen(receive, receiveError);
+      binding.controlStarted = true;
+      if (controlPort.post(start, []) !== true) {
+        failBinding(binding, 'internal_error', false);
+        return false;
+      }
+      return binding.active;
+    } catch {
+      failBinding(binding, 'internal_error', false);
+      return false;
+    }
+  };
+
+  const startApsOwner = (binding: GamAttemptBinding, lifecycleTicket: string): boolean => {
+    const controlPort = binding.controlPort;
+    if (!controlPort || binding.controlStarted || !binding.active || !mountAps || !slots) {
+      failBinding(binding, 'internal_error', false);
+      return false;
+    }
+    const mountBinding = slots.resolveApsMountBinding(
+      binding.navigationGeneration,
+      binding.slot,
+      binding.attemptId
+    );
+    if (!mountBinding || !mountBinding.isCurrent()) {
+      failBinding(binding, 'slot_unresolved', false);
+      return false;
+    }
+    const receiveUnexpected = (event: unknown): void => {
+      const ports = messaging.inspectTransferredPorts(event)?.ports ?? [];
+      for (let index = 0; index < ports.length; index += 1) {
+        const port = ports[index];
+        if (port) closePort(port);
+      }
+      failBinding(binding, 'internal_error', false);
+    };
+    try {
+      binding.controlListenerDispose = controlPort.listen(receiveUnexpected, () =>
+        failBinding(binding, 'internal_error', false)
+      );
+      binding.controlStarted = true;
+    } catch {
+      failBinding(binding, 'internal_error', false);
+      return false;
+    }
+    const start = messaging.parseProtocolMessage('apsTopMountStarted', {
+      message: TSJS_MESSAGE_PROTOCOL_V1.message.apsTopMountStarted,
+      version: 1,
+      lifecycleTicket,
+    });
+    if (!start) {
+      failBinding(binding, 'internal_error', false);
+      return false;
+    }
+    try {
+      const mounted = Reflect.apply(mountAps, undefined, [
+        {
+          attempt: binding.attempt as unknown as RenderAttempt,
+          baseArtifact: binding.artifact,
+          bindArtifact: mountBinding.bindArtifact,
+          container: mountBinding.element as HTMLElement,
+          isBindingCurrent: mountBinding.isCurrent,
+          messaging,
+          onArtifactTransferred: () => {
+            binding.artifactOwned = false;
+            binding.ownerInserted = true;
+          },
+        },
+      ]) as boolean;
+      if (!mounted || !binding.active || !binding.ownerInserted) return false;
+      if (controlPort.post(start, []) !== true) {
+        failBinding(binding, 'internal_error', false);
+        return false;
+      }
+      return binding.active;
+    } catch {
+      failBinding(binding, 'internal_error', false);
+      return false;
+    }
+  };
+
+  const handleOwnerRegistration = (
+    event: MessageEvent,
+    data: unknown,
+    routing: Readonly<{ message: string; adId?: string; lifecycleTicket?: string }>
+  ): void => {
+    const ticket = routing.lifecycleTicket;
+    if (!ticket) return;
+    const entry = mapValue(tickets, ticket);
+    if (!entry) return;
+    if (!suppress(event)) return;
+    const now = readNow();
+    let entryStillCurrent = true;
+    if (now !== undefined) {
+      pruneExpiredTickets(now);
+      entryStillCurrent = mapValue(tickets, ticket) === entry;
+    }
+
+    const exact = messaging.parseProtocolMessage('ownerRegister', data);
+    const inspection = messaging.inspectTransferredPorts(event);
+    const ports = inspection?.ports;
+    const responsePort = ports?.[0];
+    const exactPort =
+      inspection?.exactShape === true && inspection.originalCount === 1 && ports?.length === 1;
+    const closeAdditionalPorts = (): void => {
+      if (!ports) return;
+      for (let index = 1; index < ports.length; index += 1) {
+        const port = ports[index];
+        if (port) closePort(port);
+      }
+    };
+    if (!entryStillCurrent) {
+      if (responsePort) refuseOwner(responsePort, routing.adId ?? '');
+      closeAdditionalPorts();
+      return;
+    }
+    if (now === undefined) {
+      if (responsePort) refuseOwner(responsePort, routing.adId ?? '');
+      closeAdditionalPorts();
+      if (entry.state !== 'tombstone') {
+        retireTicket(entry.binding);
+        failBinding(entry.binding, 'internal_error', false);
+      }
+      return;
+    }
+    if (entry.state === 'tombstone') {
+      if (responsePort) refuseOwner(responsePort, routing.adId ?? '');
+      closeAdditionalPorts();
+      return;
+    }
+
+    if (entry.state === 'pending') {
+      if (responsePort) refuseOwner(responsePort, routing.adId ?? '');
+      closeAdditionalPorts();
+      retireTicket(entry.binding);
+      failBinding(entry.binding, 'bridge_id_mismatch', false);
+      return;
+    }
+
+    const binding = entry.binding;
+    const invalidate = (): void => {
+      if (responsePort) refuseOwner(responsePort, routing.adId ?? binding.reservationId);
+      closeAdditionalPorts();
+      retireTicket(binding);
+      failBinding(binding, 'bridge_id_mismatch', false);
+    };
+    if (!exact || !responsePort || !exactPort) {
+      invalidate();
+      return;
+    }
+    const source = eventSource(event);
+    let exactAdId: unknown;
+    let exactTicket: unknown;
+    try {
+      exactAdId = exact['adId'];
+      exactTicket = exact['lifecycleTicket'];
+    } catch {
+      invalidate();
+      return;
+    }
+    if (
+      source === undefined ||
+      source !== binding.pucSource ||
+      exactAdId !== binding.reservationId ||
+      exactTicket !== ticket ||
+      binding.ticket !== ticket ||
+      mapValue(tickets, ticket) !== entry ||
+      !currentBindingState(binding, 'waiting_for_owner')
+    ) {
+      invalidate();
+      return;
+    }
+
+    binding.lifecycleTicket = ticket;
+    retireTicket(binding);
+    const channel = messaging.createChannel();
+    if (!channel) {
+      refuseOwner(responsePort, binding.reservationId);
+      failBinding(binding, 'internal_error', false);
+      return;
+    }
+    if (!binding.active || !currentBindingState(binding, 'waiting_for_owner')) {
+      closeChannel(channel);
+      refuseOwner(responsePort, binding.reservationId);
+      if (binding.active) failBinding(binding, 'internal_error', false);
+      return;
+    }
+    binding.controlPort = channel.retained;
+    const registered = (() => {
+      try {
+        return (
+          Reflect.apply(binding.attempt.ownerRegistered, binding.attempt, []) === true &&
+          currentBindingState(binding, 'waiting_for_insertion')
+        );
+      } catch {
+        return false;
+      }
+    })();
+    const response = registered ? ownerResponse(binding.reservationId, ticket) : undefined;
+    let posted = false;
+    if (response) {
+      try {
+        posted = responsePort.post(response, [channel.transferred]) === true;
+      } catch {
+        posted = false;
+      }
+    }
+    closePort(responsePort);
+    closePort(channel.transferred);
+    if (!registered || !posted || !binding.active) {
+      if (binding.active) failBinding(binding, 'internal_error', false);
+      return;
+    }
+    let sourceType: unknown;
+    try {
+      sourceType = binding.attempt.renderSource?.type;
+    } catch {
+      sourceType = undefined;
+    }
+    if (sourceType === 'adm') {
+      startAdmOwner(binding, ticket);
+    } else if (sourceType === 'aps') {
+      startApsOwner(binding, ticket);
+    } else {
+      failBinding(binding, 'winner_not_renderable', false);
+    }
+  };
+
+  const dispatch = (event: MessageEvent): void => {
+    if (disposed) return;
+    const data = eventData(event);
+    const routing = messaging.inspectGlobalMessage(data);
+    if (routing?.message === TSJS_MESSAGE_PROTOCOL_V1.message.ownerRegister) {
+      handleOwnerRegistration(event, data, routing);
+      return;
+    }
+    if (routing?.message !== TSJS_MESSAGE_PROTOCOL_V1.message.prebidRequest || !routing.adId) {
+      return;
+    }
+
+    const recognition = recognizedReservation(reservations, routing.adId);
+    if (recognition?.recognized !== true) return;
+    if (!suppress(event)) return;
+
+    const exact = messaging.parseProtocolMessage('prebidRequest', data);
+    const inspection = messaging.inspectTransferredPorts(event);
+    const ports = inspection?.ports;
+    const port = ports?.[0];
+    if (!inspection || !port) return;
+    if (
+      inspection.exactShape !== true ||
+      inspection.originalCount !== 1 ||
+      ports.length !== 1 ||
+      exact === undefined ||
+      recognition.state !== 'renderable'
+    ) {
+      refuse(port, routing.adId);
+      for (let index = 1; index < ports.length; index += 1) {
+        const extra = ports[index];
+        if (extra) closePort(extra);
+      }
+      return;
+    }
+
+    const source = eventSource(event);
+    const binding = mapValue(attempts, routing.adId);
+    if (
+      source === undefined ||
+      !binding?.active ||
+      binding.claim !== undefined ||
+      !currentBindingState(binding, 'waiting_for_gam_and_claim')
+    ) {
+      refuse(port, routing.adId);
+      return;
+    }
+
+    binding.claim = frozen({ port, source });
+    binding.pucSource = source;
+    if (binding.gamReady) join(binding);
+  };
+
+  const uninstall = messaging.installCaptureListener(dispatch);
+  if (typeof uninstall !== 'function') {
+    throw new Error('Universal Creative capture listener installation failed');
+  }
+
+  const bridge: PucBridge = {
+    adoptFirstDisplayTickets(input): boolean {
+      if (
+        disposed ||
+        !ticketAdoptionOpen ||
+        mapSize(tickets) !== 0 ||
+        mapSize(attempts) !== 0 ||
+        typeof input !== 'object' ||
+        input === null ||
+        typeof input.clockEpochMs !== 'number' ||
+        !Number.isFinite(input.clockEpochMs) ||
+        input.clockEpochMs < 0 ||
+        !Number.isInteger(input.nextTicketOrdinal) ||
+        input.nextTicketOrdinal < 1 ||
+        input.nextTicketOrdinal > 4_294_967_295 ||
+        !Array.isArray(input.tombstones) ||
+        input.tombstones.length > MAX_TICKETS
+      ) {
+        return false;
+      }
+      const now = readNow();
+      if (now === undefined) return false;
+      const prepared = new Map<string, TicketTombstone>();
+      for (const candidate of input.tombstones) {
+        if (
+          typeof candidate !== 'object' ||
+          candidate === null ||
+          typeof candidate.ticket !== 'string' ||
+          !LIFECYCLE_TICKET.test(candidate.ticket) ||
+          prepared.has(candidate.ticket) ||
+          typeof candidate.expiresAtMs !== 'number' ||
+          !Number.isFinite(candidate.expiresAtMs) ||
+          candidate.expiresAtMs < 0
+        ) {
+          return false;
+        }
+        const remainingMs = candidate.expiresAtMs - input.clockEpochMs;
+        if (remainingMs <= 0) continue;
+        const expiresAt = now + remainingMs;
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) return false;
+        prepared.set(candidate.ticket, {
+          expiresAt,
+          expiryHandle: undefined,
+          state: 'tombstone',
+        });
+      }
+      const published: string[] = [];
+      try {
+        for (const [ticket, tombstone] of prepared) {
+          setMapValue(tickets, ticket, tombstone);
+          if (mapValue(tickets, ticket) !== tombstone) throw new Error('ticket adoption failed');
+          published.push(ticket);
+          const handle = Reflect.apply(schedulerSet, scheduler, [
+            () => expireTicket(ticket, tombstone),
+            tombstone.expiresAt - now,
+          ]);
+          if (mapValue(tickets, ticket) === tombstone) tombstone.expiryHandle = handle;
+          else clearScheduled(handle);
+        }
+      } catch {
+        for (const ticket of published) {
+          const entry = mapValue(tickets, ticket);
+          if (entry?.state === 'tombstone') clearScheduled(entry.expiryHandle);
+          deleteMapValue(tickets, ticket);
+        }
+        return false;
+      }
+      ticketOrdinalHighWater = input.nextTicketOrdinal;
+      ticketAdoptionOpen = false;
+      return ticketOrdinalHighWater === input.nextTicketOrdinal;
+    },
+    registerGamAttempt(input): boolean {
+      ticketAdoptionOpen = false;
+      if (disposed || !dynamicOwnerValid) return false;
+      const exact = exactInput(input);
+      if (!exact || mapValue(attempts, exact.reservationId) !== undefined) return false;
+      const existing = snapshotMapValues(attempts);
+      for (let index = 0; index < existing.length; index += 1) {
+        const candidate = existing[index];
+        if (
+          candidate &&
+          (candidate.attempt === exact.attempt ||
+            candidate.attempt.generation === exact.attempt.generation)
+        ) {
+          return false;
+        }
+      }
+      const recognition = recognizedReservation(reservations, exact.reservationId);
+      if (recognition?.recognized !== true || recognition.state !== 'renderable') return false;
+      try {
+        const snapshot = Reflect.apply(exact.attempt.snapshot, exact.attempt, []);
+        if (
+          Reflect.apply(exact.owner.isCurrent, exact.owner, []) !== true ||
+          snapshot.outcome !== undefined ||
+          snapshot.state !== 'created' ||
+          exact.attempt.renderSource !== undefined
+        ) {
+          return false;
+        }
+      } catch {
+        return false;
+      }
+      const started = (() => {
+        try {
+          return Reflect.apply(exact.attempt.beginGamClaim, exact.attempt, []) === true;
+        } catch {
+          return false;
+        }
+      })();
+      if (!started) return false;
+      const binding: GamAttemptBinding = {
+        reservationId: exact.reservationId,
+        attempt: exact.attempt,
+        artifact: exact.artifact,
+        owner: exact.owner,
+        attemptId: exact.attempt.id,
+        slot: exact.owner.slot,
+        navigationGeneration: exact.owner.navigationGeneration,
+        artifactOwned: true,
+        active: true,
+        claim: undefined,
+        claimDeadlineHandle: undefined,
+        claimDeadlineToken: undefined,
+        controlListenerDispose: undefined,
+        controlPort: undefined,
+        controlStarted: false,
+        gamReady: false,
+        joining: false,
+        lifecycleTicket: undefined,
+        ownerInserted: false,
+        pucSource: undefined,
+        ticket: undefined,
+      };
+      setMapValue(attempts, exact.reservationId, binding);
+      if (!currentBindingState(binding, 'waiting_for_gam_and_claim')) {
+        cleanupBinding(binding);
+        return false;
+      }
+      const observed = (() => {
+        try {
+          return (
+            Reflect.apply(exact.attempt.onSettled, exact.attempt, [
+              (outcome: RenderOutcome) => settleBinding(binding, outcome),
+            ]) === true
+          );
+        } catch {
+          return false;
+        }
+      })();
+      if (!observed || !binding.active || mapValue(attempts, exact.reservationId) !== binding) {
+        cleanupBinding(binding);
+        try {
+          Reflect.apply(exact.attempt.fail, exact.attempt, ['internal_error']);
+        } catch {
+          // Registration rejection already retains no bridge authority.
+        }
+        return false;
+      }
+      return true;
+    },
+    recordNonemptyGam(input): boolean {
+      ticketAdoptionOpen = false;
+      if (disposed) return false;
+      const exact = exactInput(input);
+      if (!exact) return false;
+      const binding = mapValue(attempts, exact.reservationId);
+      if (
+        !binding ||
+        !bindingMatches(binding, exact) ||
+        binding.gamReady ||
+        !currentBindingState(binding, 'waiting_for_gam_and_claim')
+      ) {
+        return false;
+      }
+      binding.gamReady = true;
+      if (binding.claim) join(binding);
+      else armClaimDeadline(binding);
+      return true;
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposed = true;
+      try {
+        uninstall();
+      } catch {
+        // Listener removal is already contained by the adapter.
+      }
+      const bindings = snapshotMapValues(attempts);
+      for (let index = 0; index < bindings.length; index += 1) {
+        const binding = bindings[index];
+        if (!binding) continue;
+        const cancelled = (() => {
+          try {
+            return (
+              Reflect.apply(binding.attempt.cancel, binding.attempt, ['navigation_disposed']) ===
+              true
+            );
+          } catch {
+            return false;
+          }
+        })();
+        if (!cancelled && binding.active) cleanupBinding(binding);
+      }
+      const ticketEntries = snapshotMapValues(tickets);
+      for (let index = 0; index < ticketEntries.length; index += 1) {
+        const entry = ticketEntries[index];
+        if (entry?.state !== 'pending') clearScheduled(entry?.expiryHandle);
+      }
+      Reflect.apply(mapClearIntrinsic, attempts, []);
+      Reflect.apply(mapClearIntrinsic, tickets, []);
+    },
+    snapshotInventoryForTest(): PucBridgeInventory {
+      let pendingClaims = 0;
+      const bindings = snapshotMapValues(attempts);
+      for (let index = 0; index < bindings.length; index += 1) {
+        if (bindings[index]?.claim) pendingClaims += 1;
+      }
+      let liveTickets = 0;
+      let ticketTombstones = 0;
+      const ticketEntries = snapshotMapValues(tickets);
+      for (let index = 0; index < ticketEntries.length; index += 1) {
+        if (ticketEntries[index]?.state === 'live' || ticketEntries[index]?.state === 'pending') {
+          liveTickets += 1;
+        } else if (ticketEntries[index]?.state === 'tombstone') ticketTombstones += 1;
+      }
+      return frozen({
+        attempts: mapSize(attempts),
+        disposed,
+        liveTickets,
+        pendingClaims,
+        ticketTombstones,
+      });
+    },
+  };
+  return frozen(bridge);
+}
diff --git a/crates/trusted-server-js/lib/src/services/render.ts b/crates/trusted-server-js/lib/src/services/render.ts
new file mode 100644
index 000000000..de86d784c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/render.ts
@@ -0,0 +1,2773 @@
+import { mintBrowserBootstrapNonce, mintBrowserRendererNonce } from '../kernel/identity';
+import type { IdentityGenerationResult } from '../kernel/identity';
+import type { RenderAttemptScope, WinnerContext } from '../kernel/sessions';
+
+import { isReservationService } from './reservations';
+import type {
+  ReservationClaimAdmission,
+  ReservationClaimExpectation,
+  ReservationRenderSource,
+  ReservationService,
+} from './reservations';
+
+const ATTEMPT_ID = /^a1_[A-Za-z0-9_-]{22}$/;
+const BOOTSTRAP_NONCE = /^b1_[A-Za-z0-9_-]{22}$/;
+const RENDERER_NONCE = /^n1_[A-Za-z0-9_-]{22}$/;
+const MAX_APS_NONCES_PER_ROLE = 256;
+const MAX_APS_NONCE_DRAWS = 8;
+const MAX_ADM_BODY_BYTES = 512 * 1024;
+const reflectApplyIntrinsic = Reflect.apply;
+const directAdmDocument = typeof document === 'undefined' ? undefined : document;
+const directAdmOwnerDocumentGetter =
+  typeof Node === 'undefined'
+    ? undefined
+    : Object.getOwnPropertyDescriptor(Node.prototype, 'ownerDocument')?.get;
+const objectFreezeIntrinsic = Object.freeze;
+const objectIsFrozenIntrinsic = Object.isFrozen;
+const objectGetPrototypeOfIntrinsic = Object.getPrototypeOf;
+const objectGetOwnPropertyNamesIntrinsic = Object.getOwnPropertyNames;
+const objectGetOwnPropertySymbolsIntrinsic = Object.getOwnPropertySymbols;
+const objectGetOwnPropertyDescriptorIntrinsic = Object.getOwnPropertyDescriptor;
+const objectCreateIntrinsic = Object.create;
+const arrayIncludesIntrinsic = Array.prototype.includes;
+const arrayPushIntrinsic = Array.prototype.push;
+const arraySliceIntrinsic = Array.prototype.slice;
+const arraySortIntrinsic = Array.prototype.sort;
+const arraySpliceIntrinsic = Array.prototype.splice;
+const mapGetIntrinsic = Map.prototype.get;
+const mapSetIntrinsic = Map.prototype.set;
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapClearIntrinsic = Map.prototype.clear;
+const mapEntriesIntrinsic = Map.prototype.entries;
+const mapValuesIntrinsic = Map.prototype.values;
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size')?.get as (
+  this: Map<unknown, unknown>
+) => number;
+const mapEntryIteratorNextIntrinsic = Object.getPrototypeOf(new Map().entries()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const mapValueIteratorNextIntrinsic = Object.getPrototypeOf(new Map().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const setAddIntrinsic = Set.prototype.add;
+const setHasIntrinsic = Set.prototype.has;
+const setDeleteIntrinsic = Set.prototype.delete;
+const setClearIntrinsic = Set.prototype.clear;
+const setValuesIntrinsic = Set.prototype.values;
+const setSizeGetter = Object.getOwnPropertyDescriptor(Set.prototype, 'size')?.get as (
+  this: Set<unknown>
+) => number;
+const setValueIteratorNextIntrinsic = Object.getPrototypeOf(new Set().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+const weakMapDeleteIntrinsic = WeakMap.prototype.delete;
+const weakMapHasIntrinsic = WeakMap.prototype.has;
+const weakSetAddIntrinsic = WeakSet.prototype.add;
+const weakSetHasIntrinsic = WeakSet.prototype.has;
+const weakSetDeleteIntrinsic = WeakSet.prototype.delete;
+const promiseThenIntrinsic = Promise.prototype.then;
+const numberIsFiniteIntrinsic = Number.isFinite;
+const numberIsIntegerIntrinsic = Number.isInteger;
+const stringTrimIntrinsic = String.prototype.trim;
+const textEncoder = new TextEncoder();
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+const artifactDisposals = new WeakMap<object, boolean>();
+const artifactGuards = new WeakMap<object, () => boolean>();
+const artifactRetirements = new WeakMap<object, () => void>();
+const committedArtifactStores = new WeakSet<object>();
+const renderAttempts = new WeakSet<object>();
+const ignoreAsyncDisposal = (): void => undefined;
+
+function frozen<const Value extends object>(value: Value): Readonly<Value> {
+  return reflectApplyIntrinsic(objectFreezeIntrinsic, Object, [value]) as Readonly<Value>;
+}
+
+function arrayPush<Value>(array: Value[], value: Value): number {
+  return Reflect.apply(arrayPushIntrinsic, array, [value]) as number;
+}
+
+function utf8Length(value: string): number {
+  return (reflectApplyIntrinsic(textEncoderEncodeIntrinsic, textEncoder, [value]) as Uint8Array)
+    .byteLength;
+}
+
+function isFiniteNumber(value: number): boolean {
+  return reflectApplyIntrinsic(numberIsFiniteIntrinsic, Number, [value]) as boolean;
+}
+
+function isInteger(value: number): boolean {
+  return reflectApplyIntrinsic(numberIsIntegerIntrinsic, Number, [value]) as boolean;
+}
+
+function objectIsFrozen(value: object): boolean {
+  return reflectApplyIntrinsic(objectIsFrozenIntrinsic, Object, [value]) as boolean;
+}
+
+function objectPrototype(value: object): object | null {
+  return reflectApplyIntrinsic(objectGetPrototypeOfIntrinsic, Object, [value]) as object | null;
+}
+
+function ownPropertyNames(value: object): string[] {
+  return reflectApplyIntrinsic(objectGetOwnPropertyNamesIntrinsic, Object, [value]) as string[];
+}
+
+function ownPropertySymbols(value: object): symbol[] {
+  return reflectApplyIntrinsic(objectGetOwnPropertySymbolsIntrinsic, Object, [value]) as symbol[];
+}
+
+function ownPropertyDescriptor(value: object, name: PropertyKey): PropertyDescriptor | undefined {
+  return reflectApplyIntrinsic(objectGetOwnPropertyDescriptorIntrinsic, Object, [value, name]) as
+    PropertyDescriptor | undefined;
+}
+
+function sortedStrings(values: string[]): string[] {
+  return reflectApplyIntrinsic(arraySortIntrinsic, values, []) as string[];
+}
+
+function arraySlice<Value>(array: Value[]): Value[] {
+  return Reflect.apply(arraySliceIntrinsic, array, [0]) as Value[];
+}
+
+function arraySpliceAll<Value>(array: Value[]): Value[] {
+  return Reflect.apply(arraySpliceIntrinsic, array, [0, array.length]) as Value[];
+}
+
+function mapGet<Key, Value>(map: Map<Key, Value>, key: Key): Value | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function mapSet<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void {
+  Reflect.apply(mapSetIntrinsic, map, [key, value]);
+}
+
+function mapDelete<Key, Value>(map: Map<Key, Value>, key: Key): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function mapClear<Key, Value>(map: Map<Key, Value>): void {
+  Reflect.apply(mapClearIntrinsic, map, []);
+}
+
+function mapSize<Key, Value>(map: Map<Key, Value>): number {
+  return Reflect.apply(mapSizeGetter, map, []) as number;
+}
+
+function mapEntrySnapshot<Key, Value>(map: Map<Key, Value>): Array<[Key, Value]> {
+  const iterator = Reflect.apply(mapEntriesIntrinsic, map, []) as IterableIterator<[Key, Value]>;
+  const output: Array<[Key, Value]> = [];
+  while (true) {
+    const step = Reflect.apply(mapEntryIteratorNextIntrinsic, iterator, []) as IteratorResult<
+      [Key, Value]
+    >;
+    if (step.done) return output;
+    output[output.length] = step.value;
+  }
+}
+
+function mapValueSnapshot<Key, Value>(map: Map<Key, Value>): Value[] {
+  const iterator = Reflect.apply(mapValuesIntrinsic, map, []) as IterableIterator<Value>;
+  const output: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(
+      mapValueIteratorNextIntrinsic,
+      iterator,
+      []
+    ) as IteratorResult<Value>;
+    if (step.done) return output;
+    output[output.length] = step.value;
+  }
+}
+
+function setAdd<Value>(set: Set<Value>, value: Value): void {
+  Reflect.apply(setAddIntrinsic, set, [value]);
+}
+
+function setHas<Value>(set: Set<Value>, value: Value): boolean {
+  return Reflect.apply(setHasIntrinsic, set, [value]) as boolean;
+}
+
+function setDelete<Value>(set: Set<Value>, value: Value): boolean {
+  return Reflect.apply(setDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function setClear<Value>(set: Set<Value>): void {
+  Reflect.apply(setClearIntrinsic, set, []);
+}
+
+function setSize<Value>(set: Set<Value>): number {
+  return Reflect.apply(setSizeGetter, set, []) as number;
+}
+
+function setValueSnapshot<Value>(set: Set<Value>): Value[] {
+  const iterator = Reflect.apply(setValuesIntrinsic, set, []) as IterableIterator<Value>;
+  const output: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(
+      setValueIteratorNextIntrinsic,
+      iterator,
+      []
+    ) as IteratorResult<Value>;
+    if (step.done) return output;
+    output[output.length] = step.value;
+  }
+}
+
+function weakMapGet<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): Value | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function weakMapSet<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key,
+  value: Value
+): void {
+  Reflect.apply(weakMapSetIntrinsic, map, [key, value]);
+}
+
+function weakMapDelete<Key extends object, Value>(map: WeakMap<Key, Value>, key: Key): boolean {
+  return Reflect.apply(weakMapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function weakMapHas<Key extends object, Value>(map: WeakMap<Key, Value>, key: Key): boolean {
+  return Reflect.apply(weakMapHasIntrinsic, map, [key]) as boolean;
+}
+
+function weakSetAdd<Value extends object>(set: WeakSet<Value>, value: Value): void {
+  Reflect.apply(weakSetAddIntrinsic, set, [value]);
+}
+
+function weakSetHas<Value extends object>(set: WeakSet<Value>, value: Value): boolean {
+  return Reflect.apply(weakSetHasIntrinsic, set, [value]) as boolean;
+}
+
+function weakSetDelete<Value extends object>(set: WeakSet<Value>, value: Value): boolean {
+  return Reflect.apply(weakSetDeleteIntrinsic, set, [value]) as boolean;
+}
+
+export const RENDER_FAILURE_REASONS = frozen([
+  'auction_timeout',
+  'auction_disabled',
+  'consent_denied',
+  'slot_not_eligible',
+  'provider_timeout',
+  'provider_error',
+  'invalid_provider_response',
+  'mediation_failed',
+  'winner_not_renderable',
+  'internal_error',
+  'network_error',
+  'http_error',
+  'invalid_response',
+  'slot_unresolved',
+  'descriptor_invalid',
+  'invalid_dimensions',
+  'dimensions_out_of_range',
+  'no_render_source',
+  'registry_full',
+  'capability_registry_full',
+  'external_queue_full',
+  'external_ready_timeout',
+  'external_artifact_incompatible',
+  'prebid_admission_failed',
+  'prebid_contract_violation',
+  'prebid_selection_timeout',
+  'reservation_collision',
+  'identity_generation_failed',
+  'cycle_unattributable',
+  'slot_quarantined',
+  'gpt_request_failed',
+  'gpt_request_timeout',
+  'gpt_completion_timeout',
+  'reconciliation_capacity',
+  'gam_empty',
+  'bridge_claim_timeout',
+  'bridge_id_mismatch',
+  'owner_registration_timeout',
+  'owner_insertion_timeout',
+  'renderer_document_no_load',
+  'runner_no_load',
+  'runner_failed',
+  'adm_document_no_load',
+  'abi_mismatch',
+  'bundle_partial',
+] as const);
+
+export type RenderFailureReason = (typeof RENDER_FAILURE_REASONS)[number];
+
+export const RENDER_CANCELLATION_REASONS = frozen([
+  'caller_aborted',
+  'superseded',
+  'navigation_disposed',
+] as const);
+
+export type RenderCancellationReason = (typeof RENDER_CANCELLATION_REASONS)[number];
+
+export type RenderOutcome =
+  | Readonly<{ outcome: 'accepted' }>
+  | Readonly<{ outcome: 'no_bid' }>
+  | Readonly<{ outcome: 'failed'; reason: RenderFailureReason }>
+  | Readonly<{ outcome: 'cancelled'; reason: RenderCancellationReason }>;
+
+export type RenderAttemptActiveState =
+  | 'created'
+  | 'waiting_for_gam_and_claim'
+  | 'waiting_for_owner'
+  | 'waiting_for_insertion'
+  | 'rendering_direct'
+  | 'waiting_for_document'
+  | 'waiting_for_aps_completion'
+  | 'waiting_for_adm';
+
+export type RenderAttemptState =
+  RenderAttemptActiveState | 'accepted' | 'no_bid' | 'failed' | 'cancelled';
+
+export interface CommittedRenderArtifact {
+  readonly kind: 'aps_mount' | 'direct_iframe' | 'puc';
+  readonly attemptId: string;
+  readonly slot: string;
+  readonly navigationGeneration: object;
+  readonly dispose: () => void;
+}
+
+export interface CommittedArtifactStore {
+  readonly promote: (artifact: CommittedRenderArtifact, stillCurrent?: () => boolean) => boolean;
+  readonly current: (slot: string) => CommittedRenderArtifact | undefined;
+  readonly release: (artifact: CommittedRenderArtifact) => boolean;
+  /** Retire every committed artifact whose exact DOM/binding guard is no longer current. */
+  readonly sweep: () => number;
+  readonly disposeNavigation: (navigationGeneration: object) => void;
+  readonly dispose: () => void;
+}
+
+/** Shared exact ownership for the inline position required by absolute render overlays. */
+export interface ArtifactHostPositionLeaseRegistry {
+  readonly bindOwned: (
+    artifact: CommittedRenderArtifact,
+    host: HTMLElement,
+    previousPosition: string,
+    previousPriority: string
+  ) => boolean;
+  readonly inherit: (
+    artifact: CommittedRenderArtifact,
+    predecessor: CommittedRenderArtifact,
+    host: HTMLElement
+  ) => boolean;
+  readonly claim: (artifact: CommittedRenderArtifact) => boolean;
+  readonly current: (artifact: CommittedRenderArtifact) => boolean;
+  readonly release: (artifact: CommittedRenderArtifact) => void;
+}
+
+interface ArtifactHostPositionLease {
+  readonly host: HTMLElement;
+  owner: CommittedRenderArtifact | undefined;
+  readonly previousPosition: string;
+  readonly previousPriority: string;
+}
+
+interface ArtifactHostPositionBinding {
+  live: boolean;
+  readonly lease: ArtifactHostPositionLease;
+  readonly predecessor?: CommittedRenderArtifact;
+}
+
+/** Create one render-runtime lease registry shared by adoption and later APS mounts. */
+export function createArtifactHostPositionLeaseRegistry(): ArtifactHostPositionLeaseRegistry {
+  const bindings = new WeakMap<CommittedRenderArtifact, ArtifactHostPositionBinding>();
+
+  const styleIsOwned = (host: HTMLElement): boolean => {
+    try {
+      return (
+        host.style.getPropertyValue('position') === 'relative' &&
+        host.style.getPropertyPriority('position') === ''
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const restore = (lease: ArtifactHostPositionLease): void => {
+    try {
+      if (!styleIsOwned(lease.host)) return;
+      if (lease.previousPosition === '') lease.host.style.removeProperty('position');
+      else {
+        lease.host.style.setProperty('position', lease.previousPosition, lease.previousPriority);
+      }
+    } catch {
+      // Compare-owned restoration cannot overwrite a publisher style replacement.
+    }
+  };
+
+  const registry: ArtifactHostPositionLeaseRegistry = {
+    bindOwned(artifact, host, previousPosition, previousPriority): boolean {
+      try {
+        if (
+          !validArtifact(artifact) ||
+          bindings.has(artifact) ||
+          !styleIsOwned(host) ||
+          typeof previousPosition !== 'string' ||
+          typeof previousPriority !== 'string'
+        ) {
+          return false;
+        }
+        const lease: ArtifactHostPositionLease = {
+          host,
+          owner: artifact,
+          previousPosition,
+          previousPriority,
+        };
+        const binding: ArtifactHostPositionBinding = { lease, live: true };
+        bindings.set(artifact, binding);
+        return bindings.get(artifact) === binding;
+      } catch {
+        return false;
+      }
+    },
+    inherit(artifact, predecessor, host): boolean {
+      try {
+        if (!validArtifact(artifact) || bindings.has(artifact) || !styleIsOwned(host)) return false;
+        const previous = bindings.get(predecessor);
+        if (
+          !previous?.live ||
+          previous.lease.host !== host ||
+          previous.lease.owner !== predecessor
+        ) {
+          return false;
+        }
+        const binding: ArtifactHostPositionBinding = {
+          lease: previous.lease,
+          live: true,
+          predecessor,
+        };
+        bindings.set(artifact, binding);
+        return bindings.get(artifact) === binding;
+      } catch {
+        return false;
+      }
+    },
+    claim(artifact): boolean {
+      try {
+        const binding = bindings.get(artifact);
+        if (!binding?.live || !styleIsOwned(binding.lease.host)) return false;
+        if (binding.lease.owner === artifact) return true;
+        const predecessor = binding.predecessor;
+        const previous = predecessor ? bindings.get(predecessor) : undefined;
+        if (
+          !predecessor ||
+          !previous?.live ||
+          previous.lease !== binding.lease ||
+          binding.lease.owner !== predecessor
+        ) {
+          return false;
+        }
+        binding.lease.owner = artifact;
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    current(artifact): boolean {
+      try {
+        const binding = bindings.get(artifact);
+        return (
+          !binding ||
+          (binding.live && binding.lease.owner === artifact && styleIsOwned(binding.lease.host))
+        );
+      } catch {
+        return false;
+      }
+    },
+    release(artifact): void {
+      let binding: ArtifactHostPositionBinding | undefined;
+      try {
+        binding = bindings.get(artifact);
+        if (!binding?.live) return;
+        binding.live = false;
+        if (binding.lease.owner !== artifact) return;
+        const predecessor = binding.predecessor;
+        const previous = predecessor ? bindings.get(predecessor) : undefined;
+        if (predecessor && previous?.live && previous.lease === binding.lease) {
+          binding.lease.owner = predecessor;
+          return;
+        }
+        binding.lease.owner = undefined;
+      } catch {
+        return;
+      }
+      restore(binding.lease);
+    },
+  };
+  return frozen(registry);
+}
+
+export interface RenderDeadline {
+  readonly milliseconds: number;
+  readonly reason: RenderFailureReason;
+}
+
+export interface RenderScheduler {
+  readonly set: (callback: () => void, milliseconds: number) => unknown;
+  readonly clear: (handle: unknown) => void;
+}
+
+/** Fixed deadlines owned by the state transition that enters each wait. */
+export const RENDER_STATE_DEADLINES: Readonly<
+  Partial<Record<RenderAttemptActiveState, RenderDeadline>>
+> = frozen({
+  waiting_for_owner: frozen({
+    milliseconds: 3_000,
+    reason: 'owner_registration_timeout',
+  }),
+  waiting_for_insertion: frozen({
+    milliseconds: 1_000,
+    reason: 'owner_insertion_timeout',
+  }),
+  waiting_for_document: frozen({
+    milliseconds: 3_000,
+    reason: 'renderer_document_no_load',
+  }),
+  waiting_for_aps_completion: frozen({ milliseconds: 10_000, reason: 'runner_failed' }),
+  waiting_for_adm: frozen({ milliseconds: 5_000, reason: 'adm_document_no_load' }),
+});
+
+export interface RenderAttemptOptions {
+  readonly owner: RenderAttemptScope;
+  readonly artifacts: CommittedArtifactStore;
+  readonly prepareRenderSource: (candidate: unknown) => ReservationRenderSource | undefined;
+  readonly reservations: ReservationService;
+  readonly parentAttemptId?: string;
+  readonly publishDiagnostics?: (observation: RenderAttemptDiagnosticsObservation) => unknown;
+  readonly scheduler?: RenderScheduler;
+}
+
+export interface RenderAttemptDiagnosticsObservation extends Readonly<Record<string, unknown>> {
+  readonly adId?: string;
+  readonly kind: 'render_attempt';
+  readonly attemptId: string;
+  readonly bidId?: string;
+  readonly creativeId?: string;
+  readonly injected: boolean;
+  readonly slotId: string;
+  readonly path: 'auction' | 'ssat';
+  readonly rendered: boolean;
+  readonly servedFrom?: 'inline' | 'pbs-cache';
+  readonly state: 'accepted' | 'no_bid' | 'failed' | 'cancelled';
+  readonly outcome: RenderOutcome;
+}
+
+export type RenderAttemptCreationResult =
+  | Readonly<{ ok: true; value: RenderAttempt }>
+  | Readonly<{
+      ok: false;
+      reason: 'identity_generation_failed' | 'invalid_attempt' | 'stale_owner';
+    }>;
+
+export interface RenderAttemptSnapshot {
+  readonly history: readonly RenderAttemptState[];
+  readonly outcome: RenderOutcome | undefined;
+  readonly state: RenderAttemptState;
+}
+
+export interface RenderAttempt {
+  readonly id: string;
+  readonly slot: string;
+  readonly generation: object;
+  readonly navigationGeneration: object;
+  readonly parentAttemptId: string | undefined;
+  readonly renderSource: ReservationRenderSource | undefined;
+  readonly winnerContext: WinnerContext | undefined;
+  readonly admitDirectWinner: (source: unknown, context: WinnerContext) => boolean;
+  readonly admitClaimedWinner: (source: unknown) => boolean;
+  readonly beginGamClaim: () => boolean;
+  readonly ownerClaimed: () => boolean;
+  readonly ownerRegistered: () => boolean;
+  readonly beginDirect: () => boolean;
+  readonly beginApsDocument: (artifact: CommittedRenderArtifact) => boolean;
+  readonly beginAdm: (artifact: CommittedRenderArtifact) => boolean;
+  readonly apsDocumentAccepted: () => boolean;
+  readonly accept: () => boolean;
+  readonly noBid: () => boolean;
+  readonly fail: (reason: RenderFailureReason) => boolean;
+  readonly cancel: (reason: RenderCancellationReason) => boolean;
+  readonly onSettled: (callback: (outcome: RenderOutcome) => void) => boolean;
+  readonly snapshot: () => RenderAttemptSnapshot;
+}
+
+export interface DirectAdmAttemptOptions {
+  readonly attempt: RenderAttempt;
+  readonly container: HTMLElement;
+  readonly prepareIframe: DirectAdmIframeConstructor;
+  readonly publisherOrigin: string;
+}
+
+interface DirectAdmSource {
+  readonly adm: string;
+  readonly height: number;
+  readonly type: 'adm';
+  readonly version: 1;
+  readonly width: number;
+}
+
+export interface DirectAdmIframeHandle {
+  readonly frame: HTMLIFrameElement;
+  append(): boolean;
+  activate(): boolean;
+  commit(): boolean;
+  current(): boolean;
+  dispose(): void;
+}
+
+export type DirectAdmIframeConstructor = (options: {
+  readonly adm: string;
+  readonly container: HTMLElement;
+  readonly height: number;
+  readonly onError: () => void;
+  readonly onLoad: () => void;
+  readonly width: number;
+}) => DirectAdmIframeHandle | undefined;
+
+/** Retained endpoint whose lifetime is owned by one renderer nonce binding. */
+export interface RendererNoncePort {
+  readonly close: () => void;
+}
+
+export interface RendererNonceIssueInput {
+  readonly attempt: RenderAttempt;
+  readonly source?: object;
+  readonly port?: RendererNoncePort;
+}
+
+export interface RendererNonceExpectation {
+  readonly attempt: RenderAttempt;
+  readonly nonce: string;
+  readonly generation: object;
+  readonly source: object;
+  readonly port: RendererNoncePort;
+}
+
+export type RendererNonceIssueResult =
+  | Readonly<{ ok: true; nonce: string }>
+  | Readonly<{
+      ok: false;
+      reason: 'capability_registry_full' | 'identity_generation_failed' | 'invalid_attempt';
+    }>;
+
+export interface RendererNonceRegistrySnapshot {
+  readonly bindings: number;
+  readonly disposed: boolean;
+  readonly liveNonces: number;
+}
+
+export interface RendererNonceRegistry {
+  /** On failure the caller retains port ownership; success transfers it to this registry. */
+  readonly issue: (input: RendererNonceIssueInput) => RendererNonceIssueResult;
+  /** Bind a pre-insertion nonce exactly once to the inserted renderer's WindowProxy. */
+  readonly bindSource: (expectation: RendererNonceExpectation) => boolean;
+  readonly consume: (expectation: RendererNonceExpectation) => boolean;
+  readonly dispose: () => void;
+  readonly snapshotForTest: () => RendererNonceRegistrySnapshot;
+}
+
+export interface RendererNonceRegistryOptions {
+  readonly mintNonce?: () => IdentityGenerationResult<string>;
+}
+
+export type BootstrapNoncePort = RendererNoncePort;
+export type BootstrapNonceIssueInput = RendererNonceIssueInput;
+export type BootstrapNonceExpectation = RendererNonceExpectation;
+export type BootstrapNonceIssueResult = RendererNonceIssueResult;
+export type BootstrapNonceRegistrySnapshot = RendererNonceRegistrySnapshot;
+export type BootstrapNonceRegistry = RendererNonceRegistry;
+export type BootstrapNonceRegistryOptions = RendererNonceRegistryOptions;
+
+export interface SlotOperationResult {
+  readonly path: 'primary' | 'fallback';
+  readonly outcome: RenderOutcome;
+  readonly primaryAttemptId: string;
+  readonly primary: RenderOutcome;
+  readonly fallbackAttemptId?: string;
+  readonly fallback?: RenderOutcome;
+}
+
+export interface SlotOperationSnapshot {
+  readonly settled: boolean;
+  readonly result?: SlotOperationResult;
+}
+
+export interface SlotOperation {
+  readonly snapshot: () => SlotOperationSnapshot;
+  readonly onSettled: (callback: (result: SlotOperationResult) => void) => boolean;
+}
+
+/** Result of provenance-checking a primary attempt before operation subscription. */
+export type SlotOperationCreationResult =
+  Readonly<{ ok: true; value: SlotOperation }> | Readonly<{ ok: false; reason: 'invalid_attempt' }>;
+
+export interface SlotOperationOptions {
+  readonly primary: RenderAttempt;
+  readonly createFallback?: (parentAttemptId: string) => RenderAttemptCreationResult;
+}
+
+function validAttemptId(value: unknown): value is string {
+  return typeof value === 'string' && ATTEMPT_ID.test(value);
+}
+
+function validFailureReason(value: unknown): value is RenderFailureReason {
+  return (
+    typeof value === 'string' &&
+    (Reflect.apply(arrayIncludesIntrinsic, RENDER_FAILURE_REASONS, [value]) as boolean)
+  );
+}
+
+function validCancellationReason(value: unknown): value is RenderCancellationReason {
+  return (
+    typeof value === 'string' &&
+    (Reflect.apply(arrayIncludesIntrinsic, RENDER_CANCELLATION_REASONS, [value]) as boolean)
+  );
+}
+
+function validOutcome(value: unknown): value is RenderOutcome {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      !objectIsFrozen(value) ||
+      objectPrototype(value) !== Object.prototype ||
+      ownPropertySymbols(value).length !== 0
+    ) {
+      return false;
+    }
+    const names = Object.getOwnPropertyNames(value);
+    const outcome = Object.getOwnPropertyDescriptor(value, 'outcome');
+    if (!outcome || !('value' in outcome) || outcome.enumerable !== true) return false;
+    if (outcome.value === 'accepted' || outcome.value === 'no_bid') {
+      return names.length === 1;
+    }
+    const reason = Object.getOwnPropertyDescriptor(value, 'reason');
+    if (!reason || !('value' in reason) || reason.enumerable !== true || names.length !== 2) {
+      return false;
+    }
+    return outcome.value === 'failed'
+      ? validFailureReason(reason.value)
+      : outcome.value === 'cancelled' && validCancellationReason(reason.value);
+  } catch {
+    return false;
+  }
+}
+
+function permitsPromotion(stillCurrent: (() => boolean) | undefined): boolean {
+  if (!stillCurrent) return true;
+  try {
+    return stillCurrent() === true;
+  } catch {
+    return false;
+  }
+}
+
+function validArtifact(
+  value: unknown,
+  slot?: string,
+  navigationGeneration?: object,
+  attemptId?: string
+): value is CommittedRenderArtifact {
+  try {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) return false;
+    if (!Object.isFrozen(value) || Object.getPrototypeOf(value) !== Object.prototype) return false;
+    const names = sortedStrings(ownPropertyNames(value));
+    if (
+      names.length !== 5 ||
+      names[0] !== 'attemptId' ||
+      names[1] !== 'dispose' ||
+      names[2] !== 'kind' ||
+      names[3] !== 'navigationGeneration' ||
+      names[4] !== 'slot' ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return false;
+    }
+    for (let index = 0; index < names.length; index += 1) {
+      const name = names[index];
+      if (!name) return false;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor || !('value' in descriptor) || !descriptor.enumerable) return false;
+    }
+    const artifact = value as CommittedRenderArtifact;
+    return (
+      (artifact.kind === 'aps_mount' ||
+        artifact.kind === 'direct_iframe' ||
+        artifact.kind === 'puc') &&
+      validAttemptId(artifact.attemptId) &&
+      typeof artifact.slot === 'string' &&
+      artifact.slot.length > 0 &&
+      (typeof artifact.navigationGeneration === 'object' ||
+        typeof artifact.navigationGeneration === 'function') &&
+      artifact.navigationGeneration !== null &&
+      typeof artifact.dispose === 'function' &&
+      (slot === undefined || artifact.slot === slot) &&
+      (navigationGeneration === undefined ||
+        artifact.navigationGeneration === navigationGeneration) &&
+      (attemptId === undefined || artifact.attemptId === attemptId)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Bind one immutable artifact to one exact synchronous DOM/binding guard. */
+export function bindCommittedArtifactGuard(
+  artifact: CommittedRenderArtifact,
+  current: () => boolean
+): boolean {
+  try {
+    if (
+      !validArtifact(artifact) ||
+      typeof current !== 'function' ||
+      weakMapHas(artifactGuards, artifact)
+    ) {
+      return false;
+    }
+    weakMapSet(artifactGuards, artifact, current);
+    return weakMapGet(artifactGuards, artifact) === current;
+  } catch {
+    return false;
+  }
+}
+
+/** Bind one exact metadata-release callback to a committed artifact's disposal latch. */
+export function bindCommittedArtifactRetirement(
+  artifact: CommittedRenderArtifact,
+  retire: () => void
+): boolean {
+  try {
+    if (
+      !validArtifact(artifact) ||
+      typeof retire !== 'function' ||
+      weakMapHas(artifactRetirements, artifact) ||
+      artifactDisposalStarted(artifact)
+    ) {
+      return false;
+    }
+    weakMapSet(artifactRetirements, artifact, retire);
+    return weakMapGet(artifactRetirements, artifact) === retire;
+  } catch {
+    return false;
+  }
+}
+
+function guardedArtifactCurrent(artifact: CommittedRenderArtifact): boolean {
+  try {
+    const guard = weakMapGet(artifactGuards, artifact);
+    return !guard || Reflect.apply(guard, undefined, []) === true;
+  } catch {
+    return false;
+  }
+}
+
+function disposeArtifact(artifact: CommittedRenderArtifact | undefined): boolean {
+  if (!artifact) return true;
+  try {
+    if (weakMapHas(artifactDisposals, artifact)) {
+      return weakMapGet(artifactDisposals, artifact) === true;
+    }
+    weakMapSet(artifactDisposals, artifact, false);
+  } catch {
+    return false;
+  }
+  let retirementSucceeded = true;
+  try {
+    const retire = weakMapGet(artifactRetirements, artifact);
+    if (retire) {
+      weakMapDelete(artifactRetirements, artifact);
+      Reflect.apply(retire, undefined, []);
+    }
+  } catch {
+    retirementSucceeded = false;
+  }
+  try {
+    const result = Reflect.apply(artifact.dispose, artifact, []) as unknown;
+    if ((typeof result === 'object' || typeof result === 'function') && result !== null) {
+      try {
+        Reflect.apply(promiseThenIntrinsic, result, [ignoreAsyncDisposal, ignoreAsyncDisposal]);
+        return false;
+      } catch {
+        // Non-Promise thenables are contained through their own `then` method below.
+      }
+      let thenMethod: unknown;
+      try {
+        thenMethod = Reflect.get(result, 'then');
+      } catch {
+        return false;
+      }
+      if (typeof thenMethod === 'function') {
+        try {
+          Reflect.apply(thenMethod, result, [ignoreAsyncDisposal, ignoreAsyncDisposal]);
+        } catch {
+          // A hostile thenable is still an unsupported asynchronous disposer.
+        }
+        return false;
+      }
+    }
+    if (result !== undefined) return false;
+    weakMapSet(artifactDisposals, artifact, true);
+    return retirementSucceeded;
+  } catch {
+    return false;
+  }
+}
+
+function artifactDisposalStarted(artifact: CommittedRenderArtifact): boolean {
+  try {
+    return weakMapHas(artifactDisposals, artifact);
+  } catch {
+    return true;
+  }
+}
+
+/** Own committed artifacts independently from terminal attempt scopes. */
+export function createCommittedArtifactStore(): CommittedArtifactStore {
+  const entries = new Map<string, CommittedRenderArtifact>();
+  const pendingNavigationDisposals = new Set<object>();
+  const disposedNavigations = new WeakSet<object>();
+  let disposed = false;
+  let mutating = false;
+  let disposeRequested = false;
+
+  const disposeGeneration = (navigationGeneration: object): void => {
+    const snapshot = mapEntrySnapshot(entries);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const entry = snapshot[index];
+      if (!entry) continue;
+      const slot = entry[0];
+      const artifact = entry[1];
+      if (
+        artifact.navigationGeneration === navigationGeneration &&
+        mapGet(entries, slot) === artifact
+      ) {
+        mapDelete(entries, slot);
+        disposeArtifact(artifact);
+      }
+    }
+  };
+
+  const drainDeferredDisposal = (): void => {
+    if (mutating) return;
+    if (disposeRequested) {
+      disposeRequested = false;
+      const snapshot = mapValueSnapshot(entries);
+      mapClear(entries);
+      disposed = true;
+      setClear(pendingNavigationDisposals);
+      for (let index = 0; index < snapshot.length; index += 1) {
+        disposeArtifact(snapshot[index]);
+      }
+      return;
+    }
+    const generations = setValueSnapshot(pendingNavigationDisposals);
+    setClear(pendingNavigationDisposals);
+    if (generations.length === 0) return;
+    mutating = true;
+    try {
+      for (let index = 0; index < generations.length; index += 1) {
+        const generation = generations[index];
+        if (generation) disposeGeneration(generation);
+      }
+    } finally {
+      mutating = false;
+      if (disposeRequested || setValueSnapshot(pendingNavigationDisposals).length > 0) {
+        drainDeferredDisposal();
+      }
+    }
+  };
+
+  const store: CommittedArtifactStore = {
+    promote(artifact, stillCurrent): boolean {
+      let ownsMutation = false;
+      try {
+        if (
+          disposed ||
+          mutating ||
+          !validArtifact(artifact) ||
+          artifactDisposalStarted(artifact) ||
+          !guardedArtifactCurrent(artifact) ||
+          weakSetHas(disposedNavigations, artifact.navigationGeneration) ||
+          !permitsPromotion(stillCurrent)
+        ) {
+          return false;
+        }
+        const existing = mapGet(entries, artifact.slot);
+        if (existing === artifact) return false;
+        mutating = true;
+        ownsMutation = true;
+        if (
+          disposed ||
+          disposeRequested ||
+          weakSetHas(disposedNavigations, artifact.navigationGeneration) ||
+          setHas(pendingNavigationDisposals, artifact.navigationGeneration) ||
+          !permitsPromotion(stillCurrent) ||
+          !guardedArtifactCurrent(artifact)
+        ) {
+          return false;
+        }
+        if (existing) {
+          if (!disposeArtifact(existing) || mapGet(entries, artifact.slot) !== existing)
+            return false;
+        }
+        if (
+          disposed ||
+          disposeRequested ||
+          weakSetHas(disposedNavigations, artifact.navigationGeneration) ||
+          setHas(pendingNavigationDisposals, artifact.navigationGeneration) ||
+          !permitsPromotion(stillCurrent) ||
+          !guardedArtifactCurrent(artifact) ||
+          artifactDisposalStarted(artifact)
+        ) {
+          if (existing && mapGet(entries, artifact.slot) === existing) {
+            mapDelete(entries, artifact.slot);
+          }
+          return false;
+        }
+        if (existing && mapGet(entries, artifact.slot) === existing) {
+          mapDelete(entries, artifact.slot);
+        }
+        mapSet(entries, artifact.slot, artifact);
+        return mapGet(entries, artifact.slot) === artifact;
+      } catch {
+        return false;
+      } finally {
+        if (ownsMutation) {
+          mutating = false;
+          drainDeferredDisposal();
+        }
+      }
+    },
+    current(slot): CommittedRenderArtifact | undefined {
+      try {
+        if (disposed || typeof slot !== 'string') return undefined;
+        return mapGet(entries, slot);
+      } catch {
+        return undefined;
+      }
+    },
+    release(artifact): boolean {
+      let ownsMutation = false;
+      try {
+        if (disposed || mutating || !validArtifact(artifact)) return false;
+        mutating = true;
+        ownsMutation = true;
+        if (mapGet(entries, artifact.slot) !== artifact) return false;
+        mapDelete(entries, artifact.slot);
+        const cleaned = disposeArtifact(artifact);
+        return cleaned && mapGet(entries, artifact.slot) !== artifact;
+      } catch {
+        return false;
+      } finally {
+        if (ownsMutation) {
+          mutating = false;
+          drainDeferredDisposal();
+        }
+      }
+    },
+    sweep(): number {
+      let retired = 0;
+      let ownsMutation = false;
+      try {
+        if (disposed || mutating) return 0;
+        mutating = true;
+        ownsMutation = true;
+        const snapshot = mapEntrySnapshot(entries);
+        for (let index = 0; index < snapshot.length; index += 1) {
+          const entry = snapshot[index];
+          if (!entry) continue;
+          const slot = entry[0];
+          const artifact = entry[1];
+          if (mapGet(entries, slot) !== artifact || guardedArtifactCurrent(artifact)) continue;
+          mapDelete(entries, slot);
+          disposeArtifact(artifact);
+          retired += 1;
+        }
+        return retired;
+      } catch {
+        return retired;
+      } finally {
+        if (ownsMutation) {
+          mutating = false;
+          drainDeferredDisposal();
+        }
+      }
+    },
+    disposeNavigation(navigationGeneration): void {
+      let ownsMutation = false;
+      try {
+        if (disposed) return;
+        weakSetAdd(disposedNavigations, navigationGeneration);
+        setAdd(pendingNavigationDisposals, navigationGeneration);
+        if (mutating) return;
+        mutating = true;
+        ownsMutation = true;
+        setDelete(pendingNavigationDisposals, navigationGeneration);
+        disposeGeneration(navigationGeneration);
+      } catch {
+        // Disposal is best-effort and never publishes a replacement artifact.
+      } finally {
+        if (ownsMutation) {
+          mutating = false;
+          drainDeferredDisposal();
+        }
+      }
+    },
+    dispose(): void {
+      let ownsMutation = false;
+      try {
+        if (disposed) return;
+        disposeRequested = true;
+        if (mutating) return;
+        mutating = true;
+        ownsMutation = true;
+        const snapshot = mapValueSnapshot(entries);
+        mapClear(entries);
+        disposeRequested = false;
+        disposed = true;
+        setClear(pendingNavigationDisposals);
+        for (let index = 0; index < snapshot.length; index += 1) {
+          disposeArtifact(snapshot[index]);
+        }
+      } catch {
+        disposeRequested = false;
+        disposed = true;
+        try {
+          mapClear(entries);
+        } catch {
+          // The store remains terminal even under collection corruption.
+        }
+      } finally {
+        if (ownsMutation) mutating = false;
+      }
+    },
+  };
+  weakSetAdd(committedArtifactStores, store);
+  return frozen(store);
+}
+
+function defaultScheduler(): RenderScheduler {
+  return frozen({
+    set: (callback: () => void, milliseconds: number): unknown =>
+      globalThis.setTimeout(callback, milliseconds),
+    clear: (handle: unknown): void => {
+      globalThis.clearTimeout(handle as ReturnType<typeof globalThis.setTimeout>);
+    },
+  });
+}
+
+function terminalState(outcome: RenderOutcome): RenderAttemptState {
+  return outcome.outcome;
+}
+
+/** Construct one path-independent attempt lifecycle around an issued owner scope. */
+export function createRenderAttempt(options: RenderAttemptOptions): RenderAttemptCreationResult {
+  let owner: RenderAttemptScope;
+  let ownerForCleanup: unknown;
+  let ownerDisposeForCleanup: unknown;
+  let artifacts: CommittedArtifactStore;
+  let id: string;
+  let slot: string;
+  let generation: object;
+  let navigationGeneration: object;
+  let parentAttemptId: string | undefined;
+  let prepareRenderSource: (candidate: unknown) => ReservationRenderSource | undefined;
+  let reservations: ReservationService;
+  let publishDiagnostics:
+    ((observation: RenderAttemptDiagnosticsObservation) => unknown) | undefined;
+  let consumeClaimMethod: ReservationService['consumeClaim'];
+  let ownerIsCurrentMethod: RenderAttemptScope['isCurrent'];
+  let ownerDisposeMethod: RenderAttemptScope['dispose'];
+  let ownerOnDisposeMethod: RenderAttemptScope['onDispose'];
+  let ownerPrepareWinnerMethod: RenderAttemptScope['prepareWinnerContext'];
+  let promoteArtifactMethod: CommittedArtifactStore['promote'];
+  let currentArtifactMethod: CommittedArtifactStore['current'];
+  let releaseArtifactMethod: CommittedArtifactStore['release'];
+  const rejectConstruction = (
+    reason: 'invalid_attempt' | 'stale_owner'
+  ): RenderAttemptCreationResult => {
+    try {
+      if (
+        ((typeof ownerForCleanup === 'object' && ownerForCleanup !== null) ||
+          typeof ownerForCleanup === 'function') &&
+        typeof ownerDisposeForCleanup === 'function'
+      ) {
+        Reflect.apply(ownerDisposeForCleanup, ownerForCleanup, []);
+      }
+    } catch {
+      // Rejection remains authoritative even when issued-owner cleanup throws.
+    }
+    return frozen({ ok: false, reason });
+  };
+  try {
+    owner = options.owner;
+    ownerForCleanup = owner;
+    ownerDisposeForCleanup = owner.dispose;
+    ownerDisposeMethod = ownerDisposeForCleanup as RenderAttemptScope['dispose'];
+    artifacts = options.artifacts;
+    if (!weakSetHas(committedArtifactStores, artifacts)) {
+      return rejectConstruction('invalid_attempt');
+    }
+    id = owner.id;
+    slot = owner.slot;
+    generation = owner.generation;
+    navigationGeneration = owner.navigationGeneration;
+    parentAttemptId = options.parentAttemptId;
+    prepareRenderSource = options.prepareRenderSource;
+    reservations = options.reservations;
+    publishDiagnostics = options.publishDiagnostics;
+    if (!isReservationService(reservations)) {
+      return rejectConstruction('invalid_attempt');
+    }
+    consumeClaimMethod = reservations.consumeClaim;
+    ownerIsCurrentMethod = owner.isCurrent;
+    ownerOnDisposeMethod = owner.onDispose;
+    ownerPrepareWinnerMethod = owner.prepareWinnerContext;
+    promoteArtifactMethod = artifacts.promote;
+    currentArtifactMethod = artifacts.current;
+    releaseArtifactMethod = artifacts.release;
+    if (
+      !validAttemptId(id) ||
+      typeof slot !== 'string' ||
+      slot.length === 0 ||
+      (typeof generation !== 'object' && typeof generation !== 'function') ||
+      generation === null ||
+      (typeof navigationGeneration !== 'object' && typeof navigationGeneration !== 'function') ||
+      navigationGeneration === null ||
+      generation === navigationGeneration ||
+      typeof promoteArtifactMethod !== 'function' ||
+      typeof currentArtifactMethod !== 'function' ||
+      typeof releaseArtifactMethod !== 'function' ||
+      typeof ownerIsCurrentMethod !== 'function' ||
+      typeof ownerDisposeMethod !== 'function' ||
+      typeof ownerOnDisposeMethod !== 'function' ||
+      typeof ownerPrepareWinnerMethod !== 'function' ||
+      typeof prepareRenderSource !== 'function' ||
+      typeof consumeClaimMethod !== 'function' ||
+      (publishDiagnostics !== undefined && typeof publishDiagnostics !== 'function') ||
+      (parentAttemptId !== undefined &&
+        (!validAttemptId(parentAttemptId) || parentAttemptId === id))
+    ) {
+      return rejectConstruction('invalid_attempt');
+    }
+  } catch {
+    return rejectConstruction('invalid_attempt');
+  }
+  const ownerIsCurrent = (): boolean => {
+    try {
+      return Reflect.apply(ownerIsCurrentMethod, owner, []) === true;
+    } catch {
+      return false;
+    }
+  };
+  const ownerIdentityIsCurrent = (): boolean => {
+    try {
+      return (
+        owner.id === id &&
+        owner.slot === slot &&
+        owner.generation === generation &&
+        owner.navigationGeneration === navigationGeneration &&
+        ownerIsCurrent()
+      );
+    } catch {
+      return false;
+    }
+  };
+  if (!ownerIsCurrent()) return rejectConstruction('stale_owner');
+
+  let scheduler: RenderScheduler;
+  let schedulerSetMethod: RenderScheduler['set'];
+  let schedulerClearMethod: RenderScheduler['clear'];
+  try {
+    scheduler = options.scheduler ?? defaultScheduler();
+    schedulerSetMethod = scheduler.set;
+    schedulerClearMethod = scheduler.clear;
+    if (typeof schedulerSetMethod !== 'function' || typeof schedulerClearMethod !== 'function') {
+      return rejectConstruction('invalid_attempt');
+    }
+  } catch {
+    return rejectConstruction('invalid_attempt');
+  }
+  const history: RenderAttemptState[] = ['created'];
+  const observers: Array<(outcome: RenderOutcome) => void> = [];
+  let state: RenderAttemptState = 'created';
+  let outcome: RenderOutcome | undefined;
+  let pendingArtifact: CommittedRenderArtifact | undefined;
+  let admittedRenderSource: ReservationRenderSource | undefined;
+  let admittedWinnerContext: WinnerContext | undefined;
+  let deadlineHandle: unknown;
+  let deadlineState: RenderAttemptActiveState | undefined;
+  let settlingInternally = false;
+
+  const prepareSource = (candidate: unknown): ReservationRenderSource | undefined => {
+    try {
+      const source = prepareRenderSource(candidate);
+      if (!source || !Object.isFrozen(source)) return undefined;
+      const type = Object.getOwnPropertyDescriptor(source, 'type');
+      const version = Object.getOwnPropertyDescriptor(source, 'version');
+      if (
+        !type ||
+        !('value' in type) ||
+        (type.value !== 'aps' && type.value !== 'adm') ||
+        !version ||
+        !('value' in version) ||
+        version.value !== 1
+      ) {
+        return undefined;
+      }
+      return source;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const claimedSource = (
+    admission: unknown,
+    context: WinnerContext
+  ): ReservationRenderSource | undefined => {
+    try {
+      if (
+        typeof admission !== 'object' ||
+        admission === null ||
+        !Object.isFrozen(admission) ||
+        Object.getPrototypeOf(admission) !== Object.prototype ||
+        Object.getOwnPropertySymbols(admission).length !== 0
+      ) {
+        return undefined;
+      }
+      const names = Object.getOwnPropertyNames(admission).sort();
+      const renderSource = Object.getOwnPropertyDescriptor(admission, 'renderSource');
+      const winnerContext = Object.getOwnPropertyDescriptor(admission, 'winnerContext');
+      if (
+        names.length !== 2 ||
+        names[0] !== 'renderSource' ||
+        names[1] !== 'winnerContext' ||
+        !renderSource ||
+        !('value' in renderSource) ||
+        renderSource.enumerable !== true ||
+        !winnerContext ||
+        !('value' in winnerContext) ||
+        winnerContext.enumerable !== true ||
+        winnerContext.value !== context
+      ) {
+        return undefined;
+      }
+      const source = renderSource.value as ReservationRenderSource;
+      if (!Object.isFrozen(source)) return undefined;
+      const type = Object.getOwnPropertyDescriptor(source, 'type');
+      const version = Object.getOwnPropertyDescriptor(source, 'version');
+      if (
+        !type ||
+        !('value' in type) ||
+        (type.value !== 'aps' && type.value !== 'adm') ||
+        !version ||
+        !('value' in version) ||
+        version.value !== 1
+      ) {
+        return undefined;
+      }
+      return source;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const validWinnerContext = (context: unknown): context is WinnerContext => {
+    try {
+      if (
+        (typeof context !== 'object' && typeof context !== 'function') ||
+        context === null ||
+        !objectIsFrozen(context) ||
+        objectPrototype(context) !== Object.prototype ||
+        ownPropertyNames(context).length !== 1 ||
+        ownPropertySymbols(context).length !== 0
+      ) {
+        return false;
+      }
+      const selectedCpm = ownPropertyDescriptor(context, 'selectedCpm');
+      return (
+        !!selectedCpm &&
+        'value' in selectedCpm &&
+        selectedCpm.enumerable === true &&
+        typeof selectedCpm.value === 'number' &&
+        isFiniteNumber(selectedCpm.value) &&
+        selectedCpm.value >= 0
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  const readWinnerContext = (): WinnerContext | undefined => {
+    try {
+      return owner.winnerContext;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const admitDirectWinner = (candidate: unknown, context: WinnerContext): boolean => {
+    if (
+      state !== 'created' ||
+      outcome !== undefined ||
+      admittedRenderSource !== undefined ||
+      admittedWinnerContext !== undefined ||
+      !ownerIsCurrent() ||
+      !validWinnerContext(context)
+    ) {
+      return false;
+    }
+    const source = prepareSource(candidate);
+    if (!source) return false;
+    let admission: ReturnType<RenderAttemptScope['prepareWinnerContext']>;
+    try {
+      admission = Reflect.apply(ownerPrepareWinnerMethod, owner, [context]);
+    } catch {
+      return false;
+    }
+    if (!admission) return false;
+    let committed: boolean;
+    try {
+      committed = admission.commit() === true;
+    } catch {
+      committed = false;
+    }
+    if (!committed || !ownerIsCurrent() || readWinnerContext() !== context) {
+      try {
+        admission.rollback();
+      } catch {
+        // Failed admission retains no lifecycle source/context authority.
+      }
+      return false;
+    }
+    admittedRenderSource = source;
+    admittedWinnerContext = context;
+    return true;
+  };
+
+  const admitClaimedWinner = (candidate: unknown): boolean => {
+    if (
+      state !== 'waiting_for_gam_and_claim' ||
+      outcome !== undefined ||
+      admittedRenderSource !== undefined ||
+      admittedWinnerContext !== undefined ||
+      !ownerIsCurrent()
+    ) {
+      return false;
+    }
+    const context = readWinnerContext();
+    if (!validWinnerContext(context)) return false;
+    let admission: ReservationClaimAdmission | undefined;
+    try {
+      admission = Reflect.apply(consumeClaimMethod, reservations, [
+        candidate,
+        frozen<ReservationClaimExpectation>({
+          attempt: owner,
+          attemptId: id,
+          slot,
+          navigationGeneration,
+          winnerContext: context,
+        }),
+      ]) as ReservationClaimAdmission | undefined;
+    } catch {
+      return false;
+    }
+    const source = claimedSource(admission, context);
+    if (!source || !ownerIsCurrent() || readWinnerContext() !== context) return false;
+    admittedRenderSource = source;
+    admittedWinnerContext = context;
+    return true;
+  };
+
+  const clearDeadline = (): void => {
+    if (deadlineState === undefined) return;
+    const handle = deadlineHandle;
+    deadlineHandle = undefined;
+    deadlineState = undefined;
+    try {
+      Reflect.apply(schedulerClearMethod, scheduler, [handle]);
+    } catch {
+      // A cleared logical deadline remains inert even when the host clear throws.
+    }
+  };
+
+  const notify = (terminal: RenderOutcome): void => {
+    const snapshot = arraySpliceAll(observers);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const observer = snapshot[index];
+      if (!observer) continue;
+      try {
+        observer(terminal);
+      } catch {
+        // Observation cannot change the terminal result.
+      }
+    }
+  };
+
+  const settle = (terminal: RenderOutcome, disposeOwner: boolean): boolean => {
+    if (outcome !== undefined) return false;
+    const terminalRenderSource = admittedRenderSource;
+    outcome = terminal;
+    state = terminalState(terminal);
+    arrayPush(history, state);
+    clearDeadline();
+    admittedRenderSource = undefined;
+    admittedWinnerContext = undefined;
+    if (terminal.outcome !== 'accepted') {
+      const uncommitted = pendingArtifact;
+      pendingArtifact = undefined;
+      disposeArtifact(uncommitted);
+    }
+    if (disposeOwner) {
+      settlingInternally = true;
+      try {
+        Reflect.apply(ownerDisposeMethod, owner, []);
+      } catch {
+        // The terminal latch and owned-resource cleanup remain authoritative.
+      } finally {
+        settlingInternally = false;
+      }
+    }
+    if (publishDiagnostics) {
+      const accepted = terminal.outcome === 'accepted';
+      const servedFrom = accepted ? ('inline' as const) : undefined;
+      let sourceIdentity: Readonly<{ adId?: string; bidId?: string; creativeId?: string }> =
+        Object.freeze({});
+      if (accepted && terminalRenderSource) {
+        try {
+          const readString = (name: string): string | undefined => {
+            const descriptor = Object.getOwnPropertyDescriptor(terminalRenderSource, name);
+            return descriptor && 'value' in descriptor && typeof descriptor.value === 'string'
+              ? descriptor.value
+              : undefined;
+          };
+          const bidId = terminalRenderSource.type === 'aps' ? readString('bidId') : undefined;
+          const creativeId =
+            terminalRenderSource.type === 'aps' ? readString('creativeId') : undefined;
+          sourceIdentity = frozen({
+            ...(bidId === undefined ? {} : { bidId }),
+            ...(creativeId === undefined ? {} : { creativeId }),
+          });
+        } catch {
+          // Optional trace identity cannot affect the committed terminal state.
+        }
+      }
+      const observation = frozen<RenderAttemptDiagnosticsObservation>({
+        kind: 'render_attempt',
+        attemptId: id,
+        slotId: slot,
+        path: history.includes('waiting_for_gam_and_claim') ? 'ssat' : 'auction',
+        rendered: accepted,
+        injected: accepted,
+        ...(servedFrom === undefined ? {} : { servedFrom }),
+        ...sourceIdentity,
+        state: terminal.outcome,
+        outcome: terminal,
+      });
+      try {
+        Reflect.apply(publishDiagnostics, undefined, [observation]);
+      } catch {
+        // Diagnostics publication cannot change terminal render authority.
+      }
+    }
+    notify(terminal);
+    return true;
+  };
+
+  const fail = (reason: RenderFailureReason): boolean =>
+    validFailureReason(reason) && (reason !== 'gam_empty' || state === 'waiting_for_gam_and_claim')
+      ? settle(frozen({ outcome: 'failed', reason }), true)
+      : false;
+
+  const armDeadline = (
+    entered: RenderAttemptActiveState,
+    explicitDeadline?: RenderDeadline
+  ): void => {
+    const deadline = explicitDeadline ?? RENDER_STATE_DEADLINES[entered];
+    if (!deadline) return;
+    deadlineState = entered;
+    try {
+      const handle = Reflect.apply(schedulerSetMethod, scheduler, [
+        () => {
+          if (outcome === undefined && state === entered && deadlineState === entered) {
+            fail(deadline.reason);
+          }
+        },
+        deadline.milliseconds,
+      ]);
+      if (outcome === undefined && state === entered && deadlineState === entered) {
+        deadlineHandle = handle;
+      } else {
+        try {
+          Reflect.apply(schedulerClearMethod, scheduler, [handle]);
+        } catch {
+          // A synchronously-settled deadline remains inert through the terminal latch.
+        }
+      }
+    } catch {
+      deadlineState = undefined;
+      deadlineHandle = undefined;
+      fail('internal_error');
+    }
+  };
+
+  const enter = (
+    allowed: readonly RenderAttemptActiveState[],
+    next: RenderAttemptActiveState,
+    explicitDeadline?: RenderDeadline
+  ): boolean => {
+    if (outcome !== undefined || !ownerIsCurrent() || !allowed.includes(state as never)) {
+      return false;
+    }
+    state = next;
+    arrayPush(history, next);
+    clearDeadline();
+    if (outcome === undefined) armDeadline(next, explicitDeadline);
+    return true;
+  };
+
+  const stageAndEnter = (
+    allowed: readonly RenderAttemptActiveState[],
+    next: 'waiting_for_document' | 'waiting_for_adm',
+    artifact: CommittedRenderArtifact
+  ): boolean => {
+    const sourceType = admittedRenderSource?.type;
+    const sourceMatches =
+      next === 'waiting_for_document' ? sourceType === 'aps' : sourceType === 'adm';
+    const artifactKind =
+      next === 'waiting_for_document'
+        ? 'aps_mount'
+        : state === 'rendering_direct'
+          ? 'direct_iframe'
+          : 'puc';
+    if (
+      pendingArtifact !== undefined ||
+      !validArtifact(artifact, slot, navigationGeneration, id) ||
+      artifact.kind !== artifactKind ||
+      !sourceMatches ||
+      outcome !== undefined ||
+      !ownerIsCurrent() ||
+      !allowed.includes(state as never)
+    ) {
+      return false;
+    }
+    pendingArtifact = artifact;
+    if (enter(allowed, next)) return true;
+    pendingArtifact = undefined;
+    return false;
+  };
+
+  const lifecycle: RenderAttempt = {
+    id,
+    slot,
+    generation,
+    navigationGeneration,
+    parentAttemptId,
+    get renderSource(): ReservationRenderSource | undefined {
+      return admittedRenderSource;
+    },
+    get winnerContext(): WinnerContext | undefined {
+      return admittedWinnerContext;
+    },
+    admitDirectWinner,
+    admitClaimedWinner,
+    beginGamClaim: () =>
+      admittedRenderSource === undefined && admittedWinnerContext === undefined
+        ? enter(['created'], 'waiting_for_gam_and_claim')
+        : false,
+    ownerClaimed: () =>
+      admittedRenderSource && admittedWinnerContext
+        ? enter(['waiting_for_gam_and_claim'], 'waiting_for_owner')
+        : false,
+    ownerRegistered: () => enter(['waiting_for_owner'], 'waiting_for_insertion'),
+    beginDirect: () =>
+      (admittedRenderSource?.type === 'aps' || admittedRenderSource?.type === 'adm') &&
+      admittedWinnerContext
+        ? enter(['created'], 'rendering_direct')
+        : false,
+    beginApsDocument: (artifact) =>
+      stageAndEnter(
+        ['waiting_for_insertion', 'rendering_direct'],
+        'waiting_for_document',
+        artifact
+      ),
+    beginAdm: (artifact) =>
+      stageAndEnter(['waiting_for_insertion', 'rendering_direct'], 'waiting_for_adm', artifact),
+    apsDocumentAccepted: () => enter(['waiting_for_document'], 'waiting_for_aps_completion'),
+    accept(): boolean {
+      if (
+        outcome !== undefined ||
+        !ownerIsCurrent() ||
+        (state !== 'waiting_for_aps_completion' && state !== 'waiting_for_adm') ||
+        !pendingArtifact
+      ) {
+        return false;
+      }
+      const candidate = pendingArtifact;
+      clearDeadline();
+      if (
+        outcome !== undefined ||
+        pendingArtifact !== candidate ||
+        (state !== 'waiting_for_aps_completion' && state !== 'waiting_for_adm') ||
+        !ownerIsCurrent()
+      ) {
+        return false;
+      }
+      let promoted: boolean;
+      let promotionAttempted = false;
+      try {
+        promotionAttempted = true;
+        promoted = Reflect.apply(promoteArtifactMethod, artifacts, [
+          candidate,
+          () =>
+            outcome === undefined &&
+            pendingArtifact === candidate &&
+            (state === 'waiting_for_aps_completion' || state === 'waiting_for_adm') &&
+            ownerIsCurrent(),
+        ]);
+        promoted =
+          promoted && Reflect.apply(currentArtifactMethod, artifacts, [slot]) === candidate;
+        if (
+          promoted &&
+          (outcome !== undefined ||
+            pendingArtifact !== candidate ||
+            (state !== 'waiting_for_aps_completion' && state !== 'waiting_for_adm') ||
+            !ownerIsCurrent())
+        ) {
+          promoted = false;
+        }
+      } catch {
+        promoted = false;
+      }
+      if (!promoted) {
+        if (promotionAttempted) {
+          try {
+            Reflect.apply(releaseArtifactMethod, artifacts, [candidate]);
+          } catch {
+            // The branded store contains release failure; attempt cleanup remains exact-once.
+          }
+        }
+        fail('internal_error');
+        return false;
+      }
+      pendingArtifact = undefined;
+      return settle(frozen({ outcome: 'accepted' }), true);
+    },
+    noBid: () =>
+      state === 'created' &&
+      admittedRenderSource === undefined &&
+      admittedWinnerContext === undefined &&
+      ownerIsCurrent()
+        ? settle(frozen({ outcome: 'no_bid' }), true)
+        : false,
+    fail,
+    cancel: (reason) =>
+      validCancellationReason(reason)
+        ? settle(frozen({ outcome: 'cancelled', reason }), true)
+        : false,
+    onSettled(callback): boolean {
+      if (typeof callback !== 'function') return false;
+      if (outcome) {
+        try {
+          callback(outcome);
+        } catch {
+          // Observation cannot change the terminal result.
+        }
+        return true;
+      }
+      arrayPush(observers, callback);
+      return true;
+    },
+    snapshot: () =>
+      frozen({
+        history: frozen(arraySlice(history)),
+        outcome,
+        state,
+      }),
+  };
+
+  const disposeRejectedOwner = (): void => {
+    try {
+      Reflect.apply(ownerDisposeMethod, owner, []);
+    } catch {
+      // Owner registration failure is terminal even if host disposal throws.
+    }
+  };
+
+  try {
+    Reflect.apply(ownerOnDisposeMethod, owner, [
+      'render-lifecycle',
+      () => {
+        if (!settlingInternally && outcome === undefined) {
+          settle(frozen({ outcome: 'cancelled', reason: 'navigation_disposed' }), false);
+        }
+      },
+    ]);
+  } catch {
+    disposeRejectedOwner();
+    return frozen({ ok: false, reason: 'stale_owner' });
+  }
+  if (outcome !== undefined || !ownerIdentityIsCurrent()) {
+    settle(frozen({ outcome: 'cancelled', reason: 'navigation_disposed' }), false);
+    disposeRejectedOwner();
+    return frozen({ ok: false, reason: 'stale_owner' });
+  }
+  const exposedLifecycle = frozen(lifecycle);
+  weakSetAdd(renderAttempts, exposedLifecycle);
+  return frozen({ ok: true, value: exposedLifecycle });
+}
+
+function readDirectAdmSource(value: unknown): DirectAdmSource | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      !Object.isFrozen(value) ||
+      Object.getPrototypeOf(value) !== Object.prototype ||
+      Object.getOwnPropertySymbols(value).length !== 0
+    ) {
+      return undefined;
+    }
+    const names = Object.getOwnPropertyNames(value).sort();
+    const expected = ['adm', 'height', 'type', 'version', 'width'];
+    if (names.length !== expected.length) return undefined;
+    for (let index = 0; index < expected.length; index += 1) {
+      if (names[index] !== expected[index]) return undefined;
+    }
+    const fields = reflectApplyIntrinsic(objectCreateIntrinsic, Object, [null]) as Record<
+      string,
+      unknown
+    >;
+    for (const name of expected) {
+      const descriptor = ownPropertyDescriptor(value, name);
+      if (
+        !descriptor ||
+        !('value' in descriptor) ||
+        descriptor.enumerable !== true ||
+        descriptor.configurable !== false ||
+        descriptor.writable !== false
+      ) {
+        return undefined;
+      }
+      fields[name] = descriptor.value;
+    }
+    if (
+      fields['type'] !== 'adm' ||
+      fields['version'] !== 1 ||
+      typeof fields['adm'] !== 'string' ||
+      (reflectApplyIntrinsic(stringTrimIntrinsic, fields['adm'], []) as string).length === 0 ||
+      utf8Length(fields['adm']) > MAX_ADM_BODY_BYTES ||
+      typeof fields['width'] !== 'number' ||
+      !isInteger(fields['width']) ||
+      fields['width'] < 1 ||
+      fields['width'] > 4096 ||
+      typeof fields['height'] !== 'number' ||
+      !isInteger(fields['height']) ||
+      fields['height'] < 1 ||
+      fields['height'] > 4096
+    ) {
+      return undefined;
+    }
+    return value as DirectAdmSource;
+  } catch {
+    return undefined;
+  }
+}
+
+function renderAdmAttempt(options: DirectAdmAttemptOptions): boolean {
+  let attempt: RenderAttempt;
+  let container: HTMLElement;
+  let prepareIframe: DirectAdmIframeConstructor;
+  let publisherOrigin: string;
+  try {
+    attempt = options.attempt;
+    container = options.container;
+    prepareIframe = options.prepareIframe;
+    publisherOrigin = options.publisherOrigin;
+  } catch {
+    return false;
+  }
+  if (!weakSetHas(renderAttempts, attempt) || typeof prepareIframe !== 'function') return false;
+
+  let exactDocumentOrigin: boolean;
+  try {
+    exactDocumentOrigin =
+      !!directAdmDocument &&
+      typeof directAdmOwnerDocumentGetter === 'function' &&
+      reflectApplyIntrinsic(directAdmOwnerDocumentGetter, container, []) === directAdmDocument &&
+      directAdmDocument.defaultView?.location.origin === publisherOrigin;
+  } catch {
+    exactDocumentOrigin = false;
+  }
+  if (!exactDocumentOrigin) {
+    attempt.fail('winner_not_renderable');
+    return false;
+  }
+
+  const source = readDirectAdmSource(attempt.renderSource);
+  if (!source) {
+    attempt.fail('winner_not_renderable');
+    return false;
+  }
+  if (!attempt.beginDirect()) return false;
+  try {
+    if (attempt.snapshot().state !== 'rendering_direct') return false;
+  } catch {
+    attempt.fail('internal_error');
+    return false;
+  }
+
+  let activeHandle: DirectAdmIframeHandle | undefined;
+  let activateHandleMethod: DirectAdmIframeHandle['activate'] | undefined;
+  let appendHandleMethod: DirectAdmIframeHandle['append'] | undefined;
+  let commitHandleMethod: DirectAdmIframeHandle['commit'] | undefined;
+  let currentHandleMethod: DirectAdmIframeHandle['current'] | undefined;
+  let disposeHandleMethod: DirectAdmIframeHandle['dispose'] | undefined;
+  let handleDisposed = false;
+  let artifactOwnedByAttempt = false;
+  const disposeHandle = (): void => {
+    if (handleDisposed) return;
+    handleDisposed = true;
+    if (!activeHandle || typeof disposeHandleMethod !== 'function') return;
+    try {
+      reflectApplyIntrinsic(disposeHandleMethod, activeHandle, []);
+    } catch {
+      // The attempt remains terminal even if an injected cleanup boundary is hostile.
+    }
+  };
+  const currentHandle = (): boolean => {
+    if (!activeHandle || typeof currentHandleMethod !== 'function') return false;
+    try {
+      return reflectApplyIntrinsic(currentHandleMethod, activeHandle, []) === true;
+    } catch {
+      return false;
+    }
+  };
+  const failAttempt = (reason: RenderFailureReason): void => {
+    try {
+      attempt.fail(reason);
+    } catch {
+      if (artifactOwnedByAttempt) disposeHandle();
+    }
+  };
+  const fail = (reason: RenderFailureReason): false => {
+    if (!artifactOwnedByAttempt) disposeHandle();
+    failAttempt(reason);
+    return false;
+  };
+  try {
+    activeHandle = prepareIframe({
+      adm: source.adm,
+      container,
+      height: source.height,
+      onError: () => {
+        if (artifactOwnedByAttempt) failAttempt('adm_document_no_load');
+      },
+      onLoad: () => {
+        if (!artifactOwnedByAttempt || !currentHandle()) {
+          if (artifactOwnedByAttempt) failAttempt('adm_document_no_load');
+          return;
+        }
+        let accepted = false;
+        try {
+          accepted = attempt.accept() === true;
+        } catch {
+          failAttempt('internal_error');
+        }
+        if (!accepted || !activeHandle || typeof commitHandleMethod !== 'function') return;
+        try {
+          reflectApplyIntrinsic(commitHandleMethod, activeHandle, []);
+        } catch {
+          // Terminal acceptance is already authoritative; cleanup cannot be replayed here.
+        }
+      },
+      width: source.width,
+    });
+  } catch {
+    return fail('adm_document_no_load');
+  }
+  const handle = activeHandle;
+  if (!handle) return fail('adm_document_no_load');
+  try {
+    disposeHandleMethod = handle.dispose;
+    appendHandleMethod = handle.append;
+    currentHandleMethod = handle.current;
+    activateHandleMethod = handle.activate;
+    commitHandleMethod = handle.commit;
+    if (
+      typeof disposeHandleMethod !== 'function' ||
+      typeof appendHandleMethod !== 'function' ||
+      typeof currentHandleMethod !== 'function' ||
+      typeof activateHandleMethod !== 'function' ||
+      typeof commitHandleMethod !== 'function'
+    ) {
+      return fail('adm_document_no_load');
+    }
+  } catch {
+    return fail('adm_document_no_load');
+  }
+
+  const artifact = frozen<CommittedRenderArtifact>({
+    kind: 'direct_iframe',
+    attemptId: attempt.id,
+    slot: attempt.slot,
+    navigationGeneration: attempt.navigationGeneration,
+    dispose: disposeHandle,
+  });
+  try {
+    if (reflectApplyIntrinsic(appendHandleMethod, handle, []) !== true) {
+      return fail('adm_document_no_load');
+    }
+  } catch {
+    return fail('adm_document_no_load');
+  }
+  try {
+    if (!attempt.beginAdm(artifact)) return fail('internal_error');
+  } catch {
+    return fail('internal_error');
+  }
+  artifactOwnedByAttempt = true;
+  let state: RenderAttemptState;
+  try {
+    state = attempt.snapshot().state;
+  } catch {
+    return fail('internal_error');
+  }
+  if (state !== 'waiting_for_adm') return false;
+  if (!currentHandle()) return fail('adm_document_no_load');
+  try {
+    if (reflectApplyIntrinsic(activateHandleMethod, handle, []) !== true) {
+      return fail('adm_document_no_load');
+    }
+  } catch {
+    return fail('adm_document_no_load');
+  }
+  try {
+    state = attempt.snapshot().state;
+  } catch {
+    return fail('internal_error');
+  }
+  return state === 'waiting_for_adm' || state === 'accepted';
+}
+
+/** Drive one admitted direct ADM attempt through the shared iframe constructor. */
+export function renderDirectAdmAttempt(options: DirectAdmAttemptOptions): boolean {
+  return renderAdmAttempt(options);
+}
+
+interface RendererNonceBinding {
+  readonly nonce: string;
+  readonly attempt: RenderAttempt;
+  readonly attemptId: string;
+  readonly generation: object;
+  source: object | undefined;
+  port: RendererNoncePort | undefined;
+  closeMethod: RendererNoncePort['close'] | undefined;
+  consumed: boolean;
+  closed: boolean;
+}
+
+function validRendererNonce(value: unknown): value is string {
+  return typeof value === 'string' && RENDERER_NONCE.test(value);
+}
+
+function validBootstrapNonce(value: unknown): value is string {
+  return typeof value === 'string' && BOOTSTRAP_NONCE.test(value);
+}
+
+function readMintedNonce(
+  value: unknown,
+  validNonce: (candidate: unknown) => candidate is string
+): string | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || !Object.isFrozen(value)) return undefined;
+    if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = Object.getOwnPropertyNames(value).sort();
+    const ok = Object.getOwnPropertyDescriptor(value, 'ok');
+    if (!ok || !ok.enumerable || !('value' in ok)) return undefined;
+    if (ok.value === true) {
+      if (names.length !== 2 || names[0] !== 'ok' || names[1] !== 'value') return undefined;
+      const nonce = Object.getOwnPropertyDescriptor(value, 'value');
+      return nonce && nonce.enumerable && 'value' in nonce && validNonce(nonce.value)
+        ? nonce.value
+        : undefined;
+    }
+    if (ok.value === false && names.length === 2 && names[0] === 'ok' && names[1] === 'reason') {
+      const reason = Object.getOwnPropertyDescriptor(value, 'reason');
+      if (
+        reason &&
+        reason.enumerable &&
+        'value' in reason &&
+        reason.value === 'identity_generation_failed'
+      ) {
+        return undefined;
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function readRendererNonceExpectation(value: unknown): RendererNonceExpectation | undefined {
+  try {
+    if (
+      typeof value !== 'object' ||
+      value === null ||
+      Object.getPrototypeOf(value) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = Object.getOwnPropertyNames(value).sort();
+    const expected = ['attempt', 'generation', 'nonce', 'port', 'source'];
+    if (names.length !== expected.length) return undefined;
+    const fields: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (let index = 0; index < expected.length; index += 1) {
+      const name = expected[index];
+      if (!name || names[index] !== name) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      fields[name] = descriptor.value;
+    }
+    return fields as unknown as RendererNonceExpectation;
+  } catch {
+    return undefined;
+  }
+}
+
+function createApsNonceRegistry(
+  role: 'bootstrap' | 'renderer',
+  options: RendererNonceRegistryOptions
+): RendererNonceRegistry {
+  const validNonce = role === 'bootstrap' ? validBootstrapNonce : validRendererNonce;
+  const liveByNonce = new Map<string, RendererNonceBinding>();
+  const bindingByAttempt = new WeakMap<RenderAttempt, RendererNonceBinding>();
+  const bindingByGeneration = new WeakMap<object, RendererNonceBinding>();
+  const bindingByPort = new WeakMap<RendererNoncePort, RendererNonceBinding>();
+  const bindings = new Set<RendererNonceBinding>();
+  const pendingNonces = new Set<string>();
+  const pendingAttempts = new WeakSet<RenderAttempt>();
+  const pendingGenerations = new WeakSet<object>();
+  const pendingPorts = new WeakSet<RendererNoncePort>();
+  const retiredPorts = new WeakSet<RendererNoncePort>();
+  let pendingCount = 0;
+  let disposed = false;
+  let mintNonce: () => IdentityGenerationResult<string>;
+  try {
+    mintNonce =
+      options.mintNonce ??
+      (role === 'bootstrap' ? mintBrowserBootstrapNonce : mintBrowserRendererNonce);
+  } catch {
+    mintNonce = () => frozen({ ok: false, reason: 'identity_generation_failed' });
+  }
+
+  const closeBinding = (binding: RendererNonceBinding): void => {
+    if (binding.closed) return;
+    binding.closed = true;
+    binding.consumed = true;
+    if (mapGet(liveByNonce, binding.nonce) === binding) {
+      mapDelete(liveByNonce, binding.nonce);
+    }
+    if (weakMapGet(bindingByAttempt, binding.attempt) === binding) {
+      weakMapDelete(bindingByAttempt, binding.attempt);
+    }
+    if (weakMapGet(bindingByGeneration, binding.generation) === binding) {
+      weakMapDelete(bindingByGeneration, binding.generation);
+    }
+    if (binding.port) {
+      weakSetAdd(retiredPorts, binding.port);
+      if (weakMapGet(bindingByPort, binding.port) === binding) {
+        weakMapDelete(bindingByPort, binding.port);
+      }
+    }
+    setDelete(bindings, binding);
+    try {
+      if (binding.port && binding.closeMethod) {
+        Reflect.apply(binding.closeMethod, binding.port, []);
+      }
+    } catch {
+      // Closing a retained browser port is best-effort and exact-once.
+    }
+  };
+
+  const rollbackProvisionalBinding = (binding: RendererNonceBinding): void => {
+    binding.closed = true;
+    binding.consumed = true;
+    if (mapGet(liveByNonce, binding.nonce) === binding) {
+      mapDelete(liveByNonce, binding.nonce);
+    }
+    if (weakMapGet(bindingByAttempt, binding.attempt) === binding) {
+      weakMapDelete(bindingByAttempt, binding.attempt);
+    }
+    if (weakMapGet(bindingByGeneration, binding.generation) === binding) {
+      weakMapDelete(bindingByGeneration, binding.generation);
+    }
+    if (binding.port && weakMapGet(bindingByPort, binding.port) === binding) {
+      weakMapDelete(bindingByPort, binding.port);
+    }
+    setDelete(bindings, binding);
+  };
+
+  const invalidIssue = (
+    reason: Exclude<RendererNonceIssueResult, { ok: true }>['reason']
+  ): RendererNonceIssueResult => frozen({ ok: false, reason });
+
+  const registry: RendererNonceRegistry = {
+    issue(input): RendererNonceIssueResult {
+      let attempt: RenderAttempt;
+      let source: object | undefined;
+      let port: RendererNoncePort | undefined;
+      let closeMethod: RendererNoncePort['close'] | undefined;
+      let attemptId: string;
+      let generation: object;
+      let onSettledMethod: RenderAttempt['onSettled'];
+      let snapshotMethod: RenderAttempt['snapshot'];
+      try {
+        attempt = input.attempt;
+        source = input.source;
+        port = input.port;
+        closeMethod = port?.close;
+        attemptId = attempt.id;
+        generation = attempt.generation;
+        onSettledMethod = attempt.onSettled;
+        snapshotMethod = attempt.snapshot;
+        if (
+          disposed ||
+          !weakSetHas(renderAttempts, attempt) ||
+          (source !== undefined &&
+            ((typeof source !== 'object' && typeof source !== 'function') || source === null)) ||
+          (port !== undefined &&
+            ((typeof port !== 'object' && typeof port !== 'function') ||
+              port === null ||
+              typeof closeMethod !== 'function')) ||
+          !validAttemptId(attemptId) ||
+          (typeof generation !== 'object' && typeof generation !== 'function') ||
+          generation === null ||
+          typeof onSettledMethod !== 'function' ||
+          typeof snapshotMethod !== 'function' ||
+          Reflect.apply(snapshotMethod, attempt, []).outcome !== undefined ||
+          weakMapHas(bindingByAttempt, attempt) ||
+          weakSetHas(pendingAttempts, attempt) ||
+          weakMapHas(bindingByGeneration, generation) ||
+          weakSetHas(pendingGenerations, generation) ||
+          (port !== undefined &&
+            (weakMapHas(bindingByPort, port) ||
+              weakSetHas(pendingPorts, port) ||
+              weakSetHas(retiredPorts, port)))
+        ) {
+          return invalidIssue('invalid_attempt');
+        }
+      } catch {
+        return invalidIssue('invalid_attempt');
+      }
+      if (setSize(bindings) + pendingCount >= MAX_APS_NONCES_PER_ROLE) {
+        return invalidIssue('capability_registry_full');
+      }
+      try {
+        weakSetAdd(pendingAttempts, attempt);
+        weakSetAdd(pendingGenerations, generation);
+        if (port) weakSetAdd(pendingPorts, port);
+        pendingCount += 1;
+      } catch {
+        weakSetDelete(pendingAttempts, attempt);
+        weakSetDelete(pendingGenerations, generation);
+        if (port) weakSetDelete(pendingPorts, port);
+        return invalidIssue('invalid_attempt');
+      }
+
+      const attemptStillIssuable = (): boolean => {
+        try {
+          return (
+            !disposed &&
+            !weakMapHas(bindingByAttempt, attempt) &&
+            !weakMapHas(bindingByGeneration, generation) &&
+            (!port || (!weakMapHas(bindingByPort, port) && !weakSetHas(retiredPorts, port))) &&
+            attempt.id === attemptId &&
+            attempt.generation === generation &&
+            Reflect.apply(snapshotMethod, attempt, []).outcome === undefined
+          );
+        } catch {
+          return false;
+        }
+      };
+
+      let nonce: string | undefined;
+      try {
+        for (let draw = 0; draw < MAX_APS_NONCE_DRAWS; draw += 1) {
+          let minted: unknown;
+          try {
+            minted = Reflect.apply(mintNonce, undefined, []);
+          } catch {
+            return invalidIssue('identity_generation_failed');
+          }
+          const candidate = readMintedNonce(minted, validNonce);
+          if (!attemptStillIssuable()) return invalidIssue('invalid_attempt');
+          if (setSize(bindings) + pendingCount > MAX_APS_NONCES_PER_ROLE) {
+            return invalidIssue('capability_registry_full');
+          }
+          if (!candidate) return invalidIssue('identity_generation_failed');
+          if (!mapGet(liveByNonce, candidate) && !setHas(pendingNonces, candidate)) {
+            nonce = candidate;
+            setAdd(pendingNonces, candidate);
+            break;
+          }
+        }
+        if (!nonce) return invalidIssue('identity_generation_failed');
+        if (!attemptStillIssuable()) return invalidIssue('invalid_attempt');
+
+        const binding: RendererNonceBinding = {
+          nonce,
+          attempt,
+          attemptId,
+          generation,
+          source,
+          port,
+          closeMethod,
+          consumed: false,
+          closed: false,
+        };
+        let committed = false;
+        try {
+          const registered = Reflect.apply(onSettledMethod, attempt, [
+            () => {
+              if (committed) closeBinding(binding);
+            },
+          ]);
+          if (
+            registered !== true ||
+            !attemptStillIssuable() ||
+            setSize(bindings) + pendingCount > MAX_APS_NONCES_PER_ROLE ||
+            mapGet(liveByNonce, nonce) !== undefined ||
+            !setHas(pendingNonces, nonce)
+          ) {
+            return invalidIssue('invalid_attempt');
+          }
+          mapSet(liveByNonce, nonce, binding);
+          weakMapSet(bindingByAttempt, attempt, binding);
+          weakMapSet(bindingByGeneration, generation, binding);
+          if (port) weakMapSet(bindingByPort, port, binding);
+          setAdd(bindings, binding);
+          if (
+            mapGet(liveByNonce, nonce) !== binding ||
+            weakMapGet(bindingByAttempt, attempt) !== binding ||
+            weakMapGet(bindingByGeneration, generation) !== binding ||
+            (port !== undefined && weakMapGet(bindingByPort, port) !== binding) ||
+            !setHas(bindings, binding)
+          ) {
+            rollbackProvisionalBinding(binding);
+            return invalidIssue('invalid_attempt');
+          }
+          committed = true;
+        } catch {
+          rollbackProvisionalBinding(binding);
+          return invalidIssue('invalid_attempt');
+        }
+        return frozen({ ok: true, nonce });
+      } finally {
+        if (nonce) setDelete(pendingNonces, nonce);
+        weakSetDelete(pendingAttempts, attempt);
+        weakSetDelete(pendingGenerations, generation);
+        if (port) weakSetDelete(pendingPorts, port);
+        pendingCount -= 1;
+      }
+    },
+    bindSource(expectation): boolean {
+      try {
+        const fields = readRendererNonceExpectation(expectation);
+        if (
+          disposed ||
+          !fields ||
+          !validNonce(fields.nonce) ||
+          (typeof fields.source !== 'object' && typeof fields.source !== 'function') ||
+          fields.source === null
+        ) {
+          return false;
+        }
+        const binding = mapGet(liveByNonce, fields.nonce);
+        if (
+          !binding ||
+          binding.closed ||
+          binding.consumed ||
+          binding.source !== undefined ||
+          !setHas(bindings, binding) ||
+          fields.attempt !== binding.attempt ||
+          fields.generation !== binding.generation ||
+          (binding.port !== undefined && fields.port !== binding.port) ||
+          (binding.port !== undefined && weakMapGet(bindingByPort, binding.port) !== binding) ||
+          (binding.port === undefined &&
+            (weakMapHas(bindingByPort, fields.port) || weakSetHas(retiredPorts, fields.port))) ||
+          binding.attempt.id !== binding.attemptId ||
+          binding.attempt.generation !== binding.generation ||
+          Reflect.apply(binding.attempt.snapshot, binding.attempt, []).outcome !== undefined ||
+          mapGet(liveByNonce, binding.nonce) !== binding
+        ) {
+          return false;
+        }
+        const closeMethod = fields.port.close;
+        if (typeof closeMethod !== 'function') return false;
+        binding.source = fields.source;
+        if (!binding.port) {
+          binding.port = fields.port;
+          binding.closeMethod = closeMethod;
+          weakMapSet(bindingByPort, fields.port, binding);
+        }
+        return binding.port === fields.port && weakMapGet(bindingByPort, fields.port) === binding;
+      } catch {
+        return false;
+      }
+    },
+    consume(expectation): boolean {
+      try {
+        const fields = readRendererNonceExpectation(expectation);
+        if (disposed || !fields || !validNonce(fields.nonce)) return false;
+        const binding = mapGet(liveByNonce, fields.nonce);
+        if (
+          !binding ||
+          binding.closed ||
+          binding.consumed ||
+          binding.source === undefined ||
+          binding.port === undefined ||
+          !setHas(bindings, binding) ||
+          fields.attempt !== binding.attempt ||
+          fields.generation !== binding.generation ||
+          fields.source !== binding.source ||
+          fields.port !== binding.port ||
+          weakMapGet(bindingByPort, binding.port) !== binding ||
+          binding.attempt.id !== binding.attemptId ||
+          binding.attempt.generation !== binding.generation ||
+          Reflect.apply(binding.attempt.snapshot, binding.attempt, []).outcome !== undefined
+        ) {
+          return false;
+        }
+        if (
+          disposed ||
+          binding.closed ||
+          binding.consumed ||
+          mapGet(liveByNonce, binding.nonce) !== binding ||
+          !mapDelete(liveByNonce, binding.nonce)
+        ) {
+          return false;
+        }
+        binding.consumed = true;
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposed = true;
+      const snapshot = setValueSnapshot(bindings);
+      mapClear(liveByNonce);
+      for (let index = 0; index < snapshot.length; index += 1) {
+        const binding = snapshot[index];
+        if (binding) closeBinding(binding);
+      }
+    },
+    snapshotForTest: () =>
+      frozen({
+        bindings: setSize(bindings),
+        disposed,
+        liveNonces: mapSize(liveByNonce),
+      }),
+  };
+  return frozen(registry);
+}
+
+/** Own the bounded, live-only capabilities for APS bootstrap navigation. */
+export function createBootstrapNonceRegistry(
+  options: BootstrapNonceRegistryOptions = {}
+): BootstrapNonceRegistry {
+  return createApsNonceRegistry('bootstrap', options);
+}
+
+/** Own the bounded, live-only capabilities for APS renderer-document acceptance. */
+export function createRendererNonceRegistry(
+  options: RendererNonceRegistryOptions = {}
+): RendererNonceRegistry {
+  return createApsNonceRegistry('renderer', options);
+}
+
+/** Own one public per-slot result without overwriting either child attempt result. */
+export function createSlotOperation(options: SlotOperationOptions): SlotOperationCreationResult {
+  const observers: Array<(result: SlotOperationResult) => void> = [];
+  let primary: RenderAttempt;
+  let primaryId: string;
+  let primarySlot: string;
+  let primaryNavigationGeneration: object;
+  let primaryOnSettledMethod: RenderAttempt['onSettled'];
+  let primarySnapshotMethod: RenderAttempt['snapshot'];
+  let createFallback: SlotOperationOptions['createFallback'];
+  try {
+    const primaryDescriptor = Object.getOwnPropertyDescriptor(options, 'primary');
+    const fallbackDescriptor = Object.getOwnPropertyDescriptor(options, 'createFallback');
+    if (!primaryDescriptor || !('value' in primaryDescriptor)) {
+      return frozen({ ok: false, reason: 'invalid_attempt' });
+    }
+    primary = primaryDescriptor.value as RenderAttempt;
+    if (!weakSetHas(renderAttempts, primary)) {
+      return frozen({ ok: false, reason: 'invalid_attempt' });
+    }
+    primaryId = primary.id;
+    primarySlot = primary.slot;
+    primaryNavigationGeneration = primary.navigationGeneration;
+    primaryOnSettledMethod = primary.onSettled;
+    primarySnapshotMethod = primary.snapshot;
+    createFallback =
+      fallbackDescriptor && 'value' in fallbackDescriptor
+        ? (fallbackDescriptor.value as SlotOperationOptions['createFallback'])
+        : undefined;
+    if (createFallback !== undefined && typeof createFallback !== 'function') {
+      return frozen({ ok: false, reason: 'invalid_attempt' });
+    }
+  } catch {
+    return frozen({ ok: false, reason: 'invalid_attempt' });
+  }
+  let result: SlotOperationResult | undefined;
+
+  const settle = (terminal: SlotOperationResult): boolean => {
+    if (result) return false;
+    result = frozen(terminal);
+    const snapshot = arraySpliceAll(observers);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const observer = snapshot[index];
+      if (!observer) continue;
+      try {
+        observer(result);
+      } catch {
+        // Observation cannot change the public result.
+      }
+    }
+    return true;
+  };
+
+  const settleFallbackFailure = (primary: RenderOutcome, reason: RenderFailureReason): void => {
+    settle({
+      path: 'fallback',
+      outcome: frozen({ outcome: 'failed', reason }),
+      primaryAttemptId: primaryId,
+      primary,
+    });
+  };
+
+  const beginFallback = (primary: RenderOutcome): void => {
+    let created: unknown;
+    try {
+      created =
+        (createFallback ? Reflect.apply(createFallback, options, [primaryId]) : undefined) ??
+        frozen({ ok: false, reason: 'stale_owner' });
+    } catch {
+      settleFallbackFailure(primary, 'internal_error');
+      return;
+    }
+    let createdOk: boolean;
+    let createdValue: unknown;
+    let creationReason: unknown;
+    try {
+      if (
+        (typeof created !== 'object' && typeof created !== 'function') ||
+        created === null ||
+        !Object.isFrozen(created) ||
+        Object.getPrototypeOf(created) !== Object.prototype ||
+        Object.getOwnPropertySymbols(created).length !== 0
+      ) {
+        throw new TypeError('invalid fallback result');
+      }
+      const ok = Object.getOwnPropertyDescriptor(created, 'ok');
+      if (!ok || !('value' in ok) || ok.enumerable !== true || typeof ok.value !== 'boolean') {
+        throw new TypeError('invalid fallback result');
+      }
+      createdOk = ok.value;
+      const field = Object.getOwnPropertyDescriptor(created, createdOk ? 'value' : 'reason');
+      if (!field || !('value' in field) || field.enumerable !== true) {
+        throw new TypeError('invalid fallback result');
+      }
+      const names = Object.getOwnPropertyNames(created).sort();
+      if (
+        names.length !== 2 ||
+        names[0] !== 'ok' ||
+        names[1] !== (createdOk ? 'value' : 'reason')
+      ) {
+        throw new TypeError('invalid fallback result');
+      }
+      if (createdOk) createdValue = field.value;
+      else creationReason = field.value;
+    } catch {
+      settleFallbackFailure(primary, 'internal_error');
+      return;
+    }
+    if (!createdOk) {
+      settleFallbackFailure(
+        primary,
+        creationReason === 'identity_generation_failed'
+          ? 'identity_generation_failed'
+          : 'internal_error'
+      );
+      return;
+    }
+    let child: RenderAttempt | undefined;
+    let childId: string;
+    let childOnSettledMethod: RenderAttempt['onSettled'];
+    let childCancelMethod: RenderAttempt['cancel'];
+    let cancelInvoked = false;
+    const cancelChild = (): void => {
+      if (cancelInvoked || !child || typeof childCancelMethod !== 'function') return;
+      cancelInvoked = true;
+      try {
+        Reflect.apply(childCancelMethod, child, ['superseded']);
+      } catch {
+        // Fallback cleanup cannot change the operation result.
+      }
+    };
+    try {
+      if (
+        (typeof createdValue !== 'object' && typeof createdValue !== 'function') ||
+        createdValue === null
+      ) {
+        throw new TypeError('invalid fallback child');
+      }
+      child = createdValue as RenderAttempt;
+      const cancel = Object.getOwnPropertyDescriptor(child, 'cancel');
+      if (cancel && 'value' in cancel && typeof cancel.value === 'function') {
+        childCancelMethod = cancel.value as RenderAttempt['cancel'];
+      }
+      if (!weakSetHas(renderAttempts, child)) throw new TypeError('invalid fallback child');
+      childId = child.id;
+      childOnSettledMethod = child.onSettled;
+      childCancelMethod = child.cancel;
+      if (
+        !validAttemptId(childId) ||
+        childId === primaryId ||
+        child.slot !== primarySlot ||
+        child.parentAttemptId !== primaryId ||
+        child.navigationGeneration !== primaryNavigationGeneration ||
+        typeof childOnSettledMethod !== 'function' ||
+        typeof childCancelMethod !== 'function'
+      ) {
+        throw new TypeError('invalid fallback child');
+      }
+    } catch {
+      cancelChild();
+      settleFallbackFailure(primary, 'internal_error');
+      return;
+    }
+    try {
+      const subscribed = Reflect.apply(childOnSettledMethod, child, [
+        (fallbackOutcome: RenderOutcome) => {
+          if (!validOutcome(fallbackOutcome)) {
+            cancelChild();
+            settleFallbackFailure(primary, 'internal_error');
+            return;
+          }
+          settle({
+            path: 'fallback',
+            outcome: fallbackOutcome,
+            primaryAttemptId: primaryId,
+            primary,
+            fallbackAttemptId: childId,
+            fallback: fallbackOutcome,
+          });
+        },
+      ]);
+      if (subscribed !== true && !result) {
+        cancelChild();
+        settleFallbackFailure(primary, 'internal_error');
+      }
+    } catch {
+      if (!result) {
+        cancelChild();
+        settleFallbackFailure(primary, 'internal_error');
+      }
+    }
+  };
+
+  try {
+    const subscribed = Reflect.apply(primaryOnSettledMethod, primary, [
+      (primaryOutcome: RenderOutcome) => {
+        if (!validOutcome(primaryOutcome)) {
+          const internal = frozen({
+            outcome: 'failed' as const,
+            reason: 'internal_error' as const,
+          });
+          settle({
+            path: 'primary',
+            outcome: internal,
+            primaryAttemptId: primaryId,
+            primary: internal,
+          });
+          return;
+        }
+        let attributableGamEmpty = false;
+        if (
+          primaryOutcome.outcome === 'failed' &&
+          primaryOutcome.reason === 'gam_empty' &&
+          typeof createFallback === 'function'
+        ) {
+          try {
+            const snapshot = Reflect.apply(primarySnapshotMethod, primary, []);
+            attributableGamEmpty =
+              snapshot.outcome === primaryOutcome &&
+              snapshot.state === 'failed' &&
+              snapshot.history[snapshot.history.length - 2] === 'waiting_for_gam_and_claim';
+          } catch {
+            attributableGamEmpty = false;
+          }
+        }
+        if (attributableGamEmpty) {
+          beginFallback(primaryOutcome);
+          return;
+        }
+        settle({
+          path: 'primary',
+          outcome: primaryOutcome,
+          primaryAttemptId: primaryId,
+          primary: primaryOutcome,
+        });
+      },
+    ]);
+    if (subscribed !== true && !result) {
+      const internal = frozen({ outcome: 'failed' as const, reason: 'internal_error' as const });
+      settle({
+        path: 'primary',
+        outcome: internal,
+        primaryAttemptId: primaryId,
+        primary: internal,
+      });
+    }
+  } catch {
+    const internal = frozen({ outcome: 'failed' as const, reason: 'internal_error' as const });
+    settle({
+      path: 'primary',
+      outcome: internal,
+      primaryAttemptId: primaryId,
+      primary: internal,
+    });
+  }
+
+  const operation = frozen({
+    snapshot: (): SlotOperationSnapshot =>
+      result ? frozen({ settled: true, result }) : frozen({ settled: false }),
+    onSettled(callback: (terminal: SlotOperationResult) => void): boolean {
+      if (typeof callback !== 'function') return false;
+      if (result) {
+        try {
+          callback(result);
+        } catch {
+          // Observation cannot change the public result.
+        }
+      } else {
+        arrayPush(observers, callback);
+      }
+      return true;
+    },
+  });
+  return frozen({ ok: true, value: operation });
+}
diff --git a/crates/trusted-server-js/lib/src/services/reservations.ts b/crates/trusted-server-js/lib/src/services/reservations.ts
new file mode 100644
index 000000000..00b1385e5
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/reservations.ts
@@ -0,0 +1,1420 @@
+import type { WinnerContext, WinnerContextAdmission } from '../kernel/sessions';
+
+export const RENDER_RESERVATION_LIFETIME_MS = 15 * 60 * 1_000;
+export const PREBID_ADMISSION_LEASE_MS = 10_000;
+
+const RESERVATION_ID = /^r1_[A-Za-z0-9_-]{22}$/;
+const ATTEMPT_ID = /^a1_[A-Za-z0-9_-]{22}$/;
+const AUCTION_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+const MAX_RESERVATIONS = 320;
+const textEncoder = new TextEncoder();
+
+const objectFreezeIntrinsic = Object.freeze;
+const regexpTestIntrinsic = RegExp.prototype.test;
+const stringCharCodeAtIntrinsic = String.prototype.charCodeAt;
+const textEncoderEncodeIntrinsic = TextEncoder.prototype.encode;
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapEntriesIntrinsic = Map.prototype.entries;
+const mapGetIntrinsic = Map.prototype.get;
+const mapSetIntrinsic = Map.prototype.set;
+const mapValuesIntrinsic = Map.prototype.values;
+const mapIteratorNextIntrinsic = Object.getPrototypeOf(new Map().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const mapEntryIteratorNextIntrinsic = Object.getPrototypeOf(new Map().entries()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size')?.get as (
+  this: Map<unknown, unknown>
+) => number;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+const weakSetAddIntrinsic = WeakSet.prototype.add;
+const weakSetHasIntrinsic = WeakSet.prototype.has;
+const performanceNowIntrinsic = performance.now;
+const reservationServices = new WeakSet<object>();
+
+function mapValue<Key, Value>(map: Map<Key, Value>, key: Key): Value | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setMapValue<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void {
+  Reflect.apply(mapSetIntrinsic, map, [key, value]);
+}
+
+function deleteMapValue<Key, Value>(map: Map<Key, Value>, key: Key): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function mapSize<Key, Value>(map: Map<Key, Value>): number {
+  return Reflect.apply(mapSizeGetter, map, []) as number;
+}
+
+function weakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): Value | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setWeakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key,
+  value: Value
+): void {
+  Reflect.apply(weakMapSetIntrinsic, map, [key, value]);
+}
+
+function addWeakSetValue<Value extends object>(set: WeakSet<Value>, value: Value): void {
+  Reflect.apply(weakSetAddIntrinsic, set, [value]);
+}
+
+function hasWeakSetValue<Value extends object>(set: WeakSet<Value>, value: Value): boolean {
+  return Reflect.apply(weakSetHasIntrinsic, set, [value]) as boolean;
+}
+
+function mapValueSnapshot<Key, Value>(map: Map<Key, Value>): Value[] {
+  const iterator = Reflect.apply(mapValuesIntrinsic, map, []) as IterableIterator<Value>;
+  const values: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(mapIteratorNextIntrinsic, iterator, []) as IteratorResult<Value>;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function entrySnapshot<Key, Value>(map: Map<Key, Value>): [Key, Value][] {
+  const iterator = Reflect.apply(mapEntriesIntrinsic, map, []) as IterableIterator<[Key, Value]>;
+  const values: [Key, Value][] = [];
+  while (true) {
+    const step = Reflect.apply(mapEntryIteratorNextIntrinsic, iterator, []) as IteratorResult<
+      [Key, Value]
+    >;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function ownDataRecord(
+  value: unknown,
+  expectedKeys: readonly string[]
+): Record<string, unknown> | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+    if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length !== expectedKeys.length) return undefined;
+    for (let expectedIndex = 0; expectedIndex < expectedKeys.length; expectedIndex += 1) {
+      const expected = expectedKeys[expectedIndex];
+      let found = false;
+      for (let nameIndex = 0; nameIndex < names.length; nameIndex += 1) {
+        if (names[nameIndex] === expected) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return undefined;
+    }
+    const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (let index = 0; index < names.length; index += 1) {
+      const name = names[index];
+      if (name === undefined) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      output[name] = descriptor.value;
+    }
+    return output;
+  } catch {
+    return undefined;
+  }
+}
+
+function frozenResult<Value extends object>(value: Value): Readonly<Value> {
+  return Reflect.apply(objectFreezeIntrinsic, Object, [value]) as Readonly<Value>;
+}
+
+function matches(pattern: RegExp, value: string): boolean {
+  return Reflect.apply(regexpTestIntrinsic, pattern, [value]) as boolean;
+}
+
+function validBoundedString(value: unknown, maximumBytes: number): value is string {
+  if (typeof value !== 'string' || value.length === 0) return false;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = Reflect.apply(stringCharCodeAtIntrinsic, value, [index]) as number;
+    if (code <= 0x1f || code === 0x7f) return false;
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = Reflect.apply(stringCharCodeAtIntrinsic, value, [index + 1]) as number;
+      if (!(next >= 0xdc00 && next <= 0xdfff)) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) return false;
+  }
+  return (
+    (Reflect.apply(textEncoderEncodeIntrinsic, textEncoder, [value]) as Uint8Array).length <=
+    maximumBytes
+  );
+}
+
+function copyTaggedRenderSource(value: unknown): ReservationRenderSource | undefined {
+  try {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+    if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+    if (Object.getOwnPropertySymbols(value).length !== 0) return undefined;
+    const names = Object.getOwnPropertyNames(value);
+    const output: Record<string, unknown> = {};
+    for (let index = 0; index < names.length; index += 1) {
+      const name = names[index];
+      if (name === undefined) return undefined;
+      const descriptor = Object.getOwnPropertyDescriptor(value, name);
+      if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) return undefined;
+      if (typeof descriptor.value !== 'string' && typeof descriptor.value !== 'number') {
+        return undefined;
+      }
+      Object.defineProperty(output, name, {
+        configurable: true,
+        enumerable: true,
+        value: descriptor.value,
+        writable: true,
+      });
+    }
+    if ((output.type !== 'aps' && output.type !== 'adm') || output.version !== 1) {
+      return undefined;
+    }
+    return frozenResult(output) as ReservationRenderSource;
+  } catch {
+    return undefined;
+  }
+}
+
+export interface ReservationOwner {
+  readonly generation: object;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: () => void) => void;
+}
+
+export interface ReservationAttempt {
+  readonly id: string;
+  readonly slot: string;
+  readonly winnerContext: WinnerContext | undefined;
+  readonly isCurrent: () => boolean;
+  readonly prepareWinnerContext: (context: WinnerContext) => WinnerContextAdmission | undefined;
+}
+
+export interface ReservationServiceOptions {
+  readonly now?: () => number;
+  readonly prepareRenderSource: (candidate: unknown) => ReservationRenderSource | undefined;
+}
+
+export interface FirstDisplayReservationTombstoneAdoptionV1 {
+  readonly clockEpochMs: number;
+  readonly tombstones: readonly Readonly<{
+    readonly expiresAtMs: number;
+    readonly reservationId: string;
+  }>[];
+}
+
+/** Tagged browser render source copied after an injected exact parser accepts it. */
+export type ReservationRenderSource = Readonly<{
+  type: 'aps' | 'adm';
+  version: 1;
+}> &
+  Readonly<object>;
+
+export interface ReservationRegistrationInput {
+  readonly reservationId: unknown;
+  readonly slot: unknown;
+  readonly navigation: ReservationOwner;
+  readonly attemptId: unknown;
+  readonly renderSource: unknown;
+  readonly winnerContext: unknown;
+}
+
+export interface PrebidLeaseRegistrationInput {
+  readonly reservationId: unknown;
+  readonly slot: unknown;
+  readonly navigation: ReservationOwner;
+  readonly auctionId: unknown;
+  readonly adUnitCode: unknown;
+  readonly renderSource: unknown;
+  readonly winnerContext: unknown;
+  readonly prebidBid: unknown;
+}
+
+export type ReservationRegistrationResult =
+  | Readonly<{ ok: true; expiresAt: number }>
+  | Readonly<{
+      ok: false;
+      reason:
+        | 'invalid_reservation_id'
+        | 'invalid_slot'
+        | 'invalid_render_source'
+        | 'invalid_winner_context'
+        | 'invalid_attempt'
+        | 'prebid_cpm_mismatch'
+        | 'reservation_collision'
+        | 'reservation_not_live'
+        | 'registry_full'
+        | 'service_disposed'
+        | 'stale_owner';
+    }>;
+
+export type ReservationTombstoneState =
+  | 'aborted'
+  | 'consumed'
+  | 'disposed'
+  | 'prebid_admission_failed'
+  | 'prebid_contract_violation'
+  | 'prebid_selection_timeout'
+  | 'stale'
+  | 'unselected';
+
+export type ReservationState =
+  'awaiting_prebid_selection' | 'renderable' | ReservationTombstoneState;
+
+export type ReservationRecognition =
+  | Readonly<{ recognized: false }>
+  | Readonly<{ recognized: true; state: ReservationState; expiresAt: number }>;
+
+export interface PromotePrebidSelectionInput {
+  readonly reservationId: unknown;
+  readonly auctionId: unknown;
+  readonly adUnitCode: unknown;
+  readonly navigationGeneration: object;
+  readonly attempt: ReservationAttempt;
+  readonly prebidBid: unknown;
+}
+
+export interface ReservationClaimInput {
+  readonly reservationId: unknown;
+  readonly slot: unknown;
+  readonly navigationGeneration: object;
+  readonly attempt: ReservationAttempt;
+  readonly pucSource: unknown;
+}
+
+export interface ReservationTombstoneInput {
+  readonly reservationId: unknown;
+  readonly slot: unknown;
+  readonly navigationGeneration: object;
+  readonly attemptId: unknown;
+}
+
+export interface PrebidGroupOwnerInput {
+  readonly auctionId: unknown;
+  readonly adUnitCode: unknown;
+  readonly navigationGeneration: object;
+}
+
+export interface PrebidLeaseOwnerInput extends PrebidGroupOwnerInput {
+  readonly reservationId: unknown;
+}
+
+export type ReservationClaimResult =
+  | Readonly<{ recognized: false }>
+  | Readonly<{ recognized: true; claimed: false; state: ReservationState }>
+  | Readonly<{
+      recognized: true;
+      claimed: true;
+      pucSource: object;
+      expiresAt: number;
+    }>;
+
+/** Exact lifecycle authority required to consume one successful claim object. */
+export interface ReservationClaimExpectation {
+  readonly attempt: ReservationAttempt;
+  readonly attemptId: string;
+  readonly slot: string;
+  readonly navigationGeneration: object;
+  readonly winnerContext: WinnerContext;
+}
+
+/** Source and winner context atomically recovered from one valid claim object. */
+export interface ReservationClaimAdmission {
+  readonly renderSource: ReservationRenderSource;
+  readonly winnerContext: WinnerContext;
+}
+
+export interface ReservationServiceInventory {
+  readonly clockFaulted: boolean;
+  readonly disposed: boolean;
+  readonly size: number;
+  readonly live: number;
+  readonly tombstones: number;
+  readonly entriesWithRenderSource: number;
+  readonly entriesWithWinnerContext: number;
+  readonly entriesWithPucSource: number;
+}
+
+export interface ReservationService {
+  readonly adoptFirstDisplayTombstones: (
+    candidate: FirstDisplayReservationTombstoneAdoptionV1
+  ) => boolean;
+  readonly registerRender: (input: ReservationRegistrationInput) => ReservationRegistrationResult;
+  readonly registerPrebidLease: (
+    input: PrebidLeaseRegistrationInput
+  ) => ReservationRegistrationResult;
+  readonly promotePrebidSelection: (
+    input: PromotePrebidSelectionInput
+  ) => ReservationRegistrationResult;
+  readonly claim: (input: ReservationClaimInput) => ReservationClaimResult;
+  readonly consumeClaim: (
+    claim: unknown,
+    expectation: ReservationClaimExpectation
+  ) => ReservationClaimAdmission | undefined;
+  readonly recognize: (reservationId: unknown) => ReservationRecognition;
+  readonly tombstone: (input: ReservationTombstoneInput, state: 'disposed' | 'stale') => boolean;
+  readonly tombstonePrebidGroup: (
+    input: PrebidGroupOwnerInput,
+    state: 'aborted' | 'prebid_selection_timeout' | 'unselected'
+  ) => number;
+  readonly tombstonePrebidLease: (
+    input: PrebidLeaseOwnerInput,
+    state: 'prebid_admission_failed' | 'prebid_contract_violation'
+  ) => boolean;
+  readonly dispose: () => void;
+  readonly snapshotInventoryForTest: () => ReservationServiceInventory;
+}
+
+interface LiveReservation {
+  readonly reservationId: string;
+  readonly slot: string;
+  readonly navigationGeneration: object;
+  readonly renderSource: ReservationRenderSource;
+  readonly winnerContext: WinnerContext;
+  expiresAt: number;
+  state: 'awaiting_prebid_selection' | 'renderable';
+  attemptId: string | undefined;
+  auctionId: string | undefined;
+  adUnitCode: string | undefined;
+  busy: boolean;
+  pucSource: object | undefined;
+}
+
+interface ReservationTombstone {
+  readonly expiresAt: number;
+  readonly state: ReservationTombstoneState;
+}
+
+interface ClaimedAdmission {
+  readonly attempt: ReservationAttempt;
+  readonly attemptId: string;
+  readonly expiresAt: number;
+  readonly slot: string;
+  readonly navigationGeneration: object;
+  active: boolean;
+  renderSource: ReservationRenderSource | undefined;
+  winnerContext: WinnerContext | undefined;
+}
+
+type ReservationEntry = LiveReservation | ReservationTombstone;
+
+interface OwnerSnapshot {
+  readonly identity: object;
+  readonly generation: object;
+  readonly isCurrent: () => boolean;
+  readonly onDispose: (kind: string, callback: () => void) => void;
+  readonly readGeneration: () => object | undefined;
+}
+
+interface OwnerRegistration {
+  readonly callbackState: OwnerCallbackState;
+  readonly identity: object;
+  ready: boolean;
+}
+
+interface OwnerCallbackState {
+  active: boolean;
+  disposed: boolean;
+}
+
+function liveEntry(entry: ReservationEntry): entry is LiveReservation {
+  return entry.state === 'awaiting_prebid_selection' || entry.state === 'renderable';
+}
+
+function ownerDisposalState(entry: LiveReservation): 'aborted' | 'disposed' {
+  return entry.state === 'awaiting_prebid_selection' ? 'aborted' : 'disposed';
+}
+
+function validRenderTombstoneState(value: unknown): value is 'disposed' | 'stale' {
+  return value === 'disposed' || value === 'stale';
+}
+
+function validPrebidLeaseTombstoneState(
+  value: unknown
+): value is 'prebid_admission_failed' | 'prebid_contract_violation' {
+  return value === 'prebid_admission_failed' || value === 'prebid_contract_violation';
+}
+
+function validPrebidGroupTombstoneState(
+  value: unknown
+): value is 'aborted' | 'prebid_selection_timeout' | 'unselected' {
+  return value === 'aborted' || value === 'prebid_selection_timeout' || value === 'unselected';
+}
+
+function winnerContext(value: unknown): WinnerContext | undefined {
+  const record = ownDataRecord(value, ['selectedCpm']);
+  if (
+    !record ||
+    typeof record.selectedCpm !== 'number' ||
+    !Number.isFinite(record.selectedCpm) ||
+    record.selectedCpm < 0
+  ) {
+    return undefined;
+  }
+  return frozenResult({ selectedCpm: record.selectedCpm });
+}
+
+function prebidCpmMatches(value: unknown, context: WinnerContext): boolean {
+  try {
+    if (
+      (typeof value !== 'object' && typeof value !== 'function') ||
+      value === null ||
+      !Object.isFrozen(value)
+    ) {
+      return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, 'cpm');
+    return (
+      !!descriptor && 'value' in descriptor && Object.is(descriptor.value, context.selectedCpm)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function ownerSnapshot(value: unknown): OwnerSnapshot | undefined {
+  try {
+    if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
+      return undefined;
+    }
+    const owner = value as ReservationOwner;
+    const generation = owner.generation;
+    const isCurrentMethod = owner.isCurrent;
+    const onDisposeMethod = owner.onDispose;
+    if (
+      (typeof generation !== 'object' && typeof generation !== 'function') ||
+      generation === null ||
+      typeof isCurrentMethod !== 'function' ||
+      typeof onDisposeMethod !== 'function'
+    ) {
+      return undefined;
+    }
+    return {
+      identity: value as object,
+      generation,
+      isCurrent: () => Reflect.apply(isCurrentMethod, value, []) as boolean,
+      onDispose: (kind, callback) => {
+        Reflect.apply(onDisposeMethod, value, [kind, callback]);
+      },
+      readGeneration: () => {
+        try {
+          const current = (value as ReservationOwner).generation;
+          return (typeof current === 'object' || typeof current === 'function') && current !== null
+            ? current
+            : undefined;
+        } catch {
+          return undefined;
+        }
+      },
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function currentOwner(owner: OwnerSnapshot): boolean {
+  try {
+    return owner.isCurrent() === true;
+  } catch {
+    return false;
+  }
+}
+
+function currentAttempt(attempt: ReservationAttempt): boolean {
+  try {
+    return attempt.isCurrent() === true;
+  } catch {
+    return false;
+  }
+}
+
+function attemptIdentity(attempt: ReservationAttempt): { id: string; slot: string } | undefined {
+  try {
+    const id = attempt.id;
+    const slot = attempt.slot;
+    if (!matches(ATTEMPT_ID, id) || !validBoundedString(slot, 256)) return undefined;
+    return { id, slot };
+  } catch {
+    return undefined;
+  }
+}
+
+function prepareWinnerAdmission(
+  attempt: ReservationAttempt,
+  context: WinnerContext
+): WinnerContextAdmission | undefined {
+  try {
+    const prepare = attempt.prepareWinnerContext;
+    if (typeof prepare !== 'function') return undefined;
+    const admission = Reflect.apply(prepare, attempt, [context]) as unknown;
+    if ((typeof admission !== 'object' && typeof admission !== 'function') || admission === null) {
+      return undefined;
+    }
+    const commit = (admission as WinnerContextAdmission).commit;
+    const rollback = (admission as WinnerContextAdmission).rollback;
+    if (typeof commit !== 'function' || typeof rollback !== 'function') return undefined;
+    return frozenResult({
+      commit: (): boolean => Reflect.apply(commit, admission, []) === true,
+      rollback: (): boolean => Reflect.apply(rollback, admission, []) === true,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function commitWinnerAdmission(
+  attempt: ReservationAttempt,
+  admission: WinnerContextAdmission,
+  context: WinnerContext
+): boolean {
+  try {
+    return admission.commit() === true && attempt.winnerContext === context;
+  } catch {
+    return false;
+  }
+}
+
+function rollbackWinnerAdmission(admission: WinnerContextAdmission | undefined): void {
+  try {
+    admission?.rollback();
+  } catch {
+    // The reservation is terminally suppressed even when a hostile rollback fails.
+  }
+}
+
+function monotonicClock(source: () => number): () => number | undefined {
+  let last = Number.NEGATIVE_INFINITY;
+  return (): number | undefined => {
+    try {
+      const value = source();
+      if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value < last) {
+        return undefined;
+      }
+      last = value;
+      return value;
+    } catch {
+      return undefined;
+    }
+  };
+}
+
+function fixedExpiry(now: number, lifetime: number): number | undefined {
+  const expiresAt = now + lifetime;
+  return Number.isFinite(expiresAt) && expiresAt > now ? expiresAt : undefined;
+}
+
+function defaultNow(): number {
+  return Reflect.apply(performanceNowIntrinsic, performance, []) as number;
+}
+
+/** Whether a candidate is one exact server-minted renderer reservation id. */
+export function isRendererReservationId(value: unknown): value is string {
+  return typeof value === 'string' && matches(RESERVATION_ID, value);
+}
+
+/** Whether a candidate is an exact service instance created by this module. */
+export function isReservationService(value: unknown): value is ReservationService {
+  try {
+    return (
+      ((typeof value === 'object' && value !== null) || typeof value === 'function') &&
+      hasWeakSetValue(reservationServices, value)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Construct the runtime-owned renderer reservation service. */
+export function createReservationService(options: ReservationServiceOptions): ReservationService {
+  let nowSource: () => number = defaultNow;
+  let prepareRenderSource: ReservationServiceOptions['prepareRenderSource'] | undefined;
+  let disposed = false;
+  let clockFaulted = false;
+  let storeFaulted = false;
+  try {
+    if (options.now !== undefined) {
+      if (typeof options.now !== 'function') disposed = true;
+      else nowSource = options.now;
+    }
+    if (typeof options.prepareRenderSource !== 'function') disposed = true;
+    else prepareRenderSource = options.prepareRenderSource;
+  } catch {
+    disposed = true;
+  }
+  const readNow = monotonicClock(nowSource);
+  const entries = new Map<string, ReservationEntry>();
+  const ownerRegistrations = new WeakMap<object, OwnerRegistration>();
+  const claimAdmissions = new Map<object, ClaimedAdmission>();
+  let adoptionOpen = true;
+
+  const invalidateClaimAdmission = (claim: object, admission: ClaimedAdmission): void => {
+    if (mapValue(claimAdmissions, claim) === admission) deleteMapValue(claimAdmissions, claim);
+    admission.active = false;
+    admission.renderSource = undefined;
+    admission.winnerContext = undefined;
+  };
+
+  const invalidateClaimAdmissions = (predicate: (admission: ClaimedAdmission) => boolean): void => {
+    const snapshot = entrySnapshot(claimAdmissions);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const pair = snapshot[index];
+      if (pair && predicate(pair[1])) invalidateClaimAdmission(pair[0], pair[1]);
+    }
+  };
+
+  const disposeStore = (): void => {
+    disposed = true;
+    invalidateClaimAdmissions(() => true);
+    const snapshot = entrySnapshot(entries);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const pair = snapshot[index];
+      if (pair) deleteMapValue(entries, pair[0]);
+    }
+  };
+
+  const prune = (now: number): void => {
+    invalidateClaimAdmissions((admission) => admission.expiresAt <= now);
+    const snapshot = entrySnapshot(entries);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const pair = snapshot[index];
+      if (!pair) continue;
+      const id = pair[0];
+      const entry = pair[1];
+      if (entry.expiresAt <= now) {
+        if (mapValue(entries, id) === entry) deleteMapValue(entries, id);
+      }
+    }
+  };
+
+  const clock = (): number | undefined => {
+    if (disposed || clockFaulted || storeFaulted) return undefined;
+    const now = readNow();
+    if (now === undefined) {
+      if (mapSize(entries) === 0) disposeStore();
+      else clockFaulted = true;
+      return undefined;
+    }
+    prune(now);
+    return now;
+  };
+
+  const refreshForLookup = (): boolean => {
+    if (disposed) return false;
+    if (clockFaulted || storeFaulted) return true;
+    const now = clock();
+    return now !== undefined || clockFaulted || storeFaulted;
+  };
+
+  const refreshForTerminalMutation = (): boolean => {
+    if (disposed || storeFaulted) return false;
+    if (clockFaulted) return true;
+    const now = clock();
+    return now !== undefined || clockFaulted;
+  };
+
+  const publishEntry = (
+    reservationId: string,
+    expected: ReservationEntry | undefined,
+    next: ReservationEntry,
+    allowClockFault = false
+  ): boolean => {
+    if (disposed || storeFaulted || (clockFaulted && !allowClockFault)) return false;
+    let before: ReservationEntry | undefined;
+    try {
+      before = mapValue(entries, reservationId);
+    } catch {
+      storeFaulted = true;
+      return false;
+    }
+    if (before !== expected) return false;
+    try {
+      setMapValue(entries, reservationId, next);
+    } catch {
+      // The captured operation may have applied the exact value before throwing.
+    }
+    let after: ReservationEntry | undefined;
+    try {
+      after = mapValue(entries, reservationId);
+    } catch {
+      storeFaulted = true;
+      return false;
+    }
+    if (after === next) return true;
+    storeFaulted = true;
+    return false;
+  };
+
+  const replaceWithTombstone = (
+    reservationId: string,
+    expected: LiveReservation,
+    state: ReservationTombstoneState
+  ): boolean => {
+    const tombstone = frozenResult({ expiresAt: expected.expiresAt, state });
+    return publishEntry(reservationId, expected, tombstone, true);
+  };
+
+  const readOwnerRegistration = (
+    generation: object
+  ): Readonly<{ ok: true; value: OwnerRegistration | undefined }> | Readonly<{ ok: false }> => {
+    try {
+      return { ok: true, value: weakMapValue(ownerRegistrations, generation) };
+    } catch {
+      return { ok: false };
+    }
+  };
+
+  const publishOwnerRegistration = (
+    generation: object,
+    registration: OwnerRegistration
+  ): boolean => {
+    try {
+      setWeakMapValue(ownerRegistrations, generation, registration);
+    } catch {
+      // The captured operation may have applied the exact registration before throwing.
+    }
+    const current = readOwnerRegistration(generation);
+    if (!current.ok || current.value !== registration) {
+      registration.callbackState.active = false;
+      return false;
+    }
+    return true;
+  };
+
+  const disposeOwnerEntries = (generation: object, state: OwnerCallbackState): void => {
+    if (!state.active || state.disposed) return;
+    state.disposed = true;
+    invalidateClaimAdmissions((admission) => admission.navigationGeneration === generation);
+    const snapshot = entrySnapshot(entries);
+    for (let index = 0; index < snapshot.length; index += 1) {
+      const pair = snapshot[index];
+      if (!pair) continue;
+      const entry = pair[1];
+      if (liveEntry(entry) && entry.navigationGeneration === generation) {
+        replaceWithTombstone(pair[0], entry, ownerDisposalState(entry));
+      }
+    }
+  };
+
+  const ensureOwnerRegistration = (owner: OwnerSnapshot): OwnerRegistration | undefined => {
+    const initial = readOwnerRegistration(owner.generation);
+    if (!initial.ok) return undefined;
+    const existing = initial.value;
+    if (existing) {
+      if (existing.identity !== owner.identity) return undefined;
+      const ownerIsCurrent = currentOwner(owner);
+      const currentGeneration = owner.readGeneration();
+      const current = readOwnerRegistration(owner.generation);
+      return ownerIsCurrent &&
+        currentGeneration === owner.generation &&
+        current.ok &&
+        current.value === existing &&
+        existing.ready &&
+        existing.callbackState.active &&
+        !existing.callbackState.disposed
+        ? existing
+        : undefined;
+    }
+
+    const callbackState: OwnerCallbackState = {
+      active: true,
+      disposed: false,
+    };
+    const registration: OwnerRegistration = {
+      callbackState,
+      identity: owner.identity,
+      ready: false,
+    };
+    const generation = owner.generation;
+    if (!publishOwnerRegistration(generation, registration)) return undefined;
+    try {
+      owner.onDispose('reservation', () => disposeOwnerEntries(generation, callbackState));
+    } catch {
+      callbackState.disposed = true;
+      return undefined;
+    }
+    const ownerIsCurrent = currentOwner(owner);
+    const currentGeneration = owner.readGeneration();
+    const current = readOwnerRegistration(generation);
+    if (
+      !ownerIsCurrent ||
+      currentGeneration !== generation ||
+      !current.ok ||
+      current.value !== registration ||
+      !callbackState.active ||
+      callbackState.disposed
+    ) {
+      callbackState.disposed = true;
+      return undefined;
+    }
+    registration.ready = true;
+    return registration;
+  };
+
+  const currentOwnerRegistration = (owner: OwnerSnapshot, expected: OwnerRegistration): boolean => {
+    const current = readOwnerRegistration(owner.generation);
+    return (
+      current.ok &&
+      current.value === expected &&
+      expected.ready &&
+      expected.callbackState.active &&
+      !expected.callbackState.disposed
+    );
+  };
+
+  const failure = (
+    reason: Extract<ReservationRegistrationResult, { ok: false }>['reason']
+  ): ReservationRegistrationResult => frozenResult({ ok: false, reason });
+
+  const register = (candidate: unknown, prebid: boolean): ReservationRegistrationResult => {
+    const keys = prebid
+      ? [
+          'reservationId',
+          'slot',
+          'navigation',
+          'auctionId',
+          'adUnitCode',
+          'renderSource',
+          'winnerContext',
+          'prebidBid',
+        ]
+      : ['reservationId', 'slot', 'navigation', 'attemptId', 'renderSource', 'winnerContext'];
+    const input = ownDataRecord(candidate, keys);
+    if (!input || !isRendererReservationId(input.reservationId)) {
+      return failure('invalid_reservation_id');
+    }
+    if (!validBoundedString(input.slot, 256)) return failure('invalid_slot');
+    const context = winnerContext(input.winnerContext);
+    if (!context) return failure('invalid_winner_context');
+    let renderSource: ReservationRenderSource | undefined;
+    try {
+      renderSource = copyTaggedRenderSource(prepareRenderSource?.(input.renderSource));
+    } catch {
+      renderSource = undefined;
+    }
+    if (!renderSource) return failure('invalid_render_source');
+    const owner = ownerSnapshot(input.navigation);
+    if (!owner || !currentOwner(owner)) return failure('stale_owner');
+
+    let attemptId: string | undefined;
+    let auctionId: string | undefined;
+    let adUnitCode: string | undefined;
+    if (prebid) {
+      if (
+        typeof input.auctionId !== 'string' ||
+        !matches(AUCTION_ID, input.auctionId) ||
+        !validBoundedString(input.adUnitCode, 256) ||
+        input.adUnitCode !== input.slot ||
+        !prebidCpmMatches(input.prebidBid, context)
+      ) {
+        return failure('prebid_cpm_mismatch');
+      }
+      auctionId = input.auctionId;
+      adUnitCode = input.adUnitCode;
+    } else {
+      if (typeof input.attemptId !== 'string' || !matches(ATTEMPT_ID, input.attemptId)) {
+        return failure('invalid_attempt');
+      }
+      attemptId = input.attemptId;
+    }
+
+    const now = clock();
+    if (now === undefined) return failure('service_disposed');
+    const expiresAt = fixedExpiry(
+      now,
+      prebid ? PREBID_ADMISSION_LEASE_MS : RENDER_RESERVATION_LIFETIME_MS
+    );
+    if (expiresAt === undefined) {
+      disposeStore();
+      return failure('service_disposed');
+    }
+    if (mapValue(entries, input.reservationId) !== undefined) {
+      return failure('reservation_collision');
+    }
+    if (mapSize(entries) >= MAX_RESERVATIONS) return failure('registry_full');
+    const entry: LiveReservation = {
+      reservationId: input.reservationId,
+      slot: input.slot,
+      navigationGeneration: owner.generation,
+      renderSource,
+      winnerContext: context,
+      expiresAt,
+      state: prebid ? 'awaiting_prebid_selection' : 'renderable',
+      attemptId,
+      auctionId,
+      adUnitCode,
+      busy: false,
+      pucSource: undefined,
+    };
+    const success = frozenResult({ ok: true as const, expiresAt: entry.expiresAt });
+    const staleOwner = failure('stale_owner');
+    const ownerRegistration = ensureOwnerRegistration(owner);
+    if (!ownerRegistration) {
+      const rejected = frozenResult({
+        expiresAt: entry.expiresAt,
+        state: ownerDisposalState(entry),
+      });
+      return publishEntry(input.reservationId, undefined, rejected)
+        ? staleOwner
+        : failure('service_disposed');
+    }
+    if (!publishEntry(input.reservationId, undefined, entry)) {
+      return failure('service_disposed');
+    }
+    const ownerIsCurrent = currentOwner(owner);
+    const currentGeneration = owner.readGeneration();
+    const ownerRegistrationIsCurrent = currentOwnerRegistration(owner, ownerRegistration);
+    const entryIsCurrent = mapValue(entries, input.reservationId) === entry;
+    if (
+      !ownerIsCurrent ||
+      currentGeneration !== entry.navigationGeneration ||
+      !ownerRegistrationIsCurrent ||
+      !entryIsCurrent
+    ) {
+      replaceWithTombstone(input.reservationId, entry, ownerDisposalState(entry));
+      return staleOwner;
+    }
+    return success;
+  };
+
+  const recognize = (reservationId: unknown): ReservationRecognition => {
+    if (!refreshForLookup() || typeof reservationId !== 'string') {
+      return frozenResult({ recognized: false });
+    }
+    const entry = mapValue(entries, reservationId);
+    return entry
+      ? frozenResult({ recognized: true, state: entry.state, expiresAt: entry.expiresAt })
+      : frozenResult({ recognized: false });
+  };
+
+  const refusedClaim = (state: ReservationState): ReservationClaimResult =>
+    frozenResult({ recognized: true as const, claimed: false as const, state });
+
+  const service: ReservationService = {
+    adoptFirstDisplayTombstones(candidate): boolean {
+      if (
+        !adoptionOpen ||
+        disposed ||
+        clockFaulted ||
+        storeFaulted ||
+        mapSize(entries) !== 0 ||
+        mapSize(claimAdmissions) !== 0 ||
+        typeof candidate !== 'object' ||
+        candidate === null ||
+        typeof candidate.clockEpochMs !== 'number' ||
+        !Number.isFinite(candidate.clockEpochMs) ||
+        candidate.clockEpochMs < 0 ||
+        !Array.isArray(candidate.tombstones) ||
+        candidate.tombstones.length > MAX_RESERVATIONS
+      ) {
+        return false;
+      }
+      const now = clock();
+      if (now === undefined) return false;
+      const prepared = new Map<string, ReservationTombstone>();
+      for (const tombstone of candidate.tombstones) {
+        if (
+          typeof tombstone !== 'object' ||
+          tombstone === null ||
+          typeof tombstone.reservationId !== 'string' ||
+          !matches(RESERVATION_ID, tombstone.reservationId) ||
+          prepared.has(tombstone.reservationId) ||
+          typeof tombstone.expiresAtMs !== 'number' ||
+          !Number.isFinite(tombstone.expiresAtMs) ||
+          tombstone.expiresAtMs < 0
+        ) {
+          return false;
+        }
+        const remainingMs = tombstone.expiresAtMs - candidate.clockEpochMs;
+        if (remainingMs <= 0) continue;
+        const expiresAt = now + remainingMs;
+        if (!Number.isFinite(expiresAt) || expiresAt <= now) return false;
+        prepared.set(
+          tombstone.reservationId,
+          frozenResult({ expiresAt, state: 'consumed' as const })
+        );
+      }
+      const published: string[] = [];
+      for (const [reservationId, tombstone] of prepared) {
+        if (!publishEntry(reservationId, undefined, tombstone)) {
+          for (const publishedId of published) deleteMapValue(entries, publishedId);
+          return false;
+        }
+        published.push(reservationId);
+      }
+      adoptionOpen = false;
+      return true;
+    },
+    registerRender: (input) => {
+      adoptionOpen = false;
+      return register(input, false);
+    },
+    registerPrebidLease: (input) => {
+      adoptionOpen = false;
+      return register(input, true);
+    },
+    promotePrebidSelection(input): ReservationRegistrationResult {
+      adoptionOpen = false;
+      const fields = ownDataRecord(input, [
+        'reservationId',
+        'auctionId',
+        'adUnitCode',
+        'navigationGeneration',
+        'attempt',
+        'prebidBid',
+      ]);
+      const now = clock();
+      if (now === undefined) return failure('service_disposed');
+      if (!fields || typeof fields.reservationId !== 'string') {
+        return failure('reservation_not_live');
+      }
+      const entry = mapValue(entries, fields.reservationId);
+      if (
+        !entry ||
+        !liveEntry(entry) ||
+        entry.state !== 'awaiting_prebid_selection' ||
+        entry.busy ||
+        fields.auctionId !== entry.auctionId ||
+        fields.adUnitCode !== entry.adUnitCode ||
+        fields.navigationGeneration !== entry.navigationGeneration ||
+        !prebidCpmMatches(fields.prebidBid, entry.winnerContext)
+      ) {
+        return failure('reservation_not_live');
+      }
+      const promotedExpiry = fixedExpiry(now, RENDER_RESERVATION_LIFETIME_MS);
+      if (promotedExpiry === undefined) {
+        disposeStore();
+        return failure('service_disposed');
+      }
+      const attempt = fields.attempt as ReservationAttempt;
+      const identity = attemptIdentity(attempt);
+      if (!identity || identity.slot !== entry.slot || !currentAttempt(attempt)) {
+        return failure('invalid_attempt');
+      }
+      entry.busy = true;
+      const admission = prepareWinnerAdmission(attempt, entry.winnerContext);
+      const committed = admission
+        ? commitWinnerAdmission(attempt, admission, entry.winnerContext)
+        : false;
+      const attemptIsCurrent = currentAttempt(attempt);
+      if (!committed || !attemptIsCurrent || mapValue(entries, fields.reservationId) !== entry) {
+        rollbackWinnerAdmission(admission);
+        replaceWithTombstone(fields.reservationId, entry, 'stale');
+        return failure('invalid_attempt');
+      }
+      const promoted: LiveReservation = {
+        reservationId: entry.reservationId,
+        slot: entry.slot,
+        navigationGeneration: entry.navigationGeneration,
+        renderSource: entry.renderSource,
+        winnerContext: entry.winnerContext,
+        expiresAt: promotedExpiry,
+        state: 'renderable',
+        attemptId: identity.id,
+        auctionId: entry.auctionId,
+        adUnitCode: entry.adUnitCode,
+        busy: true,
+        pucSource: undefined,
+      };
+      const success = frozenResult({ ok: true as const, expiresAt: promotedExpiry });
+      if (!publishEntry(fields.reservationId, entry, promoted)) {
+        rollbackWinnerAdmission(admission);
+        replaceWithTombstone(fields.reservationId, entry, 'stale');
+        return failure('service_disposed');
+      }
+      let losersSuppressed = true;
+      const candidates = mapValueSnapshot(entries);
+      for (let index = 0; index < candidates.length; index += 1) {
+        const candidate = candidates[index];
+        if (
+          candidate &&
+          candidate !== promoted &&
+          liveEntry(candidate) &&
+          candidate.state === 'awaiting_prebid_selection' &&
+          candidate.auctionId === promoted.auctionId &&
+          candidate.adUnitCode === promoted.adUnitCode &&
+          candidate.navigationGeneration === promoted.navigationGeneration &&
+          !replaceWithTombstone(candidate.reservationId, candidate, 'unselected')
+        ) {
+          losersSuppressed = false;
+        }
+      }
+      if (!losersSuppressed || storeFaulted) {
+        rollbackWinnerAdmission(admission);
+        return failure('service_disposed');
+      }
+      promoted.busy = false;
+      return success;
+    },
+    claim(input): ReservationClaimResult {
+      adoptionOpen = false;
+      const minimalId = (() => {
+        try {
+          return input.reservationId;
+        } catch {
+          return undefined;
+        }
+      })();
+      if (!refreshForLookup() || typeof minimalId !== 'string') {
+        return frozenResult({ recognized: false });
+      }
+      const entry = mapValue(entries, minimalId);
+      if (!entry) return frozenResult({ recognized: false });
+      if (!liveEntry(entry)) {
+        return refusedClaim(entry.state);
+      }
+      if (clockFaulted || storeFaulted) {
+        return refusedClaim(entry.state);
+      }
+      if (entry.busy) {
+        return refusedClaim(entry.state);
+      }
+      if (entry.state === 'awaiting_prebid_selection') {
+        replaceWithTombstone(minimalId, entry, 'prebid_contract_violation');
+        return refusedClaim('prebid_contract_violation');
+      }
+      const fields = ownDataRecord(input, [
+        'reservationId',
+        'slot',
+        'navigationGeneration',
+        'attempt',
+        'pucSource',
+      ]);
+      if (!fields) {
+        return refusedClaim(entry.state);
+      }
+      const attempt = fields.attempt as ReservationAttempt;
+      const identity = attemptIdentity(attempt);
+      if (
+        !identity ||
+        fields.slot !== entry.slot ||
+        fields.navigationGeneration !== entry.navigationGeneration ||
+        identity.id !== entry.attemptId ||
+        identity.slot !== entry.slot ||
+        typeof fields.pucSource !== 'object' ||
+        fields.pucSource === null ||
+        !currentAttempt(attempt)
+      ) {
+        return refusedClaim(entry.state);
+      }
+      const result = frozenResult({
+        recognized: true as const,
+        claimed: true as const,
+        pucSource: fields.pucSource,
+        expiresAt: entry.expiresAt,
+      });
+      entry.busy = true;
+      const admission = prepareWinnerAdmission(attempt, entry.winnerContext);
+      const committed = admission
+        ? commitWinnerAdmission(attempt, admission, entry.winnerContext)
+        : false;
+      const attemptIsCurrent = currentAttempt(attempt);
+      if (!committed || !attemptIsCurrent || mapValue(entries, minimalId) !== entry) {
+        rollbackWinnerAdmission(admission);
+        replaceWithTombstone(minimalId, entry, 'stale');
+        const replacement = mapValue(entries, minimalId);
+        return refusedClaim(replacement?.state ?? 'stale');
+      }
+      if (!replaceWithTombstone(minimalId, entry, 'consumed')) {
+        rollbackWinnerAdmission(admission);
+        const replacement = mapValue(entries, minimalId);
+        return refusedClaim(replacement?.state ?? 'stale');
+      }
+      try {
+        const claimedAdmission: ClaimedAdmission = {
+          attempt,
+          attemptId: identity.id,
+          expiresAt: entry.expiresAt,
+          slot: identity.slot,
+          navigationGeneration: entry.navigationGeneration,
+          active: true,
+          renderSource: entry.renderSource,
+          winnerContext: entry.winnerContext,
+        };
+        setMapValue(claimAdmissions, result, claimedAdmission);
+        if (mapValue(claimAdmissions, result) !== claimedAdmission) {
+          throw new Error('claim admission publication failed');
+        }
+      } catch {
+        storeFaulted = true;
+        rollbackWinnerAdmission(admission);
+        return refusedClaim('consumed');
+      }
+      return result;
+    },
+    consumeClaim(claim, expectation): ReservationClaimAdmission | undefined {
+      adoptionOpen = false;
+      const fields = ownDataRecord(expectation, [
+        'attempt',
+        'attemptId',
+        'slot',
+        'navigationGeneration',
+        'winnerContext',
+      ]);
+      if (!fields || (typeof claim !== 'object' && typeof claim !== 'function') || claim === null) {
+        return undefined;
+      }
+      const admission = mapValue(claimAdmissions, claim);
+      const now = clock();
+      const currentIdentity = admission ? attemptIdentity(admission.attempt) : undefined;
+      let currentContext: WinnerContext | undefined;
+      try {
+        currentContext = admission?.attempt.winnerContext;
+      } catch {
+        currentContext = undefined;
+      }
+      if (
+        admission &&
+        (!admission.active ||
+          !admission.renderSource ||
+          !admission.winnerContext ||
+          now === undefined ||
+          now >= admission.expiresAt ||
+          !currentAttempt(admission.attempt) ||
+          !currentIdentity ||
+          currentIdentity.id !== admission.attemptId ||
+          currentIdentity.slot !== admission.slot ||
+          currentContext !== admission.winnerContext)
+      ) {
+        invalidateClaimAdmission(claim, admission);
+        return undefined;
+      }
+      if (
+        !admission ||
+        fields.attempt !== admission.attempt ||
+        fields.attemptId !== admission.attemptId ||
+        fields.slot !== admission.slot ||
+        fields.navigationGeneration !== admission.navigationGeneration ||
+        fields.winnerContext !== admission.winnerContext
+      ) {
+        return undefined;
+      }
+      const renderSource = admission.renderSource;
+      const winnerContext = admission.winnerContext;
+      invalidateClaimAdmission(claim, admission);
+      return renderSource && winnerContext
+        ? frozenResult({ renderSource, winnerContext })
+        : undefined;
+    },
+    recognize,
+    tombstone(input, state): boolean {
+      adoptionOpen = false;
+      if (!validRenderTombstoneState(state)) return false;
+      const fields = ownDataRecord(input, [
+        'reservationId',
+        'slot',
+        'navigationGeneration',
+        'attemptId',
+      ]);
+      if (!refreshForTerminalMutation() || !fields || typeof fields.reservationId !== 'string') {
+        return false;
+      }
+      const entry = mapValue(entries, fields.reservationId);
+      if (
+        !entry ||
+        !liveEntry(entry) ||
+        entry.state !== 'renderable' ||
+        fields.slot !== entry.slot ||
+        fields.navigationGeneration !== entry.navigationGeneration ||
+        fields.attemptId !== entry.attemptId
+      ) {
+        return false;
+      }
+      return replaceWithTombstone(fields.reservationId, entry, state);
+    },
+    tombstonePrebidLease(input, state): boolean {
+      adoptionOpen = false;
+      if (!validPrebidLeaseTombstoneState(state)) return false;
+      const fields = ownDataRecord(input, [
+        'reservationId',
+        'auctionId',
+        'adUnitCode',
+        'navigationGeneration',
+      ]);
+      if (!refreshForTerminalMutation() || !fields || typeof fields.reservationId !== 'string') {
+        return false;
+      }
+      const entry = mapValue(entries, fields.reservationId);
+      if (
+        !entry ||
+        !liveEntry(entry) ||
+        entry.state !== 'awaiting_prebid_selection' ||
+        entry.busy ||
+        entry.auctionId !== fields.auctionId ||
+        entry.adUnitCode !== fields.adUnitCode ||
+        entry.navigationGeneration !== fields.navigationGeneration
+      ) {
+        return false;
+      }
+      return replaceWithTombstone(fields.reservationId, entry, state);
+    },
+    tombstonePrebidGroup(input, state): number {
+      adoptionOpen = false;
+      if (!validPrebidGroupTombstoneState(state)) return 0;
+      const fields = ownDataRecord(input, ['auctionId', 'adUnitCode', 'navigationGeneration']);
+      if (!refreshForTerminalMutation() || !fields) {
+        return 0;
+      }
+      let count = 0;
+      const candidates = mapValueSnapshot(entries);
+      for (let index = 0; index < candidates.length; index += 1) {
+        const entry = candidates[index];
+        if (
+          entry &&
+          liveEntry(entry) &&
+          entry.state === 'awaiting_prebid_selection' &&
+          entry.auctionId === fields.auctionId &&
+          entry.adUnitCode === fields.adUnitCode &&
+          entry.navigationGeneration === fields.navigationGeneration &&
+          replaceWithTombstone(entry.reservationId, entry, state)
+        ) {
+          count += 1;
+        }
+      }
+      return count;
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposeStore();
+    },
+    snapshotInventoryForTest(): ReservationServiceInventory {
+      let live = 0;
+      let tombstones = 0;
+      let entriesWithRenderSource = 0;
+      let entriesWithWinnerContext = 0;
+      let entriesWithPucSource = 0;
+      const snapshot = mapValueSnapshot(entries);
+      for (let index = 0; index < snapshot.length; index += 1) {
+        const entry = snapshot[index];
+        if (!entry) continue;
+        if (liveEntry(entry)) {
+          live += 1;
+          entriesWithRenderSource += 1;
+          entriesWithWinnerContext += 1;
+          if (entry.pucSource !== undefined) entriesWithPucSource += 1;
+        } else tombstones += 1;
+      }
+      return frozenResult({
+        clockFaulted,
+        disposed,
+        size: mapSize(entries),
+        live,
+        tombstones,
+        entriesWithRenderSource,
+        entriesWithWinnerContext,
+        entriesWithPucSource,
+      });
+    },
+  };
+  addWeakSetValue(reservationServices, service);
+  return frozenResult(service);
+}
diff --git a/crates/trusted-server-js/lib/src/services/slots.ts b/crates/trusted-server-js/lib/src/services/slots.ts
new file mode 100644
index 000000000..a3cf0407b
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/slots.ts
@@ -0,0 +1,3843 @@
+import type {
+  GoogletagAdapter,
+  GoogletagFacade,
+  GptSlotTokenV1,
+  GoogletagOperation,
+  GoogletagPublisherCallAdmission,
+  GoogletagPublisherDefineSlotCall,
+  GoogletagPublisherDisplayCall,
+  GoogletagPublisherRefreshCall,
+  GoogletagReplacementCommitAdmission,
+  GoogletagReplacementDefinition,
+  GoogletagReplacementResult,
+  GoogletagTraceCycleHandle,
+} from '../adapters/googletag';
+import {
+  createGoogletagTraceCycleHandle,
+  GoogletagAdapterError,
+  GoogletagReplacementCandidateCollisionError,
+  GoogletagReplacementError,
+} from '../adapters/googletag';
+import type { NavigationSession } from '../kernel/sessions';
+
+import type {
+  PreparedProjectionSlots,
+  ProjectionSlotRegistration,
+  ProjectionSlotRegistry,
+} from './projections';
+import type { CommittedRenderArtifact } from './render';
+
+/** Shared maximum across server-projected and programmatically admitted slots. */
+export const MAX_ACTIVE_SLOT_RECORDS = 256;
+
+const GPT_REQUEST_START_TIMEOUT_MS = 3_000;
+const GPT_COMPLETION_TIMEOUT_MS = 10_000;
+const GPT_RECONCILIATION_DEBOUNCE_MS = 250;
+const GPT_RECONCILIATION_WINDOW_MS = 5_000;
+const MAX_SUCCESSFUL_RECONCILIATIONS = 2;
+const MAX_PENDING_PUBLISHER_INTENTS = 64;
+const MAX_SLOT_ALIASES = 256;
+const MAX_PLACEMENT_QUARANTINE_KEYS = 2_048;
+
+export type SlotSource = 'programmatic' | 'server';
+export type GptSlotOwnership = 'publisher' | 'trusted_server';
+
+/** Immutable registration input owned by one navigation. */
+export interface SlotRegistration {
+  readonly registeredSlotId: string;
+  readonly source: SlotSource;
+  readonly adUnitCode?: string;
+  readonly domAliases?: readonly string[];
+  /** Detached programmatic `/auction` unit; absent for server projection slots. */
+  readonly directAuctionUnit?: Readonly<object>;
+}
+
+/** Public immutable view of a registered slot. */
+export interface SlotRecord {
+  readonly adUnitCode: string | undefined;
+  readonly directAuctionUnit?: Readonly<object>;
+  readonly domAliases: readonly string[];
+  readonly navigationGeneration: object;
+  readonly ordinal: number;
+  readonly registeredSlotId: string;
+  readonly source: SlotSource;
+  readonly traceToken?: GptSlotTokenV1;
+}
+
+export type SlotRegistrationFailure =
+  'duplicate_slot' | 'invalid_slot_id' | 'registry_capacity' | 'slot_quarantined' | 'stale_owner';
+
+export type SlotRegistrationResult =
+  | Readonly<{ ok: true; records: readonly SlotRecord[] }>
+  | Readonly<{ ok: false; reason: SlotRegistrationFailure }>;
+
+/** Binding metadata required for safe TS-owned replacement. */
+export interface GptSlotBinding {
+  readonly definition?: GoogletagReplacementDefinition;
+  /** Stable configured prefix accepted only for an unambiguous hydration handoff. */
+  readonly elementIdPrefix?: string;
+  readonly ownership: GptSlotOwnership;
+  readonly slot: object;
+}
+
+export type GptSlotAdoptionResult = Readonly<
+  | { ok: true }
+  | {
+      ok: false;
+      reason:
+        | 'gpt_object_collision'
+        | 'gpt_request_failed'
+        | 'slot_quarantined'
+        | 'slot_unresolved'
+        | 'stale_owner';
+    }
+>;
+
+export type SlotRequestFailure =
+  | 'cycle_unattributable'
+  | 'external_queue_full'
+  | 'external_ready_timeout'
+  | 'gpt_completion_timeout'
+  | 'gpt_request_failed'
+  | 'gpt_request_timeout'
+  | 'reconciliation_capacity'
+  | 'slot_quarantined'
+  | 'slot_unresolved';
+
+export type SlotRequestOutcome =
+  | Readonly<{
+      status: 'empty' | 'rendered';
+      responseIdentifier?: string;
+    }>
+  | Readonly<{ status: 'failed'; reason: SlotRequestFailure }>
+  | Readonly<{ status: 'cancelled'; reason: 'navigation_disposed' | 'superseded' }>;
+
+export interface SlotRequestInput {
+  /** Exact physical identity latch for a cross-service publication transaction. */
+  readonly expectedSlot?: object;
+  readonly intentId: string;
+  readonly navigationGeneration: object;
+  readonly operation: 'display' | 'refresh';
+  readonly registeredSlotId: string;
+  readonly requestClass: string;
+  /** Immutable auction evidence captured by the exact request-producing operation. */
+  readonly trustedServerOpportunity?: TrustedServerRequestOpportunity;
+}
+
+export interface TrustedServerRequestOpportunity {
+  readonly requestedSlotSizes: readonly (readonly [number, number])[];
+  readonly trustedServerAuctionId: string;
+}
+
+/** Input admitted atomically into one shared GPT SRA operation. */
+export type SlotBatchRequestInput = SlotRequestInput;
+
+export interface SlotRequestHandle {
+  readonly status: 'active' | 'queued' | 'terminal';
+  readonly result: Promise<SlotRequestOutcome>;
+  readonly dispose: () => void;
+}
+
+export type GptEventType = 'slotRenderEnded' | 'slotRequested';
+
+export interface SlotServiceInventory {
+  readonly cycles: number;
+  readonly intents: number;
+  readonly physicalSlots: number;
+  readonly records: number;
+}
+
+export interface ApsSlotMountBinding {
+  readonly bindingEpoch: object;
+  readonly cycle: Readonly<GoogletagTraceCycleHandle>;
+  readonly element: object;
+  readonly physicalSlot: object;
+  readonly isCurrent: () => boolean;
+  readonly bindArtifact: (artifact: CommittedRenderArtifact) =>
+    | Readonly<{
+        commit: () => boolean;
+        finalize: () => void;
+        isCurrent: () => boolean;
+        previousArtifact: CommittedRenderArtifact | undefined;
+        release: () => void;
+        rollback: () => void;
+      }>
+    | undefined;
+}
+
+/** Runtime-owned slot registry and physical-cycle boundary. */
+export interface SlotService {
+  readonly activate: () => void;
+  readonly activateReconciliation: () => () => void;
+  readonly adoptGptSlot: (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    binding: GptSlotBinding
+  ) => GptSlotAdoptionResult;
+  readonly adoptRegistrationHighWater: (
+    navigationGeneration: object,
+    nextOrdinal: number
+  ) => boolean;
+  readonly adoptCommittedArtifact: (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    artifact: CommittedRenderArtifact,
+    onRetire?: () => void
+  ) => boolean;
+  readonly dispose: () => void;
+  readonly handleGptEvent: (
+    type: GptEventType,
+    event: unknown
+  ) => Readonly<GoogletagTraceCycleHandle> | undefined;
+  readonly isBoundGptSlot: (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    slot: object
+  ) => boolean;
+  readonly resolveApsMountBinding: (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    intentId: string
+  ) => Readonly<ApsSlotMountBinding> | undefined;
+  readonly prepareProjectionSlots: (
+    owner: NavigationSession,
+    slots: readonly ProjectionSlotRegistration[]
+  ) => PreparedProjectionSlots | undefined;
+  readonly claimPublisherGptSlot: (
+    call: GoogletagPublisherDefineSlotCall
+  ) => Readonly<{ action: 'forward' }> | Readonly<{ action: 'handoff'; slot: object }>;
+  readonly preparePublisherDisplay: (
+    call: GoogletagPublisherDisplayCall
+  ) =>
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{ action: 'suppress' }>;
+  readonly preparePublisherRefresh: (call: GoogletagPublisherRefreshCall) =>
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{
+        action: 'replace';
+        slots: readonly object[];
+        admission?: GoogletagPublisherCallAdmission;
+      }>
+    | Readonly<{ action: 'suppress' }>;
+  readonly projectionRegistry: (owner: NavigationSession) => ProjectionSlotRegistry;
+  readonly recordPublisherDestruction: (slot: object) => boolean;
+  readonly recordPublisherIntent: (slot: object) => boolean;
+  readonly registeredSlotIdsForTest: () => readonly string[];
+  readonly register: (
+    owner: NavigationSession,
+    registrations: readonly SlotRegistration[]
+  ) => SlotRegistrationResult;
+  readonly request: (input: SlotRequestInput) => SlotRequestHandle;
+  readonly requestBatch: (inputs: readonly SlotBatchRequestInput[]) => readonly SlotRequestHandle[];
+  readonly snapshotRegisteredSlots: (owner: NavigationSession) => readonly SlotRecord[] | undefined;
+  readonly start: () => GoogletagOperation<void>;
+  readonly resolveAdUnitCode: (adUnitCode: string) => SlotRecord | undefined;
+  readonly resolveDomAlias: (alias: string) => SlotRecord | undefined;
+  readonly resolveRegisteredSlot: (registeredSlotId: string) => SlotRecord | undefined;
+  readonly snapshotForTest: () => SlotServiceInventory;
+}
+
+export interface SlotServiceOptions {
+  readonly bindCommittedArtifactRetirement?: (
+    artifact: CommittedRenderArtifact,
+    retire: () => void
+  ) => boolean;
+  readonly disposeCommittedArtifact?: (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    artifact: CommittedRenderArtifact
+  ) => void;
+  readonly googletag: GoogletagAdapter;
+  readonly now?: () => number;
+  readonly onTrustedServerRequest?: (
+    input: Readonly<{
+      opportunity?: TrustedServerRequestOpportunity;
+      registeredSlotId: string;
+      slot: object;
+    }>
+  ) => void;
+  readonly reconciliation?: SlotReconciliationBoundary;
+  readonly warnPublisherHandoffMismatch?: (
+    message: string,
+    details: Readonly<{ formatsMismatch: boolean; pathMismatch: boolean }>
+  ) => void;
+}
+
+export type SlotReconciliationResolution =
+  | Readonly<{ status: 'ambiguous' | 'unresolved' }>
+  | Readonly<{ status: 'unique'; element: object; elementId: string }>;
+
+/** Narrow DOM ownership boundary used by navigation-scoped slot reconciliation. */
+export interface SlotReconciliationBoundary {
+  readonly isConnected: (element: object) => boolean;
+  readonly observe: (callback: () => void) => () => void;
+  readonly resolve: (elementIds: readonly string[]) => SlotReconciliationResolution;
+}
+
+interface NavigationState {
+  disposed: boolean;
+  highWaterAdopted: boolean;
+  nextOrdinal: number;
+  observerRelease: (() => void) | undefined;
+  readonly owner: NavigationSession;
+  readonly records: Map<string, InternalSlotRecord>;
+}
+
+interface InternalSlotRecord {
+  activeIntent: RequestIntent | undefined;
+  physical: PhysicalSlot | undefined;
+  queuedIntent: RequestIntent | undefined;
+  reconciliation: ReconciliationWindow | undefined;
+  reconciliationSuccesses: number;
+  readonly state: NavigationState;
+  view: SlotRecord;
+}
+
+type PhysicalSlotState = 'live' | 'quarantined' | 'retired';
+
+interface PhysicalCycle {
+  intent: RequestIntent | undefined;
+  kind: 'publisher' | 'trusted_server';
+  readonly traceHandle: Readonly<GoogletagTraceCycleHandle>;
+  readonly traceRetirement: { retired: boolean };
+}
+
+interface PhysicalSlot {
+  activeCycle: PhysicalCycle | undefined;
+  apsMountClaim: Readonly<{ cycle: PhysicalCycle; token: object }> | undefined;
+  committedArtifact: CommittedRenderArtifact | undefined;
+  bindingEpoch: object;
+  definition: GoogletagReplacementDefinition | undefined;
+  domElement: object | undefined;
+  elementIdPrefix: string | undefined;
+  lastResponseIdentifier: string | undefined;
+  lastCycle: PhysicalCycle | undefined;
+  ownership: GptSlotOwnership;
+  placementKeys: readonly string[];
+  readonly publisherAdmissions: PublisherIntentAdmissionState[];
+  publisherElementIds: readonly string[];
+  suppressPublisherDisplay: boolean;
+  suppressPublisherRefresh: boolean;
+  quarantineReason: 'completion' | 'navigation' | 'request' | undefined;
+  record: InternalSlotRecord | undefined;
+  saturationOwner: boolean;
+  readonly slot: object;
+  state: PhysicalSlotState;
+  destroyAttempted: boolean;
+}
+
+interface PublisherIntentAdmissionState {
+  enqueued: boolean;
+  phase: 'committed' | 'consumed' | 'pending' | 'rolled_back';
+  readonly generation: object | undefined;
+  readonly physical: PhysicalSlot;
+  readonly record: InternalSlotRecord | undefined;
+}
+
+interface ReconciliationWindow {
+  debounceTimer: ReturnType<typeof setTimeout> | undefined;
+  deadlineTimer: ReturnType<typeof setTimeout> | undefined;
+  readonly deadlineAt: number;
+  firstPassFinished: boolean;
+  operation: GoogletagOperation<GoogletagReplacementResult> | undefined;
+  readonly orphan: PhysicalSlot;
+  pendingFailureReason: SlotRequestFailure | undefined;
+  terminal: boolean;
+}
+
+interface RequestIntent {
+  completionTimer: ReturnType<typeof setTimeout> | undefined;
+  readonly input: SlotRequestInput;
+  invocation: { dispose(): void } | undefined;
+  requestStartedAt: number | undefined;
+  requestDeadlineAt: number | undefined;
+  completionDeadlineAt: number | undefined;
+  requestTimer: ReturnType<typeof setTimeout> | undefined;
+  readonly resolve: (outcome: SlotRequestOutcome) => void;
+  readonly result: Promise<SlotRequestOutcome>;
+  record: InternalSlotRecord;
+  state: 'active' | 'cycle' | 'queued' | 'terminal';
+  terminal: boolean;
+}
+
+interface BindingSubscriptions {
+  readonly release: () => void;
+  readonly token: object;
+}
+
+interface BindingSubscriptionAdmission {
+  readonly installed: boolean;
+  readonly ownership: BindingSubscriptions;
+}
+
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapGetIntrinsic = Map.prototype.get;
+const mapSetIntrinsic = Map.prototype.set;
+const mapValuesIntrinsic = Map.prototype.values;
+const mapIteratorNextIntrinsic = Object.getPrototypeOf(new Map().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size')?.get as (
+  this: Map<unknown, unknown>
+) => number;
+const setAddIntrinsic = Set.prototype.add;
+const setDeleteIntrinsic = Set.prototype.delete;
+const setHasIntrinsic = Set.prototype.has;
+const setValuesIntrinsic = Set.prototype.values;
+const setIteratorNextIntrinsic = Object.getPrototypeOf(new Set().values()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const setSizeGetter = Object.getOwnPropertyDescriptor(Set.prototype, 'size')?.get as (
+  this: Set<unknown>
+) => number;
+const weakMapDeleteIntrinsic = WeakMap.prototype.delete;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+
+function mapValue<Key, Value>(map: Map<Key, Value>, key: Key): Value | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setMapValue<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void {
+  Reflect.apply(mapSetIntrinsic, map, [key, value]);
+}
+
+function deleteMapValue<Key, Value>(map: Map<Key, Value>, key: Key): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function mapValues<Key, Value>(map: Map<Key, Value>): IterableIterator<Value> {
+  return Reflect.apply(mapValuesIntrinsic, map, []) as IterableIterator<Value>;
+}
+
+function mapValueSnapshot<Key, Value>(map: Map<Key, Value>): Value[] {
+  const iterator = mapValues(map);
+  const values: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(mapIteratorNextIntrinsic, iterator, []) as IteratorResult<Value>;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function mapSize(map: Map<unknown, unknown>): number {
+  return Reflect.apply(mapSizeGetter, map, []) as number;
+}
+
+function addSetValue<Value>(set: Set<Value>, value: Value): void {
+  Reflect.apply(setAddIntrinsic, set, [value]);
+}
+
+function deleteSetValue<Value>(set: Set<Value>, value: Value): boolean {
+  return Reflect.apply(setDeleteIntrinsic, set, [value]) as boolean;
+}
+
+function setHasValue<Value>(set: Set<Value>, value: Value): boolean {
+  return Reflect.apply(setHasIntrinsic, set, [value]) as boolean;
+}
+
+function setValues<Value>(set: Set<Value>): IterableIterator<Value> {
+  return Reflect.apply(setValuesIntrinsic, set, []) as IterableIterator<Value>;
+}
+
+function setValueSnapshot<Value>(set: Set<Value>): Value[] {
+  const iterator = setValues(set);
+  const values: Value[] = [];
+  while (true) {
+    const step = Reflect.apply(setIteratorNextIntrinsic, iterator, []) as IteratorResult<Value>;
+    if (step.done) return values;
+    values[values.length] = step.value;
+  }
+}
+
+function setSize(set: Set<unknown>): number {
+  return Reflect.apply(setSizeGetter, set, []) as number;
+}
+
+function weakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): Value | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setWeakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key,
+  value: Value
+): void {
+  Reflect.apply(weakMapSetIntrinsic, map, [key, value]);
+}
+
+function deleteWeakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): boolean {
+  return Reflect.apply(weakMapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function setIndexValue(
+  index: Map<string, Set<InternalSlotRecord>>,
+  key: string,
+  record: InternalSlotRecord
+): void {
+  let records = mapValue(index, key);
+  if (!records) {
+    records = new Set<InternalSlotRecord>();
+    try {
+      setMapValue(index, key, records);
+    } catch (error) {
+      if (mapValue(index, key) === records) deleteMapValue(index, key);
+      throw error;
+    }
+  }
+  try {
+    addSetValue(records, record);
+  } catch (error) {
+    if (setSize(records) === 0) deleteMapValue(index, key);
+    throw error;
+  }
+}
+
+function deleteIndexValue(
+  index: Map<string, Set<InternalSlotRecord>>,
+  key: string,
+  record: InternalSlotRecord
+): void {
+  const records = mapValue(index, key);
+  if (!records) return;
+  deleteSetValue(records, record);
+  if (setSize(records) === 0) deleteMapValue(index, key);
+}
+
+function resolveUnique(
+  index: Map<string, Set<InternalSlotRecord>>,
+  key: string
+): SlotRecord | undefined {
+  const records = mapValue(index, key);
+  if (!records || setSize(records) !== 1) return undefined;
+  const iterator = setValues(records);
+  const first = Reflect.apply(
+    setIteratorNextIntrinsic,
+    iterator,
+    []
+  ) as IteratorResult<InternalSlotRecord>;
+  return first.done ? undefined : first.value.view;
+}
+
+function validSlotIdentity(value: string): boolean {
+  if (
+    value.length === 0 ||
+    new TextEncoder().encode(value).length > 256 ||
+    /[\uD800-\uDFFF]/u.test(value)
+  ) {
+    return false;
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 0x1f || code === 0x7f) return false;
+  }
+  return true;
+}
+
+function frozenAliases(aliases: readonly string[] | undefined): readonly string[] | undefined {
+  if (aliases === undefined) return Object.freeze([]);
+  if (!Array.isArray(aliases) || aliases.length > MAX_SLOT_ALIASES) return undefined;
+  const output: string[] = [];
+  const seen = new Set<string>();
+  for (const alias of aliases) {
+    if (typeof alias !== 'string' || !validSlotIdentity(alias) || setHasValue(seen, alias)) {
+      return undefined;
+    }
+    addSetValue(seen, alias);
+    output[output.length] = alias;
+  }
+  return Object.freeze(output);
+}
+
+function ownData(event: unknown, key: PropertyKey): unknown {
+  if (typeof event !== 'object' || event === null) return undefined;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(event, key);
+    return descriptor && 'value' in descriptor ? descriptor.value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotTrustedServerOpportunity(
+  candidate: unknown
+): TrustedServerRequestOpportunity | undefined {
+  if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) return;
+  const trustedServerAuctionId = ownData(candidate, 'trustedServerAuctionId');
+  const sizes = ownData(candidate, 'requestedSlotSizes');
+  if (
+    typeof trustedServerAuctionId !== 'string' ||
+    !validSlotIdentity(trustedServerAuctionId) ||
+    !Array.isArray(sizes) ||
+    sizes.length === 0 ||
+    sizes.length > 16
+  ) {
+    return;
+  }
+  const requestedSlotSizes: Array<readonly [number, number]> = [];
+  for (let index = 0; index < sizes.length; index += 1) {
+    const size = sizes[index];
+    if (
+      !Array.isArray(size) ||
+      size.length !== 2 ||
+      !Number.isInteger(size[0]) ||
+      !Number.isInteger(size[1]) ||
+      size[0] < 1 ||
+      size[0] > 4_096 ||
+      size[1] < 1 ||
+      size[1] > 4_096
+    ) {
+      return;
+    }
+    requestedSlotSizes.push(Object.freeze([size[0], size[1]]));
+  }
+  if (
+    Object.isFrozen(candidate) &&
+    Object.isFrozen(sizes) &&
+    sizes.every((size) => Object.isFrozen(size))
+  ) {
+    return candidate as unknown as TrustedServerRequestOpportunity;
+  }
+  return Object.freeze({
+    requestedSlotSizes: Object.freeze(requestedSlotSizes),
+    trustedServerAuctionId,
+  });
+}
+
+function copyReplacementSizes(sizes: unknown): unknown | undefined {
+  try {
+    if (!Array.isArray(sizes)) return undefined;
+    const length = sizes.length;
+    const copyPair = (value: unknown): readonly [number, number] | undefined => {
+      if (!Array.isArray(value) || value.length !== 2) return undefined;
+      const width = value[0] as unknown;
+      const height = value[1] as unknown;
+      if (
+        typeof width !== 'number' ||
+        !Number.isInteger(width) ||
+        width < 1 ||
+        width > 4_096 ||
+        typeof height !== 'number' ||
+        !Number.isInteger(height) ||
+        height < 1 ||
+        height > 4_096
+      ) {
+        return undefined;
+      }
+      return Object.freeze([width, height]);
+    };
+    const single = copyPair(sizes);
+    if (single) return single;
+    if (length === 0 || length > MAX_ACTIVE_SLOT_RECORDS) return undefined;
+    const copied: Array<readonly [number, number]> = [];
+    for (let index = 0; index < length; index += 1) {
+      const pair = copyPair(sizes[index] as unknown);
+      if (!pair) return undefined;
+      copied[copied.length] = pair;
+    }
+    return Object.freeze(copied);
+  } catch {
+    return undefined;
+  }
+}
+
+function replacementSizesEqual(left: unknown, right: unknown): boolean {
+  const leftCopy = copyReplacementSizes(left);
+  const rightCopy = copyReplacementSizes(right);
+  if (!Array.isArray(leftCopy) || !Array.isArray(rightCopy)) return false;
+  const pair = (value: unknown): value is readonly [number, number] =>
+    Array.isArray(value) &&
+    value.length === 2 &&
+    typeof value[0] === 'number' &&
+    typeof value[1] === 'number';
+  const normalized = (value: readonly unknown[]): readonly (readonly [number, number])[] =>
+    pair(value) ? Object.freeze([value]) : (value as readonly (readonly [number, number])[]);
+  const leftPairs = normalized(leftCopy);
+  const rightPairs = normalized(rightCopy);
+  if (leftPairs.length !== rightPairs.length) return false;
+  for (let index = 0; index < leftPairs.length; index += 1) {
+    const leftPair = leftPairs[index];
+    const rightPair = rightPairs[index];
+    if (!leftPair || !rightPair || leftPair[0] !== rightPair[0] || leftPair[1] !== rightPair[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function snapshotReplacementDefinition(input: unknown): GoogletagReplacementDefinition | undefined {
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) return undefined;
+  let adUnitPath: unknown;
+  let elementId: unknown;
+  let sizes: unknown;
+  try {
+    const external = input as {
+      readonly adUnitPath?: unknown;
+      readonly elementId?: unknown;
+      readonly sizes?: unknown;
+    };
+    adUnitPath = external.adUnitPath;
+    elementId = external.elementId;
+    sizes = external.sizes;
+  } catch {
+    return undefined;
+  }
+  const copiedSizes = copyReplacementSizes(sizes);
+  if (
+    typeof adUnitPath !== 'string' ||
+    !validSlotIdentity(adUnitPath) ||
+    typeof elementId !== 'string' ||
+    !validSlotIdentity(elementId) ||
+    copiedSizes === undefined
+  ) {
+    return undefined;
+  }
+  return Object.freeze({ adUnitPath, elementId, sizes: copiedSizes });
+}
+
+const failed = (reason: SlotRequestFailure): SlotRequestOutcome =>
+  Object.freeze({ status: 'failed' as const, reason });
+const cancelled = (reason: 'navigation_disposed' | 'superseded'): SlotRequestOutcome =>
+  Object.freeze({ status: 'cancelled' as const, reason });
+
+function externalInvocationFailure(error: unknown): SlotRequestFailure {
+  if (error instanceof GoogletagAdapterError) {
+    if (error.code === 'external_queue_full' || error.code === 'external_ready_timeout') {
+      return error.code;
+    }
+  }
+  return 'gpt_request_failed';
+}
+
+function placementKeysFor(
+  registeredSlotId: string,
+  adUnitCode: string | undefined,
+  aliases: readonly string[],
+  definition?: GoogletagReplacementDefinition
+): readonly string[] {
+  const keys: string[] = [`registered:${registeredSlotId}`];
+  if (adUnitCode !== undefined) keys[keys.length] = `ad-unit:${adUnitCode}`;
+  for (let index = 0; index < aliases.length; index += 1) {
+    const alias = aliases[index];
+    if (alias !== undefined) keys[keys.length] = `dom:${alias}`;
+  }
+  if (definition) {
+    keys[keys.length] = `path:${definition.adUnitPath}`;
+    keys[keys.length] = `dom:${definition.elementId}`;
+  }
+  return Object.freeze(keys);
+}
+
+/** Capture a browser DOM boundary without installing an observer until service activation. */
+export function createBrowserSlotReconciliationBoundary(
+  documentTarget: Document,
+  Observer: typeof MutationObserver
+): SlotReconciliationBoundary | undefined {
+  try {
+    const root = documentTarget.documentElement;
+    const windowTarget = documentTarget.defaultView;
+    if (!root || !windowTarget || typeof Observer !== 'function') return undefined;
+    const querySelectorAll = windowTarget.Document.prototype.querySelectorAll;
+    const contains = windowTarget.Node.prototype.contains;
+    const elementId = Object.getOwnPropertyDescriptor(windowTarget.Element.prototype, 'id')?.get;
+    if (
+      typeof querySelectorAll !== 'function' ||
+      typeof contains !== 'function' ||
+      typeof elementId !== 'function'
+    ) {
+      return undefined;
+    }
+    const isConnected = (element: object): boolean => {
+      try {
+        return Reflect.apply(contains, root, [element]) === true;
+      } catch {
+        return false;
+      }
+    };
+    return Object.freeze({
+      isConnected,
+      observe: (callback: () => void): (() => void) => {
+        if (typeof callback !== 'function') throw new TypeError('reconciliation callback required');
+        const observer = new Observer(() => {
+          try {
+            callback();
+          } catch {
+            // DOM observation cannot escape the service boundary.
+          }
+        });
+        observer.observe(root, { childList: true, subtree: true });
+        let active = true;
+        return (): void => {
+          if (!active) return;
+          active = false;
+          observer.disconnect();
+        };
+      },
+      resolve: (elementIds: readonly string[]): SlotReconciliationResolution => {
+        if (!Array.isArray(elementIds) || elementIds.length === 0) {
+          return Object.freeze({ status: 'unresolved' });
+        }
+        const elements = Reflect.apply(querySelectorAll, documentTarget, [
+          '[id]',
+        ]) as NodeListOf<Element>;
+        let match: object | undefined;
+        let matchId: string | undefined;
+        for (let elementIndex = 0; elementIndex < elements.length; elementIndex += 1) {
+          const element = elements.item(elementIndex);
+          if (!element || !isConnected(element)) continue;
+          const id = Reflect.apply(elementId, element, []) as string;
+          let accepted = false;
+          for (let idIndex = 0; idIndex < elementIds.length; idIndex += 1) {
+            if (elementIds[idIndex] === id) {
+              accepted = true;
+              break;
+            }
+          }
+          if (!accepted) continue;
+          if (match && match !== element) return Object.freeze({ status: 'ambiguous' });
+          match = element;
+          matchId = id;
+        }
+        return match && matchId !== undefined
+          ? Object.freeze({ status: 'unique', element: match, elementId: matchId })
+          : Object.freeze({ status: 'unresolved' });
+      },
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+/** Construct the document-lifetime slot registry and physical GPT cycle service. */
+export function createSlotService(options: SlotServiceOptions): SlotService {
+  const bindCommittedArtifactRetirement = options.bindCommittedArtifactRetirement;
+  const navigationStates = new Map<object, NavigationState>();
+  const registeredSlots = new Map<string, InternalSlotRecord>();
+  const adUnitCodes = new Map<string, Set<InternalSlotRecord>>();
+  const domAliases = new Map<string, Set<InternalSlotRecord>>();
+  const physicalByObject = new WeakMap<object, PhysicalSlot>();
+  const physicalSlots = new Set<PhysicalSlot>();
+  const placementQuarantine = new Map<string, number>();
+  const quarantinedKeysByPhysical = new WeakMap<object, readonly string[]>();
+  const now = options.now ?? (() => performance.now());
+  const disposeCommittedArtifact =
+    typeof options.disposeCommittedArtifact === 'function'
+      ? options.disposeCommittedArtifact
+      : undefined;
+  let reconciliationBoundary: SlotReconciliationBoundary | undefined;
+  let reconciliationObserve: SlotReconciliationBoundary['observe'] | undefined;
+  let reconciliationIsConnected: SlotReconciliationBoundary['isConnected'] | undefined;
+  let reconciliationResolve: SlotReconciliationBoundary['resolve'] | undefined;
+
+  const recordWithTraceToken = (
+    record: Readonly<SlotRecord>,
+    traceToken: GptSlotTokenV1 | undefined
+  ): SlotRecord =>
+    Object.freeze({
+      adUnitCode: record.adUnitCode,
+      ...(record.directAuctionUnit === undefined
+        ? {}
+        : { directAuctionUnit: record.directAuctionUnit }),
+      domAliases: record.domAliases,
+      navigationGeneration: record.navigationGeneration,
+      ordinal: record.ordinal,
+      registeredSlotId: record.registeredSlotId,
+      source: record.source,
+      ...(traceToken === undefined ? {} : { traceToken }),
+    });
+
+  const traceTokenFor = (slot: object): GptSlotTokenV1 | undefined => {
+    try {
+      return typeof options.googletag.traceToken === 'function'
+        ? options.googletag.traceToken(slot)
+        : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  try {
+    const candidate = options.reconciliation;
+    if (
+      candidate &&
+      typeof candidate.observe === 'function' &&
+      typeof candidate.isConnected === 'function' &&
+      typeof candidate.resolve === 'function'
+    ) {
+      reconciliationBoundary = candidate;
+      reconciliationObserve = candidate.observe;
+      reconciliationIsConnected = candidate.isConnected;
+      reconciliationResolve = candidate.resolve;
+    }
+  } catch {
+    reconciliationBoundary = undefined;
+  }
+  let placementQuarantineSaturated = false;
+  let placementQuarantinePoisoned = false;
+  let saturationOwnerCount = 0;
+  let disposed = false;
+  let deferInvocations = false;
+  let activation: GoogletagOperation<void> | undefined;
+  let reconciliationActive = false;
+  const subscriptionsByBinding = new WeakMap<object, BindingSubscriptions>();
+  const bindingSubscriptions = new Set<BindingSubscriptions>();
+
+  const retirePhysicalCycle = (cycle: PhysicalCycle | undefined): void => {
+    if (cycle) cycle.traceRetirement.retired = true;
+  };
+
+  const retirePhysicalTraceCycles = (physical: PhysicalSlot): void => {
+    retirePhysicalCycle(physical.activeCycle);
+    if (physical.lastCycle !== physical.activeCycle) retirePhysicalCycle(physical.lastCycle);
+  };
+
+  const openPhysicalCycle = (
+    physical: PhysicalSlot,
+    intent: RequestIntent | undefined,
+    kind: PhysicalCycle['kind']
+  ): PhysicalCycle => {
+    retirePhysicalCycle(physical.lastCycle);
+    const traceRetirement = { retired: false };
+    const cycle: PhysicalCycle = {
+      intent,
+      kind,
+      traceHandle: createGoogletagTraceCycleHandle(
+        () => traceRetirement.retired || !setHasValue(physicalSlots, physical)
+      ),
+      traceRetirement,
+    };
+    physical.activeCycle = cycle;
+    physical.lastCycle = cycle;
+    return cycle;
+  };
+
+  const clearPhysicalCycle = (physical: PhysicalSlot, completed = false): void => {
+    const cycle = physical.activeCycle;
+    if (!completed) retirePhysicalCycle(cycle);
+    physical.activeCycle = undefined;
+  };
+
+  const reconciliationElementIds = (
+    record: InternalSlotRecord,
+    definition: GoogletagReplacementDefinition | undefined
+  ): readonly string[] => {
+    const values: string[] = definition ? [definition.elementId] : [];
+    for (let aliasIndex = 0; aliasIndex < record.view.domAliases.length; aliasIndex += 1) {
+      const alias = record.view.domAliases[aliasIndex];
+      if (alias === undefined) continue;
+      let duplicate = false;
+      for (let valueIndex = 0; valueIndex < values.length; valueIndex += 1) {
+        if (values[valueIndex] === alias) {
+          duplicate = true;
+          break;
+        }
+      }
+      if (!duplicate) values[values.length] = alias;
+    }
+    return Object.freeze(values);
+  };
+
+  const resolveReconciliationElement = (
+    record: InternalSlotRecord,
+    definition: GoogletagReplacementDefinition | undefined
+  ): SlotReconciliationResolution | undefined => {
+    if (!reconciliationBoundary || !reconciliationResolve) return undefined;
+    try {
+      const resolution = Reflect.apply(reconciliationResolve, reconciliationBoundary, [
+        reconciliationElementIds(record, definition),
+      ]) as SlotReconciliationResolution;
+      if (
+        !resolution ||
+        (resolution.status !== 'unique' &&
+          resolution.status !== 'unresolved' &&
+          resolution.status !== 'ambiguous')
+      ) {
+        return undefined;
+      }
+      if (
+        resolution.status === 'unique' &&
+        (((typeof resolution.element !== 'object' || resolution.element === null) &&
+          typeof resolution.element !== 'function') ||
+          typeof resolution.elementId !== 'string' ||
+          resolution.elementId.length === 0)
+      ) {
+        return undefined;
+      }
+      return resolution;
+    } catch {
+      return undefined;
+    }
+  };
+
+  const reconciliationElementConnected = (element: object | undefined): boolean => {
+    if (!reconciliationBoundary || !reconciliationIsConnected) return true;
+    if (!element) return false;
+    try {
+      return Reflect.apply(reconciliationIsConnected, reconciliationBoundary, [element]) === true;
+    } catch {
+      return true;
+    }
+  };
+
+  const hasPlacementQuarantine = (keys: readonly string[]): boolean => {
+    if (placementQuarantineSaturated || placementQuarantinePoisoned) return true;
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      if (key !== undefined && mapValue(placementQuarantine, key) !== undefined) return true;
+    }
+    return false;
+  };
+
+  const markSaturationOwner = (physical: PhysicalSlot): void => {
+    if (physical.saturationOwner) return;
+    physical.saturationOwner = true;
+    saturationOwnerCount += 1;
+    placementQuarantineSaturated = true;
+  };
+
+  const quarantinePhysicalPlacement = (physical: PhysicalSlot): void => {
+    if (weakMapValue(quarantinedKeysByPhysical, physical.slot)) return;
+    let additionalKeys = 0;
+    for (let index = 0; index < physical.placementKeys.length; index += 1) {
+      const key = physical.placementKeys[index];
+      if (key !== undefined && mapValue(placementQuarantine, key) === undefined)
+        additionalKeys += 1;
+    }
+    if (mapSize(placementQuarantine) + additionalKeys > MAX_PLACEMENT_QUARANTINE_KEYS) {
+      markSaturationOwner(physical);
+      return;
+    }
+    const confirmedKeys: string[] = [];
+    try {
+      setWeakMapValue(quarantinedKeysByPhysical, physical.slot, confirmedKeys);
+    } catch {
+      if (weakMapValue(quarantinedKeysByPhysical, physical.slot) !== confirmedKeys) {
+        placementQuarantinePoisoned = true;
+        return;
+      }
+    }
+    if (weakMapValue(quarantinedKeysByPhysical, physical.slot) !== confirmedKeys) {
+      placementQuarantinePoisoned = true;
+      return;
+    }
+    for (let index = 0; index < physical.placementKeys.length; index += 1) {
+      const key = physical.placementKeys[index];
+      if (key === undefined) continue;
+      const previous = mapValue(placementQuarantine, key) ?? 0;
+      let publicationThrew = false;
+      try {
+        setMapValue(placementQuarantine, key, previous + 1);
+      } catch {
+        publicationThrew = true;
+      }
+      const actual = mapValue(placementQuarantine, key) ?? 0;
+      if (actual === previous + 1) {
+        confirmedKeys[confirmedKeys.length] = key;
+        if (!publicationThrew) continue;
+      } else if (actual !== previous) {
+        placementQuarantinePoisoned = true;
+        return;
+      }
+      if (publicationThrew || actual === previous) {
+        // A hostile Map implementation either rejected this increment or threw
+        // after applying it. Retain only the increments whose ownership can be
+        // proven and fail closed until this physical slot is released.
+        markSaturationOwner(physical);
+        return;
+      }
+    }
+    if (weakMapValue(quarantinedKeysByPhysical, physical.slot) !== confirmedKeys) {
+      placementQuarantinePoisoned = true;
+      markSaturationOwner(physical);
+    }
+  };
+
+  const releasePhysicalPlacement = (physical: PhysicalSlot): void => {
+    if (physical.saturationOwner) {
+      physical.saturationOwner = false;
+      saturationOwnerCount -= 1;
+      if (saturationOwnerCount === 0) placementQuarantineSaturated = false;
+    }
+    const keys = weakMapValue(quarantinedKeysByPhysical, physical.slot);
+    if (!keys) return;
+    deleteWeakMapValue(quarantinedKeysByPhysical, physical.slot);
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      if (key === undefined) continue;
+      const count = mapValue(placementQuarantine, key);
+      if (count === undefined) continue;
+      if (count <= 1) deleteMapValue(placementQuarantine, key);
+      else setMapValue(placementQuarantine, key, count - 1);
+    }
+  };
+
+  const settle = (intent: RequestIntent, outcome: SlotRequestOutcome): void => {
+    if (intent.terminal) return;
+    intent.terminal = true;
+    intent.state = 'terminal';
+    if (intent.requestTimer !== undefined) clearTimeout(intent.requestTimer);
+    if (intent.completionTimer !== undefined) clearTimeout(intent.completionTimer);
+    intent.requestTimer = undefined;
+    intent.completionTimer = undefined;
+    intent.requestDeadlineAt = undefined;
+    intent.completionDeadlineAt = undefined;
+    intent.invocation?.dispose();
+    intent.invocation = undefined;
+    if (intent.record.activeIntent === intent) intent.record.activeIntent = undefined;
+    if (intent.record.queuedIntent === intent) intent.record.queuedIntent = undefined;
+    intent.resolve(outcome);
+  };
+
+  const failQueued = (record: InternalSlotRecord, reason: SlotRequestFailure): void => {
+    const queued = record.queuedIntent;
+    if (queued) settle(queued, failed(reason));
+  };
+
+  const advanceQueued = (record: InternalSlotRecord): void => {
+    if (record.activeIntent || record.state.disposed || !record.state.owner.isCurrent()) return;
+    const queued = record.queuedIntent;
+    if (!queued) return;
+    const physical = record.physical;
+    if (!physical || physical.state !== 'live' || physical.activeCycle) return;
+    record.queuedIntent = undefined;
+    record.activeIntent = queued;
+    queued.state = 'active';
+    invokeIntent(record, queued);
+  };
+
+  const retireCommittedArtifact = (record: InternalSlotRecord, physical: PhysicalSlot): void => {
+    const artifact = physical.committedArtifact;
+    if (!artifact) return;
+    physical.committedArtifact = undefined;
+    try {
+      disposeCommittedArtifact?.(
+        record.state.owner.generation,
+        record.view.registeredSlotId,
+        artifact
+      );
+    } catch {
+      // Physical retirement remains authoritative when artifact cleanup throws.
+    }
+  };
+
+  const prepareReplacementCommit = (
+    record: InternalSlotRecord,
+    oldPhysical: PhysicalSlot,
+    replacement: object,
+    definition = oldPhysical.definition,
+    domElement = oldPhysical.domElement
+  ): GoogletagReplacementCommitAdmission => {
+    if (
+      replacement === oldPhysical.slot ||
+      record.physical !== oldPhysical ||
+      record.state.disposed ||
+      !record.state.owner.isCurrent()
+    ) {
+      throw new Error('gpt_request_failed');
+    }
+    const existing = weakMapValue(physicalByObject, replacement);
+    if (existing) throw new GoogletagReplacementCandidateCollisionError(replacement);
+    const previousView = record.view;
+    const replacementTraceToken = traceTokenFor(replacement);
+    const physical: PhysicalSlot = {
+      activeCycle: undefined,
+      apsMountClaim: undefined,
+      committedArtifact: undefined,
+      bindingEpoch: Object.freeze({}),
+      definition,
+      domElement,
+      elementIdPrefix: oldPhysical.elementIdPrefix,
+      destroyAttempted: false,
+      lastResponseIdentifier: undefined,
+      lastCycle: undefined,
+      ownership: 'trusted_server',
+      placementKeys: oldPhysical.placementKeys,
+      publisherAdmissions: [],
+      publisherElementIds: Object.freeze([]),
+      quarantineReason: undefined,
+      record,
+      saturationOwner: false,
+      slot: replacement,
+      state: 'live',
+      suppressPublisherDisplay: false,
+      suppressPublisherRefresh: false,
+    };
+    let committed = false;
+    const rollback = (): void => {
+      if (record.physical === physical) record.physical = oldPhysical;
+      if (record.physical === oldPhysical) record.view = previousView;
+      if (oldPhysical.record === undefined && record.physical === oldPhysical) {
+        oldPhysical.record = record;
+      }
+      deleteSetValue(physicalSlots, physical);
+      if (weakMapValue(physicalByObject, replacement) === physical) {
+        deleteWeakMapValue(physicalByObject, replacement);
+      }
+      if (committed) addSetValue(physicalSlots, oldPhysical);
+      committed = false;
+    };
+    return Object.freeze({
+      commit: (): boolean => {
+        if (
+          committed ||
+          record.physical !== oldPhysical ||
+          record.state.disposed ||
+          !record.state.owner.isCurrent()
+        ) {
+          return false;
+        }
+        setWeakMapValue(physicalByObject, replacement, physical);
+        if (weakMapValue(physicalByObject, replacement) !== physical) return false;
+        addSetValue(physicalSlots, physical);
+        if (!setHasValue(physicalSlots, physical)) return false;
+        if (record.state.disposed || !record.state.owner.isCurrent()) return false;
+        retireCommittedArtifact(record, oldPhysical);
+        if (record.state.disposed || !record.state.owner.isCurrent()) return false;
+        record.physical = physical;
+        record.view = recordWithTraceToken(record.view, replacementTraceToken);
+        oldPhysical.record = undefined;
+        deleteSetValue(physicalSlots, oldPhysical);
+        committed = true;
+        return true;
+      },
+      rollback,
+    });
+  };
+
+  const quarantineReplacementOrphan = (
+    source: PhysicalSlot,
+    orphanedSlot: object | undefined
+  ): void => {
+    if (!orphanedSlot || orphanedSlot === source.slot) return;
+    const orphan: PhysicalSlot = {
+      activeCycle: undefined,
+      apsMountClaim: undefined,
+      committedArtifact: undefined,
+      bindingEpoch: Object.freeze({}),
+      definition: source.definition,
+      domElement: undefined,
+      elementIdPrefix: source.elementIdPrefix,
+      destroyAttempted: true,
+      lastResponseIdentifier: undefined,
+      lastCycle: undefined,
+      ownership: 'trusted_server',
+      placementKeys: source.placementKeys,
+      publisherAdmissions: [],
+      publisherElementIds: Object.freeze([]),
+      quarantineReason: 'request',
+      record: undefined,
+      saturationOwner: false,
+      slot: orphanedSlot,
+      state: 'quarantined',
+      suppressPublisherDisplay: false,
+      suppressPublisherRefresh: false,
+    };
+    try {
+      setWeakMapValue(physicalByObject, orphan.slot, orphan);
+      if (weakMapValue(physicalByObject, orphan.slot) !== orphan) {
+        throw new Error('orphan publication failed');
+      }
+      quarantinePhysicalPlacement(orphan);
+    } catch {
+      placementQuarantinePoisoned = true;
+    }
+  };
+
+  const recoverRequestTimeout = (record: InternalSlotRecord, physical: PhysicalSlot): void => {
+    if (physical.destroyAttempted) {
+      physical.state = 'quarantined';
+      failQueued(record, 'gpt_request_failed');
+      return;
+    }
+    physical.state = 'retired';
+    physical.quarantineReason = 'request';
+    physical.destroyAttempted = true;
+    quarantinePhysicalPlacement(physical);
+    if (
+      physical.ownership !== 'trusted_server' ||
+      !physical.definition ||
+      record.state.disposed ||
+      !record.state.owner.isCurrent()
+    ) {
+      physical.state = 'quarantined';
+      failQueued(record, 'gpt_request_failed');
+      return;
+    }
+    let operation: GoogletagOperation<GoogletagReplacementResult>;
+    try {
+      operation = options.googletag.run((gpt) =>
+        gpt.transactionalReplace(
+          physical.slot,
+          physical.definition,
+          () => !record.state.disposed && record.state.owner.isCurrent(),
+          (replacement) => prepareReplacementCommit(record, physical, replacement)
+        )
+      );
+    } catch {
+      retireCommittedArtifact(record, physical);
+      physical.state = 'quarantined';
+      failQueued(record, 'gpt_request_failed');
+      return;
+    }
+    const detachDestroyedOld = (): void => {
+      if (record.physical === physical) record.physical = undefined;
+      physical.record = undefined;
+      releasePhysicalPlacement(physical);
+      deleteSetValue(physicalSlots, physical);
+      if (weakMapValue(physicalByObject, physical.slot) === physical) {
+        deleteWeakMapValue(physicalByObject, physical.slot);
+      }
+    };
+    void operation.result.then(
+      (result) => {
+        retireCommittedArtifact(record, physical);
+        if (result.status !== 'replaced') {
+          detachDestroyedOld();
+          failQueued(record, 'gpt_request_failed');
+          return;
+        }
+        releasePhysicalPlacement(physical);
+        if (weakMapValue(physicalByObject, physical.slot) === physical) {
+          deleteWeakMapValue(physicalByObject, physical.slot);
+        }
+        deleteSetValue(physicalSlots, physical);
+        advanceQueued(record);
+      },
+      (error: unknown) => {
+        retireCommittedArtifact(record, physical);
+        physical.state = 'quarantined';
+        const replacementError = error instanceof GoogletagReplacementError ? error : undefined;
+        const reusedOldIdentity = replacementError?.orphanedSlot === physical.slot;
+        if (
+          replacementError?.oldSlotDestroyed &&
+          !replacementError.preserveOldQuarantine &&
+          !reusedOldIdentity
+        ) {
+          detachDestroyedOld();
+        }
+        quarantineReplacementOrphan(physical, replacementError?.orphanedSlot);
+        failQueued(record, 'gpt_request_failed');
+      }
+    );
+  };
+
+  const cancelIntent = (intent: RequestIntent): void => {
+    if (intent.terminal) return;
+    if (intent.record.reconciliation?.pendingFailureReason !== undefined) {
+      settle(intent, cancelled('superseded'));
+      return;
+    }
+    const wasInvoked = intent.requestStartedAt !== undefined;
+    const physical = intent.record.physical;
+    if (intent.state === 'cycle' && physical?.activeCycle?.intent === intent) {
+      physical.activeCycle.intent = undefined;
+      physical.state = 'quarantined';
+      physical.quarantineReason = 'completion';
+      settle(intent, cancelled('superseded'));
+      return;
+    }
+    settle(intent, cancelled('superseded'));
+    if (wasInvoked && physical) recoverRequestTimeout(intent.record, physical);
+    else advanceQueued(intent.record);
+  };
+
+  const onRequestTimeout = (intent: RequestIntent): void => {
+    if (intent.terminal || intent.state !== 'active') return;
+    const deadline = intent.requestDeadlineAt;
+    if (deadline !== undefined && now() < deadline) {
+      intent.requestTimer = setTimeout(
+        () => onRequestTimeout(intent),
+        Math.max(1, deadline - now())
+      );
+      return;
+    }
+    const physical = intent.record.physical;
+    settle(intent, failed('gpt_request_timeout'));
+    if (!physical) {
+      failQueued(intent.record, 'gpt_request_failed');
+      return;
+    }
+    recoverRequestTimeout(intent.record, physical);
+  };
+
+  const onCompletionTimeout = (intent: RequestIntent): void => {
+    if (intent.terminal || intent.state !== 'cycle') return;
+    const deadline = intent.completionDeadlineAt;
+    if (deadline !== undefined && now() < deadline) {
+      intent.completionTimer = setTimeout(
+        () => onCompletionTimeout(intent),
+        Math.max(1, deadline - now())
+      );
+      return;
+    }
+    const physical = intent.record.physical;
+    const physicalCycle = physical?.activeCycle;
+    const ownsPhysicalCycle = physicalCycle?.intent === intent;
+    if (ownsPhysicalCycle && physical && physicalCycle) {
+      physicalCycle.intent = undefined;
+      physical.state = 'quarantined';
+      physical.quarantineReason = 'completion';
+    }
+    settle(intent, failed('gpt_completion_timeout'));
+    if (ownsPhysicalCycle && physical?.ownership === 'trusted_server') {
+      recoverRequestTimeout(intent.record, physical);
+    }
+  };
+
+  const armRequestDeadline = (intent: RequestIntent): void => {
+    intent.requestStartedAt = now();
+    intent.requestDeadlineAt = intent.requestStartedAt + GPT_REQUEST_START_TIMEOUT_MS;
+    intent.completionDeadlineAt = intent.requestStartedAt + GPT_COMPLETION_TIMEOUT_MS;
+    intent.requestTimer = setTimeout(() => onRequestTimeout(intent), GPT_REQUEST_START_TIMEOUT_MS);
+  };
+
+  const failExternalInvocation = (
+    record: InternalSlotRecord,
+    intent: RequestIntent,
+    error: unknown
+  ): void => {
+    if (intent.terminal) return;
+    if (record.reconciliation?.pendingFailureReason !== undefined) return;
+    const reason = externalInvocationFailure(error);
+    const physical = record.physical;
+    if (physical?.activeCycle?.intent === intent) {
+      physical.activeCycle.intent = undefined;
+      physical.state = 'quarantined';
+      physical.quarantineReason = 'completion';
+      settle(intent, failed(reason));
+      return;
+    }
+    const wasInvoked = intent.requestStartedAt !== undefined;
+    settle(intent, failed(reason));
+    if (wasInvoked && physical) recoverRequestTimeout(record, physical);
+    else advanceQueued(record);
+  };
+
+  const ensureBindingSubscriptions = (
+    gpt: Readonly<GoogletagFacade>
+  ): BindingSubscriptionAdmission => {
+    const token = gpt.bindingToken();
+    const existing = weakMapValue(subscriptionsByBinding, token);
+    if (existing) return { installed: false, ownership: existing };
+    const releaseRequested = gpt.subscribe('slotRequested', (event) =>
+      handleGptEvent('slotRequested', event)
+    );
+    let releaseRendered: (() => void) | undefined;
+    try {
+      releaseRendered = gpt.subscribe('slotRenderEnded', (event) =>
+        handleGptEvent('slotRenderEnded', event)
+      );
+    } catch (error) {
+      releaseRequested();
+      throw error;
+    }
+    let active = true;
+    const ownership: BindingSubscriptions = {
+      token,
+      release: (): void => {
+        if (!active) return;
+        active = false;
+        if (weakMapValue(subscriptionsByBinding, token) === ownership) {
+          deleteWeakMapValue(subscriptionsByBinding, token);
+        }
+        deleteSetValue(bindingSubscriptions, ownership);
+        try {
+          releaseRendered?.();
+        } finally {
+          releaseRequested();
+        }
+      },
+    };
+    try {
+      setWeakMapValue(subscriptionsByBinding, token, ownership);
+      addSetValue(bindingSubscriptions, ownership);
+      if (disposed) ownership.release();
+    } catch (error) {
+      ownership.release();
+      throw error;
+    }
+    return { installed: true, ownership };
+  };
+
+  const retireHistoricalSubscriptions = (current: BindingSubscriptions): void => {
+    const historical = setValueSnapshot(bindingSubscriptions);
+    for (let index = 0; index < historical.length; index += 1) {
+      const subscription = historical[index];
+      if (subscription && subscription !== current) subscription.release();
+    }
+  };
+
+  function invokeExternalIntent(
+    record: InternalSlotRecord,
+    intent: RequestIntent,
+    expectedBindingToken: object
+  ): void {
+    if (record.reconciliation?.pendingFailureReason !== undefined) return;
+    if (
+      intent.terminal ||
+      record.activeIntent !== intent ||
+      record.state.disposed ||
+      !record.state.owner.isCurrent()
+    ) {
+      settle(intent, cancelled('navigation_disposed'));
+      return;
+    }
+    const physical = record.physical;
+    if (!physical || physical.state !== 'live' || physical.activeCycle) {
+      settle(
+        intent,
+        failed(
+          physical?.state === 'quarantined'
+            ? 'slot_quarantined'
+            : physical?.activeCycle
+              ? 'cycle_unattributable'
+              : 'slot_unresolved'
+        )
+      );
+      return;
+    }
+    try {
+      const operation = options.googletag.run((gpt) => {
+        if (gpt.bindingToken() !== expectedBindingToken) {
+          throw new Error('GPT binding changed before invocation');
+        }
+        if (
+          intent.terminal ||
+          record.activeIntent !== intent ||
+          record.physical !== physical ||
+          record.state.disposed ||
+          !record.state.owner.isCurrent()
+        ) {
+          return;
+        }
+        const state = gpt.serviceState();
+        const publishRequest = (): void => {
+          try {
+            options.onTrustedServerRequest?.(
+              Object.freeze({
+                ...(intent.input.trustedServerOpportunity === undefined
+                  ? {}
+                  : { opportunity: intent.input.trustedServerOpportunity }),
+                registeredSlotId: record.view.registeredSlotId,
+                slot: physical.slot,
+              })
+            );
+          } catch {
+            // Diagnostics request-intent publication cannot alter the admitted GPT request.
+          }
+        };
+        if (!state.pubadsReady) gpt.enableServices();
+        if (intent.input.operation === 'display' && state.initialLoadDisabled) {
+          gpt.display(physical.slot);
+          if (intent.terminal || physical.activeCycle) return;
+          publishRequest();
+          armRequestDeadline(intent);
+          gpt.refresh([physical.slot], Object.freeze({ changeCorrelator: false }));
+          return;
+        }
+        publishRequest();
+        armRequestDeadline(intent);
+        if (intent.input.operation === 'display') gpt.display(physical.slot);
+        else gpt.refresh([physical.slot], Object.freeze({ changeCorrelator: false }));
+      });
+      intent.invocation = operation;
+      if (intent.terminal) operation.dispose();
+      void operation.result.then(
+        () => undefined,
+        (error: unknown) => {
+          failExternalInvocation(record, intent, error);
+        }
+      );
+    } catch (error) {
+      failExternalInvocation(record, intent, error);
+    }
+  }
+
+  function invokeIntent(record: InternalSlotRecord, intent: RequestIntent): void {
+    if (intent.terminal) return;
+    let operation: GoogletagOperation<BindingSubscriptionAdmission>;
+    let provisionalSubscriptions: BindingSubscriptionAdmission | undefined;
+    try {
+      operation = options.googletag.run((gpt) => {
+        provisionalSubscriptions = ensureBindingSubscriptions(gpt);
+        return provisionalSubscriptions;
+      });
+    } catch (error) {
+      if (provisionalSubscriptions?.installed) provisionalSubscriptions.ownership.release();
+      failExternalInvocation(record, intent, error);
+      return;
+    }
+    intent.invocation = operation;
+    void operation.result.then(
+      (subscriptions) => {
+        if (intent.invocation === operation) intent.invocation = undefined;
+        retireHistoricalSubscriptions(subscriptions.ownership);
+        if (intent.terminal) return;
+        if (record.reconciliation?.pendingFailureReason !== undefined) return;
+        invokeExternalIntent(record, intent, subscriptions.ownership.token);
+      },
+      (error: unknown) => {
+        if (intent.invocation === operation) intent.invocation = undefined;
+        if (provisionalSubscriptions?.installed) provisionalSubscriptions.ownership.release();
+        failExternalInvocation(record, intent, error);
+      }
+    );
+  }
+
+  const handleGptEvent = (
+    type: GptEventType,
+    event: unknown
+  ): Readonly<GoogletagTraceCycleHandle> | undefined => {
+    const slot = ownData(event, 'slot');
+    if ((typeof slot !== 'object' || slot === null) && typeof slot !== 'function') return;
+    const physical = weakMapValue(physicalByObject, slot as object);
+    if (!physical) return;
+
+    if (type === 'slotRequested') {
+      const publisherAdmission = physical.publisherAdmissions[0];
+      if (publisherAdmission) {
+        const phase = publisherAdmission.phase;
+        removePublisherAdmission(publisherAdmission);
+        publisherAdmission.phase = 'consumed';
+        if (phase === 'pending') applyPublisherIntent(physical);
+        if (!physical.activeCycle && physical.state === 'live') {
+          return openPhysicalCycle(physical, undefined, 'publisher').traceHandle;
+        }
+        return physical.activeCycle?.traceHandle;
+      }
+      const record = physical.record;
+      const intent = record?.activeIntent;
+      if (
+        physical.state === 'live' &&
+        !physical.activeCycle &&
+        intent &&
+        !intent.terminal &&
+        intent.state === 'active' &&
+        intent.requestStartedAt !== undefined
+      ) {
+        if (now() > (intent.requestDeadlineAt ?? Number.NEGATIVE_INFINITY)) {
+          onRequestTimeout(intent);
+          return;
+        }
+        if (intent.requestTimer !== undefined) clearTimeout(intent.requestTimer);
+        intent.requestTimer = undefined;
+        intent.state = 'cycle';
+        const cycle = openPhysicalCycle(physical, intent, 'trusted_server');
+        intent.completionTimer = setTimeout(
+          () => onCompletionTimeout(intent),
+          Math.max(0, (intent.completionDeadlineAt ?? now()) - now())
+        );
+        return cycle.traceHandle;
+      }
+      if (record) retireCommittedArtifact(record, physical);
+      if (intent && !intent.terminal) settle(intent, failed('cycle_unattributable'));
+      if (physical.state !== 'live' || physical.activeCycle) return;
+      return openPhysicalCycle(physical, undefined, 'publisher').traceHandle;
+    }
+
+    const responseIdentifierValue = ownData(event, 'responseIdentifier');
+    const responseIdentifier =
+      typeof responseIdentifierValue === 'string' ? responseIdentifierValue : undefined;
+    if (
+      responseIdentifier !== undefined &&
+      responseIdentifier === physical.lastResponseIdentifier
+    ) {
+      return;
+    }
+    const cycle = physical.activeCycle;
+    if (!cycle) return;
+    const intent = cycle.intent;
+    if (
+      intent &&
+      !intent.terminal &&
+      now() > (intent.completionDeadlineAt ?? Number.NEGATIVE_INFINITY)
+    ) {
+      onCompletionTimeout(intent);
+    }
+    const isEmptyValue = ownData(event, 'isEmpty');
+    if (isEmptyValue !== true && isEmptyValue !== false) return;
+    if (responseIdentifier !== undefined) physical.lastResponseIdentifier = responseIdentifier;
+    clearPhysicalCycle(physical, true);
+    const acceptedHandle = cycle.traceHandle;
+    if (intent && !intent.terminal) {
+      settle(
+        intent,
+        Object.freeze({
+          ...(responseIdentifier === undefined ? {} : { responseIdentifier }),
+          status: isEmptyValue ? ('empty' as const) : ('rendered' as const),
+        })
+      );
+      advanceQueued(intent.record);
+      return acceptedHandle;
+    }
+    if (physical.quarantineReason === 'completion' || physical.quarantineReason === 'navigation') {
+      const quarantineReason = physical.quarantineReason;
+      physical.quarantineReason = undefined;
+      if (quarantineReason === 'navigation' && physical.ownership === 'publisher') {
+        releasePhysicalPlacement(physical);
+      }
+      if (quarantineReason === 'completion' || physical.ownership === 'publisher') {
+        physical.state = 'live';
+      }
+      if (physical.record && physical.state === 'live') advanceQueued(physical.record);
+      else deleteSetValue(physicalSlots, physical);
+    }
+    return acceptedHandle;
+  };
+
+  const retirePhysicalForNavigation = (physical: PhysicalSlot): void => {
+    retirePhysicalTraceCycles(physical);
+    const record = physical.record;
+    if (record) retireCommittedArtifact(record, physical);
+    invalidatePublisherAdmissions(physical);
+    physical.record = undefined;
+    if (physical.ownership === 'publisher') {
+      if (physical.activeCycle) {
+        physical.state = 'quarantined';
+        physical.quarantineReason = 'navigation';
+        quarantinePhysicalPlacement(physical);
+      }
+      deleteSetValue(physicalSlots, physical);
+      return;
+    }
+    if (physical.destroyAttempted) {
+      deleteSetValue(physicalSlots, physical);
+      return;
+    }
+    physical.state = 'retired';
+    physical.quarantineReason = 'navigation';
+    physical.destroyAttempted = true;
+    quarantinePhysicalPlacement(physical);
+    deleteSetValue(physicalSlots, physical);
+    let operation: GoogletagOperation<unknown> | undefined;
+    try {
+      operation = options.googletag.run((gpt) =>
+        gpt.transactionalReplace(
+          physical.slot,
+          undefined,
+          () => false,
+          () => {
+            throw new Error('destroy-only replacement cannot commit');
+          }
+        )
+      );
+      void operation.result.then(
+        () => {
+          releasePhysicalPlacement(physical);
+          if (weakMapValue(physicalByObject, physical.slot) === physical) {
+            deleteWeakMapValue(physicalByObject, physical.slot);
+          }
+        },
+        () => undefined
+      );
+    } catch {
+      operation?.dispose();
+    }
+  };
+
+  const clearReconciliationTimers = (window: ReconciliationWindow): void => {
+    if (window.debounceTimer !== undefined) clearTimeout(window.debounceTimer);
+    if (window.deadlineTimer !== undefined) clearTimeout(window.deadlineTimer);
+    window.debounceTimer = undefined;
+    window.deadlineTimer = undefined;
+  };
+
+  const cancelReconciliation = (record: InternalSlotRecord): void => {
+    const window = record.reconciliation;
+    if (!window || window.terminal) return;
+    window.terminal = true;
+    clearReconciliationTimers(window);
+    window.operation?.dispose();
+    window.operation = undefined;
+    if (record.reconciliation === window) record.reconciliation = undefined;
+  };
+
+  const detachDestroyedReconciliationPhysical = (physical: PhysicalSlot): void => {
+    releasePhysicalPlacement(physical);
+    deleteSetValue(physicalSlots, physical);
+    if (weakMapValue(physicalByObject, physical.slot) === physical) {
+      deleteWeakMapValue(physicalByObject, physical.slot);
+    }
+  };
+
+  const settleReconciliationWork = (
+    record: InternalSlotRecord,
+    physical: PhysicalSlot,
+    reason: SlotRequestFailure
+  ): void => {
+    const cycleIntent = physical.activeCycle?.intent;
+    if (cycleIntent && !cycleIntent.terminal) settle(cycleIntent, failed(reason));
+    if (record.activeIntent) settle(record.activeIntent, failed(reason));
+    if (record.queuedIntent) settle(record.queuedIntent, failed(reason));
+    clearPhysicalCycle(physical);
+  };
+
+  const pauseReconciliationIntent = (intent: RequestIntent | undefined): void => {
+    if (!intent || intent.terminal) return;
+    if (intent.requestTimer !== undefined) clearTimeout(intent.requestTimer);
+    if (intent.completionTimer !== undefined) clearTimeout(intent.completionTimer);
+    intent.requestTimer = undefined;
+    intent.completionTimer = undefined;
+    intent.requestDeadlineAt = undefined;
+    intent.completionDeadlineAt = undefined;
+  };
+
+  const finishFailedReconciliation = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow,
+    reason: SlotRequestFailure,
+    oldSlotDestroyed: boolean
+  ): void => {
+    if (window.terminal || record.reconciliation !== window) return;
+    window.terminal = true;
+    clearReconciliationTimers(window);
+    window.operation?.dispose();
+    window.operation = undefined;
+    record.reconciliation = undefined;
+    const physical = window.orphan;
+
+    settleReconciliationWork(record, physical, reason);
+    retireCommittedArtifact(record, physical);
+    if (record.physical === physical) record.physical = undefined;
+    physical.record = undefined;
+    physical.state = 'retired';
+    physical.quarantineReason = 'request';
+    physical.destroyAttempted = true;
+    deleteSetValue(physicalSlots, physical);
+    if (oldSlotDestroyed) {
+      detachDestroyedReconciliationPhysical(physical);
+      return;
+    }
+    quarantinePhysicalPlacement(physical);
+  };
+
+  const retireFailedReconciliation = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow,
+    reason: SlotRequestFailure,
+    transactionStarted: boolean,
+    oldSlotDestroyed: boolean
+  ): void => {
+    if (window.terminal || record.reconciliation !== window) return;
+    if (window.pendingFailureReason !== undefined) return;
+    if (transactionStarted || oldSlotDestroyed) {
+      finishFailedReconciliation(record, window, reason, oldSlotDestroyed);
+      return;
+    }
+    const physical = window.orphan;
+    if (record.physical !== physical || physical.ownership !== 'trusted_server') {
+      cancelReconciliation(record);
+      return;
+    }
+
+    window.pendingFailureReason = reason;
+    clearReconciliationTimers(window);
+    window.operation?.dispose();
+    window.operation = undefined;
+    pauseReconciliationIntent(physical.activeCycle?.intent);
+    pauseReconciliationIntent(record.activeIntent);
+    pauseReconciliationIntent(record.queuedIntent);
+    clearPhysicalCycle(physical);
+    retireCommittedArtifact(record, physical);
+    physical.state = 'retired';
+    physical.quarantineReason = 'request';
+    physical.destroyAttempted = true;
+    quarantinePhysicalPlacement(physical);
+    deleteSetValue(physicalSlots, physical);
+
+    let destroyOperation: GoogletagOperation<GoogletagReplacementResult> | undefined;
+    try {
+      destroyOperation = options.googletag.run((gpt) =>
+        gpt.transactionalReplace(
+          physical.slot,
+          undefined,
+          () => false,
+          () => {
+            throw new Error('destroy-only reconciliation cannot commit');
+          }
+        )
+      );
+      window.operation = destroyOperation;
+      void destroyOperation.result.then(
+        (result) => {
+          if (result.status === 'destroyed') {
+            if (window.terminal || record.reconciliation !== window) {
+              detachDestroyedReconciliationPhysical(physical);
+              return;
+            }
+            finishFailedReconciliation(record, window, reason, true);
+            return;
+          }
+          finishFailedReconciliation(record, window, 'gpt_request_failed', true);
+        },
+        (error: unknown) => {
+          const replacementError = error instanceof GoogletagReplacementError ? error : undefined;
+          const reusedOldIdentity = replacementError?.orphanedSlot === physical.slot;
+          const destroyed =
+            replacementError?.oldSlotDestroyed === true &&
+            replacementError.preserveOldQuarantine !== true &&
+            !reusedOldIdentity;
+          if (destroyed && (window.terminal || record.reconciliation !== window)) {
+            detachDestroyedReconciliationPhysical(physical);
+            return;
+          }
+          finishFailedReconciliation(record, window, 'gpt_request_failed', destroyed);
+        }
+      );
+    } catch {
+      destroyOperation?.dispose();
+      finishFailedReconciliation(record, window, 'gpt_request_failed', false);
+    }
+  };
+
+  const completeReconciliation = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow
+  ): boolean => {
+    if (window.terminal || record.reconciliation !== window) return false;
+    const physical = record.physical;
+    if (
+      !physical ||
+      physical === window.orphan ||
+      physical.ownership !== 'trusted_server' ||
+      physical.record !== record ||
+      record.state.disposed ||
+      !record.state.owner.isCurrent()
+    ) {
+      return false;
+    }
+    retireCommittedArtifact(record, window.orphan);
+    window.terminal = true;
+    clearReconciliationTimers(window);
+    window.operation?.dispose();
+    window.operation = undefined;
+    record.reconciliation = undefined;
+    record.reconciliationSuccesses += 1;
+    const active = record.activeIntent;
+    if (
+      active &&
+      !active.terminal &&
+      (active.requestStartedAt !== undefined || window.orphan.activeCycle?.intent === active)
+    ) {
+      settle(active, failed('gpt_request_failed'));
+    }
+    clearPhysicalCycle(window.orphan);
+    detachDestroyedReconciliationPhysical(window.orphan);
+    advanceQueued(record);
+    return true;
+  };
+
+  const startReconciliationReplacement = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow,
+    resolution: Extract<SlotReconciliationResolution, { status: 'unique' }>,
+    finalPass: boolean
+  ): void => {
+    const orphan = window.orphan;
+    const existingDefinition = orphan.definition;
+    if (!existingDefinition) {
+      retireFailedReconciliation(record, window, 'slot_unresolved', false, false);
+      return;
+    }
+    const definition = Object.freeze({
+      adUnitPath: existingDefinition.adUnitPath,
+      elementId: resolution.elementId,
+      sizes: existingDefinition.sizes,
+    });
+    let transactionStarted = false;
+    let operation: GoogletagOperation<GoogletagReplacementResult> | undefined;
+    try {
+      operation = options.googletag.run((gpt) => {
+        transactionStarted = true;
+        orphan.state = 'retired';
+        orphan.quarantineReason = 'request';
+        orphan.destroyAttempted = true;
+        quarantinePhysicalPlacement(orphan);
+        return gpt.transactionalReplace(
+          orphan.slot,
+          definition,
+          () =>
+            !window.terminal &&
+            record.reconciliation === window &&
+            !record.state.disposed &&
+            record.state.owner.isCurrent() &&
+            ((record.physical === orphan && orphan.ownership === 'trusted_server') ||
+              (record.physical !== undefined &&
+                record.physical !== orphan &&
+                record.physical.record === record &&
+                record.physical.ownership === 'trusted_server')),
+          (replacement) =>
+            prepareReplacementCommit(record, orphan, replacement, definition, resolution.element)
+        );
+      });
+      window.operation = operation;
+    } catch {
+      retireFailedReconciliation(record, window, 'gpt_request_failed', transactionStarted, false);
+      return;
+    }
+
+    if (record.physical !== orphan) {
+      completeReconciliation(record, window);
+      return;
+    }
+    if (finalPass && !transactionStarted) {
+      void operation.result.then(
+        () => undefined,
+        () => undefined
+      );
+      retireFailedReconciliation(record, window, 'slot_unresolved', transactionStarted, false);
+      return;
+    }
+    void operation.result.then(
+      (result) => {
+        if (window.terminal) return;
+        if (result.status === 'replaced' && completeReconciliation(record, window)) return;
+        retireFailedReconciliation(record, window, 'gpt_request_failed', true, true);
+      },
+      (error: unknown) => {
+        const replacementError = error instanceof GoogletagReplacementError ? error : undefined;
+        const reusedOldIdentity = replacementError?.orphanedSlot === orphan.slot;
+        const oldSlotDestroyed =
+          replacementError?.oldSlotDestroyed === true &&
+          replacementError.preserveOldQuarantine !== true &&
+          !reusedOldIdentity;
+        quarantineReplacementOrphan(orphan, replacementError?.orphanedSlot);
+        retireFailedReconciliation(
+          record,
+          window,
+          'gpt_request_failed',
+          transactionStarted,
+          oldSlotDestroyed
+        );
+      }
+    );
+  };
+
+  const runReconciliationPass = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow,
+    finalPass: boolean
+  ): void => {
+    if (
+      window.terminal ||
+      record.reconciliation !== window ||
+      record.physical !== window.orphan ||
+      window.orphan.ownership !== 'trusted_server' ||
+      record.state.disposed ||
+      !record.state.owner.isCurrent()
+    ) {
+      cancelReconciliation(record);
+      return;
+    }
+    if (reconciliationElementConnected(window.orphan.domElement)) {
+      cancelReconciliation(record);
+      return;
+    }
+    if (window.operation) {
+      if (record.physical !== window.orphan) completeReconciliation(record, window);
+      else if (finalPass) {
+        retireFailedReconciliation(record, window, 'slot_unresolved', false, false);
+      }
+      return;
+    }
+    const definition = window.orphan.definition;
+    const resolution = definition && resolveReconciliationElement(record, definition);
+    if (resolution?.status === 'unique') {
+      startReconciliationReplacement(record, window, resolution, finalPass);
+      return;
+    }
+    if (finalPass) {
+      retireFailedReconciliation(record, window, 'slot_unresolved', false, false);
+    } else {
+      window.firstPassFinished = true;
+    }
+  };
+
+  const scheduleReconciliationDebounce = (
+    record: InternalSlotRecord,
+    window: ReconciliationWindow
+  ): void => {
+    if (window.firstPassFinished || window.operation || window.terminal) return;
+    if (window.debounceTimer !== undefined) clearTimeout(window.debounceTimer);
+    window.debounceTimer = setTimeout(() => {
+      window.debounceTimer = undefined;
+      runReconciliationPass(record, window, false);
+    }, GPT_RECONCILIATION_DEBOUNCE_MS);
+  };
+
+  const openReconciliation = (record: InternalSlotRecord, physical: PhysicalSlot): void => {
+    if (record.reconciliationSuccesses >= MAX_SUCCESSFUL_RECONCILIATIONS) {
+      const instant: ReconciliationWindow = {
+        debounceTimer: undefined,
+        deadlineTimer: undefined,
+        deadlineAt: Number.NEGATIVE_INFINITY,
+        firstPassFinished: true,
+        operation: undefined,
+        orphan: physical,
+        pendingFailureReason: undefined,
+        terminal: false,
+      };
+      record.reconciliation = instant;
+      retireFailedReconciliation(record, instant, 'reconciliation_capacity', false, false);
+      return;
+    }
+    const openedAt = now();
+    if (!Number.isFinite(openedAt) || openedAt < 0) return;
+    const window: ReconciliationWindow = {
+      debounceTimer: undefined,
+      deadlineTimer: undefined,
+      deadlineAt: openedAt + GPT_RECONCILIATION_WINDOW_MS,
+      firstPassFinished: false,
+      operation: undefined,
+      orphan: physical,
+      pendingFailureReason: undefined,
+      terminal: false,
+    };
+    record.reconciliation = window;
+    scheduleReconciliationDebounce(record, window);
+    window.deadlineTimer = setTimeout(() => {
+      window.deadlineTimer = undefined;
+      if (window.terminal) return;
+      const current = now();
+      if (Number.isFinite(current) && current < window.deadlineAt) {
+        window.deadlineTimer = setTimeout(
+          () => runReconciliationPass(record, window, true),
+          Math.max(1, window.deadlineAt - current)
+        );
+        return;
+      }
+      runReconciliationPass(record, window, true);
+    }, GPT_RECONCILIATION_WINDOW_MS);
+  };
+
+  const inspectNavigationDom = (state: NavigationState): void => {
+    if (state.disposed || !state.owner.isCurrent()) return;
+    const records = mapValueSnapshot(state.records);
+    for (let index = 0; index < records.length; index += 1) {
+      const record = records[index];
+      const physical = record?.physical;
+      if (!record || !physical) continue;
+      if (
+        physical.ownership !== 'trusted_server' ||
+        physical.state !== 'live' ||
+        physical.publisherAdmissions.length > 0 ||
+        !physical.definition
+      ) {
+        cancelReconciliation(record);
+        continue;
+      }
+      if (reconciliationElementConnected(physical.domElement)) continue;
+      const existing = record.reconciliation;
+      if (!existing) openReconciliation(record, physical);
+      else if (existing.orphan === physical) scheduleReconciliationDebounce(record, existing);
+      else cancelReconciliation(record);
+    }
+  };
+
+  const installNavigationObserver = (state: NavigationState): boolean => {
+    if (!reconciliationBoundary || !reconciliationObserve) return true;
+    if (state.observerRelease) return true;
+    try {
+      const release = Reflect.apply(reconciliationObserve, reconciliationBoundary, [
+        () => inspectNavigationDom(state),
+      ]) as () => void;
+      if (typeof release !== 'function') return false;
+      state.observerRelease = release;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const disposeNavigationState = (state: NavigationState): void => {
+    if (state.disposed) return;
+    state.disposed = true;
+    const observerRelease = state.observerRelease;
+    state.observerRelease = undefined;
+    try {
+      observerRelease?.();
+    } catch {
+      // Logical observer ownership is already released.
+    }
+    const records = mapValueSnapshot(state.records);
+    for (const record of records) {
+      cancelReconciliation(record);
+      const active = record.activeIntent;
+      const queued = record.queuedIntent;
+      if (active) settle(active, cancelled('navigation_disposed'));
+      if (queued) settle(queued, cancelled('navigation_disposed'));
+      const physical = record.physical;
+      if (physical) retirePhysicalForNavigation(physical);
+      record.physical = undefined;
+      deleteMapValue(registeredSlots, record.view.registeredSlotId);
+      if (record.view.adUnitCode !== undefined) {
+        deleteIndexValue(adUnitCodes, record.view.adUnitCode, record);
+      }
+      for (const alias of record.view.domAliases) deleteIndexValue(domAliases, alias, record);
+      deleteMapValue(state.records, record.view.registeredSlotId);
+    }
+    deleteMapValue(navigationStates, state.owner.generation);
+  };
+
+  const stateForOwner = (owner: NavigationSession): NavigationState | undefined => {
+    if (disposed || !owner.isCurrent()) return undefined;
+    const existing = mapValue(navigationStates, owner.generation);
+    if (existing) return existing.disposed ? undefined : existing;
+    const state: NavigationState = {
+      disposed: false,
+      highWaterAdopted: false,
+      nextOrdinal: 0,
+      observerRelease: undefined,
+      owner,
+      records: new Map(),
+    };
+    let disposerInstalled = false;
+    try {
+      owner.onDispose('slot-records', () => disposeNavigationState(state));
+      disposerInstalled = true;
+      if (reconciliationActive && !installNavigationObserver(state)) {
+        throw new Error('reconciliation observer failed');
+      }
+      if (!owner.isCurrent() || state.disposed) return undefined;
+      setMapValue(navigationStates, owner.generation, state);
+      if (!owner.isCurrent() || state.disposed) {
+        deleteMapValue(navigationStates, owner.generation);
+        return undefined;
+      }
+      return state;
+    } catch (error) {
+      if (disposerInstalled) disposeNavigationState(state);
+      throw error;
+    }
+  };
+
+  const register = (
+    owner: NavigationSession,
+    registrations: readonly SlotRegistration[]
+  ): SlotRegistrationResult => {
+    if (disposed || !owner.isCurrent()) return Object.freeze({ ok: false, reason: 'stale_owner' });
+    if (!Array.isArray(registrations)) {
+      return Object.freeze({ ok: false, reason: 'invalid_slot_id' });
+    }
+    const prepared: Array<{
+      readonly adUnitCode: string | undefined;
+      readonly aliases: readonly string[];
+      readonly directAuctionUnit: Readonly<object> | undefined;
+      readonly id: string;
+      readonly placementKeys: readonly string[];
+      readonly source: SlotSource;
+    }> = [];
+    const ids = new Set<string>();
+    for (const registration of registrations) {
+      if (typeof registration !== 'object' || registration === null) {
+        return Object.freeze({ ok: false, reason: 'invalid_slot_id' });
+      }
+      const id = registration.registeredSlotId;
+      const source = registration.source;
+      const adUnitCode = registration.adUnitCode;
+      const directAuctionUnit = registration.directAuctionUnit;
+      const aliases = frozenAliases(registration.domAliases);
+      if (
+        typeof id !== 'string' ||
+        !validSlotIdentity(id) ||
+        (source !== 'server' && source !== 'programmatic') ||
+        (adUnitCode !== undefined &&
+          (typeof adUnitCode !== 'string' || !validSlotIdentity(adUnitCode))) ||
+        (directAuctionUnit !== undefined &&
+          (source !== 'programmatic' ||
+            typeof directAuctionUnit !== 'object' ||
+            directAuctionUnit === null ||
+            !Object.isFrozen(directAuctionUnit))) ||
+        aliases === undefined
+      ) {
+        return Object.freeze({ ok: false, reason: 'invalid_slot_id' });
+      }
+      if (setHasValue(ids, id) || mapValue(registeredSlots, id)) {
+        return Object.freeze({ ok: false, reason: 'duplicate_slot' });
+      }
+      const registrationPlacementKeys = placementKeysFor(id, adUnitCode, aliases);
+      if (hasPlacementQuarantine(registrationPlacementKeys)) {
+        return Object.freeze({ ok: false, reason: 'slot_quarantined' });
+      }
+      addSetValue(ids, id);
+      prepared[prepared.length] = {
+        adUnitCode,
+        aliases,
+        directAuctionUnit,
+        id,
+        placementKeys: registrationPlacementKeys,
+        source,
+      };
+    }
+
+    let state: NavigationState | undefined;
+    try {
+      state = stateForOwner(owner);
+    } catch {
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+    if (!state) return Object.freeze({ ok: false, reason: 'stale_owner' });
+    if (mapSize(state.records) + prepared.length > MAX_ACTIVE_SLOT_RECORDS) {
+      return Object.freeze({ ok: false, reason: 'registry_capacity' });
+    }
+
+    const inserted: InternalSlotRecord[] = [];
+    try {
+      for (let index = 0; index < prepared.length; index += 1) {
+        const registration = prepared[index];
+        if (!registration || !owner.isCurrent() || state.disposed) throw new Error('stale owner');
+        const ordinal = state.nextOrdinal + index;
+        const view: SlotRecord = Object.freeze({
+          adUnitCode: registration.adUnitCode,
+          ...(registration.directAuctionUnit === undefined
+            ? {}
+            : { directAuctionUnit: registration.directAuctionUnit }),
+          domAliases: registration.aliases,
+          navigationGeneration: owner.generation,
+          ordinal,
+          registeredSlotId: registration.id,
+          source: registration.source,
+        });
+        const record: InternalSlotRecord = {
+          activeIntent: undefined,
+          physical: undefined,
+          queuedIntent: undefined,
+          reconciliation: undefined,
+          reconciliationSuccesses: 0,
+          state,
+          view,
+        };
+        inserted[inserted.length] = record;
+        try {
+          setMapValue(registeredSlots, registration.id, record);
+          if (mapValue(registeredSlots, registration.id) !== record) {
+            throw new Error('slot publication failed');
+          }
+          setMapValue(state.records, registration.id, record);
+          if (mapValue(state.records, registration.id) !== record) {
+            throw new Error('slot publication failed');
+          }
+          if (registration.adUnitCode !== undefined) {
+            setIndexValue(adUnitCodes, registration.adUnitCode, record);
+          }
+          for (const alias of registration.aliases) setIndexValue(domAliases, alias, record);
+        } catch (error) {
+          deleteMapValue(registeredSlots, registration.id);
+          deleteMapValue(state.records, registration.id);
+          if (registration.adUnitCode !== undefined) {
+            deleteIndexValue(adUnitCodes, registration.adUnitCode, record);
+          }
+          for (const alias of registration.aliases) deleteIndexValue(domAliases, alias, record);
+          throw error;
+        }
+      }
+      if (!owner.isCurrent() || state.disposed) throw new Error('stale owner');
+      state.nextOrdinal += prepared.length;
+      return Object.freeze({ ok: true, records: Object.freeze(inserted.map(({ view }) => view)) });
+    } catch {
+      for (let index = inserted.length - 1; index >= 0; index -= 1) {
+        const record = inserted[index];
+        if (!record) continue;
+        deleteMapValue(registeredSlots, record.view.registeredSlotId);
+        deleteMapValue(state.records, record.view.registeredSlotId);
+        if (record.view.adUnitCode !== undefined) {
+          deleteIndexValue(adUnitCodes, record.view.adUnitCode, record);
+        }
+        for (const alias of record.view.domAliases) deleteIndexValue(domAliases, alias, record);
+      }
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+  };
+
+  const adoptGptSlot = (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    binding: GptSlotBinding
+  ): GptSlotAdoptionResult => {
+    const state = mapValue(navigationStates, navigationGeneration);
+    if (!state || state.disposed || !state.owner.isCurrent()) {
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+    const record = mapValue(state.records, registeredSlotId);
+    if (!record) return Object.freeze({ ok: false, reason: 'slot_unresolved' });
+    let slot: unknown;
+    let ownership: unknown;
+    let externalDefinition: unknown;
+    let externalElementIdPrefix: unknown;
+    try {
+      slot = binding.slot;
+      ownership = binding.ownership;
+      externalDefinition = binding.definition;
+      externalElementIdPrefix = binding.elementIdPrefix;
+    } catch {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    if (!state.owner.isCurrent() || state.disposed) {
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+    if ((typeof slot !== 'object' || slot === null) && typeof slot !== 'function') {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    if (ownership !== 'publisher' && ownership !== 'trusted_server') {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    if (
+      externalElementIdPrefix !== undefined &&
+      (typeof externalElementIdPrefix !== 'string' || !validSlotIdentity(externalElementIdPrefix))
+    ) {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    const elementIdPrefix = externalElementIdPrefix as string | undefined;
+    const definition =
+      externalDefinition === undefined
+        ? undefined
+        : snapshotReplacementDefinition(externalDefinition);
+    if (
+      (externalDefinition !== undefined && definition === undefined) ||
+      (ownership === 'trusted_server' && definition === undefined)
+    ) {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    const initialResolution = resolveReconciliationElement(record, definition);
+    const domElement =
+      initialResolution?.status === 'unique' ? initialResolution.element : undefined;
+    const slotObject = slot as object;
+    let bindingPlacementKeys: readonly string[];
+    try {
+      bindingPlacementKeys = placementKeysFor(
+        record.view.registeredSlotId,
+        record.view.adUnitCode,
+        record.view.domAliases,
+        definition
+      );
+    } catch {
+      return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+    }
+    if (hasPlacementQuarantine(bindingPlacementKeys)) {
+      return Object.freeze({ ok: false, reason: 'slot_quarantined' });
+    }
+    const existing = weakMapValue(physicalByObject, slotObject);
+    if (existing) {
+      if (existing.state === 'quarantined') {
+        return Object.freeze({ ok: false, reason: 'slot_quarantined' });
+      }
+      if (existing.state === 'retired') {
+        return Object.freeze({ ok: false, reason: 'gpt_request_failed' });
+      }
+      if (existing.record && existing.record !== record) {
+        return Object.freeze({ ok: false, reason: 'gpt_object_collision' });
+      }
+      if (record.physical && record.physical !== existing) {
+        return Object.freeze({ ok: false, reason: 'gpt_object_collision' });
+      }
+      const wasStrong = setHasValue(physicalSlots, existing);
+      const previousRecord = existing.record;
+      const previousOwnership = existing.ownership;
+      const previousDefinition = existing.definition;
+      const previousDomElement = existing.domElement;
+      const previousElementIdPrefix = existing.elementIdPrefix;
+      const previousBindingEpoch = existing.bindingEpoch;
+      const previousPlacementKeys = existing.placementKeys;
+      const previousPublisherElementIds = existing.publisherElementIds;
+      const previousView = record.view;
+      const traceToken = traceTokenFor(slotObject);
+      try {
+        if (!wasStrong) addSetValue(physicalSlots, existing);
+        if (!setHasValue(physicalSlots, existing)) throw new Error('physical publication failed');
+        if (!state.owner.isCurrent() || state.disposed) throw new Error('stale owner');
+        existing.record = record;
+        existing.ownership = ownership;
+        existing.definition = definition;
+        existing.domElement = domElement;
+        existing.elementIdPrefix = elementIdPrefix;
+        existing.bindingEpoch = Object.freeze({});
+        existing.placementKeys = bindingPlacementKeys;
+        existing.publisherElementIds =
+          ownership === 'publisher' && definition
+            ? Object.freeze([definition.elementId])
+            : Object.freeze([]);
+        record.physical = existing;
+        record.view = recordWithTraceToken(record.view, traceToken);
+        if (ownership === 'publisher') cancelReconciliation(record);
+        return Object.freeze({ ok: true });
+      } catch {
+        if (record.physical === existing) record.physical = undefined;
+        existing.record = previousRecord;
+        existing.ownership = previousOwnership;
+        existing.definition = previousDefinition;
+        existing.domElement = previousDomElement;
+        existing.elementIdPrefix = previousElementIdPrefix;
+        existing.bindingEpoch = previousBindingEpoch;
+        existing.placementKeys = previousPlacementKeys;
+        existing.publisherElementIds = previousPublisherElementIds;
+        record.view = previousView;
+        if (!wasStrong) deleteSetValue(physicalSlots, existing);
+        return Object.freeze({ ok: false, reason: 'stale_owner' });
+      }
+    }
+    if (record.physical && record.physical.slot !== slotObject) {
+      return Object.freeze({ ok: false, reason: 'gpt_object_collision' });
+    }
+    const physical: PhysicalSlot = {
+      activeCycle: undefined,
+      apsMountClaim: undefined,
+      committedArtifact: undefined,
+      bindingEpoch: Object.freeze({}),
+      definition,
+      domElement,
+      elementIdPrefix,
+      destroyAttempted: false,
+      lastResponseIdentifier: undefined,
+      lastCycle: undefined,
+      ownership,
+      placementKeys: bindingPlacementKeys,
+      publisherAdmissions: [],
+      publisherElementIds:
+        ownership === 'publisher' && definition
+          ? Object.freeze([definition.elementId])
+          : Object.freeze([]),
+      quarantineReason: undefined,
+      record,
+      saturationOwner: false,
+      slot: slotObject,
+      state: 'live',
+      suppressPublisherDisplay: false,
+      suppressPublisherRefresh: false,
+    };
+    const previousView = record.view;
+    const traceToken = traceTokenFor(slotObject);
+    try {
+      setWeakMapValue(physicalByObject, slotObject, physical);
+      addSetValue(physicalSlots, physical);
+      if (!state.owner.isCurrent() || state.disposed) throw new Error('stale owner');
+      record.physical = physical;
+      record.view = recordWithTraceToken(record.view, traceToken);
+      return Object.freeze({ ok: true });
+    } catch {
+      record.view = previousView;
+      deleteSetValue(physicalSlots, physical);
+      if (weakMapValue(physicalByObject, slotObject) === physical) {
+        deleteWeakMapValue(physicalByObject, slotObject);
+      }
+      return Object.freeze({ ok: false, reason: 'stale_owner' });
+    }
+  };
+
+  const adoptRegistrationHighWater = (
+    navigationGeneration: object,
+    nextOrdinal: number
+  ): boolean => {
+    const state = mapValue(navigationStates, navigationGeneration);
+    if (
+      !state ||
+      state.disposed ||
+      state.highWaterAdopted ||
+      !state.owner.isCurrent() ||
+      !Number.isInteger(nextOrdinal) ||
+      nextOrdinal < state.nextOrdinal ||
+      nextOrdinal > 4_294_967_295
+    ) {
+      return false;
+    }
+    state.nextOrdinal = nextOrdinal;
+    state.highWaterAdopted = true;
+    return true;
+  };
+
+  const request = (input: SlotRequestInput): SlotRequestHandle => {
+    const state = mapValue(navigationStates, input.navigationGeneration);
+    const record = state ? mapValue(state.records, input.registeredSlotId) : undefined;
+    let resolve!: (outcome: SlotRequestOutcome) => void;
+    const result = new Promise<SlotRequestOutcome>((resolveResult) => {
+      resolve = resolveResult;
+    });
+    const placeholderRecord =
+      record ??
+      ({
+        activeIntent: undefined,
+        queuedIntent: undefined,
+        reconciliation: undefined,
+        reconciliationSuccesses: 0,
+      } as InternalSlotRecord);
+    const trustedServerOpportunity = snapshotTrustedServerOpportunity(
+      input.trustedServerOpportunity
+    );
+    const intentInput: SlotRequestInput =
+      trustedServerOpportunity === input.trustedServerOpportunity
+        ? input
+        : Object.freeze({
+            ...input,
+            ...(trustedServerOpportunity === undefined ? {} : { trustedServerOpportunity }),
+          });
+    const intent: RequestIntent = {
+      completionTimer: undefined,
+      completionDeadlineAt: undefined,
+      input: intentInput,
+      invocation: undefined,
+      requestDeadlineAt: undefined,
+      requestStartedAt: undefined,
+      requestTimer: undefined,
+      resolve,
+      result,
+      record: placeholderRecord,
+      state: 'terminal',
+      terminal: false,
+    };
+    const handle = Object.freeze({
+      get status(): 'active' | 'queued' | 'terminal' {
+        return intent.state === 'cycle' ? 'active' : intent.state;
+      },
+      result,
+      dispose: (): void => cancelIntent(intent),
+    });
+    if (!state || state.disposed || !state.owner.isCurrent() || !record) {
+      settle(intent, failed('slot_unresolved'));
+      return handle;
+    }
+    intent.record = record;
+    const physical = record.physical;
+    if (!physical) {
+      settle(intent, failed('slot_unresolved'));
+      return handle;
+    }
+    if (input.expectedSlot !== undefined && input.expectedSlot !== physical.slot) {
+      settle(intent, failed('slot_unresolved'));
+      return handle;
+    }
+    if (physical.state === 'retired' || physical.quarantineReason === 'request') {
+      settle(intent, failed('gpt_request_failed'));
+      return handle;
+    }
+    if (physical.publisherAdmissions.length > 0) {
+      settle(intent, failed('cycle_unattributable'));
+      return handle;
+    }
+    if (physical.state === 'quarantined') {
+      settle(
+        intent,
+        failed(
+          physical.activeCycle?.kind === 'trusted_server' && physical.state === 'quarantined'
+            ? 'slot_quarantined'
+            : physical.activeCycle
+              ? 'cycle_unattributable'
+              : 'slot_quarantined'
+        )
+      );
+      return handle;
+    }
+    if (record.activeIntent) {
+      if (
+        physical.activeCycle &&
+        (physical.activeCycle.kind !== 'trusted_server' ||
+          physical.activeCycle.intent !== record.activeIntent)
+      ) {
+        const active = record.activeIntent;
+        settle(active, failed('cycle_unattributable'));
+        if (record.queuedIntent) {
+          settle(record.queuedIntent, failed('cycle_unattributable'));
+        }
+        settle(intent, failed('cycle_unattributable'));
+        return handle;
+      }
+      if (record.activeIntent.input.requestClass !== input.requestClass) {
+        const active = record.activeIntent;
+        const activePhysical = record.physical;
+        const hadStarted = active.requestStartedAt !== undefined;
+        if (activePhysical?.activeCycle?.intent === active) {
+          activePhysical.activeCycle.intent = undefined;
+          activePhysical.state = 'quarantined';
+          activePhysical.quarantineReason = 'completion';
+        }
+        settle(active, failed('cycle_unattributable'));
+        if (record.queuedIntent) {
+          settle(record.queuedIntent, failed('cycle_unattributable'));
+        }
+        settle(intent, failed('cycle_unattributable'));
+        if (hadStarted && activePhysical && !activePhysical.activeCycle) {
+          recoverRequestTimeout(record, activePhysical);
+        }
+        return handle;
+      }
+      intent.state = 'queued';
+      const queued = record.queuedIntent;
+      if (queued) {
+        if (queued.input.requestClass !== input.requestClass) {
+          settle(queued, failed('cycle_unattributable'));
+          settle(intent, failed('cycle_unattributable'));
+          return handle;
+        }
+        settle(queued, cancelled('superseded'));
+      }
+      record.queuedIntent = intent;
+      return handle;
+    }
+    if (physical.activeCycle) {
+      settle(intent, failed('cycle_unattributable'));
+      return handle;
+    }
+    record.activeIntent = intent;
+    intent.state = 'active';
+    if (!deferInvocations) invokeIntent(record, intent);
+    return handle;
+  };
+
+  const requestBatch = (inputs: readonly SlotBatchRequestInput[]): readonly SlotRequestHandle[] => {
+    let inputCount: number;
+    try {
+      if (!Array.isArray(inputs)) return Object.freeze([]);
+      inputCount = inputs.length;
+    } catch {
+      return Object.freeze([]);
+    }
+    if (inputCount === 0 || inputCount > MAX_ACTIVE_SLOT_RECORDS) {
+      return Object.freeze([]);
+    }
+    const preparedInputs: SlotBatchRequestInput[] = [];
+    const admittedIntents = new Set<string>();
+    const admittedRecords = new Set<InternalSlotRecord>();
+    const admittedPhysicalSlots = new Set<object>();
+    let batchGeneration: object | undefined;
+    try {
+      for (let index = 0; index < inputCount; index += 1) {
+        const input = inputs[index] as unknown;
+        if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+          return Object.freeze([]);
+        }
+        const intentId = ownData(input, 'intentId');
+        const expectedSlot = ownData(input, 'expectedSlot');
+        const navigationGeneration = ownData(input, 'navigationGeneration');
+        const operation = ownData(input, 'operation');
+        const registeredSlotId = ownData(input, 'registeredSlotId');
+        const requestClass = ownData(input, 'requestClass');
+        const trustedServerOpportunity = snapshotTrustedServerOpportunity(
+          ownData(input, 'trustedServerOpportunity')
+        );
+        if (
+          typeof intentId !== 'string' ||
+          intentId.length === 0 ||
+          typeof navigationGeneration !== 'object' ||
+          navigationGeneration === null ||
+          (operation !== 'display' && operation !== 'refresh') ||
+          typeof registeredSlotId !== 'string' ||
+          registeredSlotId.length === 0 ||
+          typeof requestClass !== 'string' ||
+          requestClass.length === 0 ||
+          setHasValue(admittedIntents, intentId)
+        ) {
+          return Object.freeze([]);
+        }
+        if (batchGeneration === undefined) batchGeneration = navigationGeneration;
+        else if (batchGeneration !== navigationGeneration) return Object.freeze([]);
+        const state = mapValue(navigationStates, navigationGeneration);
+        const record = state ? mapValue(state.records, registeredSlotId) : undefined;
+        const physical = record?.physical;
+        if (
+          !state ||
+          state.disposed ||
+          !state.owner.isCurrent() ||
+          !record ||
+          record.activeIntent ||
+          record.queuedIntent ||
+          !physical ||
+          physical.record !== record ||
+          physical.state !== 'live' ||
+          physical.activeCycle ||
+          physical.publisherAdmissions.length > 0 ||
+          (expectedSlot !== undefined && expectedSlot !== physical.slot) ||
+          setHasValue(admittedRecords, record) ||
+          setHasValue(admittedPhysicalSlots, physical.slot)
+        ) {
+          return Object.freeze([]);
+        }
+        addSetValue(admittedIntents, intentId);
+        addSetValue(admittedRecords, record);
+        addSetValue(admittedPhysicalSlots, physical.slot);
+        preparedInputs[preparedInputs.length] = Object.freeze({
+          ...(expectedSlot === undefined ? {} : { expectedSlot }),
+          intentId,
+          navigationGeneration,
+          operation,
+          registeredSlotId,
+          requestClass,
+          ...(trustedServerOpportunity === undefined ? {} : { trustedServerOpportunity }),
+        });
+      }
+    } catch {
+      return Object.freeze([]);
+    }
+    deferInvocations = true;
+    const handles: SlotRequestHandle[] = [];
+    let admissionFailed = false;
+    try {
+      for (let index = 0; index < preparedInputs.length; index += 1) {
+        const input = preparedInputs[index];
+        if (!input) throw new Error('missing prepared SRA input');
+        handles[handles.length] = request(input);
+      }
+    } catch {
+      admissionFailed = true;
+      for (let index = handles.length - 1; index >= 0; index -= 1) {
+        try {
+          handles[index]?.dispose();
+        } catch {
+          // Continue rolling back later admissions after one hostile owner callback.
+        }
+      }
+    } finally {
+      deferInvocations = false;
+    }
+    if (admissionFailed) return Object.freeze([]);
+    const intents: RequestIntent[] = [];
+    for (let index = 0; index < preparedInputs.length; index += 1) {
+      const input = preparedInputs[index];
+      if (!input) continue;
+      const state = mapValue(navigationStates, input.navigationGeneration);
+      const record = state ? mapValue(state.records, input.registeredSlotId) : undefined;
+      const intent = record?.activeIntent;
+      if (intent && intent.input === input && intent.state === 'active')
+        intents[intents.length] = intent;
+    }
+    if (intents.length > 0) {
+      const slots: object[] = [];
+      for (let index = 0; index < intents.length; index += 1) {
+        const intent = intents[index];
+        if (!intent) continue;
+        const physical = intent.record.physical;
+        if (!physical || physical.state !== 'live' || physical.activeCycle) {
+          settle(intent, failed('slot_unresolved'));
+          continue;
+        }
+        slots[slots.length] = physical.slot;
+      }
+      if (slots.length === intents.length) {
+        const allIntentsAdmitted = (): boolean => {
+          for (let index = 0; index < intents.length; index += 1) {
+            const intent = intents[index];
+            const expectedSlot = slots[index];
+            if (!intent || intent.terminal || intent.record.activeIntent !== intent) return false;
+            const state = intent.record.state;
+            if (state.disposed || !state.owner.isCurrent()) return false;
+            const physical = intent.record.physical;
+            if (
+              !physical ||
+              physical.state !== 'live' ||
+              physical.activeCycle ||
+              physical.slot !== expectedSlot
+            ) {
+              return false;
+            }
+          }
+          return true;
+        };
+        const failInvalidAdmission = (): void => {
+          for (let index = 0; index < intents.length; index += 1) {
+            const intent = intents[index];
+            if (!intent || intent.terminal) continue;
+            const state = intent.record.state;
+            settle(
+              intent,
+              state.disposed || !state.owner.isCurrent()
+                ? cancelled('navigation_disposed')
+                : failed('gpt_request_failed')
+            );
+          }
+        };
+        let subscriptionOperation: GoogletagOperation<BindingSubscriptionAdmission>;
+        let provisionalSubscriptions: BindingSubscriptionAdmission | undefined;
+        try {
+          subscriptionOperation = options.googletag.run((gpt) => {
+            provisionalSubscriptions = ensureBindingSubscriptions(gpt);
+            return provisionalSubscriptions;
+          });
+          void subscriptionOperation.result.then(
+            (subscriptions) => {
+              retireHistoricalSubscriptions(subscriptions.ownership);
+              if (!allIntentsAdmitted()) {
+                failInvalidAdmission();
+                return;
+              }
+              let operation: GoogletagOperation<unknown>;
+              try {
+                operation = options.googletag.run((gpt) => {
+                  if (gpt.bindingToken() !== subscriptions.ownership.token) {
+                    throw new Error('GPT binding changed before SRA invocation');
+                  }
+                  if (!allIntentsAdmitted()) {
+                    throw new Error('SRA admission changed before invocation');
+                  }
+                  const serviceState = gpt.serviceState();
+                  if (!serviceState.pubadsReady) gpt.enableServices();
+                  const publishRequest = (intent: RequestIntent): void => {
+                    const physical = intent.record.physical;
+                    if (!physical || intent.terminal) return;
+                    try {
+                      options.onTrustedServerRequest?.(
+                        Object.freeze({
+                          ...(intent.input.trustedServerOpportunity === undefined
+                            ? {}
+                            : { opportunity: intent.input.trustedServerOpportunity }),
+                          registeredSlotId: intent.record.view.registeredSlotId,
+                          slot: physical.slot,
+                        })
+                      );
+                    } catch {
+                      // Diagnostics request publication cannot alter the admitted GPT batch.
+                    }
+                  };
+                  if (serviceState.initialLoadDisabled) {
+                    for (let index = 0; index < intents.length; index += 1) {
+                      const intent = intents[index];
+                      const physical = intent?.record.physical;
+                      if (
+                        !intent ||
+                        intent.terminal ||
+                        intent.input.operation !== 'display' ||
+                        !physical
+                      ) {
+                        continue;
+                      }
+                      gpt.display(physical.slot);
+                    }
+                  }
+                  const refreshSlots: object[] = [];
+                  for (let index = 0; index < intents.length; index += 1) {
+                    const intent = intents[index];
+                    const physical = intent?.record.physical;
+                    if (!intent || intent.terminal || !physical || physical.activeCycle) continue;
+                    publishRequest(intent);
+                    armRequestDeadline(intent);
+                    if (serviceState.initialLoadDisabled || intent.input.operation === 'refresh') {
+                      refreshSlots[refreshSlots.length] = physical.slot;
+                    }
+                  }
+                  if (!serviceState.initialLoadDisabled) {
+                    for (let index = 0; index < intents.length; index += 1) {
+                      const intent = intents[index];
+                      const physical = intent?.record.physical;
+                      if (
+                        !intent ||
+                        intent.terminal ||
+                        intent.input.operation !== 'display' ||
+                        !physical ||
+                        physical.activeCycle
+                      ) {
+                        continue;
+                      }
+                      gpt.display(physical.slot);
+                    }
+                  }
+                  if (refreshSlots.length > 0) {
+                    gpt.refresh(refreshSlots, Object.freeze({ changeCorrelator: false }));
+                  }
+                });
+              } catch (error) {
+                for (let index = 0; index < intents.length; index += 1) {
+                  const intent = intents[index];
+                  if (intent) failExternalInvocation(intent.record, intent, error);
+                }
+                return;
+              }
+              const liveIntents: RequestIntent[] = [];
+              for (let index = 0; index < intents.length; index += 1) {
+                const intent = intents[index];
+                if (!intent) continue;
+                if (!intent.terminal) liveIntents[liveIntents.length] = intent;
+              }
+              let remaining = liveIntents.length;
+              for (let index = 0; index < liveIntents.length; index += 1) {
+                const intent = liveIntents[index];
+                if (!intent) continue;
+                let released = false;
+                intent.invocation = {
+                  dispose: (): void => {
+                    if (released) return;
+                    released = true;
+                    remaining -= 1;
+                    if (remaining === 0) operation.dispose();
+                  },
+                };
+              }
+              if (remaining === 0) operation.dispose();
+              void operation.result.then(
+                () => undefined,
+                (error: unknown) => {
+                  for (let index = 0; index < intents.length; index += 1) {
+                    const intent = intents[index];
+                    if (intent) failExternalInvocation(intent.record, intent, error);
+                  }
+                }
+              );
+            },
+            (error: unknown) => {
+              if (provisionalSubscriptions?.installed) provisionalSubscriptions.ownership.release();
+              for (let index = 0; index < intents.length; index += 1) {
+                const intent = intents[index];
+                if (intent) failExternalInvocation(intent.record, intent, error);
+              }
+            }
+          );
+        } catch (error) {
+          if (provisionalSubscriptions?.installed) provisionalSubscriptions.ownership.release();
+          for (let index = 0; index < intents.length; index += 1) {
+            const intent = intents[index];
+            if (intent) failExternalInvocation(intent.record, intent, error);
+          }
+        }
+      }
+    }
+    return Object.freeze(handles);
+  };
+
+  const recordPublisherDestruction = (slot: object): boolean => {
+    const physical = weakMapValue(physicalByObject, slot);
+    if (!physical) return false;
+    const record = physical.record;
+    if (record) cancelReconciliation(record);
+    const cycleIntent = physical.activeCycle?.intent;
+    if (cycleIntent && !cycleIntent.terminal) settle(cycleIntent, failed('gpt_request_failed'));
+    if (record?.activeIntent) settle(record.activeIntent, failed('gpt_request_failed'));
+    if (record?.queuedIntent) settle(record.queuedIntent, failed('gpt_request_failed'));
+    if (record) retireCommittedArtifact(record, physical);
+    if (record?.physical === physical) record.physical = undefined;
+    physical.record = undefined;
+    retirePhysicalTraceCycles(physical);
+    clearPhysicalCycle(physical);
+    invalidatePublisherAdmissions(physical);
+    physical.publisherElementIds = Object.freeze([]);
+    physical.suppressPublisherDisplay = false;
+    physical.suppressPublisherRefresh = false;
+    physical.state = 'retired';
+    releasePhysicalPlacement(physical);
+    deleteSetValue(physicalSlots, physical);
+    if (weakMapValue(physicalByObject, slot) === physical) {
+      deleteWeakMapValue(physicalByObject, slot);
+    }
+    return true;
+  };
+
+  const publisherAdmissionIndex = (state: PublisherIntentAdmissionState): number => {
+    const admissions = state.physical.publisherAdmissions;
+    for (let index = 0; index < admissions.length; index += 1) {
+      if (admissions[index] === state) return index;
+    }
+    return -1;
+  };
+
+  const invalidatePublisherAdmissions = (physical: PhysicalSlot): void => {
+    for (let index = 0; index < physical.publisherAdmissions.length; index += 1) {
+      const admission = physical.publisherAdmissions[index];
+      if (!admission) continue;
+      admission.enqueued = false;
+      if (admission.phase === 'pending' || admission.phase === 'committed') {
+        admission.phase = 'rolled_back';
+      }
+    }
+    physical.publisherAdmissions.length = 0;
+  };
+
+  const removePublisherAdmission = (state: PublisherIntentAdmissionState): boolean => {
+    if (!state.enqueued) return false;
+    const physical = state.physical;
+    const admissions = physical.publisherAdmissions;
+    const admissionIndex = publisherAdmissionIndex(state);
+    state.enqueued = false;
+    if (admissionIndex < 0) return false;
+    for (let index = admissionIndex; index < admissions.length - 1; index += 1) {
+      const next = admissions[index + 1];
+      if (next) admissions[index] = next;
+    }
+    admissions.length -= 1;
+    return true;
+  };
+
+  const publisherAdmissionIsCurrent = (state: PublisherIntentAdmissionState): boolean => {
+    const physical = state.physical;
+    if (
+      !state.enqueued ||
+      publisherAdmissionIndex(state) < 0 ||
+      weakMapValue(physicalByObject, physical.slot) !== physical ||
+      physical.record !== state.record ||
+      (physical.state !== 'live' && !physical.activeCycle)
+    ) {
+      return false;
+    }
+    const record = state.record;
+    return (
+      !record ||
+      (!record.state.disposed &&
+        record.state.owner.isCurrent() &&
+        record.state.owner.generation === state.generation)
+    );
+  };
+
+  const failPublisherIntentOverflow = (physical: PhysicalSlot): void => {
+    if (physical.state === 'retired') return;
+    physical.state = 'quarantined';
+    physical.quarantineReason = 'request';
+    quarantinePhysicalPlacement(physical);
+    if (physical.record?.activeIntent) {
+      settle(physical.record.activeIntent, failed('cycle_unattributable'));
+    }
+    if (physical.record?.queuedIntent) {
+      settle(physical.record.queuedIntent, failed('cycle_unattributable'));
+    }
+  };
+
+  const applyPublisherIntent = (physical: PhysicalSlot): void => {
+    if (physical.record) retireCommittedArtifact(physical.record, physical);
+    if (physical.record?.activeIntent) {
+      settle(physical.record.activeIntent, failed('cycle_unattributable'));
+    }
+    if (physical.record?.queuedIntent) {
+      settle(physical.record.queuedIntent, failed('cycle_unattributable'));
+    }
+    if (physical.activeCycle?.kind === 'trusted_server') {
+      physical.activeCycle.intent = undefined;
+      physical.activeCycle.kind = 'publisher';
+      physical.state = 'quarantined';
+      physical.quarantineReason = 'completion';
+    }
+  };
+
+  const rollbackPublisherAdmission = (state: PublisherIntentAdmissionState): void => {
+    if (state.phase !== 'pending') return;
+    removePublisherAdmission(state);
+    state.phase = 'rolled_back';
+  };
+
+  const commitPublisherAdmission = (state: PublisherIntentAdmissionState): boolean => {
+    if (state.phase === 'committed' || state.phase === 'consumed') return true;
+    if (state.phase !== 'pending') return false;
+    if (!publisherAdmissionIsCurrent(state)) {
+      rollbackPublisherAdmission(state);
+      return false;
+    }
+    const physical = state.physical;
+    if (physical.publisherAdmissions.length > MAX_PENDING_PUBLISHER_INTENTS) {
+      removePublisherAdmission(state);
+      state.phase = 'rolled_back';
+      failPublisherIntentOverflow(physical);
+      return false;
+    }
+    state.phase = 'committed';
+    applyPublisherIntent(physical);
+    return true;
+  };
+
+  const preparePublisherIntent = (
+    slot: object
+  ):
+    | Readonly<{
+        readonly admission: GoogletagPublisherCallAdmission;
+        readonly commit: () => boolean;
+      }>
+    | undefined => {
+    const physical = weakMapValue(physicalByObject, slot);
+    if (
+      !physical ||
+      (physical.state !== 'live' && !physical.activeCycle) ||
+      physical.publisherAdmissions.length > MAX_PENDING_PUBLISHER_INTENTS
+    ) {
+      return undefined;
+    }
+    const record = physical.record;
+    const state: PublisherIntentAdmissionState = {
+      enqueued: true,
+      generation: record?.state.owner.generation,
+      phase: 'pending',
+      physical,
+      record,
+    };
+    physical.publisherAdmissions[physical.publisherAdmissions.length] = state;
+    const admission: GoogletagPublisherCallAdmission = Object.freeze({
+      commit: (): void => {
+        commitPublisherAdmission(state);
+      },
+      rollback: (): void => {
+        rollbackPublisherAdmission(state);
+      },
+    });
+    return Object.freeze({ admission, commit: () => commitPublisherAdmission(state) });
+  };
+
+  const compositePublisherAdmission = (
+    admissions: readonly GoogletagPublisherCallAdmission[]
+  ): GoogletagPublisherCallAdmission | undefined => {
+    if (admissions.length === 0) return undefined;
+    return Object.freeze({
+      commit: (): void => {
+        for (let index = 0; index < admissions.length; index += 1) {
+          admissions[index]?.commit();
+        }
+      },
+      rollback: (): void => {
+        for (let index = admissions.length - 1; index >= 0; index -= 1) {
+          admissions[index]?.rollback();
+        }
+      },
+    });
+  };
+
+  const recordPublisherIntent = (slot: object): boolean => {
+    const prepared = preparePublisherIntent(slot);
+    if (!prepared) return false;
+    return prepared.commit();
+  };
+
+  const publisherPhysicalForTarget = (target: unknown): PhysicalSlot | undefined => {
+    if ((typeof target === 'object' && target !== null) || typeof target === 'function') {
+      const exact = weakMapValue(physicalByObject, target as object);
+      return exact?.ownership === 'publisher' && exact.state === 'live' ? exact : undefined;
+    }
+    if (typeof target !== 'string') return undefined;
+    let match: PhysicalSlot | undefined;
+    for (const candidate of setValueSnapshot(physicalSlots)) {
+      if (candidate.ownership !== 'publisher' || candidate.state !== 'live') continue;
+      let matches = false;
+      for (let index = 0; index < candidate.publisherElementIds.length; index += 1) {
+        if (candidate.publisherElementIds[index] === target) {
+          matches = true;
+          break;
+        }
+      }
+      if (!matches) continue;
+      if (match && match !== candidate) return undefined;
+      match = candidate;
+    }
+    return match;
+  };
+
+  const claimPublisherGptSlot = (
+    call: GoogletagPublisherDefineSlotCall
+  ): Readonly<{ action: 'forward' }> | Readonly<{ action: 'handoff'; slot: object }> => {
+    let elementId: unknown;
+    let adUnitPath: unknown;
+    let sizes: unknown;
+    let initialLoadDisabled: unknown;
+    try {
+      elementId = call.elementId;
+      adUnitPath = call.adUnitPath;
+      sizes = call.sizes;
+      initialLoadDisabled = call.initialLoadDisabled;
+    } catch {
+      return Object.freeze({ action: 'forward' });
+    }
+    if (typeof elementId !== 'string' || !validSlotIdentity(elementId)) {
+      return Object.freeze({ action: 'forward' });
+    }
+    const exact: PhysicalSlot[] = [];
+    const hydration: PhysicalSlot[] = [];
+    for (const physical of setValueSnapshot(physicalSlots)) {
+      const record = physical.record;
+      const definition = physical.definition;
+      if (
+        physical.ownership !== 'trusted_server' ||
+        physical.state !== 'live' ||
+        !record ||
+        !record.state.owner.isCurrent() ||
+        !definition
+      ) {
+        continue;
+      }
+      if (definition.elementId === elementId) {
+        exact[exact.length] = physical;
+        continue;
+      }
+      if (
+        physical.elementIdPrefix &&
+        elementId.startsWith(physical.elementIdPrefix) &&
+        !reconciliationElementConnected(physical.domElement) &&
+        adUnitPath === definition.adUnitPath &&
+        replacementSizesEqual(sizes, definition.sizes)
+      ) {
+        hydration[hydration.length] = physical;
+      }
+    }
+    const matches = exact.length > 0 ? exact : hydration;
+    if (matches.length !== 1) return Object.freeze({ action: 'forward' });
+    const physical = matches[0];
+    const record = physical?.record;
+    if (!physical || !record || !record.state.owner.isCurrent()) {
+      return Object.freeze({ action: 'forward' });
+    }
+    if (exact.length === 1) {
+      const definition = physical.definition;
+      const formatsMismatch =
+        definition !== undefined && !replacementSizesEqual(sizes, definition.sizes);
+      const pathMismatch = definition !== undefined && adUnitPath !== definition.adUnitPath;
+      if (formatsMismatch || pathMismatch) {
+        try {
+          options.warnPublisherHandoffMismatch?.(
+            'GPT publisher handoff metadata mismatch',
+            Object.freeze({ formatsMismatch, pathMismatch })
+          );
+        } catch {
+          // Diagnostics cannot block an exact publisher ownership handoff.
+        }
+      }
+    }
+    const definitionElementId = physical.definition?.elementId;
+    const aliases =
+      definitionElementId === undefined || definitionElementId === elementId
+        ? Object.freeze([elementId])
+        : Object.freeze([definitionElementId, elementId]);
+    cancelReconciliation(record);
+    if (
+      physical.record !== record ||
+      record.physical !== physical ||
+      physical.state !== 'live' ||
+      !record.state.owner.isCurrent()
+    ) {
+      return Object.freeze({ action: 'forward' });
+    }
+    physical.ownership = 'publisher';
+    physical.publisherElementIds = aliases;
+    physical.bindingEpoch = Object.freeze({});
+    physical.suppressPublisherDisplay = true;
+    physical.suppressPublisherRefresh = initialLoadDisabled === true;
+    return Object.freeze({ action: 'handoff', slot: physical.slot });
+  };
+
+  const preparePublisherDisplay = (
+    call: GoogletagPublisherDisplayCall
+  ):
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{ action: 'suppress' }> => {
+    let target: unknown;
+    let initialLoadDisabled: unknown;
+    try {
+      target = call.target;
+      initialLoadDisabled = call.initialLoadDisabled;
+    } catch {
+      return Object.freeze({ action: 'forward' });
+    }
+    const physical = publisherPhysicalForTarget(target);
+    if (!physical) return Object.freeze({ action: 'forward' });
+    if (physical.suppressPublisherDisplay) {
+      physical.suppressPublisherDisplay = false;
+      return Object.freeze({ action: 'suppress' });
+    }
+    const prepared =
+      initialLoadDisabled === true ? undefined : preparePublisherIntent(physical.slot);
+    return prepared
+      ? Object.freeze({ action: 'forward', admission: prepared.admission })
+      : Object.freeze({ action: 'forward' });
+  };
+
+  const preparePublisherRefresh = (
+    call: GoogletagPublisherRefreshCall
+  ):
+    | Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>
+    | Readonly<{
+        action: 'replace';
+        slots: readonly object[];
+        admission?: GoogletagPublisherCallAdmission;
+      }>
+    | Readonly<{ action: 'suppress' }> => {
+    let slots: readonly object[];
+    try {
+      slots = call.slots;
+    } catch {
+      return Object.freeze({ action: 'forward' });
+    }
+    if (!Array.isArray(slots)) return Object.freeze({ action: 'forward' });
+    let suppressed = false;
+    const forwarded: object[] = [];
+    const admissions: GoogletagPublisherCallAdmission[] = [];
+    for (let index = 0; index < slots.length; index += 1) {
+      const slot = slots[index];
+      if (!slot) continue;
+      const physical = weakMapValue(physicalByObject, slot);
+      if (physical?.ownership === 'publisher' && physical.suppressPublisherRefresh) {
+        physical.suppressPublisherRefresh = false;
+        suppressed = true;
+        continue;
+      }
+      forwarded[forwarded.length] = slot;
+      if (physical?.ownership === 'publisher') {
+        const prepared = preparePublisherIntent(slot);
+        if (prepared) admissions[admissions.length] = prepared.admission;
+      }
+    }
+    const admission = compositePublisherAdmission(admissions);
+    if (!suppressed) {
+      return admission
+        ? Object.freeze({ action: 'forward', admission })
+        : Object.freeze({ action: 'forward' });
+    }
+    if (forwarded.length === 0) return Object.freeze({ action: 'suppress' });
+    return admission
+      ? Object.freeze({ action: 'replace', admission, slots: Object.freeze(forwarded) })
+      : Object.freeze({ action: 'replace', slots: Object.freeze(forwarded) });
+  };
+
+  const deactivateReconciliation = (): void => {
+    if (!reconciliationActive) return;
+    reconciliationActive = false;
+    const states = mapValueSnapshot(navigationStates);
+    for (let stateIndex = 0; stateIndex < states.length; stateIndex += 1) {
+      const state = states[stateIndex];
+      if (!state) continue;
+      const observerRelease = state.observerRelease;
+      state.observerRelease = undefined;
+      try {
+        observerRelease?.();
+      } catch {
+        // Logical observer ownership is already released.
+      }
+      const records = mapValueSnapshot(state.records);
+      for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+        const record = records[recordIndex];
+        if (record) cancelReconciliation(record);
+      }
+    }
+  };
+
+  const activateReconciliation = (): (() => void) => {
+    if (disposed || reconciliationActive) {
+      throw new Error('reconciliation owner is unavailable');
+    }
+    const states = mapValueSnapshot(navigationStates);
+    const installed: NavigationState[] = [];
+    for (let index = 0; index < states.length; index += 1) {
+      const state = states[index];
+      if (!state || !installNavigationObserver(state)) {
+        for (let releaseIndex = installed.length - 1; releaseIndex >= 0; releaseIndex -= 1) {
+          const installedState = installed[releaseIndex];
+          const release = installedState?.observerRelease;
+          if (installedState) installedState.observerRelease = undefined;
+          try {
+            release?.();
+          } catch {
+            // Failed activation retains no observer ownership.
+          }
+        }
+        throw new Error('reconciliation observer failed');
+      }
+      if (state.observerRelease) installed[installed.length] = state;
+    }
+    reconciliationActive = true;
+    let active = true;
+    return (): void => {
+      if (!active) return;
+      active = false;
+      deactivateReconciliation();
+    };
+  };
+
+  const resolveApsMountBinding = (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    intentId: string
+  ): Readonly<ApsSlotMountBinding> | undefined => {
+    try {
+      const state = mapValue(navigationStates, navigationGeneration);
+      const record = state ? mapValue(state.records, registeredSlotId) : undefined;
+      const physical = record?.physical;
+      const cycle = physical?.lastCycle;
+      const intent = cycle?.intent;
+      if (
+        !state ||
+        state.disposed ||
+        !state.owner.isCurrent() ||
+        !record ||
+        !physical ||
+        physical.record !== record ||
+        physical.state !== 'live' ||
+        !cycle ||
+        cycle.kind !== 'trusted_server' ||
+        cycle.traceRetirement.retired ||
+        !intent ||
+        intent.input.intentId !== intentId ||
+        intent.input.registeredSlotId !== registeredSlotId ||
+        intent.input.navigationGeneration !== navigationGeneration ||
+        intent.input.expectedSlot !== physical.slot ||
+        !intent.terminal ||
+        !reconciliationBoundary ||
+        !reconciliationResolve ||
+        !reconciliationIsConnected
+      ) {
+        return undefined;
+      }
+
+      const ids: string[] = [];
+      const addId = (value: string | undefined): void => {
+        if (!value) return;
+        for (let index = 0; index < ids.length; index += 1) {
+          if (ids[index] === value) return;
+        }
+        ids[ids.length] = value;
+      };
+      addId(physical.definition?.elementId);
+      for (let index = 0; index < physical.publisherElementIds.length; index += 1) {
+        addId(physical.publisherElementIds[index]);
+      }
+      for (let index = 0; index < record.view.domAliases.length; index += 1) {
+        addId(record.view.domAliases[index]);
+      }
+      if (ids.length === 0) return undefined;
+
+      const resolution = Reflect.apply(reconciliationResolve, reconciliationBoundary, [
+        Object.freeze(ids),
+      ]) as SlotReconciliationResolution;
+      if (
+        resolution.status !== 'unique' ||
+        !Reflect.apply(reconciliationIsConnected, reconciliationBoundary, [resolution.element]) ||
+        physical.domElement === undefined ||
+        physical.domElement !== resolution.element ||
+        !Reflect.apply(reconciliationIsConnected, reconciliationBoundary, [physical.domElement])
+      ) {
+        return undefined;
+      }
+
+      const existingClaim = physical.apsMountClaim;
+      if (existingClaim && !existingClaim.cycle.traceRetirement.retired) return undefined;
+      const token = Object.freeze({});
+      const bindingEpoch = physical.bindingEpoch;
+      physical.apsMountClaim = Object.freeze({ cycle, token });
+      const current = (): boolean => {
+        try {
+          if (
+            state.disposed ||
+            !state.owner.isCurrent() ||
+            mapValue(state.records, registeredSlotId) !== record ||
+            record.physical !== physical ||
+            physical.record !== record ||
+            physical.state !== 'live' ||
+            intent.input.expectedSlot !== physical.slot ||
+            physical.bindingEpoch !== bindingEpoch ||
+            physical.lastCycle !== cycle ||
+            cycle.traceRetirement.retired ||
+            physical.apsMountClaim?.cycle !== cycle ||
+            physical.apsMountClaim.token !== token
+          ) {
+            return false;
+          }
+          const revalidated = Reflect.apply(reconciliationResolve, reconciliationBoundary, [
+            Object.freeze([...ids]),
+          ]) as SlotReconciliationResolution;
+          return (
+            revalidated.status === 'unique' &&
+            revalidated.element === resolution.element &&
+            Reflect.apply(reconciliationIsConnected, reconciliationBoundary, [
+              resolution.element,
+            ]) === true
+          );
+        } catch {
+          return false;
+        }
+      };
+      if (!current()) {
+        if (physical.apsMountClaim?.token === token) physical.apsMountClaim = undefined;
+        return undefined;
+      }
+      const bindArtifact = (
+        artifact: CommittedRenderArtifact
+      ):
+        | Readonly<{
+            commit: () => boolean;
+            finalize: () => void;
+            isCurrent: () => boolean;
+            previousArtifact: CommittedRenderArtifact | undefined;
+            release: () => void;
+            rollback: () => void;
+          }>
+        | undefined => {
+        try {
+          if (
+            !current() ||
+            !Object.isFrozen(artifact) ||
+            artifact.kind !== 'aps_mount' ||
+            artifact.slot !== registeredSlotId ||
+            artifact.navigationGeneration !== navigationGeneration
+          ) {
+            return undefined;
+          }
+          const previous = physical.committedArtifact;
+          let phase: 'prepared' | 'committed' | 'finalized' | 'released' | 'rolled_back' =
+            'prepared';
+          return Object.freeze({
+            commit: (): boolean => {
+              if (phase !== 'prepared' || !current() || physical.committedArtifact !== previous) {
+                return false;
+              }
+              physical.committedArtifact = artifact;
+              phase = 'committed';
+              return true;
+            },
+            finalize: (): void => {
+              if (phase === 'committed') phase = 'finalized';
+            },
+            isCurrent: (): boolean =>
+              (phase === 'committed' || phase === 'finalized') &&
+              physical.committedArtifact === artifact &&
+              current(),
+            previousArtifact: previous,
+            release: (): void => {
+              if (phase === 'released' || phase === 'rolled_back') return;
+              if (physical.committedArtifact === artifact) {
+                physical.committedArtifact = phase === 'committed' ? previous : undefined;
+              }
+              phase = 'released';
+            },
+            rollback: (): void => {
+              if (phase !== 'committed' && phase !== 'released') return;
+              if (phase === 'committed' && physical.committedArtifact === artifact) {
+                physical.committedArtifact = previous;
+              }
+              phase = 'rolled_back';
+            },
+          });
+        } catch {
+          return undefined;
+        }
+      };
+      return Object.freeze({
+        bindArtifact,
+        bindingEpoch,
+        cycle: cycle.traceHandle,
+        element: resolution.element,
+        physicalSlot: physical.slot,
+        isCurrent: current,
+      });
+    } catch {
+      return undefined;
+    }
+  };
+
+  const adoptCommittedArtifact = (
+    navigationGeneration: object,
+    registeredSlotId: string,
+    artifact: CommittedRenderArtifact,
+    onRetire?: () => void
+  ): boolean => {
+    try {
+      const state = mapValue(navigationStates, navigationGeneration);
+      const record = state ? mapValue(state.records, registeredSlotId) : undefined;
+      const physical = record?.physical;
+      if (
+        !state ||
+        state.disposed ||
+        !state.owner.isCurrent() ||
+        !record ||
+        !physical ||
+        physical.record !== record ||
+        physical.state !== 'live' ||
+        physical.committedArtifact !== undefined ||
+        !Object.isFrozen(artifact) ||
+        (artifact.kind !== 'aps_mount' && artifact.kind !== 'direct_iframe') ||
+        artifact.slot !== registeredSlotId ||
+        artifact.navigationGeneration !== navigationGeneration ||
+        (onRetire !== undefined && typeof onRetire !== 'function')
+      ) {
+        return false;
+      }
+      physical.committedArtifact = artifact;
+      if (
+        !bindCommittedArtifactRetirement ||
+        !bindCommittedArtifactRetirement(artifact, () => {
+          if (physical.committedArtifact === artifact) physical.committedArtifact = undefined;
+          try {
+            onRetire?.();
+          } catch {
+            // Exact physical retirement remains authoritative over targeting cleanup failure.
+          }
+        })
+      ) {
+        physical.committedArtifact = undefined;
+        return false;
+      }
+      return physical.committedArtifact === artifact;
+    } catch {
+      return false;
+    }
+  };
+
+  const service: SlotService = Object.freeze({
+    activate: (): void => {
+      if (reconciliationActive) return;
+      activateReconciliation();
+    },
+    activateReconciliation,
+    adoptCommittedArtifact,
+    start: (): GoogletagOperation<void> => {
+      if (activation) return activation;
+      let subscriptions: BindingSubscriptionAdmission | undefined;
+      const operation = options.googletag.run<void>((gpt) => {
+        if (disposed) return;
+        subscriptions = ensureBindingSubscriptions(gpt);
+      });
+      activation = operation;
+      void operation.result.then(
+        () => {
+          if (subscriptions) retireHistoricalSubscriptions(subscriptions.ownership);
+          if (activation === operation) activation = undefined;
+        },
+        () => {
+          if (subscriptions?.installed) subscriptions.ownership.release();
+          if (activation === operation) activation = undefined;
+        }
+      );
+      return operation;
+    },
+    adoptRegistrationHighWater,
+    adoptGptSlot,
+    dispose: (): void => {
+      if (disposed) return;
+      deactivateReconciliation();
+      disposed = true;
+      const states = mapValueSnapshot(navigationStates);
+      for (let index = 0; index < states.length; index += 1) {
+        const state = states[index];
+        if (state) disposeNavigationState(state);
+      }
+      const subscriptions = setValueSnapshot(bindingSubscriptions);
+      for (let index = subscriptions.length - 1; index >= 0; index -= 1) {
+        try {
+          subscriptions[index]?.release();
+        } catch {
+          // One adapter listener cleanup cannot escape service disposal.
+        }
+      }
+      activation?.dispose();
+    },
+    handleGptEvent,
+    isBoundGptSlot: (
+      navigationGeneration: object,
+      registeredSlotId: string,
+      slot: object
+    ): boolean => {
+      try {
+        const state = mapValue(navigationStates, navigationGeneration);
+        const record = state ? mapValue(state.records, registeredSlotId) : undefined;
+        const physical = record?.physical;
+        return (
+          !!state &&
+          !state.disposed &&
+          state.owner.isCurrent() &&
+          !!physical &&
+          physical.slot === slot &&
+          physical.record === record &&
+          physical.state === 'live'
+        );
+      } catch {
+        return false;
+      }
+    },
+    resolveApsMountBinding,
+    prepareProjectionSlots: (
+      owner: NavigationSession,
+      slots: readonly ProjectionSlotRegistration[]
+    ): PreparedProjectionSlots | undefined => {
+      if (!owner.isCurrent() || !Array.isArray(slots)) return undefined;
+      let copied: readonly SlotRegistration[];
+      try {
+        copied = Object.freeze(
+          slots.map((slot) => ({
+            registeredSlotId: slot.registeredSlotId,
+            domAliases: Object.freeze([...slot.domAliases]),
+            source: 'server' as const,
+          }))
+        );
+      } catch {
+        return undefined;
+      }
+      let committedRecords: readonly SlotRecord[] | undefined;
+      return Object.freeze({
+        ownerGeneration: owner.generation,
+        commit: (): boolean => {
+          if (committedRecords) return false;
+          const result = register(owner, copied);
+          if (!result.ok) return false;
+          committedRecords = result.records;
+          return true;
+        },
+        rollback: (): void => {
+          if (!committedRecords) return;
+          const state = mapValue(navigationStates, owner.generation);
+          if (!state) return;
+          for (const view of committedRecords) {
+            const record = mapValue(state.records, view.registeredSlotId);
+            if (!record || record.view !== view) continue;
+            deleteMapValue(registeredSlots, view.registeredSlotId);
+            deleteMapValue(state.records, view.registeredSlotId);
+          }
+          committedRecords = undefined;
+        },
+      });
+    },
+    claimPublisherGptSlot,
+    preparePublisherDisplay,
+    preparePublisherRefresh,
+    projectionRegistry: (owner: NavigationSession): ProjectionSlotRegistry =>
+      Object.freeze({
+        prepareProjectionSlots: (
+          ownerGeneration: object,
+          slots: readonly ProjectionSlotRegistration[],
+          maximumActiveSlots: number
+        ) => {
+          if (
+            ownerGeneration !== owner.generation ||
+            maximumActiveSlots !== MAX_ACTIVE_SLOT_RECORDS
+          ) {
+            return undefined;
+          }
+          return service.prepareProjectionSlots(owner, slots);
+        },
+      }),
+    recordPublisherDestruction,
+    recordPublisherIntent,
+    registeredSlotIdsForTest: (): readonly string[] => {
+      const records = mapValueSnapshot(registeredSlots);
+      records.sort((left, right) => left.view.ordinal - right.view.ordinal);
+      return Object.freeze(records.map(({ view }) => view.registeredSlotId));
+    },
+    register,
+    request,
+    requestBatch,
+    snapshotRegisteredSlots: (owner: NavigationSession): readonly SlotRecord[] | undefined => {
+      if (!owner.isCurrent()) return undefined;
+      const state = mapValue(navigationStates, owner.generation);
+      if (!state || state.disposed || state.owner !== owner) return undefined;
+      const records = mapValueSnapshot(state.records);
+      records.sort((left, right) => left.view.ordinal - right.view.ordinal);
+      return Object.freeze(records.map(({ view }) => view));
+    },
+    resolveAdUnitCode: (adUnitCode: string) => resolveUnique(adUnitCodes, adUnitCode),
+    resolveDomAlias: (alias: string) => resolveUnique(domAliases, alias),
+    resolveRegisteredSlot: (registeredSlotId: string) =>
+      mapValue(registeredSlots, registeredSlotId)?.view,
+    snapshotForTest: () => {
+      let cycles = 0;
+      let intents = 0;
+      const physicalSnapshot = setValueSnapshot(physicalSlots);
+      for (let index = 0; index < physicalSnapshot.length; index += 1) {
+        if (physicalSnapshot[index]?.activeCycle) cycles += 1;
+      }
+      const stateSnapshot = mapValueSnapshot(navigationStates);
+      for (let stateIndex = 0; stateIndex < stateSnapshot.length; stateIndex += 1) {
+        const state = stateSnapshot[stateIndex];
+        if (!state) continue;
+        const recordSnapshot = mapValueSnapshot(state.records);
+        for (let recordIndex = 0; recordIndex < recordSnapshot.length; recordIndex += 1) {
+          const record = recordSnapshot[recordIndex];
+          if (record?.activeIntent) intents += 1;
+          if (record?.queuedIntent) intents += 1;
+        }
+      }
+      return Object.freeze({
+        cycles,
+        intents,
+        physicalSlots: setSize(physicalSlots),
+        records: mapSize(registeredSlots),
+      });
+    },
+  });
+
+  return service;
+}
diff --git a/crates/trusted-server-js/lib/src/services/targeting.ts b/crates/trusted-server-js/lib/src/services/targeting.ts
new file mode 100644
index 000000000..6107d6405
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/services/targeting.ts
@@ -0,0 +1,649 @@
+/** The narrow GPT slot targeting surface consumed by the journal. */
+export interface TargetingBoundary {
+  readonly clearTargeting: (key?: string) => unknown;
+  readonly getTargeting: (key: string) => readonly string[];
+  readonly setTargeting: (key: string, value: string | readonly string[]) => unknown;
+}
+
+/** One opaque targeting ownership frame. */
+export interface TargetingOwnership {
+  readonly ownerId: string;
+  readonly release: () => void;
+}
+
+/** Frozen ownership inventory exposed only to tests. */
+export interface TargetingInventorySnapshot {
+  readonly frames: number;
+  readonly slots: number;
+}
+
+/** Owner-aware targeting operations exposed to render services. */
+export interface TargetingService {
+  readonly adopt: (
+    slot: object,
+    key: string,
+    installed: string,
+    predecessor: readonly string[],
+    ownerId: string,
+    targeting: TargetingBoundary
+  ) => TargetingOwnership | undefined;
+  readonly dispose: () => void;
+  readonly disposeOwner: (ownerId: string) => void;
+  readonly invalidatePublisherMutation: (slot: object, key?: string) => void;
+  readonly observePublisherMutations: (
+    slot: object,
+    adapter: GoogletagAdapter
+  ) => GoogletagOperation<void>;
+  readonly own: (
+    slot: object,
+    key: string,
+    value: string,
+    ownerId: string,
+    targeting: TargetingBoundary
+  ) => TargetingOwnership | undefined;
+  readonly snapshotForTest: () => TargetingInventorySnapshot;
+}
+
+interface PublisherPredecessor {
+  readonly kind: 'publisher';
+  readonly values: readonly string[];
+}
+
+interface TargetingFrame {
+  alive: boolean;
+  readonly kind: 'frame';
+  predecessor: PublisherPredecessor | TargetingFrame;
+  readonly boundary: TargetingBoundary;
+  readonly installed: string;
+  readonly key: string;
+  readonly ownerId: string;
+  readonly observation: GoogletagTargetingObservation | undefined;
+  readonly slot: object;
+}
+
+interface TargetingChain {
+  readonly frames: TargetingFrame[];
+}
+
+const mapDeleteIntrinsic = Map.prototype.delete;
+const mapGetIntrinsic = Map.prototype.get;
+const mapSetIntrinsic = Map.prototype.set;
+const mapSizeGetter = Object.getOwnPropertyDescriptor(Map.prototype, 'size')?.get as (
+  this: Map<unknown, unknown>
+) => number;
+const mapIteratorNextIntrinsic = Object.getPrototypeOf(new Map().entries()).next as (
+  this: IterableIterator<unknown>
+) => IteratorResult<unknown>;
+const weakMapDeleteIntrinsic = WeakMap.prototype.delete;
+const weakMapGetIntrinsic = WeakMap.prototype.get;
+const weakMapSetIntrinsic = WeakMap.prototype.set;
+
+function mapValue<Key, Value>(map: Map<Key, Value>, key: Key): Value | undefined {
+  return Reflect.apply(mapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setMapValue<Key, Value>(map: Map<Key, Value>, key: Key, value: Value): void {
+  Reflect.apply(mapSetIntrinsic, map, [key, value]);
+}
+
+function deleteMapValue<Key, Value>(map: Map<Key, Value>, key: Key): boolean {
+  return Reflect.apply(mapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function mapSize(map: Map<unknown, unknown>): number {
+  return Reflect.apply(mapSizeGetter, map, []) as number;
+}
+
+function weakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): Value | undefined {
+  return Reflect.apply(weakMapGetIntrinsic, map, [key]) as Value | undefined;
+}
+
+function setWeakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key,
+  value: Value
+): void {
+  Reflect.apply(weakMapSetIntrinsic, map, [key, value]);
+}
+
+function deleteWeakMapValue<Key extends object, Value>(
+  map: WeakMap<Key, Value>,
+  key: Key
+): boolean {
+  return Reflect.apply(weakMapDeleteIntrinsic, map, [key]) as boolean;
+}
+
+function exactInstalledValue(values: readonly string[], installed: string): boolean {
+  return values.length === 1 && values[0] === installed;
+}
+
+function exactValues(left: readonly string[], right: readonly string[]): boolean {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+
+function copyValues(values: readonly string[]): readonly string[] {
+  if (!Array.isArray(values)) {
+    throw new TypeError('GPT targeting values must be strings');
+  }
+  const copied: string[] = [];
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (typeof value !== 'string') {
+      throw new TypeError('GPT targeting values must be strings');
+    }
+    copied[index] = value;
+  }
+  return Object.freeze(copied);
+}
+
+/** Construct the runtime-owned GPT targeting restoration journal. */
+export function createTargetingService(): TargetingService {
+  const chainsBySlot = new WeakMap<object, Map<string, TargetingChain>>();
+  const publisherMutationTokensBySlot = new WeakMap<object, object>();
+  const observationsBySlot = new WeakMap<object, GoogletagTargetingObservation>();
+  const liveFrames = new Set<TargetingFrame>();
+  const observationReleases = new Set<() => void>();
+  const setAddIntrinsic = Set.prototype.add;
+  const setDeleteIntrinsic = Set.prototype.delete;
+  const setValuesIntrinsic = Set.prototype.values;
+  const setIteratorNextIntrinsic = Object.getPrototypeOf(new Set().values()).next as (
+    this: IterableIterator<unknown>
+  ) => IteratorResult<unknown>;
+  let disposed = false;
+  let frameCount = 0;
+  let slotCount = 0;
+
+  const addLiveFrame = (frame: TargetingFrame): void => {
+    Reflect.apply(setAddIntrinsic, liveFrames, [frame]);
+  };
+  const deleteLiveFrame = (frame: TargetingFrame): boolean =>
+    Reflect.apply(setDeleteIntrinsic, liveFrames, [frame]) as boolean;
+  const liveFrameValues = (): IterableIterator<TargetingFrame> =>
+    Reflect.apply(setValuesIntrinsic, liveFrames, []) as IterableIterator<TargetingFrame>;
+  const addObservationRelease = (release: () => void): void => {
+    Reflect.apply(setAddIntrinsic, observationReleases, [release]);
+  };
+  const deleteObservationRelease = (release: () => void): boolean =>
+    Reflect.apply(setDeleteIntrinsic, observationReleases, [release]) as boolean;
+  const observationValues = (): IterableIterator<() => void> =>
+    Reflect.apply(setValuesIntrinsic, observationReleases, []) as IterableIterator<() => void>;
+  const setSnapshot = <Value>(iterator: IterableIterator<Value>): Value[] => {
+    const values: Value[] = [];
+    while (true) {
+      const step = Reflect.apply(setIteratorNextIntrinsic, iterator, []) as IteratorResult<Value>;
+      if (step.done) return values;
+      values[values.length] = step.value;
+    }
+  };
+
+  const removeEmptySlot = (slot: object, slotChains: Map<string, TargetingChain>): void => {
+    if (mapSize(slotChains) !== 0) return;
+    if (weakMapValue(chainsBySlot, slot) !== slotChains) return;
+    if (deleteWeakMapValue(chainsBySlot, slot)) slotCount -= 1;
+  };
+
+  const invalidateChain = (
+    slot: object,
+    slotChains: Map<string, TargetingChain>,
+    key: string,
+    chain: TargetingChain
+  ): void => {
+    if (mapValue(slotChains, key) !== chain) return;
+    deleteMapValue(slotChains, key);
+    for (let index = 0; index < chain.frames.length; index += 1) {
+      const frame = chain.frames[index];
+      if (!frame?.alive) continue;
+      frame.alive = false;
+      frameCount -= 1;
+      deleteLiveFrame(frame);
+    }
+    chain.frames.length = 0;
+    removeEmptySlot(slot, slotChains);
+  };
+
+  const removeFrame = (
+    frame: TargetingFrame,
+    slotChains: Map<string, TargetingChain>,
+    chain: TargetingChain,
+    frameIndex: number
+  ): void => {
+    const successor = chain.frames[frameIndex + 1];
+    if (successor) successor.predecessor = frame.predecessor;
+    for (let index = frameIndex; index < chain.frames.length - 1; index += 1) {
+      const next = chain.frames[index + 1];
+      if (next) chain.frames[index] = next;
+    }
+    chain.frames.length -= 1;
+    frame.alive = false;
+    frameCount -= 1;
+    deleteLiveFrame(frame);
+    if (chain.frames.length === 0) deleteMapValue(slotChains, frame.key);
+    removeEmptySlot(frame.slot, slotChains);
+  };
+
+  const expectedPredecessor = (frame: TargetingFrame): readonly string[] | undefined => {
+    const predecessor = frame.predecessor;
+    if (predecessor.kind === 'publisher') return predecessor.values;
+    return predecessor.alive ? Object.freeze([predecessor.installed]) : undefined;
+  };
+
+  const restorePredecessor = (frame: TargetingFrame): void => {
+    const predecessor = frame.predecessor;
+    if (predecessor.kind === 'publisher') {
+      if (predecessor.values.length === 0) frame.boundary.clearTargeting(frame.key);
+      else frame.boundary.setTargeting(frame.key, predecessor.values);
+    } else if (predecessor.alive) {
+      frame.boundary.setTargeting(frame.key, predecessor.installed);
+    }
+  };
+
+  const observationIsCurrent = (observation: GoogletagTargetingObservation): boolean => {
+    try {
+      return observation.isCurrent() === true;
+    } catch {
+      return false;
+    }
+  };
+
+  const release = (frame: TargetingFrame): boolean => {
+    if (!frame.alive) return true;
+    const slotChains = weakMapValue(chainsBySlot, frame.slot);
+    const chain = slotChains ? mapValue(slotChains, frame.key) : undefined;
+    if (!slotChains || !chain) {
+      frame.alive = false;
+      frameCount -= 1;
+      deleteLiveFrame(frame);
+      return true;
+    }
+    let frameIndex = -1;
+    for (let index = 0; index < chain.frames.length; index += 1) {
+      if (chain.frames[index] === frame) {
+        frameIndex = index;
+        break;
+      }
+    }
+    if (frameIndex < 0) {
+      frame.alive = false;
+      frameCount -= 1;
+      deleteLiveFrame(frame);
+      return true;
+    }
+
+    if (frame.observation && !observationIsCurrent(frame.observation)) {
+      invalidateChain(frame.slot, slotChains, frame.key, chain);
+      return true;
+    }
+
+    const wasTop = frameIndex === chain.frames.length - 1;
+    if (!wasTop) {
+      removeFrame(frame, slotChains, chain, frameIndex);
+      return true;
+    }
+
+    let actual: readonly string[];
+    try {
+      actual = copyValues(frame.boundary.getTargeting(frame.key));
+    } catch {
+      return false;
+    }
+    if (frame.observation && !observationIsCurrent(frame.observation)) {
+      invalidateChain(frame.slot, slotChains, frame.key, chain);
+      return true;
+    }
+    if (!exactInstalledValue(actual, frame.installed)) {
+      invalidateChain(frame.slot, slotChains, frame.key, chain);
+      return true;
+    }
+
+    const expected = expectedPredecessor(frame);
+    if (!expected) return false;
+    if (frame.observation && !observationIsCurrent(frame.observation)) {
+      invalidateChain(frame.slot, slotChains, frame.key, chain);
+      return true;
+    }
+    try {
+      restorePredecessor(frame);
+    } catch {
+      // The post-failure read below distinguishes mutate-then-throw from no mutation.
+    }
+    let restored: readonly string[];
+    try {
+      restored = copyValues(frame.boundary.getTargeting(frame.key));
+    } catch {
+      return false;
+    }
+    let exact = restored.length === expected.length;
+    for (let index = 0; exact && index < restored.length; index += 1) {
+      exact = restored[index] === expected[index];
+    }
+    if (!exact) {
+      return false;
+    }
+    removeFrame(frame, slotChains, chain, frameIndex);
+    return true;
+  };
+
+  const rollbackFailedInstallation = (frame: TargetingFrame): boolean => {
+    const slotChains = weakMapValue(chainsBySlot, frame.slot);
+    const chain = slotChains ? mapValue(slotChains, frame.key) : undefined;
+    if (!slotChains || !chain) return true;
+    const frameIndex = chain.frames.length - 1;
+    if (chain.frames[frameIndex] !== frame) return false;
+    let actual: readonly string[];
+    try {
+      actual = copyValues(frame.boundary.getTargeting(frame.key));
+    } catch {
+      return false;
+    }
+    const predecessor = expectedPredecessor(frame);
+    if (predecessor && exactValues(actual, predecessor)) {
+      removeFrame(frame, slotChains, chain, frameIndex);
+      return true;
+    }
+    if (exactInstalledValue(actual, frame.installed)) return release(frame);
+    return false;
+  };
+
+  const invalidatePublisherMutation = (slot: object, key?: string): void => {
+    setWeakMapValue(publisherMutationTokensBySlot, slot, {});
+    const slotChains = weakMapValue(chainsBySlot, slot);
+    if (!slotChains) return;
+    if (key !== undefined) {
+      const chain = mapValue(slotChains, key);
+      if (chain) invalidateChain(slot, slotChains, key, chain);
+      return;
+    }
+    const entries: Array<readonly [string, TargetingChain]> = [];
+    const mapEntriesIntrinsic = Map.prototype.entries;
+    const iterator = Reflect.apply(mapEntriesIntrinsic, slotChains, []) as IterableIterator<
+      [string, TargetingChain]
+    >;
+    while (true) {
+      const step = Reflect.apply(mapIteratorNextIntrinsic, iterator, []) as IteratorResult<
+        [string, TargetingChain]
+      >;
+      if (step.done) break;
+      entries[entries.length] = step.value;
+    }
+    for (const [entryKey, chain] of entries) invalidateChain(slot, slotChains, entryKey, chain);
+  };
+
+  const adopt = (
+    slot: object,
+    key: string,
+    installed: string,
+    predecessor: readonly string[],
+    ownerId: string,
+    targeting: TargetingBoundary
+  ): TargetingOwnership | undefined => {
+    if (disposed) return undefined;
+    if ((typeof slot !== 'object' || slot === null) && typeof slot !== 'function') {
+      throw new TypeError('GPT slot object required');
+    }
+    if (key.length === 0 || installed.length === 0 || ownerId.length === 0) {
+      throw new TypeError('Targeting key, value, and owner are required');
+    }
+    const predecessorValues = copyValues(predecessor);
+    const mutationToken = weakMapValue(publisherMutationTokensBySlot, slot);
+    const actual = copyValues(targeting.getTargeting(key));
+    if (weakMapValue(publisherMutationTokensBySlot, slot) !== mutationToken) return undefined;
+    if (!exactInstalledValue(actual, installed)) return undefined;
+    const observation = weakMapValue(observationsBySlot, slot);
+    if (observation && !observationIsCurrent(observation)) {
+      invalidatePublisherMutation(slot);
+      return undefined;
+    }
+    if (weakMapValue(publisherMutationTokensBySlot, slot) !== mutationToken) return undefined;
+    let slotChains = weakMapValue(chainsBySlot, slot);
+    if (slotChains && mapValue(slotChains, key)) return undefined;
+    if (!slotChains) slotChains = new Map<string, TargetingChain>();
+    const chain: TargetingChain = { frames: [] };
+    const frame: TargetingFrame = {
+      alive: true,
+      kind: 'frame',
+      predecessor: { kind: 'publisher', values: predecessorValues },
+      boundary: targeting,
+      installed,
+      key,
+      observation,
+      ownerId,
+      slot,
+    };
+    const wasNewSlot = weakMapValue(chainsBySlot, slot) === undefined;
+    let publishedWeakMap = false;
+    let publishedChain = false;
+    let publishedFrame = false;
+    try {
+      if (wasNewSlot) {
+        setWeakMapValue(chainsBySlot, slot, slotChains);
+        if (weakMapValue(chainsBySlot, slot) !== slotChains) throw new Error('journal publication');
+        publishedWeakMap = true;
+        slotCount += 1;
+      }
+      setMapValue(slotChains, key, chain);
+      if (mapValue(slotChains, key) !== chain) throw new Error('journal publication');
+      publishedChain = true;
+      chain.frames[0] = frame;
+      publishedFrame = true;
+      addLiveFrame(frame);
+      frameCount += 1;
+    } catch (error) {
+      if (publishedFrame) chain.frames.length = 0;
+      frame.alive = false;
+      if (deleteLiveFrame(frame) && frameCount > 0) frameCount -= 1;
+      if (publishedChain || mapValue(slotChains, key) === chain) deleteMapValue(slotChains, key);
+      if (weakMapValue(chainsBySlot, slot) === slotChains && mapSize(slotChains) === 0) {
+        deleteWeakMapValue(chainsBySlot, slot);
+        if (publishedWeakMap && slotCount > 0) slotCount -= 1;
+      }
+      throw error;
+    }
+    let released = false;
+    return Object.freeze({
+      ownerId,
+      release: (): void => {
+        if (released) return;
+        released = release(frame);
+      },
+    });
+  };
+
+  const own = (
+    slot: object,
+    key: string,
+    value: string,
+    ownerId: string,
+    targeting: TargetingBoundary
+  ): TargetingOwnership | undefined => {
+    if (disposed) return undefined;
+    if ((typeof slot !== 'object' || slot === null) && typeof slot !== 'function') {
+      throw new TypeError('GPT slot object required');
+    }
+    if (key.length === 0 || value.length === 0 || ownerId.length === 0) {
+      throw new TypeError('Targeting key, value, and owner are required');
+    }
+
+    const actual = copyValues(targeting.getTargeting(key));
+    const observation = weakMapValue(observationsBySlot, slot);
+    if (observation && !observationIsCurrent(observation)) {
+      invalidatePublisherMutation(slot);
+      return undefined;
+    }
+    let slotChains = weakMapValue(chainsBySlot, slot);
+    let chain = slotChains ? mapValue(slotChains, key) : undefined;
+    const top = chain?.frames[chain.frames.length - 1];
+    if (top && !exactInstalledValue(actual, top.installed)) {
+      invalidateChain(
+        slot,
+        slotChains as Map<string, TargetingChain>,
+        key,
+        chain as TargetingChain
+      );
+      slotChains = weakMapValue(chainsBySlot, slot);
+      chain = undefined;
+    }
+    if (!slotChains) slotChains = new Map<string, TargetingChain>();
+    if (!chain) chain = { frames: [] };
+    const currentTop = chain.frames[chain.frames.length - 1];
+    const frame: TargetingFrame = {
+      alive: true,
+      kind: 'frame',
+      predecessor: currentTop ?? { kind: 'publisher', values: actual },
+      boundary: targeting,
+      installed: value,
+      key,
+      observation,
+      ownerId,
+      slot,
+    };
+    const wasNewSlot = weakMapValue(chainsBySlot, slot) === undefined;
+    const wasNewChain = mapValue(slotChains, key) === undefined;
+    let publishedWeakMap = false;
+    let publishedChain = false;
+    let publishedFrame = false;
+    try {
+      if (wasNewSlot) {
+        setWeakMapValue(chainsBySlot, slot, slotChains);
+        if (weakMapValue(chainsBySlot, slot) !== slotChains) throw new Error('journal publication');
+        publishedWeakMap = true;
+        slotCount += 1;
+      }
+      if (wasNewChain) {
+        setMapValue(slotChains, key, chain);
+        if (mapValue(slotChains, key) !== chain) throw new Error('journal publication');
+        publishedChain = true;
+      }
+      chain.frames[chain.frames.length] = frame;
+      publishedFrame = true;
+      addLiveFrame(frame);
+      frameCount += 1;
+    } catch (error) {
+      if (publishedFrame) chain.frames.length -= 1;
+      frame.alive = false;
+      if (deleteLiveFrame(frame) && frameCount > 0) frameCount -= 1;
+      if ((publishedChain || mapValue(slotChains, key) === chain) && chain.frames.length === 0) {
+        deleteMapValue(slotChains, key);
+      }
+      if (weakMapValue(chainsBySlot, slot) === slotChains && mapSize(slotChains) === 0) {
+        deleteWeakMapValue(chainsBySlot, slot);
+        if (publishedWeakMap && slotCount > 0) slotCount -= 1;
+      }
+      throw error;
+    }
+
+    try {
+      targeting.setTargeting(key, value);
+    } catch (error) {
+      rollbackFailedInstallation(frame);
+      throw error;
+    }
+    let installedExactly = false;
+    try {
+      installedExactly = exactInstalledValue(copyValues(targeting.getTargeting(key)), value);
+    } catch {
+      // The rollback path below retries observation and retains ownership if still unreadable.
+    }
+    if (!installedExactly) {
+      rollbackFailedInstallation(frame);
+      throw new Error('GPT targeting postcondition failed');
+    }
+
+    let released = false;
+    return Object.freeze({
+      ownerId,
+      release: (): void => {
+        if (released) return;
+        released = release(frame);
+      },
+    });
+  };
+
+  return Object.freeze({
+    adopt,
+    dispose: (): void => {
+      if (disposed) return;
+      disposed = true;
+      const frames = setSnapshot(liveFrameValues());
+      for (let index = frames.length - 1; index >= 0; index -= 1) {
+        const frame = frames[index];
+        if (frame) release(frame);
+      }
+      const observations = setSnapshot(observationValues());
+      for (let index = observations.length - 1; index >= 0; index -= 1) {
+        try {
+          observations[index]?.();
+        } catch {
+          // Adapter wrapper cleanup cannot escape service disposal.
+        }
+      }
+    },
+    disposeOwner: (ownerId: string): void => {
+      const frames = setSnapshot(liveFrameValues());
+      for (let index = frames.length - 1; index >= 0; index -= 1) {
+        const frame = frames[index];
+        if (frame?.ownerId === ownerId) release(frame);
+      }
+    },
+    invalidatePublisherMutation,
+    observePublisherMutations: (slot: object, adapter: GoogletagAdapter) => {
+      let ownedRelease = (): void => undefined;
+      const operation = adapter.run<void>((gpt) => {
+        if (disposed) return;
+        const release = gpt.observeTargeting(
+          slot,
+          Object.freeze({
+            beforePublisherMutation: (mutatedSlot: object, key?: string) => {
+              invalidatePublisherMutation(mutatedSlot, key);
+            },
+          })
+        );
+        let active = true;
+        ownedRelease = (): void => {
+          if (!active) return;
+          active = false;
+          deleteObservationRelease(ownedRelease);
+          if (weakMapValue(observationsBySlot, slot) === release) {
+            deleteWeakMapValue(observationsBySlot, slot);
+          }
+          const current = release;
+          current();
+        };
+        try {
+          setWeakMapValue(observationsBySlot, slot, release);
+          addObservationRelease(ownedRelease);
+        } catch (error) {
+          ownedRelease();
+          throw error;
+        }
+        if (disposed) ownedRelease();
+      });
+      void operation.result.catch(() => {
+        ownedRelease();
+      });
+      return Object.freeze({
+        get status() {
+          return operation.status;
+        },
+        result: operation.result,
+        dispose: (): void => {
+          ownedRelease();
+          operation.dispose();
+        },
+      });
+    },
+    own,
+    snapshotForTest: () => Object.freeze({ frames: frameCount, slots: slotCount }),
+  });
+}
+import type {
+  GoogletagAdapter,
+  GoogletagOperation,
+  GoogletagTargetingObservation,
+} from '../adapters/googletag';
diff --git a/crates/trusted-server-js/lib/src/shared/aps_documents.ts b/crates/trusted-server-js/lib/src/shared/aps_documents.ts
new file mode 100644
index 000000000..f3cfce936
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/aps_documents.ts
@@ -0,0 +1,564 @@
+import type { ApsRendererV1 } from '../core/types';
+import { validateApsRenderer } from '../core/contracts/aps_renderer';
+import { APS_RENDERER_VALIDATOR_ES5_V1 } from '../core/contracts/generated/renderer_validator_document_v1';
+
+export const MAX_APS_CONTAINER_DOCUMENT_BYTES = 65_536;
+export const MAX_APS_INNER_DOCUMENT_BYTES = 65_536;
+export const MAX_APS_CONTAINER_URL_BYTES = 196_663;
+export const APS_DATA_URL_PREFIX = 'data:text/html;charset=utf-8,';
+export const APS_PERMANENT_SANDBOX =
+  'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation';
+
+const bootstrapNoncePattern = /^b1_[A-Za-z0-9_-]{22}$/;
+const rendererNoncePattern = /^n1_[A-Za-z0-9_-]{22}$/;
+const loopbackIpv4Pattern = /^127(?:\.\d{1,3}){3}$/;
+const sentinelPattern = /__TS_[A-Z0-9_]+__/;
+const encoder = new TextEncoder();
+
+function scriptSources(
+  trustedServerOrigin: string,
+  creativeOrigin: string,
+  scriptCreative: boolean
+): string {
+  return scriptCreative
+    ? `'unsafe-inline' ${trustedServerOrigin} ${creativeOrigin}`
+    : `'unsafe-inline' ${trustedServerOrigin}`;
+}
+
+function outerCsp(
+  trustedServerOrigin: string,
+  creativeOrigin: string,
+  scriptCreative: boolean
+): string {
+  return `default-src 'none'; base-uri 'none'; object-src 'none'; script-src ${scriptSources(trustedServerOrigin, creativeOrigin, scriptCreative)}; connect-src https: ${trustedServerOrigin}; frame-src data: ${creativeOrigin}; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;`;
+}
+
+function innerCsp(
+  trustedServerOrigin: string,
+  creativeOrigin: string,
+  scriptCreative: boolean
+): string {
+  return `default-src 'none'; base-uri 'none'; object-src 'none'; script-src ${scriptSources(trustedServerOrigin, creativeOrigin, scriptCreative)}; connect-src https: ${trustedServerOrigin}; frame-src ${creativeOrigin}; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;`;
+}
+
+export const APS_IFRAME_OUTER_CSP = (trustedServerOrigin: string, creativeOrigin: string): string =>
+  outerCsp(trustedServerOrigin, creativeOrigin, false);
+export const APS_IFRAME_INNER_CSP = (trustedServerOrigin: string, creativeOrigin: string): string =>
+  innerCsp(trustedServerOrigin, creativeOrigin, false);
+export const APS_SCRIPT_OUTER_CSP = (trustedServerOrigin: string, creativeOrigin: string): string =>
+  outerCsp(trustedServerOrigin, creativeOrigin, true);
+export const APS_SCRIPT_INNER_CSP = (trustedServerOrigin: string, creativeOrigin: string): string =>
+  innerCsp(trustedServerOrigin, creativeOrigin, true);
+
+export interface ApsDataDocumentInputV1 {
+  readonly renderer: unknown;
+  readonly publisherOrigin: string;
+  readonly bootstrapNonce: string;
+  readonly rendererNonce: string;
+}
+
+export interface ApsDataDocumentsV1 {
+  readonly version: 1;
+  readonly bootstrapNonce: string;
+  readonly rendererNonce: string;
+  readonly trustedServerOrigin: string;
+  readonly creativeOrigin: string;
+  readonly sandbox: string;
+  readonly outerCsp: string;
+  readonly innerCsp: string;
+  readonly outerDocument: string;
+  readonly innerDocument: string;
+  readonly outerUrl: string;
+  readonly innerUrl: string;
+}
+
+// Build-time authority for the renderer-v2 response generator and its contract tests.
+// Production TSJS artifacts must not import this module.
+const INNER_TEMPLATE = `<!doctype html>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="__TS_INNER_CSP__">
+<style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}</style>
+<body>
+<script>
+(function(){
+'use strict';
+__TS_RENDERER_VALIDATOR__
+var EXPECTED_NONCE=__TS_RENDERER_NONCE_JSON__;
+var EXPECTED_PUBLISHER_ORIGIN=__TS_PUBLISHER_ORIGIN_JSON__;
+var EXPECTED_CREATIVE_ORIGIN=__TS_CREATIVE_ORIGIN_JSON__;
+var EXPECTED_TAG_TYPE=__TS_TAG_TYPE_JSON__;
+var RUNNER_URL=__TS_RUNNER_URL_JSON__;
+var MAX_GLOBAL_MESSAGE_BYTES=4096;
+var port=null;
+var accepted=false;
+var terminal=false;
+var runnerLoaded=false;
+var callbackOutcome=null;
+function utf8Length(value){return(new TextEncoder()).encode(value).length;}
+function exactPlain(value,keys){
+ return !!value&&typeof value==='object'&&!Array.isArray(value)&&
+  Object.getPrototypeOf(value)===Object.prototype&&apsExactRecord(value,keys);
+}
+function hasForbiddenOriginCharacter(value){
+ for(var index=0;index<value.length;index+=1){
+  var code=value.charCodeAt(index);
+  if(code<=32||code===127||value[index]==="'"||value[index]==='"'||value[index]===';')return true;
+ }
+ return false;
+}
+function exactOrigin(value){
+ if(typeof value!=='string'||utf8Length(value)>2048||hasForbiddenOriginCharacter(value))return false;
+ try{
+  var parsed=new URL(value);
+  return (parsed.protocol==='https:'||parsed.protocol==='http:')&&parsed.hostname!==''&&
+   parsed.username===''&&parsed.password===''&&parsed.origin===value&&
+   parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';
+ }catch(_error){return false;}
+}
+function rendererMatchesPolicy(renderer){
+ try{
+  return renderer.tagType===EXPECTED_TAG_TYPE&&
+   (new URL(renderer.creativeUrl)).origin===EXPECTED_CREATIVE_ORIGIN;
+ }catch(_error){return false;}
+}
+function send(message){
+ if(!port)return;
+ try{port.postMessage(message);}catch(_error){/* A closed terminal port has no fallback channel. */}
+}
+function close(){
+ if(!port)return;
+ try{port.close();}catch(_error){/* Port cleanup remains best-effort after settlement. */}
+}
+function fail(reason){
+ if(terminal)return;
+ terminal=true;
+ send({message:'TS APS Render Failed',version:1,nonce:EXPECTED_NONCE,reason:reason});
+ close();
+}
+function finishCallback(){
+ if(terminal||!runnerLoaded||callbackOutcome===null)return;
+ if(callbackOutcome==='rejected')return fail('runner_failed');
+ terminal=true;
+ send({message:'TS APS Render Completed',version:1,nonce:EXPECTED_NONCE});
+ close();
+}
+function receiveEnvelope(event){
+ if(accepted||terminal)return;
+ var envelope=event&&event.data;
+ if(!exactPlain(envelope,['nonce','publisherOrigin','renderer','version'])||
+    envelope.version!==1||envelope.nonce!==EXPECTED_NONCE||
+    envelope.publisherOrigin!==EXPECTED_PUBLISHER_ORIGIN||
+    !exactOrigin(envelope.publisherOrigin)||
+    classifyApsRendererV1(envelope.renderer,envelope.publisherOrigin)!=='accepted'||
+    !rendererMatchesPolicy(envelope.renderer)){
+  fail('descriptor_invalid');
+  return;
+ }
+ accepted=true;
+ port.onmessage=null;
+ send({message:'TS APS Document Accepted',version:1,nonce:EXPECTED_NONCE});
+ window._aps=window._aps instanceof Map?window._aps:new Map();
+ var renderer=envelope.renderer;
+ var account=window._aps.get(renderer.accountId);
+ if(!account){
+  account={queue:[],store:new Map([['listeners',new Map()]])};
+  window._aps.set(renderer.accountId,account);
+ }
+ var renderPromise=new Promise(function(resolve,reject){
+  account.queue.push(new CustomEvent('prebid/creative/render',{detail:{
+   aaxResponse:renderer.aaxResponse,
+   seatBidId:renderer.bidId,
+   source:'internal',
+   resolve:resolve,
+   reject:reject
+  }}));
+ });
+ renderPromise.then(function(){
+  callbackOutcome='resolved';
+  finishCallback();
+ },function(){
+  callbackOutcome='rejected';
+  finishCallback();
+ });
+ var script=document.createElement('script');
+ script.src=RUNNER_URL;
+ script.crossOrigin='anonymous';
+ script.referrerPolicy='no-referrer';
+ script.onload=function(){
+  if(terminal)return;
+  runnerLoaded=true;
+  send({message:'TS APS Runner Loaded',version:1,nonce:EXPECTED_NONCE});
+  finishCallback();
+ };
+ script.onerror=function(){fail('runner_no_load');};
+ document.head.appendChild(script);
+}
+function receiveBind(event){
+ if(port||terminal||event.source!==parent||event.origin!=='null'||
+    !event.ports||event.ports.length!==1||typeof event.data!=='string'||
+    utf8Length(event.data)>MAX_GLOBAL_MESSAGE_BYTES)return;
+ var value;
+ try{value=JSON.parse(event.data);}catch(_error){return;}
+ if(!exactPlain(value,['message','rendererNonce','version'])||
+    value.message!=='TS APS Inner Bind'||value.version!==1||
+    value.rendererNonce!==EXPECTED_NONCE||
+    event.data!==JSON.stringify({message:'TS APS Inner Bind',version:1,
+     rendererNonce:EXPECTED_NONCE}))return;
+ port=event.ports[0];
+ removeEventListener('message',receiveBind);
+ port.onmessage=receiveEnvelope;
+ port.onmessageerror=function(){fail(accepted?'runner_failed':'descriptor_invalid');};
+ try{port.start();}catch(_error){fail('descriptor_invalid');}
+}
+var match=/^#(n1_[A-Za-z0-9_-]{22})$/.exec(location.hash);
+if(!match||match[1]!==EXPECTED_NONCE)return;
+try{history.replaceState(null,'',location.pathname+location.search);}catch(_error){
+ /* Fragment clearing has no authority over envelope acceptance. */
+}
+addEventListener('message',receiveBind);
+parent.postMessage(JSON.stringify({message:'TS APS Inner Ready',version:1,
+ rendererNonce:EXPECTED_NONCE}),'*');
+})();
+</script>
+`;
+
+const OUTER_TEMPLATE = `<!doctype html>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="__TS_OUTER_CSP__">
+<style>html,body{border:0;height:100%;margin:0;overflow:hidden;padding:0;width:100%}iframe{border:0;display:block;height:100%;margin:0;overflow:hidden;width:100%}</style>
+<body>
+<script>
+(function(){
+'use strict';
+var EXPECTED_BOOTSTRAP_NONCE=__TS_BOOTSTRAP_NONCE_JSON__;
+var EXPECTED_RENDERER_NONCE=__TS_RENDERER_NONCE_JSON__;
+var INNER_URL=__TS_INNER_URL_JSON__;
+var PERMANENT_SANDBOX=__TS_PERMANENT_SANDBOX_JSON__;
+var MAX_GLOBAL_MESSAGE_BYTES=4096;
+var consumed=false;
+function utf8Length(value){return(new TextEncoder()).encode(value).length;}
+function exact(value,keys){
+ if(!value||typeof value!=='object'||Array.isArray(value)||
+    Object.getPrototypeOf(value)!==Object.prototype)return false;
+ if(typeof Object.getOwnPropertySymbols==='function'&&
+    Object.getOwnPropertySymbols(value).length!==0)return false;
+ var names=Object.getOwnPropertyNames(value).sort();
+ if(names.length!==keys.length)return false;
+ for(var index=0;index<names.length;index+=1){
+  if(names[index]!==keys[index])return false;
+  var descriptor=Object.getOwnPropertyDescriptor(value,names[index]);
+  if(!descriptor||!Object.prototype.hasOwnProperty.call(descriptor,'value'))return false;
+ }
+ return true;
+}
+var match=/^#(b1_[A-Za-z0-9_-]{22})$/.exec(location.hash);
+if(!match||match[1]!==EXPECTED_BOOTSTRAP_NONCE)return;
+try{history.replaceState(null,'',location.pathname+location.search);}catch(_error){
+ /* Fragment clearing has no authority over channel acceptance. */
+}
+var frame=document.createElement('iframe');
+frame.setAttribute('title','Ad content');
+frame.setAttribute('aria-label','Advertisement');
+frame.setAttribute('scrolling','no');
+frame.setAttribute('frameborder','0');
+frame.setAttribute('marginheight','0');
+frame.setAttribute('marginwidth','0');
+frame.setAttribute('sandbox',PERMANENT_SANDBOX);
+frame.src=INNER_URL;
+var source=null;
+function receive(event){
+ if(consumed||!source||event.source!==source||event.origin!=='null'||
+    !event.ports||event.ports.length!==0||typeof event.data!=='string'||
+    utf8Length(event.data)>MAX_GLOBAL_MESSAGE_BYTES)return;
+ var value;
+ try{value=JSON.parse(event.data);}catch(_error){return;}
+ if(!exact(value,['message','rendererNonce','version'])||
+    value.message!=='TS APS Inner Ready'||value.version!==1||
+    value.rendererNonce!==EXPECTED_RENDERER_NONCE||
+    event.data!==JSON.stringify({message:'TS APS Inner Ready',version:1,
+     rendererNonce:EXPECTED_RENDERER_NONCE}))return;
+ consumed=true;
+ removeEventListener('message',receive);
+ var channel=new MessageChannel();
+ try{
+  source.postMessage(JSON.stringify({message:'TS APS Inner Bind',version:1,
+   rendererNonce:EXPECTED_RENDERER_NONCE}),'*',[channel.port1]);
+  parent.postMessage(JSON.stringify({message:'TS APS Container Ready',version:1,
+   bootstrapNonce:EXPECTED_BOOTSTRAP_NONCE,
+   rendererNonce:EXPECTED_RENDERER_NONCE}),'*',[channel.port2]);
+ }catch(_error){
+  try{channel.port1.close();}catch(_closeError){/* Continue closing the retained endpoint. */}
+  try{channel.port2.close();}catch(_closeError){/* Both endpoints are now inert to this owner. */}
+ }
+}
+addEventListener('message',receive);
+document.body.appendChild(frame);
+source=frame.contentWindow;
+})();
+</script>
+`;
+
+function exactGenerationInput(candidate: unknown): ApsDataDocumentInputV1 | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype
+    ) {
+      return undefined;
+    }
+    const expected = ['renderer', 'publisherOrigin', 'bootstrapNonce', 'rendererNonce'];
+    const keys = Reflect.ownKeys(candidate);
+    if (
+      keys.length !== expected.length ||
+      keys.some((key) => typeof key !== 'string' || !expected.includes(key))
+    ) {
+      return undefined;
+    }
+    const values: Record<string, unknown> = {};
+    for (const key of expected) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor?.enumerable || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+        return undefined;
+      }
+      values[key] = descriptor.value;
+    }
+    if (
+      typeof values['publisherOrigin'] !== 'string' ||
+      typeof values['bootstrapNonce'] !== 'string' ||
+      typeof values['rendererNonce'] !== 'string'
+    ) {
+      return undefined;
+    }
+    return {
+      renderer: values['renderer'],
+      publisherOrigin: values['publisherOrigin'],
+      bootstrapNonce: values['bootstrapNonce'],
+      rendererNonce: values['rendererNonce'],
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function hasForbiddenOriginCharacter(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (
+      code <= 0x20 ||
+      code === 0x7f ||
+      value[index] === "'" ||
+      value[index] === '"' ||
+      value[index] === ';'
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function trustedServerOrigin(value: string): string | undefined {
+  if (encoder.encode(value).byteLength > 2_048 || hasForbiddenOriginCharacter(value)) {
+    return undefined;
+  }
+  try {
+    const origin = new URL(value);
+    const loopbackHttp =
+      origin.protocol === 'http:' &&
+      (origin.hostname === 'localhost' ||
+        origin.hostname === '[::1]' ||
+        loopbackIpv4Pattern.test(origin.hostname));
+    return origin.origin === value &&
+      origin.username === '' &&
+      origin.password === '' &&
+      origin.pathname === '/' &&
+      origin.search === '' &&
+      origin.hash === '' &&
+      (origin.protocol === 'https:' || loopbackHttp)
+      ? origin.origin
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function validatedCreativeOrigin(
+  renderer: Readonly<ApsRendererV1>,
+  publisherOrigin: string
+): string | undefined {
+  try {
+    const creative = new URL(renderer.creativeUrl);
+    return creative.protocol === 'https:' &&
+      creative.username === '' &&
+      creative.password === '' &&
+      creative.origin !== publisherOrigin &&
+      !hasForbiddenOriginCharacter(creative.origin)
+      ? creative.origin
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function replaceSentinel(
+  template: string,
+  sentinel: string,
+  replacement: string
+): string | undefined {
+  const first = template.indexOf(sentinel);
+  if (first < 0 || template.indexOf(sentinel, first + sentinel.length) >= 0) return undefined;
+  return `${template.slice(0, first)}${replacement}${template.slice(first + sentinel.length)}`;
+}
+
+function substitute(
+  template: string,
+  replacements: Readonly<Record<string, string>>
+): string | undefined {
+  let output = template;
+  for (const [sentinel, replacement] of Object.entries(replacements)) {
+    const next = replaceSentinel(output, sentinel, replacement);
+    if (next === undefined) return undefined;
+    output = next;
+  }
+  return sentinelPattern.test(output) ? undefined : output;
+}
+
+function htmlAttribute(value: string): string | undefined {
+  if (value.includes('&') || value.includes('"') || value.includes('<') || value.includes('>')) {
+    return undefined;
+  }
+  return value;
+}
+
+function scriptString(value: string): string | undefined {
+  if (!validUnicodeScalars(value)) return undefined;
+  return JSON.stringify(value)
+    .replace(/</g, '\\u003c')
+    .replace(/>/g, '\\u003e')
+    .replace(/&/g, '\\u0026')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+}
+
+function hasOneClosingScript(documentSource: string): boolean {
+  const token = '</script>';
+  const first = documentSource.indexOf(token);
+  return first >= 0 && first === documentSource.lastIndexOf(token);
+}
+
+function validUnicodeScalars(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next < 0xdc00 || next > 0xdfff) return false;
+      index += 1;
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function dataUrl(documentSource: string, nonce: string): string {
+  return `${APS_DATA_URL_PREFIX}${encodeURIComponent(documentSource)}#${nonce}`;
+}
+
+/** Generate one detached outer container and inner renderer before any DOM mutation. */
+export function generateApsDataDocumentsV1(
+  candidate: unknown
+): Readonly<ApsDataDocumentsV1> | undefined {
+  try {
+    const input = exactGenerationInput(candidate);
+    if (
+      !input ||
+      !bootstrapNoncePattern.test(input.bootstrapNonce) ||
+      !rendererNoncePattern.test(input.rendererNonce)
+    ) {
+      return undefined;
+    }
+    const trustedOrigin = trustedServerOrigin(input.publisherOrigin);
+    if (!trustedOrigin) return undefined;
+    const renderer = validateApsRenderer(input.renderer, trustedOrigin);
+    if (!renderer) return undefined;
+    const creativeOrigin = validatedCreativeOrigin(renderer, trustedOrigin);
+    if (!creativeOrigin) return undefined;
+    const scriptCreative = renderer.tagType === 'script';
+    const selectedOuterCsp = outerCsp(trustedOrigin, creativeOrigin, scriptCreative);
+    const selectedInnerCsp = innerCsp(trustedOrigin, creativeOrigin, scriptCreative);
+    const runnerUrl = new URL('/integrations/aps/runner.js', trustedOrigin).href;
+    const innerCspAttribute = htmlAttribute(selectedInnerCsp);
+    const rendererNonceJson = scriptString(input.rendererNonce);
+    const publisherOriginJson = scriptString(trustedOrigin);
+    const creativeOriginJson = scriptString(creativeOrigin);
+    const tagTypeJson = scriptString(renderer.tagType);
+    const runnerUrlJson = scriptString(runnerUrl);
+    if (
+      !innerCspAttribute ||
+      !rendererNonceJson ||
+      !publisherOriginJson ||
+      !creativeOriginJson ||
+      !tagTypeJson ||
+      !runnerUrlJson
+    ) {
+      return undefined;
+    }
+    const innerDocument = substitute(INNER_TEMPLATE, {
+      __TS_INNER_CSP__: innerCspAttribute,
+      __TS_RENDERER_VALIDATOR__: APS_RENDERER_VALIDATOR_ES5_V1,
+      __TS_RENDERER_NONCE_JSON__: rendererNonceJson,
+      __TS_PUBLISHER_ORIGIN_JSON__: publisherOriginJson,
+      __TS_CREATIVE_ORIGIN_JSON__: creativeOriginJson,
+      __TS_TAG_TYPE_JSON__: tagTypeJson,
+      __TS_RUNNER_URL_JSON__: runnerUrlJson,
+    });
+    if (
+      !innerDocument ||
+      !hasOneClosingScript(innerDocument) ||
+      encoder.encode(innerDocument).byteLength > MAX_APS_INNER_DOCUMENT_BYTES
+    ) {
+      return undefined;
+    }
+    const innerUrl = dataUrl(innerDocument, input.rendererNonce);
+    const outerCspAttribute = htmlAttribute(selectedOuterCsp);
+    const bootstrapNonceJson = scriptString(input.bootstrapNonce);
+    const innerUrlJson = scriptString(innerUrl);
+    const permanentSandboxJson = scriptString(APS_PERMANENT_SANDBOX);
+    if (!outerCspAttribute || !bootstrapNonceJson || !innerUrlJson || !permanentSandboxJson) {
+      return undefined;
+    }
+    const outerDocument = substitute(OUTER_TEMPLATE, {
+      __TS_OUTER_CSP__: outerCspAttribute,
+      __TS_BOOTSTRAP_NONCE_JSON__: bootstrapNonceJson,
+      __TS_RENDERER_NONCE_JSON__: rendererNonceJson,
+      __TS_INNER_URL_JSON__: innerUrlJson,
+      __TS_PERMANENT_SANDBOX_JSON__: permanentSandboxJson,
+    });
+    if (
+      !outerDocument ||
+      !hasOneClosingScript(outerDocument) ||
+      encoder.encode(outerDocument).byteLength > MAX_APS_CONTAINER_DOCUMENT_BYTES
+    ) {
+      return undefined;
+    }
+    const outerUrl = dataUrl(outerDocument, input.bootstrapNonce);
+    if (encoder.encode(outerUrl).byteLength > MAX_APS_CONTAINER_URL_BYTES) return undefined;
+    return Object.freeze({
+      version: 1,
+      bootstrapNonce: input.bootstrapNonce,
+      rendererNonce: input.rendererNonce,
+      trustedServerOrigin: trustedOrigin,
+      creativeOrigin,
+      sandbox: APS_PERMANENT_SANDBOX,
+      outerCsp: selectedOuterCsp,
+      innerCsp: selectedInnerCsp,
+      outerDocument,
+      innerDocument,
+      outerUrl,
+      innerUrl,
+    });
+  } catch {
+    return undefined;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/shared/beacon_guard.ts b/crates/trusted-server-js/lib/src/shared/beacon_guard.ts
index 94618dc30..a5a99552f 100644
--- a/crates/trusted-server-js/lib/src/shared/beacon_guard.ts
+++ b/crates/trusted-server-js/lib/src/shared/beacon_guard.ts
@@ -50,13 +50,53 @@ function extractUrl(input: RequestInfo | URL): string | null {
   return null;
 }
 
+function sameDescriptor(
+  left: PropertyDescriptor | undefined,
+  right: PropertyDescriptor | undefined
+): boolean {
+  if (!left || !right) return left === right;
+  if (left.configurable !== right.configurable || left.enumerable !== right.enumerable) {
+    return false;
+  }
+  if ('value' in left || 'value' in right) {
+    return (
+      'value' in left &&
+      'value' in right &&
+      left.value === right.value &&
+      left.writable === right.writable
+    );
+  }
+  return left.get === right.get && left.set === right.set;
+}
+
+function restoreOwnedDescriptor(
+  target: object,
+  property: PropertyKey,
+  installed: PropertyDescriptor | undefined,
+  original: PropertyDescriptor | undefined
+): void {
+  try {
+    if (!sameDescriptor(Object.getOwnPropertyDescriptor(target, property), installed)) return;
+    if (original) Object.defineProperty(target, property, original);
+    else Reflect.deleteProperty(target, property);
+  } catch {
+    // Publisher replacement or a hostile descriptor cannot block independent cleanup.
+  }
+}
+
 /**
  * Create an independent beacon guard for a specific integration.
  */
 export function createBeaconGuard(config: BeaconGuardConfig): BeaconGuard {
   let installed = false;
-  let originalSendBeacon: typeof navigator.sendBeacon | null = null;
-  let originalFetch: typeof window.fetch | null = null;
+  let originalSendBeacon: typeof navigator.sendBeacon | undefined;
+  let originalSendBeaconDescriptor: PropertyDescriptor | undefined;
+  let installedSendBeaconDescriptor: PropertyDescriptor | undefined;
+  let originalFetch: typeof window.fetch | undefined;
+  let originalFetchDescriptor: PropertyDescriptor | undefined;
+  let installedFetchDescriptor: PropertyDescriptor | undefined;
+  let sendBeaconPatched = false;
+  let fetchPatched = false;
   const prefix = `${config.name} beacon guard`;
 
   function install(): void {
@@ -74,23 +114,37 @@ export function createBeaconGuard(config: BeaconGuardConfig): BeaconGuard {
 
     // --- Patch navigator.sendBeacon ---
     if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
-      originalSendBeacon = navigator.sendBeacon.bind(navigator);
+      originalSendBeacon = navigator.sendBeacon;
+      originalSendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+      sendBeaconPatched = true;
 
-      navigator.sendBeacon = function (url: string, data?: BodyInit | null): boolean {
+      const wrapper = function (url: string, data?: BodyInit | null): boolean {
+        const sendBeacon = originalSendBeacon;
+        if (!sendBeacon) return false;
         if (config.isTargetUrl(url)) {
           const rewritten = config.rewriteUrl(url);
           log.info(`${prefix}: rewriting sendBeacon`, { original: url, rewritten });
-          return originalSendBeacon!(rewritten, data);
+          return Reflect.apply(sendBeacon, navigator, [rewritten, data]);
         }
-        return originalSendBeacon!(url, data);
+        return Reflect.apply(sendBeacon, navigator, [url, data]);
       };
+      navigator.sendBeacon = wrapper;
+      installedSendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+      sendBeaconPatched = sameDescriptor(installedSendBeaconDescriptor, {
+        ...installedSendBeaconDescriptor,
+        value: wrapper,
+      });
     }
 
     // --- Patch window.fetch ---
     if (typeof window.fetch === 'function') {
-      originalFetch = window.fetch.bind(window);
+      originalFetch = window.fetch;
+      originalFetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+      fetchPatched = true;
 
-      window.fetch = function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+      const wrapper = function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+        const fetch = originalFetch;
+        if (!fetch) return Promise.reject(new TypeError('fetch is unavailable'));
         const url = extractUrl(input);
 
         if (url && config.isTargetUrl(url)) {
@@ -100,13 +154,19 @@ export function createBeaconGuard(config: BeaconGuardConfig): BeaconGuard {
           // If the input was a Request, create a new one with the rewritten URL
           if (input instanceof Request) {
             const newRequest = new Request(rewritten, input);
-            return originalFetch!(newRequest, init);
+            return Reflect.apply(fetch, window, [newRequest, init]);
           }
-          return originalFetch!(rewritten, init);
+          return Reflect.apply(fetch, window, [rewritten, init]);
         }
 
-        return originalFetch!(input, init);
+        return Reflect.apply(fetch, window, [input, init]);
       };
+      window.fetch = wrapper;
+      installedFetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+      fetchPatched = sameDescriptor(installedFetchDescriptor, {
+        ...installedFetchDescriptor,
+        value: wrapper,
+      });
     }
 
     installed = true;
@@ -118,14 +178,25 @@ export function createBeaconGuard(config: BeaconGuardConfig): BeaconGuard {
   }
 
   function reset(): void {
-    if (originalSendBeacon && typeof navigator !== 'undefined') {
-      navigator.sendBeacon = originalSendBeacon;
-      originalSendBeacon = null;
+    if (sendBeaconPatched && typeof navigator !== 'undefined') {
+      restoreOwnedDescriptor(
+        navigator,
+        'sendBeacon',
+        installedSendBeaconDescriptor,
+        originalSendBeaconDescriptor
+      );
     }
-    if (originalFetch && typeof window !== 'undefined') {
-      window.fetch = originalFetch;
-      originalFetch = null;
+    if (fetchPatched && typeof window !== 'undefined') {
+      restoreOwnedDescriptor(window, 'fetch', installedFetchDescriptor, originalFetchDescriptor);
     }
+    originalSendBeacon = undefined;
+    originalSendBeaconDescriptor = undefined;
+    installedSendBeaconDescriptor = undefined;
+    originalFetch = undefined;
+    originalFetchDescriptor = undefined;
+    installedFetchDescriptor = undefined;
+    sendBeaconPatched = false;
+    fetchPatched = false;
     installed = false;
     log.debug(`${prefix}: reset and uninstalled`);
   }
diff --git a/crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts b/crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts
index 5fb9283be..1046d951d 100644
--- a/crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts
+++ b/crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts
@@ -42,11 +42,11 @@ interface RegisteredDomInsertionHandler extends DomInsertionHandler {
 }
 
 interface DomInsertionDispatcherState {
-  appendChildWrapper?: AppendChildMethod;
-  baselineAppendChild?: AppendChildMethod;
-  baselineInsertBefore?: InsertBeforeMethod;
+  appendChildWrapper?: AppendChildMethod | undefined;
+  baselineAppendChild?: AppendChildMethod | undefined;
+  baselineInsertBefore?: InsertBeforeMethod | undefined;
   handlers: Map<number, RegisteredDomInsertionHandler>;
-  insertBeforeWrapper?: InsertBeforeMethod;
+  insertBeforeWrapper?: InsertBeforeMethod | undefined;
   nextSequence: number;
   orderedHandlers: RegisteredDomInsertionHandler[];
   version: number;
diff --git a/crates/trusted-server-js/lib/src/shared/first_display_contracts.ts b/crates/trusted-server-js/lib/src/shared/first_display_contracts.ts
new file mode 100644
index 000000000..7a7ec162c
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/first_display_contracts.ts
@@ -0,0 +1,1610 @@
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+import type { FirstDisplayGptDiagnosticsV1, FirstDisplayGptFactV1 } from '../shared/takeover';
+
+export const FIRST_DISPLAY_CONTRACT_IDS: readonly FirstDisplaySliceId[] = Object.freeze([
+  'first_display',
+  'render_owner_initial',
+  'aps_initial',
+  'creative_initial',
+  'datadome_initial',
+  'didomi_initial',
+  'google_tag_manager_initial',
+  'gpt_initial',
+  'lockr_initial',
+  'osano_initial',
+  'permutive_initial',
+  'sourcepoint_initial',
+  'prebid_initial',
+  'testlight_initial',
+]);
+
+export const MAX_FIRST_DISPLAY_SLOTS = 256;
+export const MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES = 8 * 1024 * 1024;
+export const MAX_GPT_FACT_BYTES = 512 * 1024;
+export const MAX_SINGLE_GPT_FACT_BYTES = 1_000;
+export const MAX_FIRST_DISPLAY_HANDOFF_BYTES = 8.5 * 1024 * 1024;
+
+const MAX_U32 = 4_294_967_295;
+const MAX_STRING_BYTES = 4096;
+const MAX_PROPERTY_BYTES = 128;
+const MAX_TARGETING = 32;
+const MAX_FORMATS = 32;
+const MAX_ALIASES = 32;
+const MAX_FACTS = 512;
+const HASH = /^[0-9a-f]{64}$/;
+const FIRST_DISPLAY_ORDER = new Map(
+  FIRST_DISPLAY_CONTRACT_IDS.map((id, index) => [id, index + 1] as const)
+);
+
+export type TerminalAttemptState = 'accepted' | 'no_bid' | 'failed' | 'cancelled';
+export type CommittedArtifactKind = 'none' | 'gpt_adm' | 'aps';
+
+export interface TakeoverOutlineV1 {
+  readonly version: 1;
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly projectionDigest: string;
+  readonly integrationConfigDigest: string;
+  readonly slices: readonly FirstDisplaySliceId[];
+  readonly slotCount: number;
+  readonly outcomeCount: number;
+  readonly capabilities: readonly string[];
+  readonly objectKinds: readonly ('gpt_slot' | 'dom_artifact')[];
+}
+
+export interface FirstDisplayHandoffV1 {
+  readonly version: 1;
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly projectionDigest: string;
+  readonly integrationConfigDigest: string;
+  readonly slices: readonly FirstDisplaySliceId[];
+  readonly slots: readonly Readonly<Record<string, unknown>>[];
+  readonly attempts: readonly Readonly<Record<string, unknown>>[];
+  readonly tombstones: readonly Readonly<Record<string, unknown>>[];
+  readonly artifacts: readonly Readonly<Record<string, unknown>>[];
+  readonly parserState: readonly Readonly<Record<string, unknown>>[];
+  readonly gptDiagnostics: Readonly<FirstDisplayGptDiagnosticsV1>;
+  readonly timing: Readonly<Record<string, number | null>>;
+  readonly highWater: Readonly<Record<string, number | string>>;
+  readonly cycles: readonly Readonly<Record<string, unknown>>[];
+  readonly trace: Readonly<Record<string, unknown>>;
+  readonly mutationRevision: number;
+}
+
+export interface FirstDisplayOwnershipCapsuleV1<T extends object = object> {
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly consume: (releaseId: string, generation: number) => readonly T[] | undefined;
+  readonly clear: () => void;
+}
+
+function utf8Length(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function isU32(value: unknown, allowZero = true): value is number {
+  return (
+    typeof value === 'number' &&
+    Number.isInteger(value) &&
+    value >= (allowZero ? 0 : 1) &&
+    value <= MAX_U32
+  );
+}
+
+function finiteNonnegative(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+
+function isCapability(value: string): boolean {
+  if (value.length === 0 || value.length > MAX_PROPERTY_BYTES) return false;
+  const first = value.charCodeAt(0);
+  if (first < 0x61 || first > 0x7a) return false;
+  let previousWasDot = false;
+  for (let index = 1; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code === 0x2e) {
+      if (previousWasDot || index === value.length - 1) return false;
+      previousWasDot = true;
+      continue;
+    }
+    const lowercase = code >= 0x61 && code <= 0x7a;
+    const digit = code >= 0x30 && code <= 0x39;
+    if (!lowercase && !digit && code !== 0x5f) return false;
+    previousWasDot = false;
+  }
+  return true;
+}
+
+function boundedString(
+  value: unknown,
+  maximum = MAX_STRING_BYTES,
+  allowEmpty = false
+): value is string {
+  return (
+    typeof value === 'string' &&
+    (allowEmpty || value.length > 0) &&
+    utf8Length(value) <= maximum &&
+    !value.split('').some((character) => {
+      const code = character.charCodeAt(0);
+      return code <= 0x1f || code === 0x7f;
+    })
+  );
+}
+
+function exactRecord(
+  value: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return undefined;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+  const ownKeys = Reflect.ownKeys(value);
+  if (
+    ownKeys.length !== keys.length ||
+    !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+  ) {
+    return undefined;
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+
+function exactArray(value: unknown, maximum: number): readonly unknown[] | undefined {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;
+  const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+  if (!lengthDescriptor || !('value' in lengthDescriptor)) return undefined;
+  const length = lengthDescriptor.value;
+  if (!Number.isSafeInteger(length) || length < 0 || length > maximum) return undefined;
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== length + 1) return undefined;
+  const result: unknown[] = [];
+  for (let index = 0; index < length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result.push(descriptor.value);
+  }
+  return result;
+}
+
+function uniqueStrings(
+  value: unknown,
+  maximum: number,
+  validate: (value: string) => boolean = (candidate) => boundedString(candidate)
+): readonly string[] | undefined {
+  const values = exactArray(value, maximum);
+  if (!values) return undefined;
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const candidate of values) {
+    if (typeof candidate !== 'string' || !validate(candidate) || seen.has(candidate))
+      return undefined;
+    seen.add(candidate);
+    result.push(candidate);
+  }
+  return Object.freeze(result);
+}
+
+function snapshotSlices(value: unknown): readonly FirstDisplaySliceId[] | undefined {
+  const slices = uniqueStrings(value, FIRST_DISPLAY_CONTRACT_IDS.length, (candidate) =>
+    FIRST_DISPLAY_ORDER.has(candidate as FirstDisplaySliceId)
+  );
+  if (!slices || slices[0] !== 'first_display') return undefined;
+  let previous = 0;
+  for (const slice of slices) {
+    const order = FIRST_DISPLAY_ORDER.get(slice as FirstDisplaySliceId);
+    if (!order || order <= previous) return undefined;
+    previous = order;
+  }
+  const renderOwner = slices.includes('render_owner_initial');
+  if (
+    (slices.includes('aps_initial') && !renderOwner) ||
+    (renderOwner && !slices.includes('gpt_initial'))
+  ) {
+    return undefined;
+  }
+  return slices as readonly FirstDisplaySliceId[];
+}
+
+function freezeRecord<T extends Record<string, unknown>>(value: T): Readonly<T> {
+  return Object.freeze(value);
+}
+
+function canonicalBytes(value: unknown): number | undefined {
+  try {
+    return utf8Length(JSON.stringify(value));
+  } catch {
+    return undefined;
+  }
+}
+
+export function snapshotTakeoverOutlineV1(candidate: unknown): TakeoverOutlineV1 | undefined {
+  try {
+    const fields = exactRecord(candidate, [
+      'version',
+      'releaseId',
+      'generation',
+      'projectionDigest',
+      'integrationConfigDigest',
+      'slices',
+      'slotCount',
+      'outcomeCount',
+      'capabilities',
+      'objectKinds',
+    ]);
+    if (!fields) return undefined;
+    const slices = snapshotSlices(fields.slices);
+    const capabilities = uniqueStrings(fields.capabilities, 32, isCapability);
+    const objectKinds = uniqueStrings(
+      fields.objectKinds,
+      2,
+      (value) => value === 'gpt_slot' || value === 'dom_artifact'
+    ) as readonly ('gpt_slot' | 'dom_artifact')[] | undefined;
+    if (
+      fields.version !== 1 ||
+      typeof fields.releaseId !== 'string' ||
+      !HASH.test(fields.releaseId) ||
+      !isU32(fields.generation, false) ||
+      typeof fields.projectionDigest !== 'string' ||
+      !HASH.test(fields.projectionDigest) ||
+      typeof fields.integrationConfigDigest !== 'string' ||
+      !HASH.test(fields.integrationConfigDigest) ||
+      !slices ||
+      !isU32(fields.slotCount, false) ||
+      fields.slotCount > MAX_FIRST_DISPLAY_SLOTS ||
+      fields.outcomeCount !== fields.slotCount ||
+      !capabilities ||
+      !objectKinds
+    ) {
+      return undefined;
+    }
+    return Object.freeze({
+      version: 1,
+      releaseId: fields.releaseId,
+      generation: fields.generation,
+      projectionDigest: fields.projectionDigest,
+      integrationConfigDigest: fields.integrationConfigDigest,
+      slices,
+      slotCount: fields.slotCount,
+      outcomeCount: fields.outcomeCount,
+      capabilities,
+      objectKinds,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function snapshotStringPairs(
+  value: unknown,
+  maximum: number
+): readonly (readonly [string, string])[] | undefined {
+  const entries = exactArray(value, maximum);
+  if (!entries) return undefined;
+  const seen = new Set<string>();
+  const result: Array<readonly [string, string]> = [];
+  for (const entry of entries) {
+    const pair = exactArray(entry, 2);
+    if (
+      !pair ||
+      pair.length !== 2 ||
+      !boundedString(pair[0], MAX_PROPERTY_BYTES) ||
+      !boundedString(pair[1], MAX_STRING_BYTES, true) ||
+      seen.has(pair[0])
+    ) {
+      return undefined;
+    }
+    seen.add(pair[0]);
+    result.push(Object.freeze([pair[0], pair[1]]));
+  }
+  return Object.freeze(result);
+}
+
+function snapshotTargetingOwnership(
+  value: unknown
+): readonly Readonly<{ installed: string; key: string; prior: readonly string[] }>[] | undefined {
+  const entries = exactArray(value, MAX_TARGETING);
+  if (!entries) return undefined;
+  const seen = new Set<string>();
+  const result: Array<Readonly<{ installed: string; key: string; prior: readonly string[] }>> = [];
+  for (const entry of entries) {
+    const fields = exactRecord(entry, ['installed', 'key', 'prior']);
+    const prior = fields ? exactArray(fields.prior, MAX_TARGETING) : undefined;
+    if (
+      !fields ||
+      !boundedString(fields.key, MAX_PROPERTY_BYTES) ||
+      !boundedString(fields.installed, MAX_STRING_BYTES) ||
+      !prior ||
+      prior.some((value) => !boundedString(value, MAX_STRING_BYTES, true)) ||
+      seen.has(fields.key)
+    ) {
+      return undefined;
+    }
+    seen.add(fields.key);
+    result.push(
+      Object.freeze({
+        installed: fields.installed,
+        key: fields.key,
+        prior: Object.freeze([...prior] as string[]),
+      })
+    );
+  }
+  return Object.freeze(result);
+}
+
+function snapshotSlot(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, [
+    'id',
+    'aliases',
+    'domId',
+    'gamPath',
+    'formats',
+    'owner',
+    'outcome',
+    'targeting',
+    'targetingOwnership',
+    'committedArtifact',
+    'gptToken',
+  ]);
+  if (!fields) return undefined;
+  const aliases = uniqueStrings(fields.aliases, MAX_ALIASES);
+  const formatValues = exactArray(fields.formats, MAX_FORMATS);
+  const formats: Array<readonly [number, number]> = [];
+  if (!formatValues) return undefined;
+  for (const format of formatValues) {
+    const dimensions = exactArray(format, 2);
+    if (
+      !dimensions ||
+      dimensions.length !== 2 ||
+      !isU32(dimensions[0], false) ||
+      !isU32(dimensions[1], false) ||
+      dimensions[0] > 4096 ||
+      dimensions[1] > 4096
+    ) {
+      return undefined;
+    }
+    formats.push(Object.freeze([dimensions[0], dimensions[1]]));
+  }
+  const targeting = snapshotStringPairs(fields.targeting, MAX_TARGETING);
+  const targetingOwnership = snapshotTargetingOwnership(fields.targetingOwnership);
+  if (
+    !boundedString(fields.id) ||
+    !aliases ||
+    !boundedString(fields.domId) ||
+    !boundedString(fields.gamPath) ||
+    (fields.owner !== 'trusted_server' && fields.owner !== 'publisher') ||
+    !['accepted', 'no_bid', 'failed', 'cancelled'].includes(fields.outcome as string) ||
+    !targeting ||
+    !targetingOwnership ||
+    !['none', 'gpt_adm', 'aps'].includes(fields.committedArtifact as string) ||
+    (fields.gptToken !== null &&
+      (!boundedString(fields.gptToken) || !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(fields.gptToken)))
+  ) {
+    return undefined;
+  }
+  return freezeRecord({
+    id: fields.id,
+    aliases,
+    domId: fields.domId,
+    gamPath: fields.gamPath,
+    formats: Object.freeze(formats),
+    owner: fields.owner,
+    outcome: fields.outcome,
+    targeting,
+    targetingOwnership,
+    committedArtifact: fields.committedArtifact,
+    gptToken: fields.gptToken,
+  });
+}
+
+function snapshotAttempt(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, ['id', 'slotId', 'ordinal', 'state', 'reason']);
+  if (
+    !fields ||
+    typeof fields.id !== 'string' ||
+    !/^a1_[A-Za-z0-9_-]{22}$/.test(fields.id) ||
+    !boundedString(fields.slotId) ||
+    !isU32(fields.ordinal, false) ||
+    !['accepted', 'no_bid', 'failed', 'cancelled'].includes(fields.state as string) ||
+    (fields.state === 'accepted' || fields.state === 'no_bid'
+      ? fields.reason !== null
+      : !boundedString(fields.reason))
+  ) {
+    return undefined;
+  }
+  return freezeRecord({ ...fields });
+}
+
+function snapshotTombstone(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, ['kind', 'value', 'expiresAtMs', 'ordinal']);
+  if (
+    !fields ||
+    (fields.kind !== 'reservation' && fields.kind !== 'ticket') ||
+    typeof fields.value !== 'string' ||
+    (fields.kind === 'reservation'
+      ? !/^r1_[A-Za-z0-9_-]{22}$/.test(fields.value)
+      : !/^t1_[A-Za-z0-9_-]{22}$/.test(fields.value)) ||
+    !finiteNonnegative(fields.expiresAtMs) ||
+    !isU32(fields.ordinal, false)
+  ) {
+    return undefined;
+  }
+  return freezeRecord({ ...fields });
+}
+
+function snapshotArtifact(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, [
+    'slotId',
+    'kind',
+    'owner',
+    'token',
+    'hostPosition',
+    'hostPositionPriority',
+  ]);
+  if (
+    !fields ||
+    !boundedString(fields.slotId) ||
+    (fields.kind !== 'gpt_adm' && fields.kind !== 'aps') ||
+    (fields.owner !== 'trusted_server' && fields.owner !== 'publisher') ||
+    typeof fields.token !== 'string' ||
+    !/^r1_[A-Za-z0-9_-]{22}$/.test(fields.token) ||
+    (fields.hostPosition !== null && !boundedString(fields.hostPosition, MAX_STRING_BYTES, true)) ||
+    (fields.hostPositionPriority !== null &&
+      fields.hostPositionPriority !== '' &&
+      fields.hostPositionPriority !== 'important') ||
+    (fields.hostPosition === null) !== (fields.hostPositionPriority === null) ||
+    (fields.kind === 'gpt_adm' && fields.hostPosition !== null)
+  ) {
+    return undefined;
+  }
+  return freezeRecord({ ...fields });
+}
+
+function validParserValues(
+  sliceId: unknown,
+  values: readonly (readonly [string, string | number | boolean | null])[]
+): boolean {
+  const single = (
+    key: string,
+    validate: (value: string | number | boolean | null) => boolean
+  ): boolean => values.length === 1 && values[0]?.[0] === key && validate(values[0][1]);
+  const integer = (value: string | number | boolean | null): value is number =>
+    typeof value === 'number' && Number.isInteger(value) && value >= 0;
+  switch (sliceId) {
+    case 'render_owner_initial':
+    case 'aps_initial':
+    case 'prebid_initial':
+      return single('protocol_version', (value) => value === 1);
+    case 'gpt_initial':
+      return (
+        values.length === 2 &&
+        values[0]?.[0] === 'gam' &&
+        typeof values[0][1] === 'boolean' &&
+        values[1]?.[0] === 'v' &&
+        values[1][1] === 1
+      );
+    case 'creative_initial':
+      return single('guard_count', (value) => integer(value) && value >= 1 && value <= 3);
+    case 'datadome_initial':
+      return single('route_guard', (value) => value === 'datadome');
+    case 'didomi_initial':
+      return single('sdk_path', (value) => typeof value === 'string' && value.length > 0);
+    case 'google_tag_manager_initial':
+      return single('route_guard', (value) => value === 'google_tag_manager');
+    case 'lockr_initial':
+      return (
+        values[0]?.[0] === 'route_guard' &&
+        values[0][1] === 'lockr' &&
+        (values.length === 1 ||
+          (values.length === 2 &&
+            (values[1]?.[0] === 'sdk_host'
+              ? typeof values[1][1] === 'string' && values[1][1].length > 0
+              : values[1]?.[0] === 'readiness_timeout' && values[1][1] === 50)))
+      );
+    case 'osano_initial':
+      return values.length === 0 || single('consent_snapshot', integer);
+    case 'permutive_initial':
+      return (
+        values.length === 0 ||
+        single('sdk_config', (value) => typeof value === 'string' && value.length > 0) ||
+        single('readiness_timeout', (value) => value === 50)
+      );
+    case 'sourcepoint_initial':
+      return single('gpp_snapshot', integer);
+    case 'testlight_initial':
+      return single('callback_count', integer);
+    default:
+      return false;
+  }
+}
+
+function snapshotParserState(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, ['sliceId', 'observations', 'values']);
+  const observations = uniqueStrings(fields?.observations, 256);
+  const entries = exactArray(fields?.values, 256);
+  if (
+    !fields ||
+    typeof fields.sliceId !== 'string' ||
+    fields.sliceId === 'first_display' ||
+    !FIRST_DISPLAY_ORDER.has(fields.sliceId as FirstDisplaySliceId) ||
+    !observations ||
+    !entries ||
+    observations.length !== entries.length
+  ) {
+    return undefined;
+  }
+  const seen = new Set<string>();
+  const values: Array<readonly [string, string | number | boolean | null]> = [];
+  for (const entry of entries) {
+    const pair = exactArray(entry, 2);
+    if (
+      !pair ||
+      pair.length !== 2 ||
+      !boundedString(pair[0], MAX_PROPERTY_BYTES) ||
+      pair[0] !== observations[values.length] ||
+      seen.has(pair[0])
+    ) {
+      return undefined;
+    }
+    const scalar = pair[1];
+    if (
+      scalar !== null &&
+      typeof scalar !== 'string' &&
+      typeof scalar !== 'boolean' &&
+      !(typeof scalar === 'number' && Number.isFinite(scalar))
+    ) {
+      return undefined;
+    }
+    if (typeof scalar === 'string' && !boundedString(scalar, MAX_STRING_BYTES, true))
+      return undefined;
+    seen.add(pair[0]);
+    values.push(Object.freeze([pair[0], scalar]));
+  }
+  if (!validParserValues(fields.sliceId, values)) return undefined;
+  return freezeRecord({
+    sliceId: fields.sliceId,
+    observations,
+    values: Object.freeze(values),
+  });
+}
+
+function snapshotTiming(value: unknown): Readonly<Record<string, number | null>> | undefined {
+  const fields = exactRecord(value, ['bidsScriptMs', 'firstDisplayMs', 'terminalMs', 'paintMs']);
+  if (!fields) return undefined;
+  for (const key of ['bidsScriptMs', 'terminalMs', 'paintMs'] as const) {
+    if (!finiteNonnegative(fields[key])) return undefined;
+  }
+  if (fields.firstDisplayMs !== null && !finiteNonnegative(fields.firstDisplayMs)) return undefined;
+  if (
+    (fields.bidsScriptMs as number) > (fields.terminalMs as number) ||
+    (fields.terminalMs as number) > (fields.paintMs as number) ||
+    (fields.firstDisplayMs !== null &&
+      ((fields.bidsScriptMs as number) > (fields.firstDisplayMs as number) ||
+        (fields.firstDisplayMs as number) > (fields.terminalMs as number)))
+  ) {
+    return undefined;
+  }
+  return freezeRecord({
+    bidsScriptMs: fields.bidsScriptMs as number,
+    firstDisplayMs: fields.firstDisplayMs as number | null,
+    terminalMs: fields.terminalMs as number,
+    paintMs: fields.paintMs as number,
+  });
+}
+
+function snapshotHighWater(value: unknown): Readonly<Record<string, number | string>> | undefined {
+  const fields = exactRecord(value, [
+    'navigationAttemptPrefix',
+    'nextNavigationAttemptOrdinal',
+    'nextAttemptOrdinal',
+    'nextSlotRegistrationOrdinal',
+    'reservationClockEpochMs',
+    'nextReservationOrdinal',
+    'nextTicketOrdinal',
+  ]);
+  if (
+    !fields ||
+    typeof fields.navigationAttemptPrefix !== 'string' ||
+    !/^[A-Za-z0-9_-]{11}$/.test(fields.navigationAttemptPrefix)
+  ) {
+    return undefined;
+  }
+  for (const key of [
+    'nextNavigationAttemptOrdinal',
+    'nextAttemptOrdinal',
+    'nextSlotRegistrationOrdinal',
+    'nextReservationOrdinal',
+    'nextTicketOrdinal',
+  ] as const) {
+    if (!isU32(fields[key], false)) return undefined;
+  }
+  if (!finiteNonnegative(fields.reservationClockEpochMs)) return undefined;
+  return freezeRecord({ ...fields }) as Readonly<Record<string, number | string>>;
+}
+
+const GPT_DIAGNOSTIC_EVENTS = Object.freeze([
+  'slotRequested',
+  'slotResponseReceived',
+  'slotRenderEnded',
+  'slotOnload',
+  'impressionViewable',
+  'slotVisibilityChanged',
+] as const);
+
+function snapshotCycle(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, [
+    'slotId',
+    'token',
+    'nextCycleOrdinal',
+    'unknownPriorCycle',
+    'records',
+    'quarantines',
+  ]);
+  const records = exactArray(fields?.records, 10);
+  const quarantines = uniqueStrings(fields?.quarantines, 10);
+  if (
+    !fields ||
+    !boundedString(fields.slotId) ||
+    !boundedString(fields.token) ||
+    !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(fields.token) ||
+    !isU32(fields.nextCycleOrdinal, false) ||
+    typeof fields.unknownPriorCycle !== 'boolean' ||
+    !records ||
+    !quarantines
+  ) {
+    return undefined;
+  }
+  const normalized: Array<Readonly<Record<string, unknown>>> = [];
+  let maximum = 0;
+  for (const record of records) {
+    const recordFields = exactRecord(record, ['ordinal', 'responseIdentifier', 'seen', 'state']);
+    const seen = uniqueStrings(recordFields?.seen, GPT_DIAGNOSTIC_EVENTS.length, (event) =>
+      GPT_DIAGNOSTIC_EVENTS.includes(event as (typeof GPT_DIAGNOSTIC_EVENTS)[number])
+    );
+    if (
+      !recordFields ||
+      !isU32(recordFields.ordinal, false) ||
+      (recordFields.responseIdentifier !== null &&
+        !boundedString(recordFields.responseIdentifier, 256)) ||
+      !seen ||
+      !seen.includes('slotRequested') ||
+      !['open', 'completed', 'retired'].includes(recordFields.state as string) ||
+      (recordFields.state === 'open' && seen.includes('slotRenderEnded')) ||
+      (recordFields.state === 'completed' && !seen.includes('slotRenderEnded')) ||
+      recordFields.ordinal <= maximum
+    ) {
+      return undefined;
+    }
+    maximum = Math.max(maximum, recordFields.ordinal);
+    normalized.push(freezeRecord({ ...recordFields, seen }));
+  }
+  if (fields.nextCycleOrdinal <= maximum) return undefined;
+  return freezeRecord({
+    slotId: fields.slotId,
+    token: fields.token,
+    nextCycleOrdinal: fields.nextCycleOrdinal,
+    unknownPriorCycle: fields.unknownPriorCycle,
+    records: Object.freeze(normalized),
+    quarantines,
+  });
+}
+
+function snapshotTrace(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  const fields = exactRecord(value, ['nextSequence', 'nextGlobalSlotOrdinal', 'slots']);
+  const slots = exactArray(fields?.slots, MAX_FIRST_DISPLAY_SLOTS);
+  if (
+    !fields ||
+    !isU32(fields.nextSequence, false) ||
+    !isU32(fields.nextGlobalSlotOrdinal, false) ||
+    !slots
+  ) {
+    return undefined;
+  }
+  const normalized: Array<Readonly<Record<string, unknown>>> = [];
+  for (const slot of slots) {
+    const slotFields = exactRecord(slot, ['slotId', 'impressions', 'bindings']);
+    const rawBindings = exactArray(slotFields?.bindings, 10);
+    if (
+      !slotFields ||
+      !boundedString(slotFields.slotId) ||
+      !isU32(slotFields.impressions) ||
+      !rawBindings
+    ) {
+      return undefined;
+    }
+    const bindings: Array<Readonly<Record<string, unknown>>> = [];
+    const compoundKeys = new Set<string>();
+    const historySequences = new Set<number>();
+    for (const binding of rawBindings) {
+      const bindingFields = exactRecord(binding, [
+        'atMs',
+        'cycleOrdinal',
+        'historySequence',
+        'state',
+        'token',
+      ]);
+      if (
+        !bindingFields ||
+        !finiteNonnegative(bindingFields.atMs) ||
+        !isU32(bindingFields.cycleOrdinal, false) ||
+        !isU32(bindingFields.historySequence, false) ||
+        bindingFields.state !== 'completed' ||
+        typeof bindingFields.token !== 'string' ||
+        !/^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(bindingFields.token)
+      ) {
+        return undefined;
+      }
+      const compoundKey = `${bindingFields.token}:${bindingFields.cycleOrdinal}`;
+      if (compoundKeys.has(compoundKey) || historySequences.has(bindingFields.historySequence)) {
+        return undefined;
+      }
+      compoundKeys.add(compoundKey);
+      historySequences.add(bindingFields.historySequence);
+      bindings.push(freezeRecord({ ...bindingFields }));
+    }
+    normalized.push(freezeRecord({ ...slotFields, bindings: Object.freeze(bindings) }));
+  }
+  return freezeRecord({
+    nextSequence: fields.nextSequence,
+    nextGlobalSlotOrdinal: fields.nextGlobalSlotOrdinal,
+    slots: Object.freeze(normalized),
+  });
+}
+
+const GPT_DIAGNOSTIC_DISPOSITIONS = Object.freeze(['matched', 'unmatched', 'ambiguous'] as const);
+const GPT_DIAGNOSTIC_ISSUES = Object.freeze([
+  'no_request_cycle',
+  'overlapping_request_cycles',
+  'unknown_prior_cycle',
+  'invalid_event_order',
+] as const);
+
+function snapshotGptFact(value: unknown): Readonly<FirstDisplayGptFactV1> | undefined {
+  const fields = exactRecord(value, [
+    'version',
+    'event',
+    'token',
+    'runtimeSlotNumber',
+    'cycleOrdinal',
+    'disposition',
+    'issueReason',
+    'capturedAtMs',
+    'elementId',
+    'adUnitPath',
+    'requestedSlotSizes',
+    'isEmpty',
+    'renderedSize',
+    'isBackfill',
+    'slotContentChanged',
+    'visibilityPercent',
+  ]);
+  if (!fields) return undefined;
+  const event = GPT_DIAGNOSTIC_EVENTS.includes(
+    fields.event as (typeof GPT_DIAGNOSTIC_EVENTS)[number]
+  )
+    ? (fields.event as FirstDisplayGptFactV1['event'])
+    : undefined;
+  const disposition = GPT_DIAGNOSTIC_DISPOSITIONS.includes(
+    fields.disposition as (typeof GPT_DIAGNOSTIC_DISPOSITIONS)[number]
+  )
+    ? (fields.disposition as FirstDisplayGptFactV1['disposition'])
+    : undefined;
+  const issueReason =
+    fields.issueReason === null ||
+    GPT_DIAGNOSTIC_ISSUES.includes(fields.issueReason as (typeof GPT_DIAGNOSTIC_ISSUES)[number])
+      ? (fields.issueReason as FirstDisplayGptFactV1['issueReason'])
+      : undefined;
+  const renderedSize = (() => {
+    const dimensions = exactArray(fields.renderedSize, 2);
+    if (
+      !dimensions ||
+      dimensions.length !== 2 ||
+      !dimensions.every(
+        (dimension) =>
+          typeof dimension === 'number' &&
+          Number.isInteger(dimension) &&
+          dimension >= 1 &&
+          dimension <= 4096
+      )
+    ) {
+      return undefined;
+    }
+    return Object.freeze([dimensions[0] as number, dimensions[1] as number] as const);
+  })();
+  const requestedSlotSizes = (() => {
+    if (fields.requestedSlotSizes === null) return null;
+    const values = exactArray(fields.requestedSlotSizes, 16);
+    if (!values || values.length === 0) return undefined;
+    const sizes: Array<readonly [number, number]> = [];
+    for (const value of values) {
+      const dimensions = exactArray(value, 2);
+      if (
+        !dimensions ||
+        dimensions.length !== 2 ||
+        !isU32(dimensions[0], false) ||
+        !isU32(dimensions[1], false) ||
+        dimensions[0] > 4096 ||
+        dimensions[1] > 4096
+      ) {
+        return undefined;
+      }
+      sizes.push(Object.freeze([dimensions[0], dimensions[1]]));
+    }
+    return Object.freeze(sizes);
+  })();
+  const tokenOrdinal =
+    typeof fields.token === 'string' && /^gt1_[1-9a-z][0-9a-z]{0,6}$/.test(fields.token)
+      ? Number.parseInt(fields.token.slice(4), 36)
+      : undefined;
+  if (
+    fields.version !== 1 ||
+    !event ||
+    tokenOrdinal === undefined ||
+    tokenOrdinal > MAX_U32 ||
+    !isU32(fields.runtimeSlotNumber, false) ||
+    fields.runtimeSlotNumber !== tokenOrdinal ||
+    (fields.cycleOrdinal !== null && !isU32(fields.cycleOrdinal, false)) ||
+    !disposition ||
+    issueReason === undefined ||
+    !finiteNonnegative(fields.capturedAtMs) ||
+    (fields.elementId !== null && !boundedString(fields.elementId, 256)) ||
+    (fields.adUnitPath !== null && !boundedString(fields.adUnitPath, 256)) ||
+    requestedSlotSizes === undefined ||
+    (requestedSlotSizes !== null && (event !== 'slotRequested' || disposition !== 'matched')) ||
+    (fields.isEmpty !== null && typeof fields.isEmpty !== 'boolean') ||
+    (fields.renderedSize !== null && !renderedSize) ||
+    (fields.isBackfill !== null && typeof fields.isBackfill !== 'boolean') ||
+    (fields.slotContentChanged !== null && typeof fields.slotContentChanged !== 'boolean') ||
+    (fields.visibilityPercent !== null &&
+      (typeof fields.visibilityPercent !== 'number' ||
+        !Number.isFinite(fields.visibilityPercent) ||
+        fields.visibilityPercent < 0 ||
+        fields.visibilityPercent > 100)) ||
+    (event !== 'slotRenderEnded' &&
+      (fields.isEmpty !== null ||
+        fields.renderedSize !== null ||
+        fields.isBackfill !== null ||
+        fields.slotContentChanged !== null)) ||
+    (event !== 'slotVisibilityChanged' && fields.visibilityPercent !== null) ||
+    (issueReason === 'invalid_event_order' && disposition !== 'matched') ||
+    (issueReason === 'overlapping_request_cycles' && disposition !== 'ambiguous') ||
+    ((issueReason === 'no_request_cycle' || issueReason === 'unknown_prior_cycle') &&
+      disposition !== 'unmatched') ||
+    (disposition === 'matched' && event !== 'slotVisibilityChanged' && fields.cycleOrdinal === null)
+  ) {
+    return undefined;
+  }
+  const result = Object.freeze({
+    version: 1 as const,
+    event,
+    token: fields.token as string,
+    runtimeSlotNumber: fields.runtimeSlotNumber,
+    cycleOrdinal: fields.cycleOrdinal as number | null,
+    disposition,
+    issueReason,
+    capturedAtMs: fields.capturedAtMs as number,
+    elementId: fields.elementId as string | null,
+    adUnitPath: fields.adUnitPath as string | null,
+    requestedSlotSizes,
+    isEmpty: fields.isEmpty as boolean | null,
+    renderedSize: fields.renderedSize === null ? null : renderedSize!,
+    isBackfill: fields.isBackfill as boolean | null,
+    slotContentChanged: fields.slotContentChanged as boolean | null,
+    visibilityPercent: fields.visibilityPercent as number | null,
+  });
+  const bytes = canonicalBytes(result);
+  return bytes !== undefined && bytes <= MAX_SINGLE_GPT_FACT_BYTES ? result : undefined;
+}
+
+function snapshotGptDiagnostics(
+  value: unknown
+): Readonly<FirstDisplayGptDiagnosticsV1> | undefined {
+  const fields = exactRecord(value, ['facts', 'overflowCount', 'dropCount']);
+  if (!fields) return undefined;
+  const values = exactArray(fields.facts, MAX_FACTS);
+  if (!values || !isU32(fields.overflowCount) || !isU32(fields.dropCount)) {
+    return undefined;
+  }
+  const facts: Array<Readonly<FirstDisplayGptFactV1>> = [];
+  for (const value of values) {
+    const fact = snapshotGptFact(value);
+    if (!fact) return undefined;
+    facts.push(fact);
+  }
+  const result = Object.freeze({
+    facts: Object.freeze(facts),
+    overflowCount: fields.overflowCount,
+    dropCount: fields.dropCount,
+  });
+  const bytes = canonicalBytes(result);
+  return bytes !== undefined && bytes <= MAX_GPT_FACT_BYTES ? result : undefined;
+}
+
+function snapshotList(
+  value: unknown,
+  maximum: number,
+  snapshot: (value: unknown) => Readonly<Record<string, unknown>> | undefined
+): readonly Readonly<Record<string, unknown>>[] | undefined {
+  const values = exactArray(value, maximum);
+  if (!values) return undefined;
+  const result: Array<Readonly<Record<string, unknown>>> = [];
+  for (const entry of values) {
+    const accepted = snapshot(entry);
+    if (!accepted) return undefined;
+    result.push(accepted);
+  }
+  return Object.freeze(result);
+}
+
+export function snapshotFirstDisplayHandoffV1(
+  candidate: unknown
+): FirstDisplayHandoffV1 | undefined {
+  try {
+    const fields = exactRecord(candidate, [
+      'version',
+      'releaseId',
+      'generation',
+      'projectionDigest',
+      'integrationConfigDigest',
+      'slices',
+      'slots',
+      'attempts',
+      'tombstones',
+      'artifacts',
+      'parserState',
+      'gptDiagnostics',
+      'timing',
+      'highWater',
+      'cycles',
+      'trace',
+      'mutationRevision',
+    ]);
+    if (!fields) return undefined;
+    const slices = snapshotSlices(fields.slices);
+    const slots = snapshotList(fields.slots, MAX_FIRST_DISPLAY_SLOTS, snapshotSlot);
+    const attempts = snapshotList(fields.attempts, MAX_FIRST_DISPLAY_SLOTS, snapshotAttempt);
+    const tombstones = snapshotList(fields.tombstones, 512, snapshotTombstone);
+    const artifacts = snapshotList(fields.artifacts, MAX_FIRST_DISPLAY_SLOTS, snapshotArtifact);
+    const parserState = snapshotList(
+      fields.parserState,
+      FIRST_DISPLAY_CONTRACT_IDS.length,
+      snapshotParserState
+    );
+    const gptDiagnostics = snapshotGptDiagnostics(fields.gptDiagnostics);
+    const timing = snapshotTiming(fields.timing);
+    const highWater = snapshotHighWater(fields.highWater);
+    const cycles = snapshotList(fields.cycles, MAX_FIRST_DISPLAY_SLOTS, snapshotCycle);
+    const trace = snapshotTrace(fields.trace);
+    if (
+      fields.version !== 1 ||
+      typeof fields.releaseId !== 'string' ||
+      !HASH.test(fields.releaseId) ||
+      !isU32(fields.generation, false) ||
+      typeof fields.projectionDigest !== 'string' ||
+      !HASH.test(fields.projectionDigest) ||
+      typeof fields.integrationConfigDigest !== 'string' ||
+      !HASH.test(fields.integrationConfigDigest) ||
+      !slices ||
+      !slots ||
+      !attempts ||
+      !tombstones ||
+      !artifacts ||
+      !parserState ||
+      !gptDiagnostics ||
+      !timing ||
+      !highWater ||
+      !cycles ||
+      !trace ||
+      !isU32(fields.mutationRevision)
+    ) {
+      return undefined;
+    }
+    const slotIds = new Set(slots.map((slot) => slot.id as string));
+    const attemptIds = new Set(attempts.map((attempt) => attempt.id as string));
+    const attemptOrdinals = new Set(attempts.map((attempt) => attempt.ordinal as number));
+    const attemptSlotIds = new Set(attempts.map((attempt) => attempt.slotId as string));
+    const tombstoneKeys = new Set(
+      tombstones.map((tombstone) => `${String(tombstone.kind)}:${String(tombstone.value)}`)
+    );
+    const tombstoneOrdinals = new Set(
+      tombstones.map((tombstone) => `${String(tombstone.kind)}:${String(tombstone.ordinal)}`)
+    );
+    if (
+      parserState.length !== slices.length - 1 ||
+      parserState.some((state, index) => state.sliceId !== slices[index + 1])
+    ) {
+      return undefined;
+    }
+    const cycleSlotIds = new Set(cycles.map((cycle) => cycle.slotId as string));
+    const artifactSlotIds = new Set(artifacts.map((artifact) => artifact.slotId as string));
+    const traceSlots = trace.slots as readonly Readonly<Record<string, unknown>>[];
+    const traceSlotIds = new Set(traceSlots.map((slot) => slot.slotId as string));
+    const slotById = new Map(slots.map((slot) => [slot.id as string, slot]));
+    const traceBySlot = new Map(traceSlots.map((slot) => [slot.slotId as string, slot]));
+    const artifactBySlot = new Map(
+      artifacts.map((artifact) => [artifact.slotId as string, artifact])
+    );
+    const cycleBySlot = new Map(cycles.map((cycle) => [cycle.slotId as string, cycle]));
+    if (
+      ((cycles.length > 0 ||
+        gptDiagnostics.facts.length > 0 ||
+        slots.some((slot) => slot.gptToken !== null)) &&
+        !slices.includes('gpt_initial')) ||
+      slotIds.size !== slots.length ||
+      attempts.length !== slots.length ||
+      attemptIds.size !== attempts.length ||
+      attemptOrdinals.size !== attempts.length ||
+      attemptSlotIds.size !== attempts.length ||
+      tombstoneKeys.size !== tombstones.length ||
+      tombstoneOrdinals.size !== tombstones.length ||
+      tombstones.some(
+        (tombstone) =>
+          (tombstone.expiresAtMs as number) <= (highWater.reservationClockEpochMs as number)
+      ) ||
+      cycleSlotIds.size !== cycles.length ||
+      artifactSlotIds.size !== artifacts.length ||
+      traceSlotIds.size !== traceSlots.length ||
+      traceSlots.length !== slots.length ||
+      traceSlots.some((traceSlot, index) => {
+        const slot = slots[index];
+        if (!slot || traceSlot.slotId !== slot.id) return true;
+        const accepted = slot.outcome === 'accepted';
+        const bindings = traceSlot.bindings as readonly Readonly<Record<string, unknown>>[];
+        return (
+          traceSlot.impressions !== (accepted ? 1 : 0) ||
+          (accepted
+            ? bindings.length !== 1 || bindings[0]?.token !== slot.gptToken
+            : bindings.length !== 0)
+        );
+      }) ||
+      attempts.some((attempt, index) => {
+        const slot = slots[index];
+        return (
+          !slot ||
+          attempt.slotId !== slot.id ||
+          attempt.state !== slot.outcome ||
+          attempt.ordinal !== index + 1 ||
+          !(attempt.id as string).startsWith(`a1_${highWater.navigationAttemptPrefix as string}`)
+        );
+      }) ||
+      slots.some((slot) => {
+        const artifact = artifactBySlot.get(slot.id as string);
+        const cycle = cycleBySlot.get(slot.id as string);
+        const targetingOwnership = slot.targetingOwnership as readonly Readonly<{
+          installed: string;
+          key: string;
+          prior: readonly string[];
+        }>[];
+        if (slot.outcome !== 'accepted') {
+          return (
+            slot.committedArtifact !== 'none' ||
+            slot.gptToken !== null ||
+            targetingOwnership.length !== 0 ||
+            artifact ||
+            cycle
+          );
+        }
+        const targeting = slot.targeting as readonly (readonly [string, string])[];
+        const reservation = targeting.find(([key]) => key === 'hb_adid')?.[1];
+        return (
+          slot.committedArtifact === 'none' ||
+          typeof slot.gptToken !== 'string' ||
+          !artifact ||
+          artifact.kind !== slot.committedArtifact ||
+          artifact.token !== reservation ||
+          !cycle ||
+          cycle.token !== slot.gptToken ||
+          (slot.owner !== 'publisher' && targetingOwnership.length !== 0) ||
+          targetingOwnership.some(
+            (ownership) =>
+              targeting.find(([key]) => key === ownership.key)?.[1] !== ownership.installed
+          )
+        );
+      }) ||
+      cycles.some((cycle) => {
+        const slot = slotById.get(cycle.slotId as string);
+        const traceSlot = traceBySlot.get(cycle.slotId as string);
+        const bindings = traceSlot?.bindings as
+          readonly Readonly<Record<string, unknown>>[] | undefined;
+        const cycleRecords = cycle.records as readonly Readonly<Record<string, unknown>>[];
+        return (
+          !slot ||
+          slot.gptToken !== cycle.token ||
+          !bindings ||
+          bindings.length !== 1 ||
+          bindings[0]?.token !== cycle.token ||
+          !cycleRecords.some(
+            (record) =>
+              record.ordinal === bindings[0]?.cycleOrdinal && record.state === bindings[0]?.state
+          )
+        );
+      })
+    ) {
+      return undefined;
+    }
+    const maximumGlobalSlotOrdinal = [
+      ...cycles.map((cycle) => Number.parseInt((cycle.token as string).slice(4), 36)),
+      ...gptDiagnostics.facts.map((fact) => fact.runtimeSlotNumber),
+    ].reduce((maximum, ordinal) => Math.max(maximum, ordinal), 0);
+    if ((trace.nextGlobalSlotOrdinal as number) <= maximumGlobalSlotOrdinal) return undefined;
+    const transferredImpressions = traceSlots.reduce(
+      (count, slot) => count + (slot.impressions as number),
+      0
+    );
+    const traceBindings = traceSlots.flatMap(
+      (slot) => slot.bindings as readonly Readonly<Record<string, unknown>>[]
+    );
+    const traceHistorySequences = new Set(
+      traceBindings.map((binding) => binding.historySequence as number)
+    );
+    const maximumTraceSequence = traceBindings.reduce(
+      (maximum, binding) => Math.max(maximum, binding.historySequence as number),
+      0
+    );
+    if (
+      traceBindings.length !== transferredImpressions ||
+      traceHistorySequences.size !== traceBindings.length ||
+      traceBindings.some(
+        (binding) =>
+          (binding.atMs as number) < (timing.bidsScriptMs as number) ||
+          (binding.atMs as number) > (timing.terminalMs as number)
+      ) ||
+      (trace.nextSequence as number) <= maximumTraceSequence
+    ) {
+      return undefined;
+    }
+    const maximumAttempt = attempts.reduce(
+      (maximum, attempt) => Math.max(maximum, attempt.ordinal as number),
+      0
+    );
+    const maximumReservation = tombstones.reduce(
+      (maximum, tombstone) =>
+        tombstone.kind === 'reservation' ? Math.max(maximum, tombstone.ordinal as number) : maximum,
+      0
+    );
+    const maximumTicket = tombstones.reduce(
+      (maximum, tombstone) =>
+        tombstone.kind === 'ticket' ? Math.max(maximum, tombstone.ordinal as number) : maximum,
+      0
+    );
+    if (
+      (highWater.nextNavigationAttemptOrdinal as number) <= maximumAttempt ||
+      (highWater.nextAttemptOrdinal as number) <= maximumAttempt ||
+      (highWater.nextSlotRegistrationOrdinal as number) <= slots.length ||
+      (highWater.nextReservationOrdinal as number) <= maximumReservation ||
+      (highWater.nextTicketOrdinal as number) <= maximumTicket
+    ) {
+      return undefined;
+    }
+    const result = Object.freeze({
+      version: 1 as const,
+      releaseId: fields.releaseId,
+      generation: fields.generation,
+      projectionDigest: fields.projectionDigest,
+      integrationConfigDigest: fields.integrationConfigDigest,
+      slices,
+      slots,
+      attempts,
+      tombstones,
+      artifacts,
+      parserState,
+      gptDiagnostics,
+      timing,
+      highWater,
+      cycles,
+      trace,
+      mutationRevision: fields.mutationRevision,
+    });
+    const factBytes = canonicalBytes(gptDiagnostics);
+    const nonDiagnostics = Object.freeze({
+      ...result,
+      gptDiagnostics: Object.freeze({
+        facts: Object.freeze([]),
+        overflowCount: 0,
+        dropCount: 0,
+      }),
+    });
+    const nonDiagnosticsBytes = canonicalBytes(nonDiagnostics);
+    const totalBytes = canonicalBytes(result);
+    if (
+      factBytes === undefined ||
+      nonDiagnosticsBytes === undefined ||
+      totalBytes === undefined ||
+      factBytes > MAX_GPT_FACT_BYTES ||
+      nonDiagnosticsBytes > MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES ||
+      totalBytes > MAX_FIRST_DISPLAY_HANDOFF_BYTES
+    ) {
+      return undefined;
+    }
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Validate one complete handoff against the server-authored takeover outline. */
+export function snapshotOutlinedFirstDisplayHandoffV1(
+  candidate: unknown,
+  outlineCandidate: unknown
+): FirstDisplayHandoffV1 | undefined {
+  const handoff = snapshotFirstDisplayHandoffV1(candidate);
+  const outline = snapshotTakeoverOutlineV1(outlineCandidate);
+  const requiredObjectKinds = [
+    ...(handoff?.cycles.length === 0 ? [] : (['gpt_slot'] as const)),
+    ...(handoff?.artifacts.length === 0 ? [] : (['dom_artifact'] as const)),
+  ];
+  if (
+    !handoff ||
+    !outline ||
+    outline.releaseId !== handoff.releaseId ||
+    outline.generation !== handoff.generation ||
+    outline.projectionDigest !== handoff.projectionDigest ||
+    outline.integrationConfigDigest !== handoff.integrationConfigDigest ||
+    outline.slotCount !== handoff.slots.length ||
+    outline.outcomeCount !== handoff.slots.length ||
+    outline.slices.length !== handoff.slices.length ||
+    outline.slices.some((id, index) => id !== handoff.slices[index]) ||
+    requiredObjectKinds.some((kind) => !outline.objectKinds.includes(kind))
+  ) {
+    return undefined;
+  }
+  return handoff;
+}
+
+/**
+ * Expand the compact old-owner capture after the persistent bundle is available,
+ * then run the unchanged canonical handoff validator before either owner detaches.
+ */
+export function snapshotOutlinedFirstDisplayCaptureV1(
+  candidate: unknown,
+  outlineCandidate: unknown,
+  bootCandidate: unknown,
+  identityIssuer?: Readonly<{
+    mintAttemptId: () => Readonly<{ ok: boolean; value?: string }>;
+    snapshotPrefix: () => string;
+  }>
+): FirstDisplayHandoffV1 | undefined {
+  try {
+    const capture = exactRecord(candidate, [
+      'captureVersion',
+      'releaseId',
+      'generation',
+      'data',
+      'mutationRevision',
+      'identityCount',
+    ]);
+    const data = exactArray(capture?.data, 14);
+    const boot = exactRecord(bootCandidate, [
+      'abi',
+      'releaseId',
+      'manifest',
+      'auctionProjection',
+      'integrations',
+      'creative',
+      'diagnostics',
+    ]);
+    const projection = exactRecord(boot?.auctionProjection, [
+      'version',
+      'auction',
+      'slots',
+      'bids',
+    ]);
+    const auction = exactRecord(projection?.auction, ['version', 'auctionId', 'results']);
+    const placements = exactArray(projection?.slots, MAX_FIRST_DISPLAY_SLOTS);
+    const bids = exactArray(projection?.bids, MAX_FIRST_DISPLAY_SLOTS);
+    const decisions = exactArray(auction?.results, MAX_FIRST_DISPLAY_SLOTS);
+    const results = exactArray(data?.[3], MAX_FIRST_DISPLAY_SLOTS);
+    const bindings = exactArray(data?.[4], MAX_FIRST_DISPLAY_SLOTS);
+    const rawTombstones = exactArray(data?.[5], 512);
+    const rawArtifacts = exactArray(data?.[6], MAX_FIRST_DISPLAY_SLOTS);
+    const rawParserState = exactArray(data?.[7], FIRST_DISPLAY_CONTRACT_IDS.length);
+    const diagnostics = exactArray(data?.[8], 3);
+    const timing = exactArray(data?.[9], 4);
+    const highWater = exactArray(data?.[10], 4);
+    const cycles = exactArray(data?.[11], MAX_FIRST_DISPLAY_SLOTS);
+    if (
+      !capture ||
+      capture.captureVersion !== 1 ||
+      !data ||
+      data.length !== 14 ||
+      !boot ||
+      boot.abi !== 1 ||
+      !projection ||
+      projection.version !== 1 ||
+      !auction ||
+      auction.version !== 1 ||
+      !placements ||
+      !bids ||
+      !decisions ||
+      !results ||
+      results.length !== placements.length ||
+      decisions.length !== placements.length ||
+      !bindings ||
+      !rawTombstones ||
+      !rawArtifacts ||
+      !rawParserState ||
+      !diagnostics ||
+      diagnostics.length !== 3 ||
+      !timing ||
+      timing.length !== 4 ||
+      !highWater ||
+      highWater.length !== 4 ||
+      !cycles ||
+      !Number.isInteger(capture.identityCount) ||
+      !identityIssuer
+    ) {
+      return undefined;
+    }
+    const bidBySlot = new Map<string, Readonly<Record<string, unknown>>>();
+    for (const value of bids) {
+      const bid = exactRecord(
+        value,
+        Object.prototype.hasOwnProperty.call(value, 'creativeId')
+          ? [
+              'candidateId',
+              'slot',
+              'provider',
+              'upstreamBidId',
+              'cpm',
+              'currency',
+              'targeting',
+              'rendererReservationId',
+              'renderSource',
+              'creativeId',
+            ]
+          : [
+              'candidateId',
+              'slot',
+              'provider',
+              'upstreamBidId',
+              'cpm',
+              'currency',
+              'targeting',
+              'rendererReservationId',
+              'renderSource',
+            ]
+      );
+      if (!bid || typeof bid.slot !== 'string' || bidBySlot.has(bid.slot)) return undefined;
+      bidBySlot.set(bid.slot, bid);
+    }
+    const bindingBySlot = new Map<string, Readonly<Record<string, unknown>>>();
+    for (const value of bindings) {
+      const fields = exactArray(value, 5);
+      if (!fields || fields.length !== 5 || typeof fields[0] !== 'string') return undefined;
+      const binding = {
+        slotId: fields[0],
+        domId: fields[1],
+        owner: fields[2],
+        targetingOwnership: fields[3],
+        gptToken: fields[4],
+      };
+      if (bindingBySlot.has(binding.slotId)) {
+        return undefined;
+      }
+      bindingBySlot.set(binding.slotId, binding);
+    }
+    const tombstones: Readonly<Record<string, unknown>>[] = [];
+    for (const value of rawTombstones) {
+      const fields = exactArray(value, 4);
+      if (!fields || fields.length !== 4) return undefined;
+      tombstones.push({
+        kind: fields[0],
+        value: fields[1],
+        expiresAtMs: fields[2],
+        ordinal: fields[3],
+      });
+    }
+    const artifacts: Readonly<Record<string, unknown>>[] = [];
+    for (const value of rawArtifacts) {
+      const fields = exactArray(value, 6);
+      if (!fields || fields.length !== 6) return undefined;
+      artifacts.push({
+        hostPosition: fields[0],
+        hostPositionPriority: fields[1],
+        slotId: fields[2],
+        kind: fields[3],
+        owner: fields[4],
+        token: fields[5],
+      });
+    }
+    const parserState: Readonly<Record<string, unknown>>[] = [];
+    for (const value of rawParserState) {
+      const fields = exactArray(value, 2);
+      const values = exactArray(fields?.[1], 256);
+      if (!fields || fields.length !== 2 || !values) return undefined;
+      const observations: unknown[] = [];
+      for (const value of values) {
+        const pair = exactArray(value, 2);
+        if (!pair || pair.length !== 2) return undefined;
+        observations.push(pair[0]);
+      }
+      parserState.push({ sliceId: fields[0], observations, values });
+    }
+    let acceptedBindings = 0;
+    const slots: Readonly<Record<string, unknown>>[] = [];
+    const attempts: Readonly<Record<string, unknown>>[] = [];
+    const traceSlots: Readonly<Record<string, unknown>>[] = [];
+    for (let index = 0; index < placements.length; index += 1) {
+      const placement = exactRecord(placements[index], [
+        'slot',
+        'gamUnitPath',
+        'divId',
+        'formats',
+        'targeting',
+      ]);
+      const decision = exactRecord(
+        decisions[index],
+        Object.prototype.hasOwnProperty.call(decisions[index], 'candidateId')
+          ? ['slot', 'outcome', 'candidateId']
+          : Object.prototype.hasOwnProperty.call(decisions[index], 'reason')
+            ? ['slot', 'outcome', 'reason']
+            : ['slot', 'outcome']
+      );
+      const result = exactArray(results[index], 4);
+      const slotId = placement?.slot;
+      if (
+        !placement ||
+        typeof slotId !== 'string' ||
+        !decision ||
+        decision.slot !== slotId ||
+        !result ||
+        result.length !== 4
+      ) {
+        return undefined;
+      }
+      const bid = bidBySlot.get(slotId);
+      const renderSource = bid?.renderSource as Readonly<Record<string, unknown>> | undefined;
+      const projectedKind =
+        decision.outcome === 'no_bid'
+          ? 'no_bid'
+          : decision.outcome === 'failed'
+            ? 'failed'
+            : renderSource?.type === 'aps'
+              ? 'aps'
+              : renderSource?.type === 'adm'
+                ? 'gpt_adm'
+                : undefined;
+      if (!projectedKind) return undefined;
+      const binding = bindingBySlot.get(slotId);
+      const accepted = result[0] === 'accepted';
+      if (accepted !== Boolean(binding) || (accepted && !bid)) return undefined;
+      if (!accepted && (result[2] !== null || result[3] !== null)) return undefined;
+      if (binding) acceptedBindings += 1;
+      const identity = identityIssuer.mintAttemptId();
+      if (!identity.ok || typeof identity.value !== 'string') return undefined;
+      attempts.push({
+        id: identity.value,
+        slotId,
+        ordinal: index + 1,
+        state: result[0],
+        reason: result[1],
+      });
+      const targeting = {
+        ...(placement.targeting as Record<string, string>),
+        ...(bid?.targeting as Record<string, string> | undefined),
+      };
+      if (bid) targeting['hb_adid'] = bid.rendererReservationId as string;
+      slots.push({
+        id: slotId,
+        aliases: [],
+        domId: binding?.domId ?? placement.divId,
+        gamPath: placement.gamUnitPath,
+        formats: placement.formats,
+        owner: binding?.owner ?? 'trusted_server',
+        outcome: result[0],
+        targeting: Object.keys(targeting)
+          .sort()
+          .map((key) => [key, targeting[key]]),
+        targetingOwnership: binding?.targetingOwnership ?? [],
+        committedArtifact:
+          accepted && (projectedKind === 'gpt_adm' || projectedKind === 'aps')
+            ? projectedKind
+            : 'none',
+        gptToken: binding?.gptToken ?? null,
+      });
+      traceSlots.push({
+        slotId,
+        impressions: accepted ? 1 : 0,
+        bindings: accepted
+          ? [
+              {
+                atMs: result[2],
+                cycleOrdinal: 1,
+                historySequence: result[3],
+                state: 'completed',
+                token: binding?.gptToken,
+              },
+            ]
+          : [],
+      });
+    }
+    if (bindingBySlot.size !== acceptedBindings) return undefined;
+    const expanded = {
+      version: 1,
+      releaseId: capture.releaseId,
+      generation: capture.generation,
+      projectionDigest: data[0],
+      integrationConfigDigest: data[1],
+      slices: data[2],
+      slots,
+      attempts,
+      tombstones,
+      artifacts,
+      parserState,
+      gptDiagnostics: {
+        facts: diagnostics[0],
+        overflowCount: diagnostics[1],
+        dropCount: diagnostics[2],
+      },
+      timing: {
+        bidsScriptMs: timing[0],
+        firstDisplayMs: timing[1],
+        terminalMs: timing[2],
+        paintMs: timing[3],
+      },
+      highWater: {
+        navigationAttemptPrefix: identityIssuer.snapshotPrefix(),
+        nextNavigationAttemptOrdinal: attempts.length + 1,
+        nextAttemptOrdinal: attempts.length + 1,
+        nextSlotRegistrationOrdinal: highWater[0],
+        reservationClockEpochMs: highWater[1],
+        nextReservationOrdinal: highWater[2],
+        nextTicketOrdinal: highWater[3],
+      },
+      cycles,
+      trace: {
+        nextSequence: data[12],
+        nextGlobalSlotOrdinal: data[13],
+        slots: traceSlots,
+      },
+      mutationRevision: capture.mutationRevision,
+    };
+    const accepted = snapshotOutlinedFirstDisplayHandoffV1(expanded, outlineCandidate);
+    return accepted && capture.identityCount === accepted.cycles.length + accepted.artifacts.length
+      ? accepted
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Mint a closure-private, release/generation-bound one-use object-identity capsule. */
+export function createFirstDisplayOwnershipCapsuleV1<T extends object>(
+  releaseId: string,
+  generation: number,
+  identities: readonly T[]
+): FirstDisplayOwnershipCapsuleV1<T> | undefined {
+  if (
+    !HASH.test(releaseId) ||
+    !isU32(generation, false) ||
+    identities.length > MAX_FIRST_DISPLAY_SLOTS * 2
+  ) {
+    return undefined;
+  }
+  const accepted = [...identities];
+  if (
+    accepted.some((identity) => typeof identity !== 'object' || identity === null) ||
+    new Set(accepted).size !== accepted.length
+  )
+    return undefined;
+  let live: T[] | undefined = accepted;
+  return Object.freeze({
+    releaseId,
+    generation,
+    consume: (candidateReleaseId: string, candidateGeneration: number) => {
+      if (!live || candidateReleaseId !== releaseId || candidateGeneration !== generation) {
+        return undefined;
+      }
+      const result = Object.freeze(live);
+      live = undefined;
+      return result;
+    },
+    clear: () => {
+      live = undefined;
+    },
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/shared/first_display_handoff.ts b/crates/trusted-server-js/lib/src/shared/first_display_handoff.ts
new file mode 100644
index 000000000..24f98367b
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/first_display_handoff.ts
@@ -0,0 +1,498 @@
+import type { BootFailureReason } from '../kernel/fallback_surface';
+import type { PreparedKernelTakeover } from '../kernel/integration_registry';
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+import type { FirstDisplayRenderCaptureV1 } from '../first_display/driver';
+import type {
+  FirstDisplayGptCaptureCycleV1,
+  FirstDisplayGptDiagnosticsCaptureV1,
+} from '../first_display/leaf/gpt_protocol';
+import type { FirstDisplayProjectedKind } from '../first_display/leaf/projection';
+
+import type {
+  FirstDisplayHandoffV1,
+  FirstDisplayOwnershipCapsuleV1,
+} from './first_display_contracts';
+
+const HASH = /^[0-9a-f]{64}$/;
+const MAX_U32 = 4_294_967_295;
+/** Seal inert ordinary data before the runtime download; semantic authority stays at takeover. */
+export function snapshotFirstDisplayHandoffEnvelopeV1(
+  candidate: unknown
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const serialized = JSON.stringify(candidate);
+    if (typeof serialized !== 'string' || serialized.length > 9 * 1024 * 1024) return undefined;
+    const handoff = JSON.parse(serialized) as Record<string, unknown>;
+    return handoff &&
+      !Array.isArray(handoff) &&
+      handoff['captureVersion'] === 1 &&
+      typeof handoff['releaseId'] === 'string' &&
+      HASH.test(handoff['releaseId']) &&
+      Number.isInteger(handoff['generation']) &&
+      (handoff['generation'] as number) >= 1 &&
+      (handoff['generation'] as number) <= MAX_U32 &&
+      Number.isInteger(handoff['mutationRevision']) &&
+      (handoff['mutationRevision'] as number) >= 0 &&
+      (handoff['mutationRevision'] as number) <= MAX_U32 &&
+      Number.isInteger(handoff['identityCount']) &&
+      (handoff['identityCount'] as number) >= 0 &&
+      (handoff['identityCount'] as number) <= 512
+      ? Object.freeze(handoff)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export type FirstDisplayHandoffOwnerState =
+  'observing' | 'sealing' | 'finalized' | 'failed' | 'disposed';
+
+export interface FirstDisplayHandoffOwnerOptions {
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly initialMutationRevision?: number;
+  readonly isCurrentGeneration: () => boolean;
+  readonly isTerminal: () => boolean;
+  readonly isPainted: () => boolean;
+  /** Closes all old-epoch work ingress synchronously before the final snapshot. */
+  readonly closeIngress: () => void;
+  readonly onFailure: (reason: BootFailureReason) => void;
+}
+
+export interface FinalizedFirstDisplayHandoffV1 {
+  readonly handoff: Readonly<Record<string, unknown>>;
+  readonly capsule: FirstDisplayOwnershipCapsuleV1<object>;
+}
+
+export interface FirstDisplayHandoffOwner {
+  readonly state: FirstDisplayHandoffOwnerState;
+  readonly mutationRevision: number;
+  readonly observeMutation: () => boolean;
+  readonly finalize: (
+    capture: () => Readonly<{ candidate: unknown; identities: readonly object[] }> | undefined
+  ) => FinalizedFirstDisplayHandoffV1 | undefined;
+  readonly dispose: () => void;
+}
+
+export interface FirstDisplayTakeoverOptions {
+  readonly finalized: FinalizedFirstDisplayHandoffV1;
+  readonly outline: unknown;
+  readonly boot?: unknown;
+  readonly isCurrentGeneration: () => boolean;
+  readonly authenticateRuntimeScript: () => boolean;
+  readonly currentMutationRevision: () => number;
+  readonly quiesceAgent: () => void;
+  readonly detachCommittedArtifacts: () => void;
+  readonly disposeAgent: () => void;
+  /** Persistent-core validator; executes before either owner mutates state. */
+  readonly validateHandoff: (
+    handoff: unknown,
+    outline: unknown,
+    boot?: unknown
+  ) => FirstDisplayHandoffV1 | undefined;
+  readonly activatePersistent: (
+    handoff: FirstDisplayHandoffV1,
+    identities: readonly object[],
+    own: (dispose: () => void) => void
+  ) => void;
+  readonly commitPersistent: () => void;
+  readonly onFailure: (reason: BootFailureReason) => void;
+}
+
+export interface PreparedFirstDisplayTakeoverOptions extends Omit<
+  FirstDisplayTakeoverOptions,
+  'activatePersistent' | 'commitPersistent' | 'validateHandoff'
+> {
+  readonly prepared: PreparedKernelTakeover;
+}
+
+/** Stack-local old-owner state accepted only by the release-matched persistent finalizer. */
+export type FirstDisplayAgentCaptureSourceV1 = readonly [
+  handoff: Readonly<{
+    releaseId: string;
+    generation: number;
+    integrationConfigDigest: string;
+    slices: readonly FirstDisplaySliceId[];
+  }>,
+  batch: readonly [
+    projectionDigest: string,
+    outcomes: readonly (readonly [slotId: string, kind: FirstDisplayProjectedKind])[],
+  ],
+  slotResults: ReadonlyMap<string, string>,
+  reasons: ReadonlyMap<string, string | null>,
+  acceptedTrace: ReadonlyMap<string, Readonly<{ atMs: number; historySequence: number }>>,
+  parserState: readonly (readonly [
+    string,
+    readonly (readonly [string, string | number | boolean | null])[],
+  ])[],
+  gptCycles: readonly FirstDisplayGptCaptureCycleV1[] | undefined,
+  diagnostics: FirstDisplayGptDiagnosticsCaptureV1 | undefined,
+  render: FirstDisplayRenderCaptureV1 | undefined,
+  timing: readonly [
+    startedAtMs: number,
+    firstActionAtMs: number | null,
+    terminalAtMs: number,
+    paintAtMs: number,
+    currentTimeMs: number,
+  ],
+  nextTraceSequence: number,
+  mutationRevision: number,
+];
+
+export type FirstDisplayAgentCaptureFinalizerV1 = (
+  source: FirstDisplayAgentCaptureSourceV1
+) => FinalizedFirstDisplayHandoffV1 | undefined;
+
+export function createFirstDisplayOwnershipCapsuleV1<T extends object>(
+  releaseId: string,
+  generation: number,
+  identities: readonly T[]
+): FirstDisplayOwnershipCapsuleV1<T> | undefined {
+  if (
+    !HASH.test(releaseId) ||
+    !Number.isInteger(generation) ||
+    generation < 1 ||
+    generation > MAX_U32 ||
+    identities.length > 512
+  ) {
+    return undefined;
+  }
+  const accepted = [...identities];
+  if (
+    accepted.some((identity) => typeof identity !== 'object' || identity === null) ||
+    new Set(accepted).size !== accepted.length
+  ) {
+    return undefined;
+  }
+  let live: T[] | undefined = accepted;
+  return Object.freeze({
+    releaseId,
+    generation,
+    consume: (candidateReleaseId: string, candidateGeneration: number) => {
+      if (!live || candidateReleaseId !== releaseId || candidateGeneration !== generation) {
+        return undefined;
+      }
+      const result = Object.freeze(live);
+      live = undefined;
+      return result;
+    },
+    clear: () => {
+      live = undefined;
+    },
+  });
+}
+
+/** Materialize the compact data envelope and one-use identities in the takeover task. */
+export function finalizeFirstDisplayAgentCaptureV1(
+  source: FirstDisplayAgentCaptureSourceV1
+): FinalizedFirstDisplayHandoffV1 | undefined {
+  try {
+    const [
+      handoffSource,
+      batch,
+      slotResults,
+      reasons,
+      acceptedTrace,
+      parserState,
+      gptCycles,
+      diagnosticsSource,
+      renderSource,
+      timing,
+      nextTraceSequence,
+      mutationRevision,
+    ] = source;
+    const cycles = gptCycles ?? Object.freeze([]);
+    const diagnostics =
+      diagnosticsSource ?? Object.freeze([Object.freeze([]), Object.freeze([]), 1, 0, 0] as const);
+    const render =
+      renderSource ??
+      Object.freeze([Object.freeze([]), Object.freeze([]), timing[4], 1, 1] as const);
+    if (
+      diagnostics[0].length !== cycles.length ||
+      diagnostics[0].some((cycle) => {
+        const physical = cycles.find((candidate) => candidate[0] === cycle[0]);
+        return !physical || physical[4] !== cycle[1];
+      })
+    ) {
+      return undefined;
+    }
+    const identities = [
+      ...cycles.map((cycle) => cycle[5]),
+      ...render[0].map((artifact) => artifact[2]),
+    ];
+    const capsule = createFirstDisplayOwnershipCapsuleV1(
+      handoffSource.releaseId,
+      handoffSource.generation,
+      identities
+    );
+    if (!capsule) return undefined;
+    const results = batch[1].map(([slotId]) => {
+      const accepted = acceptedTrace.get(slotId);
+      return [
+        slotResults.get(slotId) ?? 'failed',
+        reasons.get(slotId) ?? null,
+        accepted?.atMs ?? null,
+        accepted?.historySequence ?? null,
+      ];
+    });
+    const handoff = Object.freeze({
+      captureVersion: 1,
+      releaseId: handoffSource.releaseId,
+      generation: handoffSource.generation,
+      data: [
+        batch[0],
+        handoffSource.integrationConfigDigest,
+        handoffSource.slices,
+        results,
+        cycles.map((cycle) => cycle.slice(0, 5)),
+        render[1],
+        render[0].map((artifact) => [
+          artifact[0],
+          artifact[1],
+          artifact[5],
+          artifact[3],
+          artifact[4],
+          artifact[6],
+        ]),
+        parserState,
+        [diagnostics[1], diagnostics[3], diagnostics[4]],
+        timing.slice(0, 4),
+        [results.length + 1, render[2], render[3], render[4]],
+        diagnostics[0].map((cycle) => ({
+          slotId: cycle[0],
+          token: cycle[1],
+          nextCycleOrdinal: cycle[2],
+          unknownPriorCycle: cycle[3],
+          quarantines: cycle[4],
+          records: cycle[5].map((record) => ({
+            ordinal: record[0],
+            responseIdentifier: record[1],
+            seen: record[2],
+            state: record[3],
+          })),
+        })),
+        nextTraceSequence,
+        diagnostics[2],
+      ],
+      mutationRevision,
+      identityCount: identities.length,
+    });
+    return Object.freeze({ handoff, capsule });
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Own the final old-epoch revision and one-use object capsule. `finalize` is
+ * deliberately synchronous: after ingress closes, no browser task can interleave
+ * before the immutable snapshot and capsule are bound to the same revision.
+ */
+export function createFirstDisplayHandoffOwner(
+  options: FirstDisplayHandoffOwnerOptions
+): FirstDisplayHandoffOwner {
+  let state: FirstDisplayHandoffOwnerState = 'observing';
+  let revision = options.initialMutationRevision ?? 0;
+  let liveCapsule: FirstDisplayOwnershipCapsuleV1<object> | undefined;
+  let failurePublished = false;
+
+  const publishFailure = (): undefined => {
+    liveCapsule?.clear();
+    liveCapsule = undefined;
+    state = 'failed';
+    if (!failurePublished) {
+      failurePublished = true;
+      try {
+        options.onFailure('bundle_partial');
+      } catch {
+        // Failure reporting cannot preserve transferable object authority.
+      }
+    }
+    return undefined;
+  };
+
+  if (
+    !HASH.test(options.releaseId) ||
+    !Number.isInteger(options.generation) ||
+    options.generation < 1 ||
+    options.generation > MAX_U32 ||
+    !Number.isInteger(revision) ||
+    revision < 0 ||
+    revision > MAX_U32
+  ) {
+    publishFailure();
+  }
+
+  return Object.freeze({
+    get state() {
+      return state;
+    },
+    get mutationRevision() {
+      return revision;
+    },
+    observeMutation: (): boolean => {
+      if (state !== 'observing' && state !== 'sealing') return false;
+      if (revision >= MAX_U32) {
+        publishFailure();
+        return false;
+      }
+      revision += 1;
+      return true;
+    },
+    finalize: (
+      capture: () => Readonly<{ candidate: unknown; identities: readonly object[] }> | undefined
+    ): FinalizedFirstDisplayHandoffV1 | undefined => {
+      if (state !== 'observing') return publishFailure();
+      try {
+        if (
+          typeof capture !== 'function' ||
+          !options.isCurrentGeneration() ||
+          !options.isTerminal() ||
+          !options.isPainted()
+        ) {
+          return publishFailure();
+        }
+        state = 'sealing';
+        options.closeIngress();
+        const captured = capture();
+        if (!captured) return publishFailure();
+        const handoff = snapshotFirstDisplayHandoffEnvelopeV1(captured.candidate);
+        if (
+          !handoff ||
+          handoff['releaseId'] !== options.releaseId ||
+          handoff['generation'] !== options.generation ||
+          handoff['mutationRevision'] !== revision ||
+          captured.identities.length !== handoff['identityCount'] ||
+          new Set(captured.identities).size !== captured.identities.length
+        ) {
+          return publishFailure();
+        }
+        const capsule = createFirstDisplayOwnershipCapsuleV1(
+          options.releaseId,
+          options.generation,
+          captured.identities
+        );
+        if (!capsule) return publishFailure();
+        liveCapsule = capsule;
+        state = 'finalized';
+        return Object.freeze({ handoff, capsule });
+      } catch {
+        return publishFailure();
+      }
+    },
+    dispose: (): void => {
+      if (state === 'disposed') return;
+      liveCapsule?.clear();
+      liveCapsule = undefined;
+      state = 'disposed';
+    },
+  });
+}
+
+/** Execute the non-yielding old-owner to persistent-owner transfer in one call stack. */
+export function performFirstDisplayTakeoverV1(options: FirstDisplayTakeoverOptions): boolean {
+  const persistentDisposers: Array<() => void> = [];
+  let ownershipOpen = true;
+  let failurePublished = false;
+  const fail = (): false => {
+    ownershipOpen = false;
+    for (let index = persistentDisposers.length - 1; index >= 0; index -= 1) {
+      try {
+        persistentDisposers[index]?.();
+      } catch {
+        // Continue unwinding every independently activated persistent effect.
+      }
+    }
+    persistentDisposers.length = 0;
+    options.finalized.capsule.clear();
+    if (!failurePublished) {
+      failurePublished = true;
+      try {
+        options.onFailure('bundle_partial');
+      } catch {
+        // Failure publication cannot restore either ownership epoch.
+      }
+    }
+    return false;
+  };
+
+  try {
+    const handoff = options.validateHandoff(
+      options.finalized.handoff,
+      options.outline,
+      options.boot
+    );
+    const { capsule } = options.finalized;
+    if (
+      !handoff ||
+      !options.isCurrentGeneration() ||
+      !options.authenticateRuntimeScript() ||
+      options.currentMutationRevision() !== handoff.mutationRevision
+    ) {
+      return fail();
+    }
+
+    options.quiesceAgent();
+    if (
+      !options.isCurrentGeneration() ||
+      options.currentMutationRevision() !== handoff.mutationRevision
+    ) {
+      return fail();
+    }
+    const identities = capsule.consume(handoff.releaseId, handoff.generation);
+    if (!identities) return fail();
+
+    options.detachCommittedArtifacts();
+    options.disposeAgent();
+    options.activatePersistent(handoff, identities, (dispose) => {
+      if (!ownershipOpen || typeof dispose !== 'function') {
+        throw new TypeError('tsjs');
+      }
+      persistentDisposers.push(dispose);
+    });
+    ownershipOpen = false;
+    if (
+      !options.isCurrentGeneration() ||
+      !options.authenticateRuntimeScript() ||
+      options.currentMutationRevision() !== handoff.mutationRevision
+    ) {
+      return fail();
+    }
+    options.commitPersistent();
+    persistentDisposers.length = 0;
+    return true;
+  } catch {
+    return fail();
+  }
+}
+
+/** Bind the validated old-epoch snapshot to one prepared persistent activation transaction. */
+export function coordinatePreparedFirstDisplayTakeoverV1(
+  options: PreparedFirstDisplayTakeoverOptions
+): boolean {
+  return performFirstDisplayTakeoverV1({
+    finalized: options.finalized,
+    outline: options.outline,
+    ...(options.boot === undefined ? {} : { boot: options.boot }),
+    validateHandoff: options.prepared.validateHandoff,
+    isCurrentGeneration: options.isCurrentGeneration,
+    authenticateRuntimeScript: options.authenticateRuntimeScript,
+    currentMutationRevision: options.currentMutationRevision,
+    quiesceAgent: options.quiesceAgent,
+    detachCommittedArtifacts: options.detachCommittedArtifacts,
+    disposeAgent: options.disposeAgent,
+    activatePersistent: (handoff, identities, own) => {
+      own(options.prepared.rollback);
+      options.prepared.activate(
+        Object.freeze({
+          version: 1 as const,
+          adoptInitialDisplay: true as const,
+          handoff,
+          identities,
+        })
+      );
+    },
+    commitPersistent: options.prepared.commit,
+    onFailure: options.onFailure,
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/shared/first_display_registration.ts b/crates/trusted-server-js/lib/src/shared/first_display_registration.ts
new file mode 100644
index 000000000..d6c73aa0e
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/first_display_registration.ts
@@ -0,0 +1,313 @@
+/** Private registration protocol shared by the bootstrap and provisional artifact. */
+declare const __TSJS_EMBEDDED_RELEASE_ID_V1__: string;
+
+const HASH = /^[0-9a-f]{64}$/;
+const COMPONENT_ID = /^[a-z][a-z0-9_]{0,63}$/;
+const FIRST_DISPLAY_SRC =
+  /^\/static\/tsjs=tsjs-first-display\.min\.js\?m=[0-9a-f]{4}&v=[0-9a-f]{64}$/;
+const PARSER_SLICE_ORDER = Object.freeze([
+  'render_owner_initial',
+  'aps_initial',
+  'creative_initial',
+  'datadome_initial',
+  'didomi_initial',
+  'google_tag_manager_initial',
+  'gpt_initial',
+  'lockr_initial',
+  'osano_initial',
+  'permutive_initial',
+  'sourcepoint_initial',
+  'prebid_initial',
+  'testlight_initial',
+]);
+
+export const FIRST_DISPLAY_REGISTRATION_FIELD = '_registerFirstDisplay' as const;
+
+export interface FirstDisplayComponentRegistrationV1 {
+  readonly abi: 1;
+  readonly id: string;
+  readonly releaseId: string;
+  /** Absolute catalog order, not the component's position in one selected mask. */
+  readonly order: number;
+  readonly install: (
+    bindings: unknown,
+    own: (dispose: () => void) => void,
+    config: unknown
+  ) => unknown;
+}
+
+type FirstDisplayBootstrapTarget = object & {
+  readonly [FIRST_DISPLAY_REGISTRATION_FIELD]?: unknown;
+};
+
+export interface FirstDisplayParserStateCollector {
+  readonly register: (sliceId: string) => boolean;
+  readonly observe: (sliceId: string, key: unknown, value: unknown) => boolean;
+  readonly snapshot: () => readonly Readonly<{
+    sliceId: string;
+    observations: readonly string[];
+    values: readonly (readonly [string, string | number | boolean | null])[];
+  }>[];
+}
+
+/** Retain only bounded ordinary-data observations needed by persistent slice owners. */
+export function createFirstDisplayParserStateCollector(): FirstDisplayParserStateCollector {
+  const states = new Map<
+    string,
+    { observations: string[]; values: Map<string, string | number | boolean | null> }
+  >();
+  const encoder = new TextEncoder();
+  const register = (sliceId: string): boolean => {
+    if (!PARSER_SLICE_ORDER.includes(sliceId)) return false;
+    if (!states.has(sliceId)) states.set(sliceId, { observations: [], values: new Map() });
+    return true;
+  };
+  const bounded = (value: string, bytes: number, allowEmpty = false): boolean => {
+    if ((!allowEmpty && value.length === 0) || encoder.encode(value).byteLength > bytes)
+      return false;
+    for (let index = 0; index < value.length; index += 1) {
+      const code = value.charCodeAt(index);
+      if (code <= 0x1f || code === 0x7f) return false;
+    }
+    return true;
+  };
+  return Object.freeze({
+    register,
+    observe: (sliceId: string, key: unknown, value: unknown): boolean => {
+      if (
+        !register(sliceId) ||
+        typeof key !== 'string' ||
+        !bounded(key, 128) ||
+        (value !== null &&
+          typeof value !== 'string' &&
+          typeof value !== 'boolean' &&
+          !(typeof value === 'number' && Number.isFinite(value))) ||
+        (typeof value === 'string' && !bounded(value, 4096, true))
+      ) {
+        return false;
+      }
+      const state = states.get(sliceId)!;
+      if (!state.values.has(key)) {
+        if (state.values.size >= 256) return false;
+        state.observations.push(key);
+      }
+      state.values.set(key, value as string | number | boolean | null);
+      return true;
+    },
+    snapshot: () =>
+      Object.freeze(
+        PARSER_SLICE_ORDER.flatMap((sliceId) => {
+          const state = states.get(sliceId);
+          if (!state) return [];
+          return [
+            Object.freeze({
+              sliceId,
+              observations: Object.freeze([...state.observations]),
+              values: Object.freeze(
+                state.observations.map((key) =>
+                  Object.freeze([key, state.values.get(key)!] as const)
+                )
+              ),
+            }),
+          ];
+        })
+      ),
+  });
+}
+
+/** Wrap one exact frozen slice observation channel with the final-revision ledger. */
+export function captureMutationObservedBindings(
+  candidate: unknown,
+  observeMutation: () => boolean,
+  captureObservation?: (key: unknown, value: unknown) => void
+): unknown {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate) ||
+      typeof observeMutation !== 'function'
+    ) {
+      return candidate;
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(candidate);
+    const observe = descriptors.observe;
+    if (!observe?.enumerable || !('value' in observe) || typeof observe.value !== 'function') {
+      return candidate;
+    }
+    const original = observe.value as (...arguments_: unknown[]) => unknown;
+    const captured = Object.create(Object.prototype) as Record<PropertyKey, unknown>;
+    Object.defineProperties(captured, {
+      ...descriptors,
+      observe: {
+        ...observe,
+        value: (...arguments_: unknown[]): unknown => {
+          const result = Reflect.apply(original, candidate, arguments_);
+          captureObservation?.(arguments_[0], arguments_[1]);
+          observeMutation();
+          return result;
+        },
+      },
+    });
+    return Object.freeze(captured);
+  } catch {
+    return candidate;
+  }
+}
+
+/** Copy one untrusted component record without invoking accessors or inherited hooks. */
+export function snapshotFirstDisplayComponentRegistration(
+  candidate: unknown
+): FirstDisplayComponentRegistrationV1 | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate)
+    ) {
+      return undefined;
+    }
+    const keys = Reflect.ownKeys(candidate);
+    if (
+      keys.length !== 5 ||
+      !keys.every(
+        (key) =>
+          typeof key === 'string' && ['abi', 'id', 'releaseId', 'order', 'install'].includes(key)
+      )
+    ) {
+      return undefined;
+    }
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    }
+    const registration = candidate as unknown as FirstDisplayComponentRegistrationV1;
+    if (
+      registration.abi !== 1 ||
+      !COMPONENT_ID.test(registration.id) ||
+      !HASH.test(registration.releaseId) ||
+      !Number.isInteger(registration.order) ||
+      registration.order < 1 ||
+      registration.order > 14 ||
+      typeof registration.install !== 'function'
+    ) {
+      return undefined;
+    }
+    return Object.freeze({
+      abi: 1,
+      id: registration.id,
+      releaseId: registration.releaseId,
+      order: registration.order,
+      install: registration.install,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function bootstrapTarget(browser: Window): FirstDisplayBootstrapTarget | undefined {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(browser, 'tsjs');
+    if (!descriptor || !('value' in descriptor)) return undefined;
+    const target = descriptor.value;
+    return (typeof target === 'object' || typeof target === 'function') && target !== null
+      ? (target as FirstDisplayBootstrapTarget)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function authenticatedCurrentScript(browser: Window): HTMLScriptElement | undefined {
+  try {
+    const { document } = browser;
+    const candidate = document.currentScript;
+    const Script = document.defaultView?.HTMLScriptElement;
+    if (!Script || !(candidate instanceof Script)) {
+      return undefined;
+    }
+    const script = candidate as HTMLScriptElement;
+    if (
+      script.id !== 'trustedserver-js' ||
+      !script.isConnected ||
+      script.ownerDocument !== document
+    ) {
+      return undefined;
+    }
+    const origin = document.location.origin;
+    if (!/^https?:\/\//.test(origin)) return undefined;
+    const source = new URL(script.src, origin);
+    if (
+      source.origin !== origin ||
+      source.hash !== '' ||
+      !FIRST_DISPLAY_SRC.test(`${source.pathname}${source.search}`)
+    ) {
+      return undefined;
+    }
+    return script;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Register one independently built component through the bootstrap's ephemeral sink.
+ * The sink receives the authenticated current script so its closure can compare the
+ * exact parser-inserted owner without consulting `document.currentScript` later.
+ */
+export function registerFirstDisplayComponent(
+  browser: Window,
+  registration: FirstDisplayComponentRegistrationV1
+): boolean {
+  if (!snapshotFirstDisplayComponentRegistration(registration)) return false;
+  const script = authenticatedCurrentScript(browser);
+  const target = script ? bootstrapTarget(browser) : undefined;
+  if (!script || !target) return false;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(target, FIRST_DISPLAY_REGISTRATION_FIELD);
+    if (
+      !descriptor ||
+      !('value' in descriptor) ||
+      typeof descriptor.value !== 'function' ||
+      descriptor.enumerable ||
+      !descriptor.configurable ||
+      descriptor.writable
+    ) {
+      return false;
+    }
+    return Reflect.apply(descriptor.value, target, [registration, script]) === true;
+  } catch {
+    return false;
+  }
+}
+
+/** Create one immutable release-bound registration shared by the build entries. */
+export function firstDisplayComponentRegistration(
+  id: string,
+  order: number,
+  install: FirstDisplayComponentRegistrationV1['install']
+): FirstDisplayComponentRegistrationV1 {
+  return Object.freeze({
+    abi: 1,
+    id,
+    releaseId: __TSJS_EMBEDDED_RELEASE_ID_V1__,
+    order,
+    install,
+  });
+}
+
+/** Execute only in a browser build; unit imports without a current script remain inert. */
+export function registerCurrentFirstDisplayComponent(
+  registration: FirstDisplayComponentRegistrationV1
+): boolean {
+  try {
+    const browser = (globalThis as unknown as { window?: Window }).window;
+    return browser ? registerFirstDisplayComponent(browser, registration) : false;
+  } catch {
+    return false;
+  }
+}
diff --git a/crates/trusted-server-js/lib/src/shared/first_display_transaction.ts b/crates/trusted-server-js/lib/src/shared/first_display_transaction.ts
new file mode 100644
index 000000000..fac8e0a28
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/first_display_transaction.ts
@@ -0,0 +1,314 @@
+import type { FirstDisplaySliceId } from '../kernel/release_catalog';
+
+/** Closure-private activation transaction shared by bootstrap and provisional base. */
+
+const HASH = /^[0-9a-f]{64}$/;
+const FIRST_DISPLAY_SRC =
+  /^\/static\/tsjs=tsjs-first-display\.min\.js\?m=[0-9a-f]{4}&v=[0-9a-f]{64}$/;
+const FIRST_DISPLAY_ORDER = new Map(
+  [
+    'first_display',
+    'render_owner_initial',
+    'aps_initial',
+    'creative_initial',
+    'datadome_initial',
+    'didomi_initial',
+    'google_tag_manager_initial',
+    'gpt_initial',
+    'lockr_initial',
+    'osano_initial',
+    'permutive_initial',
+    'sourcepoint_initial',
+    'prebid_initial',
+    'testlight_initial',
+  ].map((id, index) => [id, index + 1] as const)
+);
+
+export type FirstDisplayTransactionState =
+  'collecting' | 'preparing' | 'activating' | 'active' | 'failed' | 'disposed';
+
+export interface FirstDisplaySlicePrepareContext {
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly sliceId: FirstDisplaySliceId;
+}
+
+export interface FirstDisplaySliceActivationContext {
+  readonly own: (dispose: () => void) => void;
+  /** Base-only action that runs synchronously after every selected slice activates. */
+  readonly afterActivate: (callback: () => void) => void;
+}
+
+export interface PreparedFirstDisplaySliceV1 {
+  readonly activate: (context: FirstDisplaySliceActivationContext) => void;
+}
+
+export interface FirstDisplaySliceRegistrationV1 {
+  readonly abi: 1;
+  readonly id: FirstDisplaySliceId;
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly order: number;
+  readonly prepare: (context: FirstDisplaySlicePrepareContext) => PreparedFirstDisplaySliceV1;
+}
+
+export interface FirstDisplayTransactionOptions {
+  readonly document: Document;
+  readonly script: HTMLScriptElement;
+  readonly releaseId: string;
+  readonly generation: number;
+  readonly expectedSliceIds: readonly FirstDisplaySliceId[];
+  readonly isCurrentGeneration: () => boolean;
+  readonly onDisposalError?: (error: unknown) => void;
+}
+
+export interface FirstDisplayTransaction {
+  readonly state: FirstDisplayTransactionState;
+  readonly register: (candidate: unknown) => boolean;
+  readonly activate: () => boolean;
+  readonly dispose: () => void;
+}
+
+function exactRecord(value: unknown, keys: readonly string[]): Record<string, unknown> | undefined {
+  if (
+    typeof value !== 'object' ||
+    value === null ||
+    Array.isArray(value) ||
+    Object.getPrototypeOf(value) !== Object.prototype
+  ) {
+    return undefined;
+  }
+  const ownKeys = Reflect.ownKeys(value);
+  if (
+    ownKeys.length !== keys.length ||
+    !ownKeys.every((key) => typeof key === 'string' && keys.includes(key))
+  ) {
+    return undefined;
+  }
+  const result: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+
+function snapshotRegistration(candidate: unknown): FirstDisplaySliceRegistrationV1 | undefined {
+  try {
+    const fields = exactRecord(candidate, [
+      'abi',
+      'id',
+      'releaseId',
+      'generation',
+      'order',
+      'prepare',
+    ]);
+    if (
+      !fields ||
+      fields.abi !== 1 ||
+      typeof fields.id !== 'string' ||
+      typeof fields.releaseId !== 'string' ||
+      !HASH.test(fields.releaseId) ||
+      !Number.isInteger(fields.generation) ||
+      (fields.generation as number) < 1 ||
+      (fields.generation as number) > 4_294_967_295 ||
+      !Number.isInteger(fields.order) ||
+      (fields.order as number) < 1 ||
+      typeof fields.prepare !== 'function'
+    ) {
+      return undefined;
+    }
+    return Object.freeze({
+      abi: 1,
+      id: fields.id as FirstDisplaySliceId,
+      releaseId: fields.releaseId,
+      generation: fields.generation as number,
+      order: fields.order as number,
+      prepare: fields.prepare as FirstDisplaySliceRegistrationV1['prepare'],
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+class FirstDisplayTransactionOwner implements FirstDisplayTransaction {
+  private stateValue: FirstDisplayTransactionState = 'collecting';
+  private readonly registrations: FirstDisplaySliceRegistrationV1[] = [];
+  private readonly disposers: Array<() => void> = [];
+
+  public constructor(private readonly options: FirstDisplayTransactionOptions) {}
+
+  public get state(): FirstDisplayTransactionState {
+    return this.stateValue;
+  }
+
+  public register(candidate: unknown): boolean {
+    if (this.stateValue !== 'collecting' || !this.authenticated()) return this.reject();
+    const registration = snapshotRegistration(candidate);
+    const expectedIndex = this.registrations.length;
+    if (
+      !registration ||
+      registration.releaseId !== this.options.releaseId ||
+      registration.generation !== this.options.generation ||
+      registration.order !== FIRST_DISPLAY_ORDER.get(registration.id) ||
+      registration.id !== this.options.expectedSliceIds[expectedIndex]
+    ) {
+      return this.reject();
+    }
+    this.registrations.push(registration);
+    return true;
+  }
+
+  public activate(): boolean {
+    if (
+      this.stateValue !== 'collecting' ||
+      this.registrations.length !== this.options.expectedSliceIds.length ||
+      !this.authenticated()
+    ) {
+      return this.reject();
+    }
+    if (this.stateValue !== 'collecting') return false;
+    const prepared: PreparedFirstDisplaySliceV1[] = [];
+    this.stateValue = 'preparing';
+    try {
+      for (const registration of this.registrations) {
+        const candidate = registration.prepare(
+          Object.freeze({
+            releaseId: this.options.releaseId,
+            generation: this.options.generation,
+            sliceId: registration.id,
+          })
+        );
+        if (this.stateValue !== 'preparing') throw new TypeError('stale slice preparation');
+        const fields = exactRecord(candidate, ['activate']);
+        if (!fields || typeof fields.activate !== 'function')
+          throw new TypeError('invalid prepared slice');
+        prepared.push(
+          Object.freeze({ activate: fields.activate as PreparedFirstDisplaySliceV1['activate'] })
+        );
+      }
+      if (!this.authenticated() || this.stateValue !== 'preparing') {
+        throw new TypeError('stale first-display owner');
+      }
+      this.stateValue = 'activating';
+      let ownershipOpen = true;
+      let afterActivation: (() => void) | undefined;
+      try {
+        for (let index = 0; index < prepared.length; index += 1) {
+          const slice = prepared[index];
+          if (!slice) throw new TypeError('missing prepared first-display slice');
+          slice.activate(
+            Object.freeze({
+              own: (dispose: () => void): void => {
+                if (!ownershipOpen || typeof dispose !== 'function') {
+                  throw new TypeError('first-display disposer registration is closed');
+                }
+                this.disposers.push(dispose);
+              },
+              afterActivate: (callback: () => void): void => {
+                if (
+                  !ownershipOpen ||
+                  index !== 0 ||
+                  afterActivation !== undefined ||
+                  typeof callback !== 'function'
+                ) {
+                  throw new TypeError('invalid first-display post-activation callback');
+                }
+                afterActivation = callback;
+              },
+            })
+          );
+          if (this.stateValue !== 'activating') {
+            throw new TypeError('stale first-display activation');
+          }
+        }
+      } finally {
+        ownershipOpen = false;
+      }
+      afterActivation?.();
+      if (
+        !this.stateCurrent('activating') ||
+        !this.authenticated() ||
+        !this.stateCurrent('activating')
+      ) {
+        throw new TypeError('stale first-display activation');
+      }
+      this.stateValue = 'active';
+      return true;
+    } catch {
+      if (!this.stateCurrent('disposed')) this.stateValue = 'failed';
+      this.unwind();
+      return false;
+    }
+  }
+
+  public dispose(): void {
+    if (this.stateValue === 'disposed') return;
+    this.stateValue = 'disposed';
+    this.unwind();
+    this.registrations.length = 0;
+  }
+
+  private stateCurrent(expected: FirstDisplayTransactionState): boolean {
+    return this.stateValue === expected;
+  }
+
+  private authenticated(): boolean {
+    try {
+      const { document, script, releaseId, generation, isCurrentGeneration } = this.options;
+      const origin = document.defaultView?.location.origin;
+      if (!origin || !HASH.test(releaseId) || generation < 1 || !isCurrentGeneration())
+        return false;
+      const source = new URL(script.src, origin);
+      return (
+        script.id === 'trustedserver-js' &&
+        script.isConnected &&
+        document.currentScript === script &&
+        source.origin === origin &&
+        source.hash === '' &&
+        FIRST_DISPLAY_SRC.test(`${source.pathname}${source.search}`)
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  private reject(): false {
+    if (this.stateValue !== 'active' && this.stateValue !== 'disposed') {
+      this.stateValue = 'failed';
+      this.unwind();
+    }
+    return false;
+  }
+
+  private unwind(): void {
+    while (this.disposers.length > 0) {
+      const dispose = this.disposers.pop();
+      try {
+        dispose?.();
+      } catch (error) {
+        try {
+          this.options.onDisposalError?.(error);
+        } catch {
+          // Continue releasing every independent provisional effect.
+        }
+      }
+    }
+  }
+}
+
+/** Create the closure-private collector for exactly one authenticated agent artifact. */
+export function createFirstDisplayTransaction(
+  options: FirstDisplayTransactionOptions
+): FirstDisplayTransaction {
+  const owner = new FirstDisplayTransactionOwner(options);
+  return Object.freeze({
+    get state() {
+      return owner.state;
+    },
+    register: (candidate: unknown) => owner.register(candidate),
+    activate: () => owner.activate(),
+    dispose: () => owner.dispose(),
+  });
+}
diff --git a/crates/trusted-server-js/lib/src/shared/globals.ts b/crates/trusted-server-js/lib/src/shared/globals.ts
index cbacb590f..8785ecfb5 100644
--- a/crates/trusted-server-js/lib/src/shared/globals.ts
+++ b/crates/trusted-server-js/lib/src/shared/globals.ts
@@ -1,43 +1,4 @@
-// Cross-runtime helpers for resolving windows/globals in creatives and pbjs shims.
-import type { TsjsApi } from '../core/types';
-
-export interface TsCreativeApi {
-  installGuards(): void;
-  setConfig?(cfg: TsCreativeConfig): void;
-  getConfig?(): TsCreativeConfig;
-}
-
-export interface TsCreativeConfig {
-  /** Enable click guard runtime. Defaults to true. */
-  clickGuard?: boolean;
-  /** Enable render guard (dynamic image/iframe src proxies). Defaults to false. */
-  renderGuard?: boolean;
-}
-
-export type CreativeWindow = Window & {
-  __ts_creative_installed?: boolean;
-  tsCreativeConfig?: TsCreativeConfig;
-};
-
-export type CreativeGlobal = typeof globalThis & {
+/** Minimal cross-runtime access to optional browser storage. */
+export const creativeGlobal = globalThis as typeof globalThis & {
   localStorage?: Storage;
-  tscreative?: TsCreativeApi;
-  tsCreativeConfig?: TsCreativeConfig;
 };
-
-export const creativeGlobal = globalThis as CreativeGlobal;
-
-// Support SSR/unit tests where window may live on globalThis or be undefined.
-export function resolveWindow(): Window | undefined {
-  if (typeof window !== 'undefined') return window;
-  const maybeWindow = (globalThis as { window?: Window }).window;
-  return maybeWindow;
-}
-
-export type PrebidWindow = Window & { tsjs?: TsjsApi; pbjs?: TsjsApi };
-
-// Always hand back an object so shims can safely assign tsjs/pbjs globals.
-export function resolvePrebidWindow(): PrebidWindow {
-  const maybeWindow = resolveWindow();
-  return (maybeWindow as PrebidWindow) ?? ({} as PrebidWindow);
-}
diff --git a/crates/trusted-server-js/lib/src/shared/gpt_diagnostics.ts b/crates/trusted-server-js/lib/src/shared/gpt_diagnostics.ts
new file mode 100644
index 000000000..bca9887e0
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/gpt_diagnostics.ts
@@ -0,0 +1,96 @@
+import type { GptDiagnosticsTrustedServerOpportunity, Size } from '../core/types';
+
+/** Opaque GPT slot identity safe to pass through the data-only diagnostics capability. */
+export interface GptDiagnosticsSlotIdentityV1 {
+  readonly token: object;
+  readonly traceToken?: string | undefined;
+  readonly runtimeSlotNumber?: number | undefined;
+  readonly cycleOrdinal?: number | undefined;
+  readonly elementId?: string | undefined;
+  readonly adUnitPath?: string | undefined;
+}
+
+/** Release-private Trusted Server request intent consumed only by GPT diagnostics. */
+export interface GptDiagnosticsOpportunityFact {
+  readonly kind: 'trustedServerOpportunity';
+  readonly auctionSlotId: string;
+  readonly opportunity: GptDiagnosticsTrustedServerOpportunity;
+  readonly requestedSlotSizes: readonly Readonly<Size>[];
+  readonly slot: Readonly<GptDiagnosticsSlotIdentityV1>;
+  readonly trustedServerAuctionId?: string | undefined;
+}
+
+const opportunityFacts = new WeakSet<object>();
+
+/** Copy one immutable request-intent fact before its exact GPT request starts. */
+export function createTrustedServerOpportunityFact(input: {
+  readonly auctionSlotId: string;
+  readonly opportunity: GptDiagnosticsTrustedServerOpportunity;
+  readonly requestedSlotSizes: readonly Readonly<Size>[];
+  readonly slot: Readonly<GptDiagnosticsSlotIdentityV1>;
+  readonly trustedServerAuctionId?: string | undefined;
+}): Readonly<GptDiagnosticsOpportunityFact> | undefined {
+  try {
+    if (
+      typeof input.auctionSlotId !== 'string' ||
+      input.auctionSlotId.length === 0 ||
+      input.auctionSlotId.length > 256 ||
+      (input.opportunity !== 'renderable_candidate' &&
+        input.opportunity !== 'unrenderable_candidate' &&
+        input.opportunity !== 'no_candidate') ||
+      typeof input.slot !== 'object' ||
+      input.slot === null ||
+      !Object.isFrozen(input.slot) ||
+      !Array.isArray(input.requestedSlotSizes)
+    ) {
+      return undefined;
+    }
+    const requestedSlotSizes: Readonly<Size>[] = [];
+    for (let index = 0; index < input.requestedSlotSizes.length && index < 16; index += 1) {
+      const size = input.requestedSlotSizes[index];
+      if (
+        !Array.isArray(size) ||
+        size.length !== 2 ||
+        !Number.isInteger(size[0]) ||
+        !Number.isInteger(size[1]) ||
+        (size[0] ?? 0) < 1 ||
+        (size[0] ?? 0) > 4_096 ||
+        (size[1] ?? 0) < 1 ||
+        (size[1] ?? 0) > 4_096
+      ) {
+        continue;
+      }
+      requestedSlotSizes.push(Object.freeze([size[0], size[1]] as Size));
+    }
+    if (requestedSlotSizes.length === 0) return undefined;
+    if (
+      input.trustedServerAuctionId !== undefined &&
+      (typeof input.trustedServerAuctionId !== 'string' ||
+        input.trustedServerAuctionId.length === 0 ||
+        input.trustedServerAuctionId.length > 256)
+    ) {
+      return undefined;
+    }
+    const fact = Object.freeze({
+      kind: 'trustedServerOpportunity' as const,
+      auctionSlotId: input.auctionSlotId,
+      opportunity: input.opportunity,
+      requestedSlotSizes: Object.freeze(requestedSlotSizes),
+      slot: input.slot,
+      ...(input.trustedServerAuctionId === undefined
+        ? {}
+        : { trustedServerAuctionId: input.trustedServerAuctionId }),
+    });
+    opportunityFacts.add(fact);
+    return fact;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Verify that an opportunity fact was minted by this release's private producer. */
+export function isTrustedServerOpportunityFact(
+  candidate: unknown
+): candidate is Readonly<GptDiagnosticsOpportunityFact> {
+  return typeof candidate === 'object' && candidate !== null && opportunityFacts.has(candidate);
+}
diff --git a/crates/trusted-server-js/lib/src/shared/integration_config_validators.ts b/crates/trusted-server-js/lib/src/shared/integration_config_validators.ts
new file mode 100644
index 000000000..4ae83f69a
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/integration_config_validators.ts
@@ -0,0 +1,141 @@
+/** Exact validator used by products whose browser projection is deliberately empty. */
+export function isEmptyIntegrationConfigV1(candidate: unknown): boolean {
+  try {
+    return (
+      typeof candidate === 'object' &&
+      candidate !== null &&
+      !Array.isArray(candidate) &&
+      Object.getPrototypeOf(candidate) === Object.prototype &&
+      Object.isFrozen(candidate) &&
+      Reflect.ownKeys(candidate).length === 0
+    );
+  } catch {
+    return false;
+  }
+}
+
+function exactFrozenRecord(
+  candidate: unknown,
+  required: readonly string[],
+  optional: readonly string[] = []
+): Readonly<Record<string, unknown>> | undefined {
+  try {
+    if (
+      typeof candidate !== 'object' ||
+      candidate === null ||
+      Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Object.prototype ||
+      !Object.isFrozen(candidate)
+    ) {
+      return undefined;
+    }
+    const keys = Reflect.ownKeys(candidate);
+    if (
+      keys.some((key) => typeof key !== 'string') ||
+      required.some((key) => !keys.includes(key)) ||
+      keys.some(
+        (key) => typeof key !== 'string' || (!required.includes(key) && !optional.includes(key))
+      )
+    ) {
+      return undefined;
+    }
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    }
+    return candidate as Readonly<Record<string, unknown>>;
+  } catch {
+    return undefined;
+  }
+}
+
+function frozenStringArray(candidate: unknown): candidate is readonly string[] {
+  try {
+    if (
+      !Array.isArray(candidate) ||
+      Object.getPrototypeOf(candidate) !== Array.prototype ||
+      !Object.isFrozen(candidate) ||
+      Reflect.ownKeys(candidate).length !== candidate.length + 1
+    ) {
+      return false;
+    }
+    for (let index = 0; index < candidate.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+      if (
+        !descriptor?.enumerable ||
+        !('value' in descriptor) ||
+        typeof descriptor.value !== 'string'
+      ) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface GptIntegrationConfigV1 {
+  readonly gamAttributionEnabled: boolean;
+  readonly pageBidsEnabled: boolean;
+}
+
+export function isGptIntegrationConfigV1(
+  candidate: unknown
+): candidate is Readonly<GptIntegrationConfigV1> {
+  const config = exactFrozenRecord(candidate, ['gamAttributionEnabled', 'pageBidsEnabled']);
+  return (
+    typeof config?.gamAttributionEnabled === 'boolean' &&
+    typeof config.pageBidsEnabled === 'boolean'
+  );
+}
+
+export function isDidomiIntegrationConfigV1(candidate: unknown): boolean {
+  const config = exactFrozenRecord(candidate, ['proxyPath']);
+  if (typeof config?.proxyPath !== 'string') return false;
+  return (
+    config.proxyPath.startsWith('/') &&
+    !config.proxyPath.startsWith('//') &&
+    !config.proxyPath.startsWith('/\\') &&
+    !config.proxyPath.includes('?') &&
+    !config.proxyPath.includes('#')
+  );
+}
+
+export function isSourcepointIntegrationConfigV1(candidate: unknown): boolean {
+  const config = exactFrozenRecord(candidate, ['rewriteSdk']);
+  return typeof config?.rewriteSdk === 'boolean';
+}
+
+export function isPrebidIntegrationConfigV1(candidate: unknown): boolean {
+  const config = exactFrozenRecord(
+    candidate,
+    ['accountId', 'timeout', 'debug', 'bidders'],
+    ['clientSideBidders', 'excludedGamAdUnitPathSuffixes']
+  );
+  return Boolean(
+    config &&
+    typeof config.accountId === 'string' &&
+    typeof config.timeout === 'number' &&
+    Number.isInteger(config.timeout) &&
+    config.timeout >= 0 &&
+    config.timeout <= 4_294_967_295 &&
+    typeof config.debug === 'boolean' &&
+    frozenStringArray(config.bidders) &&
+    (config.clientSideBidders === undefined || frozenStringArray(config.clientSideBidders)) &&
+    (config.excludedGamAdUnitPathSuffixes === undefined ||
+      frozenStringArray(config.excludedGamAdUnitPathSuffixes))
+  );
+}
+
+export function isCreativeBootConfigV1(candidate: unknown): boolean {
+  const config = exactFrozenRecord(candidate, ['version', 'enabled', 'clickGuard', 'renderGuard']);
+  return Boolean(
+    config &&
+    config.version === 1 &&
+    typeof config.enabled === 'boolean' &&
+    typeof config.clickGuard === 'boolean' &&
+    typeof config.renderGuard === 'boolean' &&
+    (config.enabled || (!config.clickGuard && !config.renderGuard))
+  );
+}
diff --git a/crates/trusted-server-js/lib/src/shared/origin.ts b/crates/trusted-server-js/lib/src/shared/origin.ts
index e08431ae4..ae1a0ce9b 100644
--- a/crates/trusted-server-js/lib/src/shared/origin.ts
+++ b/crates/trusted-server-js/lib/src/shared/origin.ts
@@ -78,3 +78,26 @@ export const TRUSTED_BASE_URL: string = (() => {
   }
   return '';
 })();
+
+// Exact first-party origin for protocol messages and root-owned endpoints.
+// `TRUSTED_BASE_URL` may be a full inherited base URI in the final fallback,
+// so normalize it to its origin while retaining the same HTTP(S)-only and
+// credential-free trust boundary.
+export function trustedHttpOrigin(baseUrl: string = TRUSTED_BASE_URL): string {
+  if (!baseUrl) return '';
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return '';
+    if (parsed.username !== '' || parsed.password !== '') return '';
+    return parsed.origin;
+  } catch {
+    return '';
+  }
+}
+
+export function trustedDocumentHttpOrigin(
+  documentOrigin: string,
+  trustedBaseUrl: string = TRUSTED_BASE_URL
+): string {
+  return trustedHttpOrigin(documentOrigin === 'null' ? trustedBaseUrl : documentOrigin);
+}
diff --git a/crates/trusted-server-js/lib/src/shared/realm.ts b/crates/trusted-server-js/lib/src/shared/realm.ts
new file mode 100644
index 000000000..58923e653
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/realm.ts
@@ -0,0 +1,49 @@
+function realmOwnedInstance(
+  candidate: unknown,
+  targetRealm: unknown,
+  constructorName: 'Document' | 'Element' | 'HTMLElement'
+): object | undefined {
+  try {
+    if (typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)) {
+      return undefined;
+    }
+    if (
+      (typeof targetRealm !== 'object' && typeof targetRealm !== 'function') ||
+      targetRealm === null
+    ) {
+      return undefined;
+    }
+    const constructor = (targetRealm as Readonly<Record<string, unknown>>)[constructorName];
+    return typeof constructor === 'function' && candidate instanceof constructor
+      ? candidate
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Return a Document only when its own browsing-context realm authenticates it. */
+export function realmOwnedDocument(candidate: unknown): Document | undefined {
+  try {
+    const targetWindow = (candidate as { readonly defaultView?: unknown } | null)?.defaultView;
+    const document = realmOwnedInstance(candidate, targetWindow, 'Document');
+    if (!document) return undefined;
+    const realmDocument = (targetWindow as { readonly document?: unknown }).document;
+    return realmDocument === candidate ? (document as Document) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Return an Element only when the supplied target realm authenticates it. */
+export function realmOwnedElement(candidate: unknown, targetRealm: unknown): Element | undefined {
+  return realmOwnedInstance(candidate, targetRealm, 'Element') as Element | undefined;
+}
+
+/** Return an HTMLElement only when the supplied target realm authenticates it. */
+export function realmOwnedHtmlElement(
+  candidate: unknown,
+  targetRealm: unknown
+): HTMLElement | undefined {
+  return realmOwnedInstance(candidate, targetRealm, 'HTMLElement') as HTMLElement | undefined;
+}
diff --git a/crates/trusted-server-js/lib/src/shared/scheduler.ts b/crates/trusted-server-js/lib/src/shared/scheduler.ts
index 32664f635..088eadfe5 100644
--- a/crates/trusted-server-js/lib/src/shared/scheduler.ts
+++ b/crates/trusted-server-js/lib/src/shared/scheduler.ts
@@ -1,15 +1,34 @@
 // Mutation observer helper that batches callbacks onto the microtask queue.
 import { queueTask } from './async';
 
+export interface MutationScheduler<T extends Element> {
+  (target: T): void;
+  readonly dispose: () => void;
+}
+
 // Coalesce repeated mutation callbacks on the same element into a single microtask run.
-export function createMutationScheduler<T extends Element>(perform: (target: T) => void) {
+export function createMutationScheduler<T extends Element>(
+  perform: (target: T) => void
+): MutationScheduler<T> {
   const queued = new WeakSet<T>();
-  return (target: T) => {
+  let active = true;
+  const schedule = ((target: T): void => {
+    if (!active) return;
     if (queued.has(target)) return;
     queued.add(target);
     queueTask(() => {
       queued.delete(target);
+      if (!active) return;
       perform(target);
     });
-  };
+  }) as MutationScheduler<T>;
+  Object.defineProperty(schedule, 'dispose', {
+    configurable: false,
+    enumerable: true,
+    value: (): void => {
+      active = false;
+    },
+    writable: false,
+  });
+  return Object.freeze(schedule);
 }
diff --git a/crates/trusted-server-js/lib/src/shared/script_guard.ts b/crates/trusted-server-js/lib/src/shared/script_guard.ts
index b34d696bf..c70d87ae7 100644
--- a/crates/trusted-server-js/lib/src/shared/script_guard.ts
+++ b/crates/trusted-server-js/lib/src/shared/script_guard.ts
@@ -6,165 +6,441 @@ import {
   type DomInsertionCandidate,
 } from './dom_insertion_dispatcher';
 
-/**
- * Shared Script Guard Factory
- *
- * Creates a DOM interception guard that registers with the shared DOM insertion
- * dispatcher. Matching dynamically inserted script (and preload/prefetch link)
- * elements are rewritten to a first-party proxy endpoint before insertion.
- *
- * Each call to createScriptGuard() produces an independent guard with its own
- * installation state, so multiple integrations can coexist without interference.
- */
+/** Maximum fallback instance descriptors retained until one guard is reset. */
+const MAX_TRACKED_INSTANCE_PATCHES = 256;
+
+/** Optional interception layers needed by SDKs that load child scripts themselves. */
+export interface DeepScriptInterceptionConfig {
+  /** Cheap fail-closed hint used before parsing HTML passed to document.write/writeln. */
+  readonly documentWriteUrlHint: string;
+}
 
-/**
- * Base configuration shared by all guard types.
- */
 interface ScriptGuardConfigBase {
-  /** Integration ID used for deterministic ordering and internal identity. */
+  /** Install source setters, document-write parsing, and a mutation observer. */
+  deepInterception?: DeepScriptInterceptionConfig;
+  /** Integration ID used for deterministic dispatcher ordering. */
   id: string;
-  /** Optional human-readable label used in log messages (e.g. "GTM"). */
+  /** Return true only for a URL owned by this integration. */
+  isTargetUrl: (url: string) => boolean;
+  /** Optional human-readable log label. */
   displayName?: string;
-  /** Lower values run earlier when multiple handlers match the same node. */
+  /** Lower values run earlier when multiple insertion handlers match. */
   priority?: number;
-  /** Return true if the URL belongs to this integration's SDK. */
-  isTargetUrl: (url: string) => boolean;
 }
 
-/**
- * Config using a fixed proxy path (original behavior).
- * The entire URL is replaced with `{origin}{proxyPath}`.
- */
 interface ScriptGuardConfigWithProxyPath extends ScriptGuardConfigBase {
-  /** First-party proxy path to rewrite to (e.g. "/integrations/lockr/sdk"). */
   proxyPath: string;
   rewriteUrl?: never;
 }
 
-/**
- * Config using a custom URL rewriter function.
- * Allows integrations like DataDome to preserve the original path.
- */
 interface ScriptGuardConfigWithRewriter extends ScriptGuardConfigBase {
   proxyPath?: never;
-  /** Custom function to rewrite the original URL to a first-party URL. */
   rewriteUrl: (originalUrl: string) => string;
 }
 
 export type ScriptGuardConfig = ScriptGuardConfigWithProxyPath | ScriptGuardConfigWithRewriter;
 
 export interface ScriptGuard {
-  /** Install a shared DOM insertion handler for matching scripts and links. */
   install: () => void;
-  /** Whether the guard has already been installed. */
   isInstalled: () => boolean;
-  /** Reset installation state (primarily for testing). */
   reset: () => void;
 }
 
-/**
- * Build a first-party URL from the current page origin and the configured proxy path.
- */
+interface InstancePatch {
+  readonly element: HTMLScriptElement;
+  readonly previous: PropertyDescriptor | undefined;
+  readonly setter: (this: HTMLScriptElement, value: string) => void;
+}
+
 function rewriteToFirstParty(proxyPath: string): string {
   return `${window.location.origin}${proxyPath}`;
 }
 
-/**
- * Get the rewritten URL using either the custom rewriter or the proxy path.
- */
-function getRewrittenUrl(originalUrl: string, config: ScriptGuardConfig): string {
-  if (config.rewriteUrl) {
-    return config.rewriteUrl(originalUrl);
-  }
-  return rewriteToFirstParty(config.proxyPath);
+function rewrittenUrl(originalUrl: string, config: ScriptGuardConfig): string {
+  return config.rewriteUrl ? config.rewriteUrl(originalUrl) : rewriteToFirstParty(config.proxyPath);
 }
 
 /**
- * Rewrite the URL attribute on a matched element to the first-party proxy.
+ * Create one reversible guard. Basic guards share only the insertion dispatcher;
+ * deep guards additionally own the browser patches required by self-loading SDKs.
  */
-function rewriteElement(candidate: DomInsertionCandidate, config: ScriptGuardConfig): void {
+export function createScriptGuard(config: ScriptGuardConfig): ScriptGuard {
   const prefix = `${config.displayName ?? config.id} guard`;
+  let installed = false;
+  let unregister: (() => void) | undefined;
+  let mutationObserver: MutationObserver | undefined;
+  let nativeDocWrite: typeof document.write | undefined;
+  let nativeDocWriteln: typeof document.writeln | undefined;
+  let documentWriteWrapper: typeof document.write | undefined;
+  let documentWritelnWrapper: typeof document.writeln | undefined;
+  let nativeCreateElement: typeof document.createElement | undefined;
+  let createElementWrapper: typeof document.createElement | undefined;
+  let nativeSetAttribute: typeof HTMLScriptElement.prototype.setAttribute | undefined;
+  let setAttributeWrapper: typeof HTMLScriptElement.prototype.setAttribute | undefined;
+  let nativeSrcDescriptor: PropertyDescriptor | undefined;
+  let nativeSrcGet: ((this: HTMLScriptElement) => string) | undefined;
+  let nativeSrcSet: ((this: HTMLScriptElement, value: string) => void) | undefined;
+  let installedSrcSetter: ((this: HTMLScriptElement, value: string) => void) | undefined;
+  let srcDescriptorInstalled = false;
+  let rewritten = new WeakMap<HTMLScriptElement | HTMLLinkElement, string>();
+  let patchedInstances = new Map<HTMLScriptElement, InstancePatch>();
 
-  if (candidate.kind === 'script') {
-    const rewritten = getRewrittenUrl(candidate.url, config);
+  const isTarget = (url: string): boolean => {
+    try {
+      return config.isTargetUrl(url);
+    } catch {
+      return false;
+    }
+  };
 
-    log.info(`${prefix}: rewriting dynamically inserted SDK script`, {
-      original: candidate.url,
-      rewritten,
-      framework: candidate.element.getAttribute('data-nscript') || 'generic',
-    });
+  const rewrite = (url: string): string => {
+    try {
+      return rewrittenUrl(url, config);
+    } catch {
+      return url;
+    }
+  };
 
-    candidate.element.src = rewritten;
-    candidate.element.setAttribute('src', rewritten);
-  } else {
-    const rewritten = getRewrittenUrl(candidate.url, config);
+  const applyScriptSource = (element: HTMLScriptElement, value: string): void => {
+    if (nativeSrcSet) {
+      nativeSrcSet.call(element, value);
+      return;
+    }
+    if (nativeSetAttribute) {
+      nativeSetAttribute.call(element, 'src', value);
+      return;
+    }
+    element.setAttribute('src', value);
+  };
 
+  const rewriteScriptSource = (element: HTMLScriptElement, rawUrl: string): boolean => {
+    if (!isTarget(rawUrl)) return false;
+    const finalUrl = rewrite(rawUrl);
+    if (finalUrl === rawUrl || rewritten.get(element) === finalUrl) return false;
+    rewritten.set(element, finalUrl);
+    log.info(`${prefix}: rewriting script src`, { original: rawUrl, rewritten: finalUrl });
+    applyScriptSource(element, finalUrl);
+    return true;
+  };
+
+  const rewriteLinkSource = (
+    element: HTMLLinkElement,
+    rawUrl: string,
+    rel: string | null
+  ): boolean => {
+    if (
+      (rel !== 'preload' && rel !== 'prefetch') ||
+      element.getAttribute('as') !== 'script' ||
+      !isTarget(rawUrl)
+    ) {
+      return false;
+    }
+    const finalUrl = rewrite(rawUrl);
+    if (finalUrl === rawUrl || rewritten.get(element) === finalUrl) return false;
+    rewritten.set(element, finalUrl);
+    log.info(`${prefix}: rewriting SDK ${rel} link`, { original: rawUrl, rewritten: finalUrl });
+    element.href = finalUrl;
+    element.setAttribute('href', finalUrl);
+    return true;
+  };
+
+  const rewriteCandidate = (candidate: DomInsertionCandidate): boolean => {
+    if (!isTarget(candidate.url)) return false;
+    if (candidate.kind === 'script') {
+      if (config.deepInterception) return rewriteScriptSource(candidate.element, candidate.url);
+      const finalUrl = rewrite(candidate.url);
+      candidate.element.src = finalUrl;
+      candidate.element.setAttribute('src', finalUrl);
+      log.info(`${prefix}: rewriting dynamically inserted SDK script`, {
+        framework: candidate.element.getAttribute('data-nscript') || 'generic',
+        original: candidate.url,
+        rewritten: finalUrl,
+      });
+      return true;
+    }
+    if (config.deepInterception) {
+      return rewriteLinkSource(candidate.element, candidate.url, candidate.rel);
+    }
+    const finalUrl = rewrite(candidate.url);
+    candidate.element.href = finalUrl;
+    candidate.element.setAttribute('href', finalUrl);
     log.info(`${prefix}: rewriting SDK ${candidate.rel} link`, {
+      as: candidate.element.getAttribute('as'),
       original: candidate.url,
-      rewritten,
       rel: candidate.rel,
-      as: candidate.element.getAttribute('as'),
+      rewritten: finalUrl,
     });
+    return true;
+  };
 
-    candidate.element.href = rewritten;
-    candidate.element.setAttribute('href', rewritten);
-  }
-}
+  const rewriteDocumentHtml = (html: string): string => {
+    const hint = config.deepInterception?.documentWriteUrlHint;
+    if (!hint || !html.includes(hint)) return html;
+    if (typeof DOMParser === 'undefined') {
+      log.warn(`${prefix}: DOMParser unavailable, blocking matching document.write HTML`);
+      return '';
+    }
+    try {
+      const parsed = new DOMParser().parseFromString(html, 'text/html');
+      const scripts = parsed.querySelectorAll('script[src]');
+      let changed = false;
+      for (let index = 0; index < scripts.length; index += 1) {
+        const script = scripts.item(index);
+        const rawUrl = script.getAttribute('src') ?? '';
+        if (!isTarget(rawUrl)) continue;
+        const finalUrl = rewrite(rawUrl);
+        if (finalUrl === rawUrl) continue;
+        script.setAttribute('src', finalUrl);
+        changed = true;
+      }
+      return changed ? (parsed.head?.innerHTML ?? '') + (parsed.body?.innerHTML ?? '') : html;
+    } catch (error) {
+      log.warn(`${prefix}: failed to parse matching document.write HTML, blocking`, error);
+      return '';
+    }
+  };
 
-/**
- * Create an independent script guard for a specific integration.
- */
-export function createScriptGuard(config: ScriptGuardConfig): ScriptGuard {
-  let installed = false;
-  let unregister: (() => void) | undefined;
-  const prefix = `${config.displayName ?? config.id} guard`;
+  const installDocumentWritePatch = (): void => {
+    if (typeof document === 'undefined') return;
+    nativeDocWrite = document.write;
+    nativeDocWriteln = document.writeln;
+    documentWriteWrapper = function (this: Document, ...args: string[]): void {
+      nativeDocWrite?.apply(
+        this,
+        args.map((value) => (typeof value === 'string' ? rewriteDocumentHtml(value) : value))
+      );
+    };
+    documentWritelnWrapper = function (this: Document, ...args: string[]): void {
+      nativeDocWriteln?.apply(
+        this,
+        args.map((value) => (typeof value === 'string' ? rewriteDocumentHtml(value) : value))
+      );
+    };
+    document.write = documentWriteWrapper;
+    document.writeln = documentWritelnWrapper;
+  };
 
-  function install(): void {
-    if (installed) {
-      log.debug(`${prefix}: already installed, skipping`);
+  const installSrcDescriptor = (): void => {
+    if (typeof HTMLScriptElement === 'undefined') return;
+    const descriptor = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');
+    if (!descriptor || typeof descriptor.set !== 'function' || descriptor.configurable === false) {
       return;
     }
+    nativeSrcDescriptor = descriptor;
+    nativeSrcGet = typeof descriptor.get === 'function' ? descriptor.get : undefined;
+    nativeSrcSet = descriptor.set;
+    installedSrcSetter = function (this: HTMLScriptElement, value: string): void {
+      const rawUrl = String(value ?? '');
+      if (!rewriteScriptSource(this, rawUrl)) applyScriptSource(this, rawUrl);
+    };
+    try {
+      Object.defineProperty(HTMLScriptElement.prototype, 'src', {
+        configurable: true,
+        enumerable: descriptor.enumerable ?? true,
+        get(this: HTMLScriptElement): string {
+          return nativeSrcGet ? nativeSrcGet.call(this) : (this.getAttribute('src') ?? '');
+        },
+        set: installedSrcSetter,
+      });
+      srcDescriptorInstalled = true;
+    } catch {
+      nativeSrcDescriptor = undefined;
+      nativeSrcGet = undefined;
+      nativeSrcSet = undefined;
+      installedSrcSetter = undefined;
+    }
+  };
 
-    if (typeof window === 'undefined' || typeof Element === 'undefined') {
-      log.debug(`${prefix}: not in browser environment, skipping`);
-      return;
+  const installSetAttributePatch = (): void => {
+    if (typeof HTMLScriptElement === 'undefined') return;
+    nativeSetAttribute = HTMLScriptElement.prototype.setAttribute;
+    setAttributeWrapper = function (this: HTMLScriptElement, name: string, value: string): void {
+      if (typeof name === 'string' && name.toLowerCase() === 'src') {
+        const rawUrl = String(value ?? '');
+        if (isTarget(rawUrl)) {
+          const finalUrl = rewrite(rawUrl);
+          if (finalUrl !== rawUrl && rewritten.get(this) !== finalUrl) {
+            rewritten.set(this, finalUrl);
+            nativeSetAttribute?.call(this, name, finalUrl);
+            return;
+          }
+        }
+      }
+      nativeSetAttribute?.call(this, name, value);
+    };
+    HTMLScriptElement.prototype.setAttribute = setAttributeWrapper;
+  };
+
+  const ensureInstancePatched = (element: HTMLScriptElement): void => {
+    if (srcDescriptorInstalled || patchedInstances.has(element)) return;
+    if (patchedInstances.size >= MAX_TRACKED_INSTANCE_PATCHES) return;
+    const previous = Object.getOwnPropertyDescriptor(element, 'src');
+    const setter = function (this: HTMLScriptElement, value: string): void {
+      const rawUrl = String(value ?? '');
+      if (!rewriteScriptSource(this, rawUrl)) applyScriptSource(this, rawUrl);
+    };
+    try {
+      Object.defineProperty(element, 'src', {
+        configurable: true,
+        enumerable: true,
+        get(this: HTMLScriptElement): string {
+          return nativeSrcGet ? nativeSrcGet.call(this) : (this.getAttribute('src') ?? '');
+        },
+        set: setter,
+      });
+      patchedInstances.set(element, { element, previous, setter });
+    } catch {
+      // The insertion dispatcher and observer remain fail-safe fallbacks.
     }
+  };
 
-    log.info(`${prefix}: installing DOM interception for SDK`);
+  const installCreateElementPatch = (): void => {
+    if (typeof document === 'undefined') return;
+    nativeCreateElement = document.createElement;
+    createElementWrapper = function (
+      this: Document,
+      tagName: string,
+      options?: ElementCreationOptions
+    ): HTMLElement {
+      const element = nativeCreateElement!.call(this, tagName, options);
+      if (typeof tagName === 'string' && tagName.toLowerCase() === 'script') {
+        ensureInstancePatched(element as HTMLScriptElement);
+      }
+      return element;
+    } as typeof document.createElement;
+    document.createElement = createElementWrapper;
+  };
 
-    unregister = registerDomInsertionHandler({
-      handle(candidate): boolean {
-        if (!config.isTargetUrl(candidate.url)) {
-          return false;
+  const inspectMutationNode = (node: Node): void => {
+    if (node instanceof HTMLScriptElement) {
+      const rawUrl = node.src || node.getAttribute('src') || '';
+      if (rawUrl) rewriteScriptSource(node, rawUrl);
+      return;
+    }
+    if (node instanceof HTMLLinkElement) {
+      rewriteLinkSource(
+        node,
+        node.href || node.getAttribute('href') || '',
+        node.getAttribute('rel')
+      );
+      return;
+    }
+    if (!(node instanceof Element)) return;
+    const descendants = node.querySelectorAll<HTMLScriptElement | HTMLLinkElement>(
+      'script[src],link[rel="preload"][as="script"],link[rel="prefetch"][as="script"]'
+    );
+    for (let index = 0; index < descendants.length; index += 1) {
+      inspectMutationNode(descendants.item(index));
+    }
+  };
+
+  const installMutationObserver = (): void => {
+    if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') return;
+    mutationObserver = new MutationObserver((records) => {
+      for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+        const record = records[recordIndex];
+        if (!record) continue;
+        if (record.type === 'attributes' && record.attributeName === 'src') {
+          inspectMutationNode(record.target);
+          continue;
         }
+        if (record.type !== 'childList') continue;
+        for (let nodeIndex = 0; nodeIndex < record.addedNodes.length; nodeIndex += 1) {
+          const node = record.addedNodes.item(nodeIndex);
+          if (node) inspectMutationNode(node);
+        }
+      }
+    });
+    mutationObserver.observe(document, {
+      attributeFilter: ['src'],
+      attributes: true,
+      childList: true,
+      subtree: true,
+    });
+  };
 
-        rewriteElement(candidate, config);
-        return true;
-      },
+  const install = (): void => {
+    if (installed) return;
+    if (
+      typeof window === 'undefined' ||
+      (!config.deepInterception && typeof Element === 'undefined')
+    ) {
+      return;
+    }
+    if (config.deepInterception) {
+      installDocumentWritePatch();
+      installSrcDescriptor();
+      installSetAttributePatch();
+      installCreateElementPatch();
+      installMutationObserver();
+    }
+    unregister = registerDomInsertionHandler({
+      handle: rewriteCandidate,
       id: config.id,
       priority: config.priority ?? DEFAULT_DOM_INSERTION_HANDLER_PRIORITY,
     });
-
     installed = true;
-    log.info(`${prefix}: DOM interception installed successfully`);
-  }
+  };
 
-  function isInstalled(): boolean {
-    return installed;
-  }
+  const reset = (): void => {
+    mutationObserver?.disconnect();
+    mutationObserver = undefined;
+    unregister?.();
+    unregister = undefined;
 
-  function reset(): void {
-    if (unregister) {
-      unregister();
-      unregister = undefined;
+    for (const patch of patchedInstances.values()) {
+      try {
+        const current = Object.getOwnPropertyDescriptor(patch.element, 'src');
+        if (current?.set !== patch.setter) continue;
+        if (patch.previous) Object.defineProperty(patch.element, 'src', patch.previous);
+        else Reflect.deleteProperty(patch.element, 'src');
+      } catch {
+        // External replacement wins; do not overwrite it during cleanup.
+      }
     }
+    patchedInstances.clear();
 
-    if (installed) {
-      log.debug(`${prefix}: reset and uninstalled`);
+    if (typeof document !== 'undefined') {
+      if (document.write === documentWriteWrapper && nativeDocWrite)
+        document.write = nativeDocWrite;
+      if (document.writeln === documentWritelnWrapper && nativeDocWriteln) {
+        document.writeln = nativeDocWriteln;
+      }
+      if (document.createElement === createElementWrapper && nativeCreateElement) {
+        document.createElement = nativeCreateElement;
+      }
+    }
+    if (typeof HTMLScriptElement !== 'undefined') {
+      if (HTMLScriptElement.prototype.setAttribute === setAttributeWrapper && nativeSetAttribute) {
+        HTMLScriptElement.prototype.setAttribute = nativeSetAttribute;
+      }
+      const current = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src');
+      if (current?.set === installedSrcSetter && nativeSrcDescriptor) {
+        try {
+          Object.defineProperty(HTMLScriptElement.prototype, 'src', nativeSrcDescriptor);
+        } catch {
+          // External hardening can make restoration impossible; keep cleanup contained.
+        }
+      }
     }
 
+    nativeDocWrite = undefined;
+    nativeDocWriteln = undefined;
+    documentWriteWrapper = undefined;
+    documentWritelnWrapper = undefined;
+    nativeCreateElement = undefined;
+    createElementWrapper = undefined;
+    nativeSetAttribute = undefined;
+    setAttributeWrapper = undefined;
+    nativeSrcDescriptor = undefined;
+    nativeSrcGet = undefined;
+    nativeSrcSet = undefined;
+    installedSrcSetter = undefined;
+    srcDescriptorInstalled = false;
+    rewritten = new WeakMap();
+    patchedInstances = new Map();
     installed = false;
-  }
+  };
 
-  return { install, isInstalled, reset };
+  return { install, isInstalled: () => installed, reset };
 }
diff --git a/crates/trusted-server-js/lib/src/shared/takeover.ts b/crates/trusted-server-js/lib/src/shared/takeover.ts
new file mode 100644
index 000000000..e5d8fe289
--- /dev/null
+++ b/crates/trusted-server-js/lib/src/shared/takeover.ts
@@ -0,0 +1,361 @@
+import type { BootFailureReason } from '../kernel/fallback_surface';
+
+import type {
+  FinalizedFirstDisplayHandoffV1,
+  FirstDisplayAgentCaptureFinalizerV1,
+} from './first_display_handoff';
+
+export type FirstDisplayGptDiagnosticEventV1 =
+  | 'slotRequested'
+  | 'slotResponseReceived'
+  | 'slotRenderEnded'
+  | 'slotOnload'
+  | 'impressionViewable'
+  | 'slotVisibilityChanged';
+
+export type FirstDisplayGptDiagnosticDispositionV1 = 'matched' | 'unmatched' | 'ambiguous';
+
+export type FirstDisplayGptDiagnosticIssueReasonV1 =
+  'no_request_cycle' | 'overlapping_request_cycles' | 'unknown_prior_cycle' | 'invalid_event_order';
+
+/** Exact ordinary-data GPT observation permitted to cross the first-display handoff. */
+export interface FirstDisplayGptFactV1 {
+  readonly version: 1;
+  readonly event: FirstDisplayGptDiagnosticEventV1;
+  readonly token: string;
+  readonly runtimeSlotNumber: number;
+  readonly cycleOrdinal: number | null;
+  readonly disposition: FirstDisplayGptDiagnosticDispositionV1;
+  readonly issueReason: FirstDisplayGptDiagnosticIssueReasonV1 | null;
+  readonly capturedAtMs: number;
+  readonly elementId: string | null;
+  readonly adUnitPath: string | null;
+  readonly requestedSlotSizes: readonly (readonly [number, number])[] | null;
+  readonly isEmpty: boolean | null;
+  readonly renderedSize: readonly [number, number] | null;
+  readonly isBackfill: boolean | null;
+  readonly slotContentChanged: boolean | null;
+  readonly visibilityPercent: number | null;
+}
+
+export interface FirstDisplayGptDiagnosticsV1 {
+  readonly facts: readonly Readonly<FirstDisplayGptFactV1>[];
+  readonly overflowCount: number;
+  readonly dropCount: number;
+}
+
+export interface PersistentFirstDisplayAdoptionV1 {
+  readonly version: 1;
+  readonly adoptInitialDisplay: true;
+  readonly handoff: Readonly<Record<string, unknown>>;
+  readonly identities: readonly object[];
+}
+
+export interface PersistentFirstDisplaySliceStateV1 {
+  readonly sliceId: string;
+  readonly observations: readonly string[];
+  readonly values: readonly (readonly [string, string | number | boolean | null])[];
+}
+
+function exactDataRecord(
+  candidate: unknown,
+  expected: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    Array.isArray(candidate) ||
+    Object.getPrototypeOf(candidate) !== Object.prototype
+  ) {
+    return undefined;
+  }
+  const keys = Reflect.ownKeys(candidate);
+  if (
+    keys.length !== expected.length ||
+    !keys.every((key) => typeof key === 'string' && expected.includes(key))
+  ) {
+    return undefined;
+  }
+  const fields: Record<string, unknown> = {};
+  for (const key of expected) {
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+    if (!descriptor?.enumerable || !('value' in descriptor)) return undefined;
+    fields[key] = descriptor.value;
+  }
+  return fields;
+}
+
+function exactFrozenIdentities(candidate: unknown): candidate is readonly object[] {
+  if (!Array.isArray(candidate) || !Object.isFrozen(candidate) || candidate.length > 512) {
+    return false;
+  }
+  const expectedKeys = Array.from({ length: candidate.length }, (_, index) => String(index));
+  expectedKeys.push('length');
+  const actualKeys = Reflect.ownKeys(candidate);
+  if (
+    actualKeys.length !== expectedKeys.length ||
+    !actualKeys.every((key) => typeof key === 'string' && expectedKeys.includes(key))
+  ) {
+    return false;
+  }
+  for (let index = 0; index < candidate.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+    const identity = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+    if (
+      !descriptor?.enumerable ||
+      (typeof identity !== 'object' && typeof identity !== 'function') ||
+      identity === null
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** Validate only the closure-private outer adoption carrier without cloning object identities. */
+export function snapshotPersistentFirstDisplayAdoptionV1(
+  candidate: unknown
+): PersistentFirstDisplayAdoptionV1 | undefined {
+  try {
+    if (!Object.isFrozen(candidate)) return undefined;
+    const fields = exactDataRecord(candidate, [
+      'version',
+      'adoptInitialDisplay',
+      'handoff',
+      'identities',
+    ]);
+    if (
+      !fields ||
+      fields.version !== 1 ||
+      fields.adoptInitialDisplay !== true ||
+      typeof fields.handoff !== 'object' ||
+      fields.handoff === null ||
+      Array.isArray(fields.handoff) ||
+      Object.getPrototypeOf(fields.handoff) !== Object.prototype ||
+      !Object.isFrozen(fields.handoff) ||
+      !exactFrozenIdentities(fields.identities)
+    ) {
+      return undefined;
+    }
+    return candidate as PersistentFirstDisplayAdoptionV1;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Select one exact parser-time slice snapshot from a validated takeover carrier. */
+export function snapshotPersistentFirstDisplaySliceStateV1(
+  candidate: unknown,
+  sliceId: string
+): Readonly<PersistentFirstDisplaySliceStateV1> | undefined {
+  try {
+    const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+    if (!adoption || typeof sliceId !== 'string' || sliceId.length === 0) return undefined;
+    const slicesDescriptor = Object.getOwnPropertyDescriptor(adoption.handoff, 'slices');
+    const parserDescriptor = Object.getOwnPropertyDescriptor(adoption.handoff, 'parserState');
+    const slices = slicesDescriptor && 'value' in slicesDescriptor ? slicesDescriptor.value : null;
+    const parserState =
+      parserDescriptor && 'value' in parserDescriptor ? parserDescriptor.value : null;
+    if (
+      !Array.isArray(slices) ||
+      !Object.isFrozen(slices) ||
+      !slices.includes(sliceId) ||
+      !Array.isArray(parserState) ||
+      !Object.isFrozen(parserState)
+    ) {
+      return undefined;
+    }
+    const matches = parserState.filter((entry) => {
+      const descriptor =
+        typeof entry === 'object' && entry !== null
+          ? Object.getOwnPropertyDescriptor(entry, 'sliceId')
+          : undefined;
+      return descriptor && 'value' in descriptor && descriptor.value === sliceId;
+    });
+    if (matches.length !== 1) return undefined;
+    const row = matches[0];
+    if (!Object.isFrozen(row)) return undefined;
+    const fields = exactDataRecord(row, ['sliceId', 'observations', 'values']);
+    if (!fields || !Array.isArray(fields.observations) || !Array.isArray(fields.values)) {
+      return undefined;
+    }
+    if (
+      !Object.isFrozen(fields.observations) ||
+      !Object.isFrozen(fields.values) ||
+      fields.observations.length > 256 ||
+      fields.values.length !== fields.observations.length
+    ) {
+      return undefined;
+    }
+    const observations: string[] = [];
+    const values: Array<readonly [string, string | number | boolean | null]> = [];
+    for (let index = 0; index < fields.observations.length; index += 1) {
+      const key = fields.observations[index];
+      const pair = fields.values[index];
+      if (
+        typeof key !== 'string' ||
+        key.length === 0 ||
+        observations.includes(key) ||
+        !Array.isArray(pair) ||
+        !Object.isFrozen(pair) ||
+        pair.length !== 2 ||
+        pair[0] !== key
+      ) {
+        return undefined;
+      }
+      const value = pair[1];
+      if (
+        value !== null &&
+        typeof value !== 'string' &&
+        typeof value !== 'boolean' &&
+        !(typeof value === 'number' && Number.isFinite(value))
+      ) {
+        return undefined;
+      }
+      observations.push(key);
+      values.push(Object.freeze([key, value] as const));
+    }
+    return Object.freeze({
+      sliceId,
+      observations: Object.freeze(observations),
+      values: Object.freeze(values),
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+/** Report whether one validated takeover selected an exact parser-time slice. */
+export function persistentFirstDisplaySliceSelectedV1(
+  candidate: unknown,
+  sliceId: string
+): boolean | undefined {
+  try {
+    const adoption = snapshotPersistentFirstDisplayAdoptionV1(candidate);
+    if (!adoption || typeof sliceId !== 'string' || sliceId.length === 0) return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(adoption.handoff, 'slices');
+    const slices = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+    if (
+      !Array.isArray(slices) ||
+      !Object.isFrozen(slices) ||
+      slices.length === 0 ||
+      slices[0] !== 'first_display' ||
+      slices.some((value) => typeof value !== 'string') ||
+      new Set(slices).size !== slices.length
+    ) {
+      return undefined;
+    }
+    return slices.includes(sliceId);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Validate one selected parser row while allowing an integration absent from the initial batch. */
+export function validatePersistentFirstDisplaySliceAdoptionV1(
+  candidate: unknown,
+  sliceId: string,
+  validate?: (state: Readonly<PersistentFirstDisplaySliceStateV1>) => boolean
+): boolean {
+  const selected = persistentFirstDisplaySliceSelectedV1(candidate, sliceId);
+  if (selected === undefined) return false;
+  if (!selected) return true;
+  const state = snapshotPersistentFirstDisplaySliceStateV1(candidate, sliceId);
+  if (!state) return false;
+  try {
+    return validate?.(state) ?? true;
+  } catch {
+    return false;
+  }
+}
+
+export const FIRST_DISPLAY_TAKEOVER_FIELD = '_firstDisplayTakeover' as const;
+
+/** One-use old-owner lease claimed only after persistent preparation is complete. */
+export type ClaimedFirstDisplayTakeoverV1 = readonly [
+  finalized: FinalizedFirstDisplayHandoffV1,
+  outline: unknown,
+  isCurrentGeneration: () => boolean,
+  authenticateRuntimeScript: () => boolean,
+  currentMutationRevision: () => number,
+  detachCommittedArtifacts: () => boolean,
+  disposeAgent: () => void,
+  onFailure: (reason: BootFailureReason) => void,
+  onCommit: () => void,
+  trustedScriptUrl: (value: string) => unknown,
+  currentScript: () => HTMLScriptElement | null,
+];
+
+export type FirstDisplayTakeoverClaim = (
+  source: unknown,
+  finalize: FirstDisplayAgentCaptureFinalizerV1
+) => ClaimedFirstDisplayTakeoverV1 | undefined;
+
+export type FirstDisplayTakeoverTransportResult =
+  | Readonly<{ status: 'absent' }>
+  | Readonly<{ status: 'invalid' }>
+  | Readonly<{ status: 'accepted'; claim: FirstDisplayTakeoverClaim }>;
+
+/** Install one non-enumerable, one-use handoff sink shared only by bootstrap and core IIFEs. */
+export function installFirstDisplayTakeoverTransport(
+  target: object,
+  claim: FirstDisplayTakeoverClaim
+): (() => void) | undefined {
+  if (
+    typeof claim !== 'function' ||
+    Object.getOwnPropertyDescriptor(target, FIRST_DISPLAY_TAKEOVER_FIELD)
+  ) {
+    return undefined;
+  }
+  let live = true;
+  const installed: FirstDisplayTakeoverClaim = (source, finalize) => {
+    if (!live) return undefined;
+    try {
+      const result = claim(source, finalize);
+      if (result !== undefined) live = false;
+      return result;
+    } catch (error) {
+      live = false;
+      throw error;
+    }
+  };
+  try {
+    Object.defineProperty(target, FIRST_DISPLAY_TAKEOVER_FIELD, {
+      configurable: false,
+      enumerable: false,
+      value: installed,
+      writable: false,
+    });
+  } catch {
+    return undefined;
+  }
+  return (): void => {
+    if (!live) return;
+    live = false;
+  };
+}
+
+/** Consume the exact bootstrap-owned sink before persistent preparation starts. */
+export function consumeFirstDisplayTakeoverTransport(
+  target: object
+): FirstDisplayTakeoverTransportResult {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(target, FIRST_DISPLAY_TAKEOVER_FIELD);
+    if (!descriptor) return Object.freeze({ status: 'absent' });
+    if (
+      descriptor.configurable ||
+      descriptor.enumerable ||
+      descriptor.writable ||
+      !('value' in descriptor) ||
+      typeof descriptor.value !== 'function'
+    ) {
+      return Object.freeze({ status: 'invalid' });
+    }
+    return Object.freeze({
+      status: 'accepted',
+      claim: descriptor.value as FirstDisplayTakeoverClaim,
+    });
+  } catch {
+    return Object.freeze({ status: 'invalid' });
+  }
+}
diff --git a/crates/trusted-server-js/lib/test/adapters/googletag.test.ts b/crates/trusted-server-js/lib/test/adapters/googletag.test.ts
new file mode 100644
index 000000000..75a1437bf
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/adapters/googletag.test.ts
@@ -0,0 +1,3547 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createBrowserGoogletagAdapter,
+  createGoogletagTraceCycleHandle,
+  type GoogletagDiagnosticsFact,
+} from '../../src/adapters/googletag';
+
+type Command = () => void;
+
+function createReadyGoogletag(
+  options: {
+    readonly deferCommands?: boolean;
+    readonly initialLoadDisabled?: boolean;
+    readonly servicesEnabled?: boolean;
+  } = {}
+) {
+  const commands: Command[] = [];
+  const display = vi.fn();
+  const initialLoad = { disabled: options.initialLoadDisabled === true };
+  const listeners = new Map<string, Set<(event: unknown) => void>>();
+  const pubads = {
+    addEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      const registered = listeners.get(type) ?? new Set();
+      registered.add(listener);
+      listeners.set(type, registered);
+    }),
+    disableInitialLoad: vi.fn(() => {
+      initialLoad.disabled = true;
+      return 'legacy-result';
+    }),
+    enableSingleRequest: vi.fn(() => true),
+    getSlots: vi.fn<() => object[]>(() => []),
+    refresh: vi.fn(),
+    removeEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      listeners.get(type)?.delete(listener);
+    }),
+  };
+  const googletag = {
+    apiReady: true,
+    pubadsReady: options.servicesEnabled !== false,
+    cmd: {
+      push: vi.fn((command: Command): number => {
+        if (options.deferCommands) commands.push(command);
+        else command();
+        return commands.length;
+      }),
+    },
+    defineSlot: vi.fn(),
+    destroySlots: vi.fn(),
+    display,
+    enableServices: vi.fn(() => {
+      googletag.pubadsReady = true;
+    }),
+    getConfig: vi.fn((key: string) =>
+      key === 'disableInitialLoad' ? { disableInitialLoad: initialLoad.disabled } : {}
+    ),
+    pubads: vi.fn(() => pubads),
+    setConfig: vi.fn((config: { readonly disableInitialLoad?: boolean | null }) => {
+      if (Object.prototype.hasOwnProperty.call(config, 'disableInitialLoad')) {
+        initialLoad.disabled = config.disableInitialLoad === true;
+      }
+      return 'config-result';
+    }),
+  };
+  return { commands, display, googletag, initialLoad, listeners, pubads };
+}
+
+describe('browser googletag adapter readiness', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('enqueues GAM attribution once before later publisher commands', () => {
+    const ready = createReadyGoogletag({ deferCommands: true });
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const order: string[] = [];
+    ready.googletag.setConfig.mockImplementation((config) => {
+      order.push('trusted-server');
+      return JSON.stringify(config);
+    });
+
+    expect(adapter.enqueueGamAttribution()).toBe(true);
+    expect(adapter.enqueueGamAttribution()).toBe(true);
+    ready.googletag.cmd.push(() => order.push('publisher'));
+
+    expect(ready.commands).toHaveLength(2);
+    ready.commands.splice(0).forEach((command) => command());
+    expect(order).toEqual(['trusted-server', 'publisher']);
+    expect(ready.googletag.setConfig).toHaveBeenCalledExactlyOnceWith({
+      targeting: { ts: 'true' },
+    });
+  });
+
+  it('creates an absent GPT queue and isolates a missing or throwing targeting API', () => {
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+
+    expect(adapter.enqueueGamAttribution()).toBe(true);
+    const created = target.googletag as { cmd: Array<() => void> };
+    expect(created.cmd).toHaveLength(1);
+    expect(() => created.cmd[0]?.()).not.toThrow();
+
+    const publisher = vi.fn();
+    const throwing = createReadyGoogletag();
+    throwing.googletag.setConfig.mockImplementation(() => {
+      throw new Error('targeting unavailable');
+    });
+    const throwingAdapter = createBrowserGoogletagAdapter({ googletag: throwing.googletag });
+    expect(throwingAdapter.enqueueGamAttribution()).toBe(true);
+    expect(() => throwing.googletag.cmd.push(publisher)).not.toThrow();
+    expect(publisher).toHaveBeenCalledOnce();
+  });
+
+  it('reports present and gives the command only a frozen narrow facade', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const operation = adapter.run((gpt) => {
+      expect(Object.isFrozen(gpt)).toBe(true);
+      expect('cmd' in gpt).toBe(false);
+      expect('apiReady' in gpt).toBe(false);
+      gpt.display('slot-a');
+      return 'completed';
+    });
+
+    expect(operation.status).toBe('present');
+    await expect(operation.result).resolves.toBe('completed');
+    expect(ready.display).toHaveBeenCalledWith('slot-a');
+  });
+
+  it('defines and adopts one GPT slot as a synchronous rollback-capable transaction', async () => {
+    const ready = createReadyGoogletag();
+    const slot = { addService: vi.fn() };
+    ready.googletag.defineSlot.mockReturnValue(slot);
+    ready.googletag.destroySlots.mockReturnValue(true);
+    const commit = vi.fn(() => true);
+    const rollback = vi.fn();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+
+    const operation = adapter.run((gpt) =>
+      gpt.transactionalDefine(
+        {
+          adUnitPath: '/123/slot-a',
+          elementId: 'slot-a',
+          sizes: [[300, 250]],
+        },
+        () => true,
+        (candidate) => {
+          expect(candidate).toBe(slot);
+          return Object.freeze({ commit, rollback });
+        }
+      )
+    );
+
+    await expect(operation.result).resolves.toEqual({ status: 'defined', slot });
+    expect(ready.googletag.defineSlot).toHaveBeenCalledExactlyOnceWith(
+      '/123/slot-a',
+      [[300, 250]],
+      'slot-a'
+    );
+    expect(slot.addService).toHaveBeenCalledExactlyOnceWith(ready.pubads);
+    expect(commit).toHaveBeenCalledOnce();
+    expect(rollback).not.toHaveBeenCalled();
+    expect(ready.googletag.destroySlots).not.toHaveBeenCalled();
+    expect(slot.addService.mock.invocationCallOrder[0]).toBeLessThan(
+      commit.mock.invocationCallOrder[0]!
+    );
+  });
+
+  it('destroys a newly defined GPT slot when its navigation becomes stale before adoption', async () => {
+    const ready = createReadyGoogletag();
+    const slot = { addService: vi.fn() };
+    ready.googletag.defineSlot.mockReturnValue(slot);
+    ready.googletag.destroySlots.mockReturnValue(true);
+    const isGenerationCurrent = vi.fn().mockReturnValueOnce(true).mockReturnValue(false);
+    const prepareCommit = vi.fn();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+
+    const operation = adapter.run((gpt) =>
+      gpt.transactionalDefine(
+        {
+          adUnitPath: '/123/slot-a',
+          elementId: 'slot-a',
+          sizes: [[300, 250]],
+        },
+        isGenerationCurrent,
+        prepareCommit
+      )
+    );
+
+    await expect(operation.result).resolves.toEqual({ status: 'discarded' });
+    expect(prepareCommit).not.toHaveBeenCalled();
+    expect(slot.addService).not.toHaveBeenCalled();
+    expect(ready.googletag.destroySlots).toHaveBeenCalledExactlyOnceWith([slot]);
+  });
+
+  it('marks and measures only the first TS-authoritative display', async () => {
+    const ready = createReadyGoogletag();
+    const performance = {
+      mark: vi.fn(),
+      measure: vi.fn(),
+    };
+    const target = { googletag: ready.googletag, performance };
+    const adapter = createBrowserGoogletagAdapter(target);
+
+    ready.googletag.display('publisher-slot');
+    expect(performance.mark).not.toHaveBeenCalled();
+
+    const first = adapter.run((gpt) => {
+      gpt.display('trusted-slot-one');
+      gpt.display('trusted-slot-two');
+    });
+    await expect(first.result).resolves.toBeUndefined();
+    const replay = adapter.run((gpt) => gpt.display('trusted-slot-three'));
+    await expect(replay.result).resolves.toBeUndefined();
+
+    expect(performance.mark).toHaveBeenCalledExactlyOnceWith('tsjs:first-display');
+    expect(performance.measure).toHaveBeenCalledExactlyOnceWith(
+      'tsjs:boot-to-first-display',
+      'tsjs:bids-script',
+      'tsjs:first-display'
+    );
+    expect(performance.mark.mock.invocationCallOrder[0]).toBeLessThan(
+      ready.display.mock.invocationCallOrder[1]!
+    );
+  });
+
+  it('contains missing and throwing Performance APIs at the first display boundary', async () => {
+    const missing = createReadyGoogletag();
+    const missingAdapter = createBrowserGoogletagAdapter({ googletag: missing.googletag });
+    await expect(missingAdapter.run((gpt) => gpt.display('slot-missing')).result).resolves.toBe(
+      undefined
+    );
+    expect(missing.display).toHaveBeenCalledExactlyOnceWith('slot-missing');
+
+    const throwing = createReadyGoogletag();
+    const mark = vi.fn(() => {
+      throw new Error('performance unavailable');
+    });
+    const measure = vi.fn();
+    const target = { googletag: throwing.googletag, performance: { mark, measure } };
+    const throwingAdapter = createBrowserGoogletagAdapter(target);
+    await expect(
+      throwingAdapter.run((gpt) => {
+        gpt.display('slot-throwing');
+        gpt.display('slot-replay');
+      }).result
+    ).resolves.toBeUndefined();
+
+    expect(mark).toHaveBeenCalledExactlyOnceWith('tsjs:first-display');
+    expect(measure).not.toHaveBeenCalled();
+    expect(throwing.display).toHaveBeenCalledTimes(2);
+
+    const markOnly = createReadyGoogletag();
+    const markWithoutMeasure = vi.fn();
+    const markOnlyAdapter = createBrowserGoogletagAdapter({
+      googletag: markOnly.googletag,
+      performance: { mark: markWithoutMeasure },
+    });
+    await expect(markOnlyAdapter.run((gpt) => gpt.display('slot-mark-only')).result).resolves.toBe(
+      undefined
+    );
+    expect(markWithoutMeasure).toHaveBeenCalledExactlyOnceWith('tsjs:first-display');
+    expect(markOnly.display).toHaveBeenCalledExactlyOnceWith('slot-mark-only');
+  });
+
+  it('does not mark a display rejected from a stale GPT generation', async () => {
+    const first = createReadyGoogletag();
+    const replacement = createReadyGoogletag();
+    const performance = { mark: vi.fn(), measure: vi.fn() };
+    const target = { googletag: first.googletag, performance };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operation = adapter.run((gpt) => {
+      target.googletag = replacement.googletag;
+      gpt.display('stale-slot');
+    });
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(performance.mark).not.toHaveBeenCalled();
+    expect(performance.measure).not.toHaveBeenCalled();
+    expect(first.display).not.toHaveBeenCalled();
+    expect(replacement.display).not.toHaveBeenCalled();
+
+    await expect(adapter.run((gpt) => gpt.display('current-slot')).result).resolves.toBeUndefined();
+    expect(performance.mark).toHaveBeenCalledExactlyOnceWith('tsjs:first-display');
+    expect(replacement.display).toHaveBeenCalledExactlyOnceWith('current-slot');
+  });
+
+  it('reports pending and drains live operations FIFO through a real GPT command notification', async () => {
+    const readinessCommands: Command[] = [];
+    const target: { googletag?: unknown } = {
+      googletag: { cmd: readinessCommands },
+    };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const order: number[] = [];
+    const first = adapter.run(() => order.push(1));
+    const second = adapter.run(() => order.push(2));
+
+    expect(first.status).toBe('pending');
+    expect(second.status).toBe('pending');
+    expect(readinessCommands).toHaveLength(1);
+
+    target.googletag = createReadyGoogletag().googletag;
+    readinessCommands[0]?.();
+
+    await expect(first.result).resolves.toBe(1);
+    await expect(second.result).resolves.toBe(2);
+    expect(order).toEqual([1, 2]);
+    expect(first.status).toBe('present');
+    expect(second.status).toBe('present');
+  });
+
+  it.each(['before', 'after'] as const)(
+    'recovers GPT notification arming when WeakSet.add throws %s insertion',
+    async (failure) => {
+      const readinessCommands: Command[] = [];
+      const target: { googletag?: unknown } = { googletag: { cmd: readinessCommands } };
+      const adapter = createBrowserGoogletagAdapter(target);
+      const originalWeakSetAdd = WeakSet.prototype.add;
+      WeakSet.prototype.add = function (this: WeakSet<object>, value: object): WeakSet<object> {
+        if (failure === 'after') Reflect.apply(originalWeakSetAdd, this, [value]);
+        throw new Error(`GPT arming failed ${failure} insertion`);
+      } as typeof WeakSet.prototype.add;
+
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(() => 'ready');
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakSet.prototype.add = originalWeakSetAdd;
+      }
+
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      expect(readinessCommands).toHaveLength(0);
+      adapter.notifyReady();
+      expect(readinessCommands).toHaveLength(1);
+      target.googletag = createReadyGoogletag().googletag;
+      readinessCommands[0]?.();
+      await expect(operation.result).resolves.toBe('ready');
+      adapter.dispose();
+    }
+  );
+
+  it('recovers GPT notification arming when WeakSet.has throws after publication', async () => {
+    vi.useFakeTimers();
+    const readinessCommands: Command[] = [];
+    const target: { googletag?: unknown } = { googletag: { cmd: readinessCommands } };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const order: number[] = [];
+    const originalWeakSetHas = WeakSet.prototype.has;
+    WeakSet.prototype.has = function (): boolean {
+      throw new Error('GPT armed lookup failed');
+    } as typeof WeakSet.prototype.has;
+
+    let first: ReturnType<typeof adapter.run> | undefined;
+    let thrown: unknown;
+    try {
+      first = adapter.run(() => order.push(1));
+    } catch (error) {
+      thrown = error;
+    } finally {
+      WeakSet.prototype.has = originalWeakSetHas;
+    }
+
+    expect(thrown).toBeUndefined();
+    if (!first) throw new Error('Expected a published GPT operation');
+    expect(readinessCommands).toHaveLength(1);
+    const second = adapter.run(() => order.push(2));
+    expect(readinessCommands).toHaveLength(1);
+    target.googletag = createReadyGoogletag().googletag;
+    readinessCommands[0]?.();
+    await expect(Promise.all([first.result, second.result])).resolves.toEqual([1, 2]);
+    expect(order).toEqual([1, 2]);
+    expect(vi.getTimerCount()).toBe(0);
+
+    target.googletag = undefined;
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    for (const operation of recovered) operation.dispose();
+    await Promise.all(recoveredResults);
+    expect(vi.getTimerCount()).toBe(0);
+    adapter.dispose();
+  });
+
+  it.each([
+    { pushFailure: 'before', deleteFailure: 'throw' },
+    { pushFailure: 'after', deleteFailure: 'retain' },
+  ] as const)(
+    'retries GPT notification registration after $pushFailure enqueue failure and $deleteFailure rollback',
+    async ({ pushFailure, deleteFailure }) => {
+      vi.useFakeTimers();
+      const readinessCommands: Command[] = [];
+      let queueBroken = true;
+      const push = vi.fn((command: Command): number => {
+        if (queueBroken) {
+          if (pushFailure === 'after') readinessCommands.push(command);
+          throw new Error(`GPT queue failed ${pushFailure} enqueue`);
+        }
+        readinessCommands.push(command);
+        return readinessCommands.length;
+      });
+      const target: { googletag?: unknown } = { googletag: { cmd: { push } } };
+      const adapter = createBrowserGoogletagAdapter(target);
+      const order: number[] = [];
+      const originalWeakSetDelete = WeakSet.prototype.delete;
+      WeakSet.prototype.delete = function (): boolean {
+        if (deleteFailure === 'throw') throw new Error('GPT arming rollback failed');
+        return false;
+      } as typeof WeakSet.prototype.delete;
+
+      let first: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        first = adapter.run(() => order.push(1));
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakSet.prototype.delete = originalWeakSetDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      if (!first) throw new Error('Expected a published GPT operation');
+      expect(readinessCommands).toHaveLength(pushFailure === 'after' ? 1 : 0);
+      queueBroken = false;
+      const second = adapter.run(() => order.push(2));
+      expect(readinessCommands).toHaveLength(pushFailure === 'after' ? 2 : 1);
+
+      target.googletag = createReadyGoogletag().googletag;
+      if (pushFailure === 'after') {
+        readinessCommands[0]?.();
+        expect(order).toEqual([]);
+      }
+      readinessCommands[readinessCommands.length - 1]?.();
+      await expect(Promise.all([first.result, second.result])).resolves.toEqual([1, 2]);
+      expect(order).toEqual([1, 2]);
+      for (const notify of readinessCommands) notify();
+      expect(order).toEqual([1, 2]);
+      expect(vi.getTimerCount()).toBe(0);
+
+      target.googletag = undefined;
+      const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+      const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      for (const operation of recovered) operation.dispose();
+      await Promise.all(recoveredResults);
+      expect(vi.getTimerCount()).toBe(0);
+      adapter.dispose();
+    }
+  );
+
+  it('rejects a queued operation when its pending GPT stub becomes incompatible', async () => {
+    const readinessCommands: Command[] = [];
+    const ready = createReadyGoogletag();
+    const binding: Record<string, unknown> = {
+      ...ready.googletag,
+      apiReady: false,
+      cmd: readinessCommands,
+    };
+    const adapter = createBrowserGoogletagAdapter({ googletag: binding });
+    const command = vi.fn();
+    const operation = adapter.run(command);
+
+    binding['apiReady'] = true;
+    delete binding['display'];
+    readinessCommands[0]?.();
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(operation.status).toBe('incompatible');
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('requires the captured GPT queue and root methods to remain compatible', async () => {
+    const mutations = [
+      (binding: Record<string, unknown>): void => {
+        binding['apiReady'] = false;
+      },
+      (binding: Record<string, unknown>): void => {
+        binding['display'] = vi.fn();
+      },
+      (binding: Record<string, unknown>): void => {
+        binding['pubads'] = vi.fn();
+      },
+      (binding: Record<string, unknown>): void => {
+        binding['cmd'] = { push: vi.fn() };
+      },
+    ];
+    for (const mutate of mutations) {
+      const ready = createReadyGoogletag({ deferCommands: true });
+      const binding = ready.googletag as unknown as Record<string, unknown>;
+      const adapter = createBrowserGoogletagAdapter({ googletag: binding });
+      const command = vi.fn();
+      const operation = adapter.run(command);
+
+      mutate(binding);
+      ready.commands[0]?.();
+
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+      expect(operation.status).toBe('incompatible');
+      expect(command).not.toHaveBeenCalled();
+    }
+  });
+
+  it('rechecks GPT compatibility after an in-place getter mutation', async () => {
+    const ready = createReadyGoogletag({ deferCommands: true });
+    const binding = ready.googletag as unknown as Record<string, unknown>;
+    const originalDisplay = ready.googletag.display;
+    const adapter = createBrowserGoogletagAdapter({ googletag: binding });
+    const command = vi.fn();
+    const operation = adapter.run(command);
+    Object.defineProperty(binding, 'display', {
+      configurable: true,
+      get: () => {
+        binding['apiReady'] = false;
+        return originalDisplay;
+      },
+    });
+
+    ready.commands[0]?.();
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('ignores a stale GPT notification and lets the replacement notification decide', async () => {
+    const oldNotifications: Command[] = [];
+    const replacementNotifications: Command[] = [];
+    const oldBinding = { cmd: oldNotifications };
+    const replacement: Record<string, unknown> = { cmd: replacementNotifications };
+    const target: { googletag?: unknown } = { googletag: oldBinding };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const first = adapter.run(() => 'first');
+    target.googletag = replacement;
+    const second = adapter.run(() => 'second');
+
+    replacement['apiReady'] = true;
+    oldNotifications[0]?.();
+    expect(first.status).toBe('pending');
+    expect(second.status).toBe('pending');
+
+    replacementNotifications[0]?.();
+    await expect(first.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    await expect(second.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+  });
+
+  it('does not let a stale GPT notification condemn a primitive replacement', async () => {
+    const oldNotifications: Command[] = [];
+    const target: { googletag?: unknown } = { googletag: { cmd: oldNotifications } };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operation = adapter.run(vi.fn());
+    const result = operation.result.catch((error: unknown) => error);
+    target.googletag = 1;
+
+    oldNotifications[0]?.();
+    expect(operation.status).toBe('pending');
+    adapter.dispose();
+    await expect(result).resolves.toMatchObject({ code: 'operation_disposed' });
+  });
+
+  it('marks only the current operation incompatible and permits a later replacement', async () => {
+    const target = { googletag: { apiReady: true, cmd: {} } };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const incompatible = adapter.run(vi.fn());
+
+    expect(incompatible.status).toBe('incompatible');
+    await expect(incompatible.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+
+    target.googletag = createReadyGoogletag().googletag;
+    const replacement = adapter.run(() => 'replacement');
+    expect(replacement.status).toBe('present');
+    await expect(replacement.result).resolves.toBe('replacement');
+  });
+
+  it('holds 64 pending operations and fails only overflow synchronously', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operations = Array.from({ length: 64 }, () => adapter.run(() => undefined));
+
+    expect(operations.every(({ status }) => status === 'pending')).toBe(true);
+    expect(() => adapter.run(() => undefined)).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await expect(Promise.all(operations.map(({ result }) => result))).resolves.toHaveLength(64);
+  });
+
+  it('reserves pending GPT capacity before hostile signal registration reenters', async () => {
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const accepted: Array<ReturnType<typeof adapter.run>> = [];
+    const overflows: unknown[] = [];
+    const order: number[] = [];
+    const signal = {
+      aborted: false,
+      addEventListener: vi.fn(() => {
+        for (let index = 1; index <= 64; index += 1) {
+          try {
+            accepted.push(adapter.run(() => order.push(index)));
+          } catch (error) {
+            overflows.push(error);
+          }
+        }
+      }),
+      removeEventListener: vi.fn(),
+    } as unknown as AbortSignal;
+
+    const outer = adapter.run(() => order.push(0), { signal });
+
+    expect(accepted).toHaveLength(63);
+    expect(overflows).toHaveLength(1);
+    expect(overflows[0]).toMatchObject({ code: 'external_queue_full' });
+
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await expect(
+      Promise.all([outer.result, ...accepted.map(({ result }) => result)])
+    ).resolves.toHaveLength(64);
+    expect(order).toEqual(Array.from({ length: 64 }, (_, index) => index));
+  });
+
+  it('reserves pending GPT capacity before poisoned Set.add reenters', async () => {
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const accepted: Array<ReturnType<typeof adapter.run>> = [];
+    const overflows: unknown[] = [];
+    const order: number[] = [];
+    const originalSetAdd = Set.prototype.add;
+    let reentered = false;
+    Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+      if (!reentered) {
+        reentered = true;
+        Set.prototype.add = originalSetAdd;
+        for (let index = 1; index <= 64; index += 1) {
+          try {
+            accepted.push(adapter.run(() => order.push(index)));
+          } catch (error) {
+            overflows.push(error);
+          }
+        }
+      }
+      return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+    } as typeof Set.prototype.add;
+
+    let outer: ReturnType<typeof adapter.run> | undefined;
+    try {
+      outer = adapter.run(() => order.push(0));
+    } finally {
+      Set.prototype.add = originalSetAdd;
+    }
+    if (!outer) throw new Error('Expected a published GPT operation');
+
+    expect(accepted).toHaveLength(63);
+    expect(overflows).toHaveLength(1);
+    expect(overflows[0]).toMatchObject({ code: 'external_queue_full' });
+
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await expect(
+      Promise.all([outer.result, ...accepted.map(({ result }) => result)])
+    ).resolves.toHaveLength(64);
+    expect(order).toEqual([...Array.from({ length: 63 }, (_, index) => index + 1), 0]);
+
+    target.googletag = undefined;
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await expect(Promise.all(recovered.map(({ result }) => result))).resolves.toHaveLength(64);
+  });
+
+  it('rolls back pending GPT publication when poisoned Set.add throws', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const publicationError = new Error('GPT publication failed');
+    const command = vi.fn();
+    const signalGetter = vi.fn(() => undefined);
+    const options = Object.defineProperty({}, 'signal', {
+      get: signalGetter,
+    }) as { readonly signal?: AbortSignal };
+    const originalSetAdd = Set.prototype.add;
+    const originalSetDelete = Set.prototype.delete;
+    const poisonedDelete = function (): boolean {
+      throw new Error('GPT publication rollback delete failed');
+    } as typeof Set.prototype.delete;
+    let poisonNextAdd = true;
+    Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+      if (poisonNextAdd) {
+        poisonNextAdd = false;
+        Set.prototype.add = originalSetAdd;
+        Reflect.apply(originalSetAdd, this, [value]);
+        throw publicationError;
+      }
+      return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+    } as typeof Set.prototype.add;
+    Set.prototype.delete = poisonedDelete;
+
+    let thrown: unknown;
+    try {
+      adapter.run(command, options);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      Set.prototype.add = originalSetAdd;
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    expect(thrown).toBe(publicationError);
+    expect(command).not.toHaveBeenCalled();
+    expect(signalGetter).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await expect(Promise.all(recovered.map(({ result }) => result))).resolves.toHaveLength(64);
+    expect(vi.getTimerCount()).toBe(0);
+    Set.prototype.delete = poisonedDelete;
+    try {
+      expect(() => adapter.dispose()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+    await Promise.resolve();
+  });
+
+  it.each(['signal-getter', 'aborted-getter', 'add-throw', 'abort-remove-throw'] as const)(
+    'contains hostile GPT AbortSignal ownership for %s',
+    async (failure) => {
+      const adapter = createBrowserGoogletagAdapter({});
+      const signalError = new Error(`signal failure: ${failure}`);
+      const listeners = new Set<() => void>();
+      const removeEventListener = vi.fn((_type: string, listener: () => void) => {
+        if (failure === 'abort-remove-throw') throw signalError;
+        listeners.delete(listener);
+      });
+      const signal = Object.defineProperties(
+        {},
+        {
+          aborted: {
+            get: () => {
+              if (failure === 'aborted-getter') throw signalError;
+              return false;
+            },
+          },
+          addEventListener: {
+            value: vi.fn((_type: string, listener: () => void) => {
+              listeners.add(listener);
+              if (failure === 'add-throw') throw signalError;
+              if (failure === 'abort-remove-throw') listener();
+            }),
+          },
+          removeEventListener: { value: removeEventListener },
+        }
+      ) as AbortSignal;
+      const options =
+        failure === 'signal-getter'
+          ? (Object.defineProperty({}, 'signal', {
+              get: () => {
+                throw signalError;
+              },
+            }) as { readonly signal?: AbortSignal })
+          : { signal };
+      let operation: ReturnType<typeof adapter.run> | undefined;
+
+      expect(() => {
+        operation = adapter.run(vi.fn(), options);
+      }).not.toThrow();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      if (failure === 'abort-remove-throw') {
+        await expect(operation.result).rejects.toMatchObject({ code: 'caller_aborted' });
+      } else {
+        await expect(operation.result).rejects.toBe(signalError);
+      }
+      if (failure === 'add-throw' || failure === 'abort-remove-throw') {
+        expect(removeEventListener).toHaveBeenCalledTimes(1);
+      }
+
+      const fillers: Array<ReturnType<typeof adapter.run>> = [];
+      for (let index = 0; index < 64; index += 1) fillers.push(adapter.run(vi.fn()));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      adapter.dispose();
+      await Promise.all(fillers.map(({ result }) => result.catch((error: unknown) => error)));
+    }
+  );
+
+  it.each([
+    'add-getter',
+    'before-install',
+    'after-install',
+    'reentrant-callback',
+    'post-check-throw',
+  ] as const)(
+    'settles GPT abort transitions during listener registration for %s',
+    async (transition) => {
+      vi.useFakeTimers();
+      const target: { googletag?: unknown } = {};
+      const adapter = createBrowserGoogletagAdapter(target);
+      const signalError = new Error(`abort transition failure: ${transition}`);
+      const listeners = new Set<() => void>();
+      let aborted = false;
+      let abortedReads = 0;
+      const addEventListener = vi.fn((_type: string, listener: () => void) => {
+        if (transition === 'before-install') aborted = true;
+        listeners.add(listener);
+        if (transition === 'after-install') aborted = true;
+        if (transition === 'reentrant-callback') {
+          aborted = true;
+          listener();
+        }
+      });
+      const removeEventListener = vi.fn((_type: string, listener: () => void) => {
+        listeners.delete(listener);
+      });
+      const signal = Object.defineProperties(
+        {},
+        {
+          aborted: {
+            get: () => {
+              abortedReads += 1;
+              if (transition === 'post-check-throw' && abortedReads === 2) throw signalError;
+              return aborted;
+            },
+          },
+          addEventListener: {
+            get: () => {
+              if (transition === 'add-getter') aborted = true;
+              return addEventListener;
+            },
+          },
+          removeEventListener: { value: removeEventListener },
+        }
+      ) as AbortSignal;
+      const command = vi.fn();
+      const operation = adapter.run(command, { signal });
+      const result = operation.result.catch((error: unknown) => error);
+
+      await vi.advanceTimersByTimeAsync(10_000);
+      if (transition === 'post-check-throw') await expect(result).resolves.toBe(signalError);
+      else await expect(result).resolves.toMatchObject({ code: 'caller_aborted' });
+      expect(addEventListener).toHaveBeenCalledTimes(1);
+      expect(removeEventListener).toHaveBeenCalledTimes(1);
+      expect(listeners).toHaveLength(0);
+
+      target.googletag = createReadyGoogletag().googletag;
+      adapter.notifyReady();
+      expect(command).not.toHaveBeenCalled();
+
+      target.googletag = undefined;
+      const fillers = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      adapter.dispose();
+      await Promise.all(
+        fillers.map(({ result: filler }) => filler.catch((error: unknown) => error))
+      );
+    }
+  );
+
+  it('uses one exact independent ten-second deadline per enqueued operation', async () => {
+    vi.useFakeTimers();
+    const adapter = createBrowserGoogletagAdapter({});
+    const first = adapter.run(vi.fn());
+    const firstResult = first.result.catch((error: unknown) => error);
+    await vi.advanceTimersByTimeAsync(5_000);
+    const second = adapter.run(vi.fn());
+    const secondResult = second.result.catch((error: unknown) => error);
+
+    await vi.advanceTimersByTimeAsync(4_999);
+    expect(first.status).toBe('pending');
+    expect(second.status).toBe('pending');
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(first.status).toBe('timed_out');
+    await expect(firstResult).resolves.toMatchObject({ code: 'external_ready_timeout' });
+    expect(second.status).toBe('pending');
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(second.status).toBe('timed_out');
+    await expect(secondResult).resolves.toMatchObject({ code: 'external_ready_timeout' });
+  });
+
+  it('lets readiness immediately before the deadline win the operation latch', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operation = adapter.run(() => 'ready');
+
+    await vi.advanceTimersByTimeAsync(9_999);
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(operation.status).toBe('present');
+    await expect(operation.result).resolves.toBe('ready');
+  });
+
+  it('lets the first callback at the exact deadline win and keeps the loser inert', async () => {
+    vi.useFakeTimers();
+    const ready = createReadyGoogletag();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    vi.setSystemTime(0);
+    const operation = adapter.run(() => 'ready');
+
+    vi.setSystemTime(10_000);
+    target.googletag = ready.googletag;
+    adapter.notifyReady();
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(operation.status).toBe('present');
+    await expect(operation.result).resolves.toBe('ready');
+    expect(ready.googletag.cmd.push).toHaveBeenCalledTimes(1);
+  });
+
+  it('lets timeout at or after the deadline win and ignores late readiness', async () => {
+    vi.useFakeTimers();
+    const command = vi.fn();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operation = adapter.run(command);
+    const result = operation.result.catch((error: unknown) => error);
+
+    await vi.advanceTimersByTimeAsync(10_000);
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+
+    expect(operation.status).toBe('timed_out');
+    await expect(result).resolves.toMatchObject({ code: 'external_ready_timeout' });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('removes aborted and disposed operations immediately', async () => {
+    vi.useFakeTimers();
+    const controller = new AbortController();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const abortedCommand = vi.fn();
+    const disposedCommand = vi.fn();
+    const aborted = adapter.run(abortedCommand, { signal: controller.signal });
+    const disposed = adapter.run(disposedCommand);
+    const abortedResult = aborted.result.catch((error: unknown) => error);
+    const disposedResult = disposed.result.catch((error: unknown) => error);
+
+    controller.abort();
+    disposed.dispose();
+    const replacements = Array.from({ length: 64 }, () => adapter.run(() => undefined));
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+
+    await expect(abortedResult).resolves.toMatchObject({ code: 'caller_aborted' });
+    await expect(disposedResult).resolves.toMatchObject({ code: 'operation_disposed' });
+    expect(abortedCommand).not.toHaveBeenCalled();
+    expect(disposedCommand).not.toHaveBeenCalled();
+    await expect(Promise.all(replacements.map(({ result }) => result))).resolves.toHaveLength(64);
+  });
+
+  it('disposes the adapter by removing every pending operation', async () => {
+    const command = vi.fn();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const operation = adapter.run(command);
+    const result = operation.result.catch((error: unknown) => error);
+
+    adapter.dispose();
+    target.googletag = createReadyGoogletag().googletag;
+    adapter.notifyReady();
+
+    await expect(result).resolves.toMatchObject({ code: 'operation_disposed' });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('invalidates an entered command immediately when the adapter is disposed', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const operation = adapter.run((gpt) => {
+      adapter.dispose();
+      gpt.display('must-not-display');
+    });
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(operation.status).toBe('present');
+    expect(ready.display).not.toHaveBeenCalled();
+    expect(ready.listeners.size).toBe(0);
+  });
+
+  it('throws when GPT inspection disposes the adapter before an operation is published', () => {
+    const ready = createReadyGoogletag();
+    const holder: { adapter?: ReturnType<typeof createBrowserGoogletagAdapter> } = {};
+    const target = Object.defineProperty({}, 'googletag', {
+      get: () => {
+        holder.adapter?.dispose();
+        return ready.googletag;
+      },
+    });
+    const adapter = createBrowserGoogletagAdapter(target);
+    holder.adapter = adapter;
+    const command = vi.fn();
+
+    expect(() => adapter.run(command)).toThrowError(
+      expect.objectContaining({ code: 'operation_disposed' })
+    );
+    expect(command).not.toHaveBeenCalled();
+    expect(ready.commands).toHaveLength(0);
+  });
+
+  it('rejects without enqueueing when GPT inspection disposes a published operation', async () => {
+    const ready = createReadyGoogletag({ deferCommands: true });
+    let reads = 0;
+    const holder: { adapter?: ReturnType<typeof createBrowserGoogletagAdapter> } = {};
+    const target = Object.defineProperty({}, 'googletag', {
+      get: () => {
+        reads += 1;
+        if (reads === 3) holder.adapter?.dispose();
+        return ready.googletag;
+      },
+    });
+    const adapter = createBrowserGoogletagAdapter(target);
+    holder.adapter = adapter;
+    const command = vi.fn();
+    const operation = adapter.run(command);
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(command).not.toHaveBeenCalled();
+    expect(ready.commands).toHaveLength(0);
+  });
+
+  it('contains disposal reentrant from GPT member reads and external calls', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const staleSet = vi.fn();
+    const slot = Object.defineProperty({}, 'setTargeting', {
+      get: () => {
+        adapter.dispose();
+        return staleSet;
+      },
+    });
+    const memberOperation = adapter.run((gpt) => gpt.setTargeting(slot, 'key', 'value'));
+
+    await expect(memberOperation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(staleSet).not.toHaveBeenCalled();
+
+    const externalReady = createReadyGoogletag();
+    const externalAdapter = createBrowserGoogletagAdapter({
+      googletag: externalReady.googletag,
+    });
+    externalReady.display.mockImplementation(() => externalAdapter.dispose());
+    const externalOperation = externalAdapter.run((gpt) => {
+      gpt.display('first');
+      gpt.display('must-not-display');
+    });
+
+    await expect(externalOperation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(externalReady.display).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not enqueue after disposal reentrant from GPT configuration reads', async () => {
+    const ready = createReadyGoogletag({ deferCommands: true });
+    const nativeSetConfig = ready.googletag.setConfig;
+    const nativeDisableInitialLoad = ready.pubads.disableInitialLoad;
+    ready.googletag.getConfig.mockImplementation(() => {
+      adapter.dispose();
+      return { disableInitialLoad: false };
+    });
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const command = vi.fn();
+    const operation = adapter.run(command);
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(ready.commands).toHaveLength(0);
+    expect(command).not.toHaveBeenCalled();
+    expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(nativeDisableInitialLoad);
+
+    ready.googletag.getConfig.mockImplementation((key: string) =>
+      key === 'disableInitialLoad' ? { disableInitialLoad: ready.initialLoad.disabled } : {}
+    );
+    const laterAdapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const laterOperation = laterAdapter.run((gpt) => gpt.serviceState());
+    ready.commands[0]?.();
+    await laterOperation.result;
+    laterAdapter.dispose();
+
+    expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(nativeDisableInitialLoad);
+  });
+
+  it.each(['root', 'service'] as const)(
+    'rolls back a GPT %s wrapper when post-install currentness inspection disposes',
+    async (wrapperKind) => {
+      const ready = createReadyGoogletag({ deferCommands: true });
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisableInitialLoad = ready.pubads.disableInitialLoad;
+      let wrappedReads = 0;
+      const holder: { adapter?: ReturnType<typeof createBrowserGoogletagAdapter> } = {};
+      const target = Object.defineProperty({}, 'googletag', {
+        get: () => {
+          const wrapped =
+            wrapperKind === 'root'
+              ? ready.googletag.setConfig !== nativeSetConfig
+              : ready.pubads.disableInitialLoad !== nativeDisableInitialLoad;
+          if (wrapped) {
+            wrappedReads += 1;
+            if (wrappedReads === 7) holder.adapter?.dispose();
+          }
+          return ready.googletag;
+        },
+      });
+      const adapter = createBrowserGoogletagAdapter(target);
+      holder.adapter = adapter;
+      const operation = adapter.run(vi.fn());
+
+      await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisableInitialLoad);
+      expect(ready.commands).toHaveLength(0);
+    }
+  );
+
+  it('keeps abort ownership while a ready GPT command callback is deferred', async () => {
+    const deferred = createReadyGoogletag({ deferCommands: true });
+    const controller = new AbortController();
+    const command = vi.fn();
+    const adapter = createBrowserGoogletagAdapter({ googletag: deferred.googletag });
+    const operation = adapter.run(command, { signal: controller.signal });
+    const result = operation.result.catch((error: unknown) => error);
+
+    expect(operation.status).toBe('present');
+    controller.abort();
+    expect(() => deferred.commands[0]?.()).not.toThrow();
+
+    await expect(result).resolves.toMatchObject({ code: 'caller_aborted' });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('rejects a deferred command against a replaced GPT object and accepts later work', async () => {
+    const first = createReadyGoogletag({ deferCommands: true });
+    const replacement = createReadyGoogletag();
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const command = vi.fn();
+    const operation = adapter.run(command);
+    const result = operation.result.catch((error: unknown) => error);
+
+    target.googletag = replacement.googletag;
+    expect(() => first.commands[0]?.()).not.toThrow();
+
+    await expect(result).resolves.toMatchObject({ code: 'external_artifact_incompatible' });
+    expect(operation.status).toBe('incompatible');
+    expect(command).not.toHaveBeenCalled();
+    await expect(adapter.run(() => 'replacement').result).resolves.toBe('replacement');
+  });
+
+  it('rechecks GPT identity around hostile member reads and external calls', async () => {
+    const first = createReadyGoogletag();
+    const replacement = createReadyGoogletag();
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const staleSet = vi.fn();
+    const slot = Object.defineProperty({}, 'setTargeting', {
+      get: () => {
+        target.googletag = replacement.googletag;
+        return staleSet;
+      },
+    });
+    const operation = adapter.run((gpt) => gpt.setTargeting(slot, 'key', 'value'));
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(operation.status).toBe('incompatible');
+    expect(staleSet).not.toHaveBeenCalled();
+  });
+
+  it('makes an old GPT listener inert after whole-object replacement', async () => {
+    const first = createReadyGoogletag();
+    const replacement = createReadyGoogletag();
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const listener = vi.fn();
+    let unsubscribe = (): void => undefined;
+    await adapter.run((gpt) => {
+      unsubscribe = gpt.subscribe('slotRequested', listener);
+    }).result;
+    const oldListener = [...(first.listeners.get('slotRequested') ?? [])][0];
+
+    target.googletag = replacement.googletag;
+    expect(() => oldListener?.({ slot: {} })).not.toThrow();
+    unsubscribe();
+
+    expect(listener).not.toHaveBeenCalled();
+    expect(first.pubads.removeEventListener).toHaveBeenCalledTimes(1);
+  });
+
+  it('publishes frozen diagnostics facts after the sole adapter listener completes', async () => {
+    const ready = createReadyGoogletag();
+    const performance = { now: vi.fn(() => 42.25) };
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag, performance });
+    const order: string[] = [];
+    const facts: unknown[] = [];
+    const releaseDiagnostics = adapter.observeDiagnostics?.((fact) => {
+      order.push('diagnostics');
+      facts.push(fact);
+      throw new Error('fictional diagnostics failure');
+    });
+    expect(releaseDiagnostics).toEqual(expect.any(Function));
+    expect(ready.pubads.addEventListener).not.toHaveBeenCalled();
+
+    await adapter.run((gpt) =>
+      gpt.subscribe('slotRenderEnded', () => {
+        order.push('correctness');
+      })
+    ).result;
+    expect(ready.pubads.addEventListener).toHaveBeenCalledOnce();
+    const slot = Object.freeze({
+      getSlotElementId: () => 'fictional-slot',
+      getAdUnitPath: () => '/example/fictional-slot',
+      setTargeting: vi.fn(),
+    });
+    const emit = (event: unknown): void => {
+      for (const listener of ready.listeners.get('slotRenderEnded') ?? []) listener(event);
+    };
+    expect(() =>
+      emit({
+        slot,
+        isEmpty: false,
+        size: [300, 250],
+        isBackfill: true,
+        slotContentChanged: false,
+      })
+    ).not.toThrow();
+
+    expect(order).toEqual(['correctness', 'diagnostics']);
+    expect(facts).toEqual([
+      {
+        kind: 'slotRenderEnded',
+        observedAtMs: 42.25,
+        slot: {
+          token: expect.any(Object),
+          traceToken: 'gt1_1',
+          runtimeSlotNumber: 1,
+          elementId: 'fictional-slot',
+          adUnitPath: '/example/fictional-slot',
+        },
+        isEmpty: false,
+        size: [300, 250],
+        isBackfill: true,
+        slotContentChanged: false,
+      },
+    ]);
+    expect(Object.isFrozen(facts[0])).toBe(true);
+    expect(Object.isFrozen((facts[0] as { size: unknown }).size)).toBe(true);
+    const safeSlot = (facts[0] as { slot: Record<string, unknown> }).slot;
+    expect(Object.isFrozen(safeSlot)).toBe(true);
+    expect(Object.isFrozen(safeSlot['token'])).toBe(true);
+    expect(Reflect.ownKeys(safeSlot).sort()).toEqual([
+      'adUnitPath',
+      'elementId',
+      'runtimeSlotNumber',
+      'token',
+      'traceToken',
+    ]);
+    expect(Object.values(safeSlot).some((value) => typeof value === 'function')).toBe(false);
+    expect(safeSlot).not.toBe(slot);
+
+    releaseDiagnostics?.();
+    emit({ slot, isEmpty: true });
+    expect(facts).toHaveLength(1);
+  });
+
+  it.each([false, true])(
+    'publishes correctness facts from the sole listeners and conditions four diagnostics-only listeners (active=%s)',
+    async (diagnosticsActive) => {
+      const ready = createReadyGoogletag();
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const facts: GoogletagDiagnosticsFact[] = [];
+      const accepted = createGoogletagTraceCycleHandle(() => false);
+      adapter.observeDiagnostics?.((fact) => facts.push(fact));
+      await adapter.run((gpt) => {
+        gpt.subscribe('slotRequested', () => accepted);
+        gpt.subscribe('slotRenderEnded', () => accepted);
+        if (diagnosticsActive) {
+          for (const eventType of [
+            'slotResponseReceived',
+            'slotOnload',
+            'impressionViewable',
+            'slotVisibilityChanged',
+          ]) {
+            gpt.subscribe(eventType, () => undefined, true);
+          }
+        }
+      }).result;
+      const slot = { getSlotElementId: () => 'sole-listener-slot' };
+      const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+        const event = { slot, ...fields };
+        for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+      };
+
+      emit('slotRequested');
+      if (diagnosticsActive) emit('slotResponseReceived');
+      emit('slotRenderEnded', { isEmpty: false });
+      if (diagnosticsActive) {
+        emit('slotOnload');
+        emit('impressionViewable');
+        emit('slotVisibilityChanged', { inViewPercentage: 75 });
+      }
+
+      expect(ready.pubads.addEventListener).toHaveBeenCalledTimes(diagnosticsActive ? 6 : 2);
+      expect(facts.map(({ kind }) => kind)).toEqual(
+        diagnosticsActive
+          ? [
+              'slotRequested',
+              'slotResponseReceived',
+              'slotRenderEnded',
+              'slotOnload',
+              'impressionViewable',
+              'slotVisibilityChanged',
+            ]
+          : ['slotRequested', 'slotRenderEnded']
+      );
+      expect(facts.every(({ slot: snapshot }) => snapshot.cycleOrdinal === 1)).toBe(true);
+    }
+  );
+
+  it('opens trace cycles only from accepted lifecycle handles and publishes each raw event once', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const lifecycle = { retired: false };
+    const accepted = createGoogletagTraceCycleHandle(() => lifecycle.retired);
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => accepted);
+      gpt.subscribe('slotRenderEnded', () => accepted);
+    }).result;
+    const slot = { getSlotElementId: () => 'accepted-cycle-slot' };
+    const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot, ...fields };
+      for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+    };
+
+    emit('slotRequested');
+    emit('slotRenderEnded', { isEmpty: false, responseIdentifier: 'accepted-response' });
+    lifecycle.retired = true;
+    emit('slotRequested');
+
+    expect(facts.map(({ kind, slot: snapshot }) => [kind, snapshot.cycleOrdinal])).toEqual([
+      ['slotRequested', 1],
+      ['slotRenderEnded', 1],
+      ['slotRequested', undefined],
+    ]);
+  });
+
+  it('publishes a correctness fact only after lifecycle attribution completes', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const order: string[] = [];
+    const accepted = createGoogletagTraceCycleHandle(() => false);
+    adapter.observeDiagnostics?.((fact) => {
+      order.push('diagnostics');
+      facts.push(fact);
+    });
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => {
+        order.push('correctness');
+        return accepted;
+      });
+    }).result;
+    const slot = { getSlotElementId: () => 'attributed-cycle-slot' };
+
+    const event = { slot };
+    for (const listener of ready.listeners.get('slotRequested') ?? []) listener(event);
+
+    expect(facts).toHaveLength(1);
+    expect(facts[0]?.slot.cycleOrdinal).toBe(1);
+    expect(order).toEqual(['correctness', 'diagnostics']);
+  });
+
+  it('reports duplicate, reused, and already-open cycle handles once while preserving raw facts', async () => {
+    const ready = createReadyGoogletag();
+    const reports = vi.fn();
+    const adapter = createBrowserGoogletagAdapter(
+      { googletag: ready.googletag },
+      { reportDiagnosticsFailure: reports }
+    );
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const first = createGoogletagTraceCycleHandle(() => false);
+    const second = createGoogletagTraceCycleHandle(() => false);
+    let selected = first;
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => selected);
+    }).result;
+    const firstSlot = { getSlotElementId: () => 'cycle-collision-one' };
+    const secondSlot = { getSlotElementId: () => 'cycle-collision-two' };
+    const emit = (slot: object): void => {
+      const event = { slot };
+      for (const listener of ready.listeners.get('slotRequested') ?? []) listener(event);
+    };
+
+    emit(firstSlot);
+    emit(firstSlot);
+    selected = second;
+    emit(firstSlot);
+    selected = first;
+    emit(secondSlot);
+
+    expect(facts).toHaveLength(4);
+    expect(facts.map(({ slot }) => slot.cycleOrdinal)).toEqual([
+      1,
+      undefined,
+      undefined,
+      undefined,
+    ]);
+    expect(reports).toHaveBeenCalledOnce();
+    expect(reports).toHaveBeenCalledWith('trace_cycle_collision');
+  });
+
+  it('reports nonunique callbacks once without suppressing raw facts', async () => {
+    const ready = createReadyGoogletag();
+    const reports = vi.fn();
+    const adapter = createBrowserGoogletagAdapter(
+      { googletag: ready.googletag },
+      { reportDiagnosticsFailure: reports }
+    );
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const first = createGoogletagTraceCycleHandle(() => false);
+    const second = createGoogletagTraceCycleHandle(() => false);
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    const slot = { getSlotElementId: () => 'cycle-ambiguity' };
+    const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot, ...fields };
+      for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+    };
+
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', (event) =>
+        (event as { cycle: number }).cycle === 1 ? first : second
+      );
+      gpt.subscribe('slotRenderEnded', (event) =>
+        (event as { cycle: number }).cycle === 1 ? first : second
+      );
+      gpt.subscribe('slotOnload', () => undefined, true);
+    }).result;
+    emit('slotRequested', { cycle: 1 });
+    emit('slotRenderEnded', { cycle: 1, isEmpty: false });
+    emit('slotRequested', { cycle: 2 });
+    emit('slotRenderEnded', { cycle: 2, isEmpty: false });
+    emit('slotOnload');
+
+    expect(facts).toHaveLength(5);
+    expect(facts.map(({ slot: snapshot }) => snapshot.cycleOrdinal)).toEqual([
+      1,
+      1,
+      2,
+      2,
+      undefined,
+    ]);
+    expect(reports).toHaveBeenCalledOnce();
+    expect(reports).toHaveBeenCalledWith('trace_cycle_ambiguity');
+  });
+
+  it('never transfers a trace handle from a non-owner into a diagnostics-only fact', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const first = createGoogletagTraceCycleHandle(() => false);
+    const second = createGoogletagTraceCycleHandle(() => false);
+    let selected = first;
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => selected);
+      gpt.subscribe('slotRenderEnded', () => selected);
+      gpt.subscribe('slotOnload', () => selected);
+      gpt.subscribe('slotOnload', () => undefined, true);
+    }).result;
+    const slot = { getSlotElementId: () => 'diagnostics-only-attribution-slot' };
+    const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot, ...fields };
+      for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+    };
+
+    emit('slotRequested');
+    emit('slotRenderEnded', { isEmpty: false });
+    selected = second;
+    emit('slotRequested');
+    emit('slotRenderEnded', { isEmpty: false });
+    selected = first;
+    emit('slotOnload');
+
+    expect(facts.map(({ kind, slot: snapshot }) => [kind, snapshot.cycleOrdinal])).toEqual([
+      ['slotRequested', 1],
+      ['slotRenderEnded', 1],
+      ['slotRequested', 2],
+      ['slotRenderEnded', 2],
+      ['slotOnload', undefined],
+    ]);
+  });
+
+  it('accepts correctness attribution only from an adapter-branded trace handle', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    const forged = Object.freeze({ isRetired: () => false });
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => forged as never);
+    }).result;
+    const slot = { getSlotElementId: () => 'forged-attribution-slot' };
+
+    for (const listener of ready.listeners.get('slotRequested') ?? []) listener({ slot });
+
+    expect(facts).toHaveLength(1);
+    expect(facts[0]?.slot.cycleOrdinal).toBeUndefined();
+  });
+
+  it('admits only one diagnostics observer without adding GPT listeners', () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const release = adapter.observeDiagnostics?.(vi.fn());
+
+    expect(adapter.observeDiagnostics?.(vi.fn())).toBeUndefined();
+    expect(ready.pubads.addEventListener).not.toHaveBeenCalled();
+    release?.();
+    expect(adapter.observeDiagnostics?.(vi.fn())).toEqual(expect.any(Function));
+    expect(ready.pubads.addEventListener).not.toHaveBeenCalled();
+  });
+
+  it('keeps distinct opaque and canonical trace tokens per physical Slot', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({
+      googletag: ready.googletag,
+      performance: { now: () => 7 },
+    });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => gpt.subscribe('slotRequested', () => undefined)).result;
+    const first = {
+      getSlotElementId: () => 'same-id',
+      getAdUnitPath: () => '/example/first',
+      setTargeting: vi.fn(),
+    };
+    const replacement = {
+      getSlotElementId: () => 'same-id',
+      getAdUnitPath: () => '/example/replacement',
+      setTargeting: vi.fn(),
+    };
+    const emit = (slot: object): void => {
+      for (const listener of ready.listeners.get('slotRequested') ?? []) listener({ slot });
+    };
+
+    emit(first);
+    emit(first);
+    emit(replacement);
+
+    expect(facts).toHaveLength(3);
+    expect(facts[0]?.slot.token).toBe(facts[1]?.slot.token);
+    expect(facts[2]?.slot.token).not.toBe(facts[0]?.slot.token);
+    expect(facts[0]?.slot.traceToken).toBe('gt1_1');
+    expect(facts[1]?.slot.traceToken).toBe('gt1_1');
+    expect(facts[2]?.slot.traceToken).toBe('gt1_2');
+    expect(facts[0]?.slot.cycleOrdinal).toBeUndefined();
+    expect(facts[1]?.slot.cycleOrdinal).toBeUndefined();
+    expect(facts[2]?.slot.cycleOrdinal).toBeUndefined();
+    expect(facts[0]?.slot.token).not.toBe(facts[0]?.slot.traceToken);
+    expect(Object.isFrozen(first)).toBe(false);
+    expect(Object.isFrozen(replacement)).toBe(false);
+    expect(Reflect.ownKeys(facts[0]?.slot ?? {}).sort()).toEqual([
+      'adUnitPath',
+      'elementId',
+      'runtimeSlotNumber',
+      'token',
+      'traceToken',
+    ]);
+  });
+
+  it('mints canonical trace identity before events and keeps it stable for handoff', () => {
+    const adapter = createBrowserGoogletagAdapter({});
+    const first = {};
+    const replacement = {};
+
+    expect(adapter.traceToken(first)).toBe('gt1_1');
+    expect(adapter.traceToken(first)).toBe('gt1_1');
+    expect(adapter.traceToken(replacement)).toBe('gt1_2');
+    expect(adapter.traceToken(first)).toMatch(/^gt1_[1-9a-z][0-9a-z]{0,6}$/);
+    adapter.dispose();
+    expect(adapter.traceToken(first)).toBeUndefined();
+  });
+
+  it('adopts transferred per-slot diagnostics cycles and the global token high-water value once', () => {
+    const adapter = createBrowserGoogletagAdapter({});
+    const adopted = {};
+
+    expect(
+      adapter.adoptDiagnosticsState?.({
+        nextTraceTokenOrdinal: 9,
+        slots: [
+          {
+            nextCycleOrdinal: 4,
+            physicalSlot: adopted,
+            records: [
+              {
+                ordinal: 1,
+                responseIdentifier: null,
+                seen: ['slotRequested', 'slotRenderEnded'],
+                state: 'completed',
+              },
+              {
+                ordinal: 3,
+                responseIdentifier: null,
+                seen: ['slotRequested'],
+                state: 'retired',
+              },
+            ],
+            traceToken: 'gt1_5',
+            unknownPriorCycle: true,
+          },
+        ],
+      })
+    ).toBe(true);
+    expect(adapter.traceToken(adopted)).toBe('gt1_5');
+    const adoptedIdentity = adapter.diagnosticsIdentity(adopted);
+    expect(adoptedIdentity).toMatchObject({
+      traceToken: 'gt1_5',
+      runtimeSlotNumber: 5,
+      cycleOrdinal: 3,
+    });
+    expect(typeof adoptedIdentity?.token).toBe('object');
+    expect(adapter.diagnosticsIdentity(adopted)?.token).toBe(adoptedIdentity?.token);
+    expect(adapter.traceToken({})).toBe('gt1_9');
+    expect(adapter.adoptDiagnosticsState?.({ nextTraceTokenOrdinal: 10, slots: [] })).toBe(false);
+  });
+
+  it('preserves transferred cycle correlation for late diagnostics after takeover', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const adopted = {};
+    const facts: GoogletagDiagnosticsFact[] = [];
+
+    expect(
+      adapter.adoptDiagnosticsState?.({
+        nextTraceTokenOrdinal: 2,
+        slots: [
+          {
+            nextCycleOrdinal: 2,
+            physicalSlot: adopted,
+            records: [
+              {
+                ordinal: 1,
+                responseIdentifier: 'response-one',
+                seen: ['slotRequested', 'slotRenderEnded'],
+                state: 'completed',
+              },
+            ],
+            traceToken: 'gt1_1',
+            unknownPriorCycle: true,
+          },
+        ],
+      } as never)
+    ).toBe(true);
+    adapter.observeDiagnostics((fact) => facts.push(fact));
+    await adapter.run((gpt) => gpt.subscribe('slotOnload', () => undefined, true)).result;
+
+    for (const listener of ready.listeners.get('slotOnload') ?? []) {
+      listener({ slot: adopted, responseIdentifier: 'response-one' });
+    }
+
+    expect(facts).toHaveLength(1);
+    expect(facts[0]?.slot).toMatchObject({ traceToken: 'gt1_1', cycleOrdinal: 1 });
+  });
+
+  it('rejects malformed diagnostics adoption without consuming the token high-water value', () => {
+    const adapter = createBrowserGoogletagAdapter({});
+    const physicalSlot = {};
+
+    expect(
+      adapter.adoptDiagnosticsState?.({
+        nextTraceTokenOrdinal: 2,
+        slots: [
+          {
+            nextCycleOrdinal: 1,
+            physicalSlot,
+            records: [
+              {
+                ordinal: 1,
+                responseIdentifier: null,
+                seen: ['slotRequested', 'slotRenderEnded'],
+                state: 'completed',
+              },
+            ],
+            traceToken: 'gt1_1',
+            unknownPriorCycle: false,
+          },
+        ],
+      })
+    ).toBe(false);
+    expect(adapter.traceToken(physicalSlot)).toBe('gt1_1');
+  });
+
+  it('does not retain default canonical tokens in a collision ledger', () => {
+    const disposalClearCalls = (() => {
+      const clear = vi.spyOn(Set.prototype, 'clear');
+      try {
+        const adapter = createBrowserGoogletagAdapter({});
+        for (let ordinal = 1; ordinal <= 1_024; ordinal += 1) {
+          expect(adapter.traceToken({})).toBe(`gt1_${ordinal.toString(36)}`);
+        }
+        const callsBeforeDispose = clear.mock.calls.length;
+
+        adapter.dispose();
+        return clear.mock.calls.length - callsBeforeDispose;
+      } finally {
+        clear.mockRestore();
+      }
+    })();
+
+    expect(disposalClearCalls).toBe(0);
+  });
+
+  it('clears the custom minted trace-token collision ledger once on adapter disposal', () => {
+    const disposalClearCalls = (() => {
+      const clear = vi.spyOn(Set.prototype, 'clear');
+      try {
+        const adapter = createBrowserGoogletagAdapter(
+          {},
+          { mintTraceToken: (ordinal) => `gt1_${ordinal.toString(36)}` }
+        );
+        expect(adapter.traceToken({})).toBe('gt1_1');
+        expect(adapter.traceToken({})).toBe('gt1_2');
+        const callsBeforeDispose = clear.mock.calls.length;
+
+        adapter.dispose();
+        adapter.dispose();
+        return clear.mock.calls.length - callsBeforeDispose;
+      } finally {
+        clear.mockRestore();
+      }
+    })();
+
+    expect(disposalClearCalls).toBe(1);
+  });
+
+  it('mints trace-token boundary ordinals and reports exhaustion once without affecting older tokens', () => {
+    const boundaries = createBrowserGoogletagAdapter({}, { initialTraceTokenOrdinal: 35 });
+    expect(boundaries.traceToken({})).toBe('gt1_z');
+    expect(boundaries.traceToken({})).toBe('gt1_10');
+
+    const reports = vi.fn();
+    const exhausted = createBrowserGoogletagAdapter(
+      {},
+      { initialTraceTokenOrdinal: 4_294_967_295, reportDiagnosticsFailure: reports }
+    );
+    const retained = {};
+    expect(exhausted.traceToken(retained)).toBe('gt1_1z141z3');
+    expect(exhausted.traceToken({})).toBeUndefined();
+    expect(exhausted.traceToken({})).toBeUndefined();
+    expect(exhausted.traceToken(retained)).toBe('gt1_1z141z3');
+    expect(reports).toHaveBeenCalledTimes(1);
+    expect(reports).toHaveBeenCalledWith('trace_token_exhausted');
+  });
+
+  it('contains one injected token collision and lets the next physical object reuse the unspent ordinal', () => {
+    const reports = vi.fn(() => {
+      throw new Error('fictional diagnostics reporter failure');
+    });
+    let calls = 0;
+    const adapter = createBrowserGoogletagAdapter(
+      {},
+      {
+        mintTraceToken: (ordinal) => {
+          calls += 1;
+          return calls === 2 ? 'gt1_1' : `gt1_${ordinal.toString(36)}`;
+        },
+        reportDiagnosticsFailure: reports,
+      }
+    );
+
+    expect(adapter.traceToken({})).toBe('gt1_1');
+    expect(() => adapter.traceToken({})).not.toThrow();
+    expect(adapter.traceToken({})).toBe('gt1_2');
+    expect(reports).toHaveBeenCalledOnce();
+    expect(reports).toHaveBeenCalledWith('trace_token_collision');
+  });
+
+  it('contains per-object cycle exhaustion while preserving raw diagnostics delivery', async () => {
+    const ready = createReadyGoogletag();
+    const reports = vi.fn();
+    const adapter = createBrowserGoogletagAdapter(
+      { googletag: ready.googletag },
+      { initialTraceCycleOrdinal: 4_294_967_295, reportDiagnosticsFailure: reports }
+    );
+    const facts: GoogletagDiagnosticsFact[] = [];
+    let lifecycle = { retired: true };
+    let accepted: ReturnType<typeof createGoogletagTraceCycleHandle> | undefined;
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => {
+        lifecycle.retired = true;
+        const current = { retired: false };
+        lifecycle = current;
+        accepted = createGoogletagTraceCycleHandle(() => current.retired);
+        return accepted;
+      });
+      gpt.subscribe('slotRenderEnded', () => accepted);
+    }).result;
+    const slot = { getSlotElementId: () => 'cycle-exhaustion-slot' };
+    const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot, ...fields };
+      for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+    };
+
+    emit('slotRequested');
+    emit('slotRenderEnded', { isEmpty: false });
+    emit('slotRequested');
+
+    expect(facts.map((fact) => fact.slot.cycleOrdinal)).toEqual([
+      4_294_967_295,
+      4_294_967_295,
+      undefined,
+    ]);
+    expect(reports).toHaveBeenCalledOnce();
+    expect(reports).toHaveBeenCalledWith('trace_cycle_exhausted');
+  });
+
+  it('assigns exact per-object cycle ordinals and omits ambiguous callbacks', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const facts: GoogletagDiagnosticsFact[] = [];
+    let lifecycle = { retired: true };
+    let accepted: ReturnType<typeof createGoogletagTraceCycleHandle> | undefined;
+    adapter.observeDiagnostics?.((fact) => facts.push(fact));
+    await adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', () => {
+        lifecycle.retired = true;
+        const current = { retired: false };
+        lifecycle = current;
+        accepted = createGoogletagTraceCycleHandle(() => current.retired);
+        return accepted;
+      });
+      gpt.subscribe('slotRenderEnded', () => accepted);
+      for (const eventType of ['slotResponseReceived', 'impressionViewable']) {
+        gpt.subscribe(eventType, () => undefined, true);
+      }
+    }).result;
+    const slot = {
+      getSlotElementId: () => 'cycle-slot',
+      getAdUnitPath: () => '/example/cycle-slot',
+    };
+    const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot, ...fields };
+      for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+    };
+
+    emit('slotRequested');
+    emit('slotResponseReceived', { responseIdentifier: 'response-1' });
+    emit('slotRenderEnded', { isEmpty: false, responseIdentifier: 'response-1' });
+    emit('slotRequested');
+    emit('impressionViewable');
+    emit('slotRenderEnded', { isEmpty: false, responseIdentifier: 'response-2' });
+
+    expect(facts.map(({ kind, slot: snapshot }) => [kind, snapshot.cycleOrdinal])).toEqual([
+      ['slotRequested', 1],
+      ['slotResponseReceived', 1],
+      ['slotRenderEnded', 1],
+      ['slotRequested', 2],
+      ['impressionViewable', undefined],
+      ['slotRenderEnded', 2],
+    ]);
+    expect(facts[1]?.responseIdentifier).toBe('response-1');
+    expect(facts[2]?.responseIdentifier).toBe('response-1');
+    expect(facts[5]?.responseIdentifier).toBe('response-2');
+  });
+
+  it.each([
+    [9, 1],
+    [10, 1],
+    [11, undefined],
+  ] as const)(
+    'retains bounded cycle identity after %i completed requests',
+    async (cycleCount, expectedOldOrdinal) => {
+      const ready = createReadyGoogletag();
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const facts: GoogletagDiagnosticsFact[] = [];
+      let lifecycle = { retired: true };
+      let accepted: ReturnType<typeof createGoogletagTraceCycleHandle> | undefined;
+      adapter.observeDiagnostics?.((fact) => facts.push(fact));
+      await adapter.run((gpt) => {
+        gpt.subscribe('slotRequested', () => {
+          lifecycle.retired = true;
+          const current = { retired: false };
+          lifecycle = current;
+          accepted = createGoogletagTraceCycleHandle(() => current.retired);
+          return accepted;
+        });
+        gpt.subscribe('slotRenderEnded', () => accepted);
+        gpt.subscribe('slotOnload', () => undefined, true);
+      }).result;
+      const slot = { getSlotElementId: () => 'ledger-slot' };
+      const emit = (eventType: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+        const event = { slot, ...fields };
+        for (const listener of ready.listeners.get(eventType) ?? []) listener(event);
+      };
+
+      for (let ordinal = 1; ordinal <= cycleCount; ordinal += 1) {
+        emit('slotRequested');
+        emit('slotRenderEnded', {
+          isEmpty: false,
+          responseIdentifier: `response-${ordinal}`,
+        });
+      }
+      emit('slotOnload', { responseIdentifier: 'response-1' });
+
+      const requested = facts.filter(({ kind }) => kind === 'slotRequested');
+      expect(requested.map(({ slot: snapshot }) => snapshot.cycleOrdinal)).toEqual(
+        Array.from({ length: cycleCount }, (_, index) => index + 1)
+      );
+      expect(facts[facts.length - 1]?.kind).toBe('slotOnload');
+      expect(facts[facts.length - 1]?.slot.cycleOrdinal).toBe(expectedOldOrdinal);
+    }
+  );
+
+  it.each(
+    [
+      'slotResponseReceived',
+      'slotRenderEnded',
+      'slotOnload',
+      'impressionViewable',
+      'slotVisibilityChanged',
+    ].flatMap((eventType) =>
+      ['before-next-start', 'after-next-start', 'after-next-completion'].map(
+        (position) => [eventType, position] as const
+      )
+    )
+  )(
+    'attributes an old %s callback %s only from exact retained evidence',
+    async (eventType, position) => {
+      const ready = createReadyGoogletag();
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const facts: GoogletagDiagnosticsFact[] = [];
+      const firstState = { retired: false };
+      const secondState = { retired: false };
+      const first = createGoogletagTraceCycleHandle(() => firstState.retired);
+      const second = createGoogletagTraceCycleHandle(() => secondState.retired);
+      adapter.observeDiagnostics?.((fact) => facts.push(fact));
+      await adapter.run((gpt) => {
+        gpt.subscribe('slotRequested', (event) =>
+          (event as { cycle: number }).cycle === 1 ? first : second
+        );
+        gpt.subscribe('slotRenderEnded', (event) =>
+          (event as { cycle: number }).cycle === 1 ? first : second
+        );
+        for (const type of [
+          'slotResponseReceived',
+          'slotOnload',
+          'impressionViewable',
+          'slotVisibilityChanged',
+        ]) {
+          gpt.subscribe(type, () => undefined, true);
+        }
+      }).result;
+      const slot = { getSlotElementId: () => 'callback-order-slot' };
+      let emitted = 0;
+      const emit = (type: string, fields: Readonly<Record<string, unknown>>): void => {
+        emitted += 1;
+        const event = { slot, ...fields };
+        for (const listener of ready.listeners.get(type) ?? []) listener(event);
+      };
+      const oldFields = {
+        cycle: 1,
+        responseIdentifier: 'response-1',
+        ...(eventType === 'slotRenderEnded' ? { isEmpty: false } : {}),
+        ...(eventType === 'slotVisibilityChanged' ? { inViewPercentage: 25 } : {}),
+      };
+
+      emit('slotRequested', { cycle: 1 });
+      if (position !== 'before-next-start') {
+        emit('slotRenderEnded', {
+          cycle: 1,
+          isEmpty: false,
+          responseIdentifier: 'response-1',
+        });
+        firstState.retired = true;
+        emit('slotRequested', { cycle: 2 });
+        if (position === 'after-next-completion') {
+          emit('slotRenderEnded', {
+            cycle: 2,
+            isEmpty: false,
+            responseIdentifier: 'response-2',
+          });
+        }
+      }
+      emit(eventType, oldFields);
+
+      expect(facts).toHaveLength(emitted);
+      expect(facts[facts.length - 1]?.kind).toBe(eventType);
+      expect(facts[facts.length - 1]?.slot.cycleOrdinal).toBe(
+        eventType === 'slotRenderEnded' && position !== 'before-next-start' ? undefined : 1
+      );
+    }
+  );
+
+  it('rolls back an exact GPT listener when installation replaces the binding', async () => {
+    const first = createReadyGoogletag();
+    const replacement = createReadyGoogletag();
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+    first.pubads.addEventListener.mockImplementation((type, listener) => {
+      const registered = first.listeners.get(type) ?? new Set();
+      registered.add(listener);
+      first.listeners.set(type, registered);
+      target.googletag = replacement.googletag;
+    });
+    const operation = adapter.run((gpt) => gpt.subscribe('slotRequested', vi.fn()));
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    const installed = first.pubads.addEventListener.mock.calls[0]?.[1];
+    expect(first.pubads.removeEventListener).toHaveBeenCalledWith('slotRequested', installed);
+    expect(first.listeners.get('slotRequested')?.size).toBe(0);
+  });
+
+  it('rolls back a GPT listener when installation disposes and cleanup throws', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    ready.pubads.addEventListener.mockImplementation((type, listener) => {
+      const registered = ready.listeners.get(type) ?? new Set();
+      registered.add(listener);
+      ready.listeners.set(type, registered);
+      adapter.dispose();
+    });
+    ready.pubads.removeEventListener.mockImplementation((type, listener) => {
+      ready.listeners.get(type)?.delete(listener);
+      throw new Error('cleanup failed');
+    });
+    const operation = adapter.run((gpt) => gpt.subscribe('slotRequested', vi.fn()));
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(ready.pubads.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(ready.listeners.get('slotRequested')?.size).toBe(0);
+  });
+
+  it.each(['dispose', 'throw'] as const)(
+    'rolls back GPT subscription ownership when effect registration must %s',
+    async (failure) => {
+      const ready = createReadyGoogletag();
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const registryError = new Error('effect registry add failed');
+      const originalDescriptor = Object.getOwnPropertyDescriptor(Set.prototype, 'add');
+      const nativeAdd = Set.prototype.add;
+      const existingListeners = new Set<(event: unknown) => void>();
+      const failedListeners = new Set<(event: unknown) => void>();
+      const existingListener = vi.fn();
+      const failedListener = vi.fn();
+      ready.listeners.set('existing', existingListeners);
+      ready.listeners.set('failed', failedListeners);
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      try {
+        operation = adapter.run((gpt) => {
+          gpt.subscribe('existing', existingListener);
+          Object.defineProperty(Set.prototype, 'add', {
+            configurable: true,
+            writable: true,
+            value: function (this: Set<unknown>, value: unknown): Set<unknown> {
+              if (
+                typeof value === 'function' &&
+                this !== existingListeners &&
+                this !== failedListeners
+              ) {
+                if (failure === 'dispose') adapter.dispose();
+                else throw registryError;
+              }
+              return Reflect.apply(nativeAdd, this, [value]) as Set<unknown>;
+            },
+          });
+          return gpt.subscribe('failed', failedListener);
+        });
+      } finally {
+        if (originalDescriptor) Object.defineProperty(Set.prototype, 'add', originalDescriptor);
+      }
+
+      if (failure === 'dispose') {
+        await expect(operation?.result).rejects.toMatchObject({ code: 'operation_disposed' });
+      } else {
+        await expect(operation?.result).rejects.toBe(registryError);
+      }
+      adapter.dispose();
+      adapter.dispose();
+
+      expect(ready.listeners.get('existing')?.size).toBe(0);
+      expect(ready.listeners.get('failed')?.size).toBe(0);
+      expect(ready.pubads.removeEventListener).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  it('settles a live GPT operation and restores exact effects when Set.delete is poisoned', async () => {
+    const ready = createReadyGoogletag();
+    const nativeSetConfig = ready.googletag.setConfig;
+    const nativeDisable = ready.pubads.disableInitialLoad;
+    const originalSetDelete = Set.prototype.delete;
+    ready.pubads.removeEventListener.mockImplementation((type, listener) => {
+      const registered = ready.listeners.get(type);
+      if (registered) Reflect.apply(originalSetDelete, registered, [listener]);
+    });
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const listener = vi.fn();
+    const operation = adapter.run((gpt) => {
+      gpt.subscribe('slotRequested', listener);
+      return new Promise<never>(() => undefined);
+    });
+    expect(ready.googletag.setConfig).not.toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).not.toBe(nativeDisable);
+    expect(ready.listeners.get('slotRequested')).toHaveLength(1);
+
+    Set.prototype.delete = function (): boolean {
+      throw new Error('GPT live cleanup delete failed');
+    } as typeof Set.prototype.delete;
+    try {
+      expect(() => adapter.dispose()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(ready.listeners.get('slotRequested')).toHaveLength(0);
+    expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+    expect(() => adapter.dispose()).not.toThrow();
+  });
+
+  it.each(['keys', 'clear'] as const)(
+    'restores every GPT effect when Map.%s is poisoned during disposal',
+    async (method) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const listener = vi.fn();
+      await adapter.run((gpt) => gpt.subscribe('slotRequested', listener)).result;
+      expect(ready.googletag.setConfig).not.toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).not.toBe(nativeDisable);
+      expect(ready.listeners.get('slotRequested')).toHaveLength(1);
+
+      const originalMapKeys = Map.prototype.keys;
+      const originalMapClear = Map.prototype.clear;
+      if (method === 'keys') {
+        Map.prototype.keys = function (): never {
+          throw new Error('GPT initial-load keys failed');
+        } as typeof Map.prototype.keys;
+      } else {
+        Map.prototype.clear = function (): never {
+          throw new Error('GPT initial-load clear failed');
+        } as typeof Map.prototype.clear;
+      }
+      try {
+        expect(() => adapter.dispose()).not.toThrow();
+        expect(() => adapter.dispose()).not.toThrow();
+      } finally {
+        Map.prototype.keys = originalMapKeys;
+        Map.prototype.clear = originalMapClear;
+      }
+
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+      expect(ready.listeners.get('slotRequested')).toHaveLength(0);
+      expect(ready.pubads.removeEventListener).toHaveBeenCalledTimes(1);
+
+      const ownershipProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await ownershipProbe.run((gpt) => gpt.serviceState()).result;
+      expect(ready.googletag.setConfig).not.toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).not.toBe(nativeDisable);
+      ownershipProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+    }
+  );
+
+  it('settles GPT tracker publication failure and rolls back only its new owner', async () => {
+    const first = createReadyGoogletag();
+    const second = createReadyGoogletag();
+    const firstNativeSetConfig = first.googletag.setConfig;
+    const firstNativeDisable = first.pubads.disableInitialLoad;
+    const secondNativeSetConfig = second.googletag.setConfig;
+    const secondNativeDisable = second.pubads.disableInitialLoad;
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const priorListener = vi.fn();
+    await adapter.run((gpt) => gpt.subscribe('prior', priorListener)).result;
+    expect(first.listeners.get('prior')).toHaveLength(1);
+
+    target.googletag = second.googletag;
+    const registryError = new Error('GPT tracker effect publication failed');
+    const command = vi.fn();
+    const originalSetAdd = Set.prototype.add;
+    let additions = 0;
+    Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+      additions += 1;
+      const added = Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+      if (additions === 3) throw registryError;
+      return added;
+    } as typeof Set.prototype.add;
+
+    let operation: ReturnType<typeof adapter.run> | undefined;
+    let thrown: unknown;
+    try {
+      operation = adapter.run(command);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      Set.prototype.add = originalSetAdd;
+    }
+
+    expect(additions).toBe(3);
+    expect(thrown).toBeUndefined();
+    if (!operation) throw new Error('Expected a published GPT operation');
+    await expect(operation.result).rejects.toBe(registryError);
+    expect(command).not.toHaveBeenCalled();
+    expect(first.listeners.get('prior')).toHaveLength(1);
+    expect(first.googletag.setConfig).toBe(firstNativeSetConfig);
+    expect(first.pubads.disableInitialLoad).toBe(firstNativeDisable);
+    expect(second.googletag.setConfig).toBe(secondNativeSetConfig);
+    expect(second.pubads.disableInitialLoad).toBe(secondNativeDisable);
+
+    const ownerProbe = createBrowserGoogletagAdapter({ googletag: second.googletag });
+    await ownerProbe.run((gpt) => gpt.serviceState()).result;
+    expect(second.googletag.setConfig).not.toBe(secondNativeSetConfig);
+    expect(second.pubads.disableInitialLoad).not.toBe(secondNativeDisable);
+    ownerProbe.dispose();
+    expect(second.googletag.setConfig).toBe(secondNativeSetConfig);
+    expect(second.pubads.disableInitialLoad).toBe(secondNativeDisable);
+
+    target.googletag = undefined;
+    const recovered = Array.from({ length: 64 }, () => adapter.run(() => 'recovered'));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    target.googletag = second.googletag;
+    adapter.notifyReady();
+    await expect(Promise.all(recovered.map(({ result }) => result))).resolves.toEqual(
+      Array.from({ length: 64 }, () => 'recovered')
+    );
+    expect(first.listeners.get('prior')).toHaveLength(1);
+
+    adapter.dispose();
+    expect(first.listeners.get('prior')).toHaveLength(0);
+    expect(first.pubads.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(second.googletag.setConfig).toBe(secondNativeSetConfig);
+    expect(second.pubads.disableInitialLoad).toBe(secondNativeDisable);
+  });
+
+  it.each(['owner', 'release', 'service'] as const)(
+    'settles and rolls back GPT tracking when the %s registry has lookup throws',
+    async (registry) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const command = vi.fn(() => 'settled');
+      const originalSetHas = Set.prototype.has;
+      const originalMapHas = Map.prototype.has;
+      const originalWeakMapHas = WeakMap.prototype.has;
+      if (registry === 'owner') {
+        Set.prototype.has = function (): boolean {
+          throw new Error('GPT owner lookup failed');
+        } as typeof Set.prototype.has;
+      } else if (registry === 'release') {
+        Map.prototype.has = function (): boolean {
+          throw new Error('GPT release lookup failed');
+        } as typeof Map.prototype.has;
+      } else {
+        WeakMap.prototype.has = function (): boolean {
+          throw new Error('GPT service lookup failed');
+        } as typeof WeakMap.prototype.has;
+      }
+
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.has = originalSetHas;
+        Map.prototype.has = originalMapHas;
+        WeakMap.prototype.has = originalWeakMapHas;
+      }
+
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).resolves.toBe('settled');
+      expect(command).toHaveBeenCalledTimes(1);
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      const ownerProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await ownerProbe.run((gpt) => gpt.serviceState()).result;
+      ownerProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+      adapter.dispose();
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'rolls back shared GPT tracker publication when WeakMap.set throws %s insertion',
+    async (failure) => {
+      vi.useFakeTimers();
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const target: { googletag?: unknown } = { googletag: ready.googletag };
+      const adapter = createBrowserGoogletagAdapter(target);
+      const publicationError = new Error(`shared tracker failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalWeakMapSet = WeakMap.prototype.set;
+      const originalWeakMapDelete = WeakMap.prototype.delete;
+      let publications = 0;
+      WeakMap.prototype.set = function (
+        this: WeakMap<object, unknown>,
+        key: object,
+        value: unknown
+      ): WeakMap<object, unknown> {
+        publications += 1;
+        if (publications === 1) {
+          if (failure === 'after') Reflect.apply(originalWeakMapSet, this, [key, value]);
+          throw publicationError;
+        }
+        return Reflect.apply(originalWeakMapSet, this, [key, value]) as WeakMap<object, unknown>;
+      } as typeof WeakMap.prototype.set;
+      WeakMap.prototype.delete = function (): boolean {
+        throw new Error('shared tracker rollback delete failed');
+      } as typeof WeakMap.prototype.delete;
+
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakMap.prototype.set = originalWeakMapSet;
+        WeakMap.prototype.delete = originalWeakMapDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(publications).toBe(1);
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(publicationError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      const ownerProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      let recoveredPublications = 0;
+      WeakMap.prototype.set = function (
+        this: WeakMap<object, unknown>,
+        key: object,
+        value: unknown
+      ): WeakMap<object, unknown> {
+        recoveredPublications += 1;
+        return Reflect.apply(originalWeakMapSet, this, [key, value]) as WeakMap<object, unknown>;
+      } as typeof WeakMap.prototype.set;
+      try {
+        await ownerProbe.run((gpt) => gpt.serviceState()).result;
+      } finally {
+        WeakMap.prototype.set = originalWeakMapSet;
+      }
+      expect(recoveredPublications).toBe(2);
+      ownerProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      target.googletag = undefined;
+      const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+      const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      for (const recoveredOperation of recovered) recoveredOperation.dispose();
+      await Promise.all(recoveredResults);
+      expect(vi.getTimerCount()).toBe(0);
+      adapter.dispose();
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'removes only the new GPT owner when its release Map.set throws %s insertion',
+    async (failure) => {
+      vi.useFakeTimers();
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const first = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await first.run((gpt) => gpt.serviceState()).result;
+      const sharedSetConfig = ready.googletag.setConfig;
+      const sharedDisable = ready.pubads.disableInitialLoad;
+      const secondTarget: { googletag?: unknown } = { googletag: ready.googletag };
+      const second = createBrowserGoogletagAdapter(secondTarget);
+      const publicationError = new Error(`release map failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalMapSet = Map.prototype.set;
+      const originalMapDelete = Map.prototype.delete;
+      let publications = 0;
+      Map.prototype.set = function (
+        this: Map<unknown, unknown>,
+        key: unknown,
+        value: unknown
+      ): Map<unknown, unknown> {
+        publications += 1;
+        if (publications === 1) {
+          if (failure === 'after') Reflect.apply(originalMapSet, this, [key, value]);
+          throw publicationError;
+        }
+        return Reflect.apply(originalMapSet, this, [key, value]) as Map<unknown, unknown>;
+      } as typeof Map.prototype.set;
+      Map.prototype.delete = function (): boolean {
+        throw new Error('release map rollback delete failed');
+      } as typeof Map.prototype.delete;
+
+      let operation: ReturnType<typeof second.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = second.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Map.prototype.set = originalMapSet;
+        Map.prototype.delete = originalMapDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(publications).toBe(1);
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(publicationError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(sharedSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(sharedDisable);
+
+      first.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      secondTarget.googletag = undefined;
+      const recovered = Array.from({ length: 64 }, () => second.run(vi.fn()));
+      const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+      expect(() => second.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      for (const recoveredOperation of recovered) recoveredOperation.dispose();
+      await Promise.all(recoveredResults);
+      expect(vi.getTimerCount()).toBe(0);
+      second.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'identity-restores GPT service publication when WeakMap.set throws %s insertion',
+    async (failure) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const publicationError = new Error(`service map failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalWeakMapSet = WeakMap.prototype.set;
+      const originalWeakMapDelete = WeakMap.prototype.delete;
+      let publications = 0;
+      WeakMap.prototype.set = function (
+        this: WeakMap<object, unknown>,
+        key: object,
+        value: unknown
+      ): WeakMap<object, unknown> {
+        publications += 1;
+        if (publications === 2) {
+          if (failure === 'after') Reflect.apply(originalWeakMapSet, this, [key, value]);
+          throw publicationError;
+        }
+        return Reflect.apply(originalWeakMapSet, this, [key, value]) as WeakMap<object, unknown>;
+      } as typeof WeakMap.prototype.set;
+      WeakMap.prototype.delete = function (): boolean {
+        throw new Error('service map rollback delete failed');
+      } as typeof WeakMap.prototype.delete;
+
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakMap.prototype.set = originalWeakMapSet;
+        WeakMap.prototype.delete = originalWeakMapDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(publications).toBe(2);
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(publicationError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      const ownerProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await ownerProbe.run((gpt) => gpt.serviceState()).result;
+      ownerProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+      adapter.dispose();
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'rolls back GPT tracker owner publication when Set.add throws %s insertion',
+    async (failure) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const first = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await first.run((gpt) => gpt.serviceState()).result;
+      const sharedSetConfig = ready.googletag.setConfig;
+      const sharedDisable = ready.pubads.disableInitialLoad;
+      const second = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const registryError = new Error(`owner add failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalSetAdd = Set.prototype.add;
+      const originalSetDelete = Set.prototype.delete;
+      let additions = 0;
+      Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+        additions += 1;
+        if (additions === 2) {
+          if (failure === 'after') Reflect.apply(originalSetAdd, this, [value]);
+          throw registryError;
+        }
+        return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+      } as typeof Set.prototype.add;
+      Set.prototype.delete = function (): boolean {
+        throw new Error('owner rollback delete failed');
+      } as typeof Set.prototype.delete;
+      let operation: ReturnType<typeof second.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = second.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.add = originalSetAdd;
+        Set.prototype.delete = originalSetDelete;
+      }
+
+      expect(additions).toBe(2);
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(registryError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(sharedSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(sharedDisable);
+
+      second.dispose();
+      expect(ready.googletag.setConfig).toBe(sharedSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(sharedDisable);
+      first.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'identity-restores GPT root wrapper when restorer Set.add throws %s insertion',
+    async (failure) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const registryError = new Error(`root restorer add failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalSetAdd = Set.prototype.add;
+      const originalSetDelete = Set.prototype.delete;
+      let additions = 0;
+      Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+        additions += 1;
+        if (additions === 4) {
+          if (failure === 'after') Reflect.apply(originalSetAdd, this, [value]);
+          throw registryError;
+        }
+        return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+      } as typeof Set.prototype.add;
+      Set.prototype.delete = function (): boolean {
+        throw new Error('root restorer cleanup delete failed');
+      } as typeof Set.prototype.delete;
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.add = originalSetAdd;
+        Set.prototype.delete = originalSetDelete;
+      }
+
+      expect(additions).toBe(4);
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(registryError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      const ownerProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await ownerProbe.run((gpt) => gpt.serviceState()).result;
+      ownerProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+      adapter.dispose();
+    }
+  );
+
+  it.each(['before', 'after'] as const)(
+    'identity-restores GPT service wrapper when restorer Set.add throws %s insertion',
+    async (failure) => {
+      const ready = createReadyGoogletag();
+      const nativeSetConfig = ready.googletag.setConfig;
+      const nativeDisable = ready.pubads.disableInitialLoad;
+      const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      const registryError = new Error(`service restorer add failed ${failure} insertion`);
+      const command = vi.fn();
+      const originalSetAdd = Set.prototype.add;
+      const originalSetDelete = Set.prototype.delete;
+      let additions = 0;
+      Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+        additions += 1;
+        if (additions === 5) {
+          if (failure === 'after') Reflect.apply(originalSetAdd, this, [value]);
+          throw registryError;
+        }
+        return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+      } as typeof Set.prototype.add;
+      Set.prototype.delete = function (): boolean {
+        throw new Error('service restorer cleanup delete failed');
+      } as typeof Set.prototype.delete;
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(command);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.add = originalSetAdd;
+        Set.prototype.delete = originalSetDelete;
+      }
+
+      expect(additions).toBe(5);
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published GPT operation');
+      await expect(operation.result).rejects.toBe(registryError);
+      expect(command).not.toHaveBeenCalled();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+
+      const ownerProbe = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+      await ownerProbe.run((gpt) => gpt.serviceState()).result;
+      ownerProbe.dispose();
+      expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+      expect(ready.pubads.disableInitialLoad).toBe(nativeDisable);
+      adapter.dispose();
+    }
+  );
+
+  it('rolls back a failed GPT command subscription without touching prior global effects', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const priorListener = vi.fn();
+    const failedListener = vi.fn();
+    const commandError = new Error('command failed');
+    await adapter.run((gpt) => gpt.subscribe('prior', priorListener)).result;
+
+    const operation = adapter.run((gpt) => {
+      gpt.subscribe('failed', failedListener);
+      throw commandError;
+    });
+
+    await expect(operation.result).rejects.toBe(commandError);
+    expect(ready.listeners.get('prior')?.size).toBe(1);
+    expect(ready.listeners.get('failed')?.size).toBe(0);
+    expect(() => [...(ready.listeners.get('prior') ?? [])][0]?.({})).not.toThrow();
+    expect(priorListener).toHaveBeenCalledTimes(1);
+    expect(failedListener).not.toHaveBeenCalled();
+
+    adapter.dispose();
+    expect(ready.listeners.get('prior')?.size).toBe(0);
+    expect(ready.pubads.removeEventListener).toHaveBeenCalledTimes(2);
+  });
+
+  it('promotes fulfilled GPT command subscriptions and rolls back rejected ones', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const rejection = new Error('async command failed');
+    const rejected = adapter.run((gpt) => {
+      gpt.subscribe('rejected', vi.fn());
+      return Promise.reject(rejection);
+    });
+
+    await expect(rejected.result).rejects.toBe(rejection);
+    expect(ready.listeners.get('rejected')?.size).toBe(0);
+
+    const fulfilled = adapter.run((gpt) => {
+      gpt.subscribe('fulfilled', vi.fn());
+      return Promise.resolve('complete');
+    });
+    await expect(fulfilled.result).resolves.toBe('complete');
+    expect(ready.listeners.get('fulfilled')?.size).toBe(1);
+
+    adapter.dispose();
+    expect(ready.listeners.get('fulfilled')?.size).toBe(0);
+  });
+
+  it.each(['dispose', 'replacement'] as const)(
+    'rolls back a provisional GPT subscription after async %s',
+    async (failure) => {
+      const first = createReadyGoogletag();
+      const replacement = createReadyGoogletag();
+      const target: { googletag?: unknown } = { googletag: first.googletag };
+      const adapter = createBrowserGoogletagAdapter(target);
+      let resolveCommand!: (value: string) => void;
+      const commandResult = new Promise<string>((resolve) => {
+        resolveCommand = resolve;
+      });
+      const operation = adapter.run((gpt) => {
+        gpt.subscribe('provisional', vi.fn());
+        return commandResult;
+      });
+
+      if (failure === 'dispose') adapter.dispose();
+      else target.googletag = replacement.googletag;
+      resolveCommand('late-success');
+
+      await expect(operation.result).rejects.toMatchObject({
+        code: failure === 'dispose' ? 'operation_disposed' : 'external_artifact_incompatible',
+      });
+      expect(first.listeners.get('provisional')?.size).toBe(0);
+    }
+  );
+
+  it('contains command-queue and command-callback throws', async () => {
+    const pushError = new Error('push failed');
+    const callbackError = new Error('callback failed');
+    const throwingPush = {
+      apiReady: true,
+      pubadsReady: true,
+      cmd: {
+        push: () => {
+          throw pushError;
+        },
+      },
+      display: vi.fn(),
+      pubads: () => createReadyGoogletag().pubads,
+    };
+    const pushAdapter = createBrowserGoogletagAdapter({ googletag: throwingPush });
+
+    let pushOperation: ReturnType<typeof pushAdapter.run> | undefined;
+    expect(() => {
+      pushOperation = pushAdapter.run(() => undefined);
+    }).not.toThrow();
+    await expect(pushOperation?.result).rejects.toBe(pushError);
+
+    const deferred = createReadyGoogletag({ deferCommands: true });
+    const callbackAdapter = createBrowserGoogletagAdapter({ googletag: deferred.googletag });
+    const callbackOperation = callbackAdapter.run(() => {
+      throw callbackError;
+    });
+    expect(() => deferred.commands[0]?.()).not.toThrow();
+    await expect(callbackOperation.result).rejects.toBe(callbackError);
+  });
+
+  it('owns GPT subscriptions, refresh, targeting, and service inspection behind the facade', async () => {
+    const ready = createReadyGoogletag({ initialLoadDisabled: true });
+    const targeting = new Map<string, string[]>();
+    const slot = {
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) targeting.clear();
+        else targeting.delete(key);
+      }),
+      getAdUnitPath: vi.fn(() => '/publisher/example'),
+      getTargeting: vi.fn((key: string) => targeting.get(key) ?? []),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        targeting.set(key, typeof value === 'string' ? [value] : [...value]);
+      }),
+    };
+    ready.pubads.getSlots.mockReturnValue([slot]);
+    const listener = vi.fn(() => {
+      throw new Error('publisher callback failed');
+    });
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const operation = adapter.run((gpt) => {
+      const unsubscribe = gpt.subscribe('slotRequested', listener);
+      gpt.setTargeting(slot, 'hb_adid', 'reservation');
+      expect(gpt.getTargeting(slot, 'hb_adid')).toEqual(['reservation']);
+      expect(gpt.adUnitPath?.(slot)).toBe('/publisher/example');
+      gpt.refresh([slot], { changeCorrelator: false });
+      expect(gpt.slots()).toEqual([slot]);
+      expect(Object.isFrozen(gpt.slots())).toBe(true);
+      expect(gpt.serviceState()).toEqual({
+        apiReady: true,
+        initialLoadDisabled: true,
+        pubadsReady: true,
+      });
+      const installed = [...(ready.listeners.get('slotRequested') ?? [])][0];
+      expect(() => installed?.({ slot })).not.toThrow();
+      unsubscribe();
+      gpt.clearTargeting(slot, 'hb_adid');
+    });
+
+    await expect(operation.result).resolves.toBeUndefined();
+    expect(listener).toHaveBeenCalledWith({ slot });
+    expect(ready.pubads.refresh).toHaveBeenCalledWith([slot], { changeCorrelator: false });
+    expect(ready.pubads.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(targeting.has('hb_adid')).toBe(false);
+  });
+
+  it('enables SRA before GPT services and does not reconfigure an enabled publisher service', async () => {
+    const disabled = createReadyGoogletag({ servicesEnabled: false });
+    const order: string[] = [];
+    disabled.pubads.enableSingleRequest.mockImplementation(() => {
+      order.push('sra');
+      return true;
+    });
+    disabled.googletag.enableServices.mockImplementation(() => {
+      order.push('services');
+      disabled.googletag.pubadsReady = true;
+    });
+    const adapter = createBrowserGoogletagAdapter({ googletag: disabled.googletag });
+
+    await expect(adapter.run((gpt) => gpt.enableServices()).result).resolves.toBeUndefined();
+    await expect(adapter.run((gpt) => gpt.enableServices()).result).resolves.toBeUndefined();
+
+    expect(order).toEqual(['sra', 'services']);
+  });
+
+  it('exposes one reversible publisher-call observer without changing ordinary calls', () => {
+    const ready = createReadyGoogletag();
+    const nativeDisplay = ready.googletag.display;
+    const nativeRefresh = ready.pubads.refresh;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const boundary = adapter as unknown as {
+      observePublisherCalls?: (observer: object) => () => void;
+    };
+
+    expect(boundary.observePublisherCalls).toBeTypeOf('function');
+    if (!boundary.observePublisherCalls) return;
+
+    const release = boundary.observePublisherCalls(Object.freeze({}));
+    expect(ready.googletag.display).not.toBe(nativeDisplay);
+    expect(ready.pubads.refresh).not.toBe(nativeRefresh);
+
+    release();
+    expect(ready.googletag.display).toBe(nativeDisplay);
+    expect(ready.pubads.refresh).toBe(nativeRefresh);
+  });
+
+  it('keeps an existing event subscription live while installing publisher-call wrappers', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const listener = vi.fn();
+    let unsubscribe: (() => void) | undefined;
+    const subscription = adapter.run((gpt) => {
+      unsubscribe = gpt.subscribe('slotRequested', listener);
+    });
+    await expect(subscription.result).resolves.toBeUndefined();
+    const installed = [...(ready.listeners.get('slotRequested') ?? [])][0];
+    expect(installed).toBeTypeOf('function');
+
+    const releasePublisherObserver = adapter.observePublisherCalls(Object.freeze({}));
+    installed?.({ slot: Object.freeze({ id: 'slot-a' }) });
+
+    expect(listener).toHaveBeenCalledOnce();
+    unsubscribe?.();
+    releasePublisherObserver();
+  });
+
+  it('installs the publisher observer when an accepted command-queue stub becomes ready', () => {
+    const commands: Array<() => void> = [];
+    const pending = {
+      cmd: {
+        push: vi.fn((callback: () => void) => {
+          commands.push(callback);
+          return commands.length;
+        }),
+      },
+    };
+    const target = { googletag: pending as object };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const handoff = {};
+    const release = adapter.observePublisherCalls({
+      defineSlot: () => Object.freeze({ action: 'handoff', slot: handoff }),
+    });
+    const ready = createReadyGoogletag();
+    const nativeDefineSlot = vi.fn((_path: string, _sizes: unknown, _elementId: string) => ({}));
+    Object.assign(pending, {
+      apiReady: true,
+      defineSlot: nativeDefineSlot,
+      destroySlots: ready.googletag.destroySlots,
+      display: ready.googletag.display,
+      getConfig: ready.googletag.getConfig,
+      pubads: ready.googletag.pubads,
+      pubadsReady: true,
+      setConfig: ready.googletag.setConfig,
+    });
+
+    expect(commands).toHaveLength(1);
+    commands[0]?.();
+    const defineSlot = (pending as typeof pending & { defineSlot: typeof nativeDefineSlot })
+      .defineSlot;
+    expect(defineSlot).not.toBe(nativeDefineSlot);
+    expect(defineSlot('/publisher', [300, 250], 'slot')).toBe(handoff);
+    expect(nativeDefineSlot).not.toHaveBeenCalled();
+
+    release();
+    expect((pending as typeof pending & { defineSlot: typeof nativeDefineSlot }).defineSlot).toBe(
+      nativeDefineSlot
+    );
+  });
+
+  it('does not classify facade-driven GPT calls as publisher calls', async () => {
+    const ready = createReadyGoogletag();
+    const nativeRefresh = ready.pubads.refresh;
+    const observer = {
+      display: vi.fn(() => Object.freeze({ action: 'suppress' as const })),
+      refresh: vi.fn(() => Object.freeze({ action: 'suppress' as const })),
+    };
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    adapter.observePublisherCalls(observer);
+
+    await expect(
+      adapter.run((gpt) => {
+        gpt.display('trusted-slot');
+        gpt.refresh([], { changeCorrelator: false });
+      }).result
+    ).resolves.toBeUndefined();
+
+    expect(observer.display).not.toHaveBeenCalled();
+    expect(observer.refresh).not.toHaveBeenCalled();
+    expect(ready.display).toHaveBeenCalledExactlyOnceWith('trusted-slot');
+    expect(nativeRefresh).toHaveBeenCalledExactlyOnceWith([], {
+      changeCorrelator: false,
+    });
+  });
+
+  it('observes publisher GPT calls reentered by one facade-driven native display', async () => {
+    const ready = createReadyGoogletag();
+    const slot = Object.freeze({ id: 'nested-publisher-slot' });
+    ready.pubads.getSlots.mockReturnValue([slot]);
+    ready.googletag.defineSlot.mockReturnValue(slot);
+    ready.googletag.destroySlots.mockReturnValue(true);
+    ready.display.mockImplementation(() => {
+      ready.pubads.refresh([slot], { changeCorrelator: true });
+      ready.googletag.defineSlot('/publisher', [300, 250], 'nested-slot');
+      ready.googletag.destroySlots([slot]);
+    });
+    const observer = {
+      defineSlot: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      destroySlots: vi.fn(),
+      display: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      refresh: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+    };
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    adapter.observePublisherCalls(observer);
+
+    await expect(adapter.run((gpt) => gpt.display('trusted-slot')).result).resolves.toBeUndefined();
+
+    expect(observer.display).not.toHaveBeenCalled();
+    expect(observer.refresh).toHaveBeenCalledExactlyOnceWith({
+      options: { changeCorrelator: true },
+      requestedSlots: [slot],
+      slots: [slot],
+    });
+    expect(observer.defineSlot).toHaveBeenCalledExactlyOnceWith({
+      adUnitPath: '/publisher',
+      elementId: 'nested-slot',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    expect(observer.destroySlots).toHaveBeenCalledExactlyOnceWith({ slots: [slot] });
+  });
+
+  it('observes a publisher wrapper call made inside a TS command but outside a facade invocation', async () => {
+    const ready = createReadyGoogletag();
+    const observer = {
+      defineSlot: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      display: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+    };
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    adapter.observePublisherCalls(observer);
+
+    await expect(
+      adapter.run((gpt) => {
+        ready.googletag.defineSlot('/publisher', [300, 250], 'publisher-inside-command');
+        gpt.display('trusted-slot');
+      }).result
+    ).resolves.toBeUndefined();
+
+    expect(observer.defineSlot).toHaveBeenCalledExactlyOnceWith({
+      adUnitPath: '/publisher',
+      elementId: 'publisher-inside-command',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    expect(observer.display).not.toHaveBeenCalled();
+  });
+
+  it('commits publisher display and refresh admissions only after exact native returns', () => {
+    const ready = createReadyGoogletag();
+    const slot = Object.freeze({ id: 'publisher-slot' });
+    const receiver = Object.freeze({ publisher: true });
+    const refreshOptions = Object.freeze({ changeCorrelator: false, publisher: 'exact' });
+    const order: string[] = [];
+    const displayAdmission = Object.freeze({
+      commit: vi.fn(() => order.push('commit:display')),
+      rollback: vi.fn(),
+    });
+    const refreshAdmission = Object.freeze({
+      commit: vi.fn(() => order.push('commit:refresh')),
+      rollback: vi.fn(),
+    });
+    const nativeDisplay = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:display');
+      return Object.freeze({ arguments_, receiver: this });
+    });
+    const nativeRefresh = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:refresh');
+      return Object.freeze({ arguments_, receiver: this });
+    });
+    ready.googletag.display = nativeDisplay;
+    ready.pubads.refresh = nativeRefresh;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    adapter.observePublisherCalls({
+      display: () => Object.freeze({ action: 'forward' as const, admission: displayAdmission }),
+      refresh: () => Object.freeze({ action: 'forward' as const, admission: refreshAdmission }),
+    });
+
+    const display = ready.googletag.display as (...arguments_: unknown[]) => unknown;
+    expect(Reflect.apply(display, receiver, ['slot'])).toEqual({
+      arguments_: ['slot'],
+      receiver,
+    });
+    const refresh = ready.pubads.refresh as (...arguments_: unknown[]) => unknown;
+    expect(Reflect.apply(refresh, receiver, [[slot], refreshOptions])).toEqual({
+      arguments_: [[slot], refreshOptions],
+      receiver,
+    });
+
+    expect(order).toEqual(['native:display', 'commit:display', 'native:refresh', 'commit:refresh']);
+    expect(displayAdmission.rollback).not.toHaveBeenCalled();
+    expect(refreshAdmission.rollback).not.toHaveBeenCalled();
+  });
+
+  it('defers one explicit refresh and forwards the complete snapshot with exact options once', async () => {
+    const ready = createReadyGoogletag();
+    const first = Object.freeze({ id: 'first' });
+    const second = Object.freeze({ id: 'second' });
+    const options = Object.freeze({ changeCorrelator: false, publisher: 'exact-options' });
+    const originalSlots = [first, second];
+    let complete!: () => void;
+    const completion = new Promise<void>((resolve) => {
+      complete = resolve;
+    });
+    const admission = Object.freeze({ commit: vi.fn(), rollback: vi.fn() });
+    const nativeRefresh = vi.fn();
+    ready.pubads.refresh = nativeRefresh;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    adapter.observePublisherCalls({
+      refresh: () =>
+        Object.freeze({
+          action: 'defer' as const,
+          admission,
+          completion,
+          slots: Object.freeze([first, second]),
+        }),
+    });
+
+    expect(ready.pubads.refresh(originalSlots, options)).toBeUndefined();
+    originalSlots.length = 0;
+    expect(nativeRefresh).not.toHaveBeenCalled();
+
+    complete();
+    await completion;
+    await Promise.resolve();
+    expect(nativeRefresh).toHaveBeenCalledExactlyOnceWith([first, second], options);
+    expect(admission.commit).toHaveBeenCalledOnce();
+    expect(admission.rollback).not.toHaveBeenCalled();
+    await Promise.resolve();
+    expect(nativeRefresh).toHaveBeenCalledOnce();
+  });
+
+  it('forwards a deferred global refresh exactly once when its observer is released', async () => {
+    const ready = createReadyGoogletag();
+    const first = Object.freeze({ id: 'first' });
+    const second = Object.freeze({ id: 'second' });
+    const options = Object.freeze({ changeCorrelator: true });
+    ready.pubads.getSlots.mockReturnValue([first, second]);
+    let complete!: () => void;
+    const completion = new Promise<void>((resolve) => {
+      complete = resolve;
+    });
+    const nativeRefresh = vi.fn();
+    ready.pubads.refresh = nativeRefresh;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const release = adapter.observePublisherCalls({
+      refresh: () =>
+        Object.freeze({
+          action: 'defer' as const,
+          completion,
+          slots: Object.freeze([first, second]),
+        }),
+    });
+
+    ready.pubads.refresh(undefined, options);
+    expect(nativeRefresh).not.toHaveBeenCalled();
+    release();
+    expect(nativeRefresh).toHaveBeenCalledExactlyOnceWith([first, second], options);
+
+    complete();
+    await completion;
+    await Promise.resolve();
+    expect(nativeRefresh).toHaveBeenCalledOnce();
+  });
+
+  it('rolls back each unconsumed publisher admission on native throw and rethrows the exact error', () => {
+    const ready = createReadyGoogletag();
+    const displayError = new Error('exact display failure');
+    const refreshError = new Error('exact refresh failure');
+    const displayAdmissions = [0, 1].map(() =>
+      Object.freeze({ commit: vi.fn(), rollback: vi.fn() })
+    );
+    const refreshAdmission = Object.freeze({ commit: vi.fn(), rollback: vi.fn() });
+    ready.googletag.display = vi.fn(() => {
+      throw displayError;
+    });
+    ready.pubads.refresh = vi.fn(() => {
+      throw refreshError;
+    });
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    let displayAttempt = 0;
+    adapter.observePublisherCalls({
+      display: () =>
+        Object.freeze({
+          action: 'forward' as const,
+          admission: displayAdmissions[displayAttempt++]!,
+        }),
+      refresh: () => Object.freeze({ action: 'forward' as const, admission: refreshAdmission }),
+    });
+
+    const display = ready.googletag.display as (...arguments_: unknown[]) => unknown;
+    expect(() => display('slot')).toThrow(displayError);
+    expect(() => display('slot')).toThrow(displayError);
+    const refresh = ready.pubads.refresh as (...arguments_: unknown[]) => unknown;
+    expect(() => refresh(undefined, { changeCorrelator: true })).toThrow(refreshError);
+
+    for (const admission of displayAdmissions) {
+      expect(admission.rollback).toHaveBeenCalledOnce();
+      expect(admission.commit).not.toHaveBeenCalled();
+    }
+    expect(refreshAdmission.rollback).toHaveBeenCalledOnce();
+    expect(refreshAdmission.commit).not.toHaveBeenCalled();
+  });
+
+  it.each(['pubads', 'target_getter'] as const)(
+    'fails open to captured publisher natives when %s identity probing throws',
+    (failure) => {
+      const ready = createReadyGoogletag();
+      const target: { googletag?: unknown } = { googletag: ready.googletag };
+      const slot = Object.freeze({ id: 'publisher-slot' });
+      const nativeDefine = vi.fn(() => 'defined');
+      const nativeDisplay = vi.fn(() => 'displayed');
+      const nativeRefresh = vi.fn(() => 'refreshed');
+      const nativeDestroy = vi.fn(() => true);
+      ready.googletag.defineSlot = nativeDefine;
+      ready.googletag.display = nativeDisplay;
+      ready.googletag.destroySlots = nativeDestroy;
+      ready.pubads.refresh = nativeRefresh;
+      ready.pubads.getSlots.mockReturnValue([slot]);
+      const adapter = createBrowserGoogletagAdapter(target);
+      const observer = {
+        defineSlot: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+        destroySlots: vi.fn(),
+        display: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+        refresh: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      };
+      adapter.observePublisherCalls(observer);
+      const define = ready.googletag.defineSlot as (...arguments_: unknown[]) => unknown;
+      const display = ready.googletag.display as (...arguments_: unknown[]) => unknown;
+      const refresh = ready.pubads.refresh as (...arguments_: unknown[]) => unknown;
+      const destroy = ready.googletag.destroySlots as (...arguments_: unknown[]) => unknown;
+      const identityError = new Error(`throwing ${failure}`);
+      if (failure === 'pubads') {
+        ready.googletag.pubads.mockImplementation(() => {
+          throw identityError;
+        });
+      } else {
+        Object.defineProperty(target, 'googletag', {
+          configurable: true,
+          get: () => {
+            throw identityError;
+          },
+        });
+      }
+
+      expect(define('/publisher', [300, 250], 'slot')).toBe('defined');
+      expect(display('slot')).toBe('displayed');
+      expect(refresh([slot], { changeCorrelator: false })).toBe('refreshed');
+      expect(destroy([slot])).toBe(true);
+      expect(nativeDefine).toHaveBeenCalledOnce();
+      expect(nativeDisplay).toHaveBeenCalledOnce();
+      expect(nativeRefresh).toHaveBeenCalledOnce();
+      expect(nativeDestroy).toHaveBeenCalledOnce();
+      expect(observer.defineSlot).not.toHaveBeenCalled();
+      expect(observer.display).not.toHaveBeenCalled();
+      expect(observer.refresh).not.toHaveBeenCalled();
+      expect(observer.destroySlots).not.toHaveBeenCalled();
+    }
+  );
+
+  it('mediates only explicit publisher decisions and preserves receiver, arguments, return, throw, and order', () => {
+    const ready = createReadyGoogletag({ initialLoadDisabled: true });
+    const handoffSlot = Object.freeze({ id: 'handoff' });
+    const ordinarySlot = Object.freeze({ id: 'ordinary' });
+    const refreshOptions = Object.freeze({ changeCorrelator: true, publisher: 'kept' });
+    const publisherError = new Error('publisher display failed');
+    const defineReceiver = Object.freeze({ receiver: 'define' });
+    const refreshReceiver = Object.freeze({ receiver: 'refresh' });
+    const order: string[] = [];
+    const nativeDefineSlot = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:define');
+      return Object.freeze({ arguments_, receiver: this });
+    });
+    const nativeDisplay = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:display');
+      if (arguments_[0] === 'throw') throw publisherError;
+      return Object.freeze({ arguments_, receiver: this });
+    });
+    const nativeRefresh = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:refresh');
+      return Object.freeze({ arguments_, receiver: this });
+    });
+    const nativeDestroy = vi.fn(function (this: unknown, ...arguments_: unknown[]) {
+      order.push('native:destroy');
+      return arguments_[0] === 'throw'
+        ? (() => {
+            throw new Error('publisher destroy failed');
+          })()
+        : true;
+    });
+    Object.assign(ready.googletag, {
+      defineSlot: nativeDefineSlot,
+      destroySlots: nativeDestroy,
+      display: nativeDisplay,
+    });
+    ready.pubads.refresh = nativeRefresh;
+    ready.pubads.getSlots.mockReturnValue([handoffSlot, ordinarySlot]);
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    let suppressDisplay = true;
+    const destroyed: Array<readonly object[]> = [];
+    const release = adapter.observePublisherCalls({
+      defineSlot: (call) => {
+        order.push('observer:define');
+        expect(call.initialLoadDisabled).toBe(true);
+        return call.elementId === 'handoff-id'
+          ? Object.freeze({ action: 'handoff' as const, slot: handoffSlot })
+          : Object.freeze({ action: 'forward' as const });
+      },
+      destroySlots: (call) => {
+        order.push('observer:destroy');
+        destroyed.push(call.slots);
+      },
+      display: () => {
+        order.push('observer:display');
+        if (!suppressDisplay) return Object.freeze({ action: 'forward' as const });
+        suppressDisplay = false;
+        return Object.freeze({ action: 'suppress' as const });
+      },
+      refresh: (call) => {
+        order.push('observer:refresh');
+        expect(call.requestedSlots).toBeUndefined();
+        expect(call.slots).toEqual([handoffSlot, ordinarySlot]);
+        return Object.freeze({ action: 'replace' as const, slots: Object.freeze([ordinarySlot]) });
+      },
+    });
+
+    const defineSlot = ready.googletag.defineSlot as unknown as (
+      ...arguments_: unknown[]
+    ) => unknown;
+    expect(
+      Reflect.apply(defineSlot, defineReceiver, ['/publisher', [300, 250], 'handoff-id'])
+    ).toBe(handoffSlot);
+    expect(nativeDefineSlot).not.toHaveBeenCalled();
+    const forwarded = Reflect.apply(defineSlot, defineReceiver, [
+      '/publisher',
+      [728, 90],
+      'ordinary-id',
+      'publisher-extra',
+    ]);
+    expect(forwarded).toEqual({
+      arguments_: ['/publisher', [728, 90], 'ordinary-id', 'publisher-extra'],
+      receiver: defineReceiver,
+    });
+
+    const display = ready.googletag.display as (...arguments_: unknown[]) => unknown;
+    expect(Reflect.apply(display, defineReceiver, ['handoff-id'])).toBeUndefined();
+    expect(Reflect.apply(display, defineReceiver, ['handoff-id', 'publisher-extra'])).toEqual({
+      arguments_: ['handoff-id', 'publisher-extra'],
+      receiver: defineReceiver,
+    });
+    expect(() => Reflect.apply(display, defineReceiver, ['throw', 'publisher-extra'])).toThrow(
+      publisherError
+    );
+
+    const refresh = ready.pubads.refresh as (...arguments_: unknown[]) => unknown;
+    expect(Reflect.apply(refresh, refreshReceiver, [undefined, refreshOptions])).toEqual({
+      arguments_: [[ordinarySlot], refreshOptions],
+      receiver: refreshReceiver,
+    });
+
+    const destroySlots = ready.googletag.destroySlots as unknown as (
+      slots?: readonly object[]
+    ) => unknown;
+    expect(destroySlots([handoffSlot])).toBe(true);
+    expect(destroyed).toEqual([[handoffSlot]]);
+    expect(order).toEqual([
+      'observer:define',
+      'native:define',
+      'observer:display',
+      'native:display',
+      'native:display',
+      'observer:refresh',
+      'native:refresh',
+      'native:destroy',
+      'observer:destroy',
+    ]);
+
+    release();
+  });
+
+  it('tracks native GPT initial-load configuration without duplicate wrappers', async () => {
+    const ready = createReadyGoogletag({ initialLoadDisabled: true });
+    const nativeSetConfig = ready.googletag.setConfig;
+    const nativeDisableInitialLoad = ready.pubads.disableInitialLoad;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+
+    await expect(adapter.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      true
+    );
+    const wrappedSetConfig = ready.googletag.setConfig;
+    const wrappedDisableInitialLoad = ready.pubads.disableInitialLoad;
+    expect(wrappedSetConfig).not.toBe(nativeSetConfig);
+    expect(wrappedDisableInitialLoad).not.toBe(nativeDisableInitialLoad);
+    expect(ready.googletag.getConfig).toHaveBeenCalledWith('disableInitialLoad');
+
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    expect(ready.googletag.setConfig).toBe(wrappedSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(wrappedDisableInitialLoad);
+
+    expect(ready.googletag.setConfig({ disableInitialLoad: false })).toBe('config-result');
+    await expect(adapter.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      false
+    );
+    expect(ready.pubads.disableInitialLoad()).toBe('legacy-result');
+    await expect(adapter.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      true
+    );
+
+    adapter.dispose();
+    expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(nativeDisableInitialLoad);
+    expect(Reflect.ownKeys(ready.googletag).some((key) => String(key).startsWith('__ts'))).toBe(
+      false
+    );
+  });
+
+  it('preserves GPT configuration calls and falls back only when getConfig is unavailable', async () => {
+    const ready = createReadyGoogletag();
+    const binding = ready.googletag as unknown as Record<string, unknown>;
+    const nativeSetConfig = vi.fn(function (
+      this: unknown,
+      config: { readonly disableInitialLoad?: boolean | null },
+      marker: string
+    ) {
+      ready.initialLoad.disabled = config.disableInitialLoad === true;
+      return { marker, receiver: this };
+    });
+    binding['setConfig'] = nativeSetConfig;
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    const receiver = { publisher: true };
+    const config = { disableInitialLoad: true };
+
+    const wrappedSetConfig = binding['setConfig'] as (...arguments_: unknown[]) => unknown;
+    const returned = Reflect.apply(wrappedSetConfig, receiver, [config, 'exact']);
+    expect(nativeSetConfig).toHaveBeenCalledWith(config, 'exact');
+    expect(returned).toEqual({ marker: 'exact', receiver });
+    await expect(adapter.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      true
+    );
+
+    binding['getConfig'] = undefined;
+    Reflect.apply(wrappedSetConfig, receiver, [{ disableInitialLoad: false }, 'fallback']);
+    await expect(adapter.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      false
+    );
+  });
+
+  it('shares one GPT wrapper across adapter instances until the last owner disposes', async () => {
+    const ready = createReadyGoogletag();
+    const nativeSetConfig = ready.googletag.setConfig;
+    const nativeDisableInitialLoad = ready.pubads.disableInitialLoad;
+    const first = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    const second = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    await first.run((gpt) => gpt.serviceState()).result;
+    const sharedSetConfig = ready.googletag.setConfig;
+    const sharedDisableInitialLoad = ready.pubads.disableInitialLoad;
+
+    await second.run((gpt) => gpt.serviceState()).result;
+    expect(ready.googletag.setConfig).toBe(sharedSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(sharedDisableInitialLoad);
+
+    first.dispose();
+    expect(ready.googletag.setConfig).toBe(sharedSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(sharedDisableInitialLoad);
+    ready.googletag.setConfig({ disableInitialLoad: true });
+    await expect(second.run((gpt) => gpt.serviceState().initialLoadDisabled).result).resolves.toBe(
+      true
+    );
+
+    second.dispose();
+    expect(ready.googletag.setConfig).toBe(nativeSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(nativeDisableInitialLoad);
+  });
+
+  it('releases historical GPT initial-load ownership across A to B to C', async () => {
+    const first = createReadyGoogletag();
+    const second = createReadyGoogletag();
+    const third = createReadyGoogletag();
+    const firstNativeSetConfig = first.googletag.setConfig;
+    const firstNativeDisable = first.pubads.disableInitialLoad;
+    const secondPublisherSetConfig = vi.fn();
+    const secondPublisherDisable = vi.fn();
+    const thirdNativeSetConfig = third.googletag.setConfig;
+    const thirdNativeDisable = third.pubads.disableInitialLoad;
+    const target: { googletag?: unknown } = { googletag: first.googletag };
+    const adapter = createBrowserGoogletagAdapter(target);
+
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    expect(first.googletag.setConfig).not.toBe(firstNativeSetConfig);
+    target.googletag = second.googletag;
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    expect(first.googletag.setConfig).toBe(firstNativeSetConfig);
+    expect(first.pubads.disableInitialLoad).toBe(firstNativeDisable);
+
+    second.googletag.setConfig = secondPublisherSetConfig;
+    second.pubads.disableInitialLoad = secondPublisherDisable;
+    target.googletag = third.googletag;
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    expect(second.googletag.setConfig).toBe(secondPublisherSetConfig);
+    expect(second.pubads.disableInitialLoad).toBe(secondPublisherDisable);
+    expect(third.googletag.setConfig).not.toBe(thirdNativeSetConfig);
+    expect(third.pubads.disableInitialLoad).not.toBe(thirdNativeDisable);
+
+    adapter.dispose();
+    expect(third.googletag.setConfig).toBe(thirdNativeSetConfig);
+    expect(third.pubads.disableInitialLoad).toBe(thirdNativeDisable);
+  });
+
+  it('preserves shared GPT initial-load ownership when one adapter changes bindings', async () => {
+    const first = createReadyGoogletag();
+    const second = createReadyGoogletag();
+    const firstNativeSetConfig = first.googletag.setConfig;
+    const firstNativeDisable = first.pubads.disableInitialLoad;
+    const secondNativeSetConfig = second.googletag.setConfig;
+    const firstTarget: { googletag?: unknown } = { googletag: first.googletag };
+    const secondTarget: { googletag?: unknown } = { googletag: first.googletag };
+    const firstAdapter = createBrowserGoogletagAdapter(firstTarget);
+    const secondAdapter = createBrowserGoogletagAdapter(secondTarget);
+    await firstAdapter.run((gpt) => gpt.serviceState()).result;
+    await secondAdapter.run((gpt) => gpt.serviceState()).result;
+    const sharedSetConfig = first.googletag.setConfig;
+
+    firstTarget.googletag = second.googletag;
+    await firstAdapter.run((gpt) => gpt.serviceState()).result;
+    expect(first.googletag.setConfig).toBe(sharedSetConfig);
+    expect(first.pubads.disableInitialLoad).not.toBe(firstNativeDisable);
+    expect(second.googletag.setConfig).not.toBe(secondNativeSetConfig);
+
+    secondAdapter.dispose();
+    expect(first.googletag.setConfig).toBe(firstNativeSetConfig);
+    expect(first.pubads.disableInitialLoad).toBe(firstNativeDisable);
+    expect(second.googletag.setConfig).not.toBe(secondNativeSetConfig);
+
+    firstAdapter.dispose();
+    expect(second.googletag.setConfig).toBe(secondNativeSetConfig);
+  });
+
+  it('does not overwrite publisher GPT method replacements during restoration', async () => {
+    const ready = createReadyGoogletag();
+    const adapter = createBrowserGoogletagAdapter({ googletag: ready.googletag });
+    await adapter.run((gpt) => gpt.serviceState()).result;
+    const publisherSetConfig = vi.fn();
+    const publisherDisableInitialLoad = vi.fn();
+    ready.googletag.setConfig = publisherSetConfig;
+    ready.pubads.disableInitialLoad = publisherDisableInitialLoad;
+
+    adapter.dispose();
+
+    expect(ready.googletag.setConfig).toBe(publisherSetConfig);
+    expect(ready.pubads.disableInitialLoad).toBe(publisherDisableInitialLoad);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/adapters/messaging.test.ts b/crates/trusted-server-js/lib/test/adapters/messaging.test.ts
new file mode 100644
index 000000000..88b72a384
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/adapters/messaging.test.ts
@@ -0,0 +1,1635 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  PROTOCOL_MESSAGE_SCHEMAS_V1,
+  TSJS_MESSAGE_PROTOCOL_V1,
+  createBrowserMessagingAdapter,
+} from '../../src/adapters/messaging';
+
+function createTarget() {
+  return {
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  };
+}
+
+function createPort() {
+  const listeners = new Set<(event: unknown) => void>();
+  const messageErrorListeners = new Set<(event: unknown) => void>();
+  return {
+    addEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      (type === 'messageerror' ? messageErrorListeners : listeners).add(listener);
+    }),
+    close: vi.fn(),
+    listeners,
+    messageErrorListeners,
+    postMessage: vi.fn(),
+    removeEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      (type === 'messageerror' ? messageErrorListeners : listeners).delete(listener);
+    }),
+    start: vi.fn(),
+  };
+}
+
+function createApsRenderer() {
+  return {
+    type: 'aps',
+    version: 1,
+    accountId: 'publisher-account',
+    bidId: 'bid-1',
+    tagType: 'iframe',
+    creativeUrl: 'https://creative.example/render',
+    width: 300,
+    height: 250,
+    aaxResponse: 'renderer-envelope',
+  };
+}
+
+describe('browser messaging adapter', () => {
+  it('creates one owned channel and transfers only its exact wrapped endpoint', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    if (!channel) throw new Error('Expected one channel');
+    expect(Object.isFrozen(channel)).toBe(true);
+    expect(Object.isFrozen(channel.retained)).toBe(true);
+    expect(Object.isFrozen(channel.transferred)).toBe(true);
+
+    const receiver = { postMessage: vi.fn() };
+    const envelope = Object.freeze({ version: 1, nonce: 'n1_abcdefghijklmnopqrstuv' });
+    expect(adapter.postWindow(receiver, envelope, '*', [channel.transferred])).toBe(true);
+    expect(receiver.postMessage).toHaveBeenCalledWith(envelope, '*', [transferredRaw]);
+    channel.transferred.close();
+    expect(transferredRaw.close).not.toHaveBeenCalled();
+    expect(adapter.postWindow(receiver, envelope, '*', [channel.transferred])).toBe(false);
+    channel.retained.close();
+    expect(retainedRaw.close).toHaveBeenCalledOnce();
+  });
+
+  it('leaves an untransferred endpoint locally closeable when exact window posting fails', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    if (!channel) throw new Error('Expected one channel');
+    const receiver = {
+      postMessage: vi.fn(() => {
+        throw new Error('window post failed');
+      }),
+    };
+    expect(adapter.postWindow(receiver, Object.freeze({}), '*', [channel.transferred])).toBe(false);
+    channel.transferred.close();
+    expect(transferredRaw.close).toHaveBeenCalledOnce();
+    channel.retained.close();
+  });
+
+  it('reserves a transferred endpoint before a reentrant window post', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    if (!channel) throw new Error('Expected one channel');
+    let nested: boolean | undefined;
+    const receiver = {
+      postMessage: vi.fn(() => {
+        nested = adapter.postWindow(receiver, Object.freeze({ nested: true }), '*', [
+          channel.transferred,
+        ]);
+      }),
+    };
+    expect(
+      adapter.postWindow(receiver, Object.freeze({ outer: true }), '*', [channel.transferred])
+    ).toBe(true);
+    expect(nested).toBe(false);
+    expect(receiver.postMessage).toHaveBeenCalledOnce();
+    channel.transferred.close();
+    expect(transferredRaw.close).not.toHaveBeenCalled();
+  });
+
+  it('closes invalid channel endpoints without returning a partial facade', () => {
+    const duplicate = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = duplicate;
+        readonly port2 = duplicate;
+      },
+    });
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(duplicate.close).toHaveBeenCalledOnce();
+    expect(createBrowserMessagingAdapter(createTarget()).createChannel()).toBeUndefined();
+  });
+
+  it('transfers through descriptor snapshots when Array prototype operations are poisoned', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    if (!channel) throw new Error('Expected one channel');
+    let posts = 0;
+    let receivedTransfer: unknown;
+    const receiver = {
+      postMessage(...parameters: unknown[]): void {
+        posts += 1;
+        receivedTransfer = parameters[2];
+      },
+    };
+    const originalFilter = Object.getOwnPropertyDescriptor(Array.prototype, 'filter');
+    const originalSort = Object.getOwnPropertyDescriptor(Array.prototype, 'sort');
+    const originalPush = Object.getOwnPropertyDescriptor(Array.prototype, 'push');
+    const originalIterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const poisoned = (): never => {
+      throw new Error('poisoned Array prototype operation');
+    };
+    let result: boolean | undefined;
+    let thrown: unknown;
+    try {
+      Object.defineProperty(Array.prototype, 'filter', { value: poisoned, configurable: true });
+      Object.defineProperty(Array.prototype, 'sort', { value: poisoned, configurable: true });
+      Object.defineProperty(Array.prototype, 'push', { value: poisoned, configurable: true });
+      Object.defineProperty(Array.prototype, Symbol.iterator, {
+        value: poisoned,
+        configurable: true,
+      });
+      result = adapter.postWindow(receiver, Object.freeze({}), '*', [channel.transferred]);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      if (originalFilter) Object.defineProperty(Array.prototype, 'filter', originalFilter);
+      if (originalSort) Object.defineProperty(Array.prototype, 'sort', originalSort);
+      if (originalPush) Object.defineProperty(Array.prototype, 'push', originalPush);
+      if (originalIterator) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, originalIterator);
+      }
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(result).toBe(true);
+    expect(posts).toBe(1);
+    expect(receivedTransfer).toEqual([transferredRaw]);
+    channel.retained.close();
+  });
+
+  it('drains listeners and closes the raw port when collection iterators are poisoned', () => {
+    let messageListener: unknown;
+    let messageErrorListener: unknown;
+    let removals = 0;
+    let closes = 0;
+    const raw = {
+      addEventListener(type: string, listener: unknown): void {
+        if (type === 'message') messageListener = listener;
+        else messageErrorListener = listener;
+      },
+      close(): void {
+        closes += 1;
+      },
+      postMessage(): void {},
+      removeEventListener(type: string, listener: unknown): void {
+        if (type === 'message' && listener === messageListener) removals += 1;
+        if (type === 'messageerror' && listener === messageErrorListener) removals += 1;
+      },
+      start(): void {},
+    };
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+    if (!port) throw new Error('Expected one port');
+    port.listen(
+      () => undefined,
+      () => undefined
+    );
+
+    const originalSetIterator = Object.getOwnPropertyDescriptor(Set.prototype, Symbol.iterator);
+    const originalSetValues = Object.getOwnPropertyDescriptor(Set.prototype, 'values');
+    const originalArrayIterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const iteratorPrototype = Object.getPrototypeOf(new Set().values()) as object;
+    const originalNext = Object.getOwnPropertyDescriptor(iteratorPrototype, 'next');
+    const poisoned = (): never => {
+      throw new Error('poisoned collection iterator');
+    };
+    let thrown: unknown;
+    try {
+      Object.defineProperty(Set.prototype, Symbol.iterator, {
+        value: poisoned,
+        configurable: true,
+      });
+      Object.defineProperty(Set.prototype, 'values', { value: poisoned, configurable: true });
+      Object.defineProperty(Array.prototype, Symbol.iterator, {
+        value: poisoned,
+        configurable: true,
+      });
+      Object.defineProperty(iteratorPrototype, 'next', { value: poisoned, configurable: true });
+      port.close();
+    } catch (error) {
+      thrown = error;
+    } finally {
+      if (originalSetIterator) {
+        Object.defineProperty(Set.prototype, Symbol.iterator, originalSetIterator);
+      }
+      if (originalSetValues) Object.defineProperty(Set.prototype, 'values', originalSetValues);
+      if (originalArrayIterator) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, originalArrayIterator);
+      }
+      if (originalNext) Object.defineProperty(iteratorPrototype, 'next', originalNext);
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(removals).toBe(2);
+    expect(closes).toBe(1);
+    port.close();
+    expect(closes).toBe(1);
+  });
+
+  it('posts through a wrapped port without dynamic transfer-array iteration', () => {
+    const raw = createPort();
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+    if (!port) throw new Error('Expected one port');
+    const transferred: unknown[] = [];
+    const originalIterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const poisoned = (): never => {
+      throw new Error('poisoned Array iterator');
+    };
+    try {
+      Object.defineProperty(Array.prototype, Symbol.iterator, {
+        value: poisoned,
+        configurable: true,
+      });
+      port.post(Object.freeze({ message: true }), transferred);
+    } finally {
+      if (originalIterator) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, originalIterator);
+      }
+    }
+
+    expect(raw.postMessage).toHaveBeenCalledWith({ message: true }, []);
+    port.close();
+  });
+
+  it('unwraps and commits exact channel endpoints transferred through a retained port', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const controlRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    const [control] = adapter.extractTransferredPorts({ ports: [controlRaw] }, 1) ?? [];
+    if (!channel || !control) throw new Error('Expected channel and control port');
+    const message = Object.freeze({ message: 'transfer' });
+
+    expect(control.post(message, [channel.transferred])).toBe(true);
+    expect(controlRaw.postMessage).toHaveBeenCalledWith(message, [transferredRaw]);
+    expect(control.post(message, [channel.transferred])).toBe(false);
+    channel.transferred.close();
+    expect(transferredRaw.close).not.toHaveBeenCalled();
+    channel.retained.close();
+    control.close();
+  });
+
+  it('rolls back exact channel transfer ownership when retained-port posting throws', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const controlRaw = createPort();
+    controlRaw.postMessage.mockImplementation(() => {
+      throw new Error('port post failed');
+    });
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    const [control] = adapter.extractTransferredPorts({ ports: [controlRaw] }, 1) ?? [];
+    if (!channel || !control) throw new Error('Expected channel and control port');
+
+    expect(control.post(Object.freeze({}), [channel.transferred])).toBe(false);
+    channel.transferred.close();
+    expect(transferredRaw.close).toHaveBeenCalledOnce();
+    channel.retained.close();
+    control.close();
+  });
+
+  it('uses captured close authority when later channel validation fails', () => {
+    let closeReads = 0;
+    let closes = 0;
+    const first = {
+      addEventListener(): void {},
+      get close(): () => void {
+        closeReads += 1;
+        if (closeReads > 1) throw new Error('close authority re-read');
+        return () => {
+          closes += 1;
+        };
+      },
+      postMessage(): void {},
+      removeEventListener(): void {},
+      start(): void {},
+    };
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = first;
+        readonly port2 = Object.freeze({ invalid: true });
+      },
+    });
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(closeReads).toBe(1);
+    expect(closes).toBe(1);
+  });
+
+  it('preserves captured close authority when later raw-port method inspection throws', () => {
+    const first = createPort();
+    let closeReads = 0;
+    let closes = 0;
+    const partial = {
+      addEventListener(): void {},
+      get close(): () => void {
+        closeReads += 1;
+        if (closeReads > 1) throw new Error('close authority re-read');
+        return () => {
+          closes += 1;
+        };
+      },
+      get postMessage(): never {
+        throw new Error('later port inspection failed');
+      },
+      removeEventListener(): void {},
+      start(): void {},
+    };
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = first;
+        readonly port2 = partial;
+      },
+    });
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(closeReads).toBe(1);
+    expect(closes).toBe(1);
+    expect(first.close).toHaveBeenCalledOnce();
+  });
+
+  it('captures the first endpoint close before a hostile second-endpoint getter runs', () => {
+    let closeReads = 0;
+    let poisonedCloseReads = 0;
+    let closes = 0;
+    const first = {
+      addEventListener(): void {},
+      get close(): () => void {
+        closeReads += 1;
+        if (closeReads > 1) throw new Error('first close authority re-read');
+        return () => {
+          closes += 1;
+        };
+      },
+      postMessage(): void {},
+      removeEventListener(): void {},
+      start(): void {},
+    };
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = first;
+
+        get port2(): never {
+          Object.defineProperty(first, 'close', {
+            configurable: true,
+            get: () => {
+              poisonedCloseReads += 1;
+              throw new Error('first close authority poisoned');
+            },
+          });
+          throw new Error('second endpoint unavailable');
+        }
+      },
+    });
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(closeReads).toBe(1);
+    expect(poisonedCloseReads).toBe(0);
+    expect(closes).toBe(1);
+  });
+
+  it('uses captured WeakMap authority for channel registration and facade lookup', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const originalGet = WeakMap.prototype.get;
+    const originalSet = WeakMap.prototype.set;
+    let dynamicGets = 0;
+    let dynamicSets = 0;
+    WeakMap.prototype.set = function <K extends WeakKey, V>(
+      this: WeakMap<K, V>,
+      key: K,
+      value: V
+    ): WeakMap<K, V> {
+      dynamicSets += 1;
+      Reflect.apply(originalSet, this, [key, value]);
+      throw new Error('registration intercepted');
+    };
+    WeakMap.prototype.get = function <K extends WeakKey, V>(this: WeakMap<K, V>, _key: K): V {
+      dynamicGets += 1;
+      return {
+        raw: { binding: transferredRaw },
+        transferable: true,
+        closed: false,
+        transferred: false,
+        transferring: false,
+      } as V;
+    };
+
+    let channel: ReturnType<typeof adapter.createChannel>;
+    let forgedResult: boolean | undefined;
+    let thrown: unknown;
+    let posts = 0;
+    try {
+      channel = adapter.createChannel();
+      forgedResult = adapter.postWindow(
+        { postMessage: () => (posts += 1) },
+        Object.freeze({}),
+        '*',
+        [Object.freeze({}) as never]
+      );
+    } catch (error) {
+      thrown = error;
+    } finally {
+      WeakMap.prototype.get = originalGet;
+      WeakMap.prototype.set = originalSet;
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(channel).toBeDefined();
+    expect(forgedResult).toBe(false);
+    expect(posts).toBe(0);
+    expect(dynamicGets).toBe(0);
+    expect(dynamicSets).toBe(0);
+    channel?.retained.close();
+    channel?.transferred.close();
+  });
+
+  it('rejects MessageChannel constructors that reuse an already-owned raw endpoint', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const first = adapter.createChannel();
+    if (!first) throw new Error('Expected one channel');
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(retainedRaw.close).not.toHaveBeenCalled();
+    expect(transferredRaw.close).not.toHaveBeenCalled();
+    first.retained.close();
+    first.transferred.close();
+    expect(retainedRaw.close).toHaveBeenCalledOnce();
+    expect(transferredRaw.close).toHaveBeenCalledOnce();
+  });
+
+  it('does not close a live owned endpoint when a later constructor returns it twice', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    let constructions = 0;
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1: unknown;
+        readonly port2: unknown;
+
+        constructor() {
+          constructions += 1;
+          this.port1 = retainedRaw;
+          this.port2 = constructions === 1 ? transferredRaw : retainedRaw;
+        }
+      },
+    });
+    const first = adapter.createChannel();
+    if (!first) throw new Error('Expected one channel');
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(retainedRaw.close).not.toHaveBeenCalled();
+    expect(transferredRaw.close).not.toHaveBeenCalled();
+    first.retained.close();
+    first.transferred.close();
+    expect(retainedRaw.close).toHaveBeenCalledOnce();
+    expect(transferredRaw.close).toHaveBeenCalledOnce();
+  });
+
+  it('keeps failed channel bindings retired throughout reentrant close cleanup', () => {
+    let constructions = 0;
+    let closes = 0;
+    let nestedCloses = 0;
+    let nestedResult: ReturnType<ReturnType<typeof createBrowserMessagingAdapter>['createChannel']>;
+    const retainedRaw = {
+      addEventListener(): void {},
+      close(): void {
+        closes += 1;
+        nestedResult = adapter.createChannel();
+      },
+      postMessage(): void {},
+      removeEventListener(): void {},
+      start(): void {},
+    };
+    const nestedRaw = {
+      addEventListener(): void {},
+      close(): void {
+        nestedCloses += 1;
+      },
+      postMessage(): void {},
+      removeEventListener(): void {},
+      start(): void {},
+    };
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1: unknown;
+        readonly port2: unknown;
+
+        constructor() {
+          constructions += 1;
+          this.port1 = retainedRaw;
+          this.port2 = constructions === 1 ? Object.freeze({ invalid: true }) : nestedRaw;
+        }
+      },
+    });
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(nestedResult).toBeUndefined();
+    expect(closes).toBe(1);
+    expect(nestedCloses).toBe(1);
+  });
+
+  it('rejects channel-owned raw endpoints at transferred-port extraction without closing them', () => {
+    const retainedRaw = createPort();
+    const transferredRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = retainedRaw;
+        readonly port2 = transferredRaw;
+      },
+    });
+    const channel = adapter.createChannel();
+    if (!channel) throw new Error('Expected one channel');
+
+    expect(adapter.extractTransferredPorts({ ports: [retainedRaw] }, 1)).toBeUndefined();
+    expect(adapter.extractTransferredPorts({ ports: [retainedRaw] }, 0)).toBeUndefined();
+    expect(retainedRaw.close).not.toHaveBeenCalled();
+    channel.retained.close();
+    channel.transferred.close();
+    expect(retainedRaw.close).toHaveBeenCalledOnce();
+    expect(transferredRaw.close).toHaveBeenCalledOnce();
+  });
+
+  it('rejects MessageChannel endpoints already owned by transferred-port extraction', () => {
+    const extractedRaw = createPort();
+    const newRaw = createPort();
+    const adapter = createBrowserMessagingAdapter({
+      ...createTarget(),
+      MessageChannel: class {
+        readonly port1 = extractedRaw;
+        readonly port2 = newRaw;
+      },
+    });
+    const [extracted] = adapter.extractTransferredPorts({ ports: [extractedRaw] }, 1) ?? [];
+    if (!extracted) throw new Error('Expected one extracted port');
+
+    expect(adapter.createChannel()).toBeUndefined();
+    expect(extractedRaw.close).not.toHaveBeenCalled();
+    expect(newRaw.close).toHaveBeenCalledOnce();
+    extracted.close();
+    expect(extractedRaw.close).toHaveBeenCalledOnce();
+  });
+
+  it('extracts and wraps transferred ports without dynamic Array operations or iteration', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const raw = createPort();
+    const originalPush = Object.getOwnPropertyDescriptor(Array.prototype, 'push');
+    const originalIterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const poisoned = (): never => {
+      throw new Error('poisoned Array operation');
+    };
+    let extracted: readonly unknown[] | undefined;
+    let thrown: unknown;
+    try {
+      Object.defineProperty(Array.prototype, 'push', { value: poisoned, configurable: true });
+      Object.defineProperty(Array.prototype, Symbol.iterator, {
+        value: poisoned,
+        configurable: true,
+      });
+      extracted = adapter.extractTransferredPorts({ ports: [raw] }, 1);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      if (originalPush) Object.defineProperty(Array.prototype, 'push', originalPush);
+      if (originalIterator) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, originalIterator);
+      }
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(extracted).toHaveLength(1);
+    const port = extracted?.[0] as { close?: () => void } | undefined;
+    port?.close?.();
+    expect(raw.close).toHaveBeenCalledOnce();
+  });
+
+  it('centralizes every protocol literal and exact message shape as frozen data', () => {
+    expect(TSJS_MESSAGE_PROTOCOL_V1).toEqual({
+      version: 1,
+      rendererVersion: '4',
+      message: {
+        prebidRequest: 'Prebid Request',
+        prebidResponse: 'Prebid Response',
+        ownerRegister: 'TS Render Owner Register',
+        ownerRegistered: 'TS Render Owner Registered',
+        ownerRefused: 'TS Render Owner Refused',
+        apsTopMountStarted: 'TS APS Top Mount Started',
+        admStart: 'TS ADM Start',
+        ownerInserted: 'TS Owner Inserted',
+        ownerSettled: 'TS Owner Settled',
+        admLoaded: 'TS ADM Loaded',
+        admFailed: 'TS ADM Failed',
+        apsBootstrapReady: 'TS APS Bootstrap Ready',
+        apsBootstrapConfigure: 'TS APS Bootstrap Configure',
+        apsInnerReady: 'TS APS Inner Ready',
+        apsInnerBind: 'TS APS Inner Bind',
+        apsContainerReady: 'TS APS Container Ready',
+        apsDocumentAccepted: 'TS APS Document Accepted',
+        apsRunnerLoaded: 'TS APS Runner Loaded',
+        apsRenderCompleted: 'TS APS Render Completed',
+        apsRenderFailed: 'TS APS Render Failed',
+      },
+      status: { ready: 'ready', refused: 'refused' },
+      kind: { aps: 'aps', adm: 'adm' },
+      outcome: { accepted: 'accepted', failed: 'failed', cancelled: 'cancelled' },
+      runnerFailure: {
+        descriptorInvalid: 'descriptor_invalid',
+        runnerNoLoad: 'runner_no_load',
+        runnerFailed: 'runner_failed',
+      },
+      cancellation: {
+        callerAborted: 'caller_aborted',
+        superseded: 'superseded',
+        navigationDisposed: 'navigation_disposed',
+      },
+    });
+    expect(Object.isFrozen(TSJS_MESSAGE_PROTOCOL_V1)).toBe(true);
+    expect(Object.isFrozen(TSJS_MESSAGE_PROTOCOL_V1.message)).toBe(true);
+    expect(Object.isFrozen(PROTOCOL_MESSAGE_SCHEMAS_V1)).toBe(true);
+    expect(Object.isFrozen(PROTOCOL_MESSAGE_SCHEMAS_V1.apsTopMountStarted.keys)).toBe(true);
+  });
+
+  it('parses global JSON and structured messages through exact descriptor-safe schemas', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    expect(
+      adapter.parseProtocolMessage(
+        'prebidRequest',
+        JSON.stringify({
+          message: 'Prebid Request',
+          adId: 'r1_1234567890123456789012',
+          adServerDomain: 'ads.example.com',
+        })
+      )
+    ).toEqual({
+      message: 'Prebid Request',
+      adId: 'r1_1234567890123456789012',
+      adServerDomain: 'ads.example.com',
+    });
+    expect(
+      adapter.parseProtocolMessage('ownerInserted', {
+        message: 'TS Owner Inserted',
+        version: 1,
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+      })
+    ).toEqual({
+      message: 'TS Owner Inserted',
+      version: 1,
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    });
+
+    for (const candidate of [
+      { message: 'TS Owner Inserted', version: 2, lifecycleTicket: 't1_abcdefghijklmnopqrstuv' },
+      {
+        message: 'TS Owner Inserted',
+        version: 1,
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+        extra: true,
+      },
+      { message: 'wrong', version: 1, lifecycleTicket: 't1_abcdefghijklmnopqrstuv' },
+      Object.assign(Object.create({ inherited: true }), {
+        message: 'TS Owner Inserted',
+        version: 1,
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+      }),
+    ]) {
+      expect(adapter.parseProtocolMessage('ownerInserted', candidate)).toBeUndefined();
+    }
+  });
+
+  it('parses the exact bounded bootstrap, inner, and container window channels', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const bootstrapNonce = `b1_${'b'.repeat(22)}`;
+    const rendererNonce = `n1_${'n'.repeat(22)}`;
+    const creativeOrigin = 'https://creative.example';
+    const messages = [
+      ['apsBootstrapReady', { message: 'TS APS Bootstrap Ready', version: 1, bootstrapNonce }],
+      [
+        'apsBootstrapConfigure',
+        {
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce,
+          rendererNonce,
+          creativeOrigin,
+          tagType: 'iframe',
+        },
+      ],
+      ['apsInnerReady', { message: 'TS APS Inner Ready', version: 1, rendererNonce }],
+      ['apsInnerBind', { message: 'TS APS Inner Bind', version: 1, rendererNonce }],
+      [
+        'apsContainerReady',
+        {
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce,
+          rendererNonce,
+        },
+      ],
+    ] as const;
+    for (const [kind, value] of messages) {
+      expect(adapter.parseProtocolMessage(kind, JSON.stringify(value))).toEqual(value);
+      expect(
+        adapter.parseProtocolMessage(kind, JSON.stringify({ ...value, extra: true }))
+      ).toBeUndefined();
+    }
+    expect(
+      adapter.parseProtocolMessage(
+        'apsBootstrapConfigure',
+        `{"message":"TS APS Bootstrap Configure","version":2,"bootstrapNonce":"${bootstrapNonce}","bootstrapNonce":"${bootstrapNonce}","rendererNonce":"${rendererNonce}","creativeOrigin":"${creativeOrigin}","tagType":"iframe"}`
+      )
+    ).toBeUndefined();
+    expect(
+      adapter.parseProtocolMessage(
+        'apsBootstrapConfigure',
+        JSON.stringify({
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce,
+          rendererNonce,
+          creativeOrigin: 'http://creative.example',
+          tagType: 'iframe',
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      adapter.parseProtocolMessage(
+        'apsBootstrapConfigure',
+        JSON.stringify({
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce,
+          rendererNonce,
+          creativeOrigin,
+          tagType: 'script',
+        })
+      )
+    ).toBeDefined();
+    expect(
+      adapter.parseProtocolMessage(
+        'apsBootstrapConfigure',
+        JSON.stringify({
+          message: 'TS APS Bootstrap Configure',
+          version: 2,
+          bootstrapNonce,
+          rendererNonce,
+          creativeOrigin,
+          tagType: 'image',
+        })
+      )
+    ).toBeUndefined();
+  });
+
+  it('inspects only own routing data before exact global-message parsing', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const json = JSON.stringify({
+      message: 'Prebid Request',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+      adServerDomain: 'ads.example.com',
+      ignored: { renderer: '<script>not routing data</script>' },
+    });
+    const object = Object.assign(Object.create(null), {
+      message: 'TS Render Owner Register',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+      ignored: true,
+    });
+
+    const inspectedJson = adapter.inspectGlobalMessage(json);
+    const inspectedObject = adapter.inspectGlobalMessage(object);
+
+    expect(inspectedJson).toEqual({
+      message: 'Prebid Request',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+    });
+    expect(inspectedObject).toEqual({
+      message: 'TS Render Owner Register',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    });
+    expect(Object.isFrozen(inspectedJson)).toBe(true);
+    expect(Object.isFrozen(inspectedObject)).toBe(true);
+  });
+
+  it('inspects global routing data without invoking accessors or inherited properties', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const getter = vi.fn(() => 'Prebid Request');
+    const accessor = Object.create(null) as Record<string, unknown>;
+    Object.defineProperty(accessor, 'message', { get: getter, enumerable: true });
+    Object.defineProperty(accessor, 'adId', {
+      value: 'r1_abcdefghijklmnopqrstuv',
+      enumerable: true,
+    });
+    const inherited = Object.assign(Object.create({ message: 'Prebid Request' }), {
+      adId: 'r1_abcdefghijklmnopqrstuv',
+    });
+    const throwingProxy = new Proxy(
+      {},
+      {
+        getPrototypeOf: () => {
+          throw new Error('prototype trap');
+        },
+      }
+    );
+
+    expect(adapter.inspectGlobalMessage(accessor)).toBeUndefined();
+    expect(adapter.inspectGlobalMessage(inherited)).toBeUndefined();
+    expect(adapter.inspectGlobalMessage(throwingProxy)).toBeUndefined();
+    expect(getter).not.toHaveBeenCalled();
+  });
+
+  it('rejects malformed, duplicate-key, and oversized routing JSON during inspection', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const duplicate = '{"message":"Prebid Request","adId":"first","adId":"second","ignored":true}';
+    const oversized = JSON.stringify({
+      message: 'Prebid Request',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+      ignored: 'é'.repeat(2_100),
+    });
+
+    expect(adapter.inspectGlobalMessage('{')).toBeUndefined();
+    expect(adapter.inspectGlobalMessage(duplicate)).toBeUndefined();
+    expect(adapter.inspectGlobalMessage(oversized)).toBeUndefined();
+    expect(adapter.inspectGlobalMessage({ adId: 'r1_abcdefghijklmnopqrstuv' })).toBeUndefined();
+  });
+
+  it('does not invoke accessors while rejecting an exact-shape candidate', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const getter = vi.fn(() => 'TS Owner Inserted');
+    const candidate = {
+      version: 1,
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    } as Record<string, unknown>;
+    Object.defineProperty(candidate, 'message', { get: getter, enumerable: true });
+
+    expect(adapter.parseProtocolMessage('ownerInserted', candidate)).toBeUndefined();
+    expect(getter).not.toHaveBeenCalled();
+  });
+
+  it('rejects oversized UTF-8 and duplicate-key global JSON before stateful parsing', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const oversized = JSON.stringify({
+      message: 'Prebid Request',
+      adId: 'r1_1234567890123456789012',
+      adServerDomain: 'é'.repeat(2_100),
+    });
+    const duplicate =
+      '{"message":"Prebid Request","adId":"first","adId":"second","adServerDomain":"ads.example.com"}';
+
+    expect(adapter.parseProtocolMessage('prebidRequest', oversized)).toBeUndefined();
+    expect(adapter.parseProtocolMessage('prebidRequest', duplicate)).toBeUndefined();
+    expect(
+      adapter.parseProtocolMessage('prebidRequest', { message: 'Prebid Request' })
+    ).toBeUndefined();
+  });
+
+  it.each(['before', 'after'] as const)(
+    'fails global JSON parsing closed when duplicate-key tracking throws %s insertion',
+    (failure) => {
+      const adapter = createBrowserMessagingAdapter(createTarget());
+      const originalSetAdd = Set.prototype.add;
+      Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+        if (failure === 'after') Reflect.apply(originalSetAdd, this, [value]);
+        throw new Error(`duplicate-key tracking failed ${failure} insertion`);
+      } as typeof Set.prototype.add;
+
+      let parsed: unknown;
+      let thrown: unknown;
+      try {
+        parsed = adapter.parseProtocolMessage(
+          'prebidRequest',
+          JSON.stringify({
+            message: 'Prebid Request',
+            adId: 'r1_1234567890123456789012',
+            adServerDomain: 'ads.example.com',
+          })
+        );
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.add = originalSetAdd;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(parsed).toBeUndefined();
+    }
+  );
+
+  it.each(['duplicate-key', 'reason'] as const)(
+    'fails protocol %s membership checks closed when Set.has throws',
+    (lookup) => {
+      const adapter = createBrowserMessagingAdapter(createTarget());
+      const candidate =
+        lookup === 'duplicate-key'
+          ? JSON.stringify({
+              message: 'Prebid Request',
+              adId: 'r1_1234567890123456789012',
+              adServerDomain: 'ads.example.com',
+            })
+          : {
+              message: 'TS Owner Settled',
+              version: 1,
+              lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+              outcome: 'failed',
+              reason: 'internal_error',
+            };
+      const originalSetHas = Set.prototype.has;
+      Set.prototype.has = function (): boolean {
+        throw new Error(`${lookup} membership failed`);
+      } as typeof Set.prototype.has;
+
+      let parsed: unknown;
+      let thrown: unknown;
+      try {
+        parsed = adapter.parseProtocolMessage(
+          lookup === 'duplicate-key' ? 'prebidRequest' : 'ownerSettledFailed',
+          candidate
+        );
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.has = originalSetHas;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(parsed).toBeUndefined();
+    }
+  );
+
+  it('validates capability forms, field types, nested records, enums, and UTF-8 limits', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const request = (adId: unknown, adServerDomain: unknown) =>
+      JSON.stringify({ message: 'Prebid Request', adId, adServerDomain });
+
+    expect(
+      adapter.parseProtocolMessage(
+        'prebidRequest',
+        request('r1_abcdefghijklmnopqrstuv', 'é'.repeat(1_024))
+      )
+    ).toBeDefined();
+    for (const candidate of [
+      request('r1_too-short', 'ads.example.com'),
+      request('a1_abcdefghijklmnopqrstuv', 'ads.example.com'),
+      request('r1_abcdefghijklmnopqrstuv', ''),
+      request('r1_abcdefghijklmnopqrstuv', 'é'.repeat(1_025)),
+      request('r1_abcdefghijklmnopqrstuv', 1),
+    ]) {
+      expect(adapter.parseProtocolMessage('prebidRequest', candidate)).toBeUndefined();
+    }
+
+    expect(
+      adapter.parseProtocolMessage('tsOwnerReady', {
+        version: 1,
+        status: 'ready',
+        kind: 'aps',
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+      })
+    ).toBeDefined();
+    expect(
+      adapter.parseProtocolMessage('tsOwnerReady', {
+        version: 1,
+        status: 'ready',
+        kind: 'cache',
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+      })
+    ).toBeUndefined();
+    expect(
+      adapter.parseProtocolMessage('ownerSettledCancelled', {
+        message: 'TS Owner Settled',
+        version: 1,
+        lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+        outcome: 'cancelled',
+        reason: 'external_ready_timeout',
+      })
+    ).toBeUndefined();
+  });
+
+  it('accepts only the exact data-free APS top-mount notification', () => {
+    const message = {
+      message: 'TS APS Top Mount Started',
+      version: 1,
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    };
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    expect(adapter.parseProtocolMessage('apsTopMountStarted', message)).toEqual(message);
+    expect(
+      adapter.parseProtocolMessage('apsTopMountStarted', {
+        ...message,
+        rendererUrl: 'https://publisher.example/integrations/aps/renderer/v2',
+      })
+    ).toBeUndefined();
+  });
+
+  it('canonicalizes an exact APS renderer before invoking the semantic validator', () => {
+    const renderer = createApsRenderer();
+    let canonical: unknown;
+    const validator = vi.fn((candidate: unknown) => {
+      canonical = candidate;
+      renderer.bidId = 'mutated-during-validation';
+      return true;
+    });
+    const adapter = createBrowserMessagingAdapter(createTarget(), {
+      expectedPublisherOrigin: 'https://publisher.example',
+      expectedRendererUrl: 'https://publisher.example/integrations/aps/renderer/v2',
+      validateApsRenderer: validator,
+    });
+    const parsed = adapter.parseProtocolMessage('apsEnvelope', {
+      version: 1,
+      nonce: 'n1_abcdefghijklmnopqrstuv',
+      publisherOrigin: 'https://publisher.example',
+      renderer,
+    });
+
+    expect(validator).toHaveBeenCalledTimes(1);
+    expect(canonical).not.toBe(renderer);
+    expect(Object.getPrototypeOf(canonical)).toBeNull();
+    expect(Object.isFrozen(canonical)).toBe(true);
+    expect((canonical as Record<string, unknown>)['bidId']).toBe('bid-1');
+    expect(parsed?.['renderer']).toBe(canonical);
+  });
+
+  it('rejects APS renderer accessors, proxies, and unknown keys before validation', () => {
+    const validator = vi.fn(() => true);
+    const adapter = createBrowserMessagingAdapter(createTarget(), {
+      expectedPublisherOrigin: 'https://publisher.example',
+      expectedRendererUrl: 'https://publisher.example/integrations/aps/renderer/v2',
+      validateApsRenderer: validator,
+    });
+    const parse = (renderer: unknown) =>
+      adapter.parseProtocolMessage('apsEnvelope', {
+        version: 1,
+        nonce: 'n1_abcdefghijklmnopqrstuv',
+        publisherOrigin: 'https://publisher.example',
+        renderer,
+      });
+    const accessor = createApsRenderer();
+    const getter = vi.fn(() => 'bid-from-getter');
+    Object.defineProperty(accessor, 'bidId', { get: getter, enumerable: true });
+    const proxy = new Proxy(createApsRenderer(), {
+      ownKeys: () => {
+        throw new Error('hostile renderer proxy');
+      },
+    });
+
+    expect(parse(accessor)).toBeUndefined();
+    expect(getter).not.toHaveBeenCalled();
+    expect(() => parse(proxy)).not.toThrow();
+    expect(parse(proxy)).toBeUndefined();
+    expect(parse({ ...createApsRenderer(), unknown: true })).toBeUndefined();
+    expect(validator).not.toHaveBeenCalled();
+  });
+
+  it('returns canonical frozen nested records without invoking prototype serialization hooks', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const owner = {
+      version: 1,
+      status: 'ready',
+      kind: 'aps',
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    };
+    const toJSON = vi.fn(() => {
+      throw new Error('prototype hook called');
+    });
+    Object.defineProperty(Object.prototype, 'toJSON', { value: toJSON, configurable: true });
+    try {
+      const parsed = adapter.parseProtocolMessage('prebidResponse', {
+        message: 'Prebid Response',
+        adId: 'r1_abcdefghijklmnopqrstuv',
+        renderer: 'renderer program',
+        rendererVersion: '4',
+        tsOwner: owner,
+      });
+      expect(parsed).toBeDefined();
+      expect(parsed?.['tsOwner']).not.toBe(owner);
+      expect(Object.isFrozen(parsed?.['tsOwner'])).toBe(true);
+      owner.kind = 'adm';
+      expect(parsed?.['tsOwner']).toMatchObject({ kind: 'aps' });
+      expect(toJSON).not.toHaveBeenCalled();
+    } finally {
+      delete (Object.prototype as { toJSON?: unknown }).toJSON;
+    }
+  });
+
+  it('parses the renderer-free refused Prebid response as its own exact shape', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const refused = {
+      message: 'Prebid Response',
+      adId: 'r1_abcdefghijklmnopqrstuv',
+      rendererVersion: '4',
+      tsOwner: { version: 1, status: 'refused' },
+    };
+    expect(adapter.parseProtocolMessage('prebidResponseRefused', refused)).toBeDefined();
+    expect(
+      adapter.parseProtocolMessage('prebidResponseRefused', {
+        ...refused,
+        renderer: 'must not be present',
+      })
+    ).toBeUndefined();
+    expect(
+      adapter.parseProtocolMessage('prebidResponseRefused', {
+        ...refused,
+        tsOwner: {
+          version: 1,
+          status: 'ready',
+          kind: 'aps',
+          lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+        },
+      })
+    ).toBeUndefined();
+  });
+
+  it('returns undefined for an unknown runtime schema kind', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    expect(() =>
+      adapter.parseProtocolMessage('unknown' as keyof typeof PROTOCOL_MESSAGE_SCHEMAS_V1, {})
+    ).not.toThrow();
+    expect(
+      adapter.parseProtocolMessage('unknown' as keyof typeof PROTOCOL_MESSAGE_SCHEMAS_V1, {})
+    ).toBeUndefined();
+  });
+
+  it('extracts exactly zero, one, or two transferred ports into frozen narrow facades', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const single = createPort();
+    const pairFirst = createPort();
+    const pairSecond = createPort();
+
+    const zero = adapter.extractTransferredPorts({ ports: [] }, 0);
+    const one = adapter.extractTransferredPorts({ ports: [single] }, 1);
+    const two = adapter.extractTransferredPorts({ ports: [pairFirst, pairSecond] }, 2);
+
+    expect(zero).toEqual([]);
+    expect(one).toHaveLength(1);
+    expect(two).toHaveLength(2);
+    expect(Object.isFrozen(zero)).toBe(true);
+    expect(Object.isFrozen(one?.[0])).toBe(true);
+    expect(one?.[0]).not.toHaveProperty('postMessage');
+  });
+
+  it('inspects every available refusal port without treating malformed counts as exact', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const first = createPort();
+    const second = createPort();
+    const third = createPort();
+    const malformed = { close: vi.fn() };
+    const laterUsable = createPort();
+
+    const overflow = adapter.inspectTransferredPorts({ ports: [first, second, third] });
+    expect(overflow).toMatchObject({ exactShape: true, originalCount: 3 });
+    expect(overflow?.ports).toHaveLength(3);
+    expect(Object.isFrozen(overflow)).toBe(true);
+    expect(Object.isFrozen(overflow?.ports)).toBe(true);
+    overflow?.ports.forEach((port) => port.close());
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(second.close).toHaveBeenCalledOnce();
+    expect(third.close).toHaveBeenCalledOnce();
+
+    const mixed = adapter.inspectTransferredPorts({ ports: [malformed, laterUsable] });
+    expect(mixed).toMatchObject({ exactShape: true, originalCount: 2 });
+    expect(mixed?.ports).toHaveLength(1);
+    expect(malformed.close).toHaveBeenCalledOnce();
+    mixed?.ports[0]?.close();
+    expect(laterUsable.close).toHaveBeenCalledOnce();
+  });
+
+  it('closes every transferred port on count mismatch and contains hostile closure', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const first = createPort();
+    const second = createPort();
+    const partial = { close: vi.fn() };
+    second.close.mockImplementation(() => {
+      throw new Error('close failed');
+    });
+
+    expect(() => adapter.extractTransferredPorts({ ports: [first, second] }, 1)).not.toThrow();
+    expect(first.close).toHaveBeenCalledTimes(1);
+    expect(second.close).toHaveBeenCalledTimes(1);
+    expect(() => adapter.extractTransferredPorts({ ports: [partial] }, 0)).not.toThrow();
+    expect(partial.close).toHaveBeenCalledTimes(1);
+    expect(
+      adapter.extractTransferredPorts(
+        {
+          get ports() {
+            throw new Error('hostile');
+          },
+        },
+        0
+      )
+    ).toBeUndefined();
+  });
+
+  it('snapshots hostile transferred-port arrays without accessors, iterators, or duplicate closes', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const first = createPort();
+    const hidden = createPort();
+    const getter = vi.fn(() => hidden);
+    const hostile = [first] as unknown[];
+    Object.defineProperty(hostile, '1', { get: getter, enumerable: true });
+    Object.defineProperty(hostile, Symbol.iterator, {
+      get: () => {
+        throw new Error('iterator read');
+      },
+    });
+
+    expect(() => adapter.extractTransferredPorts({ ports: hostile }, 2)).not.toThrow();
+    expect(first.close).toHaveBeenCalledTimes(1);
+    expect(getter).not.toHaveBeenCalled();
+
+    const duplicate = createPort();
+    expect(adapter.extractTransferredPorts({ ports: [duplicate, duplicate] }, 1)).toBeUndefined();
+    expect(duplicate.close).toHaveBeenCalledTimes(1);
+
+    const duplicatePair = createPort();
+    expect(
+      adapter.extractTransferredPorts({ ports: [duplicatePair, duplicatePair] }, 2)
+    ).toBeUndefined();
+    expect(duplicatePair.close).toHaveBeenCalledTimes(1);
+
+    const mismatchFirst = createPort();
+    const mismatchSecond = createPort();
+    expect(
+      adapter.extractTransferredPorts({ ports: [mismatchFirst, mismatchSecond, mismatchSecond] }, 0)
+    ).toBeUndefined();
+    expect(mismatchFirst.close).toHaveBeenCalledTimes(1);
+    expect(mismatchSecond.close).toHaveBeenCalledTimes(1);
+  });
+
+  it('bounds sparse hostile array inspection by present own keys rather than declared length', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const raw = createPort();
+    const sparse = [raw];
+    sparse.length = 0xffff_ffff;
+    let descriptorReads = 0;
+    const hostile = new Proxy(sparse, {
+      getOwnPropertyDescriptor(target, key) {
+        descriptorReads += 1;
+        if (descriptorReads > 8) throw new Error('unbounded descriptor scan');
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+    });
+
+    expect(adapter.extractTransferredPorts({ ports: hostile }, 1)).toBeUndefined();
+    expect(descriptorReads).toBeLessThanOrEqual(3);
+    expect(raw.close).toHaveBeenCalledOnce();
+  });
+
+  it('contains port listener throws and disposes listeners and ports exactly once', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const raw = createPort();
+    const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+    if (!port) throw new Error('Expected one port');
+    const listener = vi.fn(() => {
+      throw new Error('listener failed');
+    });
+    const messageErrorListener = vi.fn(() => {
+      throw new Error('messageerror listener failed');
+    });
+    const unsubscribe = port.listen(listener, messageErrorListener);
+    const installed = [...raw.listeners][0];
+    const installedMessageError = [...raw.messageErrorListeners][0];
+
+    expect(() => installed?.({ data: { message: 'event' } })).not.toThrow();
+    expect(() => installedMessageError?.({ data: 'uncloneable' })).not.toThrow();
+    port.post({ message: 'response' }, []);
+    unsubscribe();
+    unsubscribe();
+    port.close();
+    port.close();
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(messageErrorListener).toHaveBeenCalledTimes(1);
+    expect(raw.postMessage).toHaveBeenCalledWith({ message: 'response' }, []);
+    expect(raw.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(raw.removeEventListener).toHaveBeenCalledWith('message', installed);
+    expect(raw.removeEventListener).toHaveBeenCalledWith('messageerror', installedMessageError);
+    expect(raw.close).toHaveBeenCalledTimes(1);
+  });
+
+  it('rolls back every attempted port listener when message, messageerror, or start fails', () => {
+    for (const failure of ['message', 'messageerror', 'start'] as const) {
+      const adapter = createBrowserMessagingAdapter(createTarget());
+      const raw = createPort();
+      raw.addEventListener.mockImplementation((type, listener) => {
+        (type === 'messageerror' ? raw.messageErrorListeners : raw.listeners).add(listener);
+        if (failure === type) {
+          throw new Error(`${type} add failed`);
+        }
+      });
+      if (failure === 'start') {
+        raw.start.mockImplementation(() => {
+          throw new Error('start failed');
+        });
+      }
+      const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+      if (!port) throw new Error('Expected one port');
+
+      let dispose = (): void => undefined;
+      expect(() => {
+        dispose = port.listen(vi.fn(), vi.fn());
+      }).not.toThrow();
+      expect(() => dispose()).not.toThrow();
+      expect(raw.listeners.size).toBe(0);
+      expect(raw.messageErrorListeners.size).toBe(0);
+      expect(raw.removeEventListener).toHaveBeenCalledWith('message', expect.any(Function));
+      if (failure !== 'message') {
+        expect(raw.removeEventListener).toHaveBeenCalledWith('messageerror', expect.any(Function));
+      }
+      expect(raw.removeEventListener).toHaveBeenCalledTimes(failure === 'message' ? 1 : 2);
+    }
+  });
+
+  it.each(['before', 'after'] as const)(
+    'rolls back port listener ownership when its registry throws %s insertion',
+    (failure) => {
+      const adapter = createBrowserMessagingAdapter(createTarget());
+      const raw = createPort();
+      const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+      if (!port) throw new Error('Expected one port');
+      const messageListener = vi.fn();
+      const messageErrorListener = vi.fn();
+      const originalSetAdd = Set.prototype.add;
+      const originalSetDelete = Set.prototype.delete;
+      Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+        if (failure === 'after') Reflect.apply(originalSetAdd, this, [value]);
+        throw new Error(`listener registry failed ${failure} insertion`);
+      } as typeof Set.prototype.add;
+      Set.prototype.delete = function (): boolean {
+        throw new Error('listener publication rollback delete failed');
+      } as typeof Set.prototype.delete;
+
+      let dispose: (() => void) | undefined;
+      let thrown: unknown;
+      try {
+        dispose = port.listen(messageListener, messageErrorListener);
+      } catch (error) {
+        thrown = error;
+      } finally {
+        Set.prototype.add = originalSetAdd;
+        Set.prototype.delete = originalSetDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      expect(raw.listeners.size).toBe(0);
+      expect(raw.messageErrorListeners.size).toBe(0);
+      expect(() => dispose?.()).not.toThrow();
+      port.close();
+      expect(raw.removeEventListener).not.toHaveBeenCalled();
+      expect(raw.close).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it('removes port listeners when Set.delete is poisoned during unsubscribe and close', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const firstRaw = createPort();
+    const secondRaw = createPort();
+    const originalSetDelete = Set.prototype.delete;
+    for (const raw of [firstRaw, secondRaw]) {
+      raw.removeEventListener.mockImplementation((type, listener) => {
+        const registered = type === 'messageerror' ? raw.messageErrorListeners : raw.listeners;
+        Reflect.apply(originalSetDelete, registered, [listener]);
+      });
+    }
+    const [first] = adapter.extractTransferredPorts({ ports: [firstRaw] }, 1) ?? [];
+    const [second] = adapter.extractTransferredPorts({ ports: [secondRaw] }, 1) ?? [];
+    if (!first || !second) throw new Error('Expected two ports');
+    const unsubscribe = first.listen(vi.fn(), vi.fn());
+    second.listen(vi.fn(), vi.fn());
+
+    Set.prototype.delete = function (): boolean {
+      throw new Error('port listener registry delete failed');
+    } as typeof Set.prototype.delete;
+    try {
+      expect(() => unsubscribe()).not.toThrow();
+      expect(() => unsubscribe()).not.toThrow();
+      expect(() => second.close()).not.toThrow();
+      expect(() => second.close()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    expect(firstRaw.listeners.size).toBe(0);
+    expect(firstRaw.messageErrorListeners.size).toBe(0);
+    expect(secondRaw.listeners.size).toBe(0);
+    expect(secondRaw.messageErrorListeners.size).toBe(0);
+    expect(firstRaw.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(secondRaw.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(secondRaw.close).toHaveBeenCalledTimes(1);
+    first.close();
+  });
+
+  it('rolls back both port listeners when setup and Set.delete fail together', () => {
+    const adapter = createBrowserMessagingAdapter(createTarget());
+    const raw = createPort();
+    const originalSetDelete = Set.prototype.delete;
+    raw.removeEventListener.mockImplementation((type, listener) => {
+      const registered = type === 'messageerror' ? raw.messageErrorListeners : raw.listeners;
+      Reflect.apply(originalSetDelete, registered, [listener]);
+    });
+    raw.addEventListener.mockImplementation((type, listener) => {
+      (type === 'messageerror' ? raw.messageErrorListeners : raw.listeners).add(listener);
+      if (type === 'messageerror') throw new Error('messageerror setup failed');
+    });
+    const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+    if (!port) throw new Error('Expected one port');
+    Set.prototype.delete = function (): boolean {
+      throw new Error('setup rollback registry delete failed');
+    } as typeof Set.prototype.delete;
+
+    let unsubscribe: (() => void) | undefined;
+    try {
+      expect(() => {
+        unsubscribe = port.listen(vi.fn(), vi.fn());
+      }).not.toThrow();
+      expect(() => unsubscribe?.()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    expect(raw.listeners.size).toBe(0);
+    expect(raw.messageErrorListeners.size).toBe(0);
+    expect(raw.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(() => port.close()).not.toThrow();
+    expect(raw.close).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(['message', 'messageerror', 'start'] as const)(
+    'lets reentrant close win during %s port setup',
+    (closeDuring) => {
+      const adapter = createBrowserMessagingAdapter(createTarget());
+      const raw = createPort();
+      const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+      if (!port) throw new Error('Expected one port');
+      raw.addEventListener.mockImplementation((type, listener) => {
+        (type === 'messageerror' ? raw.messageErrorListeners : raw.listeners).add(listener);
+        if (type === closeDuring) port.close();
+      });
+      raw.start.mockImplementation(() => {
+        if (closeDuring === 'start') port.close();
+      });
+
+      const dispose = port.listen(vi.fn(), vi.fn());
+      const removals = closeDuring === 'message' ? 1 : 2;
+
+      expect(raw.listeners.size).toBe(0);
+      expect(raw.messageErrorListeners.size).toBe(0);
+      expect(raw.removeEventListener).toHaveBeenCalledTimes(removals);
+      expect(raw.removeEventListener).toHaveBeenCalledWith('message', expect.any(Function));
+      if (closeDuring !== 'message') {
+        expect(raw.removeEventListener).toHaveBeenCalledWith('messageerror', expect.any(Function));
+      }
+      if (closeDuring === 'start') expect(raw.start).toHaveBeenCalledTimes(1);
+      else expect(raw.start).not.toHaveBeenCalled();
+      expect(raw.close).toHaveBeenCalledTimes(1);
+
+      dispose();
+      dispose();
+      port.close();
+      expect(raw.removeEventListener).toHaveBeenCalledTimes(removals);
+      expect(raw.close).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  it('contains hostile capture-target and captured port method throws', () => {
+    const installed: Array<(event: MessageEvent) => void> = [];
+    const target = {
+      addEventListener: vi.fn((_type: 'message', listener: (event: MessageEvent) => void) => {
+        installed.push(listener);
+      }),
+      removeEventListener: vi.fn(() => {
+        throw new Error('remove failed');
+      }),
+    };
+    const adapter = createBrowserMessagingAdapter(target);
+    const dispose = adapter.installCaptureListener(() => {
+      throw new Error('capture failed');
+    });
+    expect(dispose).toBeTypeOf('function');
+    expect(() => installed[0]?.({} as MessageEvent)).not.toThrow();
+    expect(() => dispose?.()).not.toThrow();
+
+    const raw = createPort();
+    raw.postMessage.mockImplementation(() => {
+      throw new Error('post failed');
+    });
+    raw.start.mockImplementation(() => {
+      throw new Error('start failed');
+    });
+    raw.removeEventListener.mockImplementation(() => {
+      throw new Error('port remove failed');
+    });
+    const [port] = adapter.extractTransferredPorts({ ports: [raw] }, 1) ?? [];
+    if (!port) throw new Error('Expected one port');
+    expect(() => port.post({}, [])).not.toThrow();
+    let unsubscribe = (): void => undefined;
+    expect(() => {
+      unsubscribe = port.listen(vi.fn(), vi.fn());
+    }).not.toThrow();
+    expect(() => unsubscribe()).not.toThrow();
+
+    const throwingTarget = createBrowserMessagingAdapter({
+      addEventListener: () => {
+        throw new Error('add failed');
+      },
+      removeEventListener: vi.fn(),
+    });
+    expect(throwingTarget.installCaptureListener(vi.fn())).toBeUndefined();
+  });
+
+  it('rolls back the exact capture listener when installation throws after adding it', () => {
+    const listeners = new Set<(event: MessageEvent) => void>();
+    const removeEventListener = vi.fn(
+      (_type: 'message', listener: (event: MessageEvent) => void, _capture: true) => {
+        listeners.delete(listener);
+      }
+    );
+    const target = {
+      addEventListener: vi.fn(
+        (_type: 'message', listener: (event: MessageEvent) => void, _capture: true) => {
+          listeners.add(listener);
+          throw new Error('add failed after installation');
+        }
+      ),
+      removeEventListener,
+    };
+    const dispose = createBrowserMessagingAdapter(target).installCaptureListener(vi.fn());
+    const installed = target.addEventListener.mock.calls[0]?.[1];
+
+    expect(listeners.size).toBe(0);
+    expect(removeEventListener).toHaveBeenCalledTimes(1);
+    expect(removeEventListener).toHaveBeenCalledWith('message', installed, true);
+    expect(dispose).toBeUndefined();
+    expect(removeEventListener).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/adapters/prebid.test.ts b/crates/trusted-server-js/lib/test/adapters/prebid.test.ts
new file mode 100644
index 000000000..ee185f582
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/adapters/prebid.test.ts
@@ -0,0 +1,1826 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createBrowserPrebidAdapter, type PrebidEventFacade } from '../../src/adapters/prebid';
+
+type Command = () => void;
+
+function wrapBids(bids: object[] = []): object[] & { bids: object[] } {
+  const response = [...bids] as object[] & { bids: object[] };
+  response.bids = response;
+  return response;
+}
+
+function recursivelyFreeze<T>(value: T): T {
+  if (value && typeof value === 'object') {
+    for (const child of Object.values(value)) recursivelyFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+function createStamp(overrides: Record<string, unknown> = {}) {
+  return recursivelyFreeze({
+    abi: 1,
+    artifactReleaseId: 'a'.repeat(64),
+    prebidVersion: '10.26.0',
+    moduleStems: ['alphaBidAdapter', 'sharedIdSystem'],
+    bidderCodes: ['alpha', 'alphaAlias'],
+    bidderAliases: [{ code: 'alphaAlias', moduleStem: 'alphaBidAdapter' }],
+    userIdModules: [
+      {
+        moduleName: 'sharedIdSystem',
+        configNames: ['sharedId'],
+        eidSources: ['sharedid.org'],
+      },
+    ],
+    ...overrides,
+  });
+}
+
+function createReadyPrebid(
+  options: {
+    readonly deferCommands?: boolean;
+    readonly stamp?: object;
+  } = {}
+) {
+  const commands: Command[] = [];
+  const listeners = new Map<string, Set<(event: unknown) => void>>();
+  const pbjs = {
+    addAdUnits: vi.fn(),
+    getBidResponsesForAdUnitCode: vi.fn<() => object[] & { bids: object[] }>(() => wrapBids()),
+    getHighestCpmBids: vi.fn<() => object[]>(() => []),
+    offEvent: vi.fn((type: string, listener: (event: unknown) => void) => {
+      listeners.get(type)?.delete(listener);
+    }),
+    onEvent: vi.fn((type: string, listener: (event: unknown) => void) => {
+      const registered = listeners.get(type) ?? new Set();
+      registered.add(listener);
+      listeners.set(type, registered);
+    }),
+    processQueue: vi.fn(),
+    registerBidAdapter: vi.fn(),
+    que: {
+      push: vi.fn((command: Command): number => {
+        if (options.deferCommands) commands.push(command);
+        else command();
+        return commands.length;
+      }),
+    },
+    renderAd: vi.fn(),
+    requestBids: vi.fn(),
+    setTargetingForGPTAsync: vi.fn(),
+  };
+  const stamp = options.stamp ?? createStamp();
+  Object.defineProperty(pbjs, '__trustedServerArtifactV1', {
+    value: stamp,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  });
+  return { commands, listeners, pbjs, stamp };
+}
+
+describe('browser Prebid adapter readiness', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('binds an exact valid artifact and exposes a frozen narrow facade', async () => {
+    const ready = createReadyPrebid();
+    const target: { pbjs: unknown } = { pbjs: ready.pbjs };
+    const adapter = createBrowserPrebidAdapter(target);
+    const operation = adapter.run((prebid) => {
+      expect(Object.isFrozen(prebid)).toBe(true);
+      expect('que' in prebid).toBe(false);
+      expect('__trustedServerArtifactV1' in prebid).toBe(false);
+      prebid.addAdUnits([{ code: 'slot-a' }]);
+      prebid.registerBidAdapter(undefined, 'trustedServer', { code: 'trustedServer' });
+      prebid.requestBids({ adUnitCodes: ['slot-a'] });
+      prebid.setTargetingForGpt(['slot-a']);
+      prebid.renderAd({}, 'bid-a');
+      return prebid.highestBids('slot-a');
+    });
+
+    expect(operation.status).toBe('present');
+    await expect(operation.result).resolves.toEqual([]);
+    expect(ready.pbjs.addAdUnits).toHaveBeenCalledTimes(1);
+    expect(ready.pbjs.registerBidAdapter).toHaveBeenCalledWith(undefined, 'trustedServer', {
+      code: 'trustedServer',
+    });
+    expect(ready.pbjs.requestBids).toHaveBeenCalledTimes(1);
+    expect(ready.pbjs.setTargetingForGPTAsync).toHaveBeenCalledExactlyOnceWith(['slot-a']);
+    expect(ready.pbjs.renderAd).toHaveBeenCalledWith({}, 'bid-a');
+  });
+
+  it('drains pending commands FIFO through the real Prebid queue notification', async () => {
+    const readinessCommands: Command[] = [];
+    const target: { pbjs?: unknown } = { pbjs: { que: readinessCommands } };
+    const adapter = createBrowserPrebidAdapter(target);
+    const order: number[] = [];
+    const first = adapter.run(() => order.push(1));
+    const second = adapter.run(() => order.push(2));
+
+    expect(first.status).toBe('pending');
+    expect(second.status).toBe('pending');
+    expect(readinessCommands).toHaveLength(1);
+
+    target.pbjs = createReadyPrebid().pbjs;
+    readinessCommands[0]?.();
+
+    await expect(Promise.all([first.result, second.result])).resolves.toEqual([1, 2]);
+    expect(order).toEqual([1, 2]);
+  });
+
+  it.each(['before', 'after'] as const)(
+    'recovers Prebid notification arming when WeakSet.add throws %s insertion',
+    async (failure) => {
+      const readinessCommands: Command[] = [];
+      const target: { pbjs?: unknown } = { pbjs: { que: readinessCommands } };
+      const adapter = createBrowserPrebidAdapter(target);
+      const originalWeakSetAdd = WeakSet.prototype.add;
+      WeakSet.prototype.add = function (this: WeakSet<object>, value: object): WeakSet<object> {
+        if (failure === 'after') Reflect.apply(originalWeakSetAdd, this, [value]);
+        throw new Error(`Prebid arming failed ${failure} insertion`);
+      } as typeof WeakSet.prototype.add;
+
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        operation = adapter.run(() => 'ready');
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakSet.prototype.add = originalWeakSetAdd;
+      }
+
+      expect(thrown).toBeUndefined();
+      if (!operation) throw new Error('Expected a published Prebid operation');
+      expect(readinessCommands).toHaveLength(0);
+      adapter.notifyReady();
+      expect(readinessCommands).toHaveLength(1);
+      target.pbjs = createReadyPrebid().pbjs;
+      readinessCommands[0]?.();
+      await expect(operation.result).resolves.toBe('ready');
+      adapter.dispose();
+    }
+  );
+
+  it('recovers Prebid notification arming when WeakSet.has throws after publication', async () => {
+    vi.useFakeTimers();
+    const readinessCommands: Command[] = [];
+    const target: { pbjs?: unknown } = { pbjs: { que: readinessCommands } };
+    const adapter = createBrowserPrebidAdapter(target);
+    const order: number[] = [];
+    const originalWeakSetHas = WeakSet.prototype.has;
+    WeakSet.prototype.has = function (): boolean {
+      throw new Error('Prebid armed lookup failed');
+    } as typeof WeakSet.prototype.has;
+
+    let first: ReturnType<typeof adapter.run> | undefined;
+    let thrown: unknown;
+    try {
+      first = adapter.run(() => order.push(1));
+    } catch (error) {
+      thrown = error;
+    } finally {
+      WeakSet.prototype.has = originalWeakSetHas;
+    }
+
+    expect(thrown).toBeUndefined();
+    if (!first) throw new Error('Expected a published Prebid operation');
+    expect(readinessCommands).toHaveLength(1);
+    const second = adapter.run(() => order.push(2));
+    expect(readinessCommands).toHaveLength(1);
+    target.pbjs = createReadyPrebid().pbjs;
+    readinessCommands[0]?.();
+    await expect(Promise.all([first.result, second.result])).resolves.toEqual([1, 2]);
+    expect(order).toEqual([1, 2]);
+    expect(vi.getTimerCount()).toBe(0);
+
+    target.pbjs = undefined;
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    for (const operation of recovered) operation.dispose();
+    await Promise.all(recoveredResults);
+    expect(vi.getTimerCount()).toBe(0);
+    adapter.dispose();
+  });
+
+  it.each([
+    { pushFailure: 'before', deleteFailure: 'throw' },
+    { pushFailure: 'after', deleteFailure: 'retain' },
+  ] as const)(
+    'retries Prebid notification registration after $pushFailure enqueue failure and $deleteFailure rollback',
+    async ({ pushFailure, deleteFailure }) => {
+      vi.useFakeTimers();
+      const readinessCommands: Command[] = [];
+      let queueBroken = true;
+      const push = vi.fn((command: Command): number => {
+        if (queueBroken) {
+          if (pushFailure === 'after') readinessCommands.push(command);
+          throw new Error(`Prebid queue failed ${pushFailure} enqueue`);
+        }
+        readinessCommands.push(command);
+        return readinessCommands.length;
+      });
+      const target: { pbjs?: unknown } = { pbjs: { que: { push } } };
+      const adapter = createBrowserPrebidAdapter(target);
+      const order: number[] = [];
+      const originalWeakSetDelete = WeakSet.prototype.delete;
+      WeakSet.prototype.delete = function (): boolean {
+        if (deleteFailure === 'throw') throw new Error('Prebid arming rollback failed');
+        return false;
+      } as typeof WeakSet.prototype.delete;
+
+      let first: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        first = adapter.run(() => order.push(1));
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakSet.prototype.delete = originalWeakSetDelete;
+      }
+
+      expect(thrown).toBeUndefined();
+      if (!first) throw new Error('Expected a published Prebid operation');
+      expect(readinessCommands).toHaveLength(pushFailure === 'after' ? 1 : 0);
+      queueBroken = false;
+      const second = adapter.run(() => order.push(2));
+      expect(readinessCommands).toHaveLength(pushFailure === 'after' ? 2 : 1);
+
+      target.pbjs = createReadyPrebid().pbjs;
+      if (pushFailure === 'after') {
+        readinessCommands[0]?.();
+        expect(order).toEqual([]);
+      }
+      readinessCommands[readinessCommands.length - 1]?.();
+      await expect(Promise.all([first.result, second.result])).resolves.toEqual([1, 2]);
+      expect(order).toEqual([1, 2]);
+      for (const notify of readinessCommands) notify();
+      expect(order).toEqual([1, 2]);
+      expect(vi.getTimerCount()).toBe(0);
+
+      target.pbjs = undefined;
+      const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+      const recoveredResults = recovered.map(({ result }) => result.catch((error) => error));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      for (const operation of recovered) operation.dispose();
+      await Promise.all(recoveredResults);
+      expect(vi.getTimerCount()).toBe(0);
+      adapter.dispose();
+    }
+  );
+
+  it('rejects a queued operation when its pending Prebid stub becomes incompatible', async () => {
+    const readinessCommands: Command[] = [];
+    const binding: Record<string, unknown> = { que: readinessCommands };
+    const adapter = createBrowserPrebidAdapter({ pbjs: binding });
+    const command = vi.fn();
+    const operation = adapter.run(command);
+    Object.defineProperty(binding, '__trustedServerArtifactV1', {
+      value: Object.freeze({}),
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+
+    readinessCommands[0]?.();
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(operation.status).toBe('incompatible');
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('ignores a stale Prebid notification and lets the replacement notification decide', async () => {
+    const oldNotifications: Command[] = [];
+    const replacementNotifications: Command[] = [];
+    const oldBinding = { que: oldNotifications };
+    const replacement: Record<string, unknown> = { que: replacementNotifications };
+    const target: { pbjs?: unknown } = { pbjs: oldBinding };
+    const adapter = createBrowserPrebidAdapter(target);
+    const first = adapter.run(() => 'first');
+    target.pbjs = replacement;
+    const second = adapter.run(() => 'second');
+    Object.defineProperty(replacement, '__trustedServerArtifactV1', {
+      value: Object.freeze({}),
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+
+    oldNotifications[0]?.();
+    expect(first.status).toBe('pending');
+    expect(second.status).toBe('pending');
+
+    replacementNotifications[0]?.();
+    await expect(first.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    await expect(second.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+  });
+
+  it('does not let a stale Prebid notification condemn a primitive replacement', async () => {
+    const oldNotifications: Command[] = [];
+    const target: { pbjs?: unknown } = { pbjs: { que: oldNotifications } };
+    const adapter = createBrowserPrebidAdapter(target);
+    const operation = adapter.run(vi.fn());
+    const result = operation.result.catch((error: unknown) => error);
+    target.pbjs = 1;
+
+    oldNotifications[0]?.();
+    expect(operation.status).toBe('pending');
+    adapter.dispose();
+    await expect(result).resolves.toMatchObject({ code: 'operation_disposed' });
+  });
+
+  it('requires an exact own artifact data descriptor', async () => {
+    const valid = createReadyPrebid();
+    const inherited = Object.create(valid.pbjs) as Record<string, unknown>;
+    const accessor = { ...valid.pbjs };
+    Object.defineProperty(accessor, '__trustedServerArtifactV1', { get: () => valid.stamp });
+    const enumerable = { ...valid.pbjs };
+    Object.defineProperty(enumerable, '__trustedServerArtifactV1', {
+      value: valid.stamp,
+      enumerable: true,
+      writable: false,
+      configurable: false,
+    });
+
+    for (const pbjs of [{ ...valid.pbjs }, inherited, accessor, enumerable]) {
+      const operation = createBrowserPrebidAdapter({ pbjs }).run(vi.fn());
+      expect(operation.status).toBe('incompatible');
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+  });
+
+  it('rejects stamp accessors and extra own keys without invoking them', async () => {
+    const getter = vi.fn(() => 'alpha');
+    const bidderCodes: unknown[] = [];
+    Object.defineProperty(bidderCodes, '0', {
+      get: getter,
+      enumerable: true,
+      configurable: false,
+    });
+    Object.defineProperty(bidderCodes, 'length', { writable: false });
+    Object.freeze(bidderCodes);
+    const accessorStamp = Object.freeze({ ...createStamp(), bidderCodes });
+    const extraStamp = recursivelyFreeze({ ...createStamp(), unexpected: true });
+
+    for (const stamp of [accessorStamp, extraStamp]) {
+      const operation = createBrowserPrebidAdapter({
+        pbjs: createReadyPrebid({ stamp }).pbjs,
+      }).run(vi.fn());
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+    expect(getter).not.toHaveBeenCalled();
+  });
+
+  it('validates ABI, version, frozen bounded metadata, and configured coverage', async () => {
+    const incompatibleStamps = [
+      createStamp({ abi: 2 }),
+      createStamp({ prebidVersion: '10.25.0' }),
+      createStamp({ artifactReleaseId: 'A'.repeat(64) }),
+      createStamp({ bidderCodes: ['alpha', 'alpha'] }),
+      createStamp({ moduleStems: ['sharedIdSystem', 'alphaBidAdapter'] }),
+      createStamp({ bidderAliases: [{ code: 'missing', moduleStem: 'alphaBidAdapter' }] }),
+      createStamp({
+        userIdModules: [
+          {
+            moduleName: 'sharedIdSystem',
+            configNames: ['sharedId'],
+            eidSources: ['UPPER.example'],
+          },
+        ],
+      }),
+      createStamp({
+        moduleStems: Array.from(
+          { length: 257 },
+          (_, index) => `module-${String(index).padStart(3, '0')}`
+        ),
+      }),
+    ];
+    const mutable = Object.freeze({
+      ...createStamp(),
+      bidderCodes: ['alpha', 'alphaAlias'],
+    });
+    incompatibleStamps.push(mutable);
+
+    for (const stamp of incompatibleStamps) {
+      const operation = createBrowserPrebidAdapter(
+        { pbjs: createReadyPrebid({ stamp }).pbjs },
+        {
+          configuredClientSideBidders: ['alpha'],
+          requiredUserIdModules: [
+            {
+              moduleName: 'sharedIdSystem',
+              configNames: ['sharedId'],
+              eidSources: ['sharedid.org'],
+            },
+          ],
+        }
+      ).run(vi.fn());
+      expect(operation.status).toBe('incompatible');
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+
+    const uncoveredBidder = createBrowserPrebidAdapter(
+      { pbjs: createReadyPrebid().pbjs },
+      { configuredClientSideBidders: ['unbundled'] }
+    ).run(vi.fn());
+    await expect(uncoveredBidder.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+  });
+
+  it('enforces every metadata count boundary', async () => {
+    const names = (prefix: string, count: number) =>
+      Array.from({ length: count }, (_, index) => `${prefix}-${String(index).padStart(3, '0')}`);
+    const cases: Array<{ valid: object; invalid: object }> = [];
+
+    cases.push({
+      valid: createStamp({
+        moduleStems: names('module', 256),
+        bidderAliases: [],
+        userIdModules: [],
+      }),
+      invalid: createStamp({
+        moduleStems: names('module', 257),
+        bidderAliases: [],
+        userIdModules: [],
+      }),
+    });
+    cases.push({
+      valid: createStamp({ bidderCodes: names('bidder', 512), bidderAliases: [] }),
+      invalid: createStamp({ bidderCodes: names('bidder', 513), bidderAliases: [] }),
+    });
+    const aliasCodes = names('alias', 512);
+    const aliasModules = names('adapter', 171);
+    const overflowingAliases = ['alias-a', 'alias-b', 'alias-c'].flatMap((code) =>
+      aliasModules.map((moduleStem) => ({ code, moduleStem }))
+    );
+    cases.push({
+      valid: createStamp({
+        moduleStems: ['adapter'],
+        bidderCodes: aliasCodes,
+        bidderAliases: aliasCodes.map((code) => ({ code, moduleStem: 'adapter' })),
+        userIdModules: [],
+      }),
+      invalid: createStamp({
+        moduleStems: aliasModules,
+        bidderCodes: ['alias-a', 'alias-b', 'alias-c'],
+        bidderAliases: overflowingAliases,
+        userIdModules: [],
+      }),
+    });
+    const moduleNames = names('user', 128);
+    cases.push({
+      valid: createStamp({
+        moduleStems: moduleNames,
+        bidderAliases: [],
+        userIdModules: moduleNames.map((moduleName) => ({
+          moduleName,
+          configNames: [],
+          eidSources: [],
+        })),
+      }),
+      invalid: createStamp({
+        moduleStems: [...moduleNames, 'user-overflow'].sort(),
+        bidderAliases: [],
+        userIdModules: [...moduleNames, 'user-overflow'].sort().map((moduleName) => ({
+          moduleName,
+          configNames: [],
+          eidSources: [],
+        })),
+      }),
+    });
+    const configNames = names('config', 64);
+    const eidSources = names('source', 64).map((source) => `${source}.example`);
+    cases.push({
+      valid: createStamp({
+        moduleStems: ['identity'],
+        bidderAliases: [],
+        userIdModules: [{ moduleName: 'identity', configNames, eidSources }],
+      }),
+      invalid: createStamp({
+        moduleStems: ['identity'],
+        bidderAliases: [],
+        userIdModules: [
+          {
+            moduleName: 'identity',
+            configNames: [...configNames, 'config-overflow'].sort(),
+            eidSources,
+          },
+        ],
+      }),
+    });
+    cases.push({
+      valid: createStamp({
+        moduleStems: ['identity'],
+        bidderAliases: [],
+        userIdModules: [{ moduleName: 'identity', configNames, eidSources }],
+      }),
+      invalid: createStamp({
+        moduleStems: ['identity'],
+        bidderAliases: [],
+        userIdModules: [
+          {
+            moduleName: 'identity',
+            configNames,
+            eidSources: [...eidSources, 'source-overflow.example'].sort(),
+          },
+        ],
+      }),
+    });
+
+    for (const boundary of cases) {
+      const accepted = createBrowserPrebidAdapter({
+        pbjs: createReadyPrebid({ stamp: boundary.valid }).pbjs,
+      }).run(() => 'accepted');
+      await expect(accepted.result).resolves.toBe('accepted');
+      const refused = createBrowserPrebidAdapter({
+        pbjs: createReadyPrebid({ stamp: boundary.invalid }).pbjs,
+      }).run(vi.fn());
+      await expect(refused.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+  });
+
+  it('enforces nonempty scalar-valid UTF-8 byte limits and nested lexical uniqueness', async () => {
+    const invalidStamps = [
+      createStamp({ moduleStems: [''] }),
+      createStamp({ moduleStems: ['é'.repeat(65)] }),
+      createStamp({ bidderCodes: ['\ud800'], bidderAliases: [] }),
+      createStamp({
+        bidderAliases: [
+          { code: 'alphaAlias', moduleStem: 'alphaBidAdapter' },
+          { code: 'alphaAlias', moduleStem: 'alphaBidAdapter' },
+        ],
+      }),
+      createStamp({
+        userIdModules: [
+          { moduleName: 'sharedIdSystem', configNames: ['z', 'a'], eidSources: ['sharedid.org'] },
+        ],
+      }),
+      createStamp({
+        userIdModules: [
+          {
+            moduleName: 'sharedIdSystem',
+            configNames: ['sharedId'],
+            eidSources: ['z.example', 'a.example'],
+          },
+        ],
+      }),
+      createStamp({
+        userIdModules: [{ moduleName: 'missingSystem', configNames: [], eidSources: [] }],
+      }),
+    ];
+    const accepted = createStamp({
+      moduleStems: ['é'.repeat(64)],
+      bidderAliases: [],
+      userIdModules: [],
+    });
+    await expect(
+      createBrowserPrebidAdapter({ pbjs: createReadyPrebid({ stamp: accepted }).pbjs }).run(
+        () => 'accepted'
+      ).result
+    ).resolves.toBe('accepted');
+
+    for (const [index, stamp] of invalidStamps.entries()) {
+      const operation = createBrowserPrebidAdapter({
+        pbjs: createReadyPrebid({ stamp }).pbjs,
+      }).run(vi.fn());
+      expect(operation.status, `invalid metadata case ${index}`).toBe('incompatible');
+      await expect(operation.result, `invalid metadata case ${index}`).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+  });
+
+  it('requires every real API method and contains hostile target and member getters', async () => {
+    for (const method of [
+      'addAdUnits',
+      'getBidResponsesForAdUnitCode',
+      'getHighestCpmBids',
+      'offEvent',
+      'onEvent',
+      'processQueue',
+      'registerBidAdapter',
+      'renderAd',
+      'requestBids',
+      'setTargetingForGPTAsync',
+    ] as const) {
+      const ready = createReadyPrebid();
+      Object.defineProperty(ready.pbjs, method, { value: undefined });
+      const operation = createBrowserPrebidAdapter({ pbjs: ready.pbjs }).run(vi.fn());
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+    }
+
+    const hostileTarget = Object.defineProperty({}, 'pbjs', {
+      get: () => {
+        throw new Error('target getter failed');
+      },
+    });
+    let hostileTargetOperation:
+      ReturnType<ReturnType<typeof createBrowserPrebidAdapter>['run']> | undefined;
+    expect(() => {
+      hostileTargetOperation = createBrowserPrebidAdapter(hostileTarget).run(vi.fn());
+    }).not.toThrow();
+    await expect(hostileTargetOperation?.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    const hostile = createReadyPrebid();
+    Object.defineProperty(hostile.pbjs, 'requestBids', {
+      get: () => {
+        throw new Error('member getter failed');
+      },
+    });
+    let hostileMemberOperation:
+      ReturnType<ReturnType<typeof createBrowserPrebidAdapter>['run']> | undefined;
+    expect(() => {
+      hostileMemberOperation = createBrowserPrebidAdapter({ pbjs: hostile.pbjs }).run(vi.fn());
+    }).not.toThrow();
+    await expect(hostileMemberOperation?.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+  });
+
+  it('rejects missing required user-ID coverage and diagnoses one incompatible object once', async () => {
+    const warning = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    try {
+      const ready = createReadyPrebid();
+      const adapter = createBrowserPrebidAdapter(
+        { pbjs: ready.pbjs },
+        {
+          requiredUserIdModules: [
+            {
+              moduleName: 'sharedIdSystem',
+              configNames: ['missingConfig'],
+              eidSources: ['missing.example'],
+            },
+          ],
+        }
+      );
+      const first = adapter.run(vi.fn());
+      const second = adapter.run(vi.fn());
+      await expect(first.result).rejects.toMatchObject({ code: 'external_artifact_incompatible' });
+      await expect(second.result).rejects.toMatchObject({ code: 'external_artifact_incompatible' });
+      expect(adapter.bindingStatus()).toBe('incompatible');
+      expect(warning).toHaveBeenCalledTimes(1);
+      expect(String(warning.mock.calls[0]?.[0]).length).toBeLessThanOrEqual(256);
+    } finally {
+      warning.mockRestore();
+    }
+  });
+
+  it.each(['before', 'after'] as const)(
+    'bounds Prebid diagnostics when WeakSet.add persistently throws %s insertion',
+    async (failure) => {
+      const warning = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const incompatible = createReadyPrebid({ stamp: createStamp({ abi: 2 }) });
+      const adapter = createBrowserPrebidAdapter({ pbjs: incompatible.pbjs });
+      const originalWeakSetAdd = WeakSet.prototype.add;
+      WeakSet.prototype.add = function (this: WeakSet<object>, value: object): WeakSet<object> {
+        if (failure === 'after') Reflect.apply(originalWeakSetAdd, this, [value]);
+        throw new Error(`diagnostic tracking failed ${failure} insertion`);
+      } as typeof WeakSet.prototype.add;
+
+      const poisoned: Array<ReturnType<typeof adapter.run>> = [];
+      const thrown: unknown[] = [];
+      try {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+          try {
+            poisoned.push(adapter.run(vi.fn()));
+          } catch (error) {
+            thrown.push(error);
+          }
+        }
+      } finally {
+        WeakSet.prototype.add = originalWeakSetAdd;
+      }
+
+      try {
+        expect(thrown).toEqual([]);
+        expect(poisoned).toHaveLength(3);
+        for (const operation of poisoned) {
+          await expect(operation.result).rejects.toMatchObject({
+            code: 'external_artifact_incompatible',
+          });
+        }
+        expect(warning).toHaveBeenCalledTimes(failure === 'after' ? 1 : 0);
+
+        const healthy = adapter.run(vi.fn());
+        const suppressed = adapter.run(vi.fn());
+        await expect(healthy.result).rejects.toMatchObject({
+          code: 'external_artifact_incompatible',
+        });
+        await expect(suppressed.result).rejects.toMatchObject({
+          code: 'external_artifact_incompatible',
+        });
+        expect(warning).toHaveBeenCalledTimes(1);
+      } finally {
+        warning.mockRestore();
+        adapter.dispose();
+      }
+    }
+  );
+
+  it.each(['preflight', 'observation'] as const)(
+    'recovers bounded Prebid diagnostics when WeakSet.has poisons %s',
+    async (failure) => {
+      const warning = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+      const incompatible = createReadyPrebid({ stamp: createStamp({ abi: 2 }) });
+      const adapter = createBrowserPrebidAdapter({ pbjs: incompatible.pbjs });
+      const originalWeakSetHas = WeakSet.prototype.has;
+      let lookups = 0;
+      WeakSet.prototype.has = function (this: WeakSet<object>, value: object): boolean {
+        lookups += 1;
+        if (failure === 'preflight' || lookups === 2) {
+          throw new Error(`diagnostic ${failure} lookup failed`);
+        }
+        return Reflect.apply(originalWeakSetHas, this, [value]) as boolean;
+      } as typeof WeakSet.prototype.has;
+
+      let poisoned: ReturnType<typeof adapter.run> | undefined;
+      let thrown: unknown;
+      try {
+        poisoned = adapter.run(vi.fn());
+      } catch (error) {
+        thrown = error;
+      } finally {
+        WeakSet.prototype.has = originalWeakSetHas;
+      }
+
+      try {
+        expect(thrown).toBeUndefined();
+        if (!poisoned) throw new Error('Expected a published Prebid operation');
+        await expect(poisoned.result).rejects.toMatchObject({
+          code: 'external_artifact_incompatible',
+        });
+        expect(warning).not.toHaveBeenCalled();
+
+        const healthy = adapter.run(vi.fn());
+        const suppressed = adapter.run(vi.fn());
+        await expect(healthy.result).rejects.toMatchObject({
+          code: 'external_artifact_incompatible',
+        });
+        await expect(suppressed.result).rejects.toMatchObject({
+          code: 'external_artifact_incompatible',
+        });
+        expect(warning).toHaveBeenCalledTimes(1);
+      } finally {
+        warning.mockRestore();
+        adapter.dispose();
+      }
+    }
+  );
+
+  it('releases pending capacity immediately on abort and adapter disposal', async () => {
+    vi.useFakeTimers();
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const controller = new AbortController();
+    const aborted = adapter.run(vi.fn(), { signal: controller.signal });
+    const abortedResult = aborted.result.catch((error: unknown) => error);
+    controller.abort();
+    const replacements = Array.from({ length: 64 }, () => adapter.run(() => undefined));
+    adapter.dispose();
+
+    await expect(abortedResult).resolves.toMatchObject({ code: 'caller_aborted' });
+    const disposed = await Promise.all(
+      replacements.map(({ result }) => result.catch((error: unknown) => error))
+    );
+    expect(disposed).toHaveLength(64);
+    for (const value of disposed) {
+      expect(value).toMatchObject({ code: 'operation_disposed' });
+    }
+  });
+
+  it('invalidates an entered command immediately when the adapter is disposed', async () => {
+    const ready = createReadyPrebid();
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const operation = adapter.run((prebid) => {
+      adapter.dispose();
+      prebid.requestBids({ mustNotRun: true });
+    });
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(operation.status).toBe('present');
+    expect(ready.pbjs.requestBids).not.toHaveBeenCalled();
+    expect(ready.listeners.size).toBe(0);
+  });
+
+  it('throws when Prebid inspection disposes the adapter before an operation is published', () => {
+    const ready = createReadyPrebid();
+    const holder: { adapter?: ReturnType<typeof createBrowserPrebidAdapter> } = {};
+    const target = Object.defineProperty({}, 'pbjs', {
+      get: () => {
+        holder.adapter?.dispose();
+        return ready.pbjs;
+      },
+    });
+    const adapter = createBrowserPrebidAdapter(target);
+    holder.adapter = adapter;
+    const command = vi.fn();
+
+    expect(() => adapter.run(command)).toThrowError(
+      expect.objectContaining({ code: 'operation_disposed' })
+    );
+    expect(command).not.toHaveBeenCalled();
+    expect(ready.commands).toHaveLength(0);
+  });
+
+  it('rejects without enqueueing when Prebid inspection disposes a published operation', async () => {
+    const ready = createReadyPrebid({ deferCommands: true });
+    let reads = 0;
+    const holder: { adapter?: ReturnType<typeof createBrowserPrebidAdapter> } = {};
+    const target = Object.defineProperty({}, 'pbjs', {
+      get: () => {
+        reads += 1;
+        if (reads === 2) holder.adapter?.dispose();
+        return ready.pbjs;
+      },
+    });
+    const adapter = createBrowserPrebidAdapter(target);
+    holder.adapter = adapter;
+    const command = vi.fn();
+    const operation = adapter.run(command);
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(command).not.toHaveBeenCalled();
+    expect(ready.commands).toHaveLength(0);
+  });
+
+  it('contains disposal reentrant from Prebid member reads and external calls', async () => {
+    const ready = createReadyPrebid();
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const staleRequest = vi.fn();
+    let requestBidsReads = 0;
+    Object.defineProperty(ready.pbjs, 'requestBids', {
+      get: () => {
+        requestBidsReads += 1;
+        if (requestBidsReads > 1) adapter.dispose();
+        return staleRequest;
+      },
+    });
+    const memberOperation = adapter.run((prebid) => prebid.requestBids({}));
+
+    await expect(memberOperation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(staleRequest).not.toHaveBeenCalled();
+
+    const externalReady = createReadyPrebid();
+    const externalAdapter = createBrowserPrebidAdapter({ pbjs: externalReady.pbjs });
+    externalReady.pbjs.requestBids.mockImplementation(() => externalAdapter.dispose());
+    const externalOperation = externalAdapter.run((prebid) => {
+      prebid.requestBids({ first: true });
+      prebid.requestBids({ mustNotRun: true });
+    });
+
+    await expect(externalOperation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(externalReady.pbjs.requestBids).toHaveBeenCalledTimes(1);
+  });
+
+  it('rechecks identity after hostile facade member reads and calls', async () => {
+    const first = createReadyPrebid();
+    const replacement = createReadyPrebid();
+    const target: { pbjs?: unknown } = { pbjs: first.pbjs };
+    const staleRequest = vi.fn();
+    Object.defineProperty(first.pbjs, 'requestBids', {
+      get: () => {
+        target.pbjs = replacement.pbjs;
+        return staleRequest;
+      },
+    });
+    const operation = createBrowserPrebidAdapter(target).run((prebid) => prebid.requestBids({}));
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(operation.status).toBe('incompatible');
+    expect(staleRequest).not.toHaveBeenCalled();
+  });
+
+  it('rechecks both object and stamp identity before invoking a deferred command', async () => {
+    const first = createReadyPrebid({ deferCommands: true });
+    const replacement = createReadyPrebid();
+    const target: { pbjs?: unknown } = { pbjs: first.pbjs };
+    const adapter = createBrowserPrebidAdapter(target);
+    const command = vi.fn();
+    const operation = adapter.run(command);
+    const result = operation.result.catch((error: unknown) => error);
+
+    target.pbjs = replacement.pbjs;
+    expect(() => first.commands[0]?.()).not.toThrow();
+    await expect(result).resolves.toMatchObject({ code: 'external_artifact_incompatible' });
+    expect(operation.status).toBe('incompatible');
+    expect(command).not.toHaveBeenCalled();
+
+    const later = adapter.run(() => 'replacement');
+    await expect(later.result).resolves.toBe('replacement');
+  });
+
+  it('marks an operation incompatible when its command replaces the bound object', async () => {
+    const first = createReadyPrebid();
+    const replacement = createReadyPrebid();
+    const target: { pbjs?: unknown } = { pbjs: first.pbjs };
+    const operation = createBrowserPrebidAdapter(target).run(() => {
+      target.pbjs = replacement.pbjs;
+      return 'stale';
+    });
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(operation.status).toBe('incompatible');
+  });
+
+  it('rolls back an exact Prebid listener when installation replaces the binding', async () => {
+    const first = createReadyPrebid();
+    const replacement = createReadyPrebid();
+    const target: { pbjs?: unknown } = { pbjs: first.pbjs };
+    const adapter = createBrowserPrebidAdapter(target);
+    first.pbjs.onEvent.mockImplementation((type, listener) => {
+      const registered = first.listeners.get(type) ?? new Set();
+      registered.add(listener);
+      first.listeners.set(type, registered);
+      target.pbjs = replacement.pbjs;
+    });
+    const operation = adapter.run((prebid) => prebid.subscribe('bidResponse', vi.fn()));
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    const installed = first.pbjs.onEvent.mock.calls[0]?.[1];
+    expect(first.pbjs.offEvent).toHaveBeenCalledWith('bidResponse', installed);
+    expect(first.listeners.get('bidResponse')?.size).toBe(0);
+  });
+
+  it('grants synchronous highest-bid access only for the active event callback', async () => {
+    const ready = createReadyPrebid();
+    const selected = Object.freeze({ adId: 'r1_selected', adUnitCode: 'slot-one' });
+    ready.pbjs.getHighestCpmBids.mockReturnValue([selected]);
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    let eventFacade: Readonly<PrebidEventFacade> | undefined;
+    const listener = vi.fn((event: unknown, prebid: Readonly<PrebidEventFacade>) => {
+      eventFacade = prebid;
+      expect(event).toEqual({ auctionId: 'auction-one' });
+      expect(Object.isFrozen(prebid)).toBe(true);
+      expect(Reflect.ownKeys(prebid)).toEqual(['highestBids']);
+      expect(prebid.highestBids('slot-one')).toEqual([selected]);
+    });
+
+    await adapter.run((prebid) => prebid.subscribe('auctionEnd', listener)).result;
+    const installed = [...(ready.listeners.get('auctionEnd') ?? [])][0];
+    expect(() => installed?.({ auctionId: 'auction-one' })).not.toThrow();
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(ready.pbjs.getHighestCpmBids).toHaveBeenCalledExactlyOnceWith('slot-one');
+    expect(() => eventFacade?.highestBids('slot-one')).toThrowError(
+      expect.objectContaining({ code: 'external_artifact_incompatible' })
+    );
+    adapter.dispose();
+  });
+
+  it('rolls back a Prebid listener when installation disposes and cleanup throws', async () => {
+    const ready = createReadyPrebid();
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    ready.pbjs.onEvent.mockImplementation((type, listener) => {
+      const registered = ready.listeners.get(type) ?? new Set();
+      registered.add(listener);
+      ready.listeners.set(type, registered);
+      adapter.dispose();
+    });
+    ready.pbjs.offEvent.mockImplementation((type, listener) => {
+      ready.listeners.get(type)?.delete(listener);
+      throw new Error('cleanup failed');
+    });
+    const operation = adapter.run((prebid) => prebid.subscribe('bidResponse', vi.fn()));
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(ready.pbjs.offEvent).toHaveBeenCalledTimes(1);
+    expect(ready.listeners.get('bidResponse')?.size).toBe(0);
+  });
+
+  it.each(['dispose', 'throw'] as const)(
+    'rolls back Prebid subscription ownership when effect registration must %s',
+    async (failure) => {
+      const ready = createReadyPrebid();
+      const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+      const registryError = new Error('effect registry add failed');
+      const originalDescriptor = Object.getOwnPropertyDescriptor(Set.prototype, 'add');
+      const nativeAdd = Set.prototype.add;
+      const existingListeners = new Set<(event: unknown) => void>();
+      const failedListeners = new Set<(event: unknown) => void>();
+      const existingListener = vi.fn();
+      const failedListener = vi.fn();
+      ready.listeners.set('existing', existingListeners);
+      ready.listeners.set('failed', failedListeners);
+      let operation: ReturnType<typeof adapter.run> | undefined;
+      try {
+        operation = adapter.run((prebid) => {
+          prebid.subscribe('existing', existingListener);
+          Object.defineProperty(Set.prototype, 'add', {
+            configurable: true,
+            writable: true,
+            value: function (this: Set<unknown>, value: unknown): Set<unknown> {
+              if (
+                typeof value === 'function' &&
+                this !== existingListeners &&
+                this !== failedListeners
+              ) {
+                if (failure === 'dispose') adapter.dispose();
+                else throw registryError;
+              }
+              return Reflect.apply(nativeAdd, this, [value]) as Set<unknown>;
+            },
+          });
+          return prebid.subscribe('failed', failedListener);
+        });
+      } finally {
+        if (originalDescriptor) Object.defineProperty(Set.prototype, 'add', originalDescriptor);
+      }
+
+      if (failure === 'dispose') {
+        await expect(operation?.result).rejects.toMatchObject({ code: 'operation_disposed' });
+      } else {
+        await expect(operation?.result).rejects.toBe(registryError);
+      }
+      adapter.dispose();
+      adapter.dispose();
+
+      expect(ready.listeners.get('existing')?.size).toBe(0);
+      expect(ready.listeners.get('failed')?.size).toBe(0);
+      expect(ready.pbjs.offEvent).toHaveBeenCalledTimes(2);
+    }
+  );
+
+  it('settles a live Prebid operation and restores listeners when Set.delete is poisoned', async () => {
+    const ready = createReadyPrebid();
+    const originalSetDelete = Set.prototype.delete;
+    ready.pbjs.offEvent.mockImplementation((type, listener) => {
+      const registered = ready.listeners.get(type);
+      if (registered) Reflect.apply(originalSetDelete, registered, [listener]);
+    });
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const listener = vi.fn();
+    const operation = adapter.run((prebid) => {
+      prebid.subscribe('bidResponse', listener);
+      return new Promise<never>(() => undefined);
+    });
+    expect(ready.listeners.get('bidResponse')).toHaveLength(1);
+
+    Set.prototype.delete = function (): boolean {
+      throw new Error('Prebid live cleanup delete failed');
+    } as typeof Set.prototype.delete;
+    try {
+      expect(() => adapter.dispose()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(ready.listeners.get('bidResponse')).toHaveLength(0);
+    expect(() => adapter.dispose()).not.toThrow();
+  });
+
+  it('rolls back a failed Prebid command subscription without touching prior global effects', async () => {
+    const ready = createReadyPrebid();
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const priorListener = vi.fn();
+    const failedListener = vi.fn();
+    const commandError = new Error('command failed');
+    await adapter.run((prebid) => prebid.subscribe('prior', priorListener)).result;
+
+    const operation = adapter.run((prebid) => {
+      prebid.subscribe('failed', failedListener);
+      throw commandError;
+    });
+
+    await expect(operation.result).rejects.toBe(commandError);
+    expect(ready.listeners.get('prior')?.size).toBe(1);
+    expect(ready.listeners.get('failed')?.size).toBe(0);
+    expect(() => [...(ready.listeners.get('prior') ?? [])][0]?.({})).not.toThrow();
+    expect(priorListener).toHaveBeenCalledTimes(1);
+    expect(failedListener).not.toHaveBeenCalled();
+
+    adapter.dispose();
+    expect(ready.listeners.get('prior')?.size).toBe(0);
+    expect(ready.pbjs.offEvent).toHaveBeenCalledTimes(2);
+  });
+
+  it('promotes fulfilled Prebid command subscriptions and rolls back rejected ones', async () => {
+    const ready = createReadyPrebid();
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const rejection = new Error('async command failed');
+    const rejected = adapter.run((prebid) => {
+      prebid.subscribe('rejected', vi.fn());
+      return Promise.reject(rejection);
+    });
+
+    await expect(rejected.result).rejects.toBe(rejection);
+    expect(ready.listeners.get('rejected')?.size).toBe(0);
+
+    const fulfilled = adapter.run((prebid) => {
+      prebid.subscribe('fulfilled', vi.fn());
+      return Promise.resolve('complete');
+    });
+    await expect(fulfilled.result).resolves.toBe('complete');
+    expect(ready.listeners.get('fulfilled')?.size).toBe(1);
+
+    adapter.dispose();
+    expect(ready.listeners.get('fulfilled')?.size).toBe(0);
+  });
+
+  it.each(['dispose', 'replacement'] as const)(
+    'rolls back a provisional Prebid subscription after async %s',
+    async (failure) => {
+      const first = createReadyPrebid();
+      const replacement = createReadyPrebid();
+      const target: { pbjs?: unknown } = { pbjs: first.pbjs };
+      const adapter = createBrowserPrebidAdapter(target);
+      let resolveCommand!: (value: string) => void;
+      const commandResult = new Promise<string>((resolve) => {
+        resolveCommand = resolve;
+      });
+      const operation = adapter.run((prebid) => {
+        prebid.subscribe('provisional', vi.fn());
+        return commandResult;
+      });
+
+      if (failure === 'dispose') adapter.dispose();
+      else target.pbjs = replacement.pbjs;
+      resolveCommand('late-success');
+
+      await expect(operation.result).rejects.toMatchObject({
+        code: failure === 'dispose' ? 'operation_disposed' : 'external_artifact_incompatible',
+      });
+      expect(first.listeners.get('provisional')?.size).toBe(0);
+    }
+  );
+
+  it('holds 64 pending operations and fails only overflow synchronously', async () => {
+    vi.useFakeTimers();
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const operations = Array.from({ length: 64 }, () => adapter.run(() => undefined));
+    expect(() => adapter.run(() => undefined)).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+    await expect(Promise.all(operations.map(({ result }) => result))).resolves.toHaveLength(64);
+  });
+
+  it('reserves pending Prebid capacity before hostile signal registration reenters', async () => {
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const accepted: Array<ReturnType<typeof adapter.run>> = [];
+    const overflows: unknown[] = [];
+    const order: number[] = [];
+    const signal = {
+      aborted: false,
+      addEventListener: vi.fn(() => {
+        for (let index = 1; index <= 64; index += 1) {
+          try {
+            accepted.push(adapter.run(() => order.push(index)));
+          } catch (error) {
+            overflows.push(error);
+          }
+        }
+      }),
+      removeEventListener: vi.fn(),
+    } as unknown as AbortSignal;
+
+    const outer = adapter.run(() => order.push(0), { signal });
+
+    expect(accepted).toHaveLength(63);
+    expect(overflows).toHaveLength(1);
+    expect(overflows[0]).toMatchObject({ code: 'external_queue_full' });
+
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+    await expect(
+      Promise.all([outer.result, ...accepted.map(({ result }) => result)])
+    ).resolves.toHaveLength(64);
+    expect(order).toEqual(Array.from({ length: 64 }, (_, index) => index));
+  });
+
+  it('reserves pending Prebid capacity before poisoned Set.add reenters', async () => {
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const accepted: Array<ReturnType<typeof adapter.run>> = [];
+    const overflows: unknown[] = [];
+    const order: number[] = [];
+    const originalSetAdd = Set.prototype.add;
+    let reentered = false;
+    Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+      if (!reentered) {
+        reentered = true;
+        Set.prototype.add = originalSetAdd;
+        for (let index = 1; index <= 64; index += 1) {
+          try {
+            accepted.push(adapter.run(() => order.push(index)));
+          } catch (error) {
+            overflows.push(error);
+          }
+        }
+      }
+      return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+    } as typeof Set.prototype.add;
+
+    let outer: ReturnType<typeof adapter.run> | undefined;
+    try {
+      outer = adapter.run(() => order.push(0));
+    } finally {
+      Set.prototype.add = originalSetAdd;
+    }
+    if (!outer) throw new Error('Expected a published Prebid operation');
+
+    expect(accepted).toHaveLength(63);
+    expect(overflows).toHaveLength(1);
+    expect(overflows[0]).toMatchObject({ code: 'external_queue_full' });
+
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+    await expect(
+      Promise.all([outer.result, ...accepted.map(({ result }) => result)])
+    ).resolves.toHaveLength(64);
+    expect(order).toEqual([...Array.from({ length: 63 }, (_, index) => index + 1), 0]);
+
+    target.pbjs = undefined;
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+    await expect(Promise.all(recovered.map(({ result }) => result))).resolves.toHaveLength(64);
+  });
+
+  it('rolls back pending Prebid publication when poisoned Set.add throws', async () => {
+    vi.useFakeTimers();
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const publicationError = new Error('Prebid publication failed');
+    const command = vi.fn();
+    const signalGetter = vi.fn(() => undefined);
+    const options = Object.defineProperty({}, 'signal', {
+      get: signalGetter,
+    }) as { readonly signal?: AbortSignal };
+    const originalSetAdd = Set.prototype.add;
+    const originalSetDelete = Set.prototype.delete;
+    const poisonedDelete = function (): boolean {
+      throw new Error('Prebid publication rollback delete failed');
+    } as typeof Set.prototype.delete;
+    let poisonNextAdd = true;
+    Set.prototype.add = function (this: Set<unknown>, value: unknown): Set<unknown> {
+      if (poisonNextAdd) {
+        poisonNextAdd = false;
+        Set.prototype.add = originalSetAdd;
+        Reflect.apply(originalSetAdd, this, [value]);
+        throw publicationError;
+      }
+      return Reflect.apply(originalSetAdd, this, [value]) as Set<unknown>;
+    } as typeof Set.prototype.add;
+    Set.prototype.delete = poisonedDelete;
+
+    let thrown: unknown;
+    try {
+      adapter.run(command, options);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      Set.prototype.add = originalSetAdd;
+      Set.prototype.delete = originalSetDelete;
+    }
+
+    expect(thrown).toBe(publicationError);
+    expect(command).not.toHaveBeenCalled();
+    expect(signalGetter).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+
+    const recovered = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+    expect(() => adapter.run(vi.fn())).toThrowError(
+      expect.objectContaining({ code: 'external_queue_full' })
+    );
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+    await expect(Promise.all(recovered.map(({ result }) => result))).resolves.toHaveLength(64);
+    expect(vi.getTimerCount()).toBe(0);
+    Set.prototype.delete = poisonedDelete;
+    try {
+      expect(() => adapter.dispose()).not.toThrow();
+    } finally {
+      Set.prototype.delete = originalSetDelete;
+    }
+    await Promise.resolve();
+  });
+
+  it.each(['signal-getter', 'aborted-getter', 'add-throw', 'abort-remove-throw'] as const)(
+    'contains hostile Prebid AbortSignal ownership for %s',
+    async (failure) => {
+      const adapter = createBrowserPrebidAdapter({});
+      const signalError = new Error(`signal failure: ${failure}`);
+      const listeners = new Set<() => void>();
+      const removeEventListener = vi.fn((_type: string, listener: () => void) => {
+        if (failure === 'abort-remove-throw') throw signalError;
+        listeners.delete(listener);
+      });
+      const signal = Object.defineProperties(
+        {},
+        {
+          aborted: {
+            get: () => {
+              if (failure === 'aborted-getter') throw signalError;
+              return false;
+            },
+          },
+          addEventListener: {
+            value: vi.fn((_type: string, listener: () => void) => {
+              listeners.add(listener);
+              if (failure === 'add-throw') throw signalError;
+              if (failure === 'abort-remove-throw') listener();
+            }),
+          },
+          removeEventListener: { value: removeEventListener },
+        }
+      ) as AbortSignal;
+      const options =
+        failure === 'signal-getter'
+          ? (Object.defineProperty({}, 'signal', {
+              get: () => {
+                throw signalError;
+              },
+            }) as { readonly signal?: AbortSignal })
+          : { signal };
+      let operation: ReturnType<typeof adapter.run> | undefined;
+
+      expect(() => {
+        operation = adapter.run(vi.fn(), options);
+      }).not.toThrow();
+      if (!operation) throw new Error('Expected a published Prebid operation');
+      if (failure === 'abort-remove-throw') {
+        await expect(operation.result).rejects.toMatchObject({ code: 'caller_aborted' });
+      } else {
+        await expect(operation.result).rejects.toBe(signalError);
+      }
+      if (failure === 'add-throw' || failure === 'abort-remove-throw') {
+        expect(removeEventListener).toHaveBeenCalledTimes(1);
+      }
+
+      const fillers: Array<ReturnType<typeof adapter.run>> = [];
+      for (let index = 0; index < 64; index += 1) fillers.push(adapter.run(vi.fn()));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      adapter.dispose();
+      await Promise.all(fillers.map(({ result }) => result.catch((error: unknown) => error)));
+    }
+  );
+
+  it('settles an operation when its signal getter reentrantly disposes the adapter', async () => {
+    const adapter = createBrowserPrebidAdapter({});
+    const command = vi.fn();
+    const options = Object.defineProperty({}, 'signal', {
+      get: () => {
+        adapter.dispose();
+        return undefined;
+      },
+    }) as { readonly signal?: AbortSignal };
+
+    const operation = adapter.run(command, options);
+
+    await expect(operation.result).rejects.toMatchObject({ code: 'operation_disposed' });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    'add-getter',
+    'before-install',
+    'after-install',
+    'reentrant-callback',
+    'post-check-throw',
+  ] as const)(
+    'settles Prebid abort transitions during listener registration for %s',
+    async (transition) => {
+      vi.useFakeTimers();
+      const target: { pbjs?: unknown } = {};
+      const adapter = createBrowserPrebidAdapter(target);
+      const signalError = new Error(`abort transition failure: ${transition}`);
+      const listeners = new Set<() => void>();
+      let aborted = false;
+      let abortedReads = 0;
+      const addEventListener = vi.fn((_type: string, listener: () => void) => {
+        if (transition === 'before-install') aborted = true;
+        listeners.add(listener);
+        if (transition === 'after-install') aborted = true;
+        if (transition === 'reentrant-callback') {
+          aborted = true;
+          listener();
+        }
+      });
+      const removeEventListener = vi.fn((_type: string, listener: () => void) => {
+        listeners.delete(listener);
+      });
+      const signal = Object.defineProperties(
+        {},
+        {
+          aborted: {
+            get: () => {
+              abortedReads += 1;
+              if (transition === 'post-check-throw' && abortedReads === 2) throw signalError;
+              return aborted;
+            },
+          },
+          addEventListener: {
+            get: () => {
+              if (transition === 'add-getter') aborted = true;
+              return addEventListener;
+            },
+          },
+          removeEventListener: { value: removeEventListener },
+        }
+      ) as AbortSignal;
+      const command = vi.fn();
+      const operation = adapter.run(command, { signal });
+      const result = operation.result.catch((error: unknown) => error);
+
+      await vi.advanceTimersByTimeAsync(10_000);
+      if (transition === 'post-check-throw') await expect(result).resolves.toBe(signalError);
+      else await expect(result).resolves.toMatchObject({ code: 'caller_aborted' });
+      expect(addEventListener).toHaveBeenCalledTimes(1);
+      expect(removeEventListener).toHaveBeenCalledTimes(1);
+      expect(listeners).toHaveLength(0);
+
+      target.pbjs = createReadyPrebid().pbjs;
+      adapter.notifyReady();
+      expect(command).not.toHaveBeenCalled();
+
+      target.pbjs = undefined;
+      const fillers = Array.from({ length: 64 }, () => adapter.run(vi.fn()));
+      expect(() => adapter.run(vi.fn())).toThrowError(
+        expect.objectContaining({ code: 'external_queue_full' })
+      );
+      adapter.dispose();
+      await Promise.all(
+        fillers.map(({ result: filler }) => filler.catch((error: unknown) => error))
+      );
+    }
+  );
+
+  it('owns an exact ten-second per-operation deadline and ignores late readiness', async () => {
+    vi.useFakeTimers();
+    const target: { pbjs?: unknown } = {};
+    const adapter = createBrowserPrebidAdapter(target);
+    const first = adapter.run(vi.fn());
+    const firstResult = first.result.catch((error: unknown) => error);
+    await vi.advanceTimersByTimeAsync(5_000);
+    const second = adapter.run(vi.fn());
+    const secondResult = second.result.catch((error: unknown) => error);
+
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(first.status).toBe('timed_out');
+    expect(second.status).toBe('pending');
+    target.pbjs = createReadyPrebid().pbjs;
+    adapter.notifyReady();
+
+    await expect(firstResult).resolves.toMatchObject({ code: 'external_ready_timeout' });
+    await expect(secondResult).resolves.toBeUndefined();
+  });
+
+  it('removes aborts and disposal immediately, including deferred commands', async () => {
+    const deferred = createReadyPrebid({ deferCommands: true });
+    const controller = new AbortController();
+    const adapter = createBrowserPrebidAdapter({ pbjs: deferred.pbjs });
+    const command = vi.fn();
+    const operation = adapter.run(command, { signal: controller.signal });
+    const result = operation.result.catch((error: unknown) => error);
+
+    controller.abort();
+    expect(() => deferred.commands[0]?.()).not.toThrow();
+    adapter.dispose();
+
+    await expect(result).resolves.toMatchObject({ code: 'caller_aborted' });
+    expect(command).not.toHaveBeenCalled();
+  });
+
+  it('contains queue, command, and event callback throws', async () => {
+    const ready = createReadyPrebid();
+    const callbackError = new Error('callback failed');
+    const listener = vi.fn(() => {
+      throw callbackError;
+    });
+    const adapter = createBrowserPrebidAdapter({ pbjs: ready.pbjs });
+    const operation = adapter.run((prebid) => {
+      const unsubscribe = prebid.subscribe('bidResponse', listener);
+      const installed = [...(ready.listeners.get('bidResponse') ?? [])][0];
+      expect(() => installed?.({ adId: 'bid-a' })).not.toThrow();
+      unsubscribe();
+      throw callbackError;
+    });
+    await expect(operation.result).rejects.toBe(callbackError);
+
+    const pushError = new Error('queue failed');
+    const throwing = createReadyPrebid();
+    throwing.pbjs.que.push.mockImplementation(() => {
+      throw pushError;
+    });
+    const pushAdapter = createBrowserPrebidAdapter({ pbjs: throwing.pbjs });
+    let pushOperation: ReturnType<typeof pushAdapter.run> | undefined;
+    expect(() => {
+      pushOperation = pushAdapter.run(() => undefined);
+    }).not.toThrow();
+    await expect(pushOperation?.result).rejects.toBe(pushError);
+  });
+});
+
+describe('version-pinned Trusted Server bid admission', () => {
+  const preparedBid = () =>
+    recursivelyFreeze({
+      auctionId: 'auction-one',
+      adUnitCode: 'slot-one',
+      bid: {
+        requestId: 'request-one',
+        adId: 'r1_BwcHBwcHBwcHBwcHBwcHBw',
+        cpm: 1.25,
+        width: 300,
+        height: 250,
+        ad: '' as const,
+        ttl: 300 as const,
+        creativeId: 'creative-one',
+        netRevenue: true as const,
+        currency: 'USD' as const,
+        bidderCode: 'trustedServer',
+        meta: {
+          advertiserDomains: [] as string[],
+          tsAuctionId: 'auction-one',
+          tsBidId: 'bid-one',
+        },
+      },
+    });
+
+  function admissionFixture() {
+    const ready = createReadyPrebid();
+    const stored: object[] = [];
+    ready.pbjs.getBidResponsesForAdUnitCode.mockImplementation((adUnitCode?: string) =>
+      wrapBids(stored.filter((bid) => (bid as { adUnitCode?: unknown }).adUnitCode === adUnitCode))
+    );
+    const target: { pbjs: unknown } = { pbjs: ready.pbjs };
+    const adapter = createBrowserPrebidAdapter(target);
+    const auctions: unknown[] = [];
+    const operation = adapter.run((facade) => {
+      const boundary = facade as unknown as {
+        registerTrustedServerBidder(listener: (auction: unknown) => void): () => void;
+      };
+      return boundary.registerTrustedServerBidder((auction) => auctions.push(auction));
+    });
+    const bidderFactory = ready.pbjs.registerBidAdapter.mock.calls[0]?.[0] as
+      | (() => {
+          callBids(
+            request: unknown,
+            admit: (adUnitCode: string, bid: Record<string, unknown>) => void,
+            done: () => void
+          ): void;
+        })
+      | undefined;
+    const bidder = bidderFactory?.();
+    expect(ready.pbjs.registerBidAdapter).toHaveBeenCalledWith(bidderFactory, 'trustedServer');
+    const done = vi.fn();
+    const emitBidResponse = (bid: object): void => {
+      for (const listener of ready.listeners.get('bidResponse') ?? []) listener(bid);
+    };
+    const admit = vi.fn((adUnitCode: string, bid: Record<string, unknown>) => {
+      const published = { ...bid, adUnitCode };
+      stored.push(published);
+      emitBidResponse(published);
+    });
+    bidder?.callBids(
+      {
+        auctionId: 'auction-one',
+        bids: [
+          {
+            adUnitCode: 'slot-one',
+            adUnitId: 'ad-unit-one',
+            auctionId: 'auction-one',
+            bidId: 'request-one',
+            src: 'client',
+            transactionId: 'transaction-one',
+          },
+        ],
+      },
+      admit,
+      done
+    );
+    const boundary = adapter as unknown as {
+      admitTrustedBid(prepared: ReturnType<typeof preparedBid>): 'admitted' | 'not_admitted';
+    };
+    return {
+      adapter,
+      admit,
+      auctions,
+      boundary,
+      done,
+      emitBidResponse,
+      operation,
+      ready,
+      stored,
+      target,
+    };
+  }
+
+  it('captures one exact auction callback and admits a mutable copy atomically', async () => {
+    const fixture = admissionFixture();
+    await expect(fixture.operation.result).resolves.toBeTypeOf('function');
+
+    expect(fixture.auctions).toHaveLength(1);
+    const auction = fixture.auctions[0] as {
+      auctionId: string;
+      bids: readonly { adUnitCode: string; requestId: string }[];
+      complete(): void;
+    };
+    expect(Object.isFrozen(auction)).toBe(true);
+    expect(Object.isFrozen(auction.bids)).toBe(true);
+    expect(auction).toMatchObject({
+      auctionId: 'auction-one',
+      bids: [{ adUnitCode: 'slot-one', requestId: 'request-one' }],
+    });
+
+    const prepared = preparedBid();
+    expect(fixture.boundary.admitTrustedBid(prepared)).toBe('admitted');
+    expect(fixture.admit).toHaveBeenCalledTimes(1);
+    const admitted = fixture.admit.mock.calls[0]?.[1];
+    expect(admitted).toMatchObject(prepared.bid);
+    expect(admitted).not.toBe(prepared.bid);
+    expect(admitted).toMatchObject({
+      adUnitId: 'ad-unit-one',
+      auctionId: 'auction-one',
+      mediaType: 'banner',
+      source: 'client',
+      transactionId: 'transaction-one',
+    });
+    expect(Reflect.apply(admitted?.['getSize'] as () => string, admitted, [])).toBe('300x250');
+    expect(admitted?.['meta']).not.toBe(prepared.bid.meta);
+    expect((admitted?.['meta'] as { advertiserDomains?: unknown })?.advertiserDomains).not.toBe(
+      prepared.bid.meta.advertiserDomains
+    );
+    expect(Object.isFrozen(prepared.bid)).toBe(true);
+
+    auction.complete();
+    auction.complete();
+    expect(fixture.done).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns not_admitted only when neither state nor an event was published', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+    fixture.admit.mockImplementation(() => undefined);
+
+    expect(fixture.boundary.admitTrustedBid(preparedBid())).toBe('not_admitted');
+    expect(fixture.stored).toEqual([]);
+  });
+
+  it('rejects a response query that does not use the pinned self-wrapped array shape', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+    fixture.ready.pbjs.getBidResponsesForAdUnitCode.mockImplementation(
+      () => ({ bids: [] }) as never
+    );
+
+    expect(() => fixture.boundary.admitTrustedBid(preparedBid())).toThrowError(
+      expect.objectContaining({ code: 'external_artifact_incompatible' })
+    );
+    expect(fixture.admit).not.toHaveBeenCalled();
+  });
+
+  it('makes a request terminal after not_admitted instead of retrying publication', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+    fixture.admit.mockImplementation(() => undefined);
+
+    expect(fixture.boundary.admitTrustedBid(preparedBid())).toBe('not_admitted');
+    fixture.admit.mockImplementation((adUnitCode, bid) => {
+      const published = { ...bid, adUnitCode };
+      fixture.stored.push(published);
+      fixture.emitBidResponse(published);
+    });
+    expect(fixture.boundary.admitTrustedBid(preparedBid())).toBe('not_admitted');
+    expect(fixture.admit).toHaveBeenCalledTimes(1);
+    expect(fixture.stored).toEqual([]);
+  });
+
+  it('matches response state and events by exact auction, request, and ad-unit identity', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+    const prepared = preparedBid();
+    fixture.stored.push({
+      ...prepared.bid,
+      auctionId: 'other-auction',
+      adUnitCode: prepared.adUnitCode,
+    });
+    fixture.admit.mockImplementation((adUnitCode, bid) => {
+      fixture.emitBidResponse({
+        ...bid,
+        auctionId: 'other-auction',
+        adUnitCode,
+      });
+      const published = { ...bid, adUnitCode };
+      fixture.stored.push(published);
+      fixture.emitBidResponse(published);
+    });
+
+    expect(fixture.boundary.admitTrustedBid(prepared)).toBe('admitted');
+  });
+
+  it('refuses a second live Trusted Server bidder registration on the same binding', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+
+    const duplicate = fixture.adapter.run((prebid) => prebid.registerTrustedServerBidder(vi.fn()));
+
+    await expect(duplicate.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(fixture.ready.pbjs.registerBidAdapter).toHaveBeenCalledTimes(1);
+    fixture.adapter.dispose();
+  });
+
+  it('releases the private bidder registration and permits exact replacement', async () => {
+    const fixture = admissionFixture();
+    const release = await fixture.operation.result;
+
+    expect(release).toBeTypeOf('function');
+    Reflect.apply(release, undefined, []);
+    expect(fixture.done).toHaveBeenCalledTimes(1);
+
+    const replacement = fixture.adapter.run((prebid) =>
+      prebid.registerTrustedServerBidder(vi.fn())
+    );
+    const releaseReplacement = await replacement.result;
+    expect(releaseReplacement).toBeTypeOf('function');
+    expect(fixture.ready.pbjs.registerBidAdapter).toHaveBeenCalledTimes(2);
+    Reflect.apply(releaseReplacement, undefined, []);
+  });
+
+  it('throws a contract violation for partial publication and an ordinary callback throw otherwise', async () => {
+    const partial = admissionFixture();
+    await partial.operation.result;
+    partial.admit.mockImplementation((adUnitCode, bid) =>
+      partial.emitBidResponse({ ...bid, adUnitCode })
+    );
+
+    expect(() => partial.boundary.admitTrustedBid(preparedBid())).toThrowError(
+      expect.objectContaining({ code: 'prebid_partial_publication' })
+    );
+
+    const failed = admissionFixture();
+    await failed.operation.result;
+    const callbackFailure = new Error('fictional response callback failure');
+    failed.admit.mockImplementation(() => {
+      throw callbackFailure;
+    });
+    expect(() => failed.boundary.admitTrustedBid(preparedBid())).toThrow(callbackFailure);
+  });
+
+  it('rejects detached requests, duplicate admission, binding replacement, and late use', async () => {
+    const fixture = admissionFixture();
+    await fixture.operation.result;
+
+    expect(
+      fixture.boundary.admitTrustedBid(
+        recursivelyFreeze({ ...preparedBid(), adUnitCode: 'other-slot' })
+      )
+    ).toBe('not_admitted');
+    expect(fixture.boundary.admitTrustedBid(preparedBid())).toBe('admitted');
+    expect(() => fixture.boundary.admitTrustedBid(preparedBid())).toThrowError(
+      expect.objectContaining({ code: 'prebid_partial_publication' })
+    );
+
+    const auction = fixture.auctions[0] as { complete(): void };
+    auction.complete();
+    expect(fixture.boundary.admitTrustedBid(preparedBid())).toBe('not_admitted');
+
+    const replaced = admissionFixture();
+    await replaced.operation.result;
+    replaced.target.pbjs = createReadyPrebid().pbjs;
+    expect(() => replaced.boundary.admitTrustedBid(preparedBid())).toThrowError(
+      expect.objectContaining({ code: 'external_artifact_incompatible' })
+    );
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/build-prebid-external.test.mjs b/crates/trusted-server-js/lib/test/build-prebid-external.test.mjs
index f22717f79..8176cf91c 100644
--- a/crates/trusted-server-js/lib/test/build-prebid-external.test.mjs
+++ b/crates/trusted-server-js/lib/test/build-prebid-external.test.mjs
@@ -8,14 +8,46 @@ import path from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 import {
+  ARTIFACT_RELEASE_SENTINEL,
+  assertNoLegacyRuntimeFlags,
+  assertPurePrebidArtifact,
   deriveBundleMetadata,
   main,
   parseArgs,
   readAdapterBidderCodes,
+  readAdapterMetadata,
   renderIncludedUserIdModulesExport,
 } from '../build-prebid-external.mjs';
 
 describe('build-prebid-external metadata', () => {
+  it('rejects any legacy TSJS runtime flag before publishing an artifact', () => {
+    expect(() => assertNoLegacyRuntimeFlags('window.' + '__' + 'tsjs_prebid = {};')).toThrow(
+      /legacy TSJS runtime flag/
+    );
+    expect(() => assertNoLegacyRuntimeFlags('window.pbjs = { que: [] };')).not.toThrow();
+  });
+
+  it('rejects Trusted Server auction, render, and PUC behavior in the external Prebid artifact', () => {
+    for (const marker of [
+      'TS APS Top Mount Started',
+      'TS ADM Start',
+      'TS Render Owner Register',
+      '/_ts/auction',
+      'rendererReservationId',
+      'lifecycleTicket',
+      'tsjs.requestAds',
+    ]) {
+      expect(() => assertPurePrebidArtifact(`/* prebid */ ${marker}`)).toThrow(
+        /TS-owned auction or render behavior/
+      );
+    }
+    expect(() =>
+      assertPurePrebidArtifact(
+        'window.pbjs={que:[],cmd:[]};window.__prebidProtocol="Prebid Request";Object.defineProperty(window.pbjs,"__trustedServerArtifactV1",{});'
+      )
+    ).not.toThrow();
+  });
+
   it('derives filename, sha256, and SRI from exact bundle bytes', () => {
     const bundleBytes = Buffer.from('console.log("trusted prebid");\n', 'utf8');
     const sha256 = crypto.createHash('sha256').update(bundleBytes).digest('hex');
@@ -37,6 +69,10 @@ describe('build-prebid-external metadata', () => {
   it('derives registered bidder codes including aliases from prebid metadata', () => {
     // adfBidAdapter.js registers adf plus the adform/adformOpenRTB aliases.
     expect(readAdapterBidderCodes(['adf'])).toEqual(['adf', 'adform', 'adformOpenRTB']);
+    expect(readAdapterMetadata(['adf']).bidderAliases).toEqual([
+      { code: 'adform', moduleStem: 'adf' },
+      { code: 'adformOpenRTB', moduleStem: 'adf' },
+    ]);
   });
 
   it('maps a module file stem to its registered bidder code', () => {
@@ -70,10 +106,41 @@ describe('build-prebid-external metadata', () => {
       );
       const bundle = fs.readFileSync(path.join(outputDirectory, manifest.filename), 'utf8');
 
-      expect(manifest.userIdModules).toEqual(['pairIdSystem', 'lockrAIMIdSystem']);
+      expect(manifest).toMatchObject({
+        abi: 1,
+        prebidVersion: '10.26.0',
+        moduleStems: ['lockrAIMIdSystem', 'pairIdSystem', 'rubicon'],
+        bidderCodes: ['rubicon'],
+        bidderAliases: [],
+        userIdModules: [
+          {
+            moduleName: 'lockrAIMIdSystem',
+            configNames: ['lockrAIMId'],
+            eidSources: [],
+          },
+          {
+            moduleName: 'pairIdSystem',
+            configNames: ['pairId'],
+            eidSources: ['google.com'],
+          },
+        ],
+      });
+      expect(manifest.artifactReleaseId).toMatch(/^[0-9a-f]{64}$/);
+      expect(manifest.filename).toMatch(/^trusted-prebid-[0-9a-f]{64}\.js$/);
+      expect(manifest.sha256).toMatch(/^[0-9a-f]{64}$/);
+      expect(manifest.sri).toMatch(/^sha384-/);
+      expect(bundle).toContain('__trustedServerArtifactV1');
+      expect(bundle).toContain('getBidResponsesForAdUnitCode');
+      expect(bundle).toContain(manifest.artifactReleaseId);
+      expect(bundle).not.toContain(ARTIFACT_RELEASE_SENTINEL);
+      expect(bundle).not.toContain('__' + 'tsjs_');
       expect(manifest.bidderCodes).toEqual(['rubicon']);
-      expect(bundle).toContain('"pairIdSystem"');
-      expect(bundle).toContain('"lockrAIMIdSystem"');
+      expect(bundle.split(manifest.artifactReleaseId)).toHaveLength(2);
+      const normalized = bundle.replace(manifest.artifactReleaseId, ARTIFACT_RELEASE_SENTINEL);
+      expect(crypto.createHash('sha256').update(normalized).digest('hex')).toBe(
+        manifest.artifactReleaseId
+      );
+      expect(crypto.createHash('sha256').update(bundle).digest('hex')).toBe(manifest.sha256);
     } finally {
       fs.rmSync(outputDirectory, { recursive: true, force: true });
     }
@@ -84,4 +151,9 @@ describe('build-prebid-external metadata', () => {
 
     expect(parsed.outDir).toBe(path.resolve(process.cwd(), 'dist/prebid'));
   });
+
+  it('canonicalizes module order and rejects duplicate module names', () => {
+    expect(parseArgs(['--adapters', 'rubicon,adf']).adapters).toEqual(['adf', 'rubicon']);
+    expect(() => parseArgs(['--adapters', 'rubicon,rubicon'])).toThrow(/duplicates/);
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs b/crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs
new file mode 100644
index 000000000..88adc2934
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs
@@ -0,0 +1,834 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { TextDecoder, TextEncoder } from 'node:util';
+
+import { JSDOM } from 'jsdom';
+
+const dist = path.resolve(import.meta.dirname, '../../../dist');
+const manifest = JSON.parse(readFileSync(path.join(dist, 'tsjs-release-v1.json'), 'utf8'));
+const source = readFileSync(path.join(dist, 'tsjs-bootstrap.js'), 'utf8');
+const artifactById = new Map(manifest.artifacts.map((artifact) => [artifact.id, artifact]));
+const selectedSrc = `/static/tsjs=tsjs-first-display.min.js?m=0001&v=${'c'.repeat(64)}`;
+const selectedGptSrc = `/static/tsjs=tsjs-first-display.min.js?m=0081&v=${'c'.repeat(64)}`;
+const runtimeSrc = `/static/tsjs=tsjs-unified.min.js?v=${'d'.repeat(64)}`;
+const runtimeBody = ['core', 'render_runtime']
+  .map((id) => readFileSync(path.join(dist, artifactById.get(id).file), 'utf8'))
+  .join(';\n');
+const EMPTY_INTEGRATION_CONFIGS = Object.freeze({ version: 1, entries: Object.freeze([]) });
+const EMPTY_INTEGRATION_CONFIG_DIGEST = createHash('sha256')
+  .update(JSON.stringify(EMPTY_INTEGRATION_CONFIGS))
+  .digest('hex');
+const plain = (value) => JSON.parse(JSON.stringify(value));
+const setCurrentScriptByDom = new WeakMap();
+
+function createDocument(firstDisplaySrc = selectedSrc) {
+  const dom = new JSDOM(
+    `<!doctype html><head></head><body><script id="trustedserver-js" src="${firstDisplaySrc}"></script></body>`,
+    { runScripts: 'outside-only', url: 'https://publisher.example/page' }
+  );
+  dom.window.TextEncoder = TextEncoder;
+  dom.window.TextDecoder = TextDecoder;
+  Object.defineProperty(dom.window.performance, 'mark', {
+    configurable: true,
+    value: () => undefined,
+  });
+  const animationFrames = [];
+  Object.defineProperty(dom.window, 'requestAnimationFrame', {
+    configurable: true,
+    value: (callback) => {
+      animationFrames.push(callback);
+      return animationFrames.length;
+    },
+  });
+  const selected = dom.window.document.querySelector('script#trustedserver-js');
+  let currentScript = selected;
+  Object.defineProperty(dom.window.Document.prototype, 'currentScript', {
+    configurable: true,
+    get: () => currentScript,
+  });
+  setCurrentScriptByDom.set(dom, (script) => {
+    currentScript = script;
+  });
+  return {
+    animationFrames,
+    dom,
+    selected,
+    setCurrentScript: (script) => {
+      currentScript = script;
+    },
+  };
+}
+
+function boot() {
+  return {
+    abi: 1,
+    releaseId: manifest.releaseId,
+    manifest: {
+      version: 1,
+      releaseId: manifest.releaseId,
+      firstDisplay: { src: selectedSrc, slices: ['first_display'] },
+      runtimeSrc,
+      integrations: [],
+    },
+    auctionProjection: {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'initial',
+        results: [{ slot: 'slot-1', outcome: 'no_bid' }],
+      },
+      slots: [
+        {
+          slot: 'slot-1',
+          gamUnitPath: '/123/slot-1',
+          divId: 'slot-1',
+          formats: [[300, 250]],
+          targeting: {},
+        },
+      ],
+      bids: [],
+    },
+    integrations: EMPTY_INTEGRATION_CONFIGS,
+    creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+    diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+  };
+}
+
+function outline() {
+  return {
+    version: 1,
+    releaseId: manifest.releaseId,
+    generation: 1,
+    projectionDigest: 'e'.repeat(64),
+    integrationConfigDigest: EMPTY_INTEGRATION_CONFIG_DIGEST,
+    slices: ['first_display'],
+    slotCount: 1,
+    outcomeCount: 1,
+    capabilities: [],
+    objectKinds: [],
+  };
+}
+
+function selectGpt(bootValue, outlineValue) {
+  bootValue.manifest.firstDisplay = {
+    src: selectedGptSrc,
+    slices: ['first_display', 'gpt_initial'],
+  };
+  outlineValue.slices = ['first_display', 'gpt_initial'];
+}
+
+function selectInitialSlice(bootValue, outlineValue, id, config) {
+  const firstDisplay = manifest.artifacts.filter((artifact) =>
+    ['first_display_base', 'first_display_slice'].includes(artifact.role)
+  );
+  const index = firstDisplay.findIndex((artifact) => artifact.id === id);
+  assert.ok(index > 0, `missing first-display slice ${id}`);
+  const mask = (1 | (1 << index)).toString(16).padStart(4, '0');
+  const artifact = artifactById.get(id);
+  const body = readFileSync(path.join(dist, artifact.file), 'utf8');
+  const hash = createHash('sha256').update(body).digest('hex');
+  const src = `/static/tsjs=tsjs-first-display.min.js?m=${mask}&v=${hash}`;
+  bootValue.manifest.firstDisplay = { src, slices: ['first_display', id] };
+  const product = id.slice(0, -'_initial'.length);
+  bootValue.integrations = { version: 1, entries: [{ id: product, config }] };
+  outlineValue.slices = ['first_display', id];
+  return { body, src };
+}
+
+function transport(bootValue = boot(), outlineValue = outline()) {
+  const integrity = {
+    version: 1,
+    projectionDigest: createHash('sha256')
+      .update(JSON.stringify(bootValue.auctionProjection))
+      .digest('hex'),
+    integrationConfigDigest: createHash('sha256')
+      .update(JSON.stringify(bootValue.integrations))
+      .digest('hex'),
+  };
+  if (outlineValue) {
+    outlineValue.projectionDigest = integrity.projectionDigest;
+    outlineValue.integrationConfigDigest = integrity.integrationConfigDigest;
+  }
+  return { version: 1, boot: bootValue, integrity, outline: outlineValue };
+}
+
+function evaluateTransport(dom, value) {
+  dom.window.eval(
+    `const __TSJS_SERVER_BOOT_TRANSPORT_V1__=${JSON.stringify(JSON.stringify(value))};${source}`
+  );
+  setCurrentScriptByDom.get(dom)?.(null);
+}
+
+function evaluateWithInput(dom) {
+  evaluateTransport(dom, transport());
+}
+
+test('generated bootstrap bytes are stamped exactly once and expose no callable global', () => {
+  assert.equal(source.includes('__TSJS_RELEASE_ID_SENTINEL_V1__'), false);
+  assert.equal(source.split(manifest.releaseId).length - 1, 1);
+  const { dom } = createDocument();
+  dom.window.tsjs = {};
+
+  evaluateWithInput(dom);
+
+  assert.equal(dom.window.tsjs_bootstrap, undefined);
+  assert.equal(dom.window.tsjs.boot.releaseId, manifest.releaseId);
+  assert.equal(Object.hasOwn(dom.window.tsjs, '_registerFirstDisplay'), false);
+  dom.window.close();
+});
+
+test('generated bootstrap seals the TSJS namespace handoff without mutating currentScript', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  const target = {};
+  dom.window.tsjs = target;
+  selected.src = runtimeSrc;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+  directBoot.manifest.integrations = [{ id: 'render_runtime', phase: 'takeover' }];
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(null);
+
+  assert.equal(Object.getOwnPropertyDescriptor(dom.window.document, 'currentScript'), undefined);
+  const descriptor = Object.getOwnPropertyDescriptor(dom.window, 'tsjs');
+  assert.equal(descriptor?.configurable, false);
+  assert.equal(descriptor?.enumerable, true);
+  assert.equal(typeof descriptor?.get, 'function');
+  assert.throws(() =>
+    Object.defineProperty(dom.window, 'tsjs', {
+      configurable: true,
+      value: { publisher: 'replacement' },
+    })
+  );
+  assert.equal(dom.window.tsjs, target);
+  assert.equal(typeof selected._claimRuntimeV1, 'function');
+  assert.equal(selected._claimRuntimeV1(selected), undefined);
+  dom.window.close();
+});
+
+test('generated bootstrap leaves the namespace untouched without exact server input', () => {
+  for (const input of ['', 'const __TSJS_SERVER_BOOT_TRANSPORT_V1__={};']) {
+    const { dom } = createDocument();
+    const target = { publisher: 'retained' };
+    dom.window.tsjs = target;
+
+    dom.window.eval(`${input}${source}`);
+
+    assert.equal(dom.window.tsjs, target);
+    assert.deepEqual(Object.keys(target), ['publisher']);
+    dom.window.close();
+  }
+});
+
+test('generated bootstrap transfers the direct persistent watchdog to the selected runtime', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  selected.src = runtimeSrc;
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(selected);
+
+  const claim = selected._claimRuntimeV1;
+  const originalQuerySelectorAll = dom.window.document.querySelectorAll;
+  let nestedResult;
+  let nestedCancelCalls = 0;
+  let reentered = false;
+  dom.window.document.querySelectorAll = function (...args) {
+    if (!reentered) {
+      reentered = true;
+      nestedResult = claim(selected);
+    }
+    return Reflect.apply(originalQuerySelectorAll, this, args);
+  };
+  const cancel = () => assert.fail('committed direct runtime must not be cancelled');
+  const claimed = claim(selected);
+  assert.equal(nestedResult, undefined);
+  assert.equal(nestedCancelCalls, 0);
+  assert.equal(claimed.mode, 'direct');
+  const complete = claimed.bind(cancel);
+  assert.equal(typeof complete, 'function');
+  complete('kernel');
+  assert.equal(selected._claimRuntimeV1(selected), undefined);
+  assert.equal(Object.hasOwn(target, '_internal'), false);
+  assert.equal(target.boot.manifest.firstDisplay, null);
+  dom.window.close();
+});
+
+test('generated runtime reserves the node claim before mutable realm initializers can reenter', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  selected.src = runtimeSrc;
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+  directBoot.manifest.integrations = [{ id: 'render_runtime', phase: 'takeover' }];
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(selected);
+  const claim = selected._claimRuntimeV1;
+  const nativeGetOwnPropertyDescriptor = dom.window.Object.getOwnPropertyDescriptor;
+  const nativeReflectApply = dom.window.Reflect.apply;
+  let descriptorReentry;
+  let applyReentry;
+  dom.window.Object.getOwnPropertyDescriptor = function (...args) {
+    descriptorReentry ??= claim(selected);
+    return nativeGetOwnPropertyDescriptor(...args);
+  };
+  dom.window.Reflect.apply = function (targetFunction, thisArgument, argumentsList) {
+    applyReentry ??= claim(selected);
+    return nativeReflectApply(targetFunction, thisArgument, argumentsList);
+  };
+
+  dom.window.eval(runtimeBody);
+
+  assert.equal(descriptorReentry, undefined);
+  assert.equal(applyReentry, undefined);
+  assert.equal(target._internal.state, 'kernel');
+  dom.window.close();
+});
+
+test('generated takeover claim reserves authentication against publisher reentry', () => {
+  const { animationFrames, dom, setCurrentScript } = createDocument();
+  const target = { que: [] };
+  dom.window.tsjs = target;
+
+  evaluateWithInput(dom);
+  const nativeFreeze = dom.window.Object.freeze;
+  const nativeDefineProperty = dom.window.Object.defineProperty;
+  let capabilityRecordExposed = false;
+  let claimDescriptorExposed = false;
+  dom.window.Object.freeze = function (value) {
+    if (
+      value &&
+      typeof value === 'object' &&
+      Object.prototype.hasOwnProperty.call(value, 'bind') &&
+      Object.prototype.hasOwnProperty.call(value, 'complete')
+    ) {
+      capabilityRecordExposed = true;
+    }
+    return nativeFreeze(value);
+  };
+  dom.window.Object.defineProperty = function (owner, key, descriptor) {
+    if (key === '_claimRuntimeV1' && typeof descriptor?.value === 'function') {
+      claimDescriptorExposed = true;
+    }
+    return nativeDefineProperty(owner, key, descriptor);
+  };
+  while (animationFrames.length > 0) animationFrames.shift()(dom.window.performance.now());
+
+  const runtime = dom.window.document.querySelector('script#trustedserver-js-runtime');
+  const claim = runtime._claimRuntimeV1;
+  assert.equal(typeof claim, 'function');
+  setCurrentScript(runtime);
+  const originalQuerySelectorAll = dom.window.document.querySelectorAll;
+  let nestedResult;
+  let maliciousFinalizeCalls = 0;
+  let reentered = false;
+  dom.window.document.querySelectorAll = function (...args) {
+    if (!reentered) {
+      reentered = true;
+      nestedResult = claim(runtime);
+    }
+    return Reflect.apply(originalQuerySelectorAll, this, args);
+  };
+  const claimed = claim(runtime);
+  assert.equal(claimed.mode, 'takeover');
+  let outerFinalizeCalls = 0;
+  assert.throws(() =>
+    claimed.bind(() => {
+      outerFinalizeCalls += 1;
+      return undefined;
+    })
+  );
+  assert.equal(nestedResult, undefined);
+  assert.equal(maliciousFinalizeCalls, 0);
+  assert.equal(outerFinalizeCalls, 1);
+  assert.equal(capabilityRecordExposed, false);
+  assert.equal(claimDescriptorExposed, false);
+  dom.window.close();
+});
+
+test('generated bootstrap classifies a rejected claimed boot as an ABI mismatch', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  selected.src = runtimeSrc;
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(selected);
+
+  const claim = selected._claimRuntimeV1;
+  assert.equal(typeof claim, 'function');
+  const claimed = claim(selected);
+  assert.equal(claimed.boot, target.boot);
+  claimed.complete('abi_mismatch');
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(Object.getOwnPropertyDescriptor(target, '_internal')?.value)),
+    {
+      state: 'fallback',
+      releaseId: manifest.releaseId,
+      reason: 'abi_mismatch',
+      initialDisplayCommitted: false,
+    }
+  );
+  dom.window.close();
+});
+
+test('generated bootstrap reserves the boot claim across reentrant DOM authentication', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  selected.src = runtimeSrc;
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(selected);
+
+  const claim = selected._claimRuntimeV1;
+  const querySelectorAll = dom.window.document.querySelectorAll;
+  let nested;
+  let reentered = false;
+  Object.defineProperty(dom.window.document, 'querySelectorAll', {
+    configurable: true,
+    value(selector) {
+      if (!reentered) {
+        reentered = true;
+        nested = claim(selected);
+      }
+      return Reflect.apply(querySelectorAll, this, [selector]);
+    },
+  });
+
+  const claimed = claim(selected);
+  nested?.complete('kernel');
+  claimed.complete('abi_mismatch');
+
+  assert.equal(nested, undefined);
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(Object.getOwnPropertyDescriptor(target, '_internal')?.value)),
+    {
+      state: 'fallback',
+      releaseId: manifest.releaseId,
+      reason: 'abi_mismatch',
+      initialDisplayCommitted: false,
+    }
+  );
+  dom.window.close();
+});
+
+test('generated bootstrap completes a claimed boot without a reentrant realm callback', () => {
+  const { dom, selected, setCurrentScript } = createDocument();
+  selected.src = runtimeSrc;
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  const directBoot = boot();
+  directBoot.manifest.firstDisplay = null;
+
+  evaluateTransport(dom, transport(directBoot, null));
+  setCurrentScript(selected);
+
+  const claimed = selected._claimRuntimeV1(selected);
+  const includes = dom.window.Array.prototype.includes;
+  let reentered = false;
+  Object.defineProperty(dom.window.Array.prototype, 'includes', {
+    configurable: true,
+    value(value, fromIndex) {
+      if (!reentered) {
+        reentered = true;
+        claimed.complete('kernel');
+      }
+      return Reflect.apply(includes, this, [value, fromIndex]);
+    },
+    writable: true,
+  });
+
+  assert.doesNotThrow(() => claimed.complete('abi_mismatch'));
+  assert.equal(reentered, false);
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(Object.getOwnPropertyDescriptor(target, '_internal')?.value)),
+    {
+      state: 'fallback',
+      releaseId: manifest.releaseId,
+      reason: 'abi_mismatch',
+      initialDisplayCommitted: false,
+    }
+  );
+  dom.window.close();
+});
+
+test('generated base-only takeover failure leaves terminal fallback ownership with bootstrap', () => {
+  const { animationFrames, dom, setCurrentScript } = createDocument();
+  const target = { que: [] };
+  dom.window.tsjs = target;
+  evaluateWithInput(dom);
+
+  const accepted = dom.window.document.createElement('iframe');
+  accepted.id = 'accepted-first-display';
+  dom.window.document.body.append(accepted);
+  while (animationFrames.length > 0) animationFrames.shift()(dom.window.performance.now());
+  const runtime = dom.window.document.querySelector('script#trustedserver-js-runtime');
+  assert.ok(runtime, 'the bootstrap-owned base must reach protected paint without a marker');
+  setCurrentScript(runtime);
+  const claimed = runtime._claimRuntimeV1(runtime);
+  assert.equal(claimed.boot, target.boot);
+  claimed.complete('bundle_partial');
+
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(Object.getOwnPropertyDescriptor(target, '_internal')?.value)),
+    {
+      state: 'fallback',
+      releaseId: manifest.releaseId,
+      reason: 'bundle_partial',
+      initialDisplayCommitted: false,
+    }
+  );
+  assert.equal(target.boot.manifest.firstDisplay.src, selectedSrc);
+  assert.equal(accepted.isConnected, true);
+  dom.window.close();
+});
+
+test('generated bootstrap admits the exact post-paint runtime through one private Trusted Types policy', () => {
+  const { animationFrames, dom, setCurrentScript } = createDocument();
+  const target = { que: [] };
+  const policies = [];
+  Object.defineProperty(dom.window, 'trustedTypes', {
+    configurable: true,
+    value: {
+      createPolicy(name, rules) {
+        assert.equal(name, 'trusted-server#tsjs-v1');
+        if (policies.length !== 0) throw new TypeError('duplicate policy');
+        policies.push({ name, rules });
+        return { createScriptURL: rules.createScriptURL };
+      },
+    },
+  });
+  dom.window.tsjs = target;
+
+  evaluateWithInput(dom);
+  while (animationFrames.length > 0) animationFrames.shift()(dom.window.performance.now());
+
+  assert.equal(policies.length, 1);
+  assert.equal(policies[0].name, 'trusted-server#tsjs-v1');
+  assert.throws(() => policies[0].rules.createScriptURL('https://attacker.example/core.js'));
+  const runtime = dom.window.document.querySelector('script#trustedserver-js-runtime');
+  assert.equal(runtime?.src, new URL(runtimeSrc, dom.window.location.origin).href);
+  assert.equal(Object.hasOwn(runtime, '_tsjsTrustedTypesPolicyV1'), false);
+  const takeover = runtime._claimRuntimeV1;
+  assert.equal(typeof takeover, 'function');
+  const attacker = dom.window.document.createElement('script');
+  attacker.id = 'publisher-script';
+  dom.window.document.head.append(attacker);
+  setCurrentScript(attacker);
+  let finalizeCalls = 0;
+  assert.equal(takeover(runtime), undefined);
+  assert.equal(finalizeCalls, 0);
+  assert.equal(target._claimRuntimeV1, undefined);
+  assert.equal(runtime._claimRuntimeV1, takeover);
+  setCurrentScript(runtime);
+  runtime._claimRuntimeV1(runtime).complete('bundle_partial');
+  dom.window.close();
+});
+
+test('generated bootstrap stops optional activation after a component installer fails', () => {
+  const { dom, selected, setCurrentScript } = createDocument(selectedGptSrc);
+  const target = { que: [] };
+  const events = [];
+  let bindingKeys;
+  const bootValue = boot();
+  const outlineValue = outline();
+  selectGpt(bootValue, outlineValue);
+  bootValue.integrations = { version: 1, entries: [{ id: 'gpt', config: {} }] };
+  dom.window.tsjs = target;
+  evaluateTransport(dom, transport(bootValue, outlineValue));
+  setCurrentScript(selected);
+
+  const gpt = Object.freeze([
+    1,
+    'gpt_initial',
+    manifest.releaseId,
+    (bindings) => {
+      bindingKeys = Reflect.ownKeys(bindings);
+      events.push('install-gpt');
+      throw new TypeError('invalid generated slice');
+    },
+  ]);
+
+  assert.equal(target._registerFirstDisplay.call(target, gpt, selected), false);
+  assert.deepEqual(bindingKeys, ['browser', 'observe', 'register']);
+  assert.deepEqual(events, ['install-gpt']);
+  assert.equal(Object.getOwnPropertyDescriptor(target, '_internal')?.value.reason, 'abi_mismatch');
+  dom.window.close();
+});
+
+test('generated first-display registration reserves authentication against DOM reentry', () => {
+  const { dom, selected, setCurrentScript } = createDocument(selectedGptSrc);
+  const target = { que: [] };
+  const bootValue = boot();
+  const outlineValue = outline();
+  selectGpt(bootValue, outlineValue);
+  bootValue.integrations = { version: 1, entries: [{ id: 'gpt', config: {} }] };
+  dom.window.tsjs = target;
+  evaluateTransport(dom, transport(bootValue, outlineValue));
+  setCurrentScript(selected);
+
+  const maliciousInstall = () => assert.fail('a reentrant installer must never activate');
+  let genuineInstallCalls = 0;
+  const genuineInstall = () => {
+    genuineInstallCalls += 1;
+  };
+  const originalQuerySelectorAll = dom.window.document.querySelectorAll;
+  let nestedResult;
+  let reentered = false;
+  dom.window.document.querySelectorAll = function (...args) {
+    if (!reentered) {
+      reentered = true;
+      nestedResult = target._registerFirstDisplay.call(
+        target,
+        Object.freeze([1, 'gpt_initial', manifest.releaseId, maliciousInstall]),
+        selected
+      );
+    }
+    return Reflect.apply(originalQuerySelectorAll, this, args);
+  };
+
+  const accepted = target._registerFirstDisplay.call(
+    target,
+    Object.freeze([1, 'gpt_initial', manifest.releaseId, genuineInstall]),
+    selected
+  );
+
+  assert.equal(nestedResult, false);
+  assert.equal(accepted, false);
+  assert.equal(genuineInstallCalls, 1);
+  assert.equal(Object.getOwnPropertyDescriptor(target, '_internal')?.value.reason, 'abi_mismatch');
+  dom.window.close();
+});
+
+test('generated optional slices receive their exact parser-time browser bindings', () => {
+  const fixtures = [
+    ['datadome_initial', {}],
+    ['didomi_initial', { proxyPath: '/integrations/didomi/consent/' }],
+    ['google_tag_manager_initial', {}],
+    ['lockr_initial', {}],
+    ['osano_initial', {}],
+    ['permutive_initial', {}],
+    ['sourcepoint_initial', { rewriteSdk: true }],
+    ['testlight_initial', {}],
+  ];
+  for (const [id, config] of fixtures) {
+    const bootValue = boot();
+    const outlineValue = outline();
+    const { body, src } = selectInitialSlice(bootValue, outlineValue, id, config);
+    const { dom, selected, setCurrentScript } = createDocument(src);
+    const callback = () => undefined;
+    if (id === 'lockr_initial') dom.window.identityLockr = { host: 'vendor.example' };
+    if (id === 'osano_initial') {
+      dom.window.__uspapi = (_command, _version, complete) => complete({ uspString: '1YN-' }, true);
+      dom.window.__gpp = (_command, complete) =>
+        complete({ gppString: 'DBABLA~BVQqAAAAAgA.QA', applicableSections: [7] }, true);
+      dom.window.__tcfapi = (_command, _version, complete) =>
+        complete(
+          {
+            tcString:
+              'COwK6gaOwK6gaFmAAAENAPCAAAAAAAAAAAAAAAAAAAAA.IFMsv_Z_G____bvQXQ1f9eY1f9_z_q7ff_3_3-_-3dV1v9zLv9____39nP___9v-_3_f__9P',
+          },
+          true
+        );
+    }
+    if (id === 'permutive_initial') {
+      dom.window.permutive = {
+        config: {
+          apiHost: 'api.vendor.example',
+          apiProtocol: 'https',
+          cdnBaseUrl: 'cdn.vendor.example',
+          cdnProtocol: 'https',
+          secureSignalsApiHost: 'signals.vendor.example',
+          segmentSyncApiHost: 'sync.vendor.example',
+        },
+      };
+      dom.window.localStorage.setItem(
+        'permutive-app',
+        JSON.stringify({ core: { cohorts: { all: ['one', 2] } } })
+      );
+    }
+    if (id === 'sourcepoint_initial') {
+      dom.window.localStorage.setItem(
+        '_sp_user_consent_test',
+        JSON.stringify({ gppData: { gppString: 'DBABLA', applicableSections: [7] } })
+      );
+    }
+    if (id === 'testlight_initial') dom.window.testlight = { que: [callback] };
+    dom.window.tsjs = { que: [] };
+
+    evaluateTransport(dom, transport(bootValue, outlineValue));
+    setCurrentScript(selected);
+    dom.window.eval(body);
+
+    assert.equal(
+      Object.getOwnPropertyDescriptor(dom.window.tsjs, '_internal'),
+      undefined,
+      `${id} must not force fallback`
+    );
+    if (id === 'datadome_initial' || id === 'google_tag_manager_initial') {
+      const script = dom.window.document.createElement('script');
+      script.src =
+        id === 'datadome_initial'
+          ? 'https://js.datadome.co/tags.js'
+          : 'https://www.googletagmanager.com/gtm.js?id=GTM-TEST';
+      dom.window.document.head.appendChild(script);
+      assert.match(script.src, /\/integrations\/(?:datadome|google_tag_manager)\//);
+    }
+    if (id === 'didomi_initial') {
+      assert.equal(
+        dom.window.didomiConfig.sdkPath,
+        'https://publisher.example/integrations/didomi/consent/'
+      );
+    }
+    if (id === 'lockr_initial') {
+      assert.equal(
+        dom.window.identityLockr.host,
+        'https://publisher.example/integrations/lockr/api'
+      );
+    }
+    if (id === 'permutive_initial') {
+      assert.equal(
+        dom.window.permutive.config.apiHost,
+        'publisher.example/integrations/permutive/api'
+      );
+    }
+    if (id === 'sourcepoint_initial') assert.match(dom.window.document.cookie, /__gpp=DBABLA/);
+    if (id === 'testlight_initial') assert.ok(dom.window.tsjs.que.includes(callback));
+    dom.window.close();
+  }
+});
+
+test('generated bootstrap commits one non-rendering terminal shell after registration failure', async () => {
+  const { dom, selected, setCurrentScript } = createDocument(selectedGptSrc);
+  const drained = [];
+  const target = {
+    que: [
+      function () {
+        drained.push(this);
+      },
+    ],
+  };
+  dom.window.tsjs = target;
+
+  const bootValue = boot();
+  const outlineValue = outline();
+  selectGpt(bootValue, outlineValue);
+  evaluateTransport(dom, transport(bootValue, outlineValue));
+  setCurrentScript(selected);
+  assert.equal(dom.window.tsjs._registerFirstDisplay.call(target, {}, selected), false);
+
+  assert.deepEqual(Object.keys(target).sort(), [
+    '_registerIntegration',
+    'addAdUnits',
+    'boot',
+    'log',
+    'que',
+    'releaseId',
+    'requestAds',
+    'version',
+  ]);
+  assert.deepEqual(
+    JSON.parse(JSON.stringify(Object.getOwnPropertyDescriptor(target, '_internal')?.value)),
+    {
+      state: 'fallback',
+      releaseId: manifest.releaseId,
+      reason: 'abi_mismatch',
+      initialDisplayCommitted: false,
+    }
+  );
+  assert.equal(Object.getOwnPropertyDescriptor(target, '_internal')?.enumerable, false);
+  assert.equal(target._registerIntegration(), false);
+  assert.equal(drained.length, 1);
+  assert.equal(drained[0], target);
+  assert.equal(Object.isFrozen(target.que), true);
+  assert.equal(
+    target.que.push(() => drained.push('late')),
+    0
+  );
+  assert.deepEqual(drained, [target, 'late']);
+  const malformedUnit = dom.window.eval("({code:'',mediaTypes:{}})");
+  assert.throws(() => target.addAdUnits(malformedUnit), {
+    name: 'TsjsUnavailableError',
+    code: 'runtime_unavailable',
+    releaseId: manifest.releaseId,
+    reason: 'abi_mismatch',
+  });
+  const validUnit = dom.window.eval(
+    "({code:'programmatic',mediaTypes:{banner:{sizes:[[300,250]]}}})"
+  );
+  assert.throws(() => target.addAdUnits(validUnit), {
+    name: 'TsjsUnavailableError',
+    code: 'runtime_unavailable',
+    releaseId: manifest.releaseId,
+    reason: 'abi_mismatch',
+  });
+  await assert.rejects(target.requestAds(), {
+    name: 'TsjsUnavailableError',
+    code: 'runtime_unavailable',
+    releaseId: manifest.releaseId,
+    reason: 'abi_mismatch',
+  });
+  const explicitOptions = dom.window.eval("({slots:['slot-1']})");
+  await assert.rejects(target.requestAds(explicitOptions), {
+    name: 'TsjsUnavailableError',
+    code: 'runtime_unavailable',
+    releaseId: manifest.releaseId,
+    reason: 'abi_mismatch',
+  });
+  const controller = new dom.window.AbortController();
+  controller.abort();
+  const abortedOptions = dom.window.eval("({slots:['slot-1']})");
+  abortedOptions.signal = controller.signal;
+  await assert.rejects(target.requestAds(abortedOptions), {
+    name: 'TsjsUnavailableError',
+    code: 'runtime_unavailable',
+    releaseId: manifest.releaseId,
+    reason: 'abi_mismatch',
+  });
+  assert.deepEqual(plain(target.boot.auctionProjection), {
+    version: 1,
+    auction: { version: 1, auctionId: 'fallback', results: [] },
+    slots: [],
+    bids: [],
+  });
+  assert.deepEqual(plain(target.boot.integrations), { version: 1, entries: [] });
+  dom.window.close();
+});
+
+test('generated bootstrap does not overwrite a conflicting non-configurable namespace field', () => {
+  const { dom, selected, setCurrentScript } = createDocument(selectedGptSrc);
+  const target = { que: [] };
+  const publisherApi = () => undefined;
+  Object.defineProperty(target, 'publisherApi', {
+    configurable: false,
+    enumerable: true,
+    value: publisherApi,
+    writable: false,
+  });
+  dom.window.tsjs = target;
+
+  const bootValue = boot();
+  const outlineValue = outline();
+  selectGpt(bootValue, outlineValue);
+  evaluateTransport(dom, transport(bootValue, outlineValue));
+  setCurrentScript(selected);
+  assert.equal(dom.window.tsjs._registerFirstDisplay.call(target, {}, selected), false);
+
+  assert.equal(target.publisherApi, publisherApi);
+  assert.equal(Object.hasOwn(target, 'releaseId'), false);
+  assert.equal(Object.hasOwn(target, '_internal'), false);
+  dom.window.close();
+});
diff --git a/crates/trusted-server-js/lib/test/build/release-v1.test.mjs b/crates/trusted-server-js/lib/test/build/release-v1.test.mjs
new file mode 100644
index 000000000..3a83c4bbe
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/build/release-v1.test.mjs
@@ -0,0 +1,2362 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { JSDOM } from 'jsdom';
+
+import {
+  RELEASE_SENTINEL,
+  computeReleaseId,
+  stampRelease,
+  validateStampedRelease,
+} from '../../scripts/release-v1.mjs';
+import {
+  checkBundleBudgets,
+  findTakeoverDeferredSourceViolations,
+  validateSemanticBundleSets,
+} from '../../scripts/check-bundle-budgets.mjs';
+import * as bundleBudgets from '../../scripts/check-bundle-budgets.mjs';
+import * as bundleMetrics from '../../scripts/bundle-metrics.mjs';
+import {
+  findCutoverTextViolations,
+  findVendorBoundaryViolations,
+  generatedTsjsArtifactFiles,
+} from '../../scripts/check-hard-cutover-absence.mjs';
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const libDirectory = path.resolve(testDirectory, '../..');
+const repositoryRoot = path.resolve(libDirectory, '../../..');
+const bundle = (id, logical, role = 'integration', phase = 'takeover', trigger = '') => ({
+  id,
+  role,
+  phase,
+  trigger,
+  bytes: Buffer.from(`${logical}${RELEASE_SENTINEL}`),
+});
+
+const EXPECTED_RELEASE_BUNDLE_ORDER = [
+  'bootstrap',
+  'first_display',
+  'render_owner_initial',
+  'aps_initial',
+  'creative_initial',
+  'datadome_initial',
+  'didomi_initial',
+  'google_tag_manager_initial',
+  'gpt_initial',
+  'lockr_initial',
+  'osano_initial',
+  'permutive_initial',
+  'sourcepoint_initial',
+  'prebid_initial',
+  'testlight_initial',
+  'core',
+  'render_runtime',
+  'aps',
+  'creative',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'gpt_diagnostics',
+  'lockr',
+  'osano_consent',
+  'permutive_context',
+  'sourcepoint_consent',
+  'prebid',
+  'testlight',
+  'diagnostics_presentation',
+  'gpt_later',
+  'osano_lifecycle',
+  'permutive_lifecycle',
+  'prebid_later',
+  'sourcepoint_lifecycle',
+];
+
+const TAKEOVER_CONSENT_ARTIFACTS = Object.freeze([
+  Object.freeze({
+    id: 'osano_consent',
+    capability: 'osano_consent.v1',
+  }),
+  Object.freeze({
+    id: 'permutive_context',
+    capability: 'permutive_context.v1',
+  }),
+  Object.freeze({
+    id: 'sourcepoint_consent',
+    capability: 'sourcepoint_consent.v1',
+  }),
+]);
+
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
+  if (value !== null && typeof value === 'object') {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function readBuildEvidence() {
+  return {
+    baseline: JSON.parse(
+      fs.readFileSync(
+        path.join(libDirectory, 'test/fixtures/performance/aps-tsjs-prechange.json'),
+        'utf8'
+      )
+    ),
+    catalog: JSON.parse(
+      fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-catalog-v1.json'), 'utf8')
+    ),
+    metrics: JSON.parse(
+      fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+    ),
+    release: JSON.parse(
+      fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+    ),
+  };
+}
+
+function buildStructurallyValidDescendant(mutateEvidence = () => {}) {
+  const evidence = readBuildEvidence();
+  const distDirectory = path.resolve(libDirectory, '../dist');
+  const logicalContents = new Map(
+    evidence.release.artifacts.map(({ file }) => {
+      const source = fs.readFileSync(path.join(distDirectory, file), 'utf8');
+      return [file, Buffer.from(source.replace(evidence.release.releaseId, RELEASE_SENTINEL))];
+    })
+  );
+  logicalContents.set(
+    'tsjs-core.js',
+    Buffer.concat([
+      logicalContents.get('tsjs-core.js'),
+      Buffer.from('\n/* descendant release */\n'),
+    ])
+  );
+  mutateEvidence(evidence);
+
+  const releaseArtifacts = evidence.release.artifacts.map((artifact) => ({
+    id: artifact.id,
+    role: artifact.role,
+    phase: artifact.phase ?? '',
+    trigger: artifact.trigger ?? '',
+    bytes: logicalContents.get(artifact.file),
+  }));
+  const releaseId = computeReleaseId(releaseArtifacts);
+  const currentArtifactContents = new Map(
+    evidence.release.artifacts.map(({ file }) => [
+      file,
+      Buffer.from(stampRelease(logicalContents.get(file), releaseId)),
+    ])
+  );
+
+  evidence.release.releaseId = releaseId;
+  for (const artifact of evidence.release.artifacts) {
+    const bytes = currentArtifactContents.get(artifact.file);
+    artifact.bytes = bytes.byteLength;
+    artifact.hash = createHash('sha256').update(bytes).digest('hex');
+  }
+  Object.assign(
+    evidence.metrics.bootstrap,
+    bundleMetrics.measureBytes(currentArtifactContents.get('tsjs-bootstrap.js'))
+  );
+  const productionArtifacts = evidence.release.artifacts.filter(({ role }) => role !== 'bootstrap');
+  for (const [index, module] of evidence.metrics.modules.entries()) {
+    const artifact = productionArtifacts[index];
+    module.rawBytes = artifact.bytes;
+    module.sha256 = artifact.hash;
+  }
+  const setFiles = bundleMetrics.deriveInventorySetFiles(
+    evidence.release.artifacts,
+    evidence.catalog.modules
+  );
+  for (const [setName, files] of Object.entries(setFiles)) {
+    evidence.metrics.sets[setName] = bundleMetrics.measureBundleSet(files, currentArtifactContents);
+  }
+  return { ...evidence, currentArtifactContents };
+}
+
+function executeGeneratedArtifact(window, file, registrations, { preserveTarget = false } = {}) {
+  const target = preserveTarget
+    ? window.tsjs
+    : Object.freeze({
+        _registerIntegration: (registration) => {
+          registrations.push(registration);
+          return true;
+        },
+      });
+  if (!preserveTarget) {
+    Object.defineProperty(window, 'tsjs', {
+      configurable: true,
+      value: target,
+    });
+  }
+  window.eval(fs.readFileSync(path.resolve(libDirectory, '../dist', file), 'utf8'));
+}
+
+test('generated release inventory pins the server bundle order', () => {
+  const manifest = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+
+  assert.deepEqual(
+    manifest.artifacts.map(({ id }) => id),
+    EXPECTED_RELEASE_BUNDLE_ORDER
+  );
+  assert.equal(manifest.artifacts.filter(({ role }) => role === 'bootstrap').length, 1);
+  assert.equal(manifest.artifacts.filter(({ role }) => role === 'first_display_base').length, 1);
+  assert.equal(manifest.artifacts.filter(({ role }) => role === 'first_display_slice').length, 13);
+  assert.equal(manifest.artifacts.filter(({ role }) => role === 'core').length, 1);
+  assert.equal(manifest.artifacts.filter(({ role }) => role === 'integration').length, 20);
+  for (const artifact of manifest.artifacts) {
+    assert.deepEqual(Object.keys(artifact), [
+      'id',
+      'role',
+      'phase',
+      'trigger',
+      'inputs',
+      'outputs',
+      'file',
+      'bytes',
+      'hash',
+    ]);
+  }
+});
+
+test('release id printer validates the complete generated inventory', () => {
+  const manifest = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const printed = execFileSync(
+    process.execPath,
+    [path.join(libDirectory, 'scripts/print-release-id.mjs')],
+    { encoding: 'utf8' }
+  ).trim();
+
+  assert.equal(printed, manifest.releaseId);
+});
+
+test('generated optional first-display slices self-register through one authenticated sink', () => {
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const firstDisplay = release.artifacts.filter(({ phase }) => phase === 'first_display');
+  const dom = new JSDOM(
+    `<!doctype html><script id="trustedserver-js" src="/static/tsjs=tsjs-first-display.min.js?m=3fff&v=${'b'.repeat(64)}"></script>`,
+    {
+      runScripts: 'outside-only',
+      url: 'https://publisher.example/article',
+    }
+  );
+  const registrations = [];
+  const target = {};
+  Object.defineProperty(target, '_registerFirstDisplay', {
+    configurable: true,
+    enumerable: false,
+    value(registration) {
+      assert.equal(this, target);
+      assert.equal(arguments.length, 1);
+      dom.window.Object.freeze(registration);
+      registrations.push(registration);
+      return true;
+    },
+    writable: false,
+  });
+  Object.defineProperty(dom.window, 'tsjs', {
+    configurable: true,
+    value: target,
+  });
+  try {
+    dom.window.eval(
+      firstDisplay
+        .map(({ file }) => fs.readFileSync(path.resolve(libDirectory, '../dist', file), 'utf8'))
+        .join(';\n')
+    );
+    assert.deepEqual(
+      registrations.map((registration) => registration[1]),
+      firstDisplay.slice(1).map(({ id }) => id)
+    );
+    for (const registration of registrations) {
+      assert.deepEqual(Reflect.ownKeys(registration), ['0', '1', '2', '3', 'length']);
+      assert.equal(registration[0], 1);
+      assert.equal(registration[2], release.releaseId);
+      assert.equal(typeof registration[3], 'function');
+      assert.equal(Object.isFrozen(registration), true);
+    }
+  } finally {
+    dom.window.close();
+  }
+});
+
+test('takeover transport co-bundles core and render ownership exactly once', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const core = metrics.modules.find(({ file }) => file === 'tsjs-core.js');
+  const renderRuntime = metrics.modules.find(({ file }) => file === 'tsjs-render_runtime.js');
+
+  assert.ok(core, 'core metrics must exist');
+  assert.ok(renderRuntime, 'render_runtime metrics must exist');
+  assert.ok(
+    core.sources.some(({ file }) => file === 'src/integrations/render_runtime/module.ts'),
+    'the core transport must co-bundle the mandatory render owner once'
+  );
+  assert.deepEqual(
+    renderRuntime.sources.map(({ file }) => file),
+    ['src/integrations/render_runtime/transport_marker.ts'],
+    'the logical render artifact must not duplicate the co-bundled implementation'
+  );
+});
+
+test('bootstrap physically owns the logical first-display base without transporting its marker', () => {
+  const { metrics } = readBuildEvidence();
+  const bootstrapSources = new Set(metrics.bootstrap.sources.map(({ file }) => file));
+  const marker = metrics.modules.find(({ file }) => file === 'tsjs-first_display.js');
+  const reference = metrics.firstDisplay.masks.find(({ mask }) => mask === '008b');
+
+  assert.equal(
+    bootstrapSources.has('src/first_display/agent.ts'),
+    true,
+    'the parser-inline bootstrap must physically own the first-display coordinator'
+  );
+  assert.ok(marker, 'the logical first_display catalog marker must remain in release evidence');
+  assert.deepEqual(
+    marker.sources.map(({ file }) => file),
+    ['src/first_display/base_marker.ts'],
+    'the logical marker must not duplicate the bootstrap-owned implementation'
+  );
+  assert.ok(reference, 'the exact semantic 008b first-display mask must be measured');
+  assert.equal(reference.ids[0], 'first_display');
+  assert.deepEqual(
+    reference.files,
+    reference.ids.slice(1).map((id) => `tsjs-${id}.js`),
+    'the logical base bit must select bootstrap behavior without adding response bytes'
+  );
+
+  for (const forbidden of [
+    'src/first_display/render_journal.ts',
+    'src/first_display/render_bridge.ts',
+    'src/first_display/leaf/aps_protocol.ts',
+    'src/first_display/slices/aps.ts',
+    'src/first_display/slices/gpt.ts',
+  ]) {
+    assert.equal(
+      bootstrapSources.has(forbidden),
+      false,
+      `bootstrap must not inline optional first-display source ${forbidden}`
+    );
+  }
+});
+
+test('first-display component entries register directly without a definition runtime', () => {
+  const { metrics } = readBuildEvidence();
+
+  for (const [id, component] of Object.entries(metrics.firstDisplay.components)) {
+    if (id === 'first_display') continue;
+    assert.equal(
+      component.sources.some(({ file }) => file === 'src/first_display/slices/definition.ts'),
+      false,
+      `${id} must not transport the test-only slice-definition helper`
+    );
+  }
+});
+
+test('generated integration artifacts execute their release-bound catalog entrypoints', () => {
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>', {
+    runScripts: 'outside-only',
+    url: 'https://publisher.example/article',
+  });
+  const registrations = [];
+  try {
+    executeGeneratedArtifact(dom.window, 'tsjs-render_runtime.js', registrations);
+    assert.equal(
+      registrations.length,
+      0,
+      'the catalog marker must not publish a duplicate render owner'
+    );
+    registrations.push({ id: 'render_runtime', phase: 'takeover' });
+    for (const artifact of release.artifacts.filter(
+      ({ role, id }) => role === 'integration' && id !== 'render_runtime'
+    )) {
+      executeGeneratedArtifact(dom.window, artifact.file, registrations);
+    }
+    const integrationArtifacts = release.artifacts.filter(
+      ({ role, id }) => role === 'integration' && id !== 'render_runtime'
+    );
+    for (let index = 0; index < integrationArtifacts.length; index += 1) {
+      const artifact = integrationArtifacts[index];
+      const registration = registrations[index + 1];
+      assert.deepEqual(
+        Reflect.ownKeys(registration),
+        artifact.phase === 'takeover'
+          ? ['abi', 'id', 'phase', 'releaseId', 'prepareSync', 'prepare']
+          : ['abi', 'id', 'phase', 'releaseId', 'prepare']
+      );
+      assert.equal(typeof registration.prepare, 'function');
+      assert.equal(
+        Object.prototype.hasOwnProperty.call(registration, 'prepareSync'),
+        artifact.phase === 'takeover'
+      );
+    }
+    assert.deepEqual(
+      registrations.map(({ id }) => id),
+      release.artifacts.filter(({ role }) => role === 'integration').map(({ id }) => id)
+    );
+    assert.deepEqual(
+      registrations.map(({ phase }) => phase),
+      release.artifacts.filter(({ role }) => role === 'integration').map(({ phase }) => phase)
+    );
+  } finally {
+    dom.window.close();
+  }
+});
+
+test('generated takeover transport owns branded render operations without GPT duplication', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const renderRuntime = metrics.modules.find(({ file }) => file === 'tsjs-render_runtime.js');
+  const gpt = metrics.modules.find(({ file }) => file === 'tsjs-gpt.js');
+
+  assert.ok(renderRuntime, 'render_runtime metrics must exist');
+  assert.ok(gpt, 'GPT metrics must exist');
+  assert.ok(
+    metrics.modules
+      .find(({ file }) => file === 'tsjs-core.js')
+      ?.sources.some(({ file }) => file === 'src/services/render.ts'),
+    'the co-bundled takeover transport must own the branded render implementation'
+  );
+  assert.equal(
+    gpt.sources.some(({ file }) => file === 'src/services/render.ts'),
+    false,
+    'GPT must invoke branded operations through render.v1'
+  );
+  assert.equal(
+    gpt.sources.some(({ file }) => file === 'src/core/render.ts'),
+    false,
+    'GPT must obtain the core-owned iframe constructor through render.v1'
+  );
+  assert.equal(
+    gpt.sources.some(({ file }) => file === 'src/adapters/messaging.ts'),
+    false,
+    'GPT must consume the core-owned messaging boundary without recompiling it'
+  );
+  assert.equal(
+    metrics.modules
+      .find(({ file }) => file === 'tsjs-core.js')
+      ?.sources.some(({ file }) => file === 'src/core/puc_shell.ts'),
+    false,
+    'the GPT-owned PUC shell helper must not inflate the always-on core transport'
+  );
+  assert.equal(
+    gpt.sources.some(({ file }) => file === 'src/core/puc_shell.ts'),
+    true,
+    'the sole PUC owner must carry its guarded collapsed-shell resize helper'
+  );
+  for (const source of [
+    'src/core/contracts/auction_projection.ts',
+    'src/core/contracts/generated/renderer_validator_v1.ts',
+    'src/core/contracts/aps_renderer.ts',
+    'src/core/config.ts',
+    'src/services/projections.ts',
+    'src/kernel/identity.ts',
+  ]) {
+    assert.equal(
+      gpt.sources.some(({ file }) => file === source),
+      false,
+      `GPT must consume core-owned ${source} behavior through capabilities`
+    );
+  }
+});
+
+test('generated bootstrap uses only the compact sealed transport parser', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const sources = new Set(metrics.bootstrap.sources.map(({ file }) => file));
+
+  assert.equal(sources.has('src/core/contracts/server_boot_transport.ts'), true);
+  for (const forbidden of [
+    'src/core/contracts/boot.ts',
+    'src/core/contracts/auction_projection.ts',
+    'src/core/contracts/integration_configs.ts',
+  ]) {
+    assert.equal(sources.has(forbidden), false, `bootstrap must not reach ${forbidden}`);
+  }
+});
+
+test('persistent core consumes generated capacity without bundling the build catalog', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const core = metrics.modules.find(({ file }) => file === 'tsjs-core.js');
+  const sources = new Set(core.sources.map(({ file }) => file));
+  const buildSource = fs.readFileSync(path.resolve(libDirectory, 'build-all.mjs'), 'utf8');
+  const registrySource = fs.readFileSync(
+    path.resolve(libDirectory, 'src/kernel/integration_registry.ts'),
+    'utf8'
+  );
+
+  assert.match(
+    buildSource,
+    /__TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__:\s*JSON\.stringify\(releaseCatalog\.length\)/u
+  );
+  assert.match(
+    registrySource,
+    /import \{ EMBEDDED_MAX_MANIFEST_MODULES \} from '\.\/contracts\/release_capacity';/u
+  );
+  assert.match(registrySource, /const MAX_INTEGRATIONS = EMBEDDED_MAX_MANIFEST_MODULES;/u);
+  assert.doesNotMatch(registrySource, /const MAX_INTEGRATIONS = 20;/u);
+  // The generated scalar is substituted before bundling, so its declaration is
+  // intentionally tree-shaken along with the build-only catalog.
+  assert.equal(sources.has('src/kernel/contracts/release_capacity.ts'), false);
+  assert.equal(sources.has('src/kernel/release_catalog.ts'), false);
+});
+
+test('messaging protocol binding is declared before schema initialization', () => {
+  const source = fs.readFileSync(path.resolve(libDirectory, 'src/adapters/messaging.ts'), 'utf8');
+  const binding =
+    "import { TSJS_MESSAGE_PROTOCOL_V1 } from '../kernel/contracts/message_protocol';";
+  const initialization = 'export const PROTOCOL_MESSAGE_SCHEMAS_V1';
+
+  assert.ok(source.indexOf(binding) >= 0, 'the messaging protocol must have a local binding');
+  assert.ok(
+    source.indexOf(binding) < source.indexOf(initialization),
+    'the messaging protocol binding must precede schema initialization'
+  );
+});
+
+test('generated APS bootstrap configuration preserves its public wire keys', () => {
+  const source = fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-aps_initial.js'), 'utf8');
+
+  assert.match(
+    source,
+    /TS APS Bootstrap Configure",version:2,bootstrapNonce:[^,}]+,["']?rendererNonce["']?:/u,
+    'the independently minified APS slice must serialize rendererNonce with its authored name'
+  );
+});
+
+test('co-bundled render_runtime and independent GPT start one branded display flow', async () => {
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const dom = new JSDOM(
+    '<!doctype html><html><head></head><body><div id="slot-one"></div></body></html>',
+    {
+      runScripts: 'outside-only',
+      url: 'https://publisher.example/article',
+    }
+  );
+  const registrations = [];
+  const preparationDisposers = [];
+  const activationDisposers = [];
+  const displayCalls = [];
+  try {
+    const targeting = new Map();
+    const definedSlots = [];
+    const pubads = {
+      addEventListener: () => undefined,
+      disableInitialLoad: () => undefined,
+      getSlots: () => definedSlots,
+      refresh: () => undefined,
+      removeEventListener: () => undefined,
+    };
+    dom.window.googletag = {
+      apiReady: true,
+      pubadsReady: true,
+      cmd: { push: (command) => (command(), 1) },
+      defineSlot: (adUnitPath, _sizes, elementId) => {
+        const slot = {
+          addService: () => slot,
+          clearTargeting: (key) => {
+            if (key === undefined) targeting.clear();
+            else targeting.delete(key);
+            return slot;
+          },
+          getAdUnitPath: () => adUnitPath,
+          getSlotElementId: () => elementId,
+          getTargeting: (key) => targeting.get(key) ?? [],
+          setTargeting: (key, value) => {
+            targeting.set(key, typeof value === 'string' ? [value] : [...value]);
+            return slot;
+          },
+        };
+        definedSlots.push(slot);
+        return slot;
+      },
+      destroySlots: () => true,
+      display: (elementId) => displayCalls.push(elementId),
+      getConfig: () => ({ disableInitialLoad: false }),
+      pubads: () => pubads,
+      setConfig: () => undefined,
+    };
+    const takeoverBody = fs.readFileSync(
+      path.resolve(libDirectory, '../dist/tsjs-core.js'),
+      'utf8'
+    );
+    const runtimeHash = createHash('sha256').update(takeoverBody).digest('hex');
+    const boot = dom.window.eval(`(() => {
+      const freeze = Object.freeze;
+      const placement = freeze({
+        slot: 'slot-one',
+        gamUnitPath: '/123/slot-one',
+        divId: 'slot-one',
+        formats: freeze([freeze([300, 250])]),
+        targeting: freeze({})
+      });
+      const bid = freeze({
+        candidateId: 'AAAAAAAAAAAA',
+        slot: 'slot-one',
+        provider: 'trusted',
+        upstreamBidId: 'upstream-one',
+        cpm: 2,
+        currency: 'USD',
+        targeting: freeze({ hb_bidder: 'trusted' }),
+        rendererReservationId: 'r1_aaaaaaaaaaaaaaaaaaaaaa',
+        renderSource: freeze({
+          type: 'adm',
+          version: 1,
+          adm: '<main>trusted</main>',
+          width: 300,
+          height: 250
+        })
+      });
+      return freeze({
+        abi: 1,
+        releaseId: '${release.releaseId}',
+        manifest: freeze({
+          version: 1,
+          releaseId: '${release.releaseId}',
+          firstDisplay: null,
+          runtimeSrc: '/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}',
+          integrations: freeze([
+            freeze({ id: 'render_runtime', phase: 'takeover' }),
+            freeze({ id: 'gpt', phase: 'takeover' })
+          ])
+        }),
+        auctionProjection: freeze({
+          version: 1,
+          auction: freeze({
+            version: 1,
+            auctionId: 'generated-cross-bundle',
+            results: freeze([freeze({
+              slot: 'slot-one',
+              outcome: 'winner',
+              candidateId: 'AAAAAAAAAAAA'
+            })])
+          }),
+          slots: freeze([placement]),
+          bids: freeze([bid])
+        }),
+        integrations: freeze({
+          version: 1,
+          entries: freeze([freeze({
+            id: 'gpt',
+            config: freeze({ gamAttributionEnabled: false, pageBidsEnabled: false })
+          })])
+        }),
+        creative: freeze({
+          version: 1,
+          enabled: false,
+          clickGuard: false,
+          renderGuard: false
+        }),
+        diagnostics: freeze({
+          version: 1,
+          renderTraceOverlay: false,
+          gpt: freeze({ active: false })
+        })
+      });
+    })()`);
+    const runtimeScript = dom.window.document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = `/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`;
+    dom.window.document.head.append(runtimeScript);
+    const integrity = dom.window.Object.create(dom.window.Object.prototype);
+    dom.window.Object.assign(integrity, {
+      version: 1,
+      projectionDigest: createHash('sha256')
+        .update(JSON.stringify(boot.auctionProjection))
+        .digest('hex'),
+      integrationConfigDigest: createHash('sha256')
+        .update(JSON.stringify(boot.integrations))
+        .digest('hex'),
+    });
+    dom.window.Object.freeze(integrity);
+    const target = dom.window.Object.create(dom.window.Object.prototype);
+    dom.window.Object.assign(target, { boot, que: dom.window.Array() });
+    const currentScript = () => runtimeScript;
+    const claimedRuntime = dom.window.Object.create(dom.window.Object.prototype);
+    dom.window.Object.assign(claimedRuntime, {
+      boot,
+      integrity,
+      complete: () => undefined,
+      currentScript,
+      source: runtimeScript,
+      target,
+      mode: 'direct',
+      bind: (cancel) => (typeof cancel === 'function' ? () => undefined : undefined),
+    });
+    dom.window.Object.freeze(claimedRuntime);
+    let claimLive = true;
+    Object.defineProperty(runtimeScript, '_claimRuntimeV1', {
+      configurable: false,
+      enumerable: false,
+      value: (source) => {
+        if (!claimLive || source !== runtimeScript) return undefined;
+        claimLive = false;
+        return claimedRuntime;
+      },
+      writable: false,
+    });
+    Object.defineProperty(dom.window.Document.prototype, 'currentScript', {
+      configurable: true,
+      get: currentScript,
+    });
+    let runtimeReadLive = true;
+    Object.defineProperty(dom.window, 'tsjs', {
+      configurable: false,
+      enumerable: true,
+      get: () => {
+        if (!runtimeReadLive) return target;
+        runtimeReadLive = false;
+        return runtimeScript;
+      },
+    });
+    let publisherMicrotaskRan = false;
+    dom.window.queueMicrotask(() => {
+      publisherMicrotaskRan = true;
+    });
+    dom.window.eval(takeoverBody);
+    executeGeneratedArtifact(dom.window, 'tsjs-gpt.js', registrations, { preserveTarget: true });
+    assert.equal(
+      dom.window.tsjs?._internal?.state,
+      'kernel',
+      `takeover transport should commit: ${JSON.stringify(dom.window.tsjs?._internal)}`
+    );
+    assert.equal(
+      publisherMicrotaskRan,
+      false,
+      'no-agent preparation, activation, and commit must not yield to publisher microtasks'
+    );
+    await new Promise((resolve) => queueMicrotask(resolve));
+    assert.equal(publisherMicrotaskRan, true);
+    for (let index = 0; index < 10 && displayCalls.length === 0; index += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+
+    assert.equal(displayCalls.length, 1);
+    assert.equal(displayCalls[0], definedSlots[0]);
+  } finally {
+    activationDisposers.reverse().forEach((release) => release());
+    preparationDisposers.reverse().forEach((release) => release());
+    dom.window.close();
+  }
+});
+
+for (const fixture of TAKEOVER_CONSENT_ARTIFACTS) {
+  test(`generated ${fixture.id} artifact activates through runtime.v1 and publishes ${fixture.capability}`, () => {
+    const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>', {
+      runScripts: 'outside-only',
+      url: 'https://publisher.example/article',
+    });
+    const registrations = [];
+    const preparationDisposers = [];
+    const activationDisposers = [];
+    const afterCommit = [];
+    try {
+      executeGeneratedArtifact(dom.window, `tsjs-${fixture.id}.js`, registrations);
+      assert.equal(registrations.length, 1);
+      const registration = registrations[0];
+      const runtime = dom.window.Object.freeze({
+        registerAuctionContext: () => () => undefined,
+      });
+      const config =
+        fixture.id === 'sourcepoint_consent'
+          ? dom.window.eval('Object.freeze({ rewriteSdk: false })')
+          : dom.window.eval('Object.freeze({})');
+      const prepared = registration.prepare(
+        dom.window.Object.freeze({
+          config,
+          interfaces: dom.window.Object.freeze({ 'runtime.v1': runtime }),
+          onDispose: (callback) => preparationDisposers.push(callback),
+          signal: new dom.window.AbortController().signal,
+        })
+      );
+      assert.deepEqual(Reflect.ownKeys(prepared.interfaces), [fixture.capability]);
+      assert.equal(Object.isFrozen(prepared.interfaces[fixture.capability]), true);
+      prepared.activate(
+        dom.window.Object.freeze({
+          afterCommit: (callback) => afterCommit.push(callback),
+          onDispose: (callback) => activationDisposers.push(callback),
+          signal: new dom.window.AbortController().signal,
+        })
+      );
+      assert.ok(
+        activationDisposers.length > 0 || afterCommit.length > 0,
+        'real takeover activation must acquire or schedule owned behavior'
+      );
+    } finally {
+      activationDisposers.reverse().forEach((release) => release());
+      preparationDisposers.reverse().forEach((release) => release());
+      dom.window.close();
+    }
+  });
+}
+
+test('bundle metrics use the required five-module reference vector', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const catalog = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-catalog-v1.json'), 'utf8')
+  );
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+
+  const idsByFile = new Map(release.artifacts.map(({ id, file }) => [file, id]));
+  const actualIds = Object.fromEntries(
+    Object.entries(metrics.sets).map(([name, set]) => [
+      name,
+      set.files.map((file) => idsByFile.get(file)),
+    ])
+  );
+
+  assert.deepEqual(actualIds, bundleMetrics.deriveSemanticBundleSetIds(catalog.modules));
+  assert.equal(metrics.bootstrap.file, 'tsjs-bootstrap.js');
+  assert.equal(
+    metrics.compression.concatenationSeparator,
+    bundleMetrics.BUNDLE_SEPARATOR.toString('utf8')
+  );
+  for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+    assert.ok(Number.isSafeInteger(metrics.bootstrap[size]) && metrics.bootstrap[size] > 0);
+  }
+
+  assert.deepEqual(metrics.sets.reference.files, [
+    'tsjs-core.js',
+    'tsjs-render_runtime.js',
+    'tsjs-creative.js',
+    'tsjs-gpt.js',
+    'tsjs-prebid.js',
+    'tsjs-datadome.js',
+  ]);
+});
+
+test('bundle metrics enumerate and hash every reachable first-display mask', () => {
+  const { metrics } = readBuildEvidence();
+  const masks = metrics.firstDisplay.masks;
+
+  assert.ok(Array.isArray(masks));
+  assert.equal(masks.length, 3_584);
+  assert.equal(new Set(masks.map(({ mask }) => mask)).size, masks.length);
+  assert.equal(new Set(masks.map(({ sha256 }) => sha256)).size, masks.length);
+  for (const measurement of masks) {
+    assert.match(measurement.mask, /^[0-9a-f]{4}$/u);
+    assert.equal(measurement.ids[0], 'first_display');
+    if (!measurement.ids.includes('gpt_initial')) {
+      assert.equal(measurement.ids.includes('render_owner_initial'), false);
+      assert.equal(measurement.ids.includes('aps_initial'), false);
+      assert.equal(measurement.ids.includes('prebid_initial'), false);
+    }
+    if (measurement.ids.includes('aps_initial')) {
+      assert.equal(measurement.ids.includes('render_owner_initial'), true);
+    }
+    if (measurement.ids.includes('render_owner_initial')) {
+      assert.equal(measurement.ids.includes('gpt_initial'), true);
+    }
+    assert.deepEqual(
+      measurement.files,
+      measurement.ids.slice(1).map((id) => `tsjs-${id}.js`)
+    );
+    for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+      assert.ok(
+        Number.isSafeInteger(measurement[size]) &&
+          (size === 'rawBytes' ? measurement[size] >= 0 : measurement[size] > 0)
+      );
+    }
+    assert.equal(typeof measurement.permitted, 'boolean');
+    assert.match(measurement.sha256, /^[0-9a-f]{64}$/u);
+  }
+});
+
+test('candidate architecture obeys every independent absolute transfer ceiling', () => {
+  const { metrics, release, catalog } = readBuildEvidence();
+  const currentArtifactContents = new Map(
+    release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+  const report = bundleBudgets.buildCandidateArchitectureSizeReport({
+    metrics,
+    release,
+    catalog,
+    currentArtifactContents,
+  });
+
+  assert.doesNotThrow(() => bundleBudgets.enforceCandidateArchitectureSizeCeilings(report));
+  assert.equal(report.firstDisplay.masks.length, 3_584);
+  assert.ok(report.firstDisplay.permittedMasks.length > 0);
+  assert.ok(report.firstDisplay.permittedMasks.length < report.firstDisplay.masks.length);
+  for (const name of ['minimal', 'reference', 'aps']) {
+    assert.equal(report.firstDisplay.named[name].permitted, true);
+  }
+  assert.deepEqual(report.firstDisplay.named.reference.ids, [
+    'first_display',
+    'creative_initial',
+    'datadome_initial',
+    'gpt_initial',
+    'prebid_initial',
+  ]);
+  assert.deepEqual(report.firstDisplay.named.aps.ids, [
+    'first_display',
+    'render_owner_initial',
+    'aps_initial',
+    'creative_initial',
+    'gpt_initial',
+  ]);
+  assert.deepEqual(Object.keys(report.firstDisplay.named), [
+    'minimal',
+    'reference',
+    'aps',
+    'largestRaw',
+    'largestGzip',
+    'largestBrotli',
+  ]);
+  assert.deepEqual(Object.keys(report.ceilings), [
+    'bootstrap',
+    'firstDisplayAgent',
+    'referencePersistent',
+    'maximalTotal',
+  ]);
+  const maximalNonBootstrap = bundleMetrics.measureBundleSet(
+    release.artifacts.filter(({ role }) => role !== 'bootstrap').map(({ file }) => file),
+    currentArtifactContents
+  );
+  assert.deepEqual(report.maximalTotal, {
+    rawBytes: maximalNonBootstrap.rawBytes,
+    gzipBytes: maximalNonBootstrap.gzipBytes,
+    brotliBytes: maximalNonBootstrap.brotliBytes,
+  });
+});
+
+test('absolute transfer ceilings reject independent one-byte regressions', () => {
+  const ceilings = bundleBudgets.CANDIDATE_ARCHITECTURE_SIZE_CEILINGS;
+  for (const semanticSet of Object.keys(ceilings)) {
+    for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+      const report = Object.fromEntries(
+        Object.entries(ceilings).map(([name, limits]) => [name, { ...limits }])
+      );
+      report[semanticSet][size] += 1;
+      assert.throws(
+        () => bundleBudgets.enforceCandidateArchitectureSizeCeilings(report),
+        new RegExp(`${semanticSet}\\.${size} exceeds`)
+      );
+    }
+  }
+});
+
+test('generated mask allowlist must exactly match size-admitted reachable masks', () => {
+  const { metrics, release, catalog } = readBuildEvidence();
+  const currentArtifactContents = new Map(
+    release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+  catalog.permittedFirstDisplayMasks.pop();
+
+  assert.throws(
+    () =>
+      bundleBudgets.buildCandidateArchitectureSizeReport({
+        metrics,
+        release,
+        catalog,
+        currentArtifactContents,
+      }),
+    /generated permitted first-display masks/
+  );
+});
+
+test('bundle metrics has sole ownership of semantic transfer-set derivation', () => {
+  const comparatorSource = fs.readFileSync(
+    path.join(libDirectory, 'scripts/check-bundle-budgets.mjs'),
+    'utf8'
+  );
+
+  assert.equal(typeof bundleMetrics.deriveSemanticBundleSetIds, 'function');
+  assert.match(
+    comparatorSource,
+    /import\s*\{[^}]*deriveSemanticBundleSetIds[^}]*\}\s*from '\.\/bundle-metrics\.mjs'/s
+  );
+  assert.doesNotMatch(comparatorSource, /const REFERENCE_INCLUDE_ORDER|function isCatalogModule/);
+  assert.doesNotMatch(comparatorSource, /function deriveSemanticBundleSetIds\s*\(/);
+});
+
+test('role-correct budgets use deterministic pure aggregation and compression metrics', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const catalog = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-catalog-v1.json'), 'utf8')
+  );
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const contents = new Map(
+    release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+
+  assert.equal(typeof bundleMetrics.deriveInventorySetFiles, 'function');
+  assert.equal(typeof bundleMetrics.measureBundleSet, 'function');
+  assert.equal(typeof bundleMetrics.measureBytes, 'function');
+  assert.deepEqual(
+    bundleMetrics.deriveInventorySetFiles(release.artifacts, catalog.modules),
+    Object.fromEntries(Object.entries(metrics.sets).map(([name, set]) => [name, set.files]))
+  );
+  for (const [name, files] of Object.entries(
+    bundleMetrics.deriveInventorySetFiles(release.artifacts, catalog.modules)
+  )) {
+    assert.deepEqual(bundleMetrics.measureBundleSet(files, contents), metrics.sets[name]);
+  }
+  assert.deepEqual(
+    bundleMetrics.measureBytes(contents.get('tsjs-bootstrap.js')),
+    Object.fromEntries(
+      ['rawBytes', 'gzipBytes', 'brotliBytes', 'sha256'].map((key) => [key, metrics.bootstrap[key]])
+    )
+  );
+});
+
+test('release build has one bundle aggregation and compression measurement owner', () => {
+  const buildSource = fs.readFileSync(path.join(libDirectory, 'build-all.mjs'), 'utf8');
+
+  assert.match(
+    buildSource,
+    /import\s*\{[^}]*deriveInventorySetFiles[^}]*measureBundleSet[^}]*measureBytes[^}]*\}\s*from '\.\/scripts\/bundle-metrics\.mjs'/s
+  );
+  assert.match(buildSource, /deriveInventorySetFiles\(artifactInventory, releaseCatalog\)/);
+  assert.match(buildSource, /measureBundleSet\(/);
+  assert.match(buildSource, /measureBytes\(bootstrapBytes\)/);
+  assert.doesNotMatch(buildSource, /node:zlib|const separator\s*=|function compress\s*\(/);
+  assert.doesNotMatch(buildSource, /function measureBundleSet\s*\(/);
+  assert.doesNotMatch(buildSource, /MINIMAL_TAKEOVER_IDS|REFERENCE_TAKEOVER_IDS/);
+});
+
+test('reduced remediation capture appends provenance without changing earlier evidence', () => {
+  const baseline = JSON.parse(
+    fs.readFileSync(
+      path.join(libDirectory, 'test/fixtures/performance/aps-tsjs-prechange.json'),
+      'utf8'
+    )
+  );
+  const original = Object.fromEntries(
+    Object.entries(baseline).filter(
+      ([key]) => key !== 'roleCorrectTransfer' && key !== 'reviewRemediationTransfer'
+    )
+  );
+
+  assert.ok(baseline.roleCorrectTransfer, 'role-correct capture must be appended');
+  assert.deepEqual(baseline.roleCorrectTransfer.source, {
+    ref: 'spec/aps-tsjs-resilience-design',
+    sha: '4e2c307923b838716d95e2feeebb994a37bb8025',
+  });
+  assert.equal(
+    baseline.roleCorrectTransfer.originalTopLevelSha256,
+    createHash('sha256').update(canonicalJson(original)).digest('hex')
+  );
+  assert.equal(
+    baseline.roleCorrectTransfer.originalTopLevelSha256,
+    '53f762603ad49239f1756171440be422e190cc231efafc56cf37a11e1a38ddf4'
+  );
+  assert.equal(
+    baseline.roleCorrectTransfer.compression.concatenationSeparator,
+    bundleMetrics.BUNDLE_SEPARATOR.toString('utf8')
+  );
+  assert.ok(
+    baseline.reviewRemediationTransfer,
+    'review remediation capture must be appended after the immutable intermediate capture'
+  );
+  assert.deepEqual(baseline.reviewRemediationTransfer.source, {
+    ref: 'spec/aps-tsjs-resilience-design',
+    sha: '91b3533ae7c07e03fa77441e0d94f27e31965d9e',
+  });
+  assert.equal(
+    baseline.reviewRemediationTransfer.originalTopLevelSha256,
+    baseline.roleCorrectTransfer.originalTopLevelSha256
+  );
+  assert.equal(
+    baseline.reviewRemediationTransfer.roleCorrectTransferSha256,
+    bundleBudgets.canonicalJsonSha256(baseline.roleCorrectTransfer)
+  );
+  assert.ok(baseline.reviewRemediationTransfer.sets.minimal.rawBytes <= 220_000);
+  assert.ok(baseline.reviewRemediationTransfer.sets.minimal.gzipBytes <= 59_000);
+  assert.ok(
+    baseline.reviewRemediationTransfer.sets.minimal.brotliBytes <
+      baseline.roleCorrectTransfer.sets.minimal.brotliBytes
+  );
+  for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+    assert.ok(
+      baseline.reviewRemediationTransfer.sets.reference[size] <
+        baseline.roleCorrectTransfer.sets.reference[size]
+    );
+    assert.ok(
+      baseline.reviewRemediationTransfer.sets.maximal[size] <=
+        baseline.roleCorrectTransfer.sets.maximal[size]
+    );
+  }
+});
+
+test('bundle budget membership rejects every noncanonical release inventory shape', () => {
+  const metrics = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-build-metrics-v1.json'), 'utf8')
+  );
+  const catalog = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-catalog-v1.json'), 'utf8')
+  );
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const rejectReleaseMutation = (mutate, pattern) => {
+    const candidate = structuredClone(release);
+    mutate(candidate.artifacts);
+    assert.throws(() => validateSemanticBundleSets(metrics, candidate, catalog), pattern);
+  };
+
+  assert.doesNotThrow(() => validateSemanticBundleSets(metrics, release, catalog));
+  rejectReleaseMutation((artifacts) => {
+    artifacts[0].file = 'gpt-bootstrap-fallback.js';
+  }, /bootstrap\/bootstrap\/tsjs-bootstrap\.js/);
+  rejectReleaseMutation((artifacts) => {
+    artifacts.find(({ id }) => id === 'core').id = 'runtime_core';
+  }, /core\/core\/tsjs-core\.js/);
+  rejectReleaseMutation((artifacts) => {
+    artifacts.find(({ id }) => id === 'render_runtime').role = 'core';
+  }, /integration\/render_runtime\/tsjs-render_runtime\.js/);
+  rejectReleaseMutation((artifacts) => {
+    artifacts[artifacts.length - 1] = structuredClone(artifacts.at(-2));
+  }, /invalid or duplicate artifact/);
+  rejectReleaseMutation((artifacts) => {
+    artifacts[artifacts.length - 1] = {
+      ...artifacts.at(-1),
+      id: 'unknown',
+      file: 'tsjs-unknown.js',
+    };
+  }, /sourcepoint_lifecycle/);
+  rejectReleaseMutation((artifacts) => artifacts.pop(), /exact catalog artifact count/);
+
+  const multiplyCounted = structuredClone(metrics);
+  multiplyCounted.sets.minimal.files.push(multiplyCounted.sets.minimal.files[0]);
+  assert.throws(
+    () => validateSemanticBundleSets(multiplyCounted, release, catalog),
+    /contains a duplicate/
+  );
+
+  const omittedMaximalModule = structuredClone(metrics);
+  omittedMaximalModule.sets.maximal.files.pop();
+  assert.throws(
+    () => validateSemanticBundleSets(omittedMaximalModule, release, catalog),
+    /buildMetrics\.sets\.maximal has semantic ids/
+  );
+});
+
+test('takeover bundle graphs exclude deferred entries and transitive presentation sources', () => {
+  const { metrics, release } = readBuildEvidence();
+  const cleanMetrics = structuredClone(metrics);
+  assert.deepEqual(findTakeoverDeferredSourceViolations(cleanMetrics, release), []);
+
+  const reachesDeferredEntry = structuredClone(cleanMetrics);
+  reachesDeferredEntry.modules
+    .find(({ file }) => file === 'tsjs-core.js')
+    .sources.push({
+      file: 'src/integrations/gpt/later.ts',
+      renderedBytes: 1,
+    });
+  assert.deepEqual(findTakeoverDeferredSourceViolations(reachesDeferredEntry, release), [
+    'core reaches deferred-owned source src/integrations/gpt/later.ts',
+  ]);
+
+  const reachesPresentationHelper = structuredClone(cleanMetrics);
+  reachesPresentationHelper.modules
+    .find(({ file }) => file === 'tsjs-core.js')
+    .sources.push({
+      file: 'src/integrations/gpt_diagnostics/overlay.ts',
+      renderedBytes: 1,
+    });
+  assert.deepEqual(findTakeoverDeferredSourceViolations(reachesPresentationHelper, release), [
+    'core reaches deferred-owned source src/integrations/gpt_diagnostics/overlay.ts',
+  ]);
+
+  const reachesRenderTracePresentation = structuredClone(cleanMetrics);
+  reachesRenderTracePresentation.modules
+    .find(({ file }) => file === 'tsjs-core.js')
+    .sources.push({
+      file: 'src/integrations/gpt_diagnostics/presentation.ts',
+      renderedBytes: 1,
+    });
+  assert.deepEqual(findTakeoverDeferredSourceViolations(reachesRenderTracePresentation, release), [
+    'core reaches deferred-owned source src/integrations/gpt_diagnostics/presentation.ts',
+  ]);
+});
+
+test('permanent comparator pins every historical and role-correct evidence subtree', () => {
+  const evidence = readBuildEvidence();
+  assert.equal(typeof bundleBudgets.validateRoleCorrectTransfer, 'function');
+  assert.doesNotThrow(() => bundleBudgets.validateRoleCorrectTransfer(evidence));
+
+  const originalMutations = {
+    schemaVersion: (candidate) => (candidate.schemaVersion = 2),
+    mode: (candidate) => (candidate.mode = 'changed'),
+    source: (candidate) => (candidate.source.sha = 'a'.repeat(40)),
+    environment: (candidate) => (candidate.environment.node = 'changed'),
+    sampling: (candidate) => (candidate.sampling.warmups += 1),
+    bundles: (candidate) => (candidate.bundles.minimal.rawBytes += 1),
+    performance: (candidate) => (candidate.performance.bootToFirstDisplayMs.samples[0] += 1),
+    evidence: (candidate) => (candidate.evidence.workflowRunId += 1),
+  };
+  for (const [subtree, mutate] of Object.entries(originalMutations)) {
+    const candidate = structuredClone(evidence);
+    mutate(candidate.baseline);
+    assert.throws(
+      () => bundleBudgets.validateRoleCorrectTransfer(candidate),
+      /historical evidence digest/,
+      `${subtree} mutation must fail`
+    );
+  }
+
+  const captureMutations = {
+    schemaVersion: (candidate) => (candidate.schemaVersion = 2),
+    source: (candidate) => (candidate.source.sha = 'a'.repeat(40)),
+    originalTopLevelSha256: (candidate) => (candidate.originalTopLevelSha256 = 'a'.repeat(64)),
+    tools: (candidate) => (candidate.tools.node = 'changed'),
+    compression: (candidate) => (candidate.compression.gzip.level = 8),
+    release: (candidate) => (candidate.release.artifacts[0].bytes += 1),
+    sourceOwners: (candidate) => candidate.sourceOwners['src/kernel/runtime.ts'].push('gpt'),
+    sets: (candidate) => candidate.sets.maximal.artifactIds.pop(),
+  };
+  for (const [subtree, mutate] of Object.entries(captureMutations)) {
+    const candidate = structuredClone(evidence);
+    mutate(candidate.baseline.roleCorrectTransfer);
+    assert.throws(
+      () => bundleBudgets.validateRoleCorrectTransfer(candidate),
+      /role-correct capture digest/,
+      `${subtree} mutation must fail`
+    );
+  }
+
+  const remediationMutations = {
+    source: (candidate) => (candidate.source.sha = 'b'.repeat(40)),
+    roleCorrectTransferSha256: (candidate) =>
+      (candidate.roleCorrectTransferSha256 = 'b'.repeat(64)),
+    release: (candidate) => (candidate.release.artifacts[1].bytes += 1),
+    sourceOwners: (candidate) => candidate.sourceOwners['src/core/index.ts'].push('gpt'),
+    logicalProviderSources: (candidate) => candidate.logicalProviderSources.render_runtime.pop(),
+    physicalMarkerOwners: (candidate) => (candidate.physicalMarkerOwners.render_runtime = 'gpt'),
+    graphReport: (candidate) => (candidate.graphReport.largestContributions[0].renderedBytes += 1),
+    sets: (candidate) => (candidate.sets.minimal.gzipBytes += 1),
+  };
+  for (const [subtree, mutate] of Object.entries(remediationMutations)) {
+    const candidate = structuredClone(evidence);
+    mutate(candidate.baseline.reviewRemediationTransfer);
+    assert.throws(
+      () => bundleBudgets.validateRoleCorrectTransfer(candidate),
+      /review-remediation capture digest/,
+      `${subtree} remediation mutation must fail`
+    );
+  }
+});
+
+test('bundle check authenticates historical capture provenance for descendant builds', () => {
+  const evidence = readBuildEvidence();
+  const intermediate = evidence.baseline.roleCorrectTransfer;
+  const capture = evidence.baseline.reviewRemediationTransfer;
+
+  assert.doesNotThrow(() => bundleBudgets.validateFrozenCaptureProvenance(intermediate, capture));
+  assert.doesNotThrow(() => bundleBudgets.validateCaptureSourceProvenance(capture));
+  assert.doesNotThrow(() =>
+    bundleBudgets.validateRoleCorrectTransfer({ ...evidence, verifyGitProvenance: true })
+  );
+});
+
+test('capture provenance rejects mismatched recorded lock and tool metadata', () => {
+  const baseline = readBuildEvidence().baseline;
+  const mutations = {
+    packageLockSha256: (candidate) => (candidate.tools.packageLockSha256 = '0'.repeat(64)),
+    node: (candidate) => (candidate.tools.node = 'v0.0.0'),
+    npm: (candidate) => (candidate.tools.npm = '0.0.0'),
+    typescript: (candidate) => (candidate.tools.typescript = '0.0.0'),
+    vite: (candidate) => (candidate.tools.vite = '0.0.0'),
+    esbuild: (candidate) => (candidate.tools.esbuild = '0.0.0'),
+  };
+
+  for (const captureName of ['roleCorrectTransfer', 'reviewRemediationTransfer']) {
+    for (const [field, mutate] of Object.entries(mutations)) {
+      const intermediate = structuredClone(baseline.roleCorrectTransfer);
+      const capture = structuredClone(baseline.reviewRemediationTransfer);
+      mutate(captureName === 'roleCorrectTransfer' ? intermediate : capture);
+      assert.throws(
+        () => bundleBudgets.validateFrozenCaptureProvenance(intermediate, capture),
+        new RegExp(field, 'i'),
+        `${captureName}.${field}`
+      );
+    }
+  }
+});
+
+test('capture provenance rejects an invalid source or missing captured build input', () => {
+  const baseline = readBuildEvidence().baseline;
+  const capture = baseline.reviewRemediationTransfer;
+  const invalidSource = structuredClone(capture);
+  invalidSource.source.sha = '0'.repeat(40);
+
+  assert.throws(
+    () => bundleBudgets.validateCaptureSourceProvenance(invalidSource),
+    /capture source SHA/
+  );
+  const invalidIntermediate = structuredClone(baseline.roleCorrectTransfer);
+  invalidIntermediate.source.sha = '0'.repeat(40);
+  assert.throws(
+    () => bundleBudgets.validateFrozenCaptureProvenance(invalidIntermediate, capture),
+    /capture source SHA/
+  );
+  assert.doesNotThrow(() => bundleBudgets.validateCaptureSourceProvenance(capture));
+  assert.throws(
+    () =>
+      bundleBudgets.validateCaptureSourceProvenance(capture, {
+        buildInputs: ['crates/trusted-server-js/lib/does-not-exist'],
+      }),
+    /captured build input does not exist/
+  );
+});
+
+test('authenticated frozen captures report descendant release drift without rejecting it', () => {
+  const descendant = buildStructurallyValidDescendant();
+
+  const result = bundleBudgets.validateRoleCorrectTransfer(descendant);
+
+  assert.notEqual(
+    descendant.release.releaseId,
+    descendant.baseline.reviewRemediationTransfer.release.releaseId
+  );
+  assert.deepEqual(Object.keys(result.captureReports), [
+    'roleCorrectTransfer',
+    'reviewRemediationTransfer',
+  ]);
+  for (const report of Object.values(result.captureReports)) {
+    assert.equal(
+      report.minimal.rawBytes.deltaBytes,
+      report.minimal.rawBytes.currentBytes - report.minimal.rawBytes.capturedBytes
+    );
+    assert.equal(Object.hasOwn(report.minimal.rawBytes, 'ceilingBytes'), false);
+  }
+
+  const coreIndex = descendant.release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'core');
+  descendant.metrics.modules[coreIndex].sources.push({
+    file: 'src/test/descendant_fake.ts',
+    renderedBytes: 1,
+  });
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(descendant),
+    /production test\/fake\/no-op seam/
+  );
+  descendant.metrics.modules[coreIndex].sources.pop();
+  descendant.release.artifacts.pop();
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(descendant),
+    /live catalog artifact count|exact catalog artifact count/
+  );
+});
+
+test('valid live catalog and release drift is independent from both frozen captures', () => {
+  const authoredCatalog = bundleBudgets.loadAuthoredReleaseCatalog();
+  const descendant = buildStructurallyValidDescendant((evidence) => {
+    const catalogEntry = evidence.catalog.modules.find(({ id }) => id === 'testlight');
+    const artifact = evidence.release.artifacts.find(({ id }) => id === 'testlight');
+    const authoredEntry = authoredCatalog.find(({ id }) => id === 'testlight');
+    catalogEntry.phase = 'deferred';
+    catalogEntry.trigger = 'first_display_or_idle';
+    artifact.phase = 'deferred';
+    artifact.trigger = 'first_display_or_idle';
+    authoredEntry.phase = 'deferred';
+    authoredEntry.trigger = 'first_display_or_idle';
+  });
+
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(descendant),
+    /generated catalog entry .* differs from current authored catalog/
+  );
+  assert.doesNotThrow(() =>
+    bundleBudgets.validateRoleCorrectTransfer({ ...descendant, authoredCatalog })
+  );
+});
+
+test('current release validation is capture-independent while generated bytes stay authoritative', () => {
+  const evidence = readBuildEvidence();
+  const contents = new Map(
+    evidence.release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+  assert.doesNotThrow(() =>
+    bundleBudgets.validateRoleCorrectTransfer({
+      ...evidence,
+      currentArtifactContents: contents,
+    })
+  );
+  const changed = structuredClone(evidence);
+  changed.release.artifacts[0].hash = 'a'.repeat(64);
+  assert.throws(
+    () =>
+      bundleBudgets.validateRoleCorrectTransfer({
+        ...changed,
+        currentArtifactContents: contents,
+      }),
+    /current artifact bytes/
+  );
+  const changedBytes = new Map(contents);
+  changedBytes.set('tsjs-bootstrap.js', Buffer.from('changed'));
+  assert.throws(
+    () =>
+      bundleBudgets.validateRoleCorrectTransfer({
+        ...evidence,
+        currentArtifactContents: changedBytes,
+      }),
+    /current artifact bytes/
+  );
+
+  const understatedMetrics = structuredClone(evidence);
+  understatedMetrics.metrics.sets.minimal.rawBytes -= 1;
+  assert.throws(
+    () =>
+      bundleBudgets.validateRoleCorrectTransfer({
+        ...understatedMetrics,
+        currentArtifactContents: contents,
+      }),
+    /build metrics do not match current artifact bytes/
+  );
+
+  const changedMetadata = structuredClone(evidence);
+  changedMetadata.release.artifacts.find(({ id }) => id === 'aps').inputs = [];
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(changedMetadata),
+    /must consume runtime\.v1/
+  );
+
+  const unexpectedReleaseField = structuredClone(evidence);
+  unexpectedReleaseField.release.unexpected = true;
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(unexpectedReleaseField),
+    /current release inventory must have exact keys/
+  );
+
+  const unexpectedArtifactField = structuredClone(evidence);
+  unexpectedArtifactField.release.artifacts[0].unexpected = true;
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer(unexpectedArtifactField),
+    /current release artifact 0 must have exact keys/
+  );
+});
+
+test('current semantic graph rejects malformed, duplicate, unresolved, late, and deferred capabilities', () => {
+  const mutations = [
+    [
+      /invalid output capability/,
+      (candidate) => candidate.release.artifacts.find(({ id }) => id === 'aps').outputs.push('bad'),
+    ],
+    [
+      /multiple providers/,
+      (candidate) =>
+        candidate.release.artifacts.find(({ id }) => id === 'aps').outputs.push('runtime.v1'),
+    ],
+    [
+      /unknown capability/,
+      (candidate) =>
+        candidate.release.artifacts.find(({ id }) => id === 'aps').inputs.push('missing.v1'),
+    ],
+    [
+      /provider must precede consumer/,
+      (candidate) =>
+        candidate.release.artifacts.find(({ id }) => id === 'render_runtime').inputs.push('gpt.v1'),
+    ],
+    [
+      /deferred integration cannot provide/,
+      (candidate) =>
+        candidate.release.artifacts.find(({ id }) => id === 'gpt_later').outputs.push('late.v1'),
+    ],
+    [
+      /bootstrap invariant/,
+      (candidate) => candidate.release.artifacts[0].outputs.push('bootstrap.v1'),
+    ],
+    [
+      /core invariant/,
+      (candidate) =>
+        candidate.release.artifacts.find(({ id }) => id === 'core').inputs.push('runtime.v1'),
+    ],
+  ];
+
+  for (const [pattern, mutate] of mutations) {
+    const candidate = readBuildEvidence();
+    mutate(candidate);
+    assert.throws(() => bundleBudgets.validateRoleCorrectTransfer(candidate), pattern);
+  }
+});
+
+test('source ownership drift is report-only for an otherwise valid current graph', () => {
+  const evidence = readBuildEvidence();
+  const currentArtifactContents = new Map(
+    evidence.release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+  const omittedModuleSource = structuredClone(evidence);
+  const creativeIndex = omittedModuleSource.release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'creative');
+  const creativeModule = omittedModuleSource.metrics.modules[creativeIndex];
+  const sourceIndex = creativeModule.sources.findIndex(
+    ({ file }) => file === 'src/shared/scheduler.ts'
+  );
+  assert.notEqual(sourceIndex, -1);
+  assert.notEqual(creativeModule.sources[sourceIndex].file, creativeModule.entry);
+  creativeModule.sources.splice(sourceIndex, 1);
+  assert.doesNotThrow(() =>
+    bundleBudgets.validateRoleCorrectTransfer({
+      ...omittedModuleSource,
+      currentArtifactContents,
+    })
+  );
+});
+
+test('harmless current source reassignment does not consult captured ownership', () => {
+  const evidence = readBuildEvidence();
+  const creative = evidence.metrics.modules.find(({ file }) => file === 'tsjs-creative.js');
+  const datadome = evidence.metrics.modules.find(({ file }) => file === 'tsjs-datadome.js');
+  const sourceIndex = creative.sources.findIndex(({ file }) => file === 'src/shared/async.ts');
+  assert.notEqual(sourceIndex, -1);
+  const [asyncSource] = creative.sources.splice(sourceIndex, 1);
+  datadome.sources.push(asyncSource);
+
+  assert.doesNotThrow(() => bundleBudgets.validateRoleCorrectTransfer(evidence));
+});
+
+test('current source classification fails closed for renamed provider source', () => {
+  const { metrics, release } = readBuildEvidence();
+  const gpt = metrics.modules.find(({ file }) => file === 'tsjs-gpt.js');
+  const provider = gpt.sources.find(({ file }) => file === 'src/integrations/gpt/module.ts');
+  provider.file = 'src/integrations/gpt/provider.ts';
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /current provider source is missing.*gpt\/module\.ts|unclassified current production source.*gpt\/provider\.ts/
+  );
+});
+
+test('unknown shared source cannot bridge deferred and takeover artifacts', () => {
+  const { metrics, release } = readBuildEvidence();
+  const source = {
+    file: 'src/shared/new_deferred_runtime.ts',
+    renderedBytes: 1,
+  };
+  metrics.modules.find(({ file }) => file === 'tsjs-core.js').sources.push({ ...source });
+  metrics.modules.find(({ file }) => file === 'tsjs-gpt_later.js').sources.push({ ...source });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /unclassified current production source src\/shared\/new_deferred_runtime\.ts/
+  );
+});
+
+test('provider implementation moved under core remains unclassified', () => {
+  const { metrics, release } = readBuildEvidence();
+  const gpt = metrics.modules.find(({ file }) => file === 'tsjs-gpt.js');
+  const provider = gpt.sources.find(({ file }) => file === 'src/integrations/gpt/module.ts');
+  provider.file = 'src/core/gpt_provider.ts';
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /unclassified current production source src\/core\/gpt_provider\.ts/
+  );
+});
+
+test('deferred implementation moved under shared remains unclassified', () => {
+  const { metrics, release } = readBuildEvidence();
+  const prebidLater = metrics.modules.find(({ file }) => file === 'tsjs-prebid_later.js');
+  const deferred = prebidLater.sources.find(
+    ({ file }) => file === 'src/integrations/prebid/refresh.ts'
+  );
+  deferred.file = 'src/shared/prebid_refresh_runtime.ts';
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /unclassified current production source src\/shared\/prebid_refresh_runtime\.ts/
+  );
+});
+
+test('new deferred-owned source cannot reach a takeover artifact', () => {
+  const { metrics, release } = readBuildEvidence();
+  const deferredSource = {
+    file: 'src/integrations/gpt_diagnostics/presentation/new_panel.ts',
+    renderedBytes: 1,
+  };
+  metrics.modules
+    .find(({ file }) => file === 'tsjs-diagnostics_presentation.js')
+    .sources.push({
+      ...deferredSource,
+    });
+  metrics.modules.find(({ file }) => file === 'tsjs-core.js').sources.push({ ...deferredSource });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /core reaches deferred-owned source.*new_panel\.ts/
+  );
+});
+
+test('current graph inventory rejects cleared bootstrap sources', () => {
+  const evidence = readBuildEvidence();
+  const currentArtifactContents = new Map(
+    evidence.release.artifacts.map(({ file }) => [
+      file,
+      fs.readFileSync(path.resolve(libDirectory, '../dist', file)),
+    ])
+  );
+  evidence.metrics.bootstrap.sources = [];
+  assert.throws(
+    () => bundleBudgets.validateRoleCorrectTransfer({ ...evidence, currentArtifactContents }),
+    /does not contain its entry source/
+  );
+});
+
+test('current graph validation has no captured ownership-policy parameter', () => {
+  const { metrics, release } = readBuildEvidence();
+  assert.equal(bundleBudgets.findProductionGraphViolations.length, 2);
+  assert.deepEqual(bundleBudgets.findProductionGraphViolations(metrics, release), []);
+});
+
+test('source ownership graph rejects duplicate bootstrap sources', () => {
+  const { metrics, release } = readBuildEvidence();
+  const duplicateBootstrapSource = structuredClone(metrics);
+  duplicateBootstrapSource.bootstrap.sources.push(
+    structuredClone(duplicateBootstrapSource.bootstrap.sources[0])
+  );
+  assert.throws(
+    () => bundleBudgets.findProductionGraphViolations(duplicateBootstrapSource, release),
+    /tsjs-bootstrap\.js\.sources\[.*\] is invalid/
+  );
+});
+
+test('exact release key validation accepts equivalent insertion order', () => {
+  const evidence = readBuildEvidence();
+  evidence.release = Object.fromEntries(Object.entries(evidence.release).reverse());
+  evidence.release.artifacts = evidence.release.artifacts.map((artifact) =>
+    Object.fromEntries(Object.entries(artifact).reverse())
+  );
+
+  assert.doesNotThrow(() => bundleBudgets.validateRoleCorrectTransfer(evidence));
+});
+
+test('transfer capture reports deltas without an acceptance ceiling', () => {
+  assert.equal(typeof bundleBudgets.buildTransferCaptureReport, 'function');
+  const captured = Object.fromEntries(
+    ['bootstrap', 'minimal', 'reference', 'maximal'].map((setName) => [
+      setName,
+      { rawBytes: 10, gzipBytes: 10, brotliBytes: 10 },
+    ])
+  );
+  const current = structuredClone(captured);
+  for (const set of Object.values(current)) {
+    set.rawBytes = 12;
+    set.gzipBytes = 12;
+    set.brotliBytes = 12;
+  }
+  const report = bundleBudgets.buildTransferCaptureReport(captured, current);
+  assert.deepEqual(report.reference.gzipBytes, {
+    capturedBytes: 10,
+    currentBytes: 12,
+    deltaBytes: 2,
+  });
+  assert.equal(Object.hasOwn(report.reference.gzipBytes, 'ceilingBytes'), false);
+});
+
+test('production bundle graphs reject every current forbidden edge', () => {
+  const { metrics, release } = readBuildEvidence();
+  assert.equal(typeof bundleBudgets.findProductionGraphViolations, 'function');
+  assert.deepEqual(bundleBudgets.findProductionGraphViolations(metrics, release), []);
+  const rejectSource = (artifactId, file, pattern) => {
+    const candidate = structuredClone(metrics);
+    const artifactIndex = release.artifacts
+      .filter(({ role }) => role !== 'bootstrap')
+      .findIndex(({ id }) => id === artifactId);
+    candidate.modules[artifactIndex].sources.push({ file, renderedBytes: 1 });
+    assert.match(
+      bundleBudgets.findProductionGraphViolations(candidate, release).join('\n'),
+      pattern
+    );
+  };
+
+  rejectSource('gpt', 'src/integrations/render_runtime/module.ts', /inlines provider core/);
+  rejectSource('aps', 'src/kernel/runtime.ts', /inlines provider core/);
+  rejectSource('gpt', 'src/adapters/prebid.ts', /inlines provider prebid/);
+  rejectSource('aps', 'src/shared/dom_insertion_dispatcher.ts', /forbidden shared source/);
+  for (const artifactId of ['first_display', 'aps']) {
+    rejectSource(
+      artifactId,
+      'src/shared/aps_documents.ts',
+      /unclassified current production source/
+    );
+    rejectSource(
+      artifactId,
+      'src/core/contracts/generated/renderer_validator_document_v1.ts',
+      /unclassified current production source/
+    );
+  }
+  rejectSource('aps', 'src/test/fake_adapter.ts', /test\/fake\/no-op seam/);
+  const vendoredProvider = structuredClone(metrics);
+  vendoredProvider.modules[1].sources.push({
+    file: 'node_modules/prebid.js/build/dist/prebid.js',
+    renderedBytes: 1,
+  });
+  assert.throws(
+    () => bundleBudgets.findProductionGraphViolations(vendoredProvider, release),
+    /sources\[.*\] is invalid/
+  );
+});
+
+test('first-display render ownership is physically split at the source-neutral boundary', () => {
+  const { metrics, release } = readBuildEvidence();
+  const sources = (id) =>
+    new Set(
+      metrics.modules.find(({ file }) => file === `tsjs-${id}.js`).sources.map(({ file }) => file)
+    );
+  const ownerSources = sources('render_owner_initial');
+  const apsSources = sources('aps_initial');
+  const baseSources = sources('first_display');
+
+  assert.equal(ownerSources.has('src/first_display/render_journal.ts'), true);
+  assert.equal(ownerSources.has('src/kernel/contracts/puc_dynamic_owner.ts'), true);
+  assert.equal(ownerSources.has('src/first_display/render_bridge.ts'), false);
+  assert.equal(ownerSources.has('src/first_display/leaf/aps_protocol.ts'), false);
+  assert.equal(apsSources.has('src/first_display/render_bridge.ts'), true);
+  assert.equal(apsSources.has('src/first_display/leaf/aps_protocol.ts'), true);
+  assert.equal(apsSources.has('src/first_display/render_journal.ts'), false);
+  assert.equal(apsSources.has('src/kernel/contracts/puc_dynamic_owner.ts'), false);
+  assert.equal(baseSources.has('src/first_display/render_journal.ts'), false);
+  assert.equal(baseSources.has('src/first_display/adm_render_bridge.ts'), false);
+
+  const ownerBody = fs.readFileSync(
+    path.resolve(libDirectory, '../dist/tsjs-render_owner_initial.js'),
+    'utf8'
+  );
+  const apsLiterals = [...ownerBody.matchAll(/TS APS [A-Za-z ]+/gu)].map(([value]) => value);
+  assert.ok(apsLiterals.length > 0);
+  assert.deepEqual(new Set(apsLiterals), new Set(['TS APS Top Mount Started']));
+
+  const movedJournal = structuredClone(metrics);
+  movedJournal.modules
+    .find(({ file }) => file === 'tsjs-aps_initial.js')
+    .sources.push({ file: 'src/first_display/render_journal.ts', renderedBytes: 1 });
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(movedJournal, release).join('\n'),
+    /render_owner_initial-owned source src\/first_display\/render_journal\.ts/
+  );
+
+  const movedAps = structuredClone(metrics);
+  movedAps.modules
+    .find(({ file }) => file === 'tsjs-render_owner_initial.js')
+    .sources.push({ file: 'src/first_display/render_bridge.ts', renderedBytes: 1 });
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(movedAps, release).join('\n'),
+    /aps_initial-owned source src\/first_display\/render_bridge\.ts/
+  );
+});
+
+test('production bundle graphs scan bootstrap sources for test and fake seams', () => {
+  const { metrics, release } = readBuildEvidence();
+  metrics.bootstrap.sources.push({ file: 'src/test/fake_adapter.ts', renderedBytes: 1 });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /bootstrap reaches production test\/fake\/no-op seam src\/test\/fake_adapter\.ts/
+  );
+});
+
+test('production bundle graphs reject provider implementation modules, not only entries', () => {
+  const { metrics, release } = readBuildEvidence();
+  const gptIndex = release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'gpt');
+  metrics.modules[gptIndex].sources.push({
+    file: 'src/integrations/render_runtime/module.ts',
+    renderedBytes: 1,
+  });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /gpt inlines provider core.*src\/integrations\/render_runtime\/module\.ts/
+  );
+});
+
+test('current provider policy rejects duplicated provider source without capture input', () => {
+  const { metrics, release } = readBuildEvidence();
+  const providerSource = 'src/services/render.ts';
+  const gptIndex = release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'gpt');
+  metrics.modules[gptIndex].sources.push({ file: providerSource, renderedBytes: 1 });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /gpt inlines provider core.*src\/services\/render\.ts/
+  );
+});
+
+test('bundle graph report freezes largest contributions and repeated attributions', () => {
+  const { metrics, release } = readBuildEvidence();
+  const report = bundleBudgets.buildProductionGraphReport(metrics, release);
+
+  assert.equal(report.largestContributions.length, 20);
+  assert.equal(report.largestContributions[0].source, 'src/services/slots.ts');
+  assert.ok(report.repeatedAttributions.some(({ source }) => source === 'src/core/release.ts'));
+});
+
+for (const [consumerId, providerId, providerSource] of [
+  ['gpt_later', 'gpt', 'src/integrations/gpt/module.ts'],
+  ['osano_lifecycle', 'osano_consent', 'src/integrations/osano/consent.ts'],
+  ['prebid_later', 'prebid', 'src/integrations/prebid/module.ts'],
+  ['sourcepoint_lifecycle', 'sourcepoint_consent', 'src/integrations/sourcepoint/consent.ts'],
+  ['gpt_later', 'gpt', 'src/integrations/gpt/startup.ts'],
+  ['prebid_later', 'prebid', 'src/integrations/prebid/startup.ts'],
+  ['diagnostics_presentation', 'gpt_diagnostics', 'src/integrations/gpt_diagnostics/store.ts'],
+]) {
+  test(`production bundle graph rejects ${consumerId} inlining ${providerId} implementation`, () => {
+    const { metrics, release } = readBuildEvidence();
+    const artifactIndex = release.artifacts
+      .filter(({ role }) => role !== 'bootstrap')
+      .findIndex(({ id }) => id === consumerId);
+    metrics.modules[artifactIndex].sources.push({ file: providerSource, renderedBytes: 1 });
+
+    assert.match(
+      bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+      new RegExp(
+        `${consumerId} inlines provider ${providerId}.*${providerSource.replaceAll('.', '\\.')}`
+      )
+    );
+  });
+}
+
+test('takeover bundle graph rejects deferred-presentation-only source ownership', () => {
+  const { metrics, release } = readBuildEvidence();
+  const coreIndex = release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'core');
+  metrics.modules[coreIndex].sources.push({
+    file: 'src/integrations/gpt_diagnostics/exhaustive.ts',
+    renderedBytes: 1,
+  });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /core reaches deferred-owned source src\/integrations\/gpt_diagnostics\/exhaustive\.ts/
+  );
+});
+
+test('production bundle graphs reject actual underscore-named test seams', () => {
+  const { metrics, release } = readBuildEvidence();
+  const apsIndex = release.artifacts
+    .filter(({ role }) => role !== 'bootstrap')
+    .findIndex(({ id }) => id === 'aps');
+  metrics.modules[apsIndex].sources.push({
+    file: 'src/composition/browser_test.ts',
+    renderedBytes: 1,
+  });
+
+  assert.match(
+    bundleBudgets.findProductionGraphViolations(metrics, release).join('\n'),
+    /aps reaches production test\/fake\/no-op seam src\/composition\/browser_test\.ts/
+  );
+});
+
+test('bundle check authenticates frozen captures and reports both without enforcing them', () => {
+  const result = checkBundleBudgets();
+
+  assert.equal(result.roleCorrectStatus, 'immutable-intermediate');
+  assert.equal(result.reviewRemediationStatus, 'immutable-report-only');
+  assert.equal(result.transferCapturesEnforced, false);
+  assert.deepEqual(Object.keys(result.historicalDeltas), [
+    'bootstrap',
+    'minimal',
+    'reference',
+    'maximal',
+  ]);
+  for (const report of Object.values(result.historicalDeltas)) {
+    for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+      assert.equal(
+        report[size].deltaBytes,
+        report[size].currentBytes - report[size].historicalBytes
+      );
+    }
+  }
+  assert.deepEqual(Object.keys(result.frozenTransferReports), [
+    'roleCorrectTransfer',
+    'reviewRemediationTransfer',
+  ]);
+  for (const captureReport of Object.values(result.frozenTransferReports)) {
+    for (const report of Object.values(captureReport)) {
+      for (const size of ['rawBytes', 'gzipBytes', 'brotliBytes']) {
+        assert.equal(
+          report[size].deltaBytes,
+          report[size].currentBytes - report[size].capturedBytes
+        );
+        assert.equal(Object.hasOwn(report[size], 'ceilingBytes'), false);
+      }
+    }
+  }
+
+  const commandReport = bundleBudgets.summarizeBundleBudgetCommandReport(result);
+  assert.equal(commandReport.candidateArchitecture.firstDisplay.reachableMaskCount, 3_584);
+  assert.equal(
+    commandReport.candidateArchitecture.firstDisplay.permittedMaskCount,
+    result.candidateArchitecture.firstDisplay.permittedMasks.length
+  );
+  assert.equal(Object.hasOwn(commandReport.candidateArchitecture.firstDisplay, 'masks'), false);
+});
+
+test('takeover render trace source is data-only and guarded against presentation regression', () => {
+  const traceSource = fs.readFileSync(path.join(libDirectory, 'src/core/trace.ts'), 'utf8');
+  const architectureSource = fs.readFileSync(
+    path.join(libDirectory, 'scripts/check-hard-cutover-absence.mjs'),
+    'utf8'
+  );
+
+  assert.doesNotMatch(
+    traceSource,
+    /\b(?:Document|HTMLElement|MutationObserver)\b|createElement|getElementById|querySelector|clipboard|data-ts-/
+  );
+  assert.match(architectureSource, /core render trace presentation leakage/);
+});
+
+test('bundle budgets are exposed through the package and enforced after the CI build', () => {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(libDirectory, 'package.json'), 'utf8'));
+  const workflow = fs.readFileSync(path.join(repositoryRoot, '.github/workflows/test.yml'), 'utf8');
+  const buildStep = workflow.indexOf('run: npm run build');
+  const releaseStep = workflow.indexOf('run: npm run test:release');
+  const budgetStep = workflow.indexOf('run: npm run check:bundle');
+
+  assert.equal(packageJson.scripts['check:bundle'], 'node scripts/check-bundle-budgets.mjs');
+  assert.notEqual(buildStep, -1);
+  assert.ok(releaseStep > buildStep, 'release verification must run after the TSJS build');
+  assert.ok(budgetStep > buildStep, 'bundle budget check must run after the TSJS build');
+  assert.ok(budgetStep > releaseStep, 'bundle budget check must run after release verification');
+});
+
+test('Vitest bounds worker concurrency with the supported Vitest 4 option', () => {
+  const configSource = fs.readFileSync(path.join(libDirectory, 'vitest.config.ts'), 'utf8');
+
+  assert.doesNotMatch(configSource, /\bthreads\s*:\s*false\b/u);
+  assert.match(configSource, /\bmaxWorkers\s*:\s*2\b/u);
+});
+
+test('hard-cutover absence is exposed once and enforced after both production builds', () => {
+  const packageJson = JSON.parse(fs.readFileSync(path.join(libDirectory, 'package.json'), 'utf8'));
+  const workflow = fs.readFileSync(path.join(repositoryRoot, '.github/workflows/test.yml'), 'utf8');
+  const buildStep = workflow.indexOf('run: npm run build');
+  const externalPrebidStep = workflow.indexOf('run: npm run build:prebid-external');
+  const absenceStep = workflow.indexOf('run: npm run check:hard-cutover-absence');
+
+  assert.equal(
+    packageJson.scripts['check:hard-cutover-absence'],
+    'node scripts/check-hard-cutover-absence.mjs'
+  );
+  assert.equal(
+    packageJson.scripts['check:architecture'],
+    packageJson.scripts['check:hard-cutover-absence'],
+    'architecture and absence commands must share one policy implementation'
+  );
+  assert.notEqual(buildStep, -1);
+  assert.ok(externalPrebidStep > buildStep, 'pure Prebid must build after the TSJS release');
+  assert.ok(absenceStep > externalPrebidStep, 'absence must run after both production builds');
+});
+
+test('hard-cutover policy rejects every retired wire, runtime, and public surface', () => {
+  const retired = [
+    ['src/legacy.ts', '"/integrations/aps/renderer"'],
+    [
+      'src/legacy.ts',
+      "JSON.stringify({message:'Prebid Response',rendererVersion:'4',rendererUrl})",
+    ],
+    ['src/legacy.ts', "port.postMessage({message:'TS APS Start'})"],
+    ['src/legacy.ts', 'window.__tsjs_gpt_enabled = true'],
+    ['src/legacy.ts', 'script.setAttribute("data-ts-gam-attribution", "1")'],
+    ['src/legacy.ts', 'interface TsjsApiV1 {}'],
+    ['src/legacy.ts', 'tsjs.renderAdUnit("slot")'],
+    ['src/legacy.ts', 'tsjs.setConfig({debug: true})'],
+    ['src/legacy.ts', 'const value = tsjs.getConfig()'],
+    ['src/legacy.ts', 'const slots = tsjs.adSlots'],
+    ['src/legacy.ts', 'const trace = tsjs.renders'],
+    ['src/legacy.ts', 'const diagnostics = tsjs.gptDiagnostics'],
+    ['src/legacy.ts', 'tsjs.version = "0.1.0"'],
+    ['src/legacy.ts', 'window.dispatchEvent(new Event("tsjs:adRendered"))'],
+    ['src/composition/browser.ts', 'export function createBrowserRuntime() {}'],
+  ];
+  for (const [file, source] of retired) {
+    assert.ok(
+      findCutoverTextViolations(file, source).length > 0,
+      `retired cutover surface should be rejected: ${source}`
+    );
+  }
+});
+
+test('browser cutover fixtures do not reconstruct the retired integration config carrier', () => {
+  for (const relativePath of [
+    'crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts',
+    'crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts',
+    'crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts',
+  ]) {
+    const source = fs.readFileSync(path.join(repositoryRoot, relativePath), 'utf8');
+    assert.doesNotMatch(source, /_integrationConfig/u, relativePath);
+  }
+});
+
+test('vendor boundary rejects APS, GPT, and PUC artifacts but permits conformance metadata', () => {
+  const vendored = [
+    ['fixtures/prebid-creative.js', 'window._aps = new Map();'],
+    ['fixtures/gpt.js', 'window.googletag = window.googletag || {};'],
+    ['fixtures/gpt.js.map', '{"sources":["gpt.js"]}'],
+    ['fixtures/gpt.js.sha256', 'deadbeef'],
+    ['fixtures/prebid-universal-creative-1.17.2.js', 'window.renderAd = function() {};'],
+    ['fixtures/renamed.js', '/*! Prebid Universal Creative v1.17.2 */'],
+    ['fixtures/renamed.js', '/*! @license Google Publisher Tag */'],
+    ['fixtures/renamed.js', '/*! Copyright Amazon Publisher Services */'],
+    ['fixtures/vendor.json', '{"pucIntegrity":"sha384-deadbeef"}'],
+  ];
+  for (const [file, source] of vendored) {
+    assert.ok(
+      findVendorBoundaryViolations(file, source).length > 0,
+      `vendored upstream artifact should be rejected: ${file}`
+    );
+  }
+  assert.deepEqual(
+    findVendorBoundaryViolations(
+      'browser/helpers/gam-test-network.ts',
+      'export const REAL_GAM_PUC_RELEASE = "1.17.2"; Object.freeze({pucRelease: REAL_GAM_PUC_RELEASE});'
+    ),
+    []
+  );
+  assert.deepEqual(
+    findVendorBoundaryViolations(
+      'browser/fixtures/fictional-aps-runner.js',
+      '// Fictional hermetic APS runner fixture; not copied from APS.\nwindow._aps = new Map();'
+    ),
+    []
+  );
+});
+
+test('hard-cutover scan traverses the complete generated release inventory', () => {
+  const release = JSON.parse(
+    fs.readFileSync(path.resolve(libDirectory, '../dist/tsjs-release-v1.json'), 'utf8')
+  );
+  const generated = new Set(
+    generatedTsjsArtifactFiles(libDirectory).map((file) => path.resolve(file))
+  );
+
+  for (const { file } of release.artifacts) {
+    assert.equal(
+      generated.has(path.resolve(libDirectory, '../dist', file)),
+      true,
+      `hard-cutover scan must traverse generated artifact ${file}`
+    );
+  }
+  assert.equal(
+    generated.has(path.resolve(libDirectory, '../dist/tsjs-release-v1.json')),
+    true,
+    'hard-cutover scan must traverse its generated release manifest'
+  );
+});
+
+test('registered integration dispatch selects post-switch evidence without changing the instrument', () => {
+  const workflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/integration-tests.yml'),
+    'utf8'
+  );
+
+  assert.match(
+    workflow,
+    /mode: \$\{\{ startsWith\(inputs\.evidence_id, 'aps-tsjs-postswitch-'\) && 'postswitch' \|\| 'preswitch' \}\}/
+  );
+});
+
+test('protected real-GAM evidence is dispatchable for an unmerged branch without duplicating the suite', () => {
+  const integrationWorkflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/integration-tests.yml'),
+    'utf8'
+  );
+  const realGamWorkflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/aps-real-gam.yml'),
+    'utf8'
+  );
+  assert.match(realGamWorkflow, /workflow_call:/);
+  assert.doesNotMatch(integrationWorkflow, /real_gam_evidence_id:/);
+  assert.match(
+    integrationWorkflow,
+    /real-gam-attestation:[\s\S]*?startsWith\(inputs\.evidence_id, 'aps-tsjs-cutover-'\)[\s\S]*?uses: \.\/\.github\/workflows\/aps-real-gam\.yml/
+  );
+  assert.match(
+    integrationWorkflow,
+    /real-gam-attestation:[\s\S]*?evidence_id: \$\{\{ inputs\.evidence_id \}\}/
+  );
+});
+
+function workflowJob(source, name) {
+  const marker = `  ${name}:\n`;
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, `workflow must contain ${name}`);
+  const remainder = source.slice(start + marker.length);
+  const nextJob = remainder.search(/^ {2}[a-zA-Z0-9_-]+:\n/mu);
+  return nextJob === -1 ? remainder : remainder.slice(0, nextJob);
+}
+
+test('APS and TSJS workflows keep feature programs in repository script files', () => {
+  const workflows = {
+    performance: fs.readFileSync(
+      path.join(repositoryRoot, '.github/workflows/tsjs-performance-gate.yml'),
+      'utf8'
+    ),
+    realGam: fs.readFileSync(
+      path.join(repositoryRoot, '.github/workflows/aps-real-gam.yml'),
+      'utf8'
+    ),
+    quality: workflowJob(
+      fs.readFileSync(path.join(repositoryRoot, '.github/workflows/test.yml'), 'utf8'),
+      'cutover-quality-evidence'
+    ),
+    conformance: workflowJob(
+      fs.readFileSync(path.join(repositoryRoot, '.github/workflows/integration-tests.yml'), 'utf8'),
+      'browser-tests-aps-tsjs-conformance'
+    ),
+    cutover: workflowJob(
+      fs.readFileSync(path.join(repositoryRoot, '.github/workflows/integration-tests.yml'), 'utf8'),
+      'cutover-suite'
+    ),
+  };
+  const combined = Object.values(workflows).join('\n');
+
+  for (const [name, workflow] of Object.entries(workflows)) {
+    assert.doesNotMatch(workflow, /^\s*run:\s*[>|]/mu, `${name} must not embed a run program`);
+    assert.doesNotMatch(workflow, /\bnode\s+-e\b/u, `${name} must not embed JavaScript`);
+    assert.doesNotMatch(
+      workflow,
+      /(?:^|\n)\s*(?:for|while)\s+\S+/u,
+      `${name} must not embed loops`
+    );
+    assert.doesNotMatch(
+      workflow,
+      /<<-?['"]?[A-Z][A-Z0-9_]*['"]?/u,
+      `${name} must not embed heredocs`
+    );
+  }
+
+  for (const script of [
+    'scripts/ci/read-toolchains.sh',
+    'scripts/ci/aps-real-gam.sh',
+    'scripts/ci/aps-tsjs-cutover.sh',
+    'scripts/ci/aps-tsjs-evidence.mjs',
+    'scripts/ci/aps-tsjs-quality.sh',
+    'scripts/ci/tsjs-performance.sh',
+  ]) {
+    assert.ok(combined.includes(script), `a workflow must invoke ${script}`);
+    assert.ok(fs.existsSync(path.join(repositoryRoot, script)), `${script} must be a real file`);
+  }
+
+  for (const match of combined.matchAll(/(?:bash|node)\s+(scripts\/ci\/[^\s"']+)/gu)) {
+    assert.ok(
+      fs.existsSync(path.join(repositoryRoot, match[1])),
+      `workflow script target must exist: ${match[1]}`
+    );
+  }
+
+  const performanceScript = fs.readFileSync(
+    path.join(repositoryRoot, 'scripts/ci/tsjs-performance.sh'),
+    'utf8'
+  );
+  const performanceConfig =
+    'crates/trusted-server-integration-tests/browser/playwright.performance.config.ts';
+  assert.doesNotMatch(
+    performanceScript,
+    /printf[\s\S]*export default/u,
+    'the performance action must not synthesize an executable config'
+  );
+  assert.ok(
+    performanceScript.includes(`--config="$repository_root/${performanceConfig}"`),
+    'the performance action must invoke its checked-in Playwright config'
+  );
+  assert.ok(
+    fs.existsSync(path.join(repositoryRoot, performanceConfig)),
+    'the performance Playwright config must be a real repository file'
+  );
+  const performanceConfigSource = fs.readFileSync(
+    path.join(repositoryRoot, performanceConfig),
+    'utf8'
+  );
+  assert.match(
+    performanceConfigSource,
+    /timeout: 30_000[\s\S]*retries: 0[\s\S]*workers: 1[\s\S]*browserName: "chromium"/u,
+    'the checked-in performance config must preserve the immutable single-Chromium instrument'
+  );
+});
+
+test('cutover workflows bind exact release evidence and prior artifact provenance', () => {
+  const qualityWorkflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/test.yml'),
+    'utf8'
+  );
+  const integrationWorkflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/integration-tests.yml'),
+    'utf8'
+  );
+  const realGamWorkflow = fs.readFileSync(
+    path.join(repositoryRoot, '.github/workflows/aps-real-gam.yml'),
+    'utf8'
+  );
+  const qualityScript = fs.readFileSync(
+    path.join(repositoryRoot, 'scripts/ci/aps-tsjs-quality.sh'),
+    'utf8'
+  );
+  const cutoverScript = fs.readFileSync(
+    path.join(repositoryRoot, 'scripts/ci/aps-tsjs-cutover.sh'),
+    'utf8'
+  );
+  const evidenceScript = fs.readFileSync(
+    path.join(repositoryRoot, 'scripts/ci/aps-tsjs-evidence.mjs'),
+    'utf8'
+  );
+  const evidenceSelfTest = execFileSync(
+    process.execPath,
+    [path.join(repositoryRoot, 'scripts/ci/aps-tsjs-evidence.mjs'), 'self-test'],
+    { encoding: 'utf8' }
+  );
+  const realGamNetwork = fs.readFileSync(
+    path.join(
+      repositoryRoot,
+      'crates/trusted-server-integration-tests/browser/helpers/gam-test-network.ts'
+    ),
+    'utf8'
+  );
+  const hardCutoverPolicy = fs.readFileSync(
+    path.join(
+      repositoryRoot,
+      'crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs'
+    ),
+    'utf8'
+  );
+
+  for (const [name, workflow] of [
+    ['quality', qualityWorkflow],
+    ['integration', integrationWorkflow],
+    ['real-GAM', realGamWorkflow],
+  ]) {
+    assert.match(workflow, /evidence_id:[\s\S]*?required: true/, `${name} evidence id`);
+    assert.match(workflow, /release_id:[\s\S]*?required: true/, `${name} release id`);
+    assert.match(workflow, /scripts\/ci\/aps-tsjs-evidence\.mjs/, `${name} evidence script`);
+  }
+  for (const [name, workflow] of [
+    ['integration', integrationWorkflow],
+    ['real-GAM', realGamWorkflow],
+  ]) {
+    assert.match(workflow, /previous_artifact_id:[\s\S]*?required: true/, `${name} prior input`);
+  }
+  assert.match(evidenceScript, /evidence-manifest\.json/);
+  assert.match(evidenceScript, /commitSha/);
+  assert.match(evidenceScript, /runId/);
+  assert.match(evidenceScript, /conclusion/);
+  assert.match(evidenceScript, /previousArtifactId/);
+  assert.match(evidenceSelfTest, /APS\/TSJS evidence self-test passed/);
+  assert.match(qualityWorkflow, /aps-tsjs-quality-\$\{\{ github\.run_id \}\}/);
+  assert.match(qualityScript, /set -euo pipefail[\s\S]*?quality\.log/);
+  assert.match(qualityScript, /tsjs-build-metrics-v1\.json/);
+  assert.match(integrationWorkflow, /aps-tsjs-cutover-\$\{\{ github\.sha \}\}/);
+  assert.match(cutoverScript, /for runtime in axum fastly cloudflare spin/);
+  assert.match(cutoverScript, /aps-proxy-\$runtime\.log/);
+  assert.match(cutoverScript, /--project=chromium --project=firefox --project=webkit/);
+  assert.match(
+    cutoverScript,
+    /TS_BROWSER_PROJECTS=chromium,firefox,webkit[\s\\]*npx playwright test/,
+    'the cutover script must declare every requested Playwright project itself'
+  );
+  assert.match(integrationWorkflow, /Scrub all integration evidence before upload/);
+  assert.match(realGamWorkflow, /aps-real-gam-\$\{\{ github\.run_id \}\}/);
+  assert.match(evidenceScript, /capabilities\?/);
+  assert.match(realGamNetwork, /pucRelease\.value !== expectedPucRelease/);
+  assert.match(hardCutoverPolicy, /PUC package is vendored into the local harness/);
+});
+
+test('release id changes independently with id, role, phase, trigger, bytes, and order', () => {
+  const base = [bundle('core', 'a'), bundle('gpt', 'b')];
+  assert.notEqual(computeReleaseId(base), computeReleaseId([bundle('changed', 'a'), base[1]]));
+  assert.notEqual(computeReleaseId(base), computeReleaseId([bundle('core', 'a', 'core'), base[1]]));
+  assert.notEqual(
+    computeReleaseId(base),
+    computeReleaseId([bundle('core', 'a', 'integration', 'deferred'), base[1]])
+  );
+  assert.notEqual(
+    computeReleaseId(base),
+    computeReleaseId([
+      bundle('core', 'a', 'integration', 'takeover', 'first_display_or_idle'),
+      base[1],
+    ])
+  );
+  assert.notEqual(computeReleaseId(base), computeReleaseId([bundle('core', 'changed'), base[1]]));
+  assert.notEqual(computeReleaseId(base), computeReleaseId([base[1], base[0]]));
+});
+
+test('u64 length framing distinguishes ambiguous concatenations and artifact counts', () => {
+  const left = [bundle('a', 'bc'), bundle('d', 'e')];
+  const right = [bundle('ab', 'c'), bundle('d', 'e')];
+  assert.notEqual(computeReleaseId(left), computeReleaseId(right));
+  assert.notEqual(computeReleaseId([bundle('a', 'bc')]), computeReleaseId(left));
+});
+
+test('sentinel multiplicity and remnants fail closed', () => {
+  assert.throws(() => computeReleaseId([bundle('core', RELEASE_SENTINEL)]), /exactly one/);
+  assert.throws(
+    () =>
+      computeReleaseId([
+        {
+          id: 'core',
+          role: 'core',
+          phase: '',
+          trigger: '',
+          bytes: Buffer.from('none'),
+        },
+      ]),
+    /exactly one/
+  );
+  assert.throws(() => stampRelease(`${RELEASE_SENTINEL}${RELEASE_SENTINEL}`, 'a'.repeat(64)));
+});
+
+test('wrong release and missing bundle fail validation', () => {
+  const release = computeReleaseId([bundle('core', 'a')]);
+  const stamped = stampRelease(bundle('core', 'a').bytes, release);
+  assert.doesNotThrow(() =>
+    validateStampedRelease([{ id: 'core', bytes: stamped }], release, ['core'])
+  );
+  assert.throws(() =>
+    validateStampedRelease([{ id: 'core', bytes: stamped }], 'b'.repeat(64), ['core'])
+  );
+  assert.throws(() =>
+    validateStampedRelease([{ id: 'core', bytes: stamped }], release, ['core', 'gpt'])
+  );
+});
diff --git a/crates/trusted-server-js/lib/test/composition/browser-node-import.test.ts b/crates/trusted-server-js/lib/test/composition/browser-node-import.test.ts
new file mode 100644
index 000000000..344b4b141
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/composition/browser-node-import.test.ts
@@ -0,0 +1,16 @@
+// @vitest-environment node
+
+import { describe, expect, it } from 'vitest';
+
+describe('browser composition in a non-DOM runtime', () => {
+  it('imports without claiming browser globals and constructs the no-op composition', async () => {
+    expect(globalThis.document).toBeUndefined();
+
+    const { createNoopBrowserComposition } = await import('../../src/composition/browser_test');
+    const composition = createNoopBrowserComposition();
+
+    expect(Object.isFrozen(composition)).toBe(true);
+    expect(Object.isFrozen(composition.adapters)).toBe(true);
+    expect(composition.adapters.messaging.createChannel()).toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/composition/browser.test.ts b/crates/trusted-server-js/lib/test/composition/browser.test.ts
new file mode 100644
index 000000000..a248f68b3
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/composition/browser.test.ts
@@ -0,0 +1,4147 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createBrowserGoogletagAdapter,
+  createNoopGoogletagAdapter,
+  type GoogletagAdapter,
+  type GoogletagBindingStatus,
+  type GoogletagDiagnosticsFact,
+  type GoogletagDiagnosticsObserver,
+  type GoogletagFacade,
+  type GoogletagPublisherCallObserver,
+  type GoogletagPublisherRefreshCall,
+  type GptSlotTokenV1,
+  type GptTraceCycleOrdinalV1,
+} from '../../src/adapters/googletag';
+import {
+  createBrowserMessagingAdapter,
+  createNoopMessagingAdapter,
+  type CaptureMessageListener,
+  type MessagingAdapter,
+} from '../../src/adapters/messaging';
+import {
+  createNoopPrebidAdapter,
+  PrebidAdmissionContractError,
+  type PrebidAdapter,
+  type PrebidBindingStatus,
+  type PrebidEventFacade,
+  type PrebidFacade,
+  type PrebidTrustedServerAuctionV1,
+  type PreparedTrustedBidV1,
+} from '../../src/adapters/prebid';
+import {
+  BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID,
+  BROWSER_TEST_TRACE_PROVIDER_ID,
+  createBrowserComposition,
+  createNoopBrowserComposition,
+  createTestBrowserRuntimeComposition,
+} from '../../src/composition/browser_test';
+import { log as localLog } from '../../src/core/log';
+import {
+  createDiagnosticsPresentationIntegrationRegistration,
+  TRACE_PANEL_ID,
+} from '../../src/integrations/gpt_diagnostics/presentation';
+import type { BrowserAuctionBidV1, BrowserAuctionProjectionV1 } from '../../src/core/types';
+import { createCreativeIntegrationRegistration as createProductionCreativeIntegrationRegistration } from '../../src/integrations/creative/module';
+import { createDataDomeIntegrationRegistration } from '../../src/integrations/datadome/module';
+import { createDidomiIntegrationRegistration } from '../../src/integrations/didomi/module';
+import { createGoogleTagManagerIntegrationRegistration } from '../../src/integrations/google_tag_manager/module';
+import { createLegacyGptRegistrationForTest as createGptIntegrationRegistration } from '../helpers/legacy_gpt_registration';
+import { isGuardInstalled, resetGuardState } from '../../src/integrations/gpt/script_guard';
+import { createGptDiagnosticsIntegrationRegistration } from '../../src/integrations/gpt_diagnostics/module';
+import { createLockrIntegrationRegistration } from '../../src/integrations/lockr/module';
+import { createOsanoIntegrationRegistration } from '../../src/integrations/osano/module';
+import { createOsanoLifecycleIntegrationRegistration } from '../../src/integrations/osano/lifecycle';
+import { createPermutiveIntegrationRegistration } from '../../src/integrations/permutive/module';
+import { createPermutiveLifecycleIntegrationRegistration } from '../../src/integrations/permutive/lifecycle';
+import { createSourcepointIntegrationRegistration } from '../../src/integrations/sourcepoint/module';
+import { createSourcepointLifecycleIntegrationRegistration } from '../../src/integrations/sourcepoint/lifecycle';
+import { createTestlightIntegrationRegistration } from '../../src/integrations/testlight/module';
+import { createRenderRuntimeIntegrationRegistration } from '../../src/integrations/render_runtime/module';
+import { publicLog } from '../../src/kernel/fallback';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+  PreparedIntegration,
+} from '../../src/kernel/integration_registry';
+import { RELEASE_CATALOG } from '../../src/kernel/release_catalog';
+import {
+  createRenderAttempt,
+  type CommittedRenderArtifact,
+  type RenderAttempt,
+} from '../../src/services/render';
+
+const DEFERRED_INTEGRATION_IDS = new Set([
+  'diagnostics_presentation',
+  'gpt_later',
+  'osano_lifecycle',
+  'permutive_lifecycle',
+  'prebid_later',
+  'sourcepoint_lifecycle',
+]);
+
+const GPT_DIAGNOSTICS_TEST_IDS = Object.freeze([
+  BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID,
+  'gpt_diagnostics',
+  'diagnostics_presentation',
+]);
+
+const BROWSER_TEST_OPTIONAL_GPT_DIAG_PROVIDER_ID = 'browser_test_optional_gpt_diag_provider';
+
+function runtimeManifest(releaseId: string, ids: readonly string[]) {
+  return {
+    version: 1 as const,
+    releaseId,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) =>
+      DEFERRED_INTEGRATION_IDS.has(id)
+        ? {
+            id,
+            phase: 'deferred' as const,
+            trigger: 'first_display_or_idle' as const,
+            src: `/static/tsjs=tsjs-${id}.min.js?v=${'d'.repeat(64)}`,
+          }
+        : { id, phase: 'takeover' as const }
+    ),
+  };
+}
+
+function runtimeCatalog(ids: readonly string[]) {
+  return Object.freeze(
+    ids.map((id) => {
+      const canonical = RELEASE_CATALOG.find((entry) => entry.id === id);
+      if (canonical) {
+        return Object.freeze({
+          id,
+          phase: canonical.phase,
+          trigger: canonical.trigger,
+          config: canonical.config,
+          consumes: canonical.consumes,
+          provides: canonical.provides,
+        });
+      }
+      return Object.freeze({
+        id,
+        phase: DEFERRED_INTEGRATION_IDS.has(id) ? ('deferred' as const) : ('takeover' as const),
+        trigger: DEFERRED_INTEGRATION_IDS.has(id) ? ('first_display_or_idle' as const) : null,
+        config: null,
+        consumes: Object.freeze(
+          id === BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID
+            ? ['runtime.v1']
+            : id === 'gpt_diagnostics'
+              ? ['runtime.v1', 'gpt.events.v1']
+              : id === 'diagnostics_presentation'
+                ? ['runtime.v1', 'trace.presentation.v1', 'gpt_diag.v1?gpt_diagnostics_active']
+                : []
+        ),
+        provides: Object.freeze(
+          id === BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID
+            ? ['gpt.events.v1', 'trace.v1', 'trace.presentation.v1']
+            : id === BROWSER_TEST_TRACE_PROVIDER_ID
+              ? ['trace.v1', 'trace.presentation.v1']
+              : id === 'gpt_diagnostics' || id === BROWSER_TEST_OPTIONAL_GPT_DIAG_PROVIDER_ID
+                ? ['gpt_diag.v1']
+                : []
+        ),
+      });
+    })
+  );
+}
+
+function exactLegacyRuntime(
+  interfaces: Readonly<Record<string, unknown>>,
+  id: 'creative' | 'prebid'
+): Readonly<{ activate: (config?: unknown) => () => void; start: (config: unknown) => void }> {
+  const runtime = interfaces[id] as Readonly<{ activate?: unknown; start?: unknown }> | undefined;
+  if (
+    !runtime ||
+    !Object.isFrozen(runtime) ||
+    typeof runtime.activate !== 'function' ||
+    typeof runtime.start !== 'function'
+  ) {
+    throw new TypeError(`${id} test runtime is unavailable`);
+  }
+  return runtime as Readonly<{
+    activate: (config?: unknown) => () => void;
+    start: (config: unknown) => void;
+  }>;
+}
+
+function testTakeoverRegistration(
+  id: string,
+  releaseId: string,
+  prepare: (
+    context: IntegrationPrepareContext
+  ) => PreparedIntegration | PromiseLike<PreparedIntegration>
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id,
+    phase: 'takeover',
+    releaseId,
+    prepareSync: (context: IntegrationPrepareContext) => prepare(context) as PreparedIntegration,
+    prepare,
+  });
+}
+
+function createLegacyPrebidIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces }: IntegrationPrepareContext) => {
+    const runtime = exactLegacyRuntime(interfaces, 'prebid');
+    return Object.freeze({
+      activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+        const release = runtime.activate();
+        onDispose(release);
+        afterCommit(() => runtime.start(config));
+      },
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: 'prebid',
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
+
+function createLegacyCreativeIntegrationRegistration(releaseId: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces }: IntegrationPrepareContext) => {
+    const creative = config as Readonly<{
+      clickGuard?: unknown;
+      enabled?: unknown;
+      renderGuard?: unknown;
+    }>;
+    if (!creative.enabled || (!creative.clickGuard && !creative.renderGuard)) {
+      return Object.freeze({ activate: () => undefined });
+    }
+    const runtime = exactLegacyRuntime(interfaces, 'creative');
+    return Object.freeze({
+      activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+        const release = runtime.activate(config);
+        onDispose(release);
+        afterCommit(() => runtime.start(config));
+      },
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: 'creative',
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
+
+function createTarget() {
+  return {
+    googletag: undefined as unknown,
+    pbjs: undefined as unknown,
+    addEventListener:
+      vi.fn<(type: 'message', listener: CaptureMessageListener, capture: true) => void>(),
+    removeEventListener:
+      vi.fn<(type: 'message', listener: CaptureMessageListener, capture: true) => void>(),
+  };
+}
+
+function browserSlotPlacement(slot: string, divId = slot) {
+  return Object.freeze({
+    slot,
+    gamUnitPath: `/123/${slot}`,
+    divId,
+    formats: Object.freeze([Object.freeze([300, 250] as const)]),
+    targeting: Object.freeze({}),
+  });
+}
+
+function fakeGoogletagAdapter(
+  bindingStatus: () => GoogletagBindingStatus = () => 'pending'
+): GoogletagAdapter {
+  return Object.freeze({ ...createNoopGoogletagAdapter(), bindingStatus });
+}
+
+function synchronousGptAdapter(initialSlots: readonly object[] = []) {
+  type Listener = Readonly<{
+    callback: Parameters<GoogletagFacade['subscribe']>[1];
+    diagnosticsOwner: boolean;
+  }>;
+  const listeners = new Map<string, Set<Listener>>();
+  const physicalSlots: object[] = [...initialSlots];
+  const targeting = new WeakMap<object, Map<string, readonly string[]>>();
+  const bindingToken = Object.freeze({});
+  const display = vi.fn();
+  const refresh = vi.fn();
+  const diagnosticsSlots = new WeakMap<object, GoogletagDiagnosticsFact['slot']>();
+  const diagnosticFacts: GoogletagDiagnosticsFact[] = [];
+  const traceTokens = new WeakMap<object, GptSlotTokenV1>();
+  const traceCycles = new WeakMap<object, GptTraceCycleOrdinalV1>();
+  let traceTokenSequence = 0;
+  let diagnosticsObserver: GoogletagDiagnosticsObserver | undefined;
+  let publisherObserver: GoogletagPublisherCallObserver | undefined;
+  const traceTokenFor = (slot: object): GptSlotTokenV1 => {
+    const existing = traceTokens.get(slot);
+    if (existing) return existing;
+    const token = `gt1_${(++traceTokenSequence).toString(36)}` as GptSlotTokenV1;
+    traceTokens.set(slot, token);
+    return token;
+  };
+  const transactionalDefine: GoogletagFacade['transactionalDefine'] = (
+    definition,
+    isGenerationCurrent,
+    prepareCommit
+  ) => {
+    if (!isGenerationCurrent()) return Object.freeze({ status: 'discarded' as const });
+    const slot = {
+      addService: vi.fn(),
+      getAdUnitPath: () => definition.adUnitPath,
+      getSlotElementId: () => definition.elementId,
+    };
+    const admission = prepareCommit(slot);
+    if (!admission.commit() || !isGenerationCurrent()) {
+      admission.rollback();
+      return Object.freeze({ status: 'discarded' as const });
+    }
+    physicalSlots.push(slot);
+    return Object.freeze({ status: 'defined' as const, slot });
+  };
+  const facade: GoogletagFacade = Object.freeze({
+    adUnitPath: (slot: object) =>
+      'getAdUnitPath' in slot && typeof slot.getAdUnitPath === 'function'
+        ? slot.getAdUnitPath()
+        : undefined,
+    bindingToken: () => bindingToken,
+    clearTargeting: vi.fn((slot: object, key?: string) => {
+      const values = targeting.get(slot);
+      if (key === undefined) values?.clear();
+      else values?.delete(key);
+    }),
+    enableServices: () => undefined,
+    transactionalDefine,
+    display,
+    getTargeting: vi.fn((slot: object, key: string) =>
+      Object.freeze([...(targeting.get(slot)?.get(key) ?? [])])
+    ),
+    observeTargeting: () => Object.assign(vi.fn(), { isCurrent: () => true }),
+    refresh,
+    serviceState: () =>
+      Object.freeze({ apiReady: true, initialLoadDisabled: false, pubadsReady: true }),
+    setTargeting: vi.fn((slot: object, key: string, value: string | readonly string[]) => {
+      const values = targeting.get(slot) ?? new Map<string, readonly string[]>();
+      targeting.set(slot, values);
+      values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+    }),
+    slotElementId: (slot: object) =>
+      'getSlotElementId' in slot && typeof slot.getSlotElementId === 'function'
+        ? slot.getSlotElementId()
+        : undefined,
+    slots: () => Object.freeze([...physicalSlots]),
+    subscribe: (
+      eventType: string,
+      listener: Parameters<GoogletagFacade['subscribe']>[1],
+      diagnosticsOwner = false
+    ) => {
+      const registered = listeners.get(eventType) ?? new Set();
+      const entry = Object.freeze({ callback: listener, diagnosticsOwner });
+      registered.add(entry);
+      listeners.set(eventType, registered);
+      return () => registered.delete(entry);
+    },
+    transactionalReplace: () => Object.freeze({ status: 'destroyed' as const }),
+  });
+  const adapter: GoogletagAdapter = Object.freeze({
+    bindingStatus: () => 'present',
+    enqueueGamAttribution: vi.fn(() => true),
+    diagnosticsIdentity: () => undefined,
+    dispose: vi.fn(),
+    notifyReady: vi.fn(),
+    observeDiagnostics: (observer: GoogletagDiagnosticsObserver) => {
+      if (diagnosticsObserver) return undefined;
+      diagnosticsObserver = observer;
+      return () => {
+        if (diagnosticsObserver === observer) diagnosticsObserver = undefined;
+      };
+    },
+    observePublisherCalls: (observer: GoogletagPublisherCallObserver) => {
+      publisherObserver = observer;
+      return () => {
+        if (publisherObserver === observer) publisherObserver = undefined;
+      };
+    },
+    run: <Value>(command: (gpt: Readonly<GoogletagFacade>) => Value) => {
+      let result: Promise<Value>;
+      try {
+        result = Promise.resolve(command(facade));
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+      return Object.freeze({ status: 'present' as const, result, dispose: vi.fn() });
+    },
+    traceToken: traceTokenFor,
+  });
+  return {
+    adapter,
+    emit: (eventType: string, event: unknown): void => {
+      let acceptedHandle: unknown;
+      const publishFact = (handle: unknown): void => {
+        if (typeof event !== 'object' || event === null || !('slot' in event)) return;
+        const physicalSlot = event.slot;
+        if (typeof physicalSlot !== 'object' || physicalSlot === null) return;
+        let safeSlot = diagnosticsSlots.get(physicalSlot);
+        if (!safeSlot) {
+          const elementId =
+            'getSlotElementId' in physicalSlot &&
+            typeof physicalSlot.getSlotElementId === 'function'
+              ? physicalSlot.getSlotElementId()
+              : undefined;
+          const adUnitPath =
+            'getAdUnitPath' in physicalSlot && typeof physicalSlot.getAdUnitPath === 'function'
+              ? physicalSlot.getAdUnitPath()
+              : undefined;
+          const createdSlot = Object.freeze({
+            token: Object.freeze(Object.create(null) as object),
+            traceToken: traceTokenFor(physicalSlot),
+            ...(typeof elementId === 'string' ? { elementId } : {}),
+            ...(typeof adUnitPath === 'string' ? { adUnitPath } : {}),
+          });
+          diagnosticsSlots.set(physicalSlot, createdSlot);
+          safeSlot = createdSlot;
+        }
+        if (eventType === 'slotRequested' && handle !== undefined) {
+          const next = ((traceCycles.get(physicalSlot) ?? 0) + 1) as GptTraceCycleOrdinalV1;
+          traceCycles.set(physicalSlot, next);
+        }
+        const cycleOrdinal = traceCycles.get(physicalSlot);
+        const fact = Object.freeze({
+          ...event,
+          kind: eventType,
+          observedAtMs: 1,
+          slot: Object.freeze({
+            ...safeSlot,
+            ...(cycleOrdinal === undefined ? {} : { cycleOrdinal }),
+          }),
+        }) as Parameters<GoogletagDiagnosticsObserver>[0];
+        diagnosticFacts.push(fact);
+        diagnosticsObserver?.(fact);
+      };
+      for (const listener of listeners.get(eventType) ?? []) {
+        const handle = listener.callback(event);
+        if (!listener.diagnosticsOwner) {
+          if (handle !== undefined) acceptedHandle = handle;
+          if (eventType === 'slotRequested' || eventType === 'slotRenderEnded') {
+            publishFact(handle);
+          }
+          continue;
+        }
+        publishFact(acceptedHandle);
+      }
+    },
+    diagnosticsObserverActive: () => diagnosticsObserver !== undefined,
+    diagnosticFacts: () => Object.freeze([...diagnosticFacts]),
+    display,
+    listenerInventory: () =>
+      Object.freeze(
+        [...listeners.entries()]
+          .filter(([, registered]) => registered.size > 0)
+          .map(([eventType, registered]) => Object.freeze([eventType, registered.size] as const))
+      ),
+    listenerRoles: (eventType: string) =>
+      Object.freeze(
+        [...(listeners.get(eventType) ?? [])].map((listener) => listener.diagnosticsOwner)
+      ),
+    publisherRefresh: (call: Readonly<GoogletagPublisherRefreshCall>) => {
+      const observer = publisherObserver;
+      if (!observer?.refresh) throw new Error('Publisher observer is unavailable');
+      return observer.refresh(call);
+    },
+    physicalSlots: () => Object.freeze([...physicalSlots]),
+    refresh,
+    targetingFor: (slot: object) => new Map(targeting.get(slot) ?? []),
+  };
+}
+
+function fakePrebidAdapter(
+  bindingStatus: () => PrebidBindingStatus = () => 'pending'
+): PrebidAdapter {
+  return Object.freeze({ ...createNoopPrebidAdapter(), bindingStatus });
+}
+
+function synchronousPrebidAdapter(
+  admission: (prepared: Readonly<PreparedTrustedBidV1>) => 'admitted' | 'not_admitted' = () =>
+    'admitted'
+) {
+  let auctionListener: ((auction: Readonly<PrebidTrustedServerAuctionV1>) => void) | undefined;
+  let auctionEndListener:
+    ((event: unknown, prebid: Readonly<PrebidEventFacade>) => void) | undefined;
+  let admitted: Readonly<PreparedTrustedBidV1> | undefined;
+  const admitTrustedBid = vi.fn((prepared: Readonly<PreparedTrustedBidV1>) => {
+    const result = admission(prepared);
+    if (result === 'admitted') admitted = prepared;
+    return result;
+  });
+  const requestBids = vi.fn();
+  const setTargetingForGpt = vi.fn();
+  const facade = Object.freeze({
+    addAdUnits: vi.fn(),
+    highestBids: vi.fn(() => Object.freeze([])),
+    processQueue: vi.fn(),
+    registerBidAdapter: vi.fn(),
+    registerTrustedServerBidder: vi.fn(
+      (listener: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void) => {
+        auctionListener = listener;
+        return () => {
+          auctionListener = undefined;
+        };
+      }
+    ),
+    renderAd: vi.fn(),
+    requestBids,
+    setTargetingForGpt,
+    subscribe: vi.fn(
+      (
+        eventType: string,
+        listener: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void
+      ) => {
+        if (eventType === 'auctionEnd') auctionEndListener = listener;
+        return () => {
+          if (auctionEndListener === listener) auctionEndListener = undefined;
+        };
+      }
+    ),
+  }) satisfies PrebidFacade;
+  const adapter = Object.freeze({
+    ...createNoopPrebidAdapter(),
+    admitTrustedBid,
+    bindingStatus: () => 'present' as const,
+    run: <Value>(command: (prebid: Readonly<PrebidFacade>) => Value) => {
+      let result: Promise<Value>;
+      try {
+        result = Promise.resolve(command(facade));
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+      return Object.freeze({ status: 'present' as const, result, dispose: vi.fn() });
+    },
+  }) satisfies PrebidAdapter;
+  return {
+    adapter,
+    admitTrustedBid,
+    auction: (auction: Readonly<PrebidTrustedServerAuctionV1>): void => auctionListener?.(auction),
+    auctionEnd: (auctionId: string): void => {
+      const prepared = admitted;
+      const highest = prepared
+        ? Object.freeze([
+            Object.freeze({
+              ...prepared.bid,
+              adUnitCode: prepared.adUnitCode,
+              auctionId: prepared.auctionId,
+            }),
+          ])
+        : Object.freeze([]);
+      auctionEndListener?.(
+        Object.freeze({ auctionId }),
+        Object.freeze({ highestBids: () => highest })
+      );
+    },
+    requestBids,
+    setTargetingForGpt,
+  };
+}
+
+function fakeMessagingAdapter(
+  installCaptureListener: MessagingAdapter['installCaptureListener'] = () => vi.fn()
+): MessagingAdapter {
+  return Object.freeze({ ...createNoopMessagingAdapter(), installCaptureListener });
+}
+
+describe('browser composition', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    document.head.querySelectorAll('script#trustedserver-js').forEach((script) => script.remove());
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: null });
+  });
+
+  it('constructs live adapters without changing production globals', () => {
+    const target = createTarget();
+    const composition = createBrowserComposition({ target });
+
+    expect(composition.adapters.googletag.bindingStatus()).toBe('pending');
+    expect(composition.adapters.prebid.bindingStatus()).toBe('pending');
+    expect(target.addEventListener).not.toHaveBeenCalled();
+
+    target.googletag = {};
+    target.pbjs = {};
+    expect(composition.adapters.googletag.bindingStatus()).toBe('incompatible');
+    expect(composition.adapters.prebid.bindingStatus()).toBe('incompatible');
+
+    target.googletag = 1;
+    target.pbjs = 'not-prebid';
+    expect(composition.adapters.googletag.bindingStatus()).toBe('incompatible');
+    expect(composition.adapters.prebid.bindingStatus()).toBe('incompatible');
+  });
+
+  it('routes the first-display measure through the concrete test composition', async () => {
+    const display = vi.fn();
+    const pubadsService = {};
+    const performance = { mark: vi.fn(), measure: vi.fn() };
+    const target = {
+      ...createTarget(),
+      googletag: {
+        apiReady: true,
+        cmd: {
+          push: (command: () => void): number => {
+            command();
+            return 1;
+          },
+        },
+        display,
+        pubads: vi.fn(() => pubadsService),
+      },
+      performance,
+    };
+    const composition = createBrowserComposition({ target });
+
+    target.googletag.display('publisher-slot');
+    expect(performance.mark).not.toHaveBeenCalled();
+
+    await expect(
+      composition.adapters.googletag.run((gpt) => {
+        gpt.display('authoritative-slot');
+        gpt.display('replay-slot');
+      }).result
+    ).resolves.toBeUndefined();
+
+    expect(performance.mark).toHaveBeenCalledExactlyOnceWith('tsjs:first-display');
+    expect(performance.measure).toHaveBeenCalledExactlyOnceWith(
+      'tsjs:boot-to-first-display',
+      'tsjs:bids-script',
+      'tsjs:first-display'
+    );
+    expect(display).toHaveBeenCalledTimes(3);
+  });
+
+  it('routes an attributable empty GPT cycle through the owned slot and PUC services', async () => {
+    const gpt = synchronousGptAdapter();
+    let prefix = 0;
+    const reservationId = `r1_${'a'.repeat(22)}`;
+    const source = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<main>fictional fallback</main>',
+      width: 300,
+      height: 250,
+    });
+    const bid = Object.freeze({
+      candidateId: 'AAAAAAAAAAAA',
+      slot: 'slot-one',
+      provider: 'trusted',
+      upstreamBidId: 'upstream-one',
+      cpm: 1,
+      currency: 'USD' as const,
+      targeting: Object.freeze({ hb_bidder: 'trusted' }),
+      rendererReservationId: reservationId,
+      renderSource: source,
+    });
+    const projection = Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'initial',
+        results: Object.freeze([
+          Object.freeze({
+            slot: 'slot-one',
+            outcome: 'winner' as const,
+            candidateId: bid.candidateId,
+          }),
+        ]),
+      }),
+      slots: Object.freeze([browserSlotPlacement('slot-one')]),
+      bids: Object.freeze([bid]),
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: projection,
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        createIdentityIssuerForTest: () => {
+          prefix += 1;
+          return createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(prefix);
+              return target;
+            },
+          });
+        },
+      }
+    );
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+    const session = composition.runtimeSessionForTest();
+    const navigation = session?.currentNavigation;
+    const batch = navigation?.createAuctionBatch('gpt-primary');
+    const services = session?.interfaces;
+    const artifacts = services?.['artifacts'];
+    const reservations = composition.reservationServiceForTest();
+    const slots = composition.slotServiceForTest();
+    if (!navigation || !batch || !artifacts || !reservations || !slots) {
+      throw new Error('Expected runtime-owned GPT dependencies');
+    }
+    const createAttempt = (parentAttemptId?: string): RenderAttempt => {
+      const owner = batch.createRenderAttempt('slot-one');
+      if (!owner.ok) throw new Error(owner.reason);
+      const attempt = createRenderAttempt({
+        artifacts: artifacts as Parameters<typeof createRenderAttempt>[0]['artifacts'],
+        owner: owner.value,
+        prepareRenderSource: (candidate) =>
+          typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+            ? (candidate as Readonly<{ type: 'aps' | 'adm'; version: 1 }>)
+            : undefined,
+        reservations,
+        ...(parentAttemptId === undefined ? {} : { parentAttemptId }),
+      });
+      if (!attempt.ok) throw new Error(attempt.reason);
+      return attempt.value;
+    };
+    const ownerResult = batch.createRenderAttempt('slot-one');
+    if (!ownerResult.ok) throw new Error(ownerResult.reason);
+    const primaryResult = createRenderAttempt({
+      artifacts: artifacts as Parameters<typeof createRenderAttempt>[0]['artifacts'],
+      owner: ownerResult.value,
+      prepareRenderSource: () => source,
+      reservations,
+    });
+    if (!primaryResult.ok) throw new Error(primaryResult.reason);
+    const primary = primaryResult.value;
+    const physicalSlot = Object.freeze({});
+    const slotElement = document.createElement('div');
+    slotElement.id = 'slot-one';
+    document.body.append(slotElement);
+    expect(
+      slots.adoptGptSlot(navigation.generation, 'slot-one', {
+        definition: {
+          adUnitPath: '/123/slot-one',
+          elementId: 'slot-one',
+          sizes: Object.freeze([[300, 250]]),
+        },
+        ownership: 'trusted_server',
+        slot: physicalSlot,
+      })
+    ).toEqual({ ok: true });
+    const artifact = Object.freeze({
+      kind: 'puc' as const,
+      attemptId: primary.id,
+      slot: primary.slot,
+      navigationGeneration: primary.navigationGeneration,
+      dispose: vi.fn(),
+    }) satisfies CommittedRenderArtifact;
+    const projectedBid = (
+      navigation.currentAuctionProjection as Readonly<{ bids: readonly BrowserAuctionBidV1[] }>
+    ).bids[0];
+    if (!projectedBid || !('rendererReservationId' in projectedBid)) {
+      throw new Error('Expected the parsed owned projected winner');
+    }
+    const projectedPlacement = (
+      navigation.currentAuctionProjection as Readonly<Pick<BrowserAuctionProjectionV1, 'slots'>>
+    ).slots[0];
+    if (!projectedPlacement) throw new Error('Expected the parsed projected placement');
+    let fallback: RenderAttempt | undefined;
+    const operation = await composition.publishGptWinnerForTest({
+      artifact,
+      attempt: primary,
+      bid: projectedBid,
+      createFallback: (parentAttemptId) => {
+        fallback = createAttempt(parentAttemptId);
+        return Object.freeze({ ok: true as const, value: fallback });
+      },
+      operation: 'refresh',
+      owner: ownerResult.value,
+      placement: projectedPlacement,
+      requestClass: 'primary',
+      slot: physicalSlot,
+    });
+    expect(operation.ok).toBe(true);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(gpt.refresh).toHaveBeenCalledExactlyOnceWith(
+      [physicalSlot],
+      Object.freeze({ changeCorrelator: false })
+    );
+    gpt.emit('slotRequested', { slot: physicalSlot });
+    gpt.emit('slotRenderEnded', {
+      isEmpty: true,
+      responseIdentifier: 'response-one',
+      slot: physicalSlot,
+    });
+    await Promise.resolve();
+
+    expect(primary.snapshot().outcome).toEqual({ outcome: 'failed', reason: 'gam_empty' });
+    expect(fallback).toBeDefined();
+    fallback?.fail('winner_not_renderable');
+    expect(operation.ok && operation.value.snapshot()).toMatchObject({
+      settled: true,
+      result: {
+        path: 'fallback',
+        primary: { outcome: 'failed', reason: 'gam_empty' },
+        fallback: { outcome: 'failed', reason: 'winner_not_renderable' },
+      },
+    });
+    composition.runtime.dispose();
+    slotElement.remove();
+  });
+
+  it('publishes the accepted initial projection through the production GPT lifecycle', async () => {
+    const releaseId = 'a'.repeat(64);
+    const gpt = synchronousGptAdapter();
+    const placement = browserSlotPlacement('initial-slot');
+    const bid = Object.freeze({
+      candidateId: 'AAAAAAAAAAAA',
+      slot: placement.slot,
+      provider: 'trusted',
+      upstreamBidId: 'initial-upstream',
+      cpm: 1.5,
+      currency: 'USD' as const,
+      targeting: Object.freeze({ hb_bidder: 'trusted', pos: 'bid' }),
+      rendererReservationId: `r1_${'i'.repeat(22)}`,
+      renderSource: Object.freeze({
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>initial winner</main>',
+        width: 300,
+        height: 250,
+      }),
+    });
+    const projection = {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'initial-production',
+        results: [
+          { slot: placement.slot, outcome: 'winner' as const, candidateId: bid.candidateId },
+        ],
+      },
+      slots: [{ ...placement, targeting: { pos: 'placement', section: 'news' } }],
+      bids: [bid],
+    };
+    const element = document.createElement('div');
+    element.id = placement.divId;
+    document.body.append(element);
+    let prefix = 0;
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: projection,
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        createIdentityIssuerForTest: () => {
+          prefix += 1;
+          return createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(prefix);
+              return target;
+            },
+          });
+        },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      await vi.waitFor(() => expect(gpt.physicalSlots()).toHaveLength(1));
+      const physicalSlot = gpt.physicalSlots()[0];
+      expect(physicalSlot).toBeDefined();
+      expect(gpt.display).toHaveBeenCalledExactlyOnceWith(physicalSlot);
+      expect(gpt.refresh).not.toHaveBeenCalled();
+      expect(gpt.targetingFor(physicalSlot!)).toEqual(
+        new Map([
+          ['hb_adid', [bid.rendererReservationId]],
+          ['hb_bidder', ['trusted']],
+          ['pos', ['bid']],
+          ['section', ['news']],
+        ])
+      );
+      gpt.emit('slotRequested', { slot: physicalSlot });
+      gpt.emit('slotRenderEnded', {
+        isEmpty: true,
+        responseIdentifier: 'initial-empty-response',
+        slot: physicalSlot,
+      });
+      await vi.waitFor(() => expect(element.querySelector('iframe')).not.toBeNull());
+    } finally {
+      composition.runtime.dispose();
+      element.remove();
+    }
+  });
+
+  it('reuses one publisher GPT slot resolved through a unique responsive DOM prefix', async () => {
+    const releaseId = 'a'.repeat(64);
+    const publisherSlot = {
+      getAdUnitPath: () => '/publisher/existing',
+      getSlotElementId: () => 'responsive-mobile',
+    };
+    const gpt = synchronousGptAdapter([publisherSlot]);
+    const placement = {
+      slot: 'responsive-slot',
+      gamUnitPath: '/123/responsive-slot',
+      divId: 'responsive-',
+      formats: [[300, 250]],
+      targeting: {},
+    };
+    const bid = {
+      candidateId: 'CCCCCCCCCCCC',
+      slot: placement.slot,
+      provider: 'trusted',
+      upstreamBidId: 'responsive-upstream',
+      cpm: 1,
+      currency: 'USD' as const,
+      targeting: {},
+      rendererReservationId: `r1_${'r'.repeat(22)}`,
+      renderSource: {
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>responsive winner</main>',
+        width: 300,
+        height: 250,
+      },
+    };
+    const element = document.createElement('div');
+    element.id = 'responsive-mobile';
+    document.body.append(element);
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: {
+              version: 1,
+              auctionId: 'responsive-initial',
+              results: [
+                { slot: placement.slot, outcome: 'winner' as const, candidateId: bid.candidateId },
+              ],
+            },
+            slots: [placement],
+            bids: [bid],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        createIdentityIssuerForTest: () =>
+          createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(7);
+              return target;
+            },
+          }),
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      await vi.waitFor(() => expect(gpt.refresh).toHaveBeenCalledOnce());
+      expect(gpt.physicalSlots()).toEqual([publisherSlot]);
+      expect(gpt.display).not.toHaveBeenCalled();
+      expect(gpt.refresh).toHaveBeenCalledExactlyOnceWith(
+        [publisherSlot],
+        Object.freeze({ changeCorrelator: false })
+      );
+    } finally {
+      composition.runtime.dispose();
+      element.remove();
+    }
+  });
+
+  it('derives exact APS validation coordinates only for the real browser target', () => {
+    const renderer = {
+      type: 'aps',
+      version: 1,
+      accountId: 'publisher-account',
+      bidId: 'bid-1',
+      tagType: 'iframe',
+      creativeUrl: 'https://creative.example/render',
+      width: 300,
+      height: 250,
+      aaxResponse: 'renderer-envelope',
+    };
+    const message = {
+      message: 'TS APS Top Mount Started',
+      version: 1,
+      lifecycleTicket: 't1_abcdefghijklmnopqrstuv',
+    };
+    const validation = { validateApsRenderer: () => renderer !== undefined };
+
+    const browser = createBrowserComposition({ messagingValidation: validation });
+    expect(
+      browser.adapters.messaging.parseProtocolMessage('apsTopMountStarted', message)
+    ).toBeDefined();
+
+    const injected = createBrowserComposition({
+      target: createTarget(),
+      messagingValidation: validation,
+    });
+    expect(
+      injected.adapters.messaging.parseProtocolMessage('apsTopMountStarted', message)
+    ).toBeDefined();
+  });
+
+  it('installs the capture-phase message listener synchronously and disposes once', () => {
+    const target = createTarget();
+    const composition = createBrowserComposition({ target });
+    const listener = vi.fn();
+
+    const dispose = composition.adapters.messaging.installCaptureListener(listener);
+    expect(dispose).toBeTypeOf('function');
+
+    expect(target.addEventListener).toHaveBeenCalledTimes(1);
+    const installed = target.addEventListener.mock.calls[0]?.[1];
+    expect(installed).toBeTypeOf('function');
+    expect(target.addEventListener).toHaveBeenCalledWith('message', installed, true);
+
+    dispose?.();
+    dispose?.();
+    expect(target.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(target.removeEventListener).toHaveBeenCalledWith('message', installed, true);
+  });
+
+  it('uses exact injected fakes without constructing concrete adapters', () => {
+    const googletag = fakeGoogletagAdapter(() => 'present');
+    const prebid = fakePrebidAdapter(() => 'incompatible');
+    const messaging = fakeMessagingAdapter();
+
+    const composition = createBrowserComposition({
+      adapters: { googletag, messaging, prebid },
+    });
+
+    expect(composition.adapters).toEqual({ googletag, messaging, prebid });
+    expect(Object.isFrozen(composition.adapters)).toBe(true);
+    expect(Object.isFrozen(composition)).toBe(true);
+  });
+
+  it('provides a side-effect-free no-op composition for kernel and service tests', () => {
+    const composition = createNoopBrowserComposition();
+    const listener = vi.fn();
+
+    expect(composition.adapters.googletag.bindingStatus()).toBe('pending');
+    expect(composition.adapters.prebid.bindingStatus()).toBe('pending');
+    const disposeMessaging = composition.adapters.messaging.installCaptureListener(listener);
+    expect(disposeMessaging).toBeUndefined();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('classifies exactly the six deferred integration IDs without a suffix heuristic', () => {
+    const releaseId = 'a'.repeat(64);
+    const deferredIds = Object.freeze([
+      'diagnostics_presentation',
+      'gpt_later',
+      'osano_lifecycle',
+      'permutive_lifecycle',
+      'prebid_later',
+      'sourcepoint_lifecycle',
+    ]);
+    const rows = runtimeManifest(releaseId, [
+      'takeover_lifecycle',
+      ...deferredIds,
+      'later_takeover',
+    ]).integrations;
+
+    expect(rows.map(({ id, phase }) => [id, phase])).toEqual([
+      ['takeover_lifecycle', 'takeover'],
+      ...deferredIds.map((id) => [id, 'deferred']),
+      ['later_takeover', 'takeover'],
+    ]);
+  });
+
+  it.each([false, true])(
+    'installs only the active GPT diagnostics fact path when boot active is %s',
+    async (active) => {
+      const releaseId = 'a'.repeat(64);
+      const target: Record<string, unknown> = {};
+      const gpt = synchronousGptAdapter();
+      const integrationIds = active ? GPT_DIAGNOSTICS_TEST_IDS : Object.freeze([]);
+      const composition = createTestBrowserRuntimeComposition(
+        {
+          target,
+          releaseId,
+          manifest: runtimeManifest(releaseId, integrationIds),
+          knownIntegrationIds: integrationIds,
+          catalog: runtimeCatalog(integrationIds),
+          boot: {
+            auctionProjection: {
+              version: 1,
+              auction: { version: 1, auctionId: 'boot', results: [] },
+              slots: [],
+              bids: [],
+            },
+            creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+            diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active } },
+          },
+          kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+        },
+        {
+          adapters: {
+            googletag: gpt.adapter,
+            messaging: fakeMessagingAdapter(),
+            prebid: fakePrebidAdapter(),
+          },
+          coreActivations: { correctnessGptListeners: vi.fn() },
+        }
+      );
+
+      expect(composition.runtime.start()).toBe(true);
+      if (active) {
+        expect(
+          composition.runtime.registerIntegration(
+            composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+          )
+        ).toBe(true);
+        expect(
+          composition.runtime.registerIntegration(
+            createGptDiagnosticsIntegrationRegistration(releaseId)
+          )
+        ).toBe(true);
+      }
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+      const inventory = Object.fromEntries(gpt.listenerInventory());
+      expect(inventory).toEqual(
+        active
+          ? {
+              impressionViewable: 1,
+              slotOnload: 1,
+              slotRenderEnded: 1,
+              slotRequested: 1,
+              slotResponseReceived: 1,
+              slotVisibilityChanged: 1,
+            }
+          : { slotRenderEnded: 1, slotRequested: 1 }
+      );
+      expect(gpt.diagnosticsObserverActive()).toBe(active);
+      const diagnostics = target['diagnostics'] as
+        { readonly gpt?: { snapshot(): { slots: readonly unknown[] } } } | undefined;
+      expect(Reflect.ownKeys(diagnostics ?? {}).sort()).toEqual(
+        active ? ['gpt', 'renderTrace'] : ['renderTrace']
+      );
+      expect(target).not.toHaveProperty('gpt.events.v1');
+      expect(target).not.toHaveProperty('trace.v1');
+      expect(target).not.toHaveProperty('gpt_diag.v1');
+
+      if (active) {
+        const observedSlot = Object.freeze({
+          getSlotElementId: () => 'diagnostic-slot',
+          getAdUnitPath: () => '/diagnostic/slot',
+        });
+        gpt.emit('slotRequested', { slot: observedSlot });
+        gpt.emit('slotResponseReceived', { slot: observedSlot });
+        gpt.emit('slotRenderEnded', { slot: observedSlot, isEmpty: false, size: [300, 250] });
+        expect(diagnostics?.gpt?.snapshot().slots).toHaveLength(1);
+      }
+
+      composition.runtime.dispose();
+      expect(gpt.diagnosticsObserverActive()).toBe(false);
+    }
+  );
+
+  it('composes the production GPT adapter lifecycle handle through SlotService and ingress into trace', async () => {
+    const releaseId = 'a'.repeat(64);
+    const listeners = new Map<string, Set<(event: unknown) => void>>();
+    const refresh = vi.fn();
+    const pubads = {
+      addEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+        const registered = listeners.get(type) ?? new Set();
+        registered.add(listener);
+        listeners.set(type, registered);
+      }),
+      getSlots: vi.fn(() => [] as object[]),
+      refresh,
+      removeEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+        listeners.get(type)?.delete(listener);
+      }),
+    };
+    const concreteAdapter = createBrowserGoogletagAdapter({
+      googletag: {
+        apiReady: true,
+        pubadsReady: true,
+        cmd: { push: (callback: () => void) => (callback(), 1) },
+        display: vi.fn(),
+        getConfig: vi.fn(() => ({ disableInitialLoad: false })),
+        pubads: vi.fn(() => pubads),
+        setConfig: vi.fn(),
+      },
+      performance: { now: () => 17 },
+    });
+    const integrationIds = GPT_DIAGNOSTICS_TEST_IDS;
+    const target: Record<string, unknown> = {};
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, integrationIds),
+        knownIntegrationIds: integrationIds,
+        catalog: runtimeCatalog(integrationIds),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: {
+              version: 1,
+              auctionId: 'production-adapter-cycle',
+              results: [{ slot: 'production-adapter-slot', outcome: 'no_bid' }],
+            },
+            slots: [browserSlotPlacement('production-adapter-slot')],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: concreteAdapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+    const physicalSlot = Object.freeze({
+      clearTargeting: vi.fn(),
+      getAdUnitPath: () => '/123/production-adapter-slot',
+      getSlotElementId: () => 'production-adapter-slot',
+      getTargeting: vi.fn(() => []),
+      setTargeting: vi.fn(),
+    });
+    const emit = (type: string, fields: Readonly<Record<string, unknown>> = {}): void => {
+      const event = { slot: physicalSlot, ...fields };
+      for (const listener of listeners.get(type) ?? []) listener(event);
+    };
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+        )
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createGptDiagnosticsIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const navigation = composition.runtimeSessionForTest()?.currentNavigation;
+      const slots = composition.slotServiceForTest();
+      if (!navigation || !slots) throw new Error('Expected active production adapter composition');
+      expect(
+        slots.adoptGptSlot(navigation.generation, 'production-adapter-slot', {
+          definition: {
+            adUnitPath: '/123/production-adapter-slot',
+            elementId: 'production-adapter-slot',
+            sizes: Object.freeze([[300, 250]]),
+          },
+          ownership: 'trusted_server',
+          slot: physicalSlot,
+        })
+      ).toEqual({ ok: true });
+      const request = slots.request({
+        intentId: 'production-adapter-request',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'production-adapter-slot',
+        requestClass: 'primary',
+      });
+      await vi.waitFor(() =>
+        expect(refresh).toHaveBeenCalledExactlyOnceWith(
+          [physicalSlot],
+          Object.freeze({ changeCorrelator: false })
+        )
+      );
+
+      emit('slotRequested');
+      emit('slotRenderEnded', { isEmpty: false, responseIdentifier: 'production-response' });
+      await expect(request.result).resolves.toEqual({
+        responseIdentifier: 'production-response',
+        status: 'rendered',
+      });
+      const diagnostics = target['diagnostics'] as {
+        readonly renderTrace: { current(): Readonly<Record<string, unknown>> };
+      };
+      expect(diagnostics.renderTrace.current()['production-adapter-slot']).toEqual(
+        expect.objectContaining({
+          gamEmpty: false,
+          path: 'gam-refresh',
+          rendered: true,
+        })
+      );
+      expect(listeners.get('slotRequested')).toHaveLength(1);
+      expect(listeners.get('slotRenderEnded')).toHaveLength(1);
+    } finally {
+      composition.runtime.dispose();
+    }
+  });
+
+  it('activates reversible core effects in exact order and disposes them in reverse', async () => {
+    const target = {};
+    const order: string[] = [];
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), ['test']),
+        knownIntegrationIds: Object.freeze(['test']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'boot', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: {
+          addAdUnits: vi.fn(),
+          diagnostics: Object.freeze({}),
+          requestAds: vi.fn(),
+        },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          prebid: fakePrebidAdapter(),
+          messaging: fakeMessagingAdapter(() => {
+            order.push('bridge');
+            return () => order.push('dispose-bridge');
+          }),
+        },
+        coreActivations: {
+          correctnessGptListeners: ({ onDispose }, adapters) => {
+            expect(Object.isFrozen(adapters)).toBe(true);
+            onDispose(() => order.push('dispose-gpt'));
+            order.push('gpt');
+          },
+        },
+      }
+    );
+
+    expect(composition.runtime.state).toBe('unclaimed');
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        testTakeoverRegistration(
+          'test',
+          'a'.repeat(64),
+          ({
+            interfaces,
+            onDispose,
+          }: {
+            interfaces: Readonly<Record<string, unknown>>;
+            onDispose(callback: () => void): void;
+          }) => {
+            expect(interfaces).not.toHaveProperty('diagnostics');
+            onDispose(() => order.push('dispose-module'));
+            return Object.freeze({ activate: () => order.push('module') });
+          }
+        )
+      )
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(order).toEqual(['bridge', 'gpt', 'module']);
+    expect(composition.pucBridgeForTest()).toBeDefined();
+    const diagnostics = (
+      target as {
+        diagnostics?: {
+          renderTrace?: {
+            current(): Readonly<Record<string, unknown>>;
+            history(): readonly unknown[];
+            subscribe(listener: (record: unknown) => void): () => void;
+          };
+        };
+      }
+    ).diagnostics;
+    expect(Object.isFrozen(diagnostics)).toBe(true);
+    expect(Reflect.ownKeys(diagnostics ?? {})).toEqual(['renderTrace']);
+    expect(Reflect.ownKeys(diagnostics?.renderTrace ?? {}).sort()).toEqual([
+      'current',
+      'history',
+      'subscribe',
+    ]);
+    expect(diagnostics).not.toHaveProperty('publish');
+    expect(diagnostics).not.toHaveProperty('dispose');
+
+    composition.runtime.dispose();
+    expect(order).toEqual([
+      'bridge',
+      'gpt',
+      'module',
+      'dispose-module',
+      'dispose-gpt',
+      'dispose-bridge',
+    ]);
+    expect(composition.pucBridgeForTest()).toBeUndefined();
+    expect(() => composition.adapters.googletag.run(() => undefined)).toThrowError(
+      expect.objectContaining({ code: 'operation_disposed' })
+    );
+    expect(() => composition.adapters.prebid.run(() => undefined)).toThrowError(
+      expect.objectContaining({ code: 'operation_disposed' })
+    );
+    expect(Object.isFrozen(composition)).toBe(true);
+    expect(Object.isFrozen(composition.runtime)).toBe(true);
+    expect(diagnostics?.renderTrace?.current()).toEqual({});
+    expect(diagnostics?.renderTrace?.history()).toEqual([]);
+  });
+
+  it('starts core slot listeners before module activation and disposes both listeners', async () => {
+    const releaseId = 'a'.repeat(64);
+    const subscriptions: string[] = [];
+    const releases: string[] = [];
+    const facade = {
+      bindingToken: () => Object.freeze({}),
+      subscribe: (eventType: string) => {
+        subscriptions.push(eventType);
+        return () => releases.push(eventType);
+      },
+    } as unknown as GoogletagFacade;
+    const googletag: GoogletagAdapter = Object.freeze({
+      bindingStatus: () => 'present',
+      enqueueGamAttribution: vi.fn(() => true),
+      diagnosticsIdentity: () => undefined,
+      dispose: vi.fn(),
+      notifyReady: vi.fn(),
+      observeDiagnostics: () => vi.fn(),
+      observePublisherCalls: () => vi.fn(),
+      traceToken: () => undefined,
+      run: <T>(command: (gpt: Readonly<GoogletagFacade>) => T) => {
+        const result = Promise.resolve(command(facade));
+        return Object.freeze({ status: 'present' as const, result, dispose: vi.fn() });
+      },
+    });
+    const correctness = vi.fn(
+      (
+        _context: unknown,
+        _adapters: unknown,
+        services: { readonly slots: { readonly snapshotForTest: () => { records: number } } }
+      ) => {
+        expect(subscriptions).toEqual(['slotRequested', 'slotRenderEnded']);
+        expect(services.slots.snapshotForTest().records).toBe(0);
+      }
+    );
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag,
+          messaging: fakeMessagingAdapter(() => {
+            expect(subscriptions).toEqual([]);
+            return vi.fn();
+          }),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: {
+          correctnessGptListeners: correctness,
+        },
+        gptStartupForTest: () => {
+          expect(subscriptions).toEqual(['slotRequested', 'slotRenderEnded']);
+        },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(correctness).toHaveBeenCalledOnce();
+    composition.runtime.dispose();
+    expect(releases).toEqual(['slotRenderEnded', 'slotRequested']);
+  });
+
+  it('activates one six-fact GPT diagnostics stream and publishes only diagnostics.gpt', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target: Record<string, unknown> = {};
+    const gpt = synchronousGptAdapter();
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, GPT_DIAGNOSTICS_TEST_IDS),
+        knownIntegrationIds: GPT_DIAGNOSTICS_TEST_IDS,
+        catalog: runtimeCatalog(GPT_DIAGNOSTICS_TEST_IDS),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+      )
+    ).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        createGptDiagnosticsIntegrationRegistration(releaseId)
+      )
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+    expect(gpt.diagnosticsObserverActive()).toBe(true);
+    expect(
+      [...gpt.listenerInventory()].sort(([left], [right]) => left.localeCompare(right))
+    ).toEqual([
+      ['impressionViewable', 1],
+      ['slotOnload', 1],
+      ['slotRenderEnded', 1],
+      ['slotRequested', 1],
+      ['slotResponseReceived', 1],
+      ['slotVisibilityChanged', 1],
+    ]);
+    const diagnostics = target['diagnostics'] as
+      | {
+          readonly gpt?: {
+            snapshot(): { readonly slots: readonly { readonly slotElementId?: string }[] };
+          };
+          readonly renderTrace?: object;
+        }
+      | undefined;
+    expect(Reflect.ownKeys(diagnostics ?? {}).sort()).toEqual(['gpt', 'renderTrace']);
+    expect(Reflect.ownKeys(diagnostics?.gpt ?? {}).sort()).toEqual(
+      ['export', 'hide', 'show', 'snapshot', 'subscribe'].sort()
+    );
+    expect(diagnostics).not.toHaveProperty('publish');
+    expect(target['gptDiagnostics']).toBeUndefined();
+    expect(target['__tsjs_gpt_diagnostics_runtime']).toBeUndefined();
+
+    const observedSlot = Object.freeze({
+      getSlotElementId: () => 'composition-slot',
+      getAdUnitPath: () => '/example/composition-slot',
+    });
+    gpt.emit('slotRequested', { slot: observedSlot });
+    gpt.emit('slotResponseReceived', { slot: observedSlot });
+    expect(diagnostics?.gpt?.snapshot().slots[0]?.slotElementId).toBe('composition-slot');
+
+    composition.runtime.dispose();
+    await Promise.resolve();
+    expect(gpt.diagnosticsObserverActive()).toBe(false);
+    expect(gpt.listenerInventory()).toEqual([]);
+  });
+
+  it('keeps the core diagnostics ingress private from integration modules', async () => {
+    const releaseId = 'a'.repeat(64);
+    const gpt = synchronousGptAdapter();
+    const integrationIds = Object.freeze([
+      BROWSER_TEST_DIAGNOSTICS_PROVIDER_ID,
+      'diagnostics_probe',
+      'gpt_diagnostics',
+      'diagnostics_presentation',
+    ]);
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, integrationIds),
+        knownIntegrationIds: integrationIds,
+        catalog: runtimeCatalog(integrationIds),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+        )
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          testTakeoverRegistration(
+            'diagnostics_probe',
+            releaseId,
+            ({ interfaces }: IntegrationPrepareContext) => {
+              expect(interfaces).not.toHaveProperty('diagnostics');
+              const trace = interfaces['trace.v1'] as Readonly<Record<string, unknown>>;
+              expect(Reflect.ownKeys(trace).sort()).toEqual(
+                ['diagnostics', 'enrich', 'observations', 'prune', 'record'].sort()
+              );
+              expect(Reflect.ownKeys(trace['observations'] as object)).toEqual(['publish']);
+              expect(trace).not.toHaveProperty('attachPresentation');
+              return Object.freeze({ activate: vi.fn() });
+            }
+          )
+        )
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createGptDiagnosticsIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    } finally {
+      composition.runtime.dispose();
+    }
+  });
+
+  it('routes safe GPT facts into the same-impression render trace state machine', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target: Record<string, unknown> = {};
+    const gpt = synchronousGptAdapter();
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, GPT_DIAGNOSTICS_TEST_IDS),
+        knownIntegrationIds: GPT_DIAGNOSTICS_TEST_IDS,
+        catalog: runtimeCatalog(GPT_DIAGNOSTICS_TEST_IDS),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+        )
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createGptDiagnosticsIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const addAdUnits = target['addAdUnits'] as (unit: unknown) => unknown;
+      addAdUnits({
+        code: 'gpt-trace-slot',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      });
+      const physicalSlot = Object.freeze({
+        getSlotElementId: () => 'gpt-trace-slot',
+        getAdUnitPath: () => '/example/gpt-trace-slot',
+      });
+      const navigation = composition.runtimeSessionForTest()?.currentNavigation;
+      if (!navigation) throw new Error('Expected active navigation');
+      expect(
+        composition.slotServiceForTest()?.adoptGptSlot(navigation.generation, 'gpt-trace-slot', {
+          ownership: 'publisher',
+          slot: physicalSlot,
+        })
+      ).toEqual({ ok: true });
+      expect(gpt.listenerRoles('slotRequested')).toEqual([false]);
+
+      gpt.emit('slotRequested', { slot: physicalSlot });
+      expect(composition.slotServiceForTest()?.snapshotForTest().cycles).toBe(1);
+      gpt.emit('slotRenderEnded', { slot: physicalSlot, isEmpty: false });
+      gpt.emit('impressionViewable', { slot: physicalSlot });
+      expect(gpt.diagnosticFacts().map((fact) => [fact.kind, fact.slot.cycleOrdinal])).toEqual([
+        ['slotRequested', 1],
+        ['slotRenderEnded', 1],
+        ['impressionViewable', 1],
+      ]);
+
+      const diagnostics = target['diagnostics'] as {
+        renderTrace: {
+          current(): Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+          history(): readonly Readonly<Record<string, unknown>>[];
+        };
+      };
+      expect(diagnostics.renderTrace.current()['gpt-trace-slot']).toEqual(
+        expect.objectContaining({
+          path: 'gam-refresh',
+          rendered: true,
+          gamEmpty: false,
+          injected: false,
+          visible: true,
+          servedFrom: 'gam',
+        })
+      );
+      expect(diagnostics.renderTrace.history()).toHaveLength(1);
+    } finally {
+      composition.runtime.dispose();
+    }
+  });
+
+  it('reconciles a trusted terminal that arrives after the GPT render fact', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target: Record<string, unknown> = {};
+    const gpt = synchronousGptAdapter();
+    const renderSource = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<div>reverse-order winner</div>',
+      width: 300,
+      height: 250,
+    });
+    const auctionFetcher = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        id: 'reverse-auction',
+        cur: 'USD',
+        seatbid: [
+          {
+            seat: 'fictional',
+            bid: [
+              {
+                id: 'r1_AAAAAAAAAAAAAAAAAAAAAA',
+                impid: 'reverse-order-slot',
+                price: 1,
+                adm: renderSource.adm,
+                w: renderSource.width,
+                h: renderSource.height,
+                ext: {
+                  trusted_server: {
+                    candidate_id: 'AAAAAAAAAAAA',
+                    slot_id: 'reverse-order-slot',
+                    render_source: renderSource,
+                  },
+                },
+              },
+            ],
+          },
+        ],
+        ext: {
+          trusted_server: {
+            slot_results: {
+              version: 1,
+              auctionId: 'reverse-auction',
+              results: [
+                {
+                  slot: 'reverse-order-slot',
+                  outcome: 'winner',
+                  candidateId: 'AAAAAAAAAAAA',
+                },
+              ],
+            },
+          },
+        },
+      }),
+    }));
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, GPT_DIAGNOSTICS_TEST_IDS),
+        knownIntegrationIds: GPT_DIAGNOSTICS_TEST_IDS,
+        catalog: runtimeCatalog(GPT_DIAGNOSTICS_TEST_IDS),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        auctionFetcherForTest: auctionFetcher,
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          composition.createDiagnosticsCapabilityProviderRegistrationForTest()
+        )
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createGptDiagnosticsIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const api = target as {
+        addAdUnits(value: unknown): unknown;
+        requestAds(options: unknown): Promise<unknown>;
+        diagnostics: {
+          renderTrace: {
+            current(): Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+            history(): readonly Readonly<Record<string, unknown>>[];
+          };
+        };
+      };
+      api.addAdUnits({
+        code: 'reverse-order-slot',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      });
+      document.body.innerHTML = '<div id="reverse-order-slot"></div>';
+      const physicalSlot = Object.freeze({
+        getSlotElementId: () => 'reverse-order-slot',
+        getAdUnitPath: () => '/example/reverse-order-slot',
+      });
+      const navigation = composition.runtimeSessionForTest()?.currentNavigation;
+      if (!navigation) throw new Error('Expected active navigation');
+      expect(
+        composition
+          .slotServiceForTest()
+          ?.adoptGptSlot(navigation.generation, 'reverse-order-slot', {
+            ownership: 'publisher',
+            slot: physicalSlot,
+          })
+      ).toEqual({ ok: true });
+      gpt.emit('slotRequested', { slot: physicalSlot });
+      gpt.emit('slotRenderEnded', { slot: physicalSlot, isEmpty: false });
+      const provisional = api.diagnostics.renderTrace.current()['reverse-order-slot'];
+
+      const request = api.requestAds({ slots: ['reverse-order-slot'] });
+      await vi.waitFor(() =>
+        expect(document.querySelector('#reverse-order-slot iframe')).not.toBeNull()
+      );
+      document
+        .querySelector<HTMLIFrameElement>('#reverse-order-slot iframe')
+        ?.dispatchEvent(new Event('load'));
+      await expect(request).resolves.toEqual({
+        slots: [{ slot: 'reverse-order-slot', path: 'primary', outcome: 'accepted' }],
+      });
+
+      expect(api.diagnostics.renderTrace.current()['reverse-order-slot']).toEqual(
+        expect.objectContaining({
+          seq: provisional?.['seq'],
+          count: provisional?.['count'],
+          at: provisional?.['at'],
+          path: 'auction',
+          rendered: true,
+          injected: true,
+          gamEmpty: false,
+          servedFrom: 'inline',
+        })
+      );
+      expect(api.diagnostics.renderTrace.history()).toHaveLength(1);
+      gpt.emit('slotVisibilityChanged', { slot: physicalSlot, inViewPercentage: 0 });
+      expect(api.diagnostics.renderTrace.current()['reverse-order-slot']).toEqual(
+        expect.objectContaining({ seq: provisional?.['seq'], path: 'auction', visible: false })
+      );
+      expect(api.diagnostics.renderTrace.history()).toHaveLength(1);
+    } finally {
+      composition.runtime.dispose();
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('injects GPT and Prebid module boundaries with only server-frozen configuration', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target = {};
+    const gptConfig = Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled: true });
+    const prebidConfig = Object.freeze({
+      accountId: 'test',
+      timeout: 1_000,
+      debug: false,
+      bidders: Object.freeze(['rubicon']),
+      clientSideBidders: Object.freeze(['rubicon']),
+      excludedGamAdUnitPathSuffixes: Object.freeze<string[]>([]),
+    });
+    const providedBindings = vi.fn((id: string) => ({
+      config: id === 'prebid' ? prebidConfig : gptConfig,
+      interfaces: Object.freeze({ publisherControlled: Object.freeze({}) }),
+    }));
+    const startGpt = vi.fn((received: unknown) => {
+      expect(received).toEqual(gptConfig);
+      expect(Object.isFrozen(received)).toBe(true);
+      expect((target as { version?: unknown }).version).toBe('1.0.0');
+    });
+    const startPrebid = vi.fn((received: unknown) => {
+      expect(received).toEqual(prebidConfig);
+      expect(Object.isFrozen(received)).toBe(true);
+      expect((target as { version?: unknown }).version).toBe('1.0.0');
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt', 'prebid']),
+        knownIntegrationIds: Object.freeze(['gpt', 'prebid']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          integrations: {
+            version: 1,
+            entries: [
+              { id: 'gpt', config: gptConfig },
+              { id: 'prebid', config: prebidConfig },
+            ],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: providedBindings,
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(() => vi.fn()),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        gptStartupForTest: startGpt,
+        prebidStartupForTest: startPrebid,
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createLegacyPrebidIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+      expect(providedBindings).toHaveBeenCalledTimes(2);
+      expect(providedBindings).toHaveBeenNthCalledWith(1, 'gpt');
+      expect(providedBindings).toHaveBeenNthCalledWith(2, 'prebid');
+      expect(startGpt).toHaveBeenCalledExactlyOnceWith(gptConfig);
+      expect(startPrebid).toHaveBeenCalledExactlyOnceWith(prebidConfig);
+      expect(isGuardInstalled()).toBe(true);
+      expect(composition.runtimeSessionForTest()?.interfaces).not.toHaveProperty(
+        'publisherControlled'
+      );
+    } finally {
+      composition.runtime.dispose();
+      resetGuardState();
+    }
+    expect(isGuardInstalled()).toBe(false);
+  });
+
+  it('composes the configured Prebid refresh policy through the owned GPT boundary', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target: Record<string, unknown> = {};
+    const gpt = synchronousGptAdapter();
+    const prebid = synchronousPrebidAdapter();
+    const prebidConfig = Object.freeze({
+      accountId: 'test',
+      timeout: 1_500,
+      debug: false,
+      bidders: Object.freeze(['client']),
+      clientSideBidders: Object.freeze(['client']),
+      excludedGamAdUnitPathSuffixes: Object.freeze<string[]>([]),
+    });
+    let request:
+      | Readonly<{
+          adUnits: readonly object[];
+          bidsBackHandler: () => void;
+          timeout: number;
+        }>
+      | undefined;
+    prebid.requestBids.mockImplementation((candidate: unknown) => {
+      request = candidate as typeof request;
+      request?.bidsBackHandler();
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt', 'prebid']),
+        knownIntegrationIds: Object.freeze(['gpt', 'prebid']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          integrations: {
+            version: 1,
+            entries: [
+              {
+                id: 'gpt',
+                config: { gamAttributionEnabled: false, pageBidsEnabled: true },
+              },
+              { id: 'prebid', config: prebidConfig },
+            ],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: (id) => ({
+          config: id === 'prebid' ? prebidConfig : Object.freeze({}),
+          interfaces: Object.freeze({}),
+        }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: prebid.adapter,
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+    ).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(createLegacyPrebidIntegrationRegistration(releaseId))
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+    const api = target as {
+      addAdUnits(unit: unknown): Readonly<{ registered: readonly string[] }>;
+    };
+    expect(
+      api.addAdUnits({
+        code: 'refresh-slot',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [
+          { bidder: 'server', params: { placement: 7 } },
+          { bidder: 'client', params: { placement: 'browser' } },
+        ],
+      })
+    ).toEqual({ registered: ['refresh-slot'] });
+    const navigation = composition.runtimeSessionForTest()?.currentNavigation;
+    const slots = composition.slotServiceForTest();
+    const physicalSlot = Object.freeze({ getAdUnitPath: () => '/network/refresh-slot' });
+    if (!navigation || !slots) throw new Error('Expected the active refresh composition');
+    expect(
+      slots.adoptGptSlot(navigation.generation, 'refresh-slot', {
+        definition: {
+          adUnitPath: '/network/refresh-slot',
+          elementId: 'refresh-slot',
+          sizes: Object.freeze([[300, 250]]),
+        },
+        ownership: 'publisher',
+        slot: physicalSlot,
+      })
+    ).toEqual({ ok: true });
+
+    const refreshOptions = Object.freeze({ changeCorrelator: false });
+    const decision = gpt.publisherRefresh(
+      Object.freeze({
+        requestedSlots: Object.freeze([physicalSlot]),
+        slots: Object.freeze([physicalSlot]),
+        options: refreshOptions,
+      })
+    );
+    expect(decision).toMatchObject({
+      action: 'defer',
+      slots: [physicalSlot],
+      completion: expect.any(Promise),
+    });
+    if (decision?.action !== 'defer') throw new Error('Expected the composed refresh policy');
+    await decision.completion;
+
+    expect(request?.timeout).toBe(1_500);
+    expect(request?.adUnits).toEqual([
+      {
+        code: 'refresh-slot',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [
+          {
+            bidder: 'trustedServer',
+            params: { bidderParams: { server: { placement: 7 } } },
+          },
+          { bidder: 'client', params: { placement: 'browser' } },
+        ],
+      },
+    ]);
+    expect(prebid.setTargetingForGpt).toHaveBeenCalledExactlyOnceWith(['refresh-slot']);
+    composition.runtime.dispose();
+  });
+
+  it('owns every remaining integration in one maximal composed transaction', async () => {
+    vi.useFakeTimers();
+    const releaseId = 'a'.repeat(64);
+    const target = {};
+    const takeoverMembers = Object.freeze([
+      ['render_runtime', createRenderRuntimeIntegrationRegistration] as const,
+      ['datadome', createDataDomeIntegrationRegistration] as const,
+      ['didomi', createDidomiIntegrationRegistration] as const,
+      ['google_tag_manager', createGoogleTagManagerIntegrationRegistration] as const,
+      ['lockr', createLockrIntegrationRegistration] as const,
+      ['osano_consent', createOsanoIntegrationRegistration] as const,
+      ['permutive_context', createPermutiveIntegrationRegistration] as const,
+      ['sourcepoint_consent', createSourcepointIntegrationRegistration] as const,
+      ['testlight', createTestlightIntegrationRegistration] as const,
+    ]);
+    const deferredMembers = Object.freeze([
+      ['osano_lifecycle', createOsanoLifecycleIntegrationRegistration] as const,
+      ['permutive_lifecycle', createPermutiveLifecycleIntegrationRegistration] as const,
+      ['sourcepoint_lifecycle', createSourcepointLifecycleIntegrationRegistration] as const,
+    ]);
+    const members = Object.freeze([...takeoverMembers, ...deferredMembers]);
+    const ids = Object.freeze(members.map(([id]) => id));
+    const configFor = (id: string): unknown => {
+      if (id === 'didomi') return Object.freeze({ proxyPath: '/integrations/didomi/consent/' });
+      if (id === 'sourcepoint_consent') return Object.freeze({ rewriteSdk: true });
+      return undefined;
+    };
+    const manifest = runtimeManifest(releaseId, ids);
+    expect(manifest.integrations.map(({ id, phase }) => [id, phase])).toEqual([
+      ['render_runtime', 'takeover'],
+      ['datadome', 'takeover'],
+      ['didomi', 'takeover'],
+      ['google_tag_manager', 'takeover'],
+      ['lockr', 'takeover'],
+      ['osano_consent', 'takeover'],
+      ['permutive_context', 'takeover'],
+      ['sourcepoint_consent', 'takeover'],
+      ['testlight', 'takeover'],
+      ['osano_lifecycle', 'deferred'],
+      ['permutive_lifecycle', 'deferred'],
+      ['sourcepoint_lifecycle', 'deferred'],
+    ]);
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = new URL(manifest.runtimeSrc, window.location.origin).href;
+    document.head.append(runtimeScript);
+    let executingScript: HTMLScriptElement | null = runtimeScript;
+    const currentScript = vi
+      .spyOn(document, 'currentScript', 'get')
+      .mockImplementation(() => executingScript);
+    const appendChildBefore = Element.prototype.appendChild;
+    const insertBeforeBefore = Element.prototype.insertBefore;
+    const didomiBefore = Object.getOwnPropertyDescriptor(window, 'didomiConfig');
+    const testlightBefore = Object.getOwnPropertyDescriptor(window, 'testlight');
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest,
+        knownIntegrationIds: ids,
+        catalog: runtimeCatalog(ids),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: (id) => ({ config: configFor(id), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+    const originalHeadAppend = document.head.append.bind(document.head);
+    const loadedDeferredIds: string[] = [];
+    const headAppend = vi.spyOn(document.head, 'append').mockImplementation((...nodes) => {
+      originalHeadAppend(...nodes);
+      for (const node of nodes) {
+        if (!(node instanceof HTMLScriptElement) || node === runtimeScript) continue;
+        const member = deferredMembers.find(([id]) => node.src.includes(`tsjs-${id}.min.js`));
+        if (!member) continue;
+        executingScript = node;
+        loadedDeferredIds.push(member[0]);
+        expect(composition.runtime.registerIntegration(member[1](releaseId))).toBe(true);
+        node.onload?.(new Event('load'));
+        executingScript = runtimeScript;
+      }
+    });
+
+    expect(composition.runtime.start()).toBe(true);
+    for (const [, createRegistration] of takeoverMembers) {
+      expect(composition.runtime.registerIntegration(createRegistration(releaseId))).toBe(true);
+    }
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(composition.runtime.protectFirstDisplayAttemptBatch([Promise.resolve()])).toBe(true);
+    await vi.advanceTimersByTimeAsync(2_500);
+    expect(loadedDeferredIds).toEqual(deferredMembers.map(([id]) => id));
+    expect(composition.auctionContextRegistryForTest()?.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: [],
+    });
+    expect(vi.getTimerCount()).toBeGreaterThan(0);
+
+    composition.runtime.dispose();
+    composition.runtime.dispose();
+    expect(vi.getTimerCount()).toBe(0);
+    expect(Element.prototype.appendChild).toBe(appendChildBefore);
+    expect(Element.prototype.insertBefore).toBe(insertBeforeBefore);
+    expect(Object.getOwnPropertyDescriptor(window, 'didomiConfig')).toEqual(didomiBefore);
+    expect(Object.getOwnPropertyDescriptor(window, 'testlight')).toEqual(testlightBefore);
+    headAppend.mockRestore();
+    currentScript.mockRestore();
+    runtimeScript.remove();
+  });
+
+  it('injects the exact creative boot into reversible activation and post-commit startup', async () => {
+    const releaseId = 'a'.repeat(64);
+    const creative = Object.freeze({
+      version: 1 as const,
+      enabled: true,
+      clickGuard: true,
+      renderGuard: false,
+    });
+    const release = vi.fn();
+    const activateCreative = vi.fn((received: unknown) => {
+      expect(received).toEqual(creative);
+      expect(Object.isFrozen(received)).toBe(true);
+      return release;
+    });
+    const startCreative = vi.fn((received: unknown) => {
+      expect(received).toEqual(creative);
+      expect(Object.isFrozen(received)).toBe(true);
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['creative']),
+        knownIntegrationIds: Object.freeze(['creative']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative,
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        creativeActivationForTest: activateCreative,
+        creativeStartupForTest: startCreative,
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        createLegacyCreativeIntegrationRegistration(releaseId)
+      )
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(activateCreative).toHaveBeenCalledTimes(1);
+    expect(startCreative).toHaveBeenCalledTimes(1);
+    expect(activateCreative.mock.calls[0]?.[0]).toBe(startCreative.mock.calls[0]?.[0]);
+
+    composition.runtime.dispose();
+    composition.runtime.dispose();
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  it('commits enabled creative with both guards false without creative effects', async () => {
+    const releaseId = 'a'.repeat(64);
+    const activateCreative = vi.fn();
+    const startCreative = vi.fn();
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: true, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        creativeActivationForTest: activateCreative,
+        creativeStartupForTest: startCreative,
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(activateCreative).not.toHaveBeenCalled();
+    expect(startCreative).not.toHaveBeenCalled();
+
+    composition.runtime.dispose();
+  });
+
+  it.each([
+    [
+      'disabled click guard bit',
+      { version: 1, enabled: false, clickGuard: true, renderGuard: false },
+      [],
+    ],
+    [
+      'disabled render guard bit',
+      { version: 1, enabled: false, clickGuard: false, renderGuard: true },
+      [],
+    ],
+    [
+      'disabled creative manifest member',
+      { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+      ['creative'],
+    ],
+    [
+      'missing enabled creative manifest member',
+      { version: 1, enabled: true, clickGuard: true, renderGuard: false },
+      [],
+    ],
+  ] as const)('rejects creative ABI mismatch: %s', async (_caseName, creative, manifestIds) => {
+    const releaseId = 'a'.repeat(64);
+    const activateCreative = vi.fn();
+    const startCreative = vi.fn();
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, manifestIds),
+        knownIntegrationIds: Object.freeze(['creative']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative,
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        creativeActivationForTest: activateCreative,
+        creativeStartupForTest: startCreative,
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    if (manifestIds.length === 1) {
+      expect(
+        composition.runtime.registerIntegration(
+          createProductionCreativeIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+    }
+    await expect(composition.runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect(activateCreative).not.toHaveBeenCalled();
+    expect(startCreative).not.toHaveBeenCalled();
+  });
+
+  it('owns the real creative click guard through the composition lifecycle', async () => {
+    const releaseId = 'a'.repeat(64);
+    const addEventListener = vi.spyOn(document, 'addEventListener');
+    const removeEventListener = vi.spyOn(document, 'removeEventListener');
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['creative']),
+        knownIntegrationIds: Object.freeze(['creative']),
+        catalog: runtimeCatalog(Object.freeze(['creative'])),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: true, clickGuard: true, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createProductionCreativeIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      expect(addEventListener.mock.calls.filter(([type]) => type === 'click')).toHaveLength(1);
+      expect(addEventListener.mock.calls.filter(([type]) => type === 'auxclick')).toHaveLength(1);
+    } finally {
+      composition.runtime.dispose();
+      addEventListener.mockRestore();
+    }
+    expect(removeEventListener.mock.calls.filter(([type]) => type === 'click')).toHaveLength(1);
+    expect(removeEventListener.mock.calls.filter(([type]) => type === 'auxclick')).toHaveLength(1);
+    removeEventListener.mockRestore();
+  });
+
+  it('publishes and promotes one exact Prebid winner through runtime-owned PUC state', async () => {
+    const releaseId = 'a'.repeat(64);
+    const prebid = synchronousPrebidAdapter();
+    const reservationId = `r1_${'p'.repeat(22)}`;
+    let captureListener: CaptureMessageListener | undefined;
+    const messagingTarget = {
+      addEventListener: vi.fn(
+        (_type: 'message', listener: CaptureMessageListener, _capture: true) => {
+          captureListener = listener;
+        }
+      ),
+      removeEventListener: vi.fn(),
+    };
+    const messaging = createBrowserMessagingAdapter(messagingTarget);
+    const bid = Object.freeze({
+      candidateId: 'AAAAAAAAAAAA',
+      slot: 'slot-one',
+      provider: 'trusted',
+      upstreamBidId: 'upstream-one',
+      cpm: 1.25,
+      currency: 'USD' as const,
+      targeting: Object.freeze({ hb_bidder: 'trustedServer' }),
+      rendererReservationId: reservationId,
+      renderSource: Object.freeze({
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>private creative</main>',
+        width: 300,
+        height: 250,
+      }),
+    });
+    const projection = Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'auction-one',
+        results: Object.freeze([
+          Object.freeze({
+            slot: bid.slot,
+            outcome: 'winner' as const,
+            candidateId: bid.candidateId,
+          }),
+        ]),
+      }),
+      slots: Object.freeze([browserSlotPlacement(bid.slot)]),
+      bids: Object.freeze([bid]),
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['prebid']),
+        knownIntegrationIds: Object.freeze(['prebid']),
+        boot: {
+          auctionProjection: projection,
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging,
+          prebid: prebid.adapter,
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        createIdentityIssuerForTest: () =>
+          createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(9);
+              return target;
+            },
+          }),
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          createLegacyPrebidIntegrationRegistration(releaseId)
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const complete = vi.fn();
+      prebid.auction(
+        Object.freeze({
+          auctionId: 'auction-one',
+          bids: Object.freeze([Object.freeze({ adUnitCode: bid.slot, requestId: 'request-one' })]),
+          complete,
+        })
+      );
+
+      expect(complete).toHaveBeenCalledTimes(1);
+      expect(prebid.admitTrustedBid).toHaveBeenCalledTimes(1);
+      expect(prebid.admitTrustedBid.mock.calls[0]?.[0]).toMatchObject({
+        auctionId: 'auction-one',
+        adUnitCode: bid.slot,
+        bid: { adId: reservationId, requestId: 'request-one' },
+      });
+      expect(composition.reservationServiceForTest()?.recognize(reservationId)).toMatchObject({
+        state: 'awaiting_prebid_selection',
+      });
+
+      prebid.auctionEnd('auction-one');
+      expect(composition.reservationServiceForTest()?.recognize(reservationId)).toMatchObject({
+        state: 'renderable',
+      });
+      expect(composition.pucBridgeForTest()?.snapshotInventoryForTest()).toMatchObject({
+        attempts: 1,
+      });
+
+      const claimPort = {
+        addEventListener: vi.fn(),
+        close: vi.fn(),
+        postMessage: vi.fn(),
+        removeEventListener: vi.fn(),
+        start: vi.fn(),
+      };
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'Prebid Request',
+          adId: reservationId,
+          adServerDomain: 'ads.example.com',
+        }),
+        ports: [claimPort],
+        source: Object.freeze({ frame: 'selected-creative' }),
+        stopImmediatePropagation: vi.fn(),
+      } as unknown as MessageEvent);
+      expect(composition.pucBridgeForTest()?.snapshotInventoryForTest()).toMatchObject({
+        attempts: 1,
+        liveTickets: 0,
+        pendingClaims: 1,
+      });
+      expect(claimPort.postMessage).not.toHaveBeenCalled();
+      expect(claimPort.close).not.toHaveBeenCalled();
+    } finally {
+      composition.runtime.dispose();
+    }
+  });
+
+  const prebidPublicationFailureCases: readonly (readonly [
+    string,
+    (prepared: Readonly<PreparedTrustedBidV1>) => 'admitted' | 'not_admitted',
+    'prebid_admission_failed' | 'prebid_contract_violation',
+  ])[] = [
+    ['not admitted', () => 'not_admitted', 'prebid_admission_failed'],
+    [
+      'partial publication',
+      () => {
+        throw new PrebidAdmissionContractError();
+      },
+      'prebid_contract_violation',
+    ],
+  ];
+  it.each(prebidPublicationFailureCases)(
+    'settles a %s Prebid publication as an exact slot lifecycle failure',
+    async (_case, admission, reason) => {
+      const releaseId = 'a'.repeat(64);
+      const prebid = synchronousPrebidAdapter(admission);
+      const reservationId = `r1_${'q'.repeat(22)}`;
+      const bid = Object.freeze({
+        candidateId: 'BBBBBBBBBBBB',
+        slot: 'failed-slot',
+        provider: 'trusted',
+        upstreamBidId: 'failed-upstream',
+        cpm: 2.5,
+        currency: 'USD' as const,
+        targeting: Object.freeze({ hb_bidder: 'trustedServer' }),
+        rendererReservationId: reservationId,
+        renderSource: Object.freeze({
+          type: 'adm' as const,
+          version: 1 as const,
+          adm: '<main>must not render</main>',
+          width: 300,
+          height: 250,
+        }),
+      });
+      const projection = Object.freeze({
+        version: 1,
+        auction: Object.freeze({
+          version: 1,
+          auctionId: 'failed-auction',
+          results: Object.freeze([
+            Object.freeze({
+              slot: bid.slot,
+              outcome: 'winner' as const,
+              candidateId: bid.candidateId,
+            }),
+          ]),
+        }),
+        slots: Object.freeze([browserSlotPlacement(bid.slot)]),
+        bids: Object.freeze([bid]),
+      });
+      const composition = createTestBrowserRuntimeComposition(
+        {
+          target: {},
+          releaseId,
+          manifest: runtimeManifest(releaseId, ['prebid', 'lifecycle_probe']),
+          knownIntegrationIds: Object.freeze(['prebid', 'lifecycle_probe']),
+          boot: {
+            auctionProjection: projection,
+            creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+            diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+          },
+          getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+          kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+        },
+        {
+          adapters: {
+            googletag: fakeGoogletagAdapter(),
+            messaging: fakeMessagingAdapter(),
+            prebid: prebid.adapter,
+          },
+          coreActivations: { correctnessGptListeners: vi.fn() },
+        }
+      );
+
+      try {
+        expect(composition.runtime.start()).toBe(true);
+        expect(
+          composition.runtime.registerIntegration(
+            createLegacyPrebidIntegrationRegistration(releaseId)
+          )
+        ).toBe(true);
+        expect(
+          composition.runtime.registerIntegration(
+            testTakeoverRegistration(
+              'lifecycle_probe',
+              releaseId,
+              ({ interfaces }: { interfaces: Readonly<Record<string, unknown>> }) => {
+                expect(interfaces).not.toHaveProperty('diagnostics');
+                return Object.freeze({ activate: vi.fn() });
+              }
+            )
+          )
+        ).toBe(true);
+        await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+        const complete = vi.fn();
+
+        prebid.auction(
+          Object.freeze({
+            auctionId: 'failed-auction',
+            bids: Object.freeze([
+              Object.freeze({ adUnitCode: bid.slot, requestId: 'failed-request' }),
+            ]),
+            complete,
+          })
+        );
+
+        expect(complete).toHaveBeenCalledOnce();
+        expect(composition.reservationServiceForTest()?.recognize(reservationId)).toMatchObject({
+          recognized: true,
+          state: reason,
+        });
+        expect(
+          composition.runtimeSessionForTest()?.currentNavigation?.snapshotInventoryForTest()
+        ).toMatchObject({
+          attempts: 0,
+          batches: 0,
+        });
+      } finally {
+        composition.runtime.dispose();
+      }
+    }
+  );
+
+  it('hands late publisher GPT calls through the adapter into runtime-owned slot state', async () => {
+    const releaseId = 'a'.repeat(64);
+    const slot = Object.freeze({ id: 'trusted-slot' });
+    const unrelated = Object.freeze({ id: 'publisher-slot' });
+    const refresh = vi.fn((_slots?: readonly object[], _options?: unknown) => undefined);
+    const display = vi.fn((_target: unknown) => undefined);
+    const destroySlots = vi.fn((_slots?: readonly object[]) => true);
+    const listeners = new Map<string, Set<(event: unknown) => void>>();
+    const pubads = {
+      addEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+        const registered = listeners.get(type) ?? new Set();
+        registered.add(listener);
+        listeners.set(type, registered);
+      }),
+      disableInitialLoad: vi.fn(),
+      getSlots: vi.fn(() => [slot, unrelated]),
+      refresh,
+      removeEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+        listeners.get(type)?.delete(listener);
+      }),
+    };
+    const nativeDefineSlot = vi.fn((_path: string, _sizes: unknown, _elementId: string) =>
+      Object.freeze({ id: 'duplicate' })
+    );
+    const googletag = {
+      apiReady: true,
+      pubadsReady: true,
+      cmd: { push: (command: () => void) => (command(), 0) },
+      defineSlot: nativeDefineSlot,
+      destroySlots,
+      display,
+      getConfig: vi.fn(() => ({ disableInitialLoad: true })),
+      pubads: () => pubads,
+      setConfig: vi.fn(),
+    };
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: {
+              version: 1,
+              auctionId: 'initial',
+              results: [{ slot: 'slot', outcome: 'no_bid' }],
+            },
+            slots: [browserSlotPlacement('slot')],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: createBrowserGoogletagAdapter({ googletag }),
+          messaging: fakeMessagingAdapter(() => vi.fn()),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const navigation = composition.runtimeSessionForTest()?.currentNavigation;
+      const slots = composition.slotServiceForTest();
+      if (!navigation || !slots) throw new Error('Expected active GPT composition');
+      expect(
+        slots.adoptGptSlot(navigation.generation, 'slot', {
+          definition: {
+            adUnitPath: '/trusted/path',
+            elementId: 'slot-div',
+            sizes: Object.freeze([[300, 250]]),
+          },
+          elementIdPrefix: 'slot-',
+          ownership: 'trusted_server',
+          slot,
+        })
+      ).toEqual({ ok: true });
+
+      expect(googletag.defineSlot('/publisher/mismatch', [728, 90], 'slot-div')).toBe(slot);
+      expect(nativeDefineSlot).not.toHaveBeenCalled();
+      expect(googletag.display('slot-div')).toBeUndefined();
+      expect(display).not.toHaveBeenCalled();
+      const options = Object.freeze({ changeCorrelator: true, publisher: 'preserved' });
+      expect(pubads.refresh(undefined, options)).toBeUndefined();
+      expect(refresh).toHaveBeenCalledExactlyOnceWith([unrelated], options);
+      pubads.refresh([slot], options);
+      expect(refresh).toHaveBeenLastCalledWith([slot], options);
+      const request = slots.request({
+        intentId: 'publisher-owned',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'slot',
+        requestClass: 'primary',
+      });
+      await expect(request.result).resolves.toEqual({
+        status: 'failed',
+        reason: 'cycle_unattributable',
+      });
+      expect(googletag.destroySlots([slot])).toBe(true);
+      expect(slots.isBoundGptSlot(navigation.generation, 'slot', slot)).toBe(false);
+    } finally {
+      composition.runtime.dispose();
+      resetGuardState();
+    }
+    expect(destroySlots).toHaveBeenCalledTimes(1);
+  });
+
+  it('constructs one session lazily from accepted boot and keeps it across SPA replacement', async () => {
+    const projection = {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'initial',
+        results: [{ slot: 'initial-slot', outcome: 'no_bid' }],
+      },
+      slots: [browserSlotPlacement('initial-slot')],
+      bids: [],
+    };
+    let prefix = 0;
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: projection,
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: {
+          addAdUnits: vi.fn(),
+          diagnostics: Object.freeze({}),
+          requestAds: vi.fn(),
+        },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          prebid: fakePrebidAdapter(),
+          messaging: fakeMessagingAdapter(),
+        },
+        coreActivations: {
+          correctnessGptListeners: vi.fn(),
+        },
+        createIdentityIssuerForTest: () => {
+          prefix += 1;
+          return createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(prefix);
+              return target;
+            },
+          });
+        },
+      }
+    );
+
+    expect(composition.runtimeSessionForTest()).toBeUndefined();
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    const session = composition.runtimeSessionForTest();
+    expect(session).toBeDefined();
+    expect(composition.runtimeSessionForTest()).toBe(session);
+    const slotService = composition.slotServiceForTest();
+    const targetingService = composition.targetingServiceForTest();
+    const reservationService = composition.reservationServiceForTest();
+    const rendererNonces = composition.rendererNonceRegistryForTest();
+    expect(slotService).toBeDefined();
+    expect(targetingService).toBeDefined();
+    expect(reservationService).toBeDefined();
+    expect(rendererNonces).toBeDefined();
+    expect(session?.interfaces['slots']).toBe(slotService);
+    expect(session?.interfaces['targeting']).toBe(targetingService);
+    expect(session?.interfaces['reservations']).toBe(reservationService);
+    expect(session?.interfaces['rendererNonces']).toBe(rendererNonces);
+    expect(session?.interfaces['renderDirectAps']).toBeTypeOf('function');
+    expect(session?.interfaces['renderDirectAdm']).toBeTypeOf('function');
+    expect(session?.interfaces['renderDirectCache']).toBeUndefined();
+    expect(session?.currentNavigation?.interfaces).toBe(session?.interfaces);
+    expect(session?.currentNavigation?.currentAuctionProjection).toEqual(projection);
+    expect(Object.isFrozen(session?.currentNavigation?.currentAuctionProjection)).toBe(true);
+
+    const initialNavigation = session?.currentNavigation;
+    const artifactBatch = initialNavigation?.createAuctionBatch('accepted-artifact');
+    const artifactOwner = artifactBatch?.createRenderAttempt('accepted-artifact-slot');
+    const artifactStore = session?.interfaces['artifacts'] as
+      Parameters<typeof createRenderAttempt>[0]['artifacts'] | undefined;
+    if (!artifactOwner?.ok || !artifactStore || !reservationService) {
+      throw new Error('Expected accepted-artifact dependencies');
+    }
+    const acceptedSource = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<main>accepted</main>',
+      width: 300,
+      height: 250,
+    });
+    const acceptedAttempt = createRenderAttempt({
+      artifacts: artifactStore,
+      owner: artifactOwner.value,
+      prepareRenderSource: () => acceptedSource,
+      reservations: reservationService,
+    });
+    if (!acceptedAttempt.ok) throw new Error(acceptedAttempt.reason);
+    const disposeAcceptedArtifact = vi.fn();
+    const acceptedArtifact = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: acceptedAttempt.value.id,
+      slot: acceptedAttempt.value.slot,
+      navigationGeneration: acceptedAttempt.value.navigationGeneration,
+      dispose: disposeAcceptedArtifact,
+    });
+    expect(
+      acceptedAttempt.value.admitDirectWinner(acceptedSource, Object.freeze({ selectedCpm: 1 }))
+    ).toBe(true);
+    expect(acceptedAttempt.value.beginDirect()).toBe(true);
+    expect(acceptedAttempt.value.beginAdm(acceptedArtifact)).toBe(true);
+    expect(acceptedAttempt.value.accept()).toBe(true);
+    expect(artifactStore.current('accepted-artifact-slot')).toBe(acceptedArtifact);
+
+    projection.auction.auctionId = 'publisher-mutated';
+    expect(
+      (
+        session?.currentNavigation?.currentAuctionProjection as {
+          auction: { auctionId: string };
+        }
+      ).auction.auctionId
+    ).toBe('initial');
+    const replacement = session?.replaceNavigation();
+    expect(replacement).toMatchObject({ ok: true });
+    if (!replacement?.ok) throw new Error('Expected SPA navigation');
+    expect(disposeAcceptedArtifact).toHaveBeenCalledOnce();
+    expect(artifactStore.current('accepted-artifact-slot')).toBeUndefined();
+    expect(replacement.value.currentAuctionProjection).toBeUndefined();
+    expect(composition.runtimeSessionForTest()).toBe(session);
+    expect(composition.reservationServiceForTest()).toBe(reservationService);
+
+    const pageBids = composition.pageBidsControllerForTest();
+    expect(
+      pageBids?.commit({
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: 'spa',
+          results: [{ slot: 'spa-slot', outcome: 'no_bid' }],
+        },
+        slots: [browserSlotPlacement('spa-slot')],
+        bids: [],
+      })
+    ).toEqual({ status: 'committed' });
+    expect(composition.projectionSlotsForTest()).toEqual(['spa-slot']);
+
+    composition.runtime.dispose();
+    expect(session?.disposed).toBe(true);
+    expect(slotService?.snapshotForTest()).toEqual({
+      cycles: 0,
+      intents: 0,
+      physicalSlots: 0,
+      records: 0,
+    });
+    expect(targetingService?.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+    expect(reservationService?.snapshotInventoryForTest()).toMatchObject({
+      disposed: true,
+      size: 0,
+    });
+    expect(rendererNonces?.snapshotForTest()).toMatchObject({ disposed: true });
+    expect(composition.slotServiceForTest()).toBeUndefined();
+    expect(composition.targetingServiceForTest()).toBeUndefined();
+    expect(composition.reservationServiceForTest()).toBeUndefined();
+    expect(composition.rendererNonceRegistryForTest()).toBeUndefined();
+  });
+
+  it('commits canonical page-bids into a replacement navigation without mutating boot', async () => {
+    const nativeReplaceState = history.replaceState.bind(history);
+    const releaseId = 'a'.repeat(64);
+    const initialProjection = {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'initial',
+        results: [{ slot: 'initial-slot', outcome: 'no_bid' }],
+      },
+      slots: [browserSlotPlacement('initial-slot')],
+      bids: [],
+    };
+    const spaProjection = {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'spa-auction',
+        results: [{ slot: 'spa-slot', outcome: 'no_bid' }],
+      },
+      slots: [browserSlotPlacement('spa-slot')],
+      bids: [],
+    };
+    const fetchPageBids = vi.fn(async () => ({
+      ok: true,
+      json: async () => spaProjection,
+    }));
+    const target: Record<string, unknown> = {};
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: initialProjection,
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        pageBidsFetcherForTest: fetchPageBids,
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      const boot = (target as { boot: Readonly<{ auctionProjection: object }> }).boot;
+      const initialNavigation = composition.runtimeSessionForTest()?.currentNavigation;
+
+      history.pushState({}, '', '/spa-route?section=one');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledOnce());
+      expect(fetchPageBids).toHaveBeenCalledWith(
+        '/_ts/page-bids?path=%2Fspa-route%3Fsection%3Done',
+        expect.objectContaining({
+          credentials: 'include',
+          headers: { 'X-TSJS-Page-Bids': '1' },
+          signal: expect.any(AbortSignal),
+        })
+      );
+      await vi.waitFor(() =>
+        expect(
+          composition.runtimeSessionForTest()?.currentNavigation?.currentAuctionProjection
+        ).toMatchObject({ auction: { auctionId: 'spa-auction' } })
+      );
+
+      expect(composition.runtimeSessionForTest()?.currentNavigation).not.toBe(initialNavigation);
+      expect(initialNavigation?.disposed).toBe(true);
+      expect(composition.projectionSlotsForTest()).toEqual(['spa-slot']);
+      expect(boot.auctionProjection).toMatchObject({ auction: { auctionId: 'initial' } });
+      expect(Object.isFrozen(boot.auctionProjection)).toBe(true);
+
+      history.replaceState({}, '', '/spa-replaced');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledTimes(2));
+      expect(fetchPageBids).toHaveBeenLastCalledWith(
+        '/_ts/page-bids?path=%2Fspa-replaced',
+        expect.objectContaining({ signal: expect.any(AbortSignal) })
+      );
+
+      nativeReplaceState({}, '', '/spa-popped');
+      window.dispatchEvent(new PopStateEvent('popstate'));
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledTimes(3));
+      window.dispatchEvent(new PopStateEvent('popstate'));
+      await Promise.resolve();
+      expect(fetchPageBids).toHaveBeenCalledTimes(3);
+
+      fetchPageBids.mockResolvedValueOnce({
+        ok: false,
+        json: async () => spaProjection,
+      });
+      history.pushState({}, '', '/spa-retry');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledTimes(4));
+      history.replaceState({}, '', '/spa-retry');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledTimes(5));
+      expect(fetchPageBids).toHaveBeenLastCalledWith(
+        '/_ts/page-bids?path=%2Fspa-retry',
+        expect.objectContaining({ signal: expect.any(AbortSignal) })
+      );
+    } finally {
+      composition.runtime.dispose();
+      history.replaceState({}, '', '/');
+    }
+  });
+
+  it('publishes a committed page-bids winner through the replacement navigation GPT lifecycle', async () => {
+    const releaseId = 'a'.repeat(64);
+    const gpt = synchronousGptAdapter();
+    const placement = browserSlotPlacement('spa-winner');
+    const bid = {
+      candidateId: 'BBBBBBBBBBBB',
+      slot: placement.slot,
+      provider: 'trusted',
+      upstreamBidId: 'spa-upstream',
+      cpm: 2,
+      currency: 'USD' as const,
+      targeting: { hb_bidder: 'trusted' },
+      rendererReservationId: `r1_${'s'.repeat(22)}`,
+      renderSource: {
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>spa winner</main>',
+        width: 300,
+        height: 250,
+      },
+    };
+    const spaProjection = {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'spa-production',
+        results: [
+          { slot: placement.slot, outcome: 'winner' as const, candidateId: bid.candidateId },
+        ],
+      },
+      slots: [placement],
+      bids: [bid],
+    };
+    const fetchPageBids = vi.fn(async () => ({ ok: true, json: async () => spaProjection }));
+    const element = document.createElement('div');
+    element.id = placement.divId;
+    document.body.append(element);
+    let prefix = 0;
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial-empty', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: gpt.adapter,
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners: vi.fn() },
+        createIdentityIssuerForTest: () => {
+          prefix += 1;
+          return createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(prefix);
+              return target;
+            },
+          });
+        },
+        pageBidsFetcherForTest: fetchPageBids,
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(createGptIntegrationRegistration(releaseId))
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      history.pushState({}, '', '/spa-production');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledOnce());
+      await vi.waitFor(() => expect(gpt.physicalSlots()).toHaveLength(1));
+      const physicalSlot = gpt.physicalSlots()[0];
+      expect(gpt.display).toHaveBeenCalledExactlyOnceWith(physicalSlot);
+      expect(gpt.targetingFor(physicalSlot!)).toEqual(
+        new Map([
+          ['hb_adid', [bid.rendererReservationId]],
+          ['hb_bidder', ['trusted']],
+        ])
+      );
+      expect(
+        composition.runtimeSessionForTest()?.currentNavigation?.currentAuctionProjection
+      ).toMatchObject({ auction: { auctionId: 'spa-production' } });
+    } finally {
+      composition.runtime.dispose();
+      element.remove();
+    }
+  });
+
+  it('unwinds a lazily-created session when navigation identity generation fails', async () => {
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        coreActivations: {
+          correctnessGptListeners: vi.fn(),
+        },
+        createIdentityIssuerForTest: () => ({
+          ok: false,
+          reason: 'identity_generation_failed',
+        }),
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(composition.runtimeSessionForTest()).toBeUndefined();
+    expect(composition.projectionSlotsForTest()).toBeUndefined();
+    expect(composition.pucBridgeForTest()).toBeUndefined();
+  });
+
+  it('falls back before publishing services when the PUC capture listener cannot install', async () => {
+    const correctnessGptListeners = vi.fn();
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(() => undefined),
+          prebid: fakePrebidAdapter(),
+        },
+        coreActivations: { correctnessGptListeners },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(correctnessGptListeners).not.toHaveBeenCalled();
+    expect(composition.pucBridgeForTest()).toBeUndefined();
+    expect(composition.slotServiceForTest()).toBeUndefined();
+  });
+
+  it('releases initial programmatic slots before admitting a replacement SPA projection', async () => {
+    let prefix = 0;
+    const programmaticSlots = Object.freeze(
+      Array.from({ length: 256 }, (_, index) => `programmatic-${index}`)
+    );
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        admittedProgrammaticSlotsForTest: programmaticSlots,
+        coreActivations: {
+          correctnessGptListeners: vi.fn(),
+        },
+        createIdentityIssuerForTest: () => {
+          prefix += 1;
+          return createTestNavigationIdentityIssuer({
+            getRandomValues: (target) => {
+              target.fill(prefix);
+              return target;
+            },
+          });
+        },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(composition.projectionSlotsForTest()).toEqual(programmaticSlots);
+    const replacement = composition.runtimeSessionForTest()?.replaceNavigation();
+    expect(replacement).toMatchObject({ ok: true });
+    expect(composition.projectionSlotsForTest()).toEqual([]);
+
+    expect(
+      composition.pageBidsControllerForTest()?.commit({
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: 'spa',
+          results: [{ slot: 'spa-slot', outcome: 'no_bid' }],
+        },
+        slots: [browserSlotPlacement('spa-slot')],
+        bids: [],
+      })
+    ).toEqual({ status: 'committed' });
+    expect(composition.projectionSlotsForTest()).toEqual(['spa-slot']);
+  });
+
+  it('fails closed when admitted programmatic input contains duplicate slot ids', async () => {
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        admittedProgrammaticSlotsForTest: Object.freeze(['duplicate', 'duplicate']),
+        coreActivations: {
+          correctnessGptListeners: vi.fn(),
+        },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(composition.runtimeSessionForTest()).toBeUndefined();
+    expect(composition.projectionSlotsForTest()).toBeUndefined();
+  });
+
+  it.each([
+    [2, 255],
+    [1, 256],
+  ] as const)(
+    'rejects one atomic initial registration of %i server plus %i programmatic records',
+    async (serverCount, programmaticCount) => {
+      const composition = createTestBrowserRuntimeComposition(
+        {
+          target: {},
+          releaseId: 'a'.repeat(64),
+          manifest: runtimeManifest('a'.repeat(64), []),
+          knownIntegrationIds: Object.freeze([]),
+          boot: {
+            auctionProjection: {
+              version: 1,
+              auction: {
+                version: 1,
+                auctionId: 'initial',
+                results: Array.from({ length: serverCount }, (_, index) => ({
+                  outcome: 'no_bid' as const,
+                  slot: `server-${index}`,
+                })),
+              },
+              slots: Array.from({ length: serverCount }, (_, index) =>
+                browserSlotPlacement(`server-${index}`)
+              ),
+              bids: [],
+            },
+            creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+            diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+          },
+          kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+        },
+        {
+          admittedProgrammaticSlotsForTest: Object.freeze(
+            Array.from({ length: programmaticCount }, (_, index) => `programmatic-${index}`)
+          ),
+          coreActivations: {
+            correctnessGptListeners: vi.fn(),
+          },
+        }
+      );
+
+      expect(composition.runtime.start()).toBe(true);
+      await expect(composition.runtime.install()).resolves.toEqual({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+      expect(composition.runtimeSessionForTest()).toBeUndefined();
+      expect(composition.slotServiceForTest()).toBeUndefined();
+      expect(composition.projectionSlotsForTest()).toBeUndefined();
+    }
+  );
+
+  it('owns an immutable copy of admitted programmatic slot input for navigation cleanup', async () => {
+    const programmaticSlots = ['programmatic-one', 'programmatic-two'];
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target: {},
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), []),
+        knownIntegrationIds: Object.freeze([]),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'initial', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        admittedProgrammaticSlotsForTest: programmaticSlots,
+        coreActivations: {
+          correctnessGptListeners: vi.fn(),
+        },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    programmaticSlots[0] = 'publisher-mutated';
+    programmaticSlots.length = 1;
+
+    expect(composition.runtimeSessionForTest()?.replaceNavigation()).toMatchObject({ ok: true });
+    expect(composition.projectionSlotsForTest()).toEqual([]);
+  });
+
+  it('constructs or activates nothing after a terminal fallback', async () => {
+    vi.useFakeTimers();
+    const serviceConstruction = vi.fn(() => ({
+      config: Object.freeze({}),
+      interfaces: Object.freeze({}),
+    }));
+    const adapterActivation = vi.fn(() => 'pending' as const);
+    const listenerActivation = vi.fn(() => vi.fn());
+    const latePreparation = vi.fn();
+    const target = {};
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId: 'a'.repeat(64),
+        manifest: runtimeManifest('a'.repeat(64), ['missing']),
+        knownIntegrationIds: Object.freeze(['missing']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: { version: 1, auctionId: 'boot', results: [] },
+            slots: [],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        getBindings: serviceConstruction,
+        kernel: {
+          addAdUnits: vi.fn(),
+          diagnostics: Object.freeze({}),
+          requestAds: vi.fn(),
+        },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(adapterActivation),
+          prebid: fakePrebidAdapter(adapterActivation),
+          messaging: fakeMessagingAdapter(listenerActivation),
+        },
+        coreActivations: {
+          correctnessGptListeners: adapterActivation,
+        },
+      }
+    );
+
+    expect(composition.runtime.start()).toBe(true);
+    const installed = composition.runtime.install();
+    await vi.advanceTimersByTimeAsync(10_000);
+    await expect(installed).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(composition.runtimeSessionForTest()).toBeUndefined();
+    expect(composition.projectionSlotsForTest()).toBeUndefined();
+    expect(vi.getTimerCount()).toBe(0);
+
+    expect(
+      (target as { _registerIntegration(value: unknown): boolean })._registerIntegration(
+        Object.freeze({
+          abi: 1,
+          id: 'missing',
+          phase: 'takeover',
+          releaseId: 'a'.repeat(64),
+          prepare: latePreparation,
+        })
+      )
+    ).toBe(false);
+    await vi.runAllTimersAsync();
+
+    expect(serviceConstruction).not.toHaveBeenCalled();
+    expect(adapterActivation).not.toHaveBeenCalled();
+    expect(listenerActivation).not.toHaveBeenCalled();
+    expect(latePreparation).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('isolates and locally logs a throwing auction-context contributor', async () => {
+    const releaseId = 'a'.repeat(64);
+    const target = {};
+    const requestConfigs: unknown[] = [];
+    const auctionFetcher = vi.fn(async (_input: string, init: RequestInit) => {
+      const body = JSON.parse(String(init.body)) as { config: unknown };
+      requestConfigs.push(body.config);
+      return {
+        ok: true,
+        json: async () => ({
+          id: 'context-auction',
+          cur: 'USD',
+          seatbid: [],
+          ext: {
+            trusted_server: {
+              slot_results: {
+                version: 1,
+                auctionId: 'context-auction',
+                results: [{ slot: 'server-slot', outcome: 'no_bid' }],
+              },
+            },
+          },
+        }),
+      };
+    });
+    const warn = vi.spyOn(localLog, 'warn').mockImplementation(() => undefined);
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        manifest: runtimeManifest(releaseId, ['context_test']),
+        knownIntegrationIds: Object.freeze(['context_test']),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: {
+              version: 1,
+              auctionId: 'initial',
+              results: [{ slot: 'server-slot', outcome: 'no_bid' }],
+            },
+            slots: [browserSlotPlacement('server-slot')],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        auctionFetcherForTest: auctionFetcher,
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+
+    try {
+      expect(composition.runtime.start()).toBe(true);
+      expect(
+        composition.runtime.registerIntegration(
+          testTakeoverRegistration('context_test', releaseId, () =>
+            Object.freeze({ activate: vi.fn() })
+          )
+        )
+      ).toBe(true);
+      await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+      expect((target as { log?: unknown }).log).toBe(publicLog);
+
+      const registry = composition.auctionContextRegistryForTest();
+      const session = composition.runtimeSessionForTest();
+      expect(registry).toBeDefined();
+      expect(session).toBeDefined();
+      expect(
+        registry?.register(
+          'context_test',
+          () => {
+            throw new Error('publisher contributor');
+          },
+          session!
+        )
+      ).toBe(true);
+
+      const api = target as {
+        requestAds(options?: unknown): Promise<{ readonly slots: readonly object[] }>;
+      };
+      await expect(api.requestAds({ slots: ['server-slot'] })).resolves.toEqual({
+        slots: [{ slot: 'server-slot', path: 'primary', outcome: 'no_bid' }],
+      });
+      const diagnostics = target as {
+        diagnostics?: { renderTrace?: { history(): readonly unknown[] } };
+      };
+      expect(diagnostics.diagnostics?.renderTrace?.history()).toEqual([]);
+
+      expect(requestConfigs).toEqual([{}]);
+      expect(warn).toHaveBeenCalledExactlyOnceWith('auction context: contributor failed', {
+        integrationId: 'context_test',
+        reason: 'contributor_failed',
+      });
+    } finally {
+      composition.runtime.dispose();
+      warn.mockRestore();
+    }
+  });
+
+  it('exercises transactional addAdUnits and invocation-time requestAds snapshots through the test kernel', async () => {
+    const releaseId = 'a'.repeat(64);
+    const integrationIds = Object.freeze([
+      BROWSER_TEST_TRACE_PROVIDER_ID,
+      'context_test',
+      'diagnostics_presentation',
+    ]);
+    const catalogIds = Object.freeze([
+      BROWSER_TEST_TRACE_PROVIDER_ID,
+      BROWSER_TEST_OPTIONAL_GPT_DIAG_PROVIDER_ID,
+      'context_test',
+      'diagnostics_presentation',
+    ]);
+    const manifest = runtimeManifest(releaseId, integrationIds);
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = new URL(manifest.runtimeSrc, window.location.origin).href;
+    document.head.append(runtimeScript);
+    let executingScript: HTMLScriptElement | null = runtimeScript;
+    const currentScript = vi
+      .spyOn(document, 'currentScript', 'get')
+      .mockImplementation(() => executingScript);
+    const frames: FrameRequestCallback[] = [];
+    const idle: Array<() => void> = [];
+    const presentationAnimationFrame = vi.fn();
+    vi.stubGlobal('requestAnimationFrame', presentationAnimationFrame);
+    const target = {};
+    const preGateSlot = document.createElement('div');
+    preGateSlot.id = 'pre-gate-overlay-slot';
+    document.body.append(preGateSlot);
+    const requestBodies: Array<{
+      adUnits: Array<{ code: string }>;
+      config: Readonly<Record<string, unknown>>;
+    }> = [];
+    const auctionFetcher = vi.fn(async (_input: string, init: RequestInit) => {
+      const body = JSON.parse(String(init.body)) as {
+        adUnits: Array<{ code: string }>;
+        config: Readonly<Record<string, unknown>>;
+      };
+      requestBodies.push(body);
+      const slots = body.adUnits.map(({ code }) => code);
+      const winnerSlot =
+        requestBodies.length === 1 || (slots.length === 1 && slots[0] === 'ambiguous-slot')
+          ? slots[0]
+          : undefined;
+      const candidateId = 'AAAAAAAAAAAA';
+      const renderSource = {
+        type: 'adm',
+        version: 1,
+        adm: '<div>programmatic winner</div>',
+        width: 300,
+        height: 250,
+      } as const;
+      return {
+        ok: true,
+        json: async () => ({
+          id: `auction-${requestBodies.length}`,
+          cur: 'USD',
+          seatbid: winnerSlot
+            ? [
+                {
+                  seat: 'fictional',
+                  bid: [
+                    {
+                      id: 'r1_AAAAAAAAAAAAAAAAAAAAAA',
+                      impid: winnerSlot,
+                      price: 1,
+                      adm: renderSource.adm,
+                      w: renderSource.width,
+                      h: renderSource.height,
+                      ext: {
+                        trusted_server: {
+                          candidate_id: candidateId,
+                          slot_id: winnerSlot,
+                          render_source: renderSource,
+                        },
+                      },
+                    },
+                  ],
+                },
+              ]
+            : [],
+          ext: {
+            trusted_server: {
+              slot_results: {
+                version: 1,
+                auctionId: `auction-${requestBodies.length}`,
+                results: slots.map((slot) =>
+                  slot === winnerSlot
+                    ? { slot, outcome: 'winner', candidateId }
+                    : { slot, outcome: 'no_bid' }
+                ),
+              },
+            },
+          },
+        }),
+      };
+    });
+    const composition = createTestBrowserRuntimeComposition(
+      {
+        target,
+        releaseId,
+        document,
+        manifest,
+        knownIntegrationIds: catalogIds,
+        catalog: runtimeCatalog(catalogIds),
+        boot: {
+          auctionProjection: {
+            version: 1,
+            auction: {
+              version: 1,
+              auctionId: 'initial',
+              results: [{ slot: 'server-slot', outcome: 'no_bid' }],
+            },
+            slots: [browserSlotPlacement('server-slot')],
+            bids: [],
+          },
+          creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+          diagnostics: { version: 1, renderTraceOverlay: true, gpt: { active: false } },
+        },
+        phaseScheduler: {
+          cancelAnimationFrame: vi.fn(),
+          cancelIdleCallback: vi.fn(),
+          clearTimeout,
+          requestAnimationFrame: (callback) => {
+            frames.push(callback);
+            return frames.length;
+          },
+          requestIdleCallback: (callback) => {
+            idle.push(callback);
+            return idle.length;
+          },
+          setTimeout,
+        },
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      },
+      {
+        adapters: {
+          googletag: fakeGoogletagAdapter(),
+          messaging: fakeMessagingAdapter(),
+          prebid: fakePrebidAdapter(),
+        },
+        auctionFetcherForTest: auctionFetcher,
+        coreActivations: { correctnessGptListeners: vi.fn() },
+      }
+    );
+    const originalHeadAppend = document.head.append.bind(document.head);
+    const loadedPresentation = vi.fn();
+    const headAppend = vi.spyOn(document.head, 'append').mockImplementation((...nodes) => {
+      originalHeadAppend(...nodes);
+      for (const node of nodes) {
+        if (!(node instanceof HTMLScriptElement) || node === runtimeScript) continue;
+        expect(node.src).toBe(
+          new URL(
+            manifest.integrations.find(({ id }) => id === 'diagnostics_presentation')!.src!,
+            window.location.origin
+          ).href
+        );
+        executingScript = node;
+        expect(
+          composition.runtime.registerIntegration(
+            createDiagnosticsPresentationIntegrationRegistration(releaseId)
+          )
+        ).toBe(true);
+        loadedPresentation();
+        node.onload?.(new Event('load'));
+        executingScript = runtimeScript;
+      }
+    });
+
+    expect(composition.runtime.start()).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        composition.createTraceCapabilityProviderRegistrationForTest()
+      )
+    ).toBe(true);
+    expect(
+      composition.runtime.registerIntegration(
+        testTakeoverRegistration('context_test', releaseId, () =>
+          Object.freeze({ activate: vi.fn() })
+        )
+      )
+    ).toBe(true);
+    await expect(composition.runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(document.getElementById(TRACE_PANEL_ID)).toBeNull();
+    expect(presentationAnimationFrame).not.toHaveBeenCalled();
+    expect(frames).toEqual([]);
+    expect(idle).toEqual([]);
+    expect(loadedPresentation).not.toHaveBeenCalled();
+    expect(preGateSlot.getAttributeNames().filter((name) => name.startsWith('data-ts-'))).toEqual(
+      []
+    );
+    expect(composition.runtimeSessionForTest()?.interfaces).not.toHaveProperty('gpt.events.v1');
+    expect(composition.runtimeSessionForTest()?.interfaces).not.toHaveProperty('gpt_diag.v1');
+    expect(composition.runtime.protectFirstDisplayAttemptBatch([Promise.resolve()])).toBe(true);
+    await Promise.resolve();
+    await Promise.resolve();
+    frames.shift()?.(1);
+    frames.shift()?.(2);
+    idle.shift()?.();
+    await vi.waitFor(() => expect(loadedPresentation).toHaveBeenCalledOnce());
+    expect(document.getElementById(TRACE_PANEL_ID)).not.toBeNull();
+    expect(presentationAnimationFrame).not.toHaveBeenCalled();
+    const contextContributor = vi.fn(() => ({ page: 'context' }));
+    const session = composition.runtimeSessionForTest();
+    expect(session).toBeDefined();
+    expect(
+      composition
+        .auctionContextRegistryForTest()
+        ?.register('context_test', contextContributor, session!)
+    ).toBe(true);
+    const api = target as {
+      addAdUnits(value: unknown): { readonly registered: readonly string[] };
+      requestAds(options?: unknown): Promise<{ readonly slots: readonly object[] }>;
+    };
+    const programmatic = {
+      code: 'programmatic-slot',
+      mediaTypes: { banner: { sizes: [[300, 250]] } },
+      bids: [{ bidder: 'fictional', params: { placement: 7 } }],
+    };
+
+    expect(api.addAdUnits(programmatic)).toEqual({ registered: ['programmatic-slot'] });
+    expect(composition.projectionSlotsForTest()).toEqual(['server-slot', 'programmatic-slot']);
+    const slotService = composition.slotServiceForTest();
+    expect(slotService?.resolveRegisteredSlot('programmatic-slot')).toMatchObject({
+      domAliases: [],
+      registeredSlotId: 'programmatic-slot',
+      source: 'programmatic',
+    });
+    expect(slotService?.resolveDomAlias('programmatic-slot')).toBeUndefined();
+    expect(() =>
+      api.addAdUnits([
+        {
+          code: 'must-roll-back',
+          mediaTypes: { banner: { sizes: [[1, 1]] } },
+        },
+        {
+          code: 'server-slot',
+          mediaTypes: { banner: { sizes: [[1, 1]] } },
+        },
+      ])
+    ).toThrowError(expect.objectContaining({ code: 'slot_collision', unitIndex: 1 }));
+    expect(composition.projectionSlotsForTest()).toEqual(['server-slot', 'programmatic-slot']);
+    document.body.insertAdjacentHTML(
+      'beforeend',
+      '<div id="programmatic-slot"><span>placeholder</span></div>'
+    );
+    const explicit = api.requestAds({ slots: ['unknown', 'programmatic-slot'] });
+    await vi.waitFor(() =>
+      expect(document.querySelector('#programmatic-slot iframe')).not.toBeNull()
+    );
+    const frame = document.querySelector<HTMLIFrameElement>('#programmatic-slot iframe');
+    expect(frame?.srcdoc).toContain('programmatic winner');
+    frame?.dispatchEvent(new Event('load'));
+    await expect(explicit).resolves.toEqual({
+      slots: [
+        { slot: 'unknown', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+        { slot: 'programmatic-slot', path: 'primary', outcome: 'accepted' },
+      ],
+    });
+    const renderTrace = (
+      target as {
+        diagnostics?: {
+          renderTrace?: {
+            current(): Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+            history(): readonly Readonly<Record<string, unknown>>[];
+          };
+        };
+      }
+    ).diagnostics?.renderTrace;
+    expect(renderTrace?.current()['programmatic-slot']).toEqual(
+      expect.objectContaining({
+        slotId: 'programmatic-slot',
+        path: 'auction',
+        rendered: true,
+        injected: true,
+        elementId: 'programmatic-slot',
+        servedFrom: 'inline',
+        count: 1,
+      })
+    );
+    expect(renderTrace?.history()).toHaveLength(1);
+    expect(Object.isFrozen(renderTrace?.history()[0])).toBe(true);
+    const programmaticSlot = document.getElementById('programmatic-slot');
+    await vi.waitFor(() => {
+      expect(programmaticSlot?.getAttribute('data-ts-rendered')).toBe('true');
+      expect(programmaticSlot?.getAttribute('data-ts-injected')).toBe('true');
+      expect(document.getElementById(TRACE_PANEL_ID)?.textContent).toContain('programmatic-slot');
+    });
+    expect(target).not.toHaveProperty('renders');
+    expect(target).not.toHaveProperty('renderLog');
+    expect(target).not.toHaveProperty('renderSeq');
+    expect(requestBodies[0]).toEqual({
+      adUnits: [programmatic],
+      config: { page: 'context' },
+    });
+    expect(contextContributor).toHaveBeenCalledOnce();
+
+    const omitted = api.requestAds();
+    expect(
+      api.addAdUnits({
+        code: 'later-slot',
+        mediaTypes: { banner: { sizes: [[728, 90]] } },
+      })
+    ).toEqual({ registered: ['later-slot'] });
+    await expect(omitted).resolves.toEqual({
+      slots: [
+        { slot: 'server-slot', path: 'primary', outcome: 'no_bid' },
+        { slot: 'programmatic-slot', path: 'primary', outcome: 'no_bid' },
+      ],
+    });
+    expect(requestBodies[1]?.adUnits.map(({ code }) => code)).toEqual([
+      'server-slot',
+      'programmatic-slot',
+    ]);
+    expect(requestBodies[1]?.adUnits).not.toContainEqual(
+      expect.objectContaining({ code: 'later-slot' })
+    );
+    expect(requestBodies[1]?.config).toEqual({ page: 'context' });
+    expect(contextContributor).toHaveBeenCalledTimes(2);
+    expect(auctionFetcher).toHaveBeenCalledTimes(2);
+
+    expect(
+      slotService?.register(session!.currentNavigation!, [
+        {
+          adUnitCode: '/network/path',
+          domAliases: ['publisher-alias'],
+          registeredSlotId: 'alias-owner',
+          source: 'server',
+        },
+      ])
+    ).toMatchObject({ ok: true });
+    await expect(
+      api.requestAds({ slots: ['publisher-alias', '/network/path', 'alias-owner'] })
+    ).resolves.toEqual({
+      slots: [
+        { slot: 'publisher-alias', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+        { slot: '/network/path', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+        { slot: 'alias-owner', path: 'primary', outcome: 'no_bid' },
+      ],
+    });
+    expect(requestBodies[2]?.adUnits.map(({ code }) => code)).toEqual(['alias-owner']);
+
+    expect(
+      api.addAdUnits({
+        code: 'ambiguous-slot',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      })
+    ).toEqual({ registered: ['ambiguous-slot'] });
+    document.body.insertAdjacentHTML(
+      'beforeend',
+      '<div id="ambiguous-slot"></div><div id="ambiguous-slot"></div>'
+    );
+    await expect(api.requestAds({ slots: ['ambiguous-slot'] })).resolves.toEqual({
+      slots: [
+        {
+          slot: 'ambiguous-slot',
+          path: 'primary',
+          outcome: 'failed',
+          reason: 'slot_unresolved',
+        },
+      ],
+    });
+    expect(document.querySelectorAll('[id="ambiguous-slot"] iframe')).toHaveLength(0);
+    expect(contextContributor).toHaveBeenCalledTimes(4);
+    expect(auctionFetcher).toHaveBeenCalledTimes(4);
+
+    session?.currentNavigation?.dispose();
+    expect(renderTrace?.current()).toEqual({});
+    await vi.waitFor(() => expect(programmaticSlot?.hasAttribute('data-ts-rendered')).toBe(false));
+
+    composition.runtime.dispose();
+    expect(document.getElementById(TRACE_PANEL_ID)).toBeNull();
+    expect(preGateSlot.getAttributeNames().filter((name) => name.startsWith('data-ts-'))).toEqual(
+      []
+    );
+    expect(() => api.addAdUnits(programmatic)).toThrowError(
+      expect.objectContaining({ name: 'AdUnitRegistrationError', code: 'slot_collision' })
+    );
+    document.body.innerHTML = '';
+    headAppend.mockRestore();
+    currentScript.mockRestore();
+    runtimeScript.remove();
+    preGateSlot.remove();
+    vi.unstubAllGlobals();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/composition/maximal-runtime.test.ts b/crates/trusted-server-js/lib/test/composition/maximal-runtime.test.ts
new file mode 100644
index 000000000..79700c42e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/composition/maximal-runtime.test.ts
@@ -0,0 +1,1032 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createNoopGoogletagAdapter,
+  type GoogletagDiagnosticsObserver,
+} from '../../src/adapters/googletag';
+import { createNoopMessagingAdapter } from '../../src/adapters/messaging';
+import { createNoopPrebidAdapter } from '../../src/adapters/prebid';
+import { createTestBrowserRuntimeComposition } from '../../src/composition/browser_test';
+import { createApsIntegrationRegistration } from '../../src/integrations/aps/module';
+import { createCreativeIntegrationRegistration } from '../../src/integrations/creative/module';
+import { createDataDomeIntegrationRegistration } from '../../src/integrations/datadome/module';
+import { createDidomiIntegrationRegistration } from '../../src/integrations/didomi/module';
+import { createGoogleTagManagerIntegrationRegistration } from '../../src/integrations/google_tag_manager/module';
+import { createGptLaterIntegrationRegistration } from '../../src/integrations/gpt/later';
+import { createGptIntegrationRegistration } from '../../src/integrations/gpt/module';
+import { createGptDiagnosticsIntegrationRegistration } from '../../src/integrations/gpt_diagnostics/module';
+import { createDiagnosticsPresentationIntegrationRegistration } from '../../src/integrations/gpt_diagnostics/presentation';
+import { createLockrIntegrationRegistration } from '../../src/integrations/lockr/module';
+import { createOsanoLifecycleIntegrationRegistration } from '../../src/integrations/osano/lifecycle';
+import { createOsanoIntegrationRegistration } from '../../src/integrations/osano/module';
+import { createPermutiveLifecycleIntegrationRegistration } from '../../src/integrations/permutive/lifecycle';
+import { createPermutiveIntegrationRegistration } from '../../src/integrations/permutive/module';
+import { createPrebidLaterIntegrationRegistration } from '../../src/integrations/prebid/later';
+import { createPrebidIntegrationRegistration } from '../../src/integrations/prebid/module';
+import { createRenderRuntimeIntegrationRegistration } from '../../src/integrations/render_runtime/module';
+import { createSourcepointLifecycleIntegrationRegistration } from '../../src/integrations/sourcepoint/lifecycle';
+import { createSourcepointIntegrationRegistration } from '../../src/integrations/sourcepoint/module';
+import { createTestlightIntegrationRegistration } from '../../src/integrations/testlight/module';
+import type { BootManifestV1 } from '../../src/core/types';
+import type {
+  IntegrationActivationContext,
+  IntegrationCatalogEntry,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+  PreparedIntegration,
+} from '../../src/kernel/integration_registry';
+import {
+  MAX_TAKEOVER_MODULES,
+  MAX_MANIFEST_MODULES,
+  RELEASE_CATALOG,
+} from '../../src/kernel/release_catalog';
+
+const TEST_RELEASE_ID = 'a'.repeat(64);
+const EXPECTED_MAXIMAL_INTEGRATION_IDS = Object.freeze([
+  'render_runtime',
+  'aps',
+  'creative',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'gpt_diagnostics',
+  'lockr',
+  'osano_consent',
+  'permutive_context',
+  'sourcepoint_consent',
+  'prebid',
+  'testlight',
+  'diagnostics_presentation',
+  'gpt_later',
+  'osano_lifecycle',
+  'permutive_lifecycle',
+  'prebid_later',
+  'sourcepoint_lifecycle',
+]);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+const DEFERRED_INTEGRATION_IDS = Object.freeze([
+  'diagnostics_presentation',
+  'gpt_later',
+  'osano_lifecycle',
+  'permutive_lifecycle',
+  'prebid_later',
+  'sourcepoint_lifecycle',
+] as const);
+
+type RegistrationFactory = (release: string) => IntegrationRegistration;
+
+const REGISTRATION_FACTORIES = new Map<string, RegistrationFactory>([
+  ['render_runtime', createRenderRuntimeIntegrationRegistration],
+  ['aps', createApsIntegrationRegistration],
+  ['creative', createCreativeIntegrationRegistration],
+  ['datadome', createDataDomeIntegrationRegistration],
+  ['didomi', createDidomiIntegrationRegistration],
+  ['google_tag_manager', createGoogleTagManagerIntegrationRegistration],
+  ['gpt', createGptIntegrationRegistration],
+  ['gpt_diagnostics', createGptDiagnosticsIntegrationRegistration],
+  ['lockr', createLockrIntegrationRegistration],
+  ['osano_consent', createOsanoIntegrationRegistration],
+  ['permutive_context', createPermutiveIntegrationRegistration],
+  ['prebid', createPrebidIntegrationRegistration],
+  ['sourcepoint_consent', createSourcepointIntegrationRegistration],
+  ['testlight', createTestlightIntegrationRegistration],
+  ['diagnostics_presentation', createDiagnosticsPresentationIntegrationRegistration],
+  ['gpt_later', createGptLaterIntegrationRegistration],
+  ['osano_lifecycle', createOsanoLifecycleIntegrationRegistration],
+  ['permutive_lifecycle', createPermutiveLifecycleIntegrationRegistration],
+  ['prebid_later', createPrebidLaterIntegrationRegistration],
+  ['sourcepoint_lifecycle', createSourcepointLifecycleIntegrationRegistration],
+]);
+
+function maximalIntegrationIds(): readonly string[] {
+  return Object.freeze(RELEASE_CATALOG.map(({ id }) => id));
+}
+
+function maximalManifest(): Readonly<BootManifestV1> {
+  return Object.freeze({
+    version: 1,
+    releaseId: TEST_RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: RUNTIME_SRC,
+    integrations: Object.freeze(
+      RELEASE_CATALOG.map(({ id, phase, trigger }) => {
+        if (phase === 'takeover') return Object.freeze({ id, phase });
+        if (trigger !== 'first_display_or_idle') {
+          throw new TypeError(`Deferred fixture ${id} is missing its canonical trigger`);
+        }
+        return Object.freeze({
+          id,
+          phase,
+          trigger,
+          src: `/static/tsjs=tsjs-${id}.min.js?v=${'d'.repeat(64)}`,
+        });
+      })
+    ),
+  });
+}
+
+function maximalRegistryCatalog(): readonly IntegrationCatalogEntry[] {
+  return Object.freeze(
+    RELEASE_CATALOG.map(({ id, phase, trigger, config, consumes, provides }) =>
+      Object.freeze({ id, phase, trigger, config, consumes, provides })
+    )
+  );
+}
+
+function tracedRegistration(
+  registration: IntegrationRegistration,
+  events: string[],
+  failAfterActivation?: string
+): IntegrationRegistration {
+  const tracePrepared = (prepared: PreparedIntegration): PreparedIntegration => {
+    const traced: PreparedIntegration = {
+      activate: (activationContext: IntegrationActivationContext): void => {
+        events.push(`activate:${registration.id}`);
+        activationContext.onDispose(() => events.push(`dispose:${registration.id}`));
+        prepared.activate(activationContext);
+        if (registration.id === failAfterActivation) {
+          throw new Error(`injected ${registration.id} activation failure`);
+        }
+      },
+    };
+    const interfacesDescriptor = Object.getOwnPropertyDescriptor(prepared, 'interfaces');
+    if (interfacesDescriptor) Object.defineProperty(traced, 'interfaces', interfacesDescriptor);
+    return Object.freeze(traced);
+  };
+  const prepare = async (context: IntegrationPrepareContext): Promise<PreparedIntegration> => {
+    events.push(`prepare:${registration.id}`);
+    return tracePrepared(await registration.prepare(context));
+  };
+  if (registration.phase === 'deferred') {
+    return Object.freeze({
+      abi: registration.abi,
+      id: registration.id,
+      phase: registration.phase,
+      releaseId: registration.releaseId,
+      prepare,
+    });
+  }
+  const prepareSync = (context: IntegrationPrepareContext): PreparedIntegration => {
+    events.push(`prepare:${registration.id}`);
+    return tracePrepared(registration.prepareSync(context));
+  };
+  return Object.freeze({
+    abi: registration.abi,
+    id: registration.id,
+    phase: registration.phase,
+    releaseId: registration.releaseId,
+    prepareSync,
+    prepare,
+  });
+}
+
+function integrationConfig(id: string): unknown {
+  if (id === 'didomi') return Object.freeze({ proxyPath: '/integrations/didomi/consent/' });
+  if (id === 'gpt') {
+    return Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled: true });
+  }
+  if (id === 'prebid') {
+    return Object.freeze({
+      accountId: 'test',
+      timeout: 1_000,
+      debug: false,
+      bidders: Object.freeze([]),
+      clientSideBidders: Object.freeze([]),
+      excludedGamAdUnitPathSuffixes: Object.freeze([]),
+    });
+  }
+  if (id === 'sourcepoint_consent') return Object.freeze({ rewriteSdk: true });
+  if (
+    [
+      'aps',
+      'datadome',
+      'google_tag_manager',
+      'lockr',
+      'osano_consent',
+      'permutive_context',
+      'testlight',
+    ].includes(id)
+  ) {
+    return Object.freeze({});
+  }
+  return undefined;
+}
+
+const MAXIMAL_CONFIG_PRODUCTS = Object.freeze([
+  ['aps', 'aps'],
+  ['datadome', 'datadome'],
+  ['didomi', 'didomi'],
+  ['google_tag_manager', 'google_tag_manager'],
+  ['gpt', 'gpt'],
+  ['lockr', 'lockr'],
+  ['osano', 'osano_consent'],
+  ['permutive', 'permutive_context'],
+  ['prebid', 'prebid'],
+  ['sourcepoint', 'sourcepoint_consent'],
+  ['testlight', 'testlight'],
+] as const);
+
+function maximalIntegrationConfigs(
+  overrides: Readonly<Record<string, unknown>> | undefined
+): Readonly<Record<string, unknown>> {
+  return Object.freeze({
+    version: 1,
+    entries: Object.freeze(
+      MAXIMAL_CONFIG_PRODUCTS.map(([id, moduleId]) =>
+        Object.freeze({
+          id,
+          config:
+            overrides && Object.prototype.hasOwnProperty.call(overrides, moduleId)
+              ? overrides[moduleId]
+              : integrationConfig(moduleId),
+        })
+      )
+    ),
+  });
+}
+
+interface MaximalHarnessOptions {
+  readonly blockDeferredId?: (typeof DEFERRED_INTEGRATION_IDS)[number];
+  readonly configOverrides?: Readonly<Record<string, unknown>>;
+  readonly failAfterActivation?: string;
+}
+
+interface TrackedListener {
+  readonly capture: boolean;
+  readonly listener: EventListenerOrEventListenerObject;
+  readonly target: EventTarget;
+  readonly type: string;
+}
+
+interface TrackedDeferredDeadline {
+  active: boolean;
+  readonly handle: ReturnType<typeof setTimeout>;
+  id?: string;
+  readonly identity: number;
+  readonly startedAt: number;
+}
+
+function captureOption(options?: boolean | AddEventListenerOptions): boolean {
+  return typeof options === 'boolean' ? options : options?.capture === true;
+}
+
+function createMaximalHarness(options: MaximalHarnessOptions = {}) {
+  const integrationIds = maximalIntegrationIds();
+  const events: string[] = [];
+  const registrations = integrationIds.map((id) => {
+    const factory = REGISTRATION_FACTORIES.get(id);
+    if (!factory) throw new Error(`Missing real registration factory for ${id}`);
+    return tracedRegistration(factory(TEST_RELEASE_ID), events, options.failAfterActivation);
+  });
+  const registrationsById = new Map(
+    registrations.map((registration) => [registration.id, registration])
+  );
+  const takeoverRegistrations = registrations.filter(({ phase }) => phase === 'takeover');
+  const deferredRegistrations = registrations.filter(({ phase }) => phase === 'deferred');
+  const frames: FrameRequestCallback[] = [];
+  const idle: Array<() => void> = [];
+  const deferredDeadlines: TrackedDeferredDeadline[] = [];
+  let nextDeferredDeadlineIdentity = 1;
+  const trackedSetTimeout = (
+    callback: () => void,
+    delayMs: number
+  ): ReturnType<typeof setTimeout> => {
+    let deadline: TrackedDeferredDeadline | undefined;
+    const handle = setTimeout(() => {
+      if (deadline) deadline.active = false;
+      callback();
+    }, delayMs);
+    if (delayMs === 10_000) {
+      deadline = {
+        active: true,
+        handle,
+        identity: nextDeferredDeadlineIdentity,
+        startedAt: Date.now(),
+      };
+      nextDeferredDeadlineIdentity += 1;
+      deferredDeadlines.push(deadline);
+    }
+    return handle;
+  };
+  const trackedClearTimeout = (handle: ReturnType<typeof setTimeout>): void => {
+    const deadline = deferredDeadlines.find((candidate) => candidate.handle === handle);
+    if (deadline) deadline.active = false;
+    clearTimeout(handle);
+  };
+  // JSDOM lazily installs its selector engine's own document-scoped listeners.
+  // Materialize that test-environment infrastructure before tracking runtime effects.
+  document.querySelectorAll('[id]');
+  const activeObservers = new Set<GoogletagDiagnosticsObserver>();
+  const activeMutationObservers = new Set<MutationObserver>();
+  const listenerRecords: TrackedListener[] = [];
+  const eventTargetPrototype = EventTarget.prototype;
+  const addDescriptor = Object.getOwnPropertyDescriptor(eventTargetPrototype, 'addEventListener');
+  const removeDescriptor = Object.getOwnPropertyDescriptor(
+    eventTargetPrototype,
+    'removeEventListener'
+  );
+  if (
+    !addDescriptor ||
+    !('value' in addDescriptor) ||
+    typeof addDescriptor.value !== 'function' ||
+    !removeDescriptor ||
+    !('value' in removeDescriptor) ||
+    typeof removeDescriptor.value !== 'function'
+  ) {
+    throw new Error('EventTarget listener intrinsics are unavailable');
+  }
+  const nativeAdd = addDescriptor.value as EventTarget['addEventListener'];
+  const nativeRemove = removeDescriptor.value as EventTarget['removeEventListener'];
+  Object.defineProperty(eventTargetPrototype, 'addEventListener', {
+    ...addDescriptor,
+    value: function (
+      this: EventTarget,
+      type: string,
+      listener: EventListenerOrEventListenerObject,
+      listenerOptions?: boolean | AddEventListenerOptions
+    ): void {
+      Reflect.apply(nativeAdd, this, [type, listener, listenerOptions]);
+      if (this !== window && this !== document) return;
+      const capture = captureOption(listenerOptions);
+      if (
+        !listenerRecords.some(
+          (record) =>
+            record.target === this &&
+            record.type === type &&
+            record.listener === listener &&
+            record.capture === capture
+        )
+      ) {
+        listenerRecords.push({ capture, listener, target: this, type });
+      }
+    },
+  });
+  Object.defineProperty(eventTargetPrototype, 'removeEventListener', {
+    ...removeDescriptor,
+    value: function (
+      this: EventTarget,
+      type: string,
+      listener: EventListenerOrEventListenerObject,
+      listenerOptions?: boolean | EventListenerOptions
+    ): void {
+      Reflect.apply(nativeRemove, this, [type, listener, listenerOptions]);
+      const capture = captureOption(listenerOptions);
+      const index = listenerRecords.findIndex(
+        (record) =>
+          record.target === this &&
+          record.type === type &&
+          record.listener === listener &&
+          record.capture === capture
+      );
+      if (index >= 0) listenerRecords.splice(index, 1);
+    },
+  });
+
+  const NativeMutationObserver = window.MutationObserver;
+  class TrackedMutationObserver extends NativeMutationObserver {
+    public constructor(callback: MutationCallback) {
+      super(callback);
+      activeMutationObservers.add(this);
+    }
+
+    public override disconnect(): void {
+      activeMutationObservers.delete(this);
+      super.disconnect();
+    }
+  }
+  vi.stubGlobal('MutationObserver', TrackedMutationObserver);
+
+  let activeCaptureListeners = 0;
+  const captureListenerIdentities = new Set<(event: MessageEvent) => void>();
+  const googletag = Object.freeze({
+    ...createNoopGoogletagAdapter(),
+    observeDiagnostics: (observer: GoogletagDiagnosticsObserver) => {
+      activeObservers.add(observer);
+      return (): void => {
+        activeObservers.delete(observer);
+      };
+    },
+  });
+  const messaging = Object.freeze({
+    ...createNoopMessagingAdapter(),
+    installCaptureListener: (listener: (event: MessageEvent) => void) => {
+      activeCaptureListeners += 1;
+      captureListenerIdentities.add(listener);
+      window.addEventListener('message', listener, true);
+      let active = true;
+      return (): void => {
+        if (!active) return;
+        active = false;
+        activeCaptureListeners -= 1;
+        captureListenerIdentities.delete(listener);
+        window.removeEventListener('message', listener, true);
+      };
+    },
+  });
+  const target: Record<string, unknown> = {};
+  const appendChildBefore = Element.prototype.appendChild;
+  const insertBeforeBefore = Element.prototype.insertBefore;
+  const fetchBefore = Object.getOwnPropertyDescriptor(window, 'fetch');
+  const sendBeaconBefore = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+  const didomiBefore = Object.getOwnPropertyDescriptor(window, 'didomiConfig');
+  const testlightBefore = Object.getOwnPropertyDescriptor(window, 'testlight');
+  const composition = createTestBrowserRuntimeComposition(
+    {
+      target,
+      releaseId: TEST_RELEASE_ID,
+      manifest: maximalManifest(),
+      knownIntegrationIds: integrationIds,
+      catalog: maximalRegistryCatalog(),
+      boot: {
+        auctionProjection: {
+          version: 1,
+          auction: { version: 1, auctionId: 'initial', results: [] },
+          slots: [],
+          bids: [],
+        },
+        integrations: maximalIntegrationConfigs(options.configOverrides),
+        creative: { version: 1, enabled: true, clickGuard: true, renderGuard: false },
+        diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+      },
+      getBindings: (id) =>
+        Object.freeze({
+          config:
+            options.configOverrides !== undefined &&
+            Object.prototype.hasOwnProperty.call(options.configOverrides, id)
+              ? options.configOverrides?.[id]
+              : integrationConfig(id),
+          interfaces: Object.freeze({}),
+        }),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      phaseScheduler: {
+        cancelAnimationFrame: vi.fn(),
+        cancelIdleCallback: vi.fn(),
+        clearTimeout: trackedClearTimeout,
+        requestAnimationFrame: (callback) => {
+          frames.push(callback);
+          return frames.length;
+        },
+        requestIdleCallback: (callback) => {
+          idle.push(callback);
+          return idle.length;
+        },
+        setTimeout: trackedSetTimeout,
+      },
+    },
+    {
+      adapters: {
+        googletag,
+        messaging,
+        prebid: createNoopPrebidAdapter(),
+      },
+      coreActivations: { correctnessGptListeners: vi.fn() },
+    }
+  );
+
+  expect(composition.runtime.start()).toBe(true);
+  expect(composition.runtime.start()).toBe(false);
+  for (const registration of takeoverRegistrations) {
+    expect(
+      composition.runtime.registerIntegration(registration),
+      `register ${registration.id}`
+    ).toBe(true);
+    events.push(`register:${registration.id}`);
+  }
+  const runtimeScript = document.querySelector<HTMLScriptElement>('#trustedserver-js');
+  if (!runtimeScript) throw new Error('Maximal fixture takeover script is unavailable');
+  const nativeHeadAppend = document.head.append.bind(document.head);
+  const appendDeferred = vi.spyOn(document.head, 'append').mockImplementation((...nodes) => {
+    nativeHeadAppend(...nodes);
+    for (const node of nodes) {
+      if (!(node instanceof HTMLScriptElement) || node === runtimeScript) continue;
+      const matchedId = /\/static\/tsjs=tsjs-([a-z0-9_-]+)\.min\.js$/.exec(
+        new URL(node.src).pathname
+      )?.[1];
+      const registration = matchedId ? registrationsById.get(matchedId) : undefined;
+      if (!registration || registration.phase !== 'deferred') {
+        throw new Error(`Unexpected deferred artifact ${node.src}`);
+      }
+      const deadline = [...deferredDeadlines]
+        .reverse()
+        .find((candidate) => candidate.active && candidate.id === undefined);
+      if (!deadline) throw new Error(`Deferred deadline is unavailable for ${registration.id}`);
+      deadline.id = registration.id;
+      if (registration.id === options.blockDeferredId) continue;
+      Object.defineProperty(document, 'currentScript', { configurable: true, value: node });
+      expect(
+        composition.runtime.registerIntegration(registration),
+        `register deferred ${registration.id}`
+      ).toBe(true);
+      events.push(`register:${registration.id}`);
+      node.onload?.(new Event('load'));
+      Object.defineProperty(document, 'currentScript', {
+        configurable: true,
+        value: runtimeScript,
+      });
+    }
+  });
+
+  const loadDeferred = async (): Promise<void> => {
+    expect(composition.runtime.protectFirstDisplayAttemptBatch([Promise.resolve()])).toBe(true);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(frames).toHaveLength(1);
+    frames.shift()?.(1);
+    expect(frames).toHaveLength(1);
+    frames.shift()?.(2);
+    expect(idle).toHaveLength(1);
+    idle.shift()?.();
+    const expectedDeferredIds = deferredRegistrations
+      .map(({ id }) => id)
+      .filter((id) => id !== options.blockDeferredId);
+    await vi.waitFor(() => {
+      expect(
+        events
+          .filter((event) => event.startsWith('register:'))
+          .filter((event) => deferredRegistrations.some(({ id }) => event === `register:${id}`))
+      ).toEqual(expectedDeferredIds.map((id) => `register:${id}`));
+      expect(deferredDeadlines.filter(({ id }) => id !== undefined)).toHaveLength(
+        deferredRegistrations.length
+      );
+    });
+  };
+
+  const assertReleased = async (): Promise<void> => {
+    composition.runtime.dispose();
+    composition.runtime.dispose();
+    await Promise.resolve();
+    expect(activeObservers.size).toBe(0);
+    expect(activeMutationObservers.size).toBe(0);
+    expect(activeCaptureListeners).toBe(0);
+    expect(
+      listenerRecords.map(({ capture, target: listenerTarget, type }) => ({
+        capture,
+        target: listenerTarget.constructor.name,
+        type,
+      }))
+    ).toEqual([]);
+    expect(composition.auctionContextRegistryForTest()).toBeUndefined();
+    expect(vi.getTimerCount()).toBe(0);
+    expect(Element.prototype.appendChild).toBe(appendChildBefore);
+    expect(Element.prototype.insertBefore).toBe(insertBeforeBefore);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchBefore);
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconBefore);
+    expect(Object.getOwnPropertyDescriptor(window, 'didomiConfig')).toEqual(didomiBefore);
+    expect(Object.getOwnPropertyDescriptor(window, 'testlight')).toEqual(testlightBefore);
+  };
+
+  const restoreInstrumentation = (): void => {
+    for (const record of [...listenerRecords]) {
+      try {
+        Reflect.apply(nativeRemove, record.target, [record.type, record.listener, record.capture]);
+      } catch {
+        // Test cleanup must not hide the first assertion failure.
+      }
+    }
+    listenerRecords.length = 0;
+    for (const observer of [...activeMutationObservers]) observer.disconnect();
+    appendDeferred.mockRestore();
+    Object.defineProperty(eventTargetPrototype, 'addEventListener', addDescriptor);
+    Object.defineProperty(eventTargetPrototype, 'removeEventListener', removeDescriptor);
+  };
+
+  return Object.freeze({
+    assertReleased,
+    takeoverIntegrationIds: takeoverRegistrations.map(({ id }) => id),
+    composition,
+    deferredDeadlines: () =>
+      Object.freeze(
+        deferredDeadlines.flatMap(({ active, id, identity, startedAt }) =>
+          id === undefined ? [] : [Object.freeze({ active, id, identity, startedAt })]
+        )
+      ),
+    deferredIntegrationIds: deferredRegistrations.map(({ id }) => id),
+    events,
+    integrationIds,
+    loadDeferred,
+    ownershipIdentities: () =>
+      Object.freeze({
+        adapters: composition.adapters,
+        captureListeners: Object.freeze([...captureListenerIdentities]),
+        runtime: composition.runtime,
+      }),
+    resourceCounts: () =>
+      Object.freeze({
+        captureListeners: activeCaptureListeners,
+        listeners: listenerRecords.length,
+        mutationObservers: activeMutationObservers.size,
+        observers: activeObservers.size,
+      }),
+    restoreInstrumentation,
+    target,
+  });
+}
+
+describe('generated maximal browser runtime transaction', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('derives the complete maximal fixture in canonical release order', () => {
+    const integrationIds = maximalIntegrationIds();
+    const manifest = maximalManifest();
+
+    expect(integrationIds).toEqual(EXPECTED_MAXIMAL_INTEGRATION_IDS);
+    expect(integrationIds).toHaveLength(MAX_MANIFEST_MODULES);
+    expect(manifest).toMatchObject({
+      version: 1,
+      releaseId: TEST_RELEASE_ID,
+      firstDisplay: null,
+      runtimeSrc: RUNTIME_SRC,
+    });
+    expect(manifest.integrations.map(({ id }) => id)).toEqual(integrationIds);
+    expect(
+      manifest.integrations
+        .slice(0, MAX_TAKEOVER_MODULES)
+        .every(({ phase }) => phase === 'takeover')
+    ).toBe(true);
+    expect(
+      manifest.integrations.slice(MAX_TAKEOVER_MODULES).every(({ phase }) => phase === 'deferred')
+    ).toBe(true);
+    for (const entry of manifest.integrations) {
+      expect(Object.isFrozen(entry)).toBe(true);
+      if (entry.phase === 'takeover') {
+        expect(Reflect.ownKeys(entry).sort()).toEqual(['id', 'phase']);
+      } else {
+        expect(Reflect.ownKeys(entry).sort()).toEqual(['id', 'phase', 'src', 'trigger']);
+        expect(entry.trigger).toBe('first_display_or_idle');
+        expect(entry.src).toBe(`/static/tsjs=tsjs-${entry.id}.min.js?v=${'d'.repeat(64)}`);
+      }
+    }
+    expect(Object.isFrozen(manifest)).toBe(true);
+    expect(Object.isFrozen(manifest.integrations)).toBe(true);
+  });
+
+  it.each([
+    ['provider', true],
+    ['non-provider', false],
+  ] as const)(
+    'preserves exact prepared interfaces for a %s registration',
+    async (_name, provider) => {
+      const capability = Object.freeze({ invoke: vi.fn() });
+      const providerInterfaces = Object.freeze({ 'fixture.v1': capability });
+      const activate = vi.fn();
+      const registration: IntegrationRegistration = Object.freeze({
+        abi: 1,
+        id: 'fixture',
+        phase: 'takeover',
+        releaseId: TEST_RELEASE_ID,
+        prepareSync: () =>
+          provider
+            ? Object.freeze({ activate, interfaces: providerInterfaces })
+            : Object.freeze({ activate }),
+        prepare: async () =>
+          provider
+            ? Object.freeze({ activate, interfaces: providerInterfaces })
+            : Object.freeze({ activate }),
+      });
+      const prepared = await tracedRegistration(registration, []).prepare({
+        config: undefined,
+        interfaces: Object.freeze({}),
+        signal: new AbortController().signal,
+        onDispose: vi.fn(),
+      });
+
+      expect(Object.isFrozen(prepared)).toBe(true);
+      expect(Reflect.ownKeys(prepared).sort()).toEqual(
+        provider ? ['activate', 'interfaces'] : ['activate']
+      );
+      if (provider) {
+        expect(Object.getOwnPropertyDescriptor(prepared, 'interfaces')).toMatchObject({
+          enumerable: true,
+          value: providerInterfaces,
+        });
+        expect(prepared.interfaces).toBe(providerInterfaces);
+        expect(prepared.interfaces?.['fixture.v1']).toBe(capability);
+      } else {
+        expect(Object.prototype.hasOwnProperty.call(prepared, 'interfaces')).toBe(false);
+      }
+    }
+  );
+
+  it('owns all server bundles once and disposes them in exact reverse generated order', async () => {
+    vi.useFakeTimers();
+    const harness = createMaximalHarness();
+    try {
+      const installed = await harness.composition.runtime.install();
+      if (installed.state === 'fallback') {
+        throw new Error(`${installed.reason}: ${harness.events.join(',')}`);
+      }
+      expect(installed).toEqual({
+        state: 'kernel',
+        runtimeFailures: [],
+        dispose: expect.any(Function),
+      });
+      expect(harness.composition.runtime.state).toBe('kernel');
+
+      await harness.loadDeferred();
+      expect(harness.events.filter((event) => event.startsWith('register:'))).toEqual(
+        harness.integrationIds.map((id) => `register:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('prepare:'))).toEqual(
+        harness.integrationIds.map((id) => `prepare:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('activate:'))).toEqual(
+        harness.integrationIds.map((id) => `activate:${id}`)
+      );
+
+      window.dispatchEvent(new Event('resize'));
+      harness.composition.runtime.dispose();
+      harness.composition.runtime.dispose();
+      await Promise.resolve();
+      expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+        [...harness.integrationIds].reverse().map((id) => `dispose:${id}`)
+      );
+      await harness.assertReleased();
+    } finally {
+      harness.restoreInstrumentation();
+    }
+  });
+
+  it.each(DEFERRED_INTEGRATION_IDS)(
+    'starts five deferred siblings independently while %s remains blocked to its own deadline',
+    async (blockedId) => {
+      vi.useFakeTimers();
+      const harness = createMaximalHarness({ blockDeferredId: blockedId });
+      try {
+        const installed = await harness.composition.runtime.install();
+        expect(installed.state).toBe('kernel');
+        const ownershipBefore = harness.ownershipIdentities();
+        expect(ownershipBefore.captureListeners).toHaveLength(1);
+
+        await harness.loadDeferred();
+
+        const activeIds = harness.integrationIds.filter((id) => id !== blockedId);
+        await vi.waitFor(() => {
+          expect(harness.events.filter((event) => event.startsWith('register:'))).toEqual(
+            activeIds.map((id) => `register:${id}`)
+          );
+          expect(harness.events.filter((event) => event.startsWith('prepare:'))).toEqual(
+            activeIds.map((id) => `prepare:${id}`)
+          );
+          expect(harness.events.filter((event) => event.startsWith('activate:'))).toEqual(
+            activeIds.map((id) => `activate:${id}`)
+          );
+        });
+
+        const startedDeadlines = harness.deferredDeadlines();
+        expect(startedDeadlines.map(({ id }) => id)).toEqual(DEFERRED_INTEGRATION_IDS);
+        expect(new Set(startedDeadlines.map(({ identity }) => identity).values()).size).toBe(6);
+        expect(new Set(startedDeadlines.map(({ startedAt }) => startedAt).values()).size).toBe(1);
+        expect(startedDeadlines.filter(({ active }) => active).map(({ id }) => id)).toEqual([
+          blockedId,
+        ]);
+        expect(document.querySelector(`script[src*="tsjs-${blockedId}.min.js"]`)).not.toBeNull();
+        expect(harness.ownershipIdentities()).toEqual(ownershipBefore);
+
+        const elapsedSinceStart = Date.now() - (startedDeadlines[0]?.startedAt ?? Date.now());
+        await vi.advanceTimersByTimeAsync(9_999 - elapsedSinceStart);
+        expect(harness.deferredDeadlines().find(({ id }) => id === blockedId)?.active).toBe(true);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(harness.deferredDeadlines().find(({ id }) => id === blockedId)?.active).toBe(false);
+        expect(document.querySelector(`script[src*="tsjs-${blockedId}.min.js"]`)).toBeNull();
+        expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual([]);
+        expect(harness.ownershipIdentities()).toEqual(ownershipBefore);
+
+        await harness.assertReleased();
+        expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+          [...activeIds].reverse().map((id) => `dispose:${id}`)
+        );
+      } finally {
+        harness.composition.runtime.dispose();
+        await Promise.resolve();
+        harness.restoreInstrumentation();
+      }
+    }
+  );
+
+  it.each(DEFERRED_INTEGRATION_IDS)(
+    'contains an acquired %s failure without delaying or replacing deferred siblings',
+    async (failureId) => {
+      vi.useFakeTimers();
+      const harness = createMaximalHarness({ failAfterActivation: failureId });
+      try {
+        const installed = await harness.composition.runtime.install();
+        expect(installed.state).toBe('kernel');
+        const ownershipBefore = harness.ownershipIdentities();
+        expect(ownershipBefore.captureListeners).toHaveLength(1);
+
+        await harness.loadDeferred();
+
+        await vi.waitFor(() => {
+          expect(harness.events.filter((event) => event.startsWith('register:'))).toEqual(
+            harness.integrationIds.map((id) => `register:${id}`)
+          );
+          expect(harness.events.filter((event) => event.startsWith('prepare:'))).toEqual(
+            harness.integrationIds.map((id) => `prepare:${id}`)
+          );
+          expect(harness.events.filter((event) => event.startsWith('activate:'))).toEqual(
+            harness.integrationIds.map((id) => `activate:${id}`)
+          );
+          expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual([
+            `dispose:${failureId}`,
+          ]);
+        });
+
+        const startedDeadlines = harness.deferredDeadlines();
+        expect(startedDeadlines.map(({ id }) => id)).toEqual(DEFERRED_INTEGRATION_IDS);
+        expect(new Set(startedDeadlines.map(({ identity }) => identity).values()).size).toBe(6);
+        expect(new Set(startedDeadlines.map(({ startedAt }) => startedAt).values()).size).toBe(1);
+        expect(startedDeadlines.some(({ active }) => active)).toBe(false);
+        expect(harness.ownershipIdentities()).toEqual(ownershipBefore);
+
+        await harness.assertReleased();
+        const disposalEvents = harness.events.filter((event) => event.startsWith('dispose:'));
+        expect(disposalEvents).toHaveLength(harness.integrationIds.length);
+        for (const id of harness.integrationIds) {
+          expect(disposalEvents.filter((event) => event === `dispose:${id}`)).toHaveLength(1);
+        }
+      } finally {
+        harness.composition.runtime.dispose();
+        await Promise.resolve();
+        harness.restoreInstrumentation();
+      }
+    }
+  );
+
+  it.each([
+    {
+      name: 'a real activation fails after acquiring its composed effects',
+      failureId: 'permutive_context',
+      phase: 'activate' as const,
+    },
+    {
+      name: 'one real registration receives malformed frozen config',
+      failureId: 'sourcepoint_consent',
+      phase: 'prepare' as const,
+    },
+  ])('fails closed when $name', async ({ failureId, phase }) => {
+    vi.useFakeTimers();
+    const harness = createMaximalHarness(
+      phase === 'activate'
+        ? { failAfterActivation: failureId }
+        : {
+            configOverrides: Object.freeze({
+              [failureId]: Object.freeze({ rewriteSdk: 'yes' }),
+            }),
+          }
+    );
+    try {
+      const installed = await harness.composition.runtime.install();
+      const failureIndex = harness.takeoverIntegrationIds.indexOf(failureId);
+      const preparedIds =
+        phase === 'activate'
+          ? harness.takeoverIntegrationIds
+          : harness.takeoverIntegrationIds.slice(0, failureIndex + 1);
+      const activatedIds =
+        phase === 'activate' ? harness.takeoverIntegrationIds.slice(0, failureIndex + 1) : [];
+
+      expect(installed).toEqual({ state: 'fallback', reason: 'bundle_partial' });
+      expect(harness.composition.runtime.state).toBe('fallback');
+      expect(harness.target['_internal']).toMatchObject({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+      expect(harness.events.filter((event) => event.startsWith('register:'))).toEqual(
+        harness.takeoverIntegrationIds.map((id) => `register:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('prepare:'))).toEqual(
+        preparedIds.map((id) => `prepare:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('activate:'))).toEqual(
+        activatedIds.map((id) => `activate:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+        [...activatedIds].reverse().map((id) => `dispose:${id}`)
+      );
+
+      await harness.assertReleased();
+      expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+        [...activatedIds].reverse().map((id) => `dispose:${id}`)
+      );
+    } finally {
+      harness.restoreInstrumentation();
+    }
+  });
+
+  it.each([
+    { name: 'missing SDK globals reach their bounded readiness timeouts', kind: 'readiness' },
+    { name: 'hostile consent storage fails only its after-commit owner', kind: 'storage' },
+    {
+      name: 'matcher false positives and throwing publisher callbacks stay isolated',
+      kind: 'matcher',
+    },
+  ] as const)('isolates $name across all real registrations', async ({ kind }) => {
+    vi.useFakeTimers();
+    const callbackOrder: string[] = [];
+    const publisherBinding: { target?: Record<string, unknown> } = {};
+    let falsePositiveScript: HTMLScriptElement | undefined;
+    if (kind === 'readiness') {
+      vi.stubGlobal('identityLockr', undefined);
+      vi.stubGlobal('permutive', undefined);
+    }
+    if (kind === 'storage') {
+      vi.stubGlobal(
+        'localStorage',
+        new Proxy({} as Storage, {
+          get: () => {
+            throw new Error('publisher storage is unavailable');
+          },
+        })
+      );
+    }
+    if (kind === 'matcher') {
+      vi.stubGlobal('testlight', {
+        que: [
+          function (this: unknown): void {
+            callbackOrder.push(this === publisherBinding.target ? 'throw:bound' : 'throw:unbound');
+            throw new Error('publisher queue callback failed');
+          },
+          function (this: unknown): void {
+            callbackOrder.push(
+              this === publisherBinding.target ? 'survive:bound' : 'survive:unbound'
+            );
+          },
+        ],
+      });
+    }
+    const harness = createMaximalHarness();
+    publisherBinding.target = harness.target;
+    try {
+      const installed = await harness.composition.runtime.install();
+      const expectedRuntimeFailures =
+        kind === 'storage' ? [{ id: 'sourcepoint_consent', phase: 'after_commit' }] : [];
+      const activeIntegrationIds =
+        kind === 'storage'
+          ? harness.integrationIds.filter((id) => id !== 'sourcepoint_lifecycle')
+          : harness.integrationIds;
+
+      expect(installed).toEqual({
+        state: 'kernel',
+        runtimeFailures: expectedRuntimeFailures,
+        dispose: expect.any(Function),
+      });
+      expect(harness.composition.runtime.state).toBe('kernel');
+      await harness.loadDeferred();
+      expect(harness.events.filter((event) => event.startsWith('prepare:'))).toEqual(
+        activeIntegrationIds.map((id) => `prepare:${id}`)
+      );
+      expect(harness.events.filter((event) => event.startsWith('activate:'))).toEqual(
+        activeIntegrationIds.map((id) => `activate:${id}`)
+      );
+      expect(harness.resourceCounts()).toMatchObject({
+        captureListeners: 1,
+        listeners: expect.any(Number),
+        mutationObservers: expect.any(Number),
+        observers: 1,
+      });
+      expect(harness.resourceCounts().listeners).toBeGreaterThan(0);
+      expect(harness.resourceCounts().mutationObservers).toBeGreaterThan(0);
+
+      if (kind === 'readiness') {
+        await vi.runAllTimersAsync();
+        expect(harness.composition.runtime.state).toBe('kernel');
+        expect(vi.getTimerCount()).toBe(0);
+      }
+      if (kind === 'matcher') {
+        expect(callbackOrder).toEqual(['throw:bound', 'survive:bound']);
+        falsePositiveScript = document.createElement('script');
+        const originalUrl = 'https://publisher.example/assets/www.googletagmanager.com/gtm.js';
+        falsePositiveScript.src = originalUrl;
+        document.head.appendChild(falsePositiveScript);
+        expect(falsePositiveScript.src).toBe(originalUrl);
+      }
+
+      falsePositiveScript?.remove();
+      const disposedBeforeRuntimeRelease =
+        kind === 'storage' ? ['dispose:sourcepoint_consent'] : [];
+      expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+        disposedBeforeRuntimeRelease
+      );
+      await harness.assertReleased();
+      const reverseIds = [...activeIntegrationIds].reverse();
+      const expectedDisposals =
+        kind === 'storage'
+          ? [
+              'dispose:sourcepoint_consent',
+              ...reverseIds
+                .filter((id) => id !== 'sourcepoint_consent')
+                .map((id) => `dispose:${id}`),
+            ]
+          : reverseIds.map((id) => `dispose:${id}`);
+      expect(harness.events.filter((event) => event.startsWith('dispose:'))).toEqual(
+        expectedDisposals
+      );
+    } finally {
+      falsePositiveScript?.remove();
+      harness.restoreInstrumentation();
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs b/crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs
new file mode 100644
index 000000000..666d5ec4d
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs
@@ -0,0 +1,462 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+import vm from 'node:vm';
+
+const corpus = JSON.parse(
+  await readFile(new URL('../fixtures/aps-renderer-v1-corpus.json', import.meta.url), 'utf8')
+);
+const goldenEnvelope = JSON.parse(
+  await readFile(new URL('../fixtures/aps-renderer-v1.json', import.meta.url), 'utf8')
+);
+const validatorUrl = new URL(
+  '../../../../trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js',
+  import.meta.url
+);
+const validatorSource = await readFile(validatorUrl, 'utf8');
+const bootstrapDocument = await readFile(
+  new URL(
+    '../../../../trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html',
+    import.meta.url
+  ),
+  'utf8'
+);
+
+function setPath(root, path, value) {
+  let parent = root;
+  for (const segment of path.slice(0, -1)) parent = parent[segment];
+  parent[path.at(-1)] = value;
+}
+
+function deletePath(root, path) {
+  let parent = root;
+  for (const segment of path.slice(0, -1)) parent = parent[segment];
+  delete parent[path.at(-1)];
+}
+
+function encodeBytes(value) {
+  return Buffer.from(value).toString('base64');
+}
+
+function materialize(vector) {
+  const descriptor = structuredClone(corpus.baseDescriptor);
+  const envelope = structuredClone(goldenEnvelope);
+  const operation = vector.operation;
+  let encodedEnvelope;
+
+  switch (operation.kind) {
+    case 'none':
+      break;
+    case 'descriptor-delete':
+      delete descriptor[operation.field];
+      break;
+    case 'descriptor-set':
+      descriptor[operation.field] = operation.value;
+      break;
+    case 'descriptor-repeat':
+      descriptor[operation.field] =
+        operation.unit.repeat(operation.count) + (operation.suffix ?? '');
+      break;
+    case 'bid-id-repeat': {
+      const value = operation.unit.repeat(operation.count) + (operation.suffix ?? '');
+      descriptor.bidId = value;
+      setPath(envelope, ['seatbid', 0, 'bid', 0, 'id'], value);
+      break;
+    }
+    case 'dimension': {
+      descriptor[operation.field] = operation.value;
+      setPath(
+        envelope,
+        ['seatbid', 0, 'bid', 0, operation.field === 'width' ? 'w' : 'h'],
+        operation.value
+      );
+      break;
+    }
+    case 'dimensions':
+      descriptor.width = operation.width;
+      descriptor.height = operation.height;
+      setPath(envelope, ['seatbid', 0, 'bid', 0, 'w'], operation.width);
+      setPath(envelope, ['seatbid', 0, 'bid', 0, 'h'], operation.height);
+      break;
+    case 'creative-url':
+      descriptor.creativeUrl = operation.value;
+      setPath(envelope, ['seatbid', 0, 'bid', 0, 'ext', 'creativeurl'], operation.value);
+      break;
+    case 'creative-url-bytes': {
+      const prefix = 'https://creative.example/';
+      const value = prefix + 'a'.repeat(operation.bytes - prefix.length);
+      descriptor.creativeUrl = value;
+      setPath(envelope, ['seatbid', 0, 'bid', 0, 'ext', 'creativeurl'], value);
+      break;
+    }
+    case 'aax-literal':
+      encodedEnvelope = operation.value;
+      break;
+    case 'aax-bytes':
+      encodedEnvelope = encodeBytes(Uint8Array.from(operation.values));
+      break;
+    case 'aax-raw-json':
+      encodedEnvelope = encodeBytes(operation.value);
+      break;
+    case 'aax-decoded-bytes': {
+      const serialized = JSON.stringify(envelope);
+      assert.ok(serialized.length <= operation.bytes, vector.id);
+      encodedEnvelope = encodeBytes(serialized + ' '.repeat(operation.bytes - serialized.length));
+      break;
+    }
+    case 'aax-raw-price': {
+      const serialized = JSON.stringify(envelope);
+      const raw = serialized.replace('"price":1.23', `"price":${operation.value}`);
+      assert.notEqual(raw, serialized, vector.id);
+      encodedEnvelope = encodeBytes(raw);
+      break;
+    }
+    case 'envelope-set':
+      setPath(envelope, operation.path, operation.value);
+      break;
+    case 'envelope-delete':
+      deletePath(envelope, operation.path);
+      break;
+    case 'duplicate-seat':
+      envelope.seatbid.push(structuredClone(envelope.seatbid[0]));
+      break;
+    case 'duplicate-bid':
+      envelope.seatbid[0].bid.push(structuredClone(envelope.seatbid[0].bid[0]));
+      break;
+    default:
+      throw new Error(`unknown APS renderer corpus operation: ${operation.kind}`);
+  }
+
+  descriptor.aaxResponse = encodedEnvelope ?? encodeBytes(JSON.stringify(envelope));
+  return descriptor;
+}
+
+test('the exact generated ES5 validator matches every shared corpus vector', () => {
+  const context = vm.createContext({
+    URL,
+    TextEncoder,
+    TextDecoder,
+    atob,
+    btoa,
+    inputJson: '',
+    publisherOrigin: corpus.publisherOrigin,
+  });
+  vm.runInContext(validatorSource, context, {
+    filename: 'aps_renderer_validator_v1.js',
+  });
+
+  for (const vector of corpus.vectors) {
+    context.inputJson = JSON.stringify(materialize(vector));
+    const actual = vm.runInContext(
+      'classifyApsRendererV1(JSON.parse(inputJson), publisherOrigin)',
+      context
+    );
+    assert.equal(actual, vector.expected, vector.id);
+  }
+});
+
+test('the embedded validator remains ES5 syntax', () => {
+  assert.doesNotMatch(validatorSource, /=>|\b(?:const|let|class)\b|\?\.|\?\?/);
+});
+
+function bootstrapScript() {
+  const match =
+    /^<!doctype html>\n<meta charset="utf-8">\n<script>\n([\s\S]+)\n<\/script>\n$/u.exec(
+      bootstrapDocument
+    );
+  assert.ok(match, 'bootstrap should have one exact inert document shell');
+  return match[1];
+}
+
+function executeBootstrap(
+  hash = '#b1_AAECAwQFBgcICQoLDA0ODw',
+  referrer = 'https://publisher.example/article'
+) {
+  const parent = {
+    messages: [],
+    postMessage(message, origin) {
+      this.messages.push({ message, origin });
+    },
+  };
+  const replacements = [];
+  let listener;
+  const context = vm.createContext({
+    URL,
+    TextEncoder,
+    document: { referrer },
+    history: { replaceState() {} },
+    location: {
+      hash,
+      pathname: '/integrations/aps/renderer/v2',
+      search: '',
+      replace(value) {
+        replacements.push(value);
+      },
+    },
+    parent,
+    addEventListener(type, callback) {
+      assert.equal(type, 'message');
+      listener = callback;
+    },
+    removeEventListener(type, callback) {
+      assert.equal(type, 'message');
+      if (listener === callback) listener = undefined;
+    },
+  });
+  vm.runInContext(bootstrapScript(), context, {
+    filename: 'aps_renderer_bootstrap_v2.html',
+  });
+  return {
+    parent,
+    replacements,
+    dispatch(event) {
+      listener?.(event);
+    },
+  };
+}
+
+test('the generated renderer response is an ES5 descriptor-isolated materializer', () => {
+  const source = bootstrapScript();
+  assert.doesNotMatch(source, /=>|\b(?:const|let|class)\b|\?\.|\?\?/);
+  assert.doesNotMatch(
+    source,
+    /example-account-id|fictional-selected-bid-id|fictional-creative-id/u
+  );
+  assert.doesNotMatch(source, /fetch|XMLHttpRequest/u);
+  assert.match(source, /TS APS Bootstrap Ready/);
+  assert.match(source, /TS APS Bootstrap Configure/);
+  assert.match(source, /classifyApsRendererV1/u);
+  assert.match(source, /data:text\/html;charset=utf-8,/);
+});
+
+test('the generated bootstrap materializes the opaque documents after first-action configuration', () => {
+  const bootstrapNonce = 'b1_AAECAwQFBgcICQoLDA0ODw';
+  const rendererNonce = 'n1_AAECAwQFBgcICQoLDA0ODw';
+  const harness = executeBootstrap(`#${bootstrapNonce}`);
+  const configuration = JSON.stringify({
+    message: 'TS APS Bootstrap Configure',
+    version: 2,
+    bootstrapNonce,
+    rendererNonce,
+    creativeOrigin: 'https://creative.example',
+    tagType: 'iframe',
+  });
+
+  harness.dispatch({
+    source: harness.parent,
+    origin: 'https://publisher.example',
+    data: configuration,
+    ports: [],
+  });
+
+  assert.equal(harness.replacements.length, 1);
+  const containerUrl = harness.replacements[0];
+  assert.match(containerUrl, /^data:text\/html;charset=utf-8,/u);
+  assert.match(containerUrl, new RegExp(`#${bootstrapNonce}$`, 'u'));
+  const outerDocument = decodeURIComponent(
+    containerUrl.slice('data:text/html;charset=utf-8,'.length, -`#${bootstrapNonce}`.length)
+  );
+  assert.match(outerDocument, new RegExp(rendererNonce, 'u'));
+  assert.match(outerDocument, /TS APS Container Ready/u);
+  assert.doesNotMatch(
+    outerDocument,
+    /example-account-id|fictional-selected-bid-id|fictional-creative-id/u
+  );
+});
+
+test('the generated inner document accepts an exact loopback publisher origin', () => {
+  const bootstrapNonce = 'b1_AAECAwQFBgcICQoLDA0ODw';
+  const rendererNonce = 'n1_AAECAwQFBgcICQoLDA0ODw';
+  const publisherOrigin = 'http://127.0.0.1:8888';
+  const harness = executeBootstrap(`#${bootstrapNonce}`);
+  harness.dispatch({
+    source: harness.parent,
+    origin: publisherOrigin,
+    data: JSON.stringify({
+      message: 'TS APS Bootstrap Configure',
+      version: 2,
+      bootstrapNonce,
+      rendererNonce,
+      creativeOrigin: 'https://creative.example',
+      tagType: 'iframe',
+    }),
+    ports: [],
+  });
+
+  const outerUrl = harness.replacements[0];
+  assert.ok(outerUrl, 'bootstrap should materialize one outer data document');
+  const outerDocument = decodeURIComponent(
+    outerUrl.slice('data:text/html;charset=utf-8,'.length, -`#${bootstrapNonce}`.length)
+  );
+  const innerUrlSource = /var INNER_URL=("(?:[^"\\]|\\.)*");/u.exec(outerDocument)?.[1];
+  assert.ok(innerUrlSource, 'outer document should contain one encoded inner URL');
+  const innerUrl = JSON.parse(innerUrlSource);
+  const innerDocument = decodeURIComponent(
+    innerUrl.slice('data:text/html;charset=utf-8,'.length, -`#${rendererNonce}`.length)
+  );
+  const innerScript = /<script>\n([\s\S]+)\n<\/script>\n$/u.exec(innerDocument)?.[1];
+  assert.ok(innerScript, 'inner document should contain one renderer script');
+
+  let receiveBind;
+  const documentMessages = [];
+  const documentPort = {
+    close() {},
+    onmessage: undefined,
+    onmessageerror: undefined,
+    postMessage(message) {
+      documentMessages.push(message);
+    },
+    start() {},
+  };
+  class FakeCustomEvent {
+    constructor(type, options) {
+      this.type = type;
+      this.detail = options.detail;
+    }
+  }
+  const innerParent = { postMessage() {} };
+  const innerWindow = {};
+  const context = vm.createContext({
+    URL,
+    TextEncoder,
+    TextDecoder,
+    atob,
+    btoa,
+    CustomEvent: FakeCustomEvent,
+    document: {
+      createElement() {
+        return {};
+      },
+      head: { appendChild() {} },
+    },
+    documentPort,
+    envelopeJson: JSON.stringify({
+      version: 1,
+      nonce: rendererNonce,
+      publisherOrigin,
+      renderer: {
+        ...corpus.baseDescriptor,
+        aaxResponse: encodeBytes(JSON.stringify(goldenEnvelope)),
+      },
+    }),
+    history: { replaceState() {} },
+    location: { hash: `#${rendererNonce}`, pathname: '', search: '' },
+    parent: innerParent,
+    window: innerWindow,
+    addEventListener(_type, listener) {
+      receiveBind = listener;
+    },
+    removeEventListener() {},
+  });
+  vm.runInContext(innerScript, context, { filename: 'aps_renderer_inner_v1.html' });
+  receiveBind?.({
+    source: innerParent,
+    origin: 'null',
+    ports: [documentPort],
+    data: JSON.stringify({ message: 'TS APS Inner Bind', version: 1, rendererNonce }),
+  });
+  vm.runInContext('documentPort.onmessage({data:JSON.parse(envelopeJson)})', context);
+
+  assert.equal(
+    JSON.stringify(documentMessages[0]),
+    JSON.stringify({
+      message: 'TS APS Document Accepted',
+      version: 1,
+      nonce: rendererNonce,
+    })
+  );
+});
+
+test('the generated bootstrap authenticates the parent event without referrer dependence', () => {
+  const bootstrapNonce = 'b1_AAECAwQFBgcICQoLDA0ODw';
+  const harness = executeBootstrap(`#${bootstrapNonce}`, '');
+  assert.deepEqual(harness.parent.messages, [
+    {
+      message: JSON.stringify({
+        message: 'TS APS Bootstrap Ready',
+        version: 1,
+        bootstrapNonce,
+      }),
+      origin: '*',
+    },
+  ]);
+  harness.dispatch({
+    source: harness.parent,
+    origin: 'https://publisher.example',
+    data: JSON.stringify({
+      message: 'TS APS Bootstrap Configure',
+      version: 2,
+      bootstrapNonce,
+      rendererNonce: 'n1_AAECAwQFBgcICQoLDA0ODw',
+      creativeOrigin: 'https://creative.example',
+      tagType: 'iframe',
+    }),
+    ports: [],
+  });
+  assert.equal(harness.replacements.length, 1);
+});
+
+test('the generated bootstrap rejects malformed, misbound, and oversized configuration', () => {
+  const nonce = 'b1_AAECAwQFBgcICQoLDA0ODw';
+  const valid = {
+    message: 'TS APS Bootstrap Configure',
+    version: 2,
+    bootstrapNonce: nonce,
+    rendererNonce: 'n1_AAECAwQFBgcICQoLDA0ODw',
+    creativeOrigin: 'https://creative.example',
+    tagType: 'iframe',
+  };
+  const cases = [
+    { source: {}, origin: 'https://publisher.example', data: JSON.stringify(valid), ports: [] },
+    { source: null, origin: 'null', data: JSON.stringify(valid), ports: [] },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: JSON.stringify({ ...valid, bootstrapNonce: `b1_${'z'.repeat(22)}` }),
+      ports: [],
+    },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: JSON.stringify({ ...valid, extra: true }),
+      ports: [],
+    },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: JSON.stringify(valid).replace('"version":2', '"version":2,"version":2'),
+      ports: [],
+    },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: JSON.stringify(valid),
+      ports: [{}],
+    },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: JSON.stringify({
+        ...valid,
+        creativeOrigin: 'https://publisher.example',
+      }),
+      ports: [],
+    },
+    {
+      source: null,
+      origin: 'https://publisher.example',
+      data: 'x'.repeat(16_385),
+      ports: [],
+    },
+  ];
+
+  for (const candidate of cases) {
+    const harness = executeBootstrap(`#${nonce}`);
+    harness.dispatch({
+      ...candidate,
+      source: candidate.source === null ? harness.parent : candidate.source,
+    });
+    assert.deepEqual(harness.replacements, []);
+  }
+  assert.deepEqual(executeBootstrap('#n1_AAECAwQFBgcICQoLDA0ODw').parent.messages, []);
+});
diff --git a/crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs b/crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs
new file mode 100644
index 000000000..5dae3a33e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs
@@ -0,0 +1,215 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { JSDOM } from 'jsdom';
+import { createServer } from 'vite';
+
+const defaultLibRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const libRoot = path.resolve(process.env.TSJS_CONCEPT_PROOF_LIB_ROOT ?? defaultLibRoot);
+
+const GLOBAL_NAMES = [
+  'CustomEvent',
+  'Document',
+  'Element',
+  'Event',
+  'HTMLIFrameElement',
+  'HTMLElement',
+  'MessageEvent',
+  'MutationObserver',
+  'Node',
+  'URL',
+  'Window',
+  'document',
+  'getComputedStyle',
+  'history',
+  'location',
+  'navigator',
+  'window',
+];
+
+async function withBrowserModule(modulePath, run) {
+  const dom = new JSDOM('<!doctype html><html><body></body></html>', {
+    pretendToBeVisual: true,
+    url: 'https://publisher.example/article',
+  });
+  const previous = new Map();
+  for (const name of GLOBAL_NAMES) {
+    previous.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+    const value =
+      name === 'getComputedStyle' ? dom.window.getComputedStyle.bind(dom.window) : dom.window[name];
+    Object.defineProperty(globalThis, name, { configurable: true, writable: true, value });
+  }
+  previous.set('crypto', Object.getOwnPropertyDescriptor(globalThis, 'crypto'));
+  Object.defineProperty(globalThis, 'crypto', {
+    configurable: true,
+    value: dom.window.crypto,
+  });
+
+  const server = await createServer({
+    appType: 'custom',
+    configFile: false,
+    logLevel: 'silent',
+    root: libRoot,
+    server: { middlewareMode: true },
+  });
+  try {
+    const loaded = await server.ssrLoadModule(modulePath);
+    return await run({ dom, loaded });
+  } finally {
+    await server.close();
+    dom.window.close();
+    for (const [name, descriptor] of previous) {
+      if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+      else Reflect.deleteProperty(globalThis, name);
+    }
+  }
+}
+
+test('RCJ-TRACE-01 exposes the bounded public render-trace API', async () => {
+  await withBrowserModule('/src/core/index.ts', ({ dom }) => {
+    const renderTrace = dom.window.tsjs?.diagnostics?.renderTrace;
+    assert.deepEqual(Reflect.ownKeys(renderTrace ?? {}).sort(), [
+      'current',
+      'history',
+      'subscribe',
+    ]);
+    assert.equal(Object.isFrozen(renderTrace), true);
+  });
+});
+
+test('RCJ-GPT-04 resizes only the authenticated collapsed shell after posting', async () => {
+  await withBrowserModule('/src/integrations/gpt/index.ts', ({ dom }) => {
+    const wrapper = dom.window.document.createElement('div');
+    wrapper.id = 'slot-a';
+    wrapper.style.width = '1px';
+    wrapper.style.height = '1px';
+    const frame = dom.window.document.createElement('iframe');
+    frame.width = '1';
+    frame.height = '1';
+    frame.style.width = '1px';
+    frame.style.height = '1px';
+    wrapper.append(frame);
+    dom.window.document.body.append(wrapper);
+    dom.window.tsjs = {
+      adSlots: [{ id: 'slot-a', div_id: 'slot-a', formats: [[300, 250]] }],
+      bids: { 'slot-a': { adm: '<div>creative</div>', h: 250, hb_adid: 'ad-a', w: 300 } },
+    };
+
+    const responses = [];
+    const event = new dom.window.MessageEvent('message', {
+      data: { adId: 'ad-a', message: 'Prebid Request' },
+      ports: [{ postMessage: (response) => responses.push(JSON.parse(response)) }],
+      source: frame.contentWindow,
+    });
+    dom.window.dispatchEvent(event);
+
+    assert.equal(responses.length, 1, 'the authenticated TS response should be posted');
+    assert.equal(frame.style.width, '300px');
+    assert.equal(frame.style.height, '250px');
+    assert.equal(wrapper.style.width, '300px');
+    assert.equal(wrapper.style.height, '250px');
+  });
+});
+
+function apsDescriptor(window) {
+  const bid = {
+    ext: { creativeurl: 'https://creative.example/render', tagtype: 'iframe' },
+    h: 250,
+    id: 'bid-a',
+    price: 1,
+    w: 300,
+  };
+  return {
+    aaxResponse: window.btoa(JSON.stringify({ seatbid: [{ bid: [bid] }] })),
+    accountId: 'account-a',
+    bidId: bid.id,
+    creativeId: 'creative-a',
+    creativeUrl: bid.ext.creativeurl,
+    height: bid.h,
+    tagType: bid.ext.tagtype,
+    type: 'aps',
+    version: 1,
+    width: bid.w,
+  };
+}
+
+test('RCJ-APS-03 waits for an APS callback instead of script load', async () => {
+  const sourcePath = path.resolve(libRoot, '../../trusted-server-core/src/integrations/aps.rs');
+  const rust = await readFile(sourcePath, 'utf8');
+  const documentMatch = /const APS_RENDERER_DOCUMENT: &str = r#"([\s\S]*?)"#;/.exec(rust);
+  assert.ok(documentMatch, 'current main should expose the renderer document under test');
+  const scriptSource = JSDOM.fragment(documentMatch[1]).querySelector('script')?.textContent;
+  assert.ok(scriptSource, 'renderer document should contain executable code');
+
+  const nonce = 'a'.repeat(22);
+  const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>', {
+    runScripts: 'outside-only',
+    url: `https://publisher.example/integrations/aps/renderer#tsaps=${nonce}`,
+  });
+  const posts = [];
+  dom.window.postMessage = (message) => posts.push(message);
+  dom.window.eval(scriptSource);
+  dom.window.dispatchEvent(
+    new dom.window.MessageEvent('message', {
+      data: { nonce, renderer: apsDescriptor(dom.window) },
+      source: dom.window,
+    })
+  );
+  const runner = dom.window.document.querySelector(
+    'script[src="https://client.aps.amazon-adsystem.com/prebid-creative.js"]'
+  );
+  assert.ok(runner, 'valid input should reach APS runner insertion');
+  runner.onload();
+
+  assert.equal(
+    posts.some((message) => message?.message === 'trusted-server/aps/renderer-ready'),
+    false,
+    'runner load is progress; only the APS success callback may complete rendering'
+  );
+  dom.window.close();
+});
+
+test('RCJ-APS-04 applies winning dimensions without document clipping', async () => {
+  await withBrowserModule('/src/integrations/aps/render.ts', async ({ loaded }) => {
+    const owner = new JSDOM('<!doctype html><html><body></body></html>', {
+      runScripts: 'outside-only',
+      url: 'https://publisher.example/article',
+    });
+    owner.window.eval(loaded.APS_UNIVERSAL_CREATIVE_RENDERER);
+    owner.window.setTimeout = () => 1;
+    owner.window.clearTimeout = () => undefined;
+    const pending = owner.window.render(
+      {
+        apsRenderer: { height: 250, width: 300 },
+        rendererUrl: 'https://publisher.example/integrations/aps/renderer',
+      },
+      undefined,
+      owner.window
+    );
+    const frame = owner.window.document.querySelector('iframe');
+    assert.ok(frame, 'the dynamic owner should insert the renderer frame');
+    assert.equal(owner.window.document.documentElement.style.margin, '0px');
+    assert.equal(owner.window.document.documentElement.style.padding, '0px');
+    assert.equal(owner.window.document.documentElement.style.overflow, 'hidden');
+    assert.equal(owner.window.document.body.style.margin, '0px');
+    assert.equal(owner.window.document.body.style.padding, '0px');
+    assert.equal(owner.window.document.body.style.overflow, 'hidden');
+    assert.equal(frame.style.width, '300px');
+    assert.equal(frame.style.height, '250px');
+    assert.equal(frame.style.display, 'block');
+    assert.equal(frame.scrolling, 'no');
+    frame.onerror();
+    await assert.rejects(pending);
+    owner.window.close();
+  });
+});
+
+test('RCJ-QUAL-01 exposes full-package typecheck and lint gates', async () => {
+  const packageJson = JSON.parse(await readFile(path.join(libRoot, 'package.json'), 'utf8'));
+  assert.equal(typeof packageJson.scripts?.typecheck, 'string');
+  assert.match(packageJson.scripts.typecheck, /tsc/);
+  assert.match(packageJson.scripts.lint, /eslint\s+\./);
+});
diff --git a/crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs b/crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs
new file mode 100644
index 000000000..d2c0085f1
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs
@@ -0,0 +1,594 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  assertRetiredConceptAudit,
+  auditRetiredPlanCommands,
+  auditRetiredConceptAudit,
+  countExecutableShellFences,
+} from '../../scripts/check-retired-concept-audit.mjs';
+
+const { test } = process.env.VITEST ? await import('vitest') : await import('node:test');
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(testDirectory, '../../../../..');
+const specPath = path.join(
+  repositoryRoot,
+  'docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md'
+);
+const auditFixturePath = path.join(
+  repositoryRoot,
+  'crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json'
+);
+const planPath = path.join(
+  repositoryRoot,
+  'docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md'
+);
+const historicalPerformanceFixturePath = path.join(
+  repositoryRoot,
+  'crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json'
+);
+const mainAuditSha = 'f6a2fb85ce623bf8a574e3941e1ee349acc3412d';
+const rcBaselineSha = '07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf';
+const parsedAuditFixture = JSON.parse(readFileSync(auditFixturePath, 'utf8'));
+const auditedClassifications = Array.isArray(parsedAuditFixture)
+  ? parsedAuditFixture
+  : parsedAuditFixture.historicalMain.rows;
+const validClassifications = auditedClassifications.map((row) => ({ ...row }));
+const pendingClassifications = validClassifications.map((row, index) =>
+  index === 0 ? { ...row, classification: 'proof-pending', result: 'proof-pending' } : row
+);
+const auditedRcClassifications = Array.isArray(parsedAuditFixture)
+  ? auditedClassifications.map(({ mainSha: _mainSha, ...row }) => ({
+      ...row,
+      baselineSha: rcBaselineSha,
+      classification: row.classification === 'main-owned' ? 'baseline-owned' : row.classification,
+    }))
+  : parsedAuditFixture.rcBaseline.rows;
+const validVersionedFixture = {
+  version: 2,
+  historicalMain: {
+    mainSha: mainAuditSha,
+    rows: validClassifications,
+  },
+  rcBaseline: {
+    baselineSha: rcBaselineSha,
+    rows: auditedRcClassifications,
+  },
+};
+const manifestFence = /```json retired-rcjuly-tsjs-concept-manifest-v1\n([\s\S]*?)\n```/;
+const specSource = readFileSync(specPath, 'utf8');
+const manifestSource = manifestFence.exec(specSource)?.[1];
+assert.equal(typeof manifestSource, 'string');
+const validManifest = JSON.parse(manifestSource);
+const ledgerIds = [
+  ...new Set([...specSource.matchAll(/\| `(RCJ-[A-Z]+-[0-9]+)`/g)].map((match) => match[1])),
+];
+
+function inventoryDigest(inventory) {
+  return createHash('sha256')
+    .update(inventory.map((entry) => `${entry}\n`).join(''))
+    .digest('hex');
+}
+
+function sourceFor(manifest, ids = ledgerIds) {
+  const ledger = ids.map((id) => `| \`${id}\` | retained | preserve |`).join('\n');
+  return `${ledger}\n\n\`\`\`json retired-rcjuly-tsjs-concept-manifest-v1\n${JSON.stringify(manifest, null, 2)}\n\`\`\`\n`;
+}
+
+function auditSource(source) {
+  const directory = mkdtempSync(path.join(tmpdir(), 'retired-concept-audit-'));
+  const temporarySpecPath = path.join(directory, 'spec.md');
+  writeFileSync(temporarySpecPath, source);
+  try {
+    return auditRetiredConceptAudit({ repositoryRoot, specPath: temporarySpecPath });
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+function assertSourceRejected(source, expected) {
+  assert.throws(() => assertRetiredConceptAudit(auditSource(source)), expected);
+}
+
+function assertFixtureRejected(fixture, expected, options = {}) {
+  const directory = mkdtempSync(path.join(tmpdir(), 'current-main-concept-audit-'));
+  const temporaryFixturePath = path.join(directory, 'audit.json');
+  writeFileSync(temporaryFixturePath, JSON.stringify(fixture));
+  try {
+    assert.throws(
+      () =>
+        assertRetiredConceptAudit(
+          auditRetiredConceptAudit({
+            repositoryRoot,
+            specPath,
+            auditFixturePath: temporaryFixturePath,
+            mainAuditSha,
+            rcBaselineSha,
+            ...options,
+          })
+        ),
+      expected
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+function assertHistoricalRowsRejected(rows, expected) {
+  assertFixtureRejected(
+    {
+      ...validVersionedFixture,
+      historicalMain: { ...validVersionedFixture.historicalMain, rows },
+    },
+    expected
+  );
+}
+
+function assertRcRowsRejected(rows, expected) {
+  assertFixtureRejected(
+    {
+      ...validVersionedFixture,
+      rcBaseline: { ...validVersionedFixture.rcBaseline, rows },
+    },
+    expected
+  );
+}
+
+test('the in-spec retired concept inventory is complete without a historical Git object', () => {
+  const result = auditRetiredConceptAudit({ repositoryRoot, specPath });
+
+  assert.equal(result.authority, 'concept-audit-only');
+  assert.equal(result.retiredSnapshot, '905984e62a0858c53d9f0ff6dd3a1bf190cf311d');
+  assert.equal(
+    result.inventorySha256,
+    'b1e28c8b30f0b8d95e38c0f8f57394df4ad43f760ae7abf5631e2054228aef08'
+  );
+  assert.equal(result.fileCount, 144);
+  assert.equal(result.mappingCount, 38);
+  assert.equal(result.manifestIdCount, 23);
+  assert.equal(result.ledgerIdCount, 23);
+  assert.deepEqual(result.unmappedFiles, []);
+  assert.deepEqual(result.qualityOnlySourceFiles, []);
+  assert.deepEqual(result.deadMappings, []);
+  assert.deepEqual(result.manifestOnlyIds, []);
+  assert.deepEqual(result.ledgerOnlyIds, []);
+});
+
+test('the retired concept manifest has one exact authoritative fence', () => {
+  assertSourceRejected(`${sourceFor(validManifest)}\n${sourceFor(validManifest)}`, /exactly one/);
+  assertSourceRejected(
+    sourceFor({ ...validManifest, authority: 'behavior-authority' }),
+    /concept-audit-only/
+  );
+  assertSourceRejected(
+    sourceFor({ ...validManifest, retiredSnapshot: '0'.repeat(40) }),
+    /recorded retired snapshot/
+  );
+});
+
+test('the embedded inventory is exactly counted, sorted, unique, and digested', () => {
+  assertSourceRejected(
+    sourceFor({ ...validManifest, inventoryCount: validManifest.inventoryCount - 1 }),
+    /inventoryCount/
+  );
+  assertSourceRejected(
+    sourceFor({ ...validManifest, inventory: [...validManifest.inventory].reverse() }),
+    /sorted/
+  );
+
+  const duplicateInventory = [...validManifest.inventory];
+  duplicateInventory[1] = duplicateInventory[0];
+  assertSourceRejected(
+    sourceFor({
+      ...validManifest,
+      inventory: duplicateInventory,
+      inventoryCount: duplicateInventory.length,
+      inventorySha256: inventoryDigest(duplicateInventory),
+    }),
+    /unique/
+  );
+  assertSourceRejected(sourceFor({ ...validManifest, inventorySha256: '0'.repeat(64) }), /SHA-256/);
+
+  const substitutedInventory = ['!retired-concept-audit-path', ...validManifest.inventory.slice(1)];
+  assertSourceRejected(
+    sourceFor({
+      ...validManifest,
+      inventory: substitutedInventory,
+      inventorySha256: inventoryDigest(substitutedInventory),
+    }),
+    /recorded inventory SHA-256/
+  );
+});
+
+test('every inventory path has a live behavioral mapping', () => {
+  assertSourceRejected(sourceFor({ ...validManifest, mappings: [] }), /unmappedFiles/);
+
+  const deadMappings = [
+    ...validManifest.mappings,
+    { exact: ['crates/trusted-server-js/lib/src/not-present.ts'], ids: ['RCJ-CORE-01'] },
+  ];
+  assertSourceRejected(sourceFor({ ...validManifest, mappings: deadMappings }), /deadMappings/);
+
+  const qualityOnlyMappings = validManifest.mappings.map((mapping) =>
+    mapping.prefix === 'crates/trusted-server-js/lib/src/core/'
+      ? { ...mapping, ids: ['RCJ-QUAL-01'] }
+      : mapping
+  );
+  assertSourceRejected(
+    sourceFor({ ...validManifest, mappings: qualityOnlyMappings }),
+    /qualityOnlySourceFiles/
+  );
+});
+
+test('the manifest and retained-concept ledger expose the same 23 IDs', () => {
+  assertSourceRejected(sourceFor(validManifest, ledgerIds.slice(1)), /manifestOnlyIds/);
+});
+
+test('classification rows reject missing, duplicate, pending, mismatched, or historical proof', () => {
+  assertHistoricalRowsRejected(
+    [...validClassifications, { ...validClassifications[0], id: null }],
+    /exactly 23 classification rows/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) => (index === 0 ? { ...row, id: null } : row)),
+    /valid RCJ id/
+  );
+  assertHistoricalRowsRejected(validClassifications.slice(1), /missingClassificationIds/);
+  assertHistoricalRowsRejected(
+    [validClassifications[0], ...validClassifications],
+    /duplicateClassificationIds/
+  );
+  assertHistoricalRowsRejected(pendingClassifications, /proof-pending/);
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) =>
+      index === 0 ? { ...row, mainSha: '0'.repeat(40) } : row
+    ),
+    /mainSha/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) =>
+      index === 0 ? { ...row, ownerPaths: [], testPath: '', command: '' } : row
+    ),
+    /ownerPaths/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) => (index === 0 ? { ...row, result: 'fail' } : row)),
+    /main-owned.*pass/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) =>
+      index === 0 ? { ...row, classification: 'implementation-gap' } : row
+    ),
+    /implementation-gap.*fail/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) =>
+      index === 0 ? { ...row, command: 'git show rc/july:historical.ts' } : row
+    ),
+    /historical source/
+  );
+  assert.throws(
+    () =>
+      auditRetiredConceptAudit({
+        repositoryRoot,
+        specPath,
+        auditFixturePath,
+        mainAuditSha: '0'.repeat(40),
+      }),
+    /recorded current-main SHA/
+  );
+});
+
+test('classification rows pin the authoritative current-main pass and gap results', () => {
+  assertHistoricalRowsRejected(
+    validClassifications.map((row) => ({
+      ...row,
+      classification: 'main-owned',
+      result: 'pass',
+    })),
+    /authoritative classification/
+  );
+
+  assertHistoricalRowsRejected(
+    validClassifications.map((row) => {
+      if (row.id === 'RCJ-CORE-01') {
+        return { ...row, classification: 'implementation-gap', result: 'fail' };
+      }
+      if (row.id === 'RCJ-TRACE-01') {
+        return { ...row, classification: 'main-owned', result: 'pass' };
+      }
+      return row;
+    }),
+    /authoritative classification/
+  );
+});
+
+test('every retained concept has a final current-main classification and reproducible proof', () => {
+  const result = auditRetiredConceptAudit({
+    specPath,
+    auditFixturePath,
+    mainAuditSha,
+  });
+  assertRetiredConceptAudit(result);
+
+  assert.equal(result.historicalMain.classifications.length, 23);
+  assert.deepEqual(result.historicalMain.classificationCounts, {
+    implementationGap: 5,
+    mainOwned: 18,
+  });
+  assert.deepEqual(
+    result.historicalMain.classifications.map(({ id }) => id).sort(),
+    [...result.ledgerIds].sort()
+  );
+  assert.ok(
+    result.historicalMain.classifications.every(({ classification }) =>
+      ['main-owned', 'implementation-gap'].includes(classification)
+    )
+  );
+});
+
+test('the audit fixture exposes immutable historical-main and rc-baseline evidence layers', () => {
+  const result = auditRetiredConceptAudit({
+    specPath,
+    auditFixturePath,
+    mainAuditSha,
+    rcBaselineSha,
+  });
+  assertRetiredConceptAudit(result);
+
+  assert.equal(result.fixtureVersion, 2);
+  assert.equal(result.historicalMain.mainSha, mainAuditSha);
+  assert.equal(result.historicalMain.classifications.length, 23);
+  assert.equal(result.rcBaseline.baselineSha, rcBaselineSha);
+  assert.equal(result.rcBaseline.classifications.length, 23);
+  assert.ok(
+    result.rcBaseline.classifications.every(({ classification }) =>
+      ['baseline-owned', 'implementation-gap'].includes(classification)
+    )
+  );
+});
+
+test('the versioned fixture rejects legacy roots, extra structure, and historical mutation', () => {
+  assertFixtureRejected(validClassifications, /exact version 2 object/);
+  assertFixtureRejected({ ...validVersionedFixture, version: 1 }, /exact version 2 object/);
+  assertFixtureRejected({ ...validVersionedFixture, unexpected: true }, /exact version 2 object/);
+  assertFixtureRejected(
+    {
+      ...validVersionedFixture,
+      historicalMain: { ...validVersionedFixture.historicalMain, unexpected: true },
+    },
+    /historicalMain.*exact/
+  );
+  assertHistoricalRowsRejected(
+    validClassifications.map((row, index) =>
+      index === 0 ? { ...row, disposition: 'preserve' } : row
+    ),
+    /immutable historical-main evidence/
+  );
+});
+
+test('rc-baseline rows reject incomplete, stale, pending, or historical evidence', () => {
+  assertRcRowsRejected(auditedRcClassifications.slice(1), /missingClassificationIds/);
+  assertRcRowsRejected(
+    [auditedRcClassifications[0], ...auditedRcClassifications],
+    /duplicateClassificationIds/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) => (index === 0 ? { ...row, id: null } : row)),
+    /valid RCJ id/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) =>
+      index === 0 ? { ...row, unexpected: true } : row
+    ),
+    /exact required fields/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) =>
+      index === 0 ? { ...row, classification: 'proof-pending', result: 'proof-pending' } : row
+    ),
+    /proof-pending/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) =>
+      index === 0 ? { ...row, baselineSha: '0'.repeat(40) } : row
+    ),
+    /baselineSha/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) =>
+      index === 0 ? { ...row, ownerPaths: [], testPath: '', command: '' } : row
+    ),
+    /ownerPaths/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) => (index === 0 ? { ...row, result: 'fail' } : row)),
+    /baseline-owned.*pass/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row) =>
+      row.id === 'RCJ-TRACE-01' ? { ...row, result: 'pass' } : row
+    ),
+    /implementation-gap.*fail/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row, index) =>
+      index === 0 ? { ...row, command: 'git show rc/july:historical.ts' } : row
+    ),
+    /historical source/
+  );
+});
+
+test('rc-baseline authority and final pass-gap classifications are pinned', () => {
+  assertFixtureRejected(
+    {
+      ...validVersionedFixture,
+      rcBaseline: { ...validVersionedFixture.rcBaseline, baselineSha: '0'.repeat(40) },
+    },
+    /rcBaseline baselineSha/
+  );
+  assert.throws(
+    () =>
+      auditRetiredConceptAudit({
+        specPath,
+        auditFixturePath,
+        rcBaselineSha: '0'.repeat(40),
+      }),
+    /recorded rc baseline SHA/
+  );
+  assertRcRowsRejected(
+    auditedRcClassifications.map((row) => ({
+      ...row,
+      classification: 'baseline-owned',
+      result: 'pass',
+    })),
+    /authoritative classification/
+  );
+
+  const result = auditRetiredConceptAudit({
+    specPath,
+    auditFixturePath,
+    rcBaselineSha,
+  });
+  assertRetiredConceptAudit(result);
+  assert.deepEqual(result.rcBaseline.classificationCounts, {
+    baselineOwned: 19,
+    implementationGap: 4,
+  });
+  assert.deepEqual(
+    result.rcBaseline.classifications.map(({ id }) => id).sort(),
+    [...result.ledgerIds].sort()
+  );
+});
+
+test('the default current-main authority cannot be rewritten through the fixture', () => {
+  const directory = mkdtempSync(path.join(tmpdir(), 'current-main-authority-'));
+  const temporaryFixturePath = path.join(directory, 'audit.json');
+  const rewrittenRows = auditedClassifications.map((row) => ({ ...row, mainSha: '0'.repeat(40) }));
+  writeFileSync(
+    temporaryFixturePath,
+    JSON.stringify({
+      ...validVersionedFixture,
+      historicalMain: { ...validVersionedFixture.historicalMain, rows: rewrittenRows },
+    })
+  );
+  try {
+    assert.throws(
+      () =>
+        assertRetiredConceptAudit(
+          auditRetiredConceptAudit({
+            repositoryRoot,
+            specPath,
+            auditFixturePath: temporaryFixturePath,
+          })
+        ),
+      new RegExp(`mainSha must equal ${mainAuditSha}`)
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test('plan integrity scans executable shell fences while allowing prose and rename sources', () => {
+  const safe = `
+Never build rc/july or ${validManifest.retiredSnapshot}.
+
+\`\`\`json
+{"historical":"rc/july"}
+\`\`\`
+
+\`\`\`bash
+git mv crates/trusted-server-js/lib/scripts/check-rc-july-adoption.mjs crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs
+git mv crates/trusted-server-js/lib/test/contract/rc-july-adoption.test.mjs crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs
+\`\`\`
+`;
+  assert.deepEqual(auditRetiredPlanCommands(safe), []);
+
+  for (const command of [
+    'git fetch origin RC/July',
+    'git -C repository fetch origin rc/july',
+    'git -c protocol.version=2 diff main...rc/july',
+    'git show rc/july:file',
+    `git cat-file -e ${validManifest.retiredSnapshot}`,
+    'git ls-tree -r rc/july',
+    'git mv scripts/check-rc-july-adoption.mjs scripts/check-retired-concept-audit.mjs',
+    "echo 'rc/july is retired'",
+    "echo 'Do not build rc/july'",
+    "printf '%s\\n' 'Do not compare rc/july'",
+    '# rc/july is retired',
+    'echo "$(git fetch origin rc/july)"',
+    'printf \'%s\\n\' "$(git -C repository fetch origin rc/july)"',
+    'printf -v retired_ref rc/july',
+    'printf -vretired_ref rc/july',
+    'echo "`git fetch origin rc/july`"',
+    "echo 'git fetch origin rc/july' | sh",
+    'echo rc/july && true',
+    'echo rc/july; true',
+    'true && echo rc/july',
+    'echo rc/july & wait',
+    'echo "${retired:=rc/july}"\ngit fetch "$retired"',
+    'printf \'%s\' "${retired:=rc/july}"\ngit fetch "$retired"',
+    'echo rc/july\ngit fetch "$_"',
+    'git merge rc/july',
+    'git rebase rc/july',
+    'git cherry-pick 905984e62a0858c53d9f0ff6dd3a1bf190cf311d',
+    'git checkout rc/july',
+    'git worktree add /tmp/retired rc/july',
+    'git archive rc/july',
+    'git diff main...rc/july',
+    'npm run build -- rc/july',
+    'hyperfine "build main" "build rc/july"',
+  ]) {
+    const violations = auditRetiredPlanCommands(`\`\`\`sh\n${command}\n\`\`\``);
+    assert.equal(violations.length, 1, command);
+  }
+
+  assert.equal(countExecutableShellFences('  ```bash\necho safe\n  ```'), 1);
+  assert.equal(auditRetiredPlanCommands('  ```bash\ngit fetch origin rc/july\n  ```').length, 1);
+});
+
+test('the implementation plan contains no executable retired-source command', () => {
+  const planSource = readFileSync(planPath, 'utf8');
+  assert.equal(countExecutableShellFences(planSource), 62);
+  assert.deepEqual(auditRetiredPlanCommands(planSource), []);
+
+  const mutatedPlanSource = planSource.replace(
+    '  ```bash\n',
+    '  ```bash\ngit fetch origin rc/july\n'
+  );
+  assert.equal(auditRetiredPlanCommands(mutatedPlanSource).length, 1);
+});
+
+test('the historical performance fixture is immutable report-only evidence', () => {
+  const result = auditRetiredConceptAudit({
+    specPath,
+    historicalPerformanceFixturePath,
+  });
+  assert.deepEqual(result.historicalPerformanceEvidence, {
+    authority: 'report-only',
+    sha256: 'fe5d7f52dc47dc9608ca6b92b036c6b971845e6424b157768dc9403a62d2d6b4',
+  });
+
+  const directory = mkdtempSync(path.join(tmpdir(), 'historical-performance-evidence-'));
+  const modifiedFixturePath = path.join(directory, 'modified.json');
+  writeFileSync(modifiedFixturePath, `${readFileSync(historicalPerformanceFixturePath, 'utf8')} `);
+  try {
+    assert.throws(
+      () =>
+        assertRetiredConceptAudit(
+          auditRetiredConceptAudit({
+            specPath,
+            historicalPerformanceFixturePath: modifiedFixturePath,
+          })
+        ),
+      /historicalPerformanceEvidence/
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
diff --git a/crates/trusted-server-js/lib/test/core/auction.test.ts b/crates/trusted-server-js/lib/test/core/auction.test.ts
index 55dba7bb6..8fa35f967 100644
--- a/crates/trusted-server-js/lib/test/core/auction.test.ts
+++ b/crates/trusted-server-js/lib/test/core/auction.test.ts
@@ -1,10 +1,18 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-import { buildAdRequest, parseAuctionResponse, sendAuction } from '../../src/core/auction';
+import {
+  buildAdRequest,
+  MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+  parseAuctionResponse,
+  parseBrowserAuctionProjectionV1,
+  parseTrustedServerAuctionResponseV1,
+  sendAuction,
+} from '../../src/core/auction';
 import envelope from '../fixtures/aps-renderer-v1.json';
+import type { BrowserAuctionProjectionV1 } from '../../src/core/types';
 
 function apsRenderer(creativeId?: string) {
-  const bid = envelope.seatbid[0].bid[0];
+  const bid = envelope.seatbid[0]!.bid[0]!;
   return {
     type: 'aps' as const,
     version: 1 as const,
@@ -19,8 +27,89 @@ function apsRenderer(creativeId?: string) {
   };
 }
 
+function candidateId(index = 0): string {
+  return index.toString(36).padStart(12, 'A');
+}
+
+function reservationId(index = 0): string {
+  return `r1_${index.toString(36).padStart(22, 'A')}`;
+}
+
+function browserSlot(slot: string) {
+  return {
+    slot,
+    gamUnitPath: `/123/${slot}`,
+    divId: `div-${slot}`,
+    formats: [[300, 250]] as Array<[number, number]>,
+    targeting: { pos: slot } as Record<string, string>,
+  };
+}
+
+function browserProjection() {
+  const renderer = apsRenderer('fictional-creative-id');
+  return {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: 'auction-1',
+      results: [
+        { slot: 'slot-1', outcome: 'winner', candidateId: candidateId() },
+        { slot: 'slot-2', outcome: 'no_bid' },
+        { slot: 'slot-3', outcome: 'failed', reason: 'provider_timeout' },
+      ],
+    },
+    slots: [browserSlot('slot-1'), browserSlot('slot-2'), browserSlot('slot-3')],
+    bids: [
+      {
+        candidateId: candidateId(),
+        slot: 'slot-1',
+        provider: 'aps',
+        upstreamBidId: renderer.bidId,
+        cpm: 1.25,
+        currency: 'USD',
+        targeting: { hb_bidder: 'aps', hb_pb: '1.25' } as Record<string, string>,
+        rendererReservationId: reservationId(),
+        renderSource: renderer,
+      },
+    ],
+  };
+}
+
+function largeAdmProjection(admLengths: number[]): BrowserAuctionProjectionV1 {
+  return {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: 'auction-large',
+      results: admLengths.map((_, index) => ({
+        slot: `slot-${index}`,
+        outcome: 'winner' as const,
+        candidateId: candidateId(index),
+      })),
+    },
+    slots: admLengths.map((_, index) => browserSlot(`slot-${index}`)),
+    bids: admLengths.map((length, index) => ({
+      candidateId: candidateId(index),
+      slot: `slot-${index}`,
+      provider: 'prebid',
+      upstreamBidId: `upstream-${index}`,
+      cpm: index,
+      currency: 'USD',
+      targeting: {} as Record<string, string>,
+      rendererReservationId: reservationId(index),
+      renderSource: {
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: 'x'.repeat(length),
+        width: 300,
+        height: 250,
+      },
+    })),
+  };
+}
+
 describe('auction/buildAdRequest', () => {
-  it('builds from tsjs AdUnit objects', () => {
+  it('builds from direct-auction programmatic units', () => {
     const units = [
       {
         code: 'div-1',
@@ -42,14 +131,17 @@ describe('auction/buildAdRequest', () => {
     const result = buildAdRequest(units);
 
     expect(result.adUnits).toHaveLength(1);
-    expect(result.adUnits[0].code).toBe('div-1');
-    expect(result.adUnits[0].mediaTypes.banner?.sizes).toEqual([
+    expect(result.adUnits[0]!.code).toBe('div-1');
+    expect(result.adUnits[0]!.mediaTypes.banner?.sizes).toEqual([
       [300, 250],
       [728, 90],
     ]);
-    expect(result.adUnits[0].bids).toHaveLength(2);
-    expect(result.adUnits[0].bids[0]).toEqual({ bidder: 'appnexus', params: { placementId: 123 } });
-    expect(result.adUnits[0].bids[1]).toEqual({ bidder: 'rubicon', params: {} });
+    expect(result.adUnits[0]!.bids).toHaveLength(2);
+    expect(result.adUnits[0]!.bids[0]).toEqual({
+      bidder: 'appnexus',
+      params: { placementId: 123 },
+    });
+    expect(result.adUnits[0]!.bids[1]).toEqual({ bidder: 'rubicon', params: {} });
   });
 
   it('builds from Prebid BidRequest objects (adUnitCode + bidder)', () => {
@@ -81,13 +173,13 @@ describe('auction/buildAdRequest', () => {
     const unit1 = result.adUnits.find((u) => u.code === 'div-gpt-1');
     expect(unit1).toBeDefined();
     expect(unit1!.bids).toHaveLength(2);
-    expect(unit1!.bids[0].bidder).toBe('appnexus');
-    expect(unit1!.bids[1].bidder).toBe('rubicon');
+    expect(unit1!.bids[0]!.bidder).toBe('appnexus');
+    expect(unit1!.bids[1]!.bidder).toBe('rubicon');
 
     const unit2 = result.adUnits.find((u) => u.code === 'div-gpt-2');
     expect(unit2).toBeDefined();
     expect(unit2!.bids).toHaveLength(1);
-    expect(unit2!.bids[0].bidder).toBe('openx');
+    expect(unit2!.bids[0]!.bidder).toBe('openx');
   });
 
   it('handles empty units array', () => {
@@ -139,7 +231,7 @@ describe('auction/buildAdRequest', () => {
     const result = buildAdRequest(units);
 
     expect(result.adUnits).toHaveLength(1);
-    expect(result.adUnits[0].mediaTypes).toEqual({});
+    expect(result.adUnits[0]!.mediaTypes).toEqual({});
   });
 
   it('deduplicates by code/adUnitCode', () => {
@@ -150,9 +242,9 @@ describe('auction/buildAdRequest', () => {
 
     const result = buildAdRequest(units);
     expect(result.adUnits).toHaveLength(1);
-    expect(result.adUnits[0].bids).toHaveLength(2);
-    expect(result.adUnits[0].bids[0].bidder).toBe('a');
-    expect(result.adUnits[0].bids[1].bidder).toBe('b');
+    expect(result.adUnits[0]!.bids).toHaveLength(2);
+    expect(result.adUnits[0]!.bids[0]!.bidder).toBe('a');
+    expect(result.adUnits[0]!.bids[1]!.bidder).toBe('b');
   });
 });
 
@@ -245,8 +337,8 @@ describe('auction/parseAuctionResponse', () => {
       ],
     });
 
-    expect(bids[0].renderer).toEqual(renderer);
-    expect(bids[0].creativeId).toBe('aps-fictional-slot');
+    expect(bids[0]!.renderer).toEqual(renderer);
+    expect(bids[0]!.creativeId).toBe('aps-fictional-slot');
   });
 
   it('ignores unrelated or malformed renderer extensions while retaining ordinary adm', () => {
@@ -265,8 +357,8 @@ describe('auction/parseAuctionResponse', () => {
       ],
     });
 
-    expect(bids[0].renderer).toBeUndefined();
-    expect(bids[0].adm).toBe('<div>ordinary</div>');
+    expect(bids[0]!.renderer).toBeUndefined();
+    expect(bids[0]!.adm).toBe('<div>ordinary</div>');
   });
 
   it('handles multiple seatbids with multiple bids', () => {
@@ -307,11 +399,707 @@ describe('auction/parseAuctionResponse', () => {
 
     const bids = parseAuctionResponse(body);
     expect(bids).toHaveLength(1);
-    expect(bids[0].seat).toBe('unknown');
-    expect(bids[0].adm).toBe('');
-    expect(bids[0].width).toBe(300);
-    expect(bids[0].height).toBe(250);
-    expect(bids[0].adomain).toEqual([]);
+    expect(bids[0]!.seat).toBe('unknown');
+    expect(bids[0]!.adm).toBe('');
+    expect(bids[0]!.width).toBe(300);
+    expect(bids[0]!.height).toBe(250);
+    expect(bids[0]!.adomain).toEqual([]);
+  });
+});
+
+describe('auction/parseBrowserAuctionProjectionV1', () => {
+  it('accepts one exact ordered decision per slot and deep-copies the projection', () => {
+    const input = browserProjection();
+    const parsed = parseBrowserAuctionProjectionV1(input);
+
+    expect(parsed).toEqual(input);
+    expect(parsed).not.toBe(input);
+    expect(parsed!.auction.results.map((result) => result.slot)).toEqual([
+      'slot-1',
+      'slot-2',
+      'slot-3',
+    ]);
+    expect(Object.keys(parsed!.bids[0]!.targeting)).toEqual(['hb_bidder', 'hb_pb']);
+  });
+
+  it('rejects duplicate, missing, extra, and mismatched decision/bid joins', () => {
+    const cases: unknown[] = [];
+
+    const duplicateResult = browserProjection();
+    duplicateResult.auction.results.push({
+      slot: 'slot-1',
+      outcome: 'no_bid',
+    });
+    cases.push(duplicateResult);
+
+    const missingBid = browserProjection();
+    missingBid.bids = [];
+    cases.push(missingBid);
+
+    const extraBid = browserProjection();
+    extraBid.bids.push({ ...extraBid.bids[0]!, candidateId: candidateId(1) });
+    cases.push(extraBid);
+
+    const mismatchedSlot = browserProjection();
+    mismatchedSlot.bids[0]!.slot = 'slot-other';
+    cases.push(mismatchedSlot);
+
+    const duplicateCandidate = browserProjection();
+    duplicateCandidate.auction.results.push({
+      slot: 'slot-4',
+      outcome: 'winner',
+      candidateId: candidateId(),
+    });
+    duplicateCandidate.bids.push({ ...duplicateCandidate.bids[0]!, slot: 'slot-4' });
+    cases.push(duplicateCandidate);
+
+    for (const value of cases) {
+      expect(parseBrowserAuctionProjectionV1(value)).toBeUndefined();
+    }
+  });
+
+  it('enforces exact objects, own data properties, and ordinary prototypes', () => {
+    const unknownTopLevel = { ...browserProjection(), unknown: true };
+    const unknownDecision = browserProjection();
+    Object.assign(unknownDecision.auction.results[0]!, { unknown: true });
+    const accessor = browserProjection();
+    Object.defineProperty(accessor.bids[0]!, 'provider', {
+      enumerable: true,
+      get: () => 'aps',
+    });
+    const inherited = browserProjection();
+    Object.setPrototypeOf(inherited.bids[0]!, { inherited: true });
+
+    for (const value of [unknownTopLevel, unknownDecision, accessor, inherited]) {
+      expect(parseBrowserAuctionProjectionV1(value)).toBeUndefined();
+    }
+  });
+
+  it('requires exact GAM slot definitions in the canonical projection', () => {
+    const missingSlots = browserProjection() as Record<string, unknown>;
+    delete missingSlots['slots'];
+    expect(parseBrowserAuctionProjectionV1(missingSlots)).toBeUndefined();
+
+    const emptySlots = browserProjection();
+    emptySlots.slots = [];
+    expect(parseBrowserAuctionProjectionV1(emptySlots)).toBeUndefined();
+
+    const valid = browserProjection();
+    expect(parseBrowserAuctionProjectionV1(valid)?.slots).toEqual(valid.slots);
+  });
+
+  it('enforces result and bid count boundaries', () => {
+    expect(
+      parseBrowserAuctionProjectionV1({
+        version: 1,
+        auction: { version: 1, auctionId: 'auction-empty', results: [] },
+        slots: [],
+        bids: [],
+      })
+    ).toBeDefined();
+
+    const atLimit = browserProjection();
+    atLimit.auction.results = [];
+    atLimit.slots = [];
+    atLimit.bids = [];
+    for (let index = 0; index < 256; index += 1) {
+      const slot = `slot-${index}`;
+      const id = candidateId(index);
+      atLimit.auction.results.push({ slot, outcome: 'winner', candidateId: id });
+      atLimit.slots.push(browserSlot(slot));
+      atLimit.bids.push({
+        ...browserProjection().bids[0]!,
+        slot,
+        candidateId: id,
+        upstreamBidId: `upstream-${index}`,
+        rendererReservationId: reservationId(index),
+      });
+    }
+    expect(parseBrowserAuctionProjectionV1(atLimit)).toBeDefined();
+
+    const tooManyResults = structuredClone(atLimit);
+    tooManyResults.auction.results.push({ slot: 'overflow', outcome: 'no_bid' });
+    expect(parseBrowserAuctionProjectionV1(tooManyResults)).toBeUndefined();
+
+    const tooManyBids = structuredClone(atLimit);
+    tooManyBids.bids.push({
+      ...tooManyBids.bids[0]!,
+      slot: 'overflow',
+      candidateId: candidateId(300),
+      rendererReservationId: reservationId(300),
+    });
+    expect(parseBrowserAuctionProjectionV1(tooManyBids)).toBeUndefined();
+  });
+
+  it('enforces identity, price, currency, and targeting boundaries', () => {
+    const valid = browserProjection();
+    valid.auction.auctionId = 'A'.repeat(128);
+    valid.auction.results[0]!.slot = 'é'.repeat(128);
+    valid.slots[0]!.slot = 'é'.repeat(128);
+    valid.bids[0]!.slot = 'é'.repeat(128);
+    valid.bids[0]!.upstreamBidId = 'é'.repeat(32);
+    valid.bids[0]!.targeting = Object.fromEntries(
+      Array.from({ length: 32 }, (_, index) => [
+        `key_${String(index).padStart(2, '0')}`,
+        index === 0 ? '😀'.repeat(40) : 'v',
+      ])
+    );
+    expect(parseBrowserAuctionProjectionV1(valid)).toBeDefined();
+
+    const mutations: Array<(value: ReturnType<typeof browserProjection>) => void> = [
+      (value) => {
+        value.auction.auctionId = 'A'.repeat(129);
+      },
+      (value) => {
+        value.auction.auctionId = 'contains space';
+      },
+      (value) => {
+        value.auction.results[0]!.candidateId = 'short';
+      },
+      (value) => {
+        value.auction.results[0]!.slot = `bad\u0000slot`;
+      },
+      (value) => {
+        value.bids[0]!.provider = '-aps';
+      },
+      (value) => {
+        value.bids[0]!.upstreamBidId = 'é'.repeat(33);
+      },
+      (value) => {
+        value.bids[0]!.cpm = Number.POSITIVE_INFINITY;
+      },
+      (value) => {
+        value.bids[0]!.cpm = -0.01;
+      },
+      (value) => {
+        value.bids[0]!.currency = 'EUR';
+      },
+      (value) => {
+        value.bids[0]!.rendererReservationId = 'r1_short';
+      },
+      (value) => {
+        value.bids[0]!.targeting = { hb_adid: reservationId() };
+      },
+      (value) => {
+        value.bids[0]!.targeting = { ['k'.repeat(21)]: 'v' };
+      },
+      (value) => {
+        value.bids[0]!.targeting = { key: '😀'.repeat(41) };
+      },
+      (value) => {
+        value.bids[0]!.targeting = { key: 'é'.repeat(81) };
+      },
+      (value) => {
+        value.bids[0]!.targeting = { key: 'bad\u0001value' };
+      },
+      (value) => {
+        value.bids[0]!.targeting = { key: String.fromCharCode(0xd800) };
+      },
+    ];
+
+    for (const mutate of mutations) {
+      const value = browserProjection();
+      mutate(value);
+      expect(parseBrowserAuctionProjectionV1(value)).toBeUndefined();
+    }
+  });
+
+  it('enforces exact targeting entry, key, scalar, and UTF-8 byte boundaries', () => {
+    for (const count of [31, 32]) {
+      const value = browserProjection();
+      value.bids[0]!.targeting = Object.fromEntries(
+        Array.from({ length: count }, (_, index) => [`k_${index}`, 'v'])
+      );
+      expect(parseBrowserAuctionProjectionV1(value)).toBeDefined();
+    }
+    const tooManyEntries = browserProjection();
+    tooManyEntries.bids[0]!.targeting = Object.fromEntries(
+      Array.from({ length: 33 }, (_, index) => [`k_${index}`, 'v'])
+    );
+    expect(parseBrowserAuctionProjectionV1(tooManyEntries)).toBeUndefined();
+
+    for (const length of [19, 20]) {
+      const value = browserProjection();
+      value.bids[0]!.targeting = { ['k'.repeat(length)]: 'v' };
+      expect(parseBrowserAuctionProjectionV1(value)).toBeDefined();
+    }
+    const keyTooLong = browserProjection();
+    keyTooLong.bids[0]!.targeting = { ['k'.repeat(21)]: 'v' };
+    expect(parseBrowserAuctionProjectionV1(keyTooLong)).toBeUndefined();
+
+    for (const scalars of [39, 40]) {
+      const value = browserProjection();
+      value.bids[0]!.targeting = { key: 'a'.repeat(scalars) };
+      expect(parseBrowserAuctionProjectionV1(value)).toBeDefined();
+    }
+    const tooManyScalars = browserProjection();
+    tooManyScalars.bids[0]!.targeting = { key: 'a'.repeat(41) };
+    expect(parseBrowserAuctionProjectionV1(tooManyScalars)).toBeUndefined();
+
+    for (const valueText of ['😀'.repeat(39) + '€', '😀'.repeat(40)]) {
+      const value = browserProjection();
+      value.bids[0]!.targeting = { key: valueText };
+      expect(parseBrowserAuctionProjectionV1(value)).toBeDefined();
+    }
+    const tooManyBytes = browserProjection();
+    tooManyBytes.bids[0]!.targeting = { key: '😀'.repeat(40) + 'a' };
+    expect(parseBrowserAuctionProjectionV1(tooManyBytes)).toBeUndefined();
+  });
+
+  it('deep-copies every admitted targeting key as own data, including __proto__', () => {
+    const value = browserProjection();
+    value.bids[0]!.targeting = JSON.parse('{"__proto__":"publisher-value"}') as Record<
+      string,
+      string
+    >;
+
+    const parsed = parseBrowserAuctionProjectionV1(value);
+
+    expect(parsed).toBeDefined();
+    expect(Object.getPrototypeOf(parsed!.bids[0]!.targeting)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(parsed!.bids[0]!.targeting, '__proto__')).toBe(
+      true
+    );
+    expect(parsed!.bids[0]!.targeting['__proto__']).toBe('publisher-value');
+  });
+
+  it('enforces canonical UTF-8 JSON just below, at, and above 8 MiB', () => {
+    const lengths = Array.from({ length: 16 }, () => 512 * 1024);
+    lengths[15] = 1;
+    const baseline = largeAdmProjection(lengths);
+    const baselineBytes = new TextEncoder().encode(JSON.stringify(baseline)).length;
+    const exactTail = 1 + MAX_BROWSER_AUCTION_PROJECTION_BYTES - baselineBytes;
+    expect(exactTail).toBeLessThanOrEqual(512 * 1024);
+
+    for (const [delta, accepted] of [
+      [-1, true],
+      [0, true],
+      [1, false],
+    ] as const) {
+      lengths[15] = exactTail + delta;
+      const value = largeAdmProjection(lengths);
+      expect(new TextEncoder().encode(JSON.stringify(value)).length).toBe(
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES + delta
+      );
+      expect(parseBrowserAuctionProjectionV1(value) !== undefined).toBe(accepted);
+    }
+  });
+
+  it('uses captured validation intrinsics after platform prototypes are poisoned', () => {
+    const valid = largeAdmProjection([16]);
+    const invalid = { ...largeAdmProjection([16]), unknown: true };
+    const mismatchedWinner = largeAdmProjection([16]);
+    mismatchedWinner.auction.results[0]!.slot = 'mismatched-slot';
+    const iteratorDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const everyDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'every');
+    const includesDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'includes');
+    const someDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'some');
+    const encodeDescriptor = Object.getOwnPropertyDescriptor(TextEncoder.prototype, 'encode');
+    const testDescriptor = Object.getOwnPropertyDescriptor(RegExp.prototype, 'test');
+    const calls = { encode: 0, every: 0, includes: 0, iterator: 0, some: 0, test: 0 };
+    let parsed: BrowserAuctionProjectionV1 | undefined;
+    let rejected: BrowserAuctionProjectionV1 | undefined;
+    let rejectedMismatch: BrowserAuctionProjectionV1 | undefined;
+    Object.defineProperty(Array.prototype, Symbol.iterator, {
+      configurable: true,
+      value: () => {
+        calls.iterator += 1;
+        throw new Error('poisoned array iterator');
+      },
+    });
+    Object.defineProperty(TextEncoder.prototype, 'encode', {
+      configurable: true,
+      value: () => {
+        calls.encode += 1;
+        throw new Error('poisoned text encoder');
+      },
+    });
+    Object.defineProperty(RegExp.prototype, 'test', {
+      configurable: true,
+      value: () => {
+        calls.test += 1;
+        throw new Error('poisoned regular expression');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'every', {
+      configurable: true,
+      value: () => {
+        calls.every += 1;
+        throw new Error('poisoned array every');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'includes', {
+      configurable: true,
+      value: () => {
+        calls.includes += 1;
+        throw new Error('poisoned array includes');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'some', {
+      configurable: true,
+      value: () => {
+        calls.some += 1;
+        throw new Error('poisoned array some');
+      },
+    });
+    try {
+      parsed = parseBrowserAuctionProjectionV1(valid);
+      rejected = parseBrowserAuctionProjectionV1(invalid);
+      rejectedMismatch = parseBrowserAuctionProjectionV1(mismatchedWinner);
+    } finally {
+      if (iteratorDescriptor) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, iteratorDescriptor);
+      }
+      if (encodeDescriptor)
+        Object.defineProperty(TextEncoder.prototype, 'encode', encodeDescriptor);
+      if (testDescriptor) Object.defineProperty(RegExp.prototype, 'test', testDescriptor);
+      if (everyDescriptor) Object.defineProperty(Array.prototype, 'every', everyDescriptor);
+      if (includesDescriptor)
+        Object.defineProperty(Array.prototype, 'includes', includesDescriptor);
+      if (someDescriptor) Object.defineProperty(Array.prototype, 'some', someDescriptor);
+    }
+
+    expect(parsed).toBeDefined();
+    expect(rejected).toBeUndefined();
+    expect(rejectedMismatch).toBeUndefined();
+    expect(calls).toEqual({ encode: 0, every: 0, includes: 0, iterator: 0, some: 0, test: 0 });
+  });
+
+  it('accepts only the exact opaque pbs_cache carrier without a reservation identity', () => {
+    const cacheId = 'f47447a0-b759-4f2f-9887-af458b79b570';
+    const cacheProjection = () => {
+      const value = structuredClone(browserProjection());
+      const bid = value.bids[0]!;
+      delete (bid as { rendererReservationId?: string }).rendererReservationId;
+      (bid as { renderSource: unknown }).renderSource = {
+        type: 'pbs_cache',
+        version: 1,
+        cacheId,
+        cacheHost: 'cache.example:8443',
+        cachePath: '/pbc/v1/cache',
+        width: 0,
+        height: 0xffff_ffff,
+      };
+      return value;
+    };
+
+    const parsed = parseBrowserAuctionProjectionV1(cacheProjection());
+    expect(parsed?.bids[0]).toEqual(cacheProjection().bids[0]);
+    expect(parsed?.bids[0]).not.toHaveProperty('rendererReservationId');
+
+    const withReservation = cacheProjection();
+    Object.assign(withReservation.bids[0]!, { rendererReservationId: reservationId() });
+    expect(parseBrowserAuctionProjectionV1(withReservation)).toBeUndefined();
+
+    const withExtraSourceField = cacheProjection();
+    Object.assign(withExtraSourceField.bids[0]!.renderSource, { fetchUrl: 'https://forbidden' });
+    expect(parseBrowserAuctionProjectionV1(withExtraSourceField)).toBeUndefined();
+  });
+});
+
+describe('auction/parseTrustedServerAuctionResponseV1', () => {
+  interface MutableWireBid {
+    id: string;
+    impid: string;
+    price: number;
+    w: number;
+    h: number;
+    adm?: string;
+    ext: {
+      trusted_server: {
+        candidate_id: string;
+        slot_id: string;
+        render_source: unknown;
+        extra?: boolean;
+      };
+    };
+  }
+
+  function response(): {
+    id: string;
+    cur: string;
+    seatbid: Array<{ seat: string; bid: MutableWireBid[] }>;
+    ext: { trusted_server: { slot_results: unknown } };
+  } {
+    const projection = browserProjection();
+    const winner = projection.bids[0]!;
+    return {
+      id: projection.auction.auctionId,
+      cur: 'USD',
+      seatbid: [
+        {
+          seat: winner.provider,
+          bid: [
+            {
+              id: winner.rendererReservationId,
+              impid: winner.slot,
+              price: winner.cpm,
+              w: winner.renderSource.width,
+              h: winner.renderSource.height,
+              ext: {
+                trusted_server: {
+                  candidate_id: winner.candidateId,
+                  slot_id: winner.slot,
+                  render_source: winner.renderSource,
+                },
+              },
+            },
+          ],
+        },
+      ],
+      ext: { trusted_server: { slot_results: projection.auction } },
+    };
+  }
+
+  function admResponse(admLengths: number[]) {
+    const projected = largeAdmProjection(admLengths);
+    const canonical: BrowserAuctionProjectionV1 = {
+      version: 1,
+      auction: projected.auction,
+      slots: [],
+      bids: projected.bids.map((bid) => {
+        if (!('rendererReservationId' in bid)) throw new Error('expected owned ADM bid');
+        return { ...bid, upstreamBidId: bid.rendererReservationId };
+      }),
+    };
+    return {
+      canonical,
+      wire: {
+        id: canonical.auction.auctionId,
+        cur: 'USD',
+        seatbid: [
+          {
+            seat: 'prebid',
+            bid: canonical.bids.map((bid) => {
+              if (bid.renderSource.type !== 'adm' || !('rendererReservationId' in bid)) {
+                throw new Error('expected owned ADM source');
+              }
+              return {
+                id: bid.rendererReservationId,
+                impid: bid.slot,
+                price: bid.cpm,
+                adm: bid.renderSource.adm,
+                w: bid.renderSource.width,
+                h: bid.renderSource.height,
+                ext: {
+                  trusted_server: {
+                    candidate_id: bid.candidateId,
+                    slot_id: bid.slot,
+                    render_source: bid.renderSource,
+                  },
+                },
+              };
+            }),
+          },
+        ],
+        ext: { trusted_server: { slot_results: canonical.auction } },
+      },
+    };
+  }
+
+  it('accepts the exact four-way decision/candidate/impid/slot join', () => {
+    const parsed = parseTrustedServerAuctionResponseV1(response());
+
+    expect(parsed?.auction.results).toEqual(browserProjection().auction.results);
+    expect(parsed?.bids[0]).toEqual(
+      expect.objectContaining({
+        candidateId: candidateId(),
+        rendererReservationId: reservationId(),
+        impid: 'slot-1',
+        renderSource: apsRenderer('fictional-creative-id'),
+      })
+    );
+  });
+
+  it('caps the deduplicated canonical projection instead of duplicated ADM wire bytes', () => {
+    const lengths = Array.from({ length: 16 }, () => 512 * 1024);
+    lengths[15] = 1;
+    const baseline = admResponse(lengths).canonical;
+    const baselineBytes = new TextEncoder().encode(JSON.stringify(baseline)).byteLength;
+    const exactTail = 1 + MAX_BROWSER_AUCTION_PROJECTION_BYTES - baselineBytes;
+    expect(exactTail).toBeLessThanOrEqual(512 * 1024);
+
+    for (const [delta, accepted] of [
+      [0, true],
+      [1, false],
+    ] as const) {
+      lengths[15] = exactTail + delta;
+      const { canonical, wire } = admResponse(lengths);
+      expect(new TextEncoder().encode(JSON.stringify(canonical)).byteLength).toBe(
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES + delta
+      );
+      expect(new TextEncoder().encode(JSON.stringify(wire)).byteLength).toBeGreaterThan(
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES
+      );
+      expect(
+        new TextEncoder().encode(JSON.stringify(canonical)).length <=
+          MAX_BROWSER_AUCTION_PROJECTION_BYTES
+      ).toBe(accepted);
+      expect(parseTrustedServerAuctionResponseV1(wire) !== undefined).toBe(accepted);
+    }
+  });
+
+  it.each([
+    ['Object', Object.prototype],
+    ['Array', Array.prototype],
+  ] as const)(
+    'measures projection and response own data without inherited %s.prototype.toJSON',
+    (_name, prototype) => {
+      const lengths = Array.from({ length: 16 }, () => 512 * 1024);
+      lengths[15] = 1;
+      const baselineBytes = new TextEncoder().encode(
+        JSON.stringify(largeAdmProjection(lengths))
+      ).length;
+      lengths[15] = 2 + MAX_BROWSER_AUCTION_PROJECTION_BYTES - baselineBytes;
+      const oversizedProjection = largeAdmProjection(lengths);
+      expect(new TextEncoder().encode(JSON.stringify(oversizedProjection)).length).toBe(
+        MAX_BROWSER_AUCTION_PROJECTION_BYTES + 1
+      );
+      const acceptedResponse = response();
+
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, 'toJSON');
+      const inheritedToJson = vi.fn(() => ({}));
+      try {
+        Object.defineProperty(prototype, 'toJSON', {
+          configurable: true,
+          value: inheritedToJson,
+          writable: true,
+        });
+
+        expect(parseBrowserAuctionProjectionV1(oversizedProjection)).toBeUndefined();
+        expect(inheritedToJson).not.toHaveBeenCalled();
+        expect(parseTrustedServerAuctionResponseV1(acceptedResponse)).toBeDefined();
+        expect(inheritedToJson).not.toHaveBeenCalled();
+      } finally {
+        if (descriptor) Object.defineProperty(prototype, 'toJSON', descriptor);
+        else Reflect.deleteProperty(prototype, 'toJSON');
+      }
+    }
+  );
+
+  it('returns direct winners in decision order regardless of response order', () => {
+    const value = response();
+    const first = value.seatbid[0]!.bid[0]!;
+    const second = structuredClone(first);
+    second.id = reservationId(1);
+    second.impid = 'slot-2';
+    second.ext.trusted_server.candidate_id = candidateId(1);
+    second.ext.trusted_server.slot_id = 'slot-2';
+    value.seatbid[0]!.bid = [second, first];
+    const decisions = value.ext.trusted_server.slot_results as ReturnType<
+      typeof browserProjection
+    >['auction'];
+    decisions.results[1] = {
+      slot: 'slot-2',
+      outcome: 'winner',
+      candidateId: candidateId(1),
+    };
+
+    expect(parseTrustedServerAuctionResponseV1(value)?.bids.map((bid) => bid.candidateId)).toEqual([
+      candidateId(),
+      candidateId(1),
+    ]);
+  });
+
+  it('rejects missing, duplicate, extra, and mismatched joins transactionally', () => {
+    const missing = response();
+    missing.seatbid = [];
+    const duplicate = response();
+    duplicate.seatbid[0]!.bid.push(structuredClone(duplicate.seatbid[0]!.bid[0]!));
+    const mismatchedImpid = response();
+    mismatchedImpid.seatbid[0]!.bid[0]!.impid = 'slot-other';
+    const mismatchedSlot = response();
+    mismatchedSlot.seatbid[0]!.bid[0]!.ext.trusted_server.slot_id = 'slot-other';
+    const unknownTrustedKey = response();
+    Object.assign(unknownTrustedKey.seatbid[0]!.bid[0]!.ext.trusted_server, { extra: true });
+
+    for (const value of [missing, duplicate, mismatchedImpid, mismatchedSlot, unknownTrustedKey]) {
+      expect(parseTrustedServerAuctionResponseV1(value)).toBeUndefined();
+    }
+  });
+
+  it('rejects non-USD currency, duplicate reservations, and unknown outer wire keys', () => {
+    const nonUsd = response();
+    nonUsd.cur = 'EUR';
+
+    const duplicateReservation = response();
+    const second = structuredClone(duplicateReservation.seatbid[0]!.bid[0]!);
+    second.impid = 'slot-2';
+    second.ext.trusted_server.slot_id = 'slot-2';
+    second.ext.trusted_server.candidate_id = candidateId(1);
+    duplicateReservation.seatbid[0]!.bid.push(second);
+    const decisions = duplicateReservation.ext.trusted_server.slot_results as ReturnType<
+      typeof browserProjection
+    >['auction'];
+    decisions.results[1] = {
+      slot: 'slot-2',
+      outcome: 'winner',
+      candidateId: candidateId(1),
+    };
+
+    const unknownBody = response() as ReturnType<typeof response> & { unknown?: boolean };
+    unknownBody.unknown = true;
+    const unknownBid = response();
+    Object.assign(unknownBid.seatbid[0]!.bid[0]!, { unknown: true });
+    const emptySeat = response();
+    emptySeat.seatbid[0]!.bid = [];
+
+    for (const value of [nonUsd, duplicateReservation, unknownBody, unknownBid, emptySeat]) {
+      expect(parseTrustedServerAuctionResponseV1(value)).toBeUndefined();
+    }
+  });
+
+  it('permits matching adm only for ADM sources', () => {
+    const adm = response();
+    const source = {
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<div>ok</div>',
+      width: 1,
+      height: 1,
+    };
+    const bid = adm.seatbid[0]!.bid[0]!;
+    bid.w = 1;
+    bid.h = 1;
+    bid.adm = source.adm;
+    bid.ext.trusted_server.render_source = source;
+    expect(parseTrustedServerAuctionResponseV1(adm)).toBeDefined();
+
+    const admWithoutStandardField = structuredClone(adm);
+    delete admWithoutStandardField.seatbid[0]!.bid[0]!.adm;
+    expect(parseTrustedServerAuctionResponseV1(admWithoutStandardField)).toBeDefined();
+
+    const mismatch = structuredClone(adm);
+    mismatch.seatbid[0]!.bid[0]!.adm = '<div>different</div>';
+    expect(parseTrustedServerAuctionResponseV1(mismatch)).toBeUndefined();
+
+    const apsWithAdm = response();
+    apsWithAdm.seatbid[0]!.bid[0]!.adm = '<div>forbidden</div>';
+    expect(parseTrustedServerAuctionResponseV1(apsWithAdm)).toBeUndefined();
+  });
+
+  it('binds direct pbs_cache winners to the exact cache id and opaque host/path carrier', () => {
+    const cacheId = 'f47447a0-b759-4f2f-9887-af458b79b570';
+    const value = response();
+    const bid = value.seatbid[0]!.bid[0]!;
+    bid.id = cacheId;
+    bid.ext.trusted_server.render_source = {
+      type: 'pbs_cache',
+      version: 1,
+      cacheId,
+      cacheHost: 'cache.example:8443',
+      cachePath: '/pbc/v1/cache',
+      width: bid.w,
+      height: bid.h,
+    };
+
+    const parsed = parseTrustedServerAuctionResponseV1(value);
+    expect(parsed?.bids[0]).not.toHaveProperty('rendererReservationId');
+    expect(parsed?.bids[0]?.renderSource).toEqual(bid.ext.trusted_server.render_source);
+
+    const mismatched = structuredClone(value);
+    mismatched.seatbid[0]!.bid[0]!.id = 'different-cache-id';
+    expect(parseTrustedServerAuctionResponseV1(mismatched)).toBeUndefined();
   });
 });
 
@@ -365,7 +1153,7 @@ describe('auction/sendAuction', () => {
       })
     );
     expect(bids).toHaveLength(1);
-    expect(bids[0].price).toBe(2.5);
+    expect(bids[0]!.price).toBe(2.5);
   });
 
   it('returns empty array on network error', async () => {
diff --git a/crates/trusted-server-js/lib/test/core/bootstrap.test.ts b/crates/trusted-server-js/lib/test/core/bootstrap.test.ts
new file mode 100644
index 000000000..cef433fa6
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/core/bootstrap.test.ts
@@ -0,0 +1,446 @@
+import { createHash } from 'node:crypto';
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  canonicalIntegrationConfigDigestV1,
+  integrationConfigValueV1,
+  snapshotIntegrationConfigsV1,
+} from '../../src/core/contracts/integration_configs';
+import { snapshotBootstrapInputV1 } from '../../src/core/contracts/boot';
+import { snapshotServerBootTransportV1 } from '../../src/core/contracts/server_boot_transport';
+
+const RELEASE = 'a'.repeat(64);
+
+function bootInput(): Record<string, unknown> {
+  return {
+    target: {},
+    boot: {
+      abi: 1,
+      releaseId: RELEASE,
+      manifest: {
+        version: 1,
+        releaseId: RELEASE,
+        firstDisplay: null,
+        runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'b'.repeat(64)}`,
+        integrations: [{ id: 'render_runtime', phase: 'takeover' }],
+      },
+      auctionProjection: {
+        version: 1,
+        auction: { version: 1, auctionId: 'initial', results: [] },
+        slots: [],
+        bids: [],
+      },
+      integrations: { version: 1, entries: [] },
+      creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+      diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+    },
+    outline: null,
+  };
+}
+
+function carrier(config: unknown = { nested: ['value', 1, true, null] }): Record<string, unknown> {
+  return {
+    version: 1,
+    entries: [
+      { id: 'aps', config: {} },
+      { id: 'prebid', config },
+    ],
+  };
+}
+
+function firstDisplayInput(): Record<string, unknown> {
+  const input = bootInput();
+  const boot = input.boot as Record<string, unknown>;
+  const manifest = boot.manifest as Record<string, unknown>;
+  manifest.firstDisplay = {
+    src: `/static/tsjs=tsjs-first-display.min.js?m=0001&v=${'c'.repeat(64)}`,
+    slices: ['first_display'],
+  };
+  boot.auctionProjection = {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: 'initial',
+      results: [{ slot: 'ad-1', outcome: 'no_bid' }],
+    },
+    slots: [
+      {
+        slot: 'ad-1',
+        gamUnitPath: '/123/ad-1',
+        divId: 'ad-1',
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [],
+  };
+  const canonicalCarrier = JSON.stringify(boot.integrations);
+  input.outline = {
+    version: 1,
+    releaseId: RELEASE,
+    generation: 1,
+    projectionDigest: 'd'.repeat(64),
+    integrationConfigDigest: createHash('sha256').update(canonicalCarrier).digest('hex'),
+    slices: ['first_display'],
+    slotCount: 1,
+    outcomeCount: 1,
+    capabilities: [],
+    objectKinds: [],
+  };
+  return input;
+}
+
+function transportInput(firstDisplay = false): Record<string, unknown> {
+  const input = firstDisplay ? firstDisplayInput() : bootInput();
+  const boot = input.boot as Record<string, unknown>;
+  const integrationConfigDigest = createHash('sha256')
+    .update(JSON.stringify(boot.integrations))
+    .digest('hex');
+  const projectionDigest = createHash('sha256')
+    .update(JSON.stringify(boot.auctionProjection))
+    .digest('hex');
+  const outline = input.outline as Record<string, unknown> | null;
+  if (outline) {
+    outline.projectionDigest = projectionDigest;
+    outline.integrationConfigDigest = integrationConfigDigest;
+  }
+  return {
+    version: 1,
+    boot,
+    integrity: { version: 1, projectionDigest, integrationConfigDigest },
+    outline,
+  };
+}
+
+function selectFirstDisplay(
+  input: Record<string, unknown>,
+  mask: string,
+  slices: readonly string[]
+): void {
+  const boot = input.boot as Record<string, unknown>;
+  const manifest = boot.manifest as Record<string, unknown>;
+  manifest.firstDisplay = {
+    src: `/static/tsjs=tsjs-first-display.min.js?m=${mask}&v=${'c'.repeat(64)}`,
+    slices: [...slices],
+  };
+  const outline = input.outline as Record<string, unknown>;
+  outline.slices = [...slices];
+}
+
+describe('sealed production boot transport', () => {
+  it.each([false, true])('parses and recursively freezes a fresh %s transport', (firstDisplay) => {
+    const original = transportInput(firstDisplay);
+    const accepted = snapshotServerBootTransportV1(JSON.stringify(original), RELEASE);
+
+    expect(accepted).toBeDefined();
+    expect(accepted).not.toBe(original);
+    expect(Object.isFrozen(accepted)).toBe(true);
+    expect(Object.isFrozen(accepted?.boot)).toBe(true);
+    expect(Object.isFrozen(accepted?.boot.auctionProjection)).toBe(true);
+    expect(Object.isFrozen(accepted?.integrity)).toBe(true);
+    expect(accepted?.outline === null || Object.isFrozen(accepted?.outline)).toBe(true);
+  });
+
+  it('accepts strings only and requires the exact root and always-present integrity', () => {
+    const valid = transportInput();
+    expect(snapshotServerBootTransportV1(valid, RELEASE)).toBeUndefined();
+    expect(
+      snapshotServerBootTransportV1(JSON.stringify({ ...valid, extra: true }), RELEASE)
+    ).toBeUndefined();
+    const { integrity: _integrity, ...missingIntegrity } = valid;
+    expect(
+      snapshotServerBootTransportV1(JSON.stringify(missingIntegrity), RELEASE)
+    ).toBeUndefined();
+  });
+
+  it('binds a non-null outline to the always-present integrity value', () => {
+    const value = transportInput(true);
+    (value.outline as Record<string, unknown>).projectionDigest = 'f'.repeat(64);
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it('rejects non-v1 outline capability metadata in the compact parser', () => {
+    const value = transportInput(true);
+    const outline = value.outline as Record<string, unknown>;
+    outline.capabilities = ['persistent-only'];
+    outline.objectKinds = ['persistent-only'];
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it('rejects a decoded transport above 10 MiB before parsing it', () => {
+    const encoded = `${JSON.stringify(transportInput())}${' '.repeat(10 * 1024 * 1024)}`;
+    expect(snapshotServerBootTransportV1(encoded, RELEASE)).toBeUndefined();
+  });
+
+  it('rejects more than fourteen takeover manifest entries', () => {
+    const value = transportInput();
+    const boot = value.boot as Record<string, unknown>;
+    const manifest = boot.manifest as Record<string, unknown>;
+    const integrations = Array.from({ length: 14 }, (_, index) => ({
+      id: `takeover_${index}`,
+      phase: 'takeover',
+    }));
+    manifest.integrations = integrations;
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeDefined();
+
+    integrations.push({ id: 'takeover_14', phase: 'takeover' });
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it('binds each deferred manifest source to its declared id', () => {
+    const value = transportInput();
+    const boot = value.boot as Record<string, unknown>;
+    const manifest = boot.manifest as Record<string, unknown>;
+    manifest.integrations = [
+      { id: 'render_runtime', phase: 'takeover' },
+      {
+        id: 'gpt_later',
+        phase: 'deferred',
+        trigger: 'first_display_or_idle',
+        src: `/static/tsjs=tsjs-gpt_later.min.js?v=${'e'.repeat(64)}`,
+      },
+    ];
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeDefined();
+
+    const deferred = (manifest.integrations as Array<Record<string, unknown>>)[1]!;
+    deferred.src = `/static/tsjs=tsjs-evil.min.js?v=${'e'.repeat(64)}`;
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it('rejects unselected integration config entries out of canonical order', () => {
+    const value = transportInput();
+    const boot = value.boot as Record<string, unknown>;
+    boot.integrations = {
+      version: 1,
+      entries: [
+        { id: 'prebid', config: {} },
+        { id: 'aps', config: {} },
+      ],
+    };
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it.each([
+    ['APS without the render owner', '0085', ['first_display', 'aps_initial', 'gpt_initial']],
+    ['the render owner without GPT', '0003', ['first_display', 'render_owner_initial']],
+  ])('rejects %s before exposing the compact boot', (_name, mask, slices) => {
+    const value = transportInput(true);
+    selectFirstDisplay(value, mask, slices);
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeUndefined();
+  });
+
+  it.each([
+    ['0081', ['first_display', 'gpt_initial']],
+    ['0083', ['first_display', 'render_owner_initial', 'gpt_initial']],
+  ])('admits the closed non-APS slice relationship %s', (mask, slices) => {
+    const value = transportInput(true);
+    selectFirstDisplay(value, mask, slices);
+
+    expect(snapshotServerBootTransportV1(JSON.stringify(value), RELEASE)).toBeDefined();
+  });
+});
+
+describe('bootstrap integration configuration admission', () => {
+  it('captures one complete immutable boot copy without retaining the server literal', () => {
+    const original = bootInput();
+    const originalBoot = original.boot as Record<string, unknown>;
+    const accepted = snapshotBootstrapInputV1(original, RELEASE);
+
+    expect(accepted).toBeDefined();
+    expect(accepted?.boot).not.toBe(originalBoot);
+    expect(Object.isFrozen(accepted?.boot)).toBe(true);
+    expect(Object.isFrozen(accepted?.boot.manifest)).toBe(true);
+    expect(Object.isFrozen(accepted?.boot.auctionProjection)).toBe(true);
+    originalBoot.releaseId = 'c'.repeat(64);
+    original.boot = {};
+    expect(accepted?.boot.releaseId).toBe(RELEASE);
+  });
+
+  it('rejects manifest/config membership mismatch before capture', () => {
+    const input = bootInput();
+    const boot = input.boot as Record<string, unknown>;
+    const manifest = boot.manifest as Record<string, unknown>;
+    manifest.integrations = [
+      { id: 'render_runtime', phase: 'takeover' },
+      { id: 'aps', phase: 'takeover' },
+    ];
+
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+  });
+
+  it('rejects accessor-backed bootstrap fields without invoking the accessor', () => {
+    let invoked = false;
+    const input = bootInput();
+    Object.defineProperty(input, 'boot', {
+      enumerable: true,
+      get: () => {
+        invoked = true;
+        return {};
+      },
+    });
+
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+    expect(invoked).toBe(false);
+  });
+
+  it('calculates the canonical carrier digest and binds a first-display outline to it', () => {
+    const input = firstDisplayInput();
+    const acceptedCarrier = snapshotIntegrationConfigsV1(
+      (input.boot as Record<string, unknown>).integrations
+    );
+    const expected = createHash('sha256').update(JSON.stringify(acceptedCarrier)).digest('hex');
+
+    expect(canonicalIntegrationConfigDigestV1(acceptedCarrier!)).toBe(expected);
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeDefined();
+
+    const outline = input.outline as Record<string, unknown>;
+    outline.integrationConfigDigest = 'e'.repeat(64);
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+  });
+
+  it('rejects a self-consistent outline whose counts do not match the retained projection', () => {
+    const input = firstDisplayInput();
+    const outline = input.outline as Record<string, unknown>;
+    outline.slotCount = 2;
+    outline.outcomeCount = 2;
+
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+  });
+
+  it.each([
+    ['APS without the render owner', '0085', ['first_display', 'aps_initial', 'gpt_initial']],
+    ['the render owner without GPT', '0003', ['first_display', 'render_owner_initial']],
+  ])('rejects %s before retaining the full boot', (_name, mask, slices) => {
+    const input = firstDisplayInput();
+    selectFirstDisplay(input, mask, slices);
+
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+  });
+
+  it('preserves poison-named config data properties and rejects them outside config values', () => {
+    const config = Object.defineProperty({}, '__proto__', {
+      configurable: true,
+      enumerable: true,
+      value: { retained: 'data' },
+      writable: true,
+    });
+    const accepted = snapshotIntegrationConfigsV1(carrier(config));
+    const copied = integrationConfigValueV1(accepted!, 'prebid')!;
+
+    expect(Object.getPrototypeOf(copied)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(copied, '__proto__')).toBe(true);
+    expect(Object.getOwnPropertyDescriptor(copied, '__proto__')?.value).toEqual({
+      retained: 'data',
+    });
+    expect(canonicalIntegrationConfigDigestV1(accepted!)).toBe(
+      createHash('sha256').update(JSON.stringify(accepted)).digest('hex')
+    );
+
+    const input = bootInput();
+    Object.defineProperty(input, '__proto__', {
+      configurable: true,
+      enumerable: true,
+      value: {},
+      writable: true,
+    });
+    expect(snapshotBootstrapInputV1(input, RELEASE)).toBeUndefined();
+  });
+
+  it('copies, recursively freezes, orders, and attenuates the server carrier', () => {
+    const original = carrier() as {
+      entries: Array<{ id: 'aps' | 'prebid'; config: Record<string, unknown> }>;
+    };
+    const accepted = snapshotIntegrationConfigsV1(original);
+
+    expect(accepted).toBeDefined();
+    expect(accepted).not.toBe(original);
+    expect(Object.isFrozen(accepted)).toBe(true);
+    expect(Object.isFrozen(accepted?.entries)).toBe(true);
+    const prebid = integrationConfigValueV1(accepted!, 'prebid');
+    expect(prebid).toEqual({ nested: ['value', 1, true, null] });
+    expect(prebid).not.toBe(original.entries[1]?.config);
+    expect(Object.isFrozen(prebid)).toBe(true);
+    expect(Object.isFrozen(prebid?.nested)).toBe(true);
+
+    original.entries[1]!.config.nested = ['mutated'];
+    original.entries.length = 0;
+    expect(integrationConfigValueV1(accepted!, 'prebid')).toEqual({
+      nested: ['value', 1, true, null],
+    });
+    expect(integrationConfigValueV1(accepted!, 'aps')).toEqual({});
+    expect(integrationConfigValueV1(accepted!, 'gpt')).toBeUndefined();
+  });
+
+  it.each([
+    ['unknown root key', { ...carrier(), extra: true }],
+    ['custom root prototype', Object.assign(Object.create(null), carrier())],
+    ['symbol root key', Object.assign(carrier() as object, { [Symbol('x')]: true })],
+    [
+      'root accessor',
+      Object.defineProperty({ version: 1 }, 'entries', { enumerable: true, get: () => [] }),
+    ],
+    ['unknown id', { version: 1, entries: [{ id: 'unknown', config: {} }] }],
+    [
+      'out-of-order ids',
+      {
+        version: 1,
+        entries: [
+          { id: 'prebid', config: {} },
+          { id: 'aps', config: {} },
+        ],
+      },
+    ],
+    [
+      'duplicate ids',
+      {
+        version: 1,
+        entries: [
+          { id: 'aps', config: {} },
+          { id: 'aps', config: {} },
+        ],
+      },
+    ],
+    ['non-object config', { version: 1, entries: [{ id: 'aps', config: null }] }],
+    ['non-finite number', carrier({ value: Number.NaN })],
+    ['long key', carrier({ ['k'.repeat(4_097)]: true })],
+    ['long utf8 string', carrier({ value: 'é'.repeat(2_049) })],
+  ])('rejects %s', (_name, candidate) => {
+    expect(snapshotIntegrationConfigsV1(candidate)).toBeUndefined();
+  });
+
+  it('rejects sparse arrays, cycles, repeated aliases, excessive depth, and throwing traps', () => {
+    const sparse: unknown[] = [];
+    sparse.length = 1;
+    expect(snapshotIntegrationConfigsV1(carrier({ sparse }))).toBeUndefined();
+
+    const cycle: Record<string, unknown> = {};
+    cycle.self = cycle;
+    expect(snapshotIntegrationConfigsV1(carrier(cycle))).toBeUndefined();
+
+    const alias = {};
+    expect(snapshotIntegrationConfigsV1(carrier({ one: alias, two: alias }))).toBeUndefined();
+
+    let deep: Record<string, unknown> = {};
+    const root = deep;
+    for (let index = 0; index < 17; index += 1) {
+      deep.next = {};
+      deep = deep.next as Record<string, unknown>;
+    }
+    expect(snapshotIntegrationConfigsV1(carrier(root))).toBeUndefined();
+
+    const throwing = new Proxy(carrier() as object, {
+      ownKeys: () => {
+        throw new Error('publisher trap');
+      },
+    });
+    expect(snapshotIntegrationConfigsV1(throwing)).toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/core/config.test.ts b/crates/trusted-server-js/lib/test/core/config.test.ts
deleted file mode 100644
index 6abacdf54..000000000
--- a/crates/trusted-server-js/lib/test/core/config.test.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-describe('config', () => {
-  beforeEach(async () => {
-    // reset module state between tests
-    await vi.resetModules();
-  });
-
-  it('sets and gets config, controls log level', async () => {
-    const { setConfig, getConfig } = await import('../../src/core/config');
-    const { log } = await import('../../src/core/log');
-
-    setConfig({ a: 1 });
-    expect(getConfig()).toMatchObject({ a: 1 });
-
-    setConfig({ debug: true });
-    expect(log.getLevel()).toBe('debug');
-
-    setConfig({ logLevel: 'info' });
-    expect(log.getLevel()).toBe('info');
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/core/context.test.ts b/crates/trusted-server-js/lib/test/core/context.test.ts
deleted file mode 100644
index 74854837e..000000000
--- a/crates/trusted-server-js/lib/test/core/context.test.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-describe('context provider registry', () => {
-  beforeEach(async () => {
-    await vi.resetModules();
-  });
-
-  it('returns empty context when no providers registered', async () => {
-    const { collectContext } = await import('../../src/core/context');
-    expect(collectContext()).toEqual({});
-  });
-
-  it('collects data from a single provider', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('test', () => ({ foo: 'bar' }));
-    expect(collectContext()).toEqual({ foo: 'bar' });
-  });
-
-  it('merges data from multiple providers', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('a', () => ({ a: 1 }));
-    registerContextProvider('b', () => ({ b: 2 }));
-    expect(collectContext()).toEqual({ a: 1, b: 2 });
-  });
-
-  it('later providers overwrite earlier ones on key collision', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('first', () => ({ key: 'first' }));
-    registerContextProvider('second', () => ({ key: 'second' }));
-    expect(collectContext()).toEqual({ key: 'second' });
-  });
-
-  it('skips providers that return undefined', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('noop', () => undefined);
-    registerContextProvider('kept', () => ({ kept: true }));
-    expect(collectContext()).toEqual({ kept: true });
-  });
-
-  it('skips providers that throw', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('boom', () => {
-      throw new Error('boom');
-    });
-    registerContextProvider('survivor', () => ({ survived: true }));
-    expect(collectContext()).toEqual({ survived: true });
-  });
-
-  it('re-registration with same id replaces previous provider', async () => {
-    const { registerContextProvider, collectContext } = await import('../../src/core/context');
-    registerContextProvider('dup', () => ({ v: 1 }));
-    registerContextProvider('dup', () => ({ v: 2 }));
-    expect(collectContext()).toEqual({ v: 2 });
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/core/index.test.ts b/crates/trusted-server-js/lib/test/core/index.test.ts
index a02082b59..0cd4f6d1d 100644
--- a/crates/trusted-server-js/lib/test/core/index.test.ts
+++ b/crates/trusted-server-js/lib/test/core/index.test.ts
@@ -1,95 +1,448 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { AuctionBidData, AuctionSlot, TsjsApi } from '../../src/core/types';
+import { snapshotTsjsBootV1 } from '../../src/core/contracts/boot';
+import {
+  canonicalIntegrationConfigDigestV1,
+  sha256HexUtf8V1,
+} from '../../src/core/contracts/integration_configs';
+import type { TsjsApi, TsjsBootV1 } from '../../src/core/types';
 
-const ORIGINAL_FETCH = global.fetch;
+const RELEASE = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+let pendingDirectBind: ((input: unknown) => unknown) | undefined;
+let namespaceTarget: unknown;
+let namespaceSourceLive = false;
 
-describe('core/index', () => {
+function boot() {
+  return snapshotTsjsBootV1(
+    {
+      abi: 1,
+      releaseId: RELEASE,
+      manifest: {
+        version: 1,
+        releaseId: RELEASE,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: 'render_runtime', phase: 'takeover' }],
+      },
+      auctionProjection: {
+        version: 1,
+        auction: { version: 1, auctionId: 'initial', results: [] },
+        slots: [],
+        bids: [],
+      },
+      integrations: { version: 1, entries: [] },
+      creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+      diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+    },
+    RELEASE
+  )!;
+}
+
+function bootWithHostileConfigSurface() {
+  return snapshotTsjsBootV1(
+    {
+      ...boot(),
+      manifest: {
+        ...boot().manifest,
+        integrations: [
+          { id: 'render_runtime', phase: 'takeover' },
+          { id: 'aps', phase: 'takeover' },
+        ],
+      },
+      integrations: {
+        version: 1,
+        entries: [
+          {
+            id: 'aps',
+            config: {
+              accessorValue: true,
+              custom: { value: 1 },
+              symbolTarget: { value: 1 },
+              sparse: [1, null, 3],
+              aliasLeft: { value: 1 },
+              aliasRight: { value: 1 },
+              mutable: { value: 1 },
+            },
+          },
+        ],
+      },
+    },
+    RELEASE
+  )!;
+}
+
+function freezeDataGraph(value: unknown, skipped?: object, seen = new Set<object>()): void {
+  if (typeof value !== 'object' || value === null || value === skipped || seen.has(value)) return;
+  seen.add(value);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor && 'value' in descriptor) freezeDataGraph(descriptor.value, skipped, seen);
+  }
+  Object.freeze(value);
+}
+
+type HostileBootKind =
+  | 'accessor'
+  | 'custom_prototype'
+  | 'symbol'
+  | 'sparse_array'
+  | 'repeated_alias'
+  | 'mutable_config'
+  | 'mutable_manifest'
+  | 'mutable_projection'
+  | 'mutable_diagnostics';
+
+function hostileClaimedBoot(kind: HostileBootKind): {
+  readonly candidate: Readonly<TsjsBootV1>;
+  readonly integrity: ReturnType<typeof bootIntegrity>;
+  readonly assertUnobserved: () => void;
+} {
+  const accepted = bootWithHostileConfigSurface();
+  const candidate = JSON.parse(JSON.stringify(accepted)) as Record<string, unknown>;
+  const integrations = candidate.integrations as {
+    entries: Array<{ config: Record<string, unknown> }>;
+  };
+  const config = integrations.entries[0]!.config;
+  let accessorReads = 0;
+  let skipped: object | undefined;
+  if (kind === 'accessor') {
+    Object.defineProperty(config, 'accessorValue', {
+      configurable: true,
+      enumerable: true,
+      get: () => {
+        accessorReads += 1;
+        return true;
+      },
+    });
+  } else if (kind === 'custom_prototype') {
+    Object.setPrototypeOf(config.custom as object, { inherited: true });
+  } else if (kind === 'symbol') {
+    Object.defineProperty(config.symbolTarget as object, Symbol('hostile'), {
+      enumerable: true,
+      value: true,
+    });
+  } else if (kind === 'sparse_array') {
+    const sparse = [1, null, 3];
+    Reflect.deleteProperty(sparse, '1');
+    config.sparse = sparse;
+  } else if (kind === 'repeated_alias') {
+    config.aliasRight = config.aliasLeft;
+  } else if (kind === 'mutable_config') {
+    skipped = config.mutable as object;
+  } else if (kind === 'mutable_manifest') {
+    skipped = (candidate.manifest as { integrations: object }).integrations;
+  } else if (kind === 'mutable_projection') {
+    skipped = (candidate.auctionProjection as { slots: object }).slots;
+  } else {
+    skipped = (candidate.diagnostics as { gpt: object }).gpt;
+  }
+  freezeDataGraph(candidate, skipped);
+  return {
+    candidate: candidate as unknown as Readonly<TsjsBootV1>,
+    integrity: bootIntegrity(accepted),
+    assertUnobserved: () => expect(accessorReads).toBe(0),
+  };
+}
+
+async function loadMinimalProductionRuntime(): Promise<void> {
+  await import('../../src/composition/runtime_transport');
+  await import('../../src/integrations/render_runtime/index');
+}
+
+function installRuntimeScript(): void {
+  const script = document.createElement('script');
+  script.id = 'trustedserver-js';
+  script.src = new URL(RUNTIME_SRC, window.location.origin).href;
+  document.head.append(script);
+  Object.defineProperty(window.Document.prototype, 'currentScript', {
+    configurable: true,
+    get: () => script,
+  });
+}
+
+function installNamespaceGate(target: object): void {
+  namespaceTarget = target;
+  namespaceSourceLive = true;
+}
+
+function bootIntegrity(acceptedBoot: Readonly<TsjsBootV1>) {
+  return Object.freeze({
+    version: 1 as const,
+    projectionDigest: sha256HexUtf8V1(JSON.stringify(acceptedBoot.auctionProjection)),
+    integrationConfigDigest: canonicalIntegrationConfigDigestV1(acceptedBoot.integrations),
+  });
+}
+
+function installBootClaim(
+  _target: object,
+  acceptedBoot: Readonly<TsjsBootV1>,
+  integrity = bootIntegrity(acceptedBoot)
+): ReturnType<typeof vi.fn> {
+  const completed = vi.fn();
+  const claim = (source: unknown) => {
+    if (source !== document.currentScript) return undefined;
+    const takeover = Object.getOwnPropertyDescriptor(_target, '_firstDisplayTakeover');
+    const mode = takeover ? 'takeover' : 'direct';
+    return Object.freeze({
+      source,
+      target: _target,
+      boot: acceptedBoot,
+      integrity,
+      complete: completed,
+      currentScript: () => document.currentScript,
+      mode,
+      bind:
+        mode === 'direct'
+          ? (input: unknown) => pendingDirectBind?.(input)
+          : (input: unknown) =>
+              takeover && 'value' in takeover && typeof takeover.value === 'function'
+                ? takeover.value(document.currentScript, input)
+                : undefined,
+    });
+  };
+  Object.defineProperty(document.currentScript as HTMLScriptElement, '_claimRuntimeV1', {
+    configurable: false,
+    enumerable: false,
+    value: claim,
+    writable: false,
+  });
+  return completed;
+}
+
+function installDirectRuntimeClaim(_target: object): ReturnType<typeof vi.fn> {
+  const completed = vi.fn();
+  pendingDirectBind = () => completed;
+  return completed;
+}
+
+describe('core production bootstrap', () => {
   beforeEach(async () => {
     await vi.resetModules();
+    document.head.replaceChildren();
     document.body.innerHTML = '';
-    delete window.tsjs;
+    if (!Object.getOwnPropertyDescriptor(window, 'tsjs')) {
+      Object.defineProperty(window, 'tsjs', {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+          if (!namespaceSourceLive) return namespaceTarget;
+          namespaceSourceLive = false;
+          return document.currentScript;
+        },
+      });
+    }
+    namespaceTarget = undefined;
+    namespaceSourceLive = false;
+    pendingDirectBind = undefined;
+    installRuntimeScript();
   });
 
-  afterEach(() => {
-    global.fetch = ORIGINAL_FETCH;
-  });
+  it('commits the exact hard-cutover API and drains the retained preload queue', async () => {
+    const queued = vi.fn(function (this: TsjsApi) {
+      expect(this).toBe((window as unknown as { tsjs?: unknown }).tsjs);
+    });
+    const preload = {
+      boot: boot(),
+      que: [queued],
+      renderAdUnit: vi.fn(),
+      bids: { legacy: true },
+    };
+    installBootClaim(preload, preload.boot);
+    installDirectRuntimeClaim(preload);
+    installNamespaceGate(preload);
+
+    await loadMinimalProductionRuntime();
+    await vi.waitFor(() =>
+      expect((window as unknown as { tsjs?: TsjsApi }).tsjs?._internal?.state).toBe('kernel')
+    );
 
-  it('initializes tsjs API with expected surface', async () => {
-    await import('../../src/core/index');
-    const api = window.tsjs as TsjsApi;
-    expect(api).toBeDefined();
-    expect(typeof api.version).toBe('string');
-    expect(Array.isArray(api.que)).toBe(true);
+    const api = (window as unknown as { tsjs: TsjsApi }).tsjs;
+    expect(api).toBe(preload);
+    expect(api.version).toBe('1.0.0');
+    expect(api.releaseId).toBe(RELEASE);
+    expect(api.boot.releaseId).toBe(RELEASE);
+    expect(api.boot.manifest.releaseId).toBe(RELEASE);
+    expect(Object.isFrozen(api.boot)).toBe(true);
+    expect(Object.isFrozen(api.que)).toBe(true);
     expect(typeof api.addAdUnits).toBe('function');
-    expect(typeof api.renderAdUnit).toBe('function');
-    expect(typeof api.renderAllAdUnits).toBe('function');
-    expect(typeof api.setConfig).toBe('function');
-    expect(typeof api.getConfig).toBe('function');
     expect(typeof api.requestAds).toBe('function');
+    expect(api._registerIntegration({})).toBe(false);
+    expect(queued).toHaveBeenCalledOnce();
+    expect(preload).not.toHaveProperty('_claimBootSnapshot');
+    expect(preload).not.toHaveProperty('renderAdUnit');
+    expect(preload).not.toHaveProperty('bids');
+    expect(preload).not.toHaveProperty('renderAllAdUnits');
+    expect(preload).not.toHaveProperty('setConfig');
+    expect(preload).not.toHaveProperty('getConfig');
   });
 
-  it('defaults adSlots and bids so gated-off pages never see undefined', async () => {
-    await import('../../src/core/index');
-    const api = window.tsjs as TsjsApi;
-    expect(api.adSlots).toEqual([]);
-    expect(api.bids).toEqual({});
+  it('starts installation in the combined bundle task without waiting for DOM readiness', async () => {
+    const readyState = vi.spyOn(document, 'readyState', 'get').mockReturnValue('loading');
+    const preload = { boot: boot(), que: [] };
+    installBootClaim(preload, preload.boot);
+    installDirectRuntimeClaim(preload);
+    installNamespaceGate(preload);
+
+    try {
+      await loadMinimalProductionRuntime();
+      await vi.waitFor(() =>
+        expect((window as unknown as { tsjs?: TsjsApi }).tsjs?._internal?.state).toBe('kernel')
+      );
+    } finally {
+      readyState.mockRestore();
+    }
   });
 
-  it('preserves edge-injected adSlots and bids set before the bundle loads', async () => {
-    window.tsjs = {
-      adSlots: [{ id: 'pre-injected' } as AuctionSlot],
-      bids: { 'pre-injected': { hb_pb: '1.00' } } as Record<string, AuctionBidData>,
-    } as TsjsApi;
+  it.each(['projectionDigest', 'integrationConfigDigest'] as const)(
+    'rejects a direct boot whose %s does not match before runtime publication',
+    async (field) => {
+      const preload = { boot: boot(), que: [] };
+      const rejected = installBootClaim(
+        preload,
+        preload.boot,
+        Object.freeze({ ...bootIntegrity(preload.boot), [field]: 'f'.repeat(64) })
+      );
+      installNamespaceGate(preload);
 
-    await import('../../src/core/index');
+      await loadMinimalProductionRuntime();
+      await Promise.resolve();
 
-    expect(window.tsjs!.adSlots).toEqual([{ id: 'pre-injected' }]);
-    expect(window.tsjs!.bids).toEqual({ 'pre-injected': { hb_pb: '1.00' } });
-  });
+      expect(preload).not.toHaveProperty('_internal');
+      expect(preload).not.toHaveProperty('_registerIntegration');
+      expect(preload).not.toHaveProperty('requestAds');
+      expect(rejected).toHaveBeenCalledOnce();
+      expect(rejected).toHaveBeenCalledWith('abi_mismatch');
+    }
+  );
 
-  it('flushes queued callbacks that existed before initialization', async () => {
-    const callback = vi.fn(function (this: TsjsApi) {
-      expect(this).toBe(window.tsjs);
+  it('rejects mismatched integrity before consuming takeover or preparing runtime owners', async () => {
+    const script = document.currentScript as HTMLScriptElement;
+    script.id = 'trustedserver-js-runtime';
+    const coordinate = vi.fn();
+    const preload = { boot: boot(), que: [] };
+    Object.defineProperty(preload, '_firstDisplayTakeover', {
+      configurable: true,
+      enumerable: false,
+      value: coordinate,
+      writable: false,
     });
-    window.tsjs = { que: [callback] as Array<() => void> } as TsjsApi;
+    const rejected = installBootClaim(
+      preload,
+      preload.boot,
+      Object.freeze({ ...bootIntegrity(preload.boot), projectionDigest: 'f'.repeat(64) })
+    );
+    installNamespaceGate(preload);
 
-    await import('../../src/core/index');
+    await loadMinimalProductionRuntime();
+    await Promise.resolve();
 
-    expect(callback).toHaveBeenCalledTimes(1);
+    expect(coordinate).not.toHaveBeenCalled();
+    expect(preload).toHaveProperty('_firstDisplayTakeover');
+    expect(preload).not.toHaveProperty('_registerIntegration');
+    expect(preload).not.toHaveProperty('_internal');
+    expect(rejected).toHaveBeenCalledOnce();
+    expect(rejected).toHaveBeenCalledWith('abi_mismatch');
   });
 
-  it('installs queue that executes callbacks immediately with api context', async () => {
-    await import('../../src/core/index');
-    const api = window.tsjs as TsjsApi;
-    const fn = vi.fn();
+  it.each(
+    (['direct', 'takeover'] as const).flatMap((mode) =>
+      (
+        [
+          'accessor',
+          'custom_prototype',
+          'symbol',
+          'sparse_array',
+          'repeated_alias',
+          'mutable_config',
+          'mutable_manifest',
+          'mutable_projection',
+          'mutable_diagnostics',
+        ] as const
+      ).map((kind) => [mode, kind] as const)
+    )
+  )('rejects a %s claimed boot with hostile %s data before effects', async (mode, kind) => {
+    const { candidate, integrity, assertUnobserved } = hostileClaimedBoot(kind);
+    const preload = { boot: candidate, que: [] };
+    const coordinate = vi.fn();
+    if (mode === 'takeover') {
+      Object.defineProperty(preload, '_firstDisplayTakeover', {
+        configurable: true,
+        enumerable: false,
+        value: coordinate,
+        writable: false,
+      });
+    }
+    const rejected = installBootClaim(preload, candidate, integrity);
+    installNamespaceGate(preload);
+    const { startProductionRuntime } = await import('../../src/core/index');
+    const createComposition = vi.fn(() => ({
+      runtime: { start: vi.fn(() => true) },
+    })) as unknown as Parameters<typeof startProductionRuntime>[0];
 
-    api.que.push(fn);
+    startProductionRuntime(createComposition);
 
-    expect(fn).toHaveBeenCalledTimes(1);
-    expect(fn.mock.instances[0]).toBe(api);
+    assertUnobserved();
+    expect(createComposition).not.toHaveBeenCalled();
+    expect(coordinate).not.toHaveBeenCalled();
+    expect(preload).not.toHaveProperty('_internal');
+    expect(rejected).toHaveBeenCalledOnce();
+    expect(rejected).toHaveBeenCalledWith('abi_mismatch');
   });
 
-  it('renders registered ad units using core rendering helpers', async () => {
-    await import('../../src/core/index');
-    const api = window.tsjs as TsjsApi;
+  it('publishes no terminal API when the closure boot claim is malformed', async () => {
+    const preload = { boot: boot(), que: [] };
+    Object.defineProperty(preload, '_claimBootSnapshot', {
+      configurable: true,
+      enumerable: true,
+      value: () => preload.boot,
+    });
+    installNamespaceGate(preload);
+
+    await import('../../src/composition/runtime_transport');
+    await Promise.resolve();
 
-    api.addAdUnits([
-      { code: 'slot-1', mediaTypes: { banner: { sizes: [[300, 250]] } } },
-      { code: 'slot-2', mediaTypes: { banner: { sizes: [[320, 50]] } } },
-    ]);
+    expect(preload).toHaveProperty('_claimBootSnapshot');
+    expect(preload).not.toHaveProperty('_internal');
+    expect(preload).not.toHaveProperty('requestAds');
+  });
 
-    api.renderAllAdUnits();
+  it('disposes prepared runtime state and completes abi_mismatch when the direct claim rejects', async () => {
+    const preload = { boot: boot(), que: [] };
+    const rejected = installBootClaim(preload, preload.boot);
+    pendingDirectBind = () => undefined;
+    installNamespaceGate(preload);
+    const { startProductionRuntime } = await import('../../src/core/index');
+    const dispose = vi.fn();
+    const start = vi.fn(() => true);
+    const createComposition = vi.fn(() => ({
+      runtime: { dispose, start },
+    })) as unknown as Parameters<typeof startProductionRuntime>[0];
 
-    expect(document.getElementById('slot-1')?.textContent).toContain('300x250');
-    expect(document.getElementById('slot-2')?.textContent).toContain('320x50');
+    startProductionRuntime(createComposition);
+
+    expect(createComposition).toHaveBeenCalledOnce();
+    expect(start).not.toHaveBeenCalled();
+    expect(dispose).toHaveBeenCalledOnce();
+    expect(rejected).toHaveBeenCalledOnce();
+    expect(rejected).toHaveBeenCalledWith('abi_mismatch');
   });
 
-  it('exposes requestAds from the core request module', async () => {
-    const { requestAds } = await import('../../src/core/request');
-    await import('../../src/core/index');
-    const api = window.tsjs as TsjsApi;
+  it('does not publish a fallback API over a non-configurable boot claim', async () => {
+    const preload = { boot: boot(), que: [] };
+    Object.defineProperty(preload, '_claimBootSnapshot', {
+      configurable: false,
+      enumerable: false,
+      value: () => preload.boot,
+      writable: false,
+    });
+    installNamespaceGate(preload);
+
+    await import('../../src/composition/runtime_transport');
+    await Promise.resolve();
 
-    expect(api.requestAds).toBe(requestAds);
+    expect(preload).toHaveProperty('_claimBootSnapshot');
+    expect(preload).not.toHaveProperty('_internal');
+    expect(preload).not.toHaveProperty('requestAds');
   });
 });
diff --git a/crates/trusted-server-js/lib/test/core/log.test.ts b/crates/trusted-server-js/lib/test/core/log.test.ts
new file mode 100644
index 000000000..75c127273
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/core/log.test.ts
@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { publicLog as log } from '../../src/kernel/fallback';
+
+describe('log', () => {
+  afterEach(() => {
+    log.setLevel('warn');
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('rejects invalid runtime levels without changing the current level', () => {
+    log.setLevel('info');
+
+    expect(() => log.setLevel('verbose' as never)).toThrow(TypeError);
+    expect(log.getLevel()).toBe('info');
+    expect(log.setLevel('debug')).toBeUndefined();
+  });
+
+  it('isolates absent and throwing console methods', () => {
+    vi.stubGlobal('console', undefined);
+    expect(() => log.warn('absent')).not.toThrow();
+
+    vi.stubGlobal('console', {
+      warn: vi.fn(() => {
+        throw new Error('host console');
+      }),
+    });
+    expect(() => log.warn('throwing')).not.toThrow();
+  });
+
+  it('isolates throwing console and method accessors', () => {
+    const originalConsole = Object.getOwnPropertyDescriptor(globalThis, 'console');
+    try {
+      Object.defineProperty(globalThis, 'console', {
+        configurable: true,
+        get: () => {
+          throw new Error('console accessor');
+        },
+      });
+      expect(() => log.warn('hostile console')).not.toThrow();
+
+      const hostileConsole = {};
+      Object.defineProperty(hostileConsole, 'warn', {
+        get: () => {
+          throw new Error('method accessor');
+        },
+      });
+      Object.defineProperty(globalThis, 'console', {
+        configurable: true,
+        value: hostileConsole,
+        writable: true,
+      });
+      expect(() => log.warn('hostile method')).not.toThrow();
+    } finally {
+      if (originalConsole) Object.defineProperty(globalThis, 'console', originalConsole);
+      else Reflect.deleteProperty(globalThis, 'console');
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/core/public_types.test.ts b/crates/trusted-server-js/lib/test/core/public_types.test.ts
new file mode 100644
index 000000000..21a5f037d
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/core/public_types.test.ts
@@ -0,0 +1,43 @@
+import { describe, expectTypeOf, it } from 'vitest';
+
+import type {
+  AddAdUnitsResult,
+  ProgrammaticAdUnit,
+  RequestAdsOptions,
+  RequestAdsResult,
+  TsjsApi,
+  TsjsCommandQueue,
+  TsjsDiagnostics,
+  TsjsLog,
+} from '../../src';
+
+describe('public hard-cutover types', () => {
+  it('exports the exact Promise API without legacy helper names', () => {
+    type ExpectedKeys =
+      | 'version'
+      | 'releaseId'
+      | 'boot'
+      | 'que'
+      | 'log'
+      | '_registerIntegration'
+      | 'addAdUnits'
+      | 'requestAds'
+      | 'diagnostics'
+      | '_internal';
+
+    expectTypeOf<keyof TsjsApi>().toEqualTypeOf<ExpectedKeys>();
+    expectTypeOf<TsjsApi['version']>().toEqualTypeOf<'1.0.0'>();
+    expectTypeOf<TsjsApi['que']>().toEqualTypeOf<TsjsCommandQueue>();
+    expectTypeOf<TsjsApi['log']>().toEqualTypeOf<TsjsLog>();
+    expectTypeOf<Extract<TsjsApi, { diagnostics: TsjsDiagnostics }>['diagnostics']>().toEqualTypeOf<
+      Readonly<TsjsDiagnostics>
+    >();
+    expectTypeOf<TsjsApi['addAdUnits']>().parameters.toEqualTypeOf<
+      [ProgrammaticAdUnit | readonly ProgrammaticAdUnit[]]
+    >();
+    expectTypeOf<TsjsApi['addAdUnits']>().returns.toEqualTypeOf<AddAdUnitsResult>();
+    expectTypeOf<TsjsApi['requestAds']>().toEqualTypeOf<
+      (options?: RequestAdsOptions) => Promise<RequestAdsResult>
+    >();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/core/queue.test.ts b/crates/trusted-server-js/lib/test/core/queue.test.ts
new file mode 100644
index 000000000..a42d424d6
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/core/queue.test.ts
@@ -0,0 +1,247 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  canPublishTerminalFields,
+  commitQueue,
+  prepareQueue,
+  publishQueue,
+} from '../../src/core/queue';
+import { log } from '../../src/core/log';
+
+describe('terminal queue handoff', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('snapshots callable data entries, commits atomically, then drains FIFO with isolation', () => {
+    const calls: string[] = [];
+    const warning = vi.spyOn(log, 'warn').mockImplementation(() => undefined);
+    const target: { que?: unknown; ready?: boolean } = {
+      que: [
+        function (this: unknown) {
+          expect(this).toBe(target);
+          calls.push('first');
+          (target.que as unknown[]).push(() => calls.push('nested'));
+        },
+        'ignored',
+        () => {
+          calls.push('throwing');
+          throw new Error('publisher callback');
+        },
+        () => calls.push('last'),
+      ],
+    };
+    const ingress = prepareQueue(target);
+
+    const published = publishQueue(target, ingress, { ready: true });
+    (target.que as unknown[]).push(() => calls.push('after-commit'));
+    published.drain();
+    published.drain();
+    const queue = published.queue;
+
+    expect(calls).toEqual(['after-commit', 'first', 'nested', 'throwing', 'last']);
+    expect(warning).toHaveBeenCalledTimes(1);
+    expect(target.ready).toBe(true);
+    expect(target.que).toBe(queue);
+    expect(Array.isArray(queue)).toBe(true);
+    expect(queue).toHaveLength(0);
+    expect(Object.prototype.hasOwnProperty.call(queue, 'push')).toBe(true);
+    expect(Object.isFrozen(queue)).toBe(true);
+
+    ingress.push(() => calls.push('retained'));
+    expect(calls[calls.length - 1]).toBe('retained');
+    expect(Object.isFrozen(ingress)).toBe(true);
+    expect(Reflect.set(ingress, 'push', Array.prototype.push)).toBe(false);
+    expect(() => Array.prototype.push.call(ingress, () => calls.push('lost'))).toThrow(TypeError);
+    expect(calls).not.toContain('lost');
+    expect(ingress).toHaveLength(0);
+    expect(queue).toHaveLength(0);
+  });
+
+  it('preflights terminal fields before changing the ingress queue', () => {
+    const callback = vi.fn();
+    const target: { que?: unknown; version?: string } = { que: [callback] };
+    Object.defineProperty(target, 'version', {
+      configurable: false,
+      enumerable: true,
+      value: 'publisher',
+      writable: false,
+    });
+    const ingress = prepareQueue(target);
+
+    expect(canPublishTerminalFields(target, { version: '1.0.0' })).toBe(false);
+    expect(() => publishQueue(target, ingress, { version: '1.0.0' })).toThrow(TypeError);
+    expect(target.que).toBe(ingress);
+    expect(ingress).toHaveLength(1);
+    expect(ingress.push).toBe(Array.prototype.push);
+    expect(Object.isFrozen(ingress)).toBe(false);
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it('keeps callback isolation independent of logger failures', () => {
+    const calls: string[] = [];
+    vi.spyOn(log, 'warn').mockImplementation(() => {
+      throw new Error('hostile warning sink');
+    });
+    vi.spyOn(log, 'debug').mockImplementation(() => {
+      throw new Error('hostile debug sink');
+    });
+    const target = {
+      que: [
+        () => {
+          calls.push('throwing');
+          throw new Error('publisher callback');
+        },
+        () => calls.push('last'),
+      ],
+    };
+    const ingress = prepareQueue(target);
+
+    expect(() => commitQueue(target, ingress)).not.toThrow();
+    expect(calls).toEqual(['throwing', 'last']);
+  });
+
+  it('makes the committed public fields and queue immutable', () => {
+    const target: { que?: unknown; version?: string } = { que: [] };
+    const ingress = prepareQueue(target);
+    const queue = commitQueue(target, ingress, { version: '1.0.0' });
+    const callback = vi.fn();
+
+    expect(() => Array.prototype.push.call(queue, callback)).toThrow(TypeError);
+    expect(() => Array.prototype.splice.call(queue, 0, 0, callback)).toThrow(TypeError);
+    expect(() => Reflect.set(queue, 0, callback)).not.toThrow();
+    expect(Reflect.set(queue, 0, callback)).toBe(false);
+    expect(Reflect.set(queue, 'length', 1)).toBe(false);
+    expect(Reflect.deleteProperty(queue, 'push')).toBe(false);
+    expect(() => Object.defineProperty(queue, '0', { value: callback })).toThrow(TypeError);
+    expect(queue).toHaveLength(0);
+    expect(callback).not.toHaveBeenCalled();
+
+    expect(Reflect.set(target, 'version', 'changed')).toBe(false);
+    expect(Reflect.set(target, 'que', [])).toBe(false);
+    expect(Object.getOwnPropertyDescriptor(target, 'que')).toMatchObject({
+      configurable: false,
+      writable: false,
+    });
+  });
+
+  it.each([
+    ['index assignment', 'queue[0] = callback;', true, false, undefined],
+    ['length assignment', 'queue.length = 1;', true, false, undefined],
+    ['push deletion', 'delete queue.push;', true, false, undefined],
+    ['push replacement', 'queue.push = Array.prototype.push;', true, false, undefined],
+    ['inherited native splice', 'queue.splice(0, 0, callback);', true, true, undefined],
+    ['borrowed native push', 'Array.prototype.push.call(queue, callback);', true, true, undefined],
+    [
+      'borrowed native splice',
+      'Array.prototype.splice.call(queue, 0, 0, callback);',
+      true,
+      true,
+      undefined,
+    ],
+    [
+      'Object.defineProperty',
+      "Object.defineProperty(queue, '0', { value: callback });",
+      true,
+      true,
+      undefined,
+    ],
+    [
+      'Object.defineProperty length',
+      "Object.defineProperty(queue, 'length', { value: 1 });",
+      true,
+      true,
+      undefined,
+    ],
+    [
+      'Object.defineProperty push',
+      "Object.defineProperty(queue, 'push', { value: Array.prototype.push });",
+      true,
+      true,
+      undefined,
+    ],
+    [
+      'Object.defineProperties',
+      'Object.defineProperties(queue, { 0: { value: callback } });',
+      true,
+      true,
+      undefined,
+    ],
+    [
+      'Reflect.defineProperty',
+      "return Reflect.defineProperty(queue, '0', { value: callback });",
+      false,
+      false,
+      false,
+    ],
+    ['Reflect.set index', "return Reflect.set(queue, '0', callback);", false, false, false],
+    ['Reflect.set length', "return Reflect.set(queue, 'length', 1);", false, false, false],
+    [
+      'Reflect.deleteProperty push',
+      "return Reflect.deleteProperty(queue, 'push');",
+      false,
+      false,
+      false,
+    ],
+  ] as const)(
+    'rejects terminal %s in strict and sloppy callers',
+    (_name, mutation, strictThrows, sloppyThrows, expectedResult) => {
+      const target: { que?: unknown } = { que: [] };
+      const queue = commitQueue(target, prepareQueue(target));
+      const originalPush = queue.push;
+      const callback = vi.fn();
+      const strictMutation = new Function('queue', 'callback', `'use strict'; ${mutation}`) as (
+        queue: unknown[],
+        callback: () => void
+      ) => void;
+      const sloppyMutation = new Function('queue', 'callback', mutation) as (
+        queue: unknown[],
+        callback: () => void
+      ) => unknown;
+
+      if (strictThrows) {
+        expect(() => strictMutation(queue, callback)).toThrow(TypeError);
+      } else {
+        expect(strictMutation(queue, callback)).toBe(expectedResult);
+      }
+      if (sloppyThrows) {
+        expect(() => sloppyMutation(queue, callback)).toThrow(TypeError);
+      } else {
+        expect(sloppyMutation(queue, callback)).toBe(expectedResult);
+      }
+      expect(queue).toHaveLength(0);
+      expect(queue.push).toBe(originalPush);
+      expect(Object.prototype.hasOwnProperty.call(queue, 'push')).toBe(true);
+      expect(Object.isFrozen(queue)).toBe(true);
+      expect(callback).not.toHaveBeenCalled();
+    }
+  );
+
+  it('prepares one actual ingress Array without reading hostile entries', () => {
+    const getter = vi.fn(() => () => undefined);
+    const hostile: unknown[] = [];
+    Object.defineProperty(hostile, '0', { configurable: true, enumerable: true, get: getter });
+    hostile.length = 1;
+    const target: { que?: unknown } = { que: hostile };
+
+    const ingress = prepareQueue(target);
+    const queue = commitQueue(target, ingress);
+
+    expect(ingress).toBe(hostile);
+    expect(getter).not.toHaveBeenCalled();
+    expect(queue).toHaveLength(0);
+  });
+
+  it('copies data entries out of a frozen or custom-push publisher Array', () => {
+    const callback = vi.fn();
+    const hostile = Object.freeze(Object.assign([callback], { push: vi.fn() }));
+    const target: { que?: unknown } = { que: hostile };
+
+    const ingress = prepareQueue(target);
+
+    expect(ingress).not.toBe(hostile);
+    expect(Array.isArray(ingress)).toBe(true);
+    expect(ingress[0]).toBe(callback);
+    expect(ingress.push).toBe(Array.prototype.push);
+    expect(() => commitQueue(target, ingress)).not.toThrow();
+    expect(callback).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/core/registry.test.ts b/crates/trusted-server-js/lib/test/core/registry.test.ts
index f06527e42..006030926 100644
--- a/crates/trusted-server-js/lib/test/core/registry.test.ts
+++ b/crates/trusted-server-js/lib/test/core/registry.test.ts
@@ -1,29 +1,346 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect } from 'vitest';
 
-import type { AdUnit } from '../../src/core/types';
+import {
+  AdUnitRegistrationError,
+  prepareProgrammaticAdUnits,
+  serializeAuctionRequestBody,
+} from '../../src/core/registry';
+
+function unit(code = 'programmatic-slot'): Record<string, unknown> {
+  return {
+    code,
+    mediaTypes: { banner: { sizes: [[300, 250]] } },
+    bids: [{ bidder: 'fictional', params: { placement: 7 } }],
+  };
+}
+
+function expectRegistrationError(
+  callback: () => unknown,
+  code: AdUnitRegistrationError['code'],
+  unitIndex?: number
+): void {
+  try {
+    callback();
+    throw new Error('should reject registration');
+  } catch (error) {
+    expect(error).toBeInstanceOf(AdUnitRegistrationError);
+    expect(error).toMatchObject({ code, ...(unitIndex === undefined ? {} : { unitIndex }) });
+  }
+}
 
 describe('registry', () => {
-  beforeEach(async () => {
-    await vi.resetModules();
-  });
-
-  it('adds ad units and returns size', async () => {
-    const { addAdUnits, firstSize, getAllUnits } = await import('../../src/core/registry');
-    const unit = {
-      code: 'u1',
-      mediaTypes: {
-        banner: {
-          sizes: [
-            [320, 50],
-            [300, 250],
-          ],
+  it('detaches and recursively freezes one or many exact programmatic units', () => {
+    const first = unit('first');
+    const second = unit('second');
+    const prepared = prepareProgrammaticAdUnits([first, second], new Set(['server-slot']));
+
+    expect(prepared.map(({ code }) => code)).toEqual(['first', 'second']);
+    expect(Object.isFrozen(prepared)).toBe(true);
+    expect(Object.isFrozen(prepared[0])).toBe(true);
+    expect(Object.isFrozen(prepared[0]?.mediaTypes.banner.sizes)).toBe(true);
+    expect(Object.isFrozen(prepared[0]?.bids?.[0]?.params)).toBe(true);
+    (
+      (first.bids as Array<{ params: { placement: number } }>)[0]!.params as { placement: number }
+    ).placement = 99;
+    expect(prepared[0]?.bids?.[0]?.params).toEqual({ placement: 7 });
+
+    expect(prepareProgrammaticAdUnits(unit('single'), new Set())).toHaveLength(1);
+  });
+
+  it.each([
+    [null, 'invalid_unit', 0],
+    [[], 'invalid_units', undefined],
+    [Array.from({ length: 257 }, (_, index) => unit(`slot-${index}`)), 'invalid_units', undefined],
+    [{ ...unit(), unknown: true }, 'invalid_unit', 0],
+    [{ code: '', mediaTypes: { banner: { sizes: [[300, 250]] } } }, 'invalid_code', 0],
+    [[unit('same'), unit('same')], 'duplicate_code', 1],
+    [unit('occupied'), 'slot_collision', 0],
+    [{ code: 'slot', mediaTypes: {} }, 'invalid_media_types', 0],
+    [{ code: 'slot', mediaTypes: { banner: { sizes: [] } } }, 'invalid_media_types', 0],
+    [{ code: 'slot', mediaTypes: { banner: { sizes: [[0, 250]] } } }, 'invalid_dimensions', 0],
+    [{ code: 'slot', mediaTypes: { banner: { sizes: [[1.5, 250]] } } }, 'invalid_dimensions', 0],
+    [
+      { code: 'slot', mediaTypes: { banner: { sizes: [[4_097, 250]] } } },
+      'dimensions_out_of_range',
+      0,
+    ],
+    [{ ...unit(), bids: null }, 'invalid_bids', 0],
+    [{ ...unit(), bids: [{ bidder: '' }] }, 'invalid_bidder', 0],
+    [{ ...unit(), bids: [{ bidder: 'a'.repeat(65) }] }, 'invalid_bidder', 0],
+    [{ ...unit(), bids: [{ bidder: 'fictional', params: [] }] }, 'invalid_params', 0],
+  ] as const)('rejects invalid registration %# with the exact code', (candidate, code, index) => {
+    const occupied = new Set(candidate === null ? [] : ['occupied']);
+    expectRegistrationError(() => prepareProgrammaticAdUnits(candidate, occupied), code, index);
+  });
+
+  it('rejects accessors, foreign prototypes, cyclic params, and oversized bodies without reads', () => {
+    const getter = vi.fn(() => 'accessed');
+    const accessor = unit();
+    Object.defineProperty(accessor, 'code', { enumerable: true, get: getter });
+    expectRegistrationError(
+      () => prepareProgrammaticAdUnits(accessor, new Set()),
+      'invalid_unit',
+      0
+    );
+    expect(getter).not.toHaveBeenCalled();
+
+    const foreign = Object.assign(Object.create({ inherited: true }), unit());
+    expectRegistrationError(
+      () => prepareProgrammaticAdUnits(foreign, new Set()),
+      'invalid_unit',
+      0
+    );
+
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+    expectRegistrationError(
+      () =>
+        prepareProgrammaticAdUnits(
+          { ...unit(), bids: [{ bidder: 'fictional', params: cyclic }] },
+          new Set()
+        ),
+      'invalid_params',
+      0
+    );
+
+    expectRegistrationError(
+      () =>
+        prepareProgrammaticAdUnits(
+          {
+            ...unit(),
+            bids: [{ bidder: 'fictional', params: { payload: 'x'.repeat(256 * 1024) } }],
+          },
+          new Set()
+        ),
+      'request_body_too_large'
+    );
+  });
+
+  it('accepts exact bidder and dimension boundaries and enforces combined capacity last', () => {
+    for (const bidderLength of [63, 64]) {
+      expect(
+        prepareProgrammaticAdUnits(
+          { ...unit(), bids: [{ bidder: 'a'.repeat(bidderLength), params: {} }] },
+          new Set()
+        )
+      ).toHaveLength(1);
+    }
+    for (const dimension of [1, 4_096]) {
+      expect(
+        prepareProgrammaticAdUnits(
+          {
+            code: `slot-${dimension}`,
+            mediaTypes: { banner: { sizes: [[dimension, dimension]] } },
+          },
+          new Set()
+        )
+      ).toHaveLength(1);
+    }
+    for (const existingCount of [254, 255]) {
+      const existing = new Set(
+        Array.from({ length: existingCount }, (_, index) => `server-${index}`)
+      );
+      expect(prepareProgrammaticAdUnits(unit(`at-${existingCount + 1}`), existing)).toHaveLength(1);
+    }
+    const existing = new Set(Array.from({ length: 256 }, (_, index) => `server-${index}`));
+    expectRegistrationError(
+      () => prepareProgrammaticAdUnits(unit('overflow'), existing),
+      'registry_capacity'
+    );
+  });
+
+  it('enforces the encoded auction-unit body cap at the exact byte boundary', () => {
+    const candidate = {
+      code: 'body-boundary',
+      mediaTypes: { banner: { sizes: [[300, 250]] } },
+      bids: [{ bidder: 'fictional', params: { payload: '' } }],
+    };
+    const baseBytes = new TextEncoder().encode(
+      JSON.stringify({ adUnits: [candidate], config: {} })
+    ).byteLength;
+    const payloadAtLimit = 'x'.repeat(256 * 1024 - baseBytes);
+    candidate.bids[0]!.params.payload = payloadAtLimit;
+    expect(
+      new TextEncoder().encode(JSON.stringify({ adUnits: [candidate], config: {} }))
+    ).toHaveLength(256 * 1024);
+    expect(prepareProgrammaticAdUnits(candidate, new Set())).toHaveLength(1);
+
+    candidate.bids[0]!.params.payload += 'x';
+    expectRegistrationError(
+      () => prepareProgrammaticAdUnits(candidate, new Set()),
+      'request_body_too_large'
+    );
+  });
+
+  it('bounds validation work before rejecting repeated shared params by aggregate body size', () => {
+    let ownKeysCalls = 0;
+    const sharedParams = new Proxy(
+      Object.fromEntries(
+        Array.from({ length: 16_384 }, (_, index) => [`p${index.toString(36)}`, 'x'])
+      ),
+      {
+        ownKeys: (target) => {
+          ownKeysCalls += 1;
+          return Reflect.ownKeys(target);
+        },
+      }
+    );
+    const candidates = Array.from({ length: 32 }, (_, index) => ({
+      ...unit(`shared-${index}`),
+      bids: [{ bidder: 'fictional', params: sharedParams }],
+    }));
+
+    expectRegistrationError(
+      () => prepareProgrammaticAdUnits(candidates, new Set()),
+      'request_body_too_large'
+    );
+    expect(ownKeysCalls).toBeLessThanOrEqual(4);
+  });
+
+  it('charges acyclic shared-DAG multiplicity to the aggregate body budget', () => {
+    const descriptorReads: number[] = [];
+    let shared: object = { value: 'leaf' };
+    for (let depth = 0; depth < 24; depth += 1) {
+      const node = { left: shared, right: shared };
+      const nodeIndex = descriptorReads.length;
+      descriptorReads.push(0);
+      shared = new Proxy(node, {
+        getOwnPropertyDescriptor: (target, key) => {
+          descriptorReads[nodeIndex] = (descriptorReads[nodeIndex] ?? 0) + 1;
+          return Reflect.getOwnPropertyDescriptor(target, key);
         },
+      });
+    }
+
+    expectRegistrationError(
+      () =>
+        prepareProgrammaticAdUnits(
+          {
+            ...unit('shared-dag'),
+            bids: [{ bidder: 'fictional', params: shared }],
+          },
+          new Set()
+        ),
+      'request_body_too_large'
+    );
+    expect(descriptorReads.every((reads) => reads <= 2)).toBe(true);
+  });
+
+  it('uses captured validation intrinsics after platform prototypes are poisoned', () => {
+    const validCandidate = unit('poison-safe');
+    const invalidCandidate = { ...unit('unknown-key'), unknown: true };
+    const invalidDimensions = {
+      ...unit('invalid-dimensions'),
+      mediaTypes: { banner: { sizes: [['bad', 250]] } },
+    };
+    const iteratorDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const everyDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'every');
+    const includesDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'includes');
+    const someDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'some');
+    const encodeDescriptor = Object.getOwnPropertyDescriptor(TextEncoder.prototype, 'encode');
+    const testDescriptor = Object.getOwnPropertyDescriptor(RegExp.prototype, 'test');
+    const calls = { encode: 0, every: 0, includes: 0, iterator: 0, some: 0, test: 0 };
+    let prepared: ReturnType<typeof prepareProgrammaticAdUnits> | undefined;
+    let invalidError: unknown;
+    let invalidDimensionsError: unknown;
+    Object.defineProperty(Array.prototype, Symbol.iterator, {
+      configurable: true,
+      value: () => {
+        calls.iterator += 1;
+        throw new Error('poisoned array iterator');
       },
-    } as AdUnit;
-    addAdUnits(unit);
+    });
+    Object.defineProperty(TextEncoder.prototype, 'encode', {
+      configurable: true,
+      value: () => {
+        calls.encode += 1;
+        throw new Error('poisoned text encoder');
+      },
+    });
+    Object.defineProperty(RegExp.prototype, 'test', {
+      configurable: true,
+      value: () => {
+        calls.test += 1;
+        throw new Error('poisoned regular expression');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'every', {
+      configurable: true,
+      value: () => {
+        calls.every += 1;
+        throw new Error('poisoned array every');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'includes', {
+      configurable: true,
+      value: () => {
+        calls.includes += 1;
+        throw new Error('poisoned array includes');
+      },
+    });
+    Object.defineProperty(Array.prototype, 'some', {
+      configurable: true,
+      value: () => {
+        calls.some += 1;
+        throw new Error('poisoned array some');
+      },
+    });
+    try {
+      prepared = prepareProgrammaticAdUnits(validCandidate, new Set());
+      try {
+        prepareProgrammaticAdUnits(invalidCandidate, new Set());
+      } catch (error) {
+        invalidError = error;
+      }
+      try {
+        prepareProgrammaticAdUnits(invalidDimensions, new Set());
+      } catch (error) {
+        invalidDimensionsError = error;
+      }
+    } finally {
+      if (iteratorDescriptor) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, iteratorDescriptor);
+      }
+      if (encodeDescriptor)
+        Object.defineProperty(TextEncoder.prototype, 'encode', encodeDescriptor);
+      if (testDescriptor) Object.defineProperty(RegExp.prototype, 'test', testDescriptor);
+      if (everyDescriptor) Object.defineProperty(Array.prototype, 'every', everyDescriptor);
+      if (includesDescriptor)
+        Object.defineProperty(Array.prototype, 'includes', includesDescriptor);
+      if (someDescriptor) Object.defineProperty(Array.prototype, 'some', someDescriptor);
+    }
+
+    expect(prepared?.[0]?.code).toBe('poison-safe');
+    expect(invalidError).toBeInstanceOf(AdUnitRegistrationError);
+    expect(invalidError).toMatchObject({ code: 'invalid_unit', unitIndex: 0 });
+    expect(invalidDimensionsError).toBeInstanceOf(AdUnitRegistrationError);
+    expect(invalidDimensionsError).toMatchObject({ code: 'invalid_dimensions', unitIndex: 0 });
+    expect(calls).toEqual({ encode: 0, every: 0, includes: 0, iterator: 0, some: 0, test: 0 });
+  });
+
+  it('serializes detached auction data without invoking inherited toJSON hooks', () => {
+    const prepared = prepareProgrammaticAdUnits(unit(), new Set());
+    const context = Object.freeze({ segments: Object.freeze(['one']) });
+    const publisherHook = vi.fn(() => {
+      throw new Error('publisher toJSON hook');
+    });
+    Object.defineProperty(Object.prototype, 'toJSON', {
+      configurable: true,
+      value: publisherHook,
+    });
+    Object.defineProperty(Array.prototype, 'toJSON', {
+      configurable: true,
+      value: publisherHook,
+    });
+    let body: string | undefined;
+    try {
+      body = serializeAuctionRequestBody(prepared, context);
+    } finally {
+      Reflect.deleteProperty(Object.prototype, 'toJSON');
+      Reflect.deleteProperty(Array.prototype, 'toJSON');
+    }
 
-    const all = getAllUnits();
-    expect(all.length).toBe(1);
-    expect(firstSize(all[0])!.join('x')).toBe('320x50');
+    expect(publisherHook).not.toHaveBeenCalled();
+    expect(body).toBe(JSON.stringify({ adUnits: prepared, config: context }));
   });
 });
diff --git a/crates/trusted-server-js/lib/test/core/render.test.ts b/crates/trusted-server-js/lib/test/core/render.test.ts
index cc1da6e42..7eb3490e4 100644
--- a/crates/trusted-server-js/lib/test/core/render.test.ts
+++ b/crates/trusted-server-js/lib/test/core/render.test.ts
@@ -39,6 +39,131 @@ describe('render', () => {
     expect(sandbox).not.toContain('allow-same-origin');
   });
 
+  it('prepares and appends one exact ADM iframe with srcdoc already assigned', async () => {
+    const { ADM_IFRAME_SANDBOX, prepareAdmIframe } = await import('../../src/core/render');
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    const loaded = vi.fn();
+    const failed = vi.fn();
+    const observer = new MutationObserver(() => undefined);
+    observer.observe(container, { childList: true });
+    const handle = prepareAdmIframe({
+      adm: '<div>fictional ADM creative</div>',
+      container,
+      height: 250,
+      onError: failed,
+      onLoad: loaded,
+      width: 300,
+    });
+
+    expect(handle).toBeDefined();
+    if (!handle) throw new Error('should prepare an ADM iframe');
+    expect(handle.frame.parentNode).toBeNull();
+    expect(handle.frame.srcdoc).toContain('fictional ADM creative');
+    expect(handle.frame.hasAttribute('src')).toBe(false);
+    expect(handle.frame.getAttribute('sandbox')).toBe(ADM_IFRAME_SANDBOX);
+    expect(handle.frame.referrerPolicy).toBe('no-referrer');
+    expect(handle.frame.width).toBe('300');
+    expect(handle.frame.height).toBe('250');
+    expect(handle.frame.style.width).toBe('300px');
+    expect(handle.frame.style.height).toBe('250px');
+    expect(handle.append()).toBe(true);
+    expect(handle.append()).toBe(false);
+    const mutations = observer.takeRecords();
+    expect(mutations).toHaveLength(1);
+    const inserted = mutations[0]?.addedNodes.item(0) as HTMLIFrameElement | null;
+    expect(inserted).toBe(handle.frame);
+    expect(inserted?.srcdoc).toBe(handle.frame.srcdoc);
+    expect(inserted?.srcdoc.length).toBeGreaterThan(0);
+    expect(handle.activate()).toBe(true);
+    handle.frame.dispatchEvent(new Event('load'));
+    handle.frame.dispatchEvent(new Event('load'));
+    expect(loaded).toHaveBeenCalledOnce();
+    expect(failed).not.toHaveBeenCalled();
+    expect(handle.current()).toBe(true);
+    handle.dispose();
+    expect(handle.frame.isConnected).toBe(false);
+    observer.disconnect();
+  });
+
+  it('ignores a poisoned detached factory frame and rejects a pre-append load', async () => {
+    const { prepareAdmIframe } = await import('../../src/core/render');
+    const poisoned = document.createElement('iframe');
+    poisoned.title = 'publisher frame';
+    const unrelated = document.createElement('div');
+    document.body.appendChild(unrelated);
+    poisoned.remove = vi.fn(() => unrelated.remove());
+    Object.defineProperty(poisoned, 'srcdoc', {
+      configurable: true,
+      get: () => '<div>lie</div>',
+      set: vi.fn(),
+    });
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    const createElement = vi.spyOn(document, 'createElement').mockReturnValueOnce(poisoned);
+    const loaded = vi.fn();
+    const failed = vi.fn();
+
+    try {
+      const handle = prepareAdmIframe({
+        adm: '<div>exact creative</div>',
+        container,
+        height: 250,
+        onError: failed,
+        onLoad: loaded,
+        width: 300,
+      });
+      expect(handle).toBeDefined();
+      if (!handle) throw new Error('should prepare a native ADM iframe');
+      expect(createElement).not.toHaveBeenCalled();
+      expect(handle.frame).not.toBe(poisoned);
+      handle.frame.dispatchEvent(new Event('load'));
+      expect(handle.append()).toBe(true);
+      expect(handle.activate()).toBe(true);
+      expect(loaded).not.toHaveBeenCalled();
+      expect(failed).not.toHaveBeenCalled();
+      handle.dispose();
+      expect(poisoned.remove).not.toHaveBeenCalled();
+      expect(poisoned.title).toBe('publisher frame');
+      expect(unrelated.isConnected).toBe(true);
+    } finally {
+      createElement.mockRestore();
+    }
+  });
+
+  it('commits only predecessors and keeps the accepted frame exactly disposable', async () => {
+    const { prepareAdmIframe } = await import('../../src/core/render');
+    const container = document.createElement('div');
+    const predecessor = document.createElement('div');
+    const laterSibling = document.createElement('div');
+    container.appendChild(predecessor);
+    document.body.appendChild(container);
+    const handle = prepareAdmIframe({
+      adm: '<div>accepted creative</div>',
+      container,
+      height: 250,
+      onError: vi.fn(),
+      onLoad: vi.fn(),
+      width: 300,
+    });
+
+    expect(handle).toBeDefined();
+    if (!handle) throw new Error('should prepare an ADM iframe');
+    expect(handle.append()).toBe(true);
+    container.appendChild(laterSibling);
+    expect(handle.activate()).toBe(true);
+    handle.frame.dispatchEvent(new Event('load'));
+    expect(handle.commit()).toBe(true);
+    expect(predecessor.isConnected).toBe(false);
+    expect(laterSibling.isConnected).toBe(true);
+    expect(handle.frame.isConnected).toBe(true);
+
+    handle.dispose();
+    handle.dispose();
+    expect(handle.frame.isConnected).toBe(false);
+    expect(laterSibling.isConnected).toBe(true);
+  });
+
   it('preserves dollar sequences when building the creative document', async () => {
     const { buildCreativeDocument } = await import('../../src/core/render');
     const creativeHtml = "<div>$& $$ $1 $` $'</div>";
diff --git a/crates/trusted-server-js/lib/test/core/request.test.ts b/crates/trusted-server-js/lib/test/core/request.test.ts
index e88ed520c..a3afddf1c 100644
--- a/crates/trusted-server-js/lib/test/core/request.test.ts
+++ b/crates/trusted-server-js/lib/test/core/request.test.ts
@@ -1,507 +1,127 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { AdUnit } from '../../src/core/types';
+import { snapshotTsjsBootV1 } from '../../src/core/contracts/boot';
 import {
-  APS_PREBID_CREATIVE_RUNNER_URL,
-  APS_RENDERING_MODE_ATTRIBUTE_NAME,
-} from '../../src/integrations/aps/render';
-import envelope from '../fixtures/aps-renderer-v1.json';
-
-async function flushRequestAds(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-describe('request.requestAds', () => {
-  let originalFetch: typeof globalThis.fetch;
-
-  beforeEach(async () => {
-    await vi.resetModules();
-    document.body.innerHTML = '';
-    originalFetch = globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    vi.restoreAllMocks();
-  });
-
-  it('sends fetch and renders creatives via iframe from response', async () => {
-    // mock fetch - returns creative HTML inline in adm field
-    const creativeHtml = '<div>Test Creative</div>';
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'trusted-server',
-            bid: [{ impid: 'slot1', adm: creativeHtml, crid: 'creative-1' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { log } = await import('../../src/core/log');
-    const { requestAds } = await import('../../src/core/request');
-    const infoSpy = vi.spyOn(log, 'info').mockImplementation(() => undefined);
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(globalThis.fetch).toHaveBeenCalled();
-
-    // Verify iframe was created with creative HTML in srcdoc
-    const iframe = document.querySelector('#slot1 iframe') as HTMLIFrameElement | null;
-    expect(iframe).toBeTruthy();
-    expect(iframe!.srcdoc).toContain(creativeHtml);
-
-    const renderCall = infoSpy.mock.calls.find(
-      ([message]) => message === 'renderCreativeInline: rendered'
-    );
-    expect(renderCall?.[1]).toEqual(
-      expect.objectContaining({
-        slotId: 'slot1',
-        seat: 'trusted-server',
-        creativeId: 'creative-1',
-        originalLength: creativeHtml.length,
-      })
-    );
-  });
-
-  it('dispatches a valid APS descriptor to the opaque static renderer route', async () => {
-    const apsBid = envelope.seatbid[0].bid[0];
-    const renderer = {
-      type: 'aps',
-      version: 1,
-      accountId: 'example-account-id',
-      bidId: apsBid.id,
-      tagType: apsBid.ext.tagtype,
-      creativeUrl: apsBid.ext.creativeurl,
-      aaxResponse: btoa(JSON.stringify(envelope)),
-      width: apsBid.w,
-      height: apsBid.h,
-    };
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'aps',
-            bid: [
-              {
-                impid: 'slot1',
-                price: 1.23,
-                w: 300,
-                h: 250,
-                ext: { trusted_server: { renderer } },
-              },
-            ],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-    document.body.innerHTML = '<div id="slot1"><span>existing</span></div>';
-    addAdUnits({
-      code: 'slot1',
-      mediaTypes: { banner: { sizes: [[300, 250]] } },
-    } satisfies AdUnit);
-
-    requestAds();
-    await flushRequestAds();
-
-    const iframe = document.querySelector('#slot1 iframe') as HTMLIFrameElement | null;
-    expect(iframe).not.toBeNull();
-    expect(iframe!.src).toContain('/integrations/aps/renderer#tsaps=');
-    expect(iframe!.srcdoc).toBe('');
-    expect(iframe!.getAttribute('sandbox')).not.toContain('allow-same-origin');
-    expect(document.querySelector('#slot1 span')).not.toBeNull();
-
-    const postMessage = vi.spyOn(iframe!.contentWindow!, 'postMessage');
-    iframe!.dispatchEvent(new Event('load'));
-    expect(document.querySelector('#slot1 span')).not.toBeNull();
-    expect(postMessage).toHaveBeenCalledWith(expect.objectContaining({ renderer }), '*');
-
-    const message = postMessage.mock.calls[0][0] as { nonce: string };
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { message: 'trusted-server/aps/renderer-ready', nonce: message.nonce },
-        source: iframe!.contentWindow,
-      })
-    );
-    expect(document.querySelector('#slot1 span')).toBeNull();
+  canonicalIntegrationConfigDigestV1,
+  sha256HexUtf8V1,
+} from '../../src/core/contracts/integration_configs';
+import type { TsjsApi, TsjsBootV1 } from '../../src/core/types';
+import stringifyCorpus from '../fixtures/contracts/ecmascript-json-stringify-v1.json';
+
+const RELEASE = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+describe('server JSON.stringify canonicalization corpus', () => {
+  it.each(stringifyCorpus)('$name', ({ input, expected }) => {
+    const canonical = JSON.stringify(JSON.parse(input));
+    expect(canonical).toBe(expected);
+    expect(sha256HexUtf8V1(canonical)).toMatch(/^[0-9a-f]{64}$/);
   });
+});
 
-  it('contract test: renders a direct APS bid through the injected native runner', async () => {
-    const apsBid = envelope.seatbid[0].bid[0];
-    const renderer = {
-      type: 'aps' as const,
-      version: 1 as const,
-      accountId: 'example-account-id',
-      bidId: apsBid.id,
-      tagType: apsBid.ext.tagtype as 'iframe',
-      creativeUrl: apsBid.ext.creativeurl,
-      aaxResponse: btoa(JSON.stringify(envelope)),
-      width: apsBid.w,
-      height: apsBid.h,
-    };
-    const publisherScript = document.createElement('script');
-    publisherScript.setAttribute(APS_RENDERING_MODE_ATTRIBUTE_NAME, 'publisher_native');
-    const currentScriptSpy = vi
-      .spyOn(document, 'currentScript', 'get')
-      .mockReturnValue(publisherScript);
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'aps',
-            bid: [{ impid: 'slot1', ext: { trusted_server: { renderer } } }],
-          },
-        ],
-      }),
-    });
+function boot() {
+  return snapshotTsjsBootV1(
+    {
+      abi: 1,
+      releaseId: RELEASE,
+      manifest: {
+        version: 1,
+        releaseId: RELEASE,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: 'render_runtime', phase: 'takeover' }],
+      },
+      auctionProjection: {
+        version: 1,
+        auction: { version: 1, auctionId: 'initial', results: [] },
+        slots: [],
+        bids: [],
+      },
+      integrations: { version: 1, entries: [] },
+      creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+      diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+    },
+    RELEASE
+  )!;
+}
 
-    try {
-      const { addAdUnits } = await import('../../src/core/registry');
-      const { requestAds } = await import('../../src/core/request');
-      currentScriptSpy.mockRestore();
-      document.body.innerHTML = '<div id="slot1"><span>existing</span></div>';
-      addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
+async function loadMinimalProductionRuntime(): Promise<void> {
+  await import('../../src/composition/runtime_transport');
+  await import('../../src/integrations/render_runtime/index');
+}
 
-      requestAds();
-      await flushRequestAds();
-      const frame = document.querySelector<HTMLIFrameElement>('#slot1 iframe')!;
-      const runner = frame.contentDocument?.querySelector<HTMLScriptElement>('script');
-      expect(runner).not.toBeNull();
-      const frameWindow = frame.contentWindow as unknown as {
-        _aps: Map<string, { queue: Array<CustomEvent<Record<string, string>>> }>;
-      };
-      const queued = frameWindow._aps.get(renderer.accountId)?.queue[0];
+function installRuntimeScript(): void {
+  const script = document.createElement('script');
+  script.id = 'trustedserver-js';
+  script.src = new URL(RUNTIME_SRC, window.location.origin).href;
+  document.head.append(script);
+  Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+}
 
-      expect(frame.getAttribute('sandbox')).toBeNull();
-      expect(runner!.src).toBe(APS_PREBID_CREATIVE_RUNNER_URL);
-      expect(queued?.type).toBe('prebid/creative/render');
-      expect(queued?.detail).toEqual({
-        aaxResponse: renderer.aaxResponse,
-        seatBidId: renderer.bidId,
+function installBootClaim(target: object, acceptedBoot: Readonly<TsjsBootV1>): void {
+  const source = document.currentScript as HTMLScriptElement;
+  Object.defineProperty(source, '_claimRuntimeV1', {
+    configurable: false,
+    enumerable: false,
+    value: (candidate: unknown) => {
+      if (candidate !== source || candidate !== document.currentScript) return undefined;
+      return Object.freeze({
+        source,
+        target,
+        boot: acceptedBoot,
+        complete: () => undefined,
+        currentScript: () => document.currentScript,
+        integrity: Object.freeze({
+          version: 1,
+          projectionDigest: sha256HexUtf8V1(JSON.stringify(acceptedBoot.auctionProjection)),
+          integrationConfigDigest: canonicalIntegrationConfigDigestV1(acceptedBoot.integrations),
+        }),
+        mode: 'direct',
+        bind: () => () => undefined,
       });
-      expect(document.querySelector('#slot1 span')).not.toBeNull();
-
-      runner!.dispatchEvent(new Event('load'));
-      await Promise.resolve();
-      expect(document.querySelector('#slot1 span')).toBeNull();
-      expect(frame.style.display).toBe('');
-    } finally {
-      currentScriptSpy.mockRestore();
-    }
-  });
-
-  it('does not mutate the slot for an invalid APS descriptor', async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'aps',
-            bid: [
-              {
-                impid: 'slot1',
-                ext: {
-                  trusted_server: {
-                    renderer: { type: 'aps', version: 1, aaxResponse: 'invalid' },
-                  },
-                },
-              },
-            ],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-    document.body.innerHTML = '<div id="slot1"><span>existing</span></div>';
-    addAdUnits({
-      code: 'slot1',
-      mediaTypes: { banner: { sizes: [[300, 250]] } },
-    } satisfies AdUnit);
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(document.querySelector('#slot1 iframe')).toBeNull();
-    expect(document.querySelector('#slot1 span')).not.toBeNull();
+    },
+    writable: false,
   });
-
-  it('does not render on non-JSON response', async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'text/plain' },
-      json: async () => ({}),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(globalThis.fetch).toHaveBeenCalled();
-    expect(document.querySelector('iframe')).toBeNull();
+  let sourceLive = true;
+  Object.defineProperty(window, 'tsjs', {
+    configurable: true,
+    enumerable: true,
+    get: () => {
+      if (!sourceLive) return target;
+      sourceLive = false;
+      return source;
+    },
   });
+}
 
-  it('ignores fetch rejection gracefully', async () => {
-    globalThis.fetch = vi.fn().mockRejectedValue(new Error('network-error'));
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(globalThis.fetch).toHaveBeenCalled();
-    expect(document.querySelector('iframe')).toBeNull();
-  });
-
-  it('inserts an iframe with creative HTML from unified auction', async () => {
-    // mock fetch for unified auction endpoint - returns inline HTML
-    const creativeHtml = '<img src="/first-party/proxy?tsurl=...">Ad</img>';
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'trusted-server',
-            bid: [{ impid: 'slot1', adm: creativeHtml, crid: 'creative-2' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    // Prepare slot in DOM
-    const div = document.createElement('div');
-    div.id = 'slot1';
-    document.body.appendChild(div);
-
-    // Add an ad unit and request
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-    requestAds();
-
-    await flushRequestAds();
-
-    // Verify iframe was inserted with creative HTML in srcdoc
-    const iframe = document.querySelector('#slot1 iframe') as HTMLIFrameElement | null;
-    expect(iframe).toBeTruthy();
-    expect(iframe!.srcdoc).toContain('<img src="/first-party/proxy?tsurl=...">');
-    expect(iframe!.srcdoc).toContain('Ad');
-  });
-
-  it('renders creatives with safe URI markup', async () => {
-    const creativeHtml =
-      '<a href="mailto:test@example.com">Contact</a><img src="https://example.com/ad.png" alt="ad">';
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'trusted-server',
-            bid: [{ impid: 'slot1', adm: creativeHtml, crid: 'creative-safe-uri' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    const iframe = document.querySelector('#slot1 iframe') as HTMLIFrameElement | null;
-    expect(iframe).toBeTruthy();
-    expect(iframe!.srcdoc).toContain('mailto:test@example.com');
-    expect(iframe!.srcdoc).toContain('https://example.com/ad.png');
-  });
-
-  it('rejects malformed non-string creative HTML without blanking the slot', async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'appnexus',
-            bid: [{ impid: 'slot1', adm: { html: '<div>bad</div>' }, crid: 'creative-invalid' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { log } = await import('../../src/core/log');
-    const { requestAds } = await import('../../src/core/request');
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => undefined);
-
-    document.body.innerHTML = '<div id="slot1"><span>existing</span></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(document.querySelector('#slot1 iframe')).toBeNull();
-    // Invalid-type rejection must not blank existing slot content.
-    expect(document.querySelector('#slot1')?.innerHTML).toBe('<span>existing</span>');
-
-    const rejectionCall = warnSpy.mock.calls.find(
-      ([message]) => message === 'renderCreativeInline: rejected creative'
-    );
-    expect(rejectionCall?.[1]).toEqual(
-      expect.objectContaining({
-        slotId: 'slot1',
-        seat: 'appnexus',
-        creativeId: 'creative-invalid',
-        rejectionReason: 'invalid-creative-html',
-      })
-    );
-    expect(JSON.stringify(rejectionCall)).not.toContain('[object Object]');
-  });
-
-  it('does not blank the slot when a later bid for the same slot is rejected', async () => {
-    // Regression: multi-bid scenario where a rejected bid must not erase an earlier
-    // successful render into the same slot.
-    const goodCreative = '<div>Safe Ad</div>';
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'seat-a',
-            bid: [{ impid: 'slot1', adm: goodCreative, crid: 'creative-good' }],
-          },
-          {
-            // Non-string adm is rejected client-side as invalid-creative-html.
-            seat: 'seat-b',
-            bid: [{ impid: 'slot1', adm: { html: '<div>bad</div>' }, crid: 'creative-bad' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    // The good creative should have rendered; the bad one should not have blanked it.
-    const iframe = document.querySelector('#slot1 iframe') as HTMLIFrameElement | null;
-    expect(iframe).toBeTruthy();
-    expect(iframe!.srcdoc).toContain(goodCreative);
+describe('hard-cutover requestAds API', () => {
+  beforeEach(async () => {
+    await vi.resetModules();
+    document.head.replaceChildren();
+    delete (window as unknown as { tsjs?: unknown }).tsjs;
+    installRuntimeScript();
   });
 
-  it('rejects creatives that sanitize to empty markup', async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            seat: 'appnexus',
-            bid: [{ impid: 'slot1', adm: '   ', crid: 'creative-empty' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { log } = await import('../../src/core/log');
-    const { requestAds } = await import('../../src/core/request');
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => undefined);
-
-    document.body.innerHTML = '<div id="slot1"></div>';
-    addAdUnits({ code: 'slot1', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-
-    requestAds();
-    await flushRequestAds();
-
-    expect(document.querySelector('#slot1 iframe')).toBeNull();
+  it('replaces a callback-era request function with the exact Promise result surface', async () => {
+    const legacyCallback = vi.fn();
+    const preload = {
+      boot: boot(),
+      que: [],
+      requestAds: legacyCallback,
+    };
+    installBootClaim(preload, preload.boot);
 
-    const rejectionCall = warnSpy.mock.calls.find(
-      ([message]) => message === 'renderCreativeInline: rejected creative'
-    );
-    expect(rejectionCall?.[1]).toEqual(
-      expect.objectContaining({
-        slotId: 'slot1',
-        seat: 'appnexus',
-        creativeId: 'creative-empty',
-        rejectionReason: 'empty-after-sanitize',
-      })
+    await loadMinimalProductionRuntime();
+    await vi.waitFor(() =>
+      expect((window as unknown as { tsjs?: TsjsApi }).tsjs?._internal?.state).toBe('kernel')
     );
-  });
-
-  it('skips iframe insertion when slot is missing', async () => {
-    // mock fetch for unified auction endpoint - returns inline HTML
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      status: 200,
-      headers: { get: () => 'application/json' },
-      json: async () => ({
-        seatbid: [
-          {
-            bid: [{ impid: 'missing-slot', adm: '<div>Creative for missing slot</div>' }],
-          },
-        ],
-      }),
-    });
-
-    const { addAdUnits } = await import('../../src/core/registry');
-    const { requestAds } = await import('../../src/core/request');
-
-    addAdUnits({ code: 'missing-slot', mediaTypes: { banner: { sizes: [[300, 250]] } } });
-    requestAds();
-
-    await flushRequestAds();
 
-    // No iframe should be inserted because the slot isn't present in DOM
-    const iframe = document.querySelector('iframe');
-    expect(iframe).toBeNull();
+    const api = (window as unknown as { tsjs: TsjsApi }).tsjs;
+    const result = api.requestAds();
+    expect(result).toBeInstanceOf(Promise);
+    await expect(result).resolves.toEqual({ slots: [] });
+    expect(legacyCallback).not.toHaveBeenCalled();
+    expect(api).not.toHaveProperty('renderAdUnit');
+    expect(api).not.toHaveProperty('renderAllAdUnits');
   });
 });
diff --git a/crates/trusted-server-js/lib/test/core/trace_runtime.test.ts b/crates/trusted-server-js/lib/test/core/trace_runtime.test.ts
new file mode 100644
index 000000000..10cc29133
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/core/trace_runtime.test.ts
@@ -0,0 +1,1380 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createRenderTraceStore,
+  DiagnosticsSubscriberLimitError,
+  type RenderTraceGptFactV1,
+  type RenderTracePresentationSource,
+  type RenderTraceRuntimeOptions,
+} from '../../src/core/trace';
+import {
+  createRenderTracePresentation,
+  TRACE_BADGE_CLASS,
+  TRACE_PANEL_ID,
+} from '../../src/integrations/gpt_diagnostics/presentation';
+
+function createPresentedRenderTrace(
+  options: RenderTraceRuntimeOptions & {
+    readonly document: Document;
+    readonly exportRecord?: (record: Readonly<Record<string, unknown>>) => void;
+    readonly overlayEnabled: boolean;
+  }
+) {
+  const owner = createRenderTraceStore({
+    ...options,
+    schedule:
+      options.schedule ??
+      ((callback) => {
+        callback();
+        return () => undefined;
+      }),
+  });
+  if (options.overlayEnabled) {
+    owner.attachPresentation((source) =>
+      createRenderTracePresentation(source, {
+        document: options.document,
+        ...(options.exportRecord === undefined ? {} : { exportRecord: options.exportRecord }),
+        ...(options.onPresentationError === undefined
+          ? {}
+          : { onError: options.onPresentationError }),
+      })
+    );
+  }
+  return owner;
+}
+
+function harness() {
+  const tasks: Array<() => void> = [];
+  const owner = createRenderTraceStore({
+    scheduler: {
+      set: (callback) => {
+        tasks.push(callback);
+        return callback;
+      },
+      clear: (handle) => {
+        const index = tasks.indexOf(handle as () => void);
+        if (index >= 0) tasks.splice(index, 1);
+      },
+    },
+  });
+  return {
+    owner,
+    tasks,
+    drain: (): void => {
+      while (tasks.length > 0) tasks.shift()?.();
+    },
+  };
+}
+
+describe('render trace diagnostics runtime', () => {
+  it('atomically adopts first-display sequence and impression high-water values once', () => {
+    const { owner } = harness();
+    const navigationGeneration = {};
+
+    expect(
+      owner.adoptFirstDisplay({
+        navigationGeneration,
+        nextSequence: 9,
+        slots: [
+          {
+            bindings: [
+              {
+                cycleOrdinal: 1,
+                historySequence: 8,
+                state: 'completed',
+                token: 'gt1_1',
+              },
+            ],
+            impressions: 3,
+            records: [
+              {
+                at: 4,
+                count: 3,
+                elementId: 'div-a',
+                injected: true,
+                path: 'ssat',
+                rendered: true,
+                seq: 8,
+                servedFrom: 'inline',
+                slotId: 'slot-a',
+              },
+            ],
+            slotId: 'slot-a',
+          },
+          { bindings: [], impressions: 0, records: [], slotId: 'slot-b' },
+        ],
+      })
+    ).toBe(true);
+
+    owner.observeGptFact(
+      {
+        kind: 'slotVisibilityChanged',
+        slot: { token: 'gt1_1', cycleOrdinal: 1, elementId: 'div-a' },
+        inViewPercentage: 75,
+      },
+      () => ({
+        elementId: 'div-a',
+        navigationGeneration,
+        slotId: 'slot-a',
+        traceToken: 'gt1_1',
+      })
+    );
+    expect(owner.diagnostics.current()['slot-a']).toMatchObject({
+      count: 3,
+      seq: 8,
+      visible: true,
+    });
+
+    expect(owner.record({ slotId: 'slot-a', path: 'gam-refresh', rendered: true })).toMatchObject({
+      count: 4,
+      seq: 9,
+    });
+    expect(owner.record({ slotId: 'slot-b', path: 'auction', rendered: false })).toMatchObject({
+      count: 1,
+      seq: 10,
+    });
+    expect(owner.adoptFirstDisplay({ navigationGeneration, nextSequence: 11, slots: [] })).toBe(
+      false
+    );
+  });
+
+  it('rejects malformed first-display trace adoption without partial mutation', () => {
+    const { owner } = harness();
+
+    expect(
+      owner.adoptFirstDisplay({
+        navigationGeneration: {},
+        nextSequence: 7,
+        slots: [
+          { bindings: [], impressions: 2, records: [], slotId: 'slot-a' },
+          { bindings: [], impressions: 1, records: [], slotId: 'slot-a' },
+        ],
+      })
+    ).toBe(false);
+    expect(owner.record({ slotId: 'slot-a', path: 'auction', rendered: true })).toMatchObject({
+      count: 1,
+      seq: 1,
+    });
+  });
+
+  it('exposes one exact frozen read-only public surface with copied snapshots', () => {
+    const { owner } = harness();
+    const target = window as unknown as { tsjs?: Record<string, unknown> };
+    const existingApi = (target.tsjs = {});
+    const event = vi.fn();
+    window.addEventListener('tsjs:adRendered', event);
+    const record = owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+
+    expect(Reflect.ownKeys(owner.diagnostics).sort()).toEqual(['current', 'history', 'subscribe']);
+    expect(Object.isFrozen(owner.diagnostics)).toBe(true);
+    const current = owner.diagnostics.current();
+    const history = owner.diagnostics.history();
+    expect(Object.isFrozen(current)).toBe(true);
+    expect(Object.isFrozen(history)).toBe(true);
+    expect(Object.isFrozen(current['slot-a'])).toBe(true);
+    expect(current['slot-a']).toEqual(record);
+    expect(current['slot-a']).not.toBe(record);
+    expect(history[0]).toEqual(record);
+    expect(history[0]).not.toBe(record);
+    expect(target.tsjs).toBe(existingApi);
+    expect(target.tsjs).toEqual({});
+    expect(event).not.toHaveBeenCalled();
+    window.removeEventListener('tsjs:adRendered', event);
+    delete target.tsjs;
+  });
+
+  it('commits before one asynchronous frozen public delivery', () => {
+    const { owner, tasks, drain } = harness();
+    const listener = vi.fn();
+    owner.diagnostics.subscribe(listener);
+
+    const record = owner.record({ slotId: 'slot-a', path: 'ssat', rendered: true });
+
+    expect(owner.diagnostics.current()['slot-a']).toEqual(record);
+    expect(listener).not.toHaveBeenCalled();
+    expect(tasks).toHaveLength(1);
+    drain();
+    expect(listener).toHaveBeenCalledTimes(1);
+    const delivered = listener.mock.calls[0]?.[0];
+    expect(delivered).toEqual(record);
+    expect(delivered).not.toBe(record);
+    expect(Object.isFrozen(delivered)).toBe(true);
+  });
+
+  it('enforces the 32-subscriber cap after callable validation and reuses capacity', () => {
+    const { owner } = harness();
+    const releases = Array.from({ length: 32 }, () => owner.diagnostics.subscribe(() => undefined));
+
+    expect(() => owner.diagnostics.subscribe(null as never)).toThrow(TypeError);
+    expect(() => owner.diagnostics.subscribe(() => undefined)).toThrowError(
+      expect.objectContaining({ code: 'subscriber_capacity', surface: 'renderTrace' })
+    );
+    expect(() => owner.diagnostics.subscribe(() => undefined)).toThrow(
+      DiagnosticsSubscriberLimitError
+    );
+    releases[0]?.();
+    releases[0]?.();
+    expect(owner.diagnostics.subscribe(() => undefined)).toBeTypeOf('function');
+  });
+
+  it('reserves an independent internal presentation subscription outside public capacity', () => {
+    const { owner, drain } = harness();
+    const publicListeners = Array.from({ length: 32 }, () => vi.fn());
+    const publicReleases = publicListeners.map((listener) => owner.diagnostics.subscribe(listener));
+    const presentationListener = vi.fn();
+    const disposePresentation = vi.fn();
+    const attachPresentation = (
+      owner as unknown as {
+        attachPresentation: (
+          factory: (source: {
+            current: typeof owner.diagnostics.current;
+            history: typeof owner.diagnostics.history;
+            subscribe: (listener: () => void) => () => void;
+          }) => Readonly<{ dispose: () => void }>
+        ) => () => void;
+      }
+    ).attachPresentation;
+    const detach = attachPresentation((source) => {
+      source.subscribe(presentationListener);
+      return Object.freeze({ dispose: disposePresentation });
+    });
+
+    expect(() => owner.diagnostics.subscribe(vi.fn())).toThrow(
+      expect.objectContaining({ code: 'subscriber_capacity', surface: 'renderTrace' })
+    );
+    owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+    drain();
+    expect(publicListeners.every((listener) => listener.mock.calls.length === 1)).toBe(true);
+    expect(presentationListener).toHaveBeenCalledOnce();
+
+    detach();
+    detach();
+    expect(disposePresentation).toHaveBeenCalledOnce();
+    publicReleases.forEach((release) => release());
+  });
+
+  it('makes retained presentation sources empty and inert immediately after detach', () => {
+    const { owner } = harness();
+    let retainedSource:
+      | Readonly<{
+          current: typeof owner.diagnostics.current;
+          history: typeof owner.diagnostics.history;
+          subscribe: (listener: () => void) => () => void;
+        }>
+      | undefined;
+    owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+    const detach = owner.attachPresentation((source) => {
+      retainedSource = source;
+      source.subscribe(() => undefined);
+      return Object.freeze({ dispose: vi.fn() });
+    });
+
+    expect(retainedSource?.current()).toHaveProperty('slot-a');
+    detach();
+    const current = retainedSource?.current();
+    const history = retainedSource?.history();
+    expect(current).toEqual({});
+    expect(Object.getPrototypeOf(current)).toBeNull();
+    expect(Object.isFrozen(current)).toBe(true);
+    expect(history).toEqual([]);
+    expect(Object.isFrozen(history)).toBe(true);
+    expect(() => retainedSource?.subscribe(() => undefined)).toThrow(TypeError);
+  });
+
+  it('preserves the first private presentation listener when a duplicate subscribe fails', () => {
+    const { owner, drain } = harness();
+    const first = vi.fn();
+    const second = vi.fn();
+    const detach = owner.attachPresentation((source) => {
+      source.subscribe(first);
+      expect(() => source.subscribe(second)).toThrow(
+        'render trace presentation subscription is unavailable'
+      );
+      return Object.freeze({ dispose: vi.fn() });
+    });
+
+    owner.record({ slotId: 'first-listener-slot', path: 'auction', rendered: true });
+    drain();
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).not.toHaveBeenCalled();
+    detach();
+  });
+
+  it('allows private presentation unsubscribe and resubscribe without reviving the first listener', () => {
+    const { owner, drain } = harness();
+    const first = vi.fn();
+    const second = vi.fn();
+    const detach = owner.attachPresentation((source) => {
+      const releaseFirst = source.subscribe(first);
+      releaseFirst();
+      releaseFirst();
+      source.subscribe(second);
+      return Object.freeze({ dispose: vi.fn() });
+    });
+
+    owner.record({ slotId: 'resubscribed-slot', path: 'auction', rendered: true });
+    drain();
+    expect(first).not.toHaveBeenCalled();
+    expect(second).toHaveBeenCalledOnce();
+    detach();
+  });
+
+  it('makes retained private presentation references inert after trace-owner disposal', () => {
+    const { owner } = harness();
+    const disposeControls = vi.fn();
+    let retainedSource: RenderTracePresentationSource | undefined;
+    let retainedUnsubscribe: (() => void) | undefined;
+    const detach = owner.attachPresentation((source) => {
+      retainedSource = source;
+      retainedUnsubscribe = source.subscribe(() => undefined);
+      return Object.freeze({ dispose: disposeControls });
+    });
+    owner.record({ slotId: 'owner-disposed-slot', path: 'auction', rendered: true });
+
+    owner.dispose();
+    expect(retainedSource?.current()).toEqual({});
+    expect(Object.getPrototypeOf(retainedSource?.current())).toBeNull();
+    expect(retainedSource?.history()).toEqual([]);
+    expect(() => retainedSource?.subscribe(() => undefined)).toThrow(TypeError);
+    expect(() => retainedUnsubscribe?.()).not.toThrow();
+    expect(() => detach()).not.toThrow();
+    expect(disposeControls).toHaveBeenCalledOnce();
+  });
+
+  it('coalesces zero, one, and two presentation updates without letting a hostile late task steal resubscribed work', () => {
+    const tasks: Array<() => void> = [];
+    const owner = createRenderTraceStore({
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => undefined;
+      },
+    });
+    const firstSnapshots: number[][] = [];
+    const secondSnapshots: number[][] = [];
+    let source: RenderTracePresentationSource | undefined;
+    let releaseFirst: (() => void) | undefined;
+    const detach = owner.attachPresentation((candidate) => {
+      source = candidate;
+      releaseFirst = candidate.subscribe(() =>
+        firstSnapshots.push(candidate.history().map(({ seq }) => seq))
+      );
+      return Object.freeze({ dispose: vi.fn() });
+    });
+
+    expect(tasks).toEqual([]);
+    owner.record({ slotId: 'one-update', path: 'auction', rendered: true });
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(firstSnapshots).toEqual([[1]]);
+
+    owner.record({ slotId: 'two-updates-a', path: 'auction', rendered: true });
+    owner.record({ slotId: 'two-updates-b', path: 'auction', rendered: true });
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(firstSnapshots).toEqual([[1], [1, 2, 3]]);
+
+    owner.record({ slotId: 'cancelled-update', path: 'auction', rendered: true });
+    const hostileLateTask = tasks.shift()!;
+    releaseFirst?.();
+    source?.subscribe(() => secondSnapshots.push(source!.history().map(({ seq }) => seq)));
+    owner.record({ slotId: 'resubscribed-update', path: 'auction', rendered: true });
+    expect(tasks).toHaveLength(1);
+    const currentTask = tasks.shift()!;
+    hostileLateTask();
+    expect(secondSnapshots).toEqual([]);
+    currentTask();
+    expect(secondSnapshots).toEqual([[1, 2, 3, 4, 5]]);
+    detach();
+  });
+
+  it.each(['factory throw', 'malformed controls', 'missing listener'] as const)(
+    'rolls back %s and permits a later presentation retry',
+    (failure) => {
+      const { owner } = harness();
+      const disposeCandidate = vi.fn();
+
+      expect(() =>
+        owner.attachPresentation((source) => {
+          if (failure === 'factory throw') throw new Error('fictional presentation failure');
+          if (failure !== 'missing listener') source.subscribe(() => undefined);
+          return Object.freeze(
+            failure === 'malformed controls'
+              ? { dispose: disposeCandidate, extra: true }
+              : { dispose: disposeCandidate }
+          ) as never;
+        })
+      ).toThrow();
+      expect(disposeCandidate).toHaveBeenCalledTimes(failure === 'factory throw' ? 0 : 1);
+
+      const retryDispose = vi.fn();
+      const detach = owner.attachPresentation((source) => {
+        source.subscribe(() => undefined);
+        return Object.freeze({ dispose: retryDispose });
+      });
+      detach();
+      expect(retryDispose).toHaveBeenCalledOnce();
+    }
+  );
+
+  it('validates callability before duplicate state and rejects reentrant attachment', () => {
+    const { owner } = harness();
+    const nestedFactory = vi.fn();
+    const detach = owner.attachPresentation((source) => {
+      expect(() => owner.attachPresentation(nestedFactory)).toThrow(
+        'render trace presentation is unavailable'
+      );
+      source.subscribe(() => undefined);
+      return Object.freeze({ dispose: vi.fn() });
+    });
+
+    expect(nestedFactory).not.toHaveBeenCalled();
+    expect(() => owner.attachPresentation(null as never)).toThrow(
+      'render trace presentation factory must be callable'
+    );
+    expect(() => owner.attachPresentation(() => Object.freeze({ dispose: vi.fn() }))).toThrow(
+      'render trace presentation is unavailable'
+    );
+    detach();
+  });
+
+  it('creates no DOM stamps, UI, or scheduled work before deferred presentation attaches', () => {
+    const slot = document.createElement('div');
+    slot.id = 'takeover-only-slot';
+    document.body.append(slot);
+    const { owner, tasks } = harness();
+
+    owner.record({
+      slotId: 'takeover-only-slot',
+      elementId: 'takeover-only-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+
+    expect(tasks).toEqual([]);
+    expect(slot.getAttributeNames().filter((name) => name.startsWith('data-ts-'))).toEqual([]);
+    expect(slot.querySelector('.ts-render-badge')).toBeNull();
+    expect(document.getElementById('ts-render-trace-panel')).toBeNull();
+    owner.dispose();
+    slot.remove();
+  });
+
+  it('captures membership per commit and suppresses unsubscribe before delivery', () => {
+    const { owner, drain } = harness();
+    const first = vi.fn();
+    const second = vi.fn();
+    const releaseFirst = owner.diagnostics.subscribe(first);
+    owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+    releaseFirst();
+    owner.diagnostics.subscribe(second);
+    drain();
+    expect(first).not.toHaveBeenCalled();
+    expect(second).not.toHaveBeenCalled();
+
+    owner.record({ slotId: 'slot-b', path: 'auction', rendered: true });
+    drain();
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  it('coalesces pending same-impression enrichment without changing FIFO order', () => {
+    const { owner, drain, tasks } = harness();
+    const received: Array<{ seq: number; injected?: boolean }> = [];
+    owner.diagnostics.subscribe((record) => received.push(record));
+    const first = owner.record({
+      slotId: 'slot-a',
+      path: 'ssat',
+      rendered: true,
+      injected: false,
+    });
+    const second = owner.record({ slotId: 'slot-b', path: 'auction', rendered: false });
+    owner.enrich(first!, { injected: true, servedFrom: 'pbs-cache' });
+
+    expect(tasks).toHaveLength(1);
+    drain();
+    expect(received.map(({ seq }) => seq)).toEqual([first!.seq, second!.seq]);
+    expect(received[0]).toEqual(expect.objectContaining({ injected: true }));
+  });
+
+  it('bounds current state and history and prunes navigation-owned slots', () => {
+    const { owner } = harness();
+    for (let index = 0; index < 256; index += 1) {
+      expect(
+        owner.record({ slotId: `slot-${index}`, path: 'auction', rendered: true })
+      ).toBeDefined();
+    }
+    owner.record({ slotId: 'slot-over-capacity', path: 'auction', rendered: true });
+    expect(Object.keys(owner.diagnostics.current())).toHaveLength(256);
+    owner.prune('slot-0');
+    expect(owner.diagnostics.current()).not.toHaveProperty('slot-0');
+    owner.record({ slotId: 'slot-after-prune', path: 'auction', rendered: true });
+
+    for (let index = 0; index < 10; index += 1) {
+      owner.record({ slotId: 'slot-1', path: 'gam-refresh', rendered: index % 2 === 0 });
+    }
+    const history = owner.diagnostics.history();
+    expect(history).toHaveLength(200);
+    expect(history[0]?.seq).toBeGreaterThan(1);
+  });
+
+  it('retains a bounded document-lifetime slot count after current-state pruning', () => {
+    const { owner } = harness();
+    const first = owner.record({ slotId: 'reused-slot', path: 'auction', rendered: true })!;
+
+    expect(owner.prune('reused-slot', first.seq)).toBe(true);
+    const second = owner.record({ slotId: 'reused-slot', path: 'gam-refresh', rendered: false })!;
+
+    expect(second.count).toBe(2);
+  });
+
+  it('evicts the counter paired with current-state rollover without resetting retained slots', () => {
+    const { owner } = harness();
+    for (let index = 0; index < 256; index += 1) {
+      owner.record({ slotId: `slot-${index}`, path: 'auction', rendered: true });
+    }
+    const refreshedA = owner.record({ slotId: 'slot-0', path: 'ssat', rendered: true })!;
+    expect(refreshedA.count).toBe(2);
+
+    owner.record({ slotId: 'slot-256', path: 'auction', rendered: true });
+    expect(owner.diagnostics.current()).not.toHaveProperty('slot-0');
+    const refreshedB = owner.record({ slotId: 'slot-1', path: 'ssat', rendered: true })!;
+
+    expect(refreshedB.count).toBe(2);
+    expect(owner.diagnostics.current()['slot-1']?.count).toBe(2);
+    expect(Object.values(owner.diagnostics.current()).every(({ count }) => count >= 1)).toBe(true);
+  });
+
+  it('keeps a slot count monotonic across current-state and counter-capacity churn', () => {
+    const { owner } = harness();
+    const first = owner.record({ slotId: 'reused-slot', path: 'auction', rendered: true })!;
+    expect(owner.prune('reused-slot', first.seq)).toBe(true);
+    const second = owner.record({ slotId: 'reused-slot', path: 'ssat', rendered: true })!;
+    expect(second.count).toBe(2);
+    expect(owner.prune('reused-slot', second.seq)).toBe(true);
+
+    for (let index = 0; index < 255; index += 1) {
+      owner.record({ slotId: `capacity-${index}`, path: 'auction', rendered: true });
+    }
+    owner.record({ slotId: 'capacity-255', path: 'auction', rendered: true });
+    const afterBoundedEviction = owner.record({
+      slotId: 'reused-slot',
+      path: 'auction',
+      rendered: true,
+    })!;
+
+    expect(afterBoundedEviction.count).toBe(3);
+  });
+
+  it('bounds SPA slot counters at exactly 768 with protected access-order eviction', () => {
+    const { owner } = harness();
+    for (let index = 0; index < 768; index += 1) {
+      owner.record({ slotId: `spa-slot-${index}`, path: 'auction', rendered: true });
+    }
+
+    const currentProtected = owner.record({
+      slotId: 'spa-slot-0',
+      path: 'ssat',
+      rendered: true,
+    });
+    expect(currentProtected?.count).toBe(2);
+    owner.record({ slotId: 'spa-slot-overflow-1', path: 'auction', rendered: true });
+    expect(owner.record({ slotId: 'spa-slot-0', path: 'ssat', rendered: true })?.count).toBe(3);
+    expect(owner.prune('spa-slot-0')).toBe(true);
+    owner.record({ slotId: 'spa-slot-overflow-2', path: 'auction', rendered: true });
+    expect(owner.record({ slotId: 'spa-slot-0', path: 'ssat', rendered: true })?.count).toBe(4);
+
+    expect(owner.record({ slotId: 'spa-slot-1', path: 'auction', rendered: true })?.count).toBe(1);
+  });
+
+  it('protects a dormant counter referenced by an exact GPT binding', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    owner.record({ slotId: 'bound-counter-slot', path: 'auction', rendered: true });
+    expect(owner.prune('bound-counter-slot')).toBe(true);
+    for (let index = 0; index < 200; index += 1) {
+      owner.record({ slotId: `binding-spa-slot-${index}`, path: 'auction', rendered: true });
+    }
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRequested',
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1 }),
+      }),
+      () =>
+        Object.freeze({
+          slotId: 'bound-counter-slot',
+          navigationGeneration,
+          traceToken: 'gt1_1',
+        })
+    );
+    for (let index = 200; index < 767; index += 1) {
+      owner.record({ slotId: `binding-spa-slot-${index}`, path: 'auction', rendered: true });
+    }
+
+    owner.record({ slotId: 'binding-spa-overflow', path: 'auction', rendered: true });
+
+    expect(
+      owner.record({ slotId: 'bound-counter-slot', path: 'auction', rendered: true })?.count
+    ).toBe(2);
+    expect(
+      owner.record({ slotId: 'binding-spa-slot-0', path: 'auction', rendered: true })?.count
+    ).toBe(1);
+  });
+
+  it('retains impression bookkeeping and refuses truth-weakening enrichment', () => {
+    const { owner } = harness();
+    const record = owner.record({
+      slotId: 'slot-a',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+    })!;
+
+    const enriched = owner.enrich(record, {
+      rendered: false,
+      injected: false,
+      visible: true,
+      servedFrom: 'pbs-cache',
+    })!;
+
+    expect(enriched).toEqual(
+      expect.objectContaining({
+        at: record.at,
+        count: record.count,
+        seq: record.seq,
+        rendered: true,
+        injected: true,
+        visible: true,
+        servedFrom: 'pbs-cache',
+      })
+    );
+    expect(owner.diagnostics.history()).toHaveLength(1);
+  });
+
+  it('records an unattributed GPT request as one GAM-refresh impression', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'publisher-slot',
+        elementId: 'publisher-slot',
+        navigationGeneration,
+        traceToken: 'gt1_1',
+        visible: true,
+      });
+
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRequested',
+        observedAtMs: 1,
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'publisher-slot' }),
+      }),
+      resolve
+    );
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRenderEnded',
+        observedAtMs: 2,
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'publisher-slot' }),
+        isEmpty: false,
+      }),
+      resolve
+    );
+
+    expect(owner.diagnostics.current()['publisher-slot']).toEqual(
+      expect.objectContaining({
+        path: 'gam-refresh',
+        rendered: true,
+        gamEmpty: false,
+        injected: false,
+        visible: true,
+        servedFrom: 'gam',
+      })
+    );
+    expect(owner.diagnostics.history()).toHaveLength(1);
+  });
+
+  it('reconciles a later trusted terminal into the GPT-first impression', () => {
+    const { owner, tasks, drain } = harness();
+    const listener = vi.fn();
+    const navigationGeneration = Object.freeze({});
+    const slot = Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'reverse-slot' });
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'reverse-slot',
+        elementId: 'reverse-slot',
+        navigationGeneration,
+        traceToken: 'gt1_1',
+        visible: true,
+      });
+    owner.diagnostics.subscribe(listener);
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', observedAtMs: 1, slot }), resolve);
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', observedAtMs: 2, slot, isEmpty: false }),
+      resolve
+    );
+    const provisional = owner.diagnostics.current()['reverse-slot'];
+    expect(provisional).toEqual(
+      expect.objectContaining({ path: 'gam-refresh', rendered: true, injected: false })
+    );
+
+    const terminal = owner.record({
+      slotId: 'reverse-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      bidder: 'trusted-bidder',
+      bidId: 'trusted-bid',
+      creativeId: 'trusted-creative',
+      servedFrom: 'pbs-cache',
+    })!;
+
+    expect(terminal).toEqual(
+      expect.objectContaining({
+        seq: provisional?.seq,
+        count: provisional?.count,
+        at: provisional?.at,
+        path: 'ssat',
+        bidder: 'trusted-bidder',
+        bidId: 'trusted-bid',
+        creativeId: 'trusted-creative',
+        servedFrom: 'pbs-cache',
+        rendered: true,
+        injected: true,
+        gamEmpty: false,
+      })
+    );
+    expect(owner.diagnostics.history()).toEqual([terminal]);
+    expect(tasks).toHaveLength(1);
+    drain();
+    expect(listener).toHaveBeenCalledOnce();
+    expect(listener).toHaveBeenCalledWith(
+      expect.objectContaining({ seq: terminal.seq, path: 'ssat' })
+    );
+
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotVisibilityChanged',
+        observedAtMs: 3,
+        slot,
+        inViewPercentage: 0,
+      }),
+      resolve
+    );
+    expect(owner.diagnostics.current()['reverse-slot']).toEqual(
+      expect.objectContaining({ seq: terminal.seq, path: 'ssat', visible: false })
+    );
+    expect(owner.diagnostics.history()).toHaveLength(1);
+  });
+
+  it('enriches only the same GPT impression without weakening TS placement truth', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const slot = Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'ts-slot' });
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'ts-slot',
+        elementId: 'ts-slot',
+        navigationGeneration,
+        traceToken: 'gt1_1',
+        visible: true,
+      });
+    owner.record({ slotId: 'ts-slot', path: 'gam-refresh', rendered: false, injected: false });
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', observedAtMs: 1, slot }), resolve);
+    const trusted = owner.record({
+      slotId: 'ts-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      servedFrom: 'pbs-cache',
+    })!;
+
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', observedAtMs: 2, slot, isEmpty: false }),
+      resolve
+    );
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', observedAtMs: 3, slot, isEmpty: true }),
+      resolve
+    );
+
+    expect(owner.diagnostics.history()).toHaveLength(2);
+    expect(owner.diagnostics.current()['ts-slot']).toEqual(
+      expect.objectContaining({
+        seq: trusted.seq,
+        path: 'ssat',
+        rendered: true,
+        injected: true,
+        gamEmpty: false,
+        servedFrom: 'pbs-cache',
+      })
+    );
+  });
+
+  it('routes all GPT lifecycle facts and scopes visibility to the active physical request', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    let currentTraceToken = 'gt1_1';
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'visible-slot',
+        navigationGeneration,
+        traceToken: currentTraceToken,
+        visible: false,
+      });
+    const fact = (
+      kind: RenderTraceGptFactV1['kind'],
+      token: string,
+      cycleOrdinal: number,
+      fields: Readonly<Pick<RenderTraceGptFactV1, 'isEmpty' | 'inViewPercentage'>> = Object.freeze(
+        {}
+      )
+    ): Readonly<RenderTraceGptFactV1> =>
+      Object.freeze({
+        kind,
+        observedAtMs: 1,
+        slot: Object.freeze({ token, cycleOrdinal }),
+        ...fields,
+      });
+
+    owner.observeGptFact(fact('slotRequested', 'gt1_1', 1), resolve);
+    owner.observeGptFact(fact('slotResponseReceived', 'gt1_1', 1), resolve);
+    owner.observeGptFact(fact('slotRenderEnded', 'gt1_1', 1, { isEmpty: false }), resolve);
+    owner.observeGptFact(fact('slotOnload', 'gt1_1', 1), resolve);
+    owner.observeGptFact(fact('impressionViewable', 'gt1_1', 1), resolve);
+    expect(owner.diagnostics.current()['visible-slot']?.visible).toBe(true);
+    owner.observeGptFact(
+      fact('slotVisibilityChanged', 'gt1_1', 1, { inViewPercentage: 0 }),
+      resolve
+    );
+    expect(owner.diagnostics.current()['visible-slot']?.visible).toBe(false);
+
+    currentTraceToken = 'gt1_2';
+    owner.observeGptFact(fact('slotRequested', 'gt1_2', 1), resolve);
+    owner.observeGptFact(fact('slotRenderEnded', 'gt1_1', 1, { isEmpty: true }), resolve);
+    owner.observeGptFact(fact('impressionViewable', 'gt1_1', 1), resolve);
+    owner.observeGptFact(fact('impressionViewable', 'gt1_2', 1), resolve);
+    expect(
+      owner.diagnostics.current()['visible-slot']?.visible,
+      'a pre-render callback for a replacement physical request must not enrich the old impression'
+    ).toBe(false);
+    expect(owner.diagnostics.history()).toHaveLength(1);
+  });
+
+  it('rejects late onload visibility resolved through a same-element physical replacement', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const firstSlot = Object.freeze({
+      token: 'gt1_1',
+      cycleOrdinal: 1,
+      elementId: 'reused-element',
+    });
+    const replacementSlot = Object.freeze({
+      token: 'gt1_2',
+      cycleOrdinal: 1,
+      elementId: 'reused-element',
+    });
+    const resolution = (traceToken: string, visible: boolean) =>
+      Object.freeze({
+        slotId: 'registered-slot',
+        elementId: 'reused-element',
+        navigationGeneration,
+        traceToken,
+        visible,
+      });
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', slot: firstSlot }), () =>
+      resolution('gt1_1', false)
+    );
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', slot: firstSlot, isEmpty: false }),
+      () => resolution('gt1_1', false)
+    );
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', slot: replacementSlot }), () =>
+      resolution('gt1_2', false)
+    );
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', slot: replacementSlot, isEmpty: false }),
+      () => resolution('gt1_2', false)
+    );
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotOnload', slot: firstSlot }), () =>
+      resolution('gt1_2', true)
+    );
+
+    expect(owner.diagnostics.history()).toEqual([
+      expect.objectContaining({ seq: 1, visible: false }),
+      expect.objectContaining({ seq: 2, visible: false }),
+    ]);
+    expect(owner.diagnostics.current()['registered-slot']).toEqual(
+      expect.objectContaining({ seq: 2, visible: false })
+    );
+  });
+
+  it('joins GPT enrichment by the exact token-cycle pair and enriches retired history only', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'refresh-slot',
+        navigationGeneration,
+        traceToken: 'gt1_1',
+        visible: false,
+      });
+    const fact = (
+      kind: RenderTraceGptFactV1['kind'],
+      cycleOrdinal: number,
+      fields: Readonly<Pick<RenderTraceGptFactV1, 'isEmpty'>> = Object.freeze({})
+    ): Readonly<RenderTraceGptFactV1> =>
+      Object.freeze({
+        kind,
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal }),
+        ...fields,
+      });
+
+    owner.observeGptFact(fact('slotRequested', 1), resolve);
+    owner.observeGptFact(fact('slotRenderEnded', 1, { isEmpty: false }), resolve);
+    owner.observeGptFact(fact('slotRequested', 2), resolve);
+    owner.observeGptFact(fact('slotRenderEnded', 2, { isEmpty: false }), resolve);
+    const beforeLate = owner.diagnostics.history();
+    expect(beforeLate).toHaveLength(2);
+    expect(beforeLate[0]?.visible).toBe(false);
+    expect(beforeLate[1]?.visible).toBe(false);
+
+    owner.observeGptFact(fact('impressionViewable', 1), resolve);
+    owner.observeGptFact(fact('impressionViewable', 3), resolve);
+
+    const afterLate = owner.diagnostics.history();
+    expect(afterLate[0]).toEqual(expect.objectContaining({ seq: 1, visible: true }));
+    expect(afterLate[1]).toEqual(expect.objectContaining({ seq: 2, visible: false }));
+    expect(owner.diagnostics.current()['refresh-slot']).toEqual(
+      expect.objectContaining({ seq: 2, visible: false })
+    );
+  });
+
+  it.each([
+    ['zero cycle', 'gt1_1', 0],
+    ['fractional cycle', 'gt1_1', 1.5],
+    ['overflow cycle', 'gt1_1', 4_294_967_296],
+    ['noncanonical token', 'gt1_01', 1],
+  ])('drops %s GPT trace identities', (_label, token, cycleOrdinal) => {
+    const { owner } = harness();
+
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRequested',
+        slot: Object.freeze({ token, cycleOrdinal }),
+      }),
+      () =>
+        Object.freeze({
+          slotId: 'invalid-slot',
+          navigationGeneration: Object.freeze({}),
+          traceToken: token,
+        })
+    );
+
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+  });
+
+  it('rejects a GPT request whose resolved physical token does not match', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const slot = Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'token-slot' });
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'token-slot',
+        navigationGeneration,
+        traceToken: 'gt1_2',
+      });
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', slot }), resolve);
+    owner.observeGptFact(Object.freeze({ kind: 'slotRenderEnded', slot, isEmpty: false }), resolve);
+
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+  });
+
+  it('admits exactly 256 live GPT impression bindings and refuses the 257th', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const facts = Array.from({ length: 257 }, (_, index) => {
+      const ordinal = index + 1;
+      const token = `gt1_${ordinal.toString(36)}`;
+      const elementId = `binding-slot-${ordinal}`;
+      const slot = Object.freeze({ token, cycleOrdinal: 1, elementId });
+      const resolve = () =>
+        Object.freeze({
+          slotId: elementId,
+          navigationGeneration,
+          traceToken: token,
+        });
+      return { resolve, slot };
+    });
+
+    for (const { resolve, slot } of facts) {
+      owner.observeGptFact(
+        Object.freeze({ kind: 'slotRequested', observedAtMs: 1, slot }),
+        resolve
+      );
+    }
+    for (let index = 0; index < 255; index += 1) {
+      const fact = facts[index]!;
+      owner.observeGptFact(
+        Object.freeze({
+          kind: 'slotRenderEnded',
+          observedAtMs: 2,
+          slot: fact.slot,
+          isEmpty: false,
+        }),
+        fact.resolve
+      );
+    }
+    expect(Object.keys(owner.diagnostics.current())).toHaveLength(255);
+
+    const atCapacity = facts[255]!;
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRenderEnded',
+        observedAtMs: 2,
+        slot: atCapacity.slot,
+        isEmpty: false,
+      }),
+      atCapacity.resolve
+    );
+    expect(Object.keys(owner.diagnostics.current())).toHaveLength(256);
+
+    const overflow = facts[256]!;
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRenderEnded',
+        observedAtMs: 2,
+        slot: overflow.slot,
+        isEmpty: false,
+      }),
+      overflow.resolve
+    );
+    expect(Object.keys(owner.diagnostics.current())).toHaveLength(256);
+    expect(owner.diagnostics.current()).not.toHaveProperty('binding-slot-257');
+  });
+
+  it('retires an open GPT binding on navigation disposal before it creates a row', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const slot = Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'open-slot' });
+    const resolve = () =>
+      Object.freeze({
+        slotId: 'open-slot',
+        navigationGeneration,
+        traceToken: 'gt1_1',
+      });
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', slot }), resolve);
+    expect(owner.pruneNavigation(navigationGeneration)).toBe(1);
+    owner.observeGptFact(Object.freeze({ kind: 'slotRenderEnded', slot, isEmpty: false }), resolve);
+
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+  });
+
+  it('retires an open GPT binding when its render can no longer resolve the slot', () => {
+    const { owner } = harness();
+    const navigationGeneration = Object.freeze({});
+    const slot = Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'stale-slot' });
+    const resolution = Object.freeze({
+      slotId: 'stale-slot',
+      navigationGeneration,
+      traceToken: 'gt1_1',
+    });
+
+    owner.observeGptFact(Object.freeze({ kind: 'slotRequested', slot }), () => resolution);
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', slot, isEmpty: false }),
+      () => undefined
+    );
+    owner.observeGptFact(
+      Object.freeze({ kind: 'slotRenderEnded', slot, isEmpty: false }),
+      () => resolution
+    );
+
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+  });
+
+  it('makes repeated retained record calls wholly inert after disposal', () => {
+    const now = vi.fn(() => 41);
+    const schedule = vi.fn(() => vi.fn());
+    const owner = createRenderTraceStore({ now, schedule });
+    const listener = vi.fn();
+    const resolve = vi.fn(() =>
+      Object.freeze({
+        slotId: 'disposed-binding-slot',
+        navigationGeneration: Object.freeze({}),
+        traceToken: 'gt1_1',
+      })
+    );
+    const retainedRecord = owner.record;
+    owner.diagnostics.subscribe(listener);
+    owner.record({ slotId: 'before-dispose', path: 'auction', rendered: true });
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRequested',
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1 }),
+      }),
+      resolve
+    );
+    owner.dispose();
+    now.mockClear();
+    schedule.mockClear();
+    listener.mockClear();
+    resolve.mockClear();
+    const reads = vi.fn();
+    const hostileInput = new Proxy(
+      { slotId: 'after-dispose', path: 'auction' as const, rendered: true },
+      {
+        get: (target, property, receiver) => (
+          reads(property),
+          Reflect.get(target, property, receiver)
+        ),
+      }
+    );
+
+    expect(retainedRecord(hostileInput)).toBeUndefined();
+    expect(retainedRecord(hostileInput)).toBeUndefined();
+    owner.observeGptFact(
+      Object.freeze({
+        kind: 'slotRenderEnded',
+        slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1 }),
+        isEmpty: false,
+      }),
+      resolve
+    );
+
+    expect(reads).not.toHaveBeenCalled();
+    expect(now).not.toHaveBeenCalled();
+    expect(schedule).not.toHaveBeenCalled();
+    expect(listener).not.toHaveBeenCalled();
+    expect(resolve).not.toHaveBeenCalled();
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+  });
+
+  it('drops the oldest of 201 pending records and cancels work on disposal', () => {
+    const { owner, tasks, drain } = harness();
+    const listener = vi.fn();
+    owner.diagnostics.subscribe(listener);
+    for (let index = 0; index < 201; index += 1) {
+      owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+    }
+    expect(tasks).toHaveLength(1);
+    drain();
+    expect(listener).toHaveBeenCalledTimes(200);
+    expect(listener.mock.calls[0]?.[0].seq).toBe(2);
+
+    owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+    expect(tasks).toHaveLength(1);
+    owner.dispose();
+    owner.dispose();
+    drain();
+    expect(listener).toHaveBeenCalledTimes(200);
+    const late = owner.record({ slotId: 'late', path: 'auction', rendered: true });
+    expect(late).toBeUndefined();
+    expect(owner.diagnostics.current()).toEqual({});
+    expect(owner.diagnostics.history()).toEqual([]);
+    expect(owner.diagnostics.subscribe(() => undefined)).toBeTypeOf('function');
+    expect(() => owner.diagnostics.subscribe(null as never)).toThrow(TypeError);
+  });
+
+  it('uses the server-resolved boot bit instead of reading the trace cookie', () => {
+    document.cookie = 'ts-trace=1; Path=/';
+    const disarmedSlot = document.createElement('div');
+    disarmedSlot.id = 'disarmed-slot';
+    document.body.append(disarmedSlot);
+    const disarmed = createPresentedRenderTrace({ document, overlayEnabled: false });
+
+    disarmed.record({
+      slotId: 'disarmed-slot',
+      elementId: 'disarmed-slot',
+      path: 'auction',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+
+    expect(disarmedSlot.getAttribute('data-ts-rendered')).toBeNull();
+    expect(disarmedSlot.querySelector(`.${TRACE_BADGE_CLASS}`)).toBeNull();
+    expect(document.getElementById(TRACE_PANEL_ID)).toBeNull();
+    disarmed.dispose();
+    disarmedSlot.remove();
+    document.cookie = 'ts-trace=; Max-Age=0; Path=/';
+
+    const armedSlot = document.createElement('div');
+    armedSlot.id = 'armed-slot';
+    document.body.append(armedSlot);
+    const armed = createPresentedRenderTrace({ document, overlayEnabled: true });
+    armed.record({
+      slotId: 'armed-slot',
+      elementId: 'armed-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+
+    const badge = armedSlot.querySelector(`.${TRACE_BADGE_CLASS}`) as HTMLElement | null;
+    expect(badge).not.toBeNull();
+    expect(badge?.style.pointerEvents).toBe('none');
+    expect(document.getElementById(TRACE_PANEL_ID)).not.toBeNull();
+    armed.dispose();
+    armedSlot.remove();
+  });
+
+  it('removes stale stamps and badges on a later physical impression', () => {
+    const slot = document.createElement('div');
+    slot.id = 'restamped-slot';
+    document.body.append(slot);
+    const owner = createPresentedRenderTrace({ document, overlayEnabled: true });
+    owner.record({
+      slotId: 'restamped-slot',
+      elementId: 'restamped-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      visible: true,
+      bidder: 'first-bidder',
+      admHash: 'first-hash',
+    });
+    expect(slot.getAttribute('data-ts-bidder')).toBe('first-bidder');
+    expect(slot.querySelector(`.${TRACE_BADGE_CLASS}`)).not.toBeNull();
+
+    owner.record({
+      slotId: 'restamped-slot',
+      elementId: 'restamped-slot',
+      path: 'gam-refresh',
+      rendered: true,
+      injected: true,
+      visible: false,
+    });
+
+    expect(slot.hasAttribute('data-ts-bidder')).toBe(false);
+    expect(slot.hasAttribute('data-ts-adm-hash')).toBe(false);
+    expect(slot.querySelector(`.${TRACE_BADGE_CLASS}`)).toBeNull();
+    owner.dispose();
+    expect(slot.hasAttribute('data-ts-slot-id')).toBe(false);
+    slot.remove();
+  });
+
+  it('stamps iframe slots without placing UI inside the creative frame', () => {
+    const iframe = document.createElement('iframe');
+    iframe.id = 'iframe-slot';
+    document.body.append(iframe);
+    const owner = createPresentedRenderTrace({ document, overlayEnabled: true });
+
+    owner.record({
+      slotId: 'iframe-slot',
+      elementId: 'iframe-slot',
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+
+    expect(iframe.getAttribute('data-ts-rendered')).toBe('true');
+    expect(iframe.querySelector(`.${TRACE_BADGE_CLASS}`)).toBeNull();
+    owner.dispose();
+    iframe.remove();
+  });
+
+  it('does not claim an ok badge before visibility is positively observed', () => {
+    const slot = document.createElement('div');
+    slot.id = 'unobserved-slot';
+    document.body.append(slot);
+    const owner = createPresentedRenderTrace({ document, overlayEnabled: true });
+
+    owner.record({
+      slotId: 'unobserved-slot',
+      elementId: 'unobserved-slot',
+      path: 'auction',
+      rendered: true,
+      injected: true,
+    });
+
+    expect(slot.querySelector(`.${TRACE_BADGE_CLASS}`)).toBeNull();
+    expect(document.getElementById(TRACE_PANEL_ID)?.textContent).toContain('hidden');
+    owner.dispose();
+    slot.remove();
+  });
+
+  it('does not claim or remove a publisher-owned overlay id collision', () => {
+    const publisherPanel = document.createElement('div');
+    publisherPanel.id = TRACE_PANEL_ID;
+    publisherPanel.textContent = 'publisher';
+    document.body.append(publisherPanel);
+    const owner = createPresentedRenderTrace({ document, overlayEnabled: true });
+
+    owner.record({ slotId: 'slot-a', path: 'auction', rendered: true });
+
+    expect(document.getElementById(TRACE_PANEL_ID)).toBe(publisherPanel);
+    expect(publisherPanel.textContent).toBe('publisher');
+    owner.dispose();
+    expect(document.getElementById(TRACE_PANEL_ID)).toBe(publisherPanel);
+    publisherPanel.remove();
+  });
+
+  it('keeps a bounded newest-first overlay and exports frozen row data', () => {
+    const exportRecord = vi.fn();
+    const tasks: Array<() => void> = [];
+    const owner = createPresentedRenderTrace({
+      document,
+      overlayEnabled: true,
+      exportRecord,
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => {
+          const index = tasks.indexOf(callback);
+          if (index >= 0) tasks.splice(index, 1);
+        };
+      },
+    });
+    for (let index = 1; index <= 201; index += 1) {
+      owner.record({ slotId: `slot-${index}`, path: 'auction', rendered: true });
+    }
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(tasks).toEqual([]);
+
+    const panel = document.getElementById(TRACE_PANEL_ID)!;
+    const rows = [...panel.querySelectorAll<HTMLElement>('[data-ts-trace-seq]')];
+    expect(rows).toHaveLength(200);
+    expect(rows[0]?.dataset['tsTraceSeq']).toBe('201');
+    expect(rows[rows.length - 1]?.dataset['tsTraceSeq']).toBe('2');
+    rows[0]?.click();
+    expect(exportRecord).toHaveBeenCalledOnce();
+    expect(exportRecord).toHaveBeenCalledWith(
+      expect.objectContaining({ slotId: 'slot-201', seq: 201 })
+    );
+    expect(Object.isFrozen(exportRecord.mock.calls[0]?.[0])).toBe(true);
+    owner.dispose();
+    expect(document.getElementById(TRACE_PANEL_ID)).toBeNull();
+  }, 15_000);
+
+  it('isolates presentation failures after committing diagnostics state', () => {
+    const onPresentationError = vi.fn();
+    const hostileDocument = {
+      getElementById: () => {
+        throw new Error('hostile document');
+      },
+    } as unknown as Document;
+    const owner = createPresentedRenderTrace({
+      document: hostileDocument,
+      overlayEnabled: true,
+      onPresentationError,
+    });
+
+    expect(() => owner.record({ slotId: 'slot-a', path: 'auction', rendered: true })).not.toThrow();
+    expect(owner.diagnostics.current()['slot-a']).toEqual(
+      expect.objectContaining({ slotId: 'slot-a', rendered: true })
+    );
+    expect(onPresentationError).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/eslint/no-adtech-globals.test.mjs b/crates/trusted-server-js/lib/test/eslint/no-adtech-globals.test.mjs
new file mode 100644
index 000000000..396781a4d
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/eslint/no-adtech-globals.test.mjs
@@ -0,0 +1,351 @@
+import assert from 'node:assert/strict';
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import test from 'node:test';
+
+import { ESLint, Linter } from 'eslint';
+import ts from 'typescript';
+
+import noAdtechGlobals from '../../eslint-rules/no-adtech-globals.js';
+import { ARCHITECTURE_INTEGRATION_DIRECTORIES } from '../../eslint.config.js';
+
+const ruleId = 'tsjs/no-adtech-globals';
+const packageRoot = path.resolve(import.meta.dirname, '../..');
+
+function lint(source, filename = 'src/kernel/new-runtime.js') {
+  const linter = new Linter({ configType: 'flat' });
+
+  return linter.verify(
+    source,
+    [
+      {
+        files: ['**/*.js', '**/*.ts', '**/*.tsx'],
+        languageOptions: {
+          ecmaVersion: 'latest',
+          sourceType: 'module',
+          globals: {
+            globalThis: 'readonly',
+            self: 'readonly',
+            window: 'readonly',
+          },
+        },
+        plugins: {
+          tsjs: {
+            rules: {
+              'no-adtech-globals': noAdtechGlobals,
+            },
+          },
+        },
+        rules: {
+          [ruleId]: 'error',
+        },
+      },
+    ],
+    { filename }
+  );
+}
+
+function assertRejected(source, filename) {
+  const messages = lint(source, filename);
+  assert.ok(messages.length > 0, `expected an ad-tech-global error for: ${source}`);
+  assert.ok(messages.every((message) => message.ruleId === ruleId));
+  assert.ok(messages.every((message) => message.messageId === 'externalGlobalOwnedByAdapter'));
+}
+
+async function collectRelativeModuleGraph(entry) {
+  const pending = [path.resolve(packageRoot, entry)];
+  const visited = new Set();
+  while (pending.length > 0) {
+    const filename = pending.pop();
+    if (!filename || visited.has(filename)) continue;
+    visited.add(filename);
+    const source = await readFile(filename, 'utf8');
+    const sourceFile = ts.createSourceFile(filename, source, ts.ScriptTarget.Latest, false);
+    for (const statement of sourceFile.statements) {
+      const moduleSpecifier =
+        (ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) &&
+        statement.moduleSpecifier &&
+        ts.isStringLiteral(statement.moduleSpecifier)
+          ? statement.moduleSpecifier.text
+          : undefined;
+      if (!moduleSpecifier?.startsWith('.')) continue;
+      const unresolved = path.resolve(path.dirname(filename), moduleSpecifier);
+      const candidates = [
+        unresolved,
+        `${unresolved}.ts`,
+        `${unresolved}.tsx`,
+        path.join(unresolved, 'index.ts'),
+      ];
+      let resolved;
+      for (const candidate of candidates) {
+        try {
+          await readFile(candidate, 'utf8');
+          resolved = candidate;
+          break;
+        } catch {
+          // Try the next TypeScript module resolution candidate.
+        }
+      }
+      assert.ok(resolved, `could not resolve ${moduleSpecifier} from ${filename}`);
+      pending.push(resolved);
+    }
+  }
+  return [...visited].map((filename) => path.relative(packageRoot, filename).replaceAll('\\', '/'));
+}
+
+test('rejects direct GPT and Prebid access through every browser global root', () => {
+  for (const source of [
+    'window.googletag.cmd.push(run);',
+    "globalThis['pbjs'].requestBids();",
+    'window[`googletag`].cmd.push(run);',
+    'self.googletag?.pubads();',
+    'googletag.cmd.push(run);',
+    'pbjs.requestBids();',
+  ]) {
+    assertRejected(source);
+  }
+});
+
+test('rejects same-file aliases of roots and external objects', () => {
+  for (const source of [
+    'const root = window; root.googletag.cmd.push(run);',
+    'const first = globalThis; const second = first; second.pbjs.requestBids();',
+    'let root; root = self; root.googletag.pubads();',
+    'const tag = window.googletag; tag.cmd.push(run);',
+    'const prebid = globalThis.pbjs; prebid.requestBids();',
+    'const { googletag: tag } = window; tag.cmd.push(run);',
+    'const { pbjs: prebid } = self; prebid.requestBids();',
+    'const { googletag } = window;',
+    "let prebid; ({ ['pbjs']: prebid } = globalThis);",
+    'let root; ({ window: root } = globalThis); root.pbjs.requestBids();',
+    'const { ...root } = window; root.googletag.cmd.push(run);',
+    'const root = (0, window); root.pbjs.requestBids();',
+    'class Owner { bind() { this.root = window; } read() { return this.root.googletag; } }',
+    'class Owner { root = window; read() { return this.root.pbjs; } }',
+    'class Owner { bind() { this.root = this.root ?? window; } read() { return this.root.pbjs; } }',
+    'class Owner { #root = window; read() { return this.#root.googletag; } }',
+    'function inspect(root = window) { return root.googletag; }',
+    'function inspect({ window: root } = globalThis) { return root.pbjs; }',
+    'for (const root of [window]) { root.googletag; }',
+    'let root; for (root of [globalThis]) { root.pbjs; }',
+  ]) {
+    assertRejected(source);
+  }
+});
+
+test('is scope-aware and permits unrelated shadowed values', () => {
+  assert.deepEqual(
+    lint(`
+      function inspect(window, globalThis, self, googletag, pbjs) {
+        window.googletag;
+        globalThis.pbjs;
+        self.googletag;
+        googletag.cmd;
+        pbjs.requestBids;
+      }
+      void inspect;
+    `),
+    []
+  );
+  assert.deepEqual(
+    lint(`
+      const values = [window];
+      values.googletag;
+      [window].pbjs;
+    `),
+    []
+  );
+  assert.deepEqual(
+    lint(`
+      class SelfReference {
+        bind() { this.root = this.root; }
+        read() { return this.root.googletag; }
+      }
+      void SelfReference;
+    `),
+    []
+  );
+  assert.deepEqual(
+    lint(`
+      class BrowserState { bind() { this.root = window; } }
+      class LocalState {
+        constructor() { this.root = { googletag: 'local' }; }
+        read() { return this.root.googletag; }
+      }
+      void BrowserState;
+      void LocalState;
+    `),
+    []
+  );
+  assert.deepEqual(
+    lint(`
+      class LocalState {
+        constructor() { this.window = { googletag: 'local' }; }
+        read() { return this.window.googletag; }
+      }
+      void LocalState;
+    `),
+    []
+  );
+});
+
+test('permits TSJS API and messaging access outside adapters', () => {
+  assert.deepEqual(
+    lint(`
+      window.tsjs?.requestAds();
+      globalThis.window?.postMessage({ type: 'TSJS_V1' }, '*');
+      self.addEventListener('message', onMessage, { capture: true });
+    `),
+    []
+  );
+});
+
+test('permits external-global ownership only in adapter source files', () => {
+  assert.deepEqual(
+    lint('const root = window; root.googletag; globalThis.pbjs;', 'src/adapters/googletag.js'),
+    []
+  );
+  assert.deepEqual(
+    lint('const root = window; root.googletag;', 'src/first_display/adapters/googletag.ts'),
+    []
+  );
+  assertRejected('window.googletag;', 'src/adapters-pretender/googletag.js');
+  assertRejected('window.googletag;', 'src/first_display/leaf/gpt_protocol.ts');
+});
+
+test('integration entrypoints have no ad-tech-global exemption', () => {
+  assertRejected('window.googletag;', 'src/integrations/gpt/index.ts');
+  assertRejected('globalThis.pbjs;', 'src/integrations/prebid/index.ts');
+});
+
+test('restricted paths enforce dependency direction and exact target-file exemptions', async () => {
+  const eslint = new ESLint({ cwd: packageRoot });
+  const restrictedRuleId = 'import-x/no-restricted-paths';
+
+  async function restrictedMessages(source, relativeFilename) {
+    const [result] = await eslint.lintText(source, {
+      filePath: path.join(packageRoot, relativeFilename),
+    });
+    assert.ok(result);
+    assert.equal(result.fatalErrorCount, 0);
+    return result.messages.filter((message) => message.ruleId === restrictedRuleId);
+  }
+
+  async function projectRuleMessages(source, relativeFilename, projectRuleId) {
+    const [result] = await eslint.lintText(source, {
+      filePath: path.join(packageRoot, relativeFilename),
+    });
+    assert.ok(result);
+    assert.equal(result.fatalErrorCount, 0);
+    return result.messages.filter((message) => message.ruleId === projectRuleId);
+  }
+
+  assert.ok(
+    (await restrictedMessages("import '../integrations/aps/render';", 'src/core/new-request.ts'))
+      .length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../adapters/googletag';", 'src/kernel/probe.tsx')).length > 0
+  );
+  assert.ok(
+    (
+      await projectRuleMessages(
+        'window.googletag;',
+        'src/kernel/probe.tsx',
+        'tsjs/no-adtech-globals'
+      )
+    ).length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../adapters/googletag';", 'src/core/new-index.ts')).length >
+      0
+  );
+  assert.ok((await restrictedMessages("import '../index';", 'src/adapters/probe.ts')).length > 0);
+  assert.ok(
+    (await restrictedMessages("import '../core/log.js';", 'src/adapters/probe.ts')).length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../index.js';", 'src/adapters/probe.ts')).length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../adapters/googletag.js';", 'src/kernel/probe.ts')).length >
+      0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../core/types';", 'src/adapters/new-adapter.ts')).length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../core/types';", 'src/services/new-service.ts')).length > 0
+  );
+  assert.ok(
+    (
+      await restrictedMessages(
+        "import '../composition/runtime_transport';",
+        'src/kernel/new-runtime.ts'
+      )
+    ).length > 0
+  );
+  assert.ok(
+    (
+      await restrictedMessages(
+        "import '../../composition/runtime_transport';",
+        'src/integrations/gpt/new-module.ts'
+      )
+    ).length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../prebid/index';", 'src/integrations/gpt/new-module.ts'))
+      .length > 0
+  );
+
+  assert.ok(
+    (await restrictedMessages("import '../integrations/aps/render';", 'src/core/request.ts'))
+      .length > 0
+  );
+  assert.ok(
+    (await restrictedMessages("import '../integrations/aps/render';", 'src/kernel/request.ts'))
+      .length > 0
+  );
+  assert.deepEqual(
+    await restrictedMessages("import '../adapters/googletag';", 'src/composition/new-browser.ts'),
+    []
+  );
+  assert.deepEqual(
+    await restrictedMessages("import './script_guard';", 'src/integrations/gpt/new-module.ts'),
+    []
+  );
+});
+
+test('generated bootstrap source graph excludes APS integration implementation', async () => {
+  const graph = await collectRelativeModuleGraph('src/core/bootstrap.ts');
+
+  assert.ok(graph.includes('src/core/release_id.ts'));
+  assert.deepEqual(
+    graph.filter((filename) => filename.startsWith('src/integrations/aps/')),
+    []
+  );
+});
+
+test('every current integration directory participates in cross-integration isolation', async () => {
+  const entries = await readdir(path.join(packageRoot, 'src/integrations'), {
+    withFileTypes: true,
+  });
+  const actual = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+
+  assert.deepEqual(actual, [...ARCHITECTURE_INTEGRATION_DIRECTORIES].sort());
+});
+
+test('documents exotic global-analysis blind spots and the defense-in-depth layers', async () => {
+  const source = await readFile(
+    path.join(packageRoot, 'eslint-rules/no-adtech-globals.js'),
+    'utf8'
+  );
+
+  assert.match(source, /computed composition/u);
+  assert.match(source, /function-returned roots/u);
+  assert.match(source, /bundle\/source scans/u);
+  assert.match(source, /browser ownership tests/u);
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/adm_render_bridge.test.ts b/crates/trusted-server-js/lib/test/first_display/adm_render_bridge.test.ts
new file mode 100644
index 000000000..0624b86e1
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/adm_render_bridge.test.ts
@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+
+import type { FirstDisplayGptBoundCycleV1 } from '../../src/first_display/adapters/googletag';
+
+import { createTestFirstDisplayRenderBridge } from './helpers/render_owner_composition';
+
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+function harness() {
+  const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+    url: 'https://publisher.example/',
+  });
+  const element = dom.window.document.getElementById('slot-1');
+  if (!(element instanceof dom.window.HTMLElement)) throw new Error('missing fixture element');
+  const cycle: FirstDisplayGptBoundCycleV1 = Object.freeze([
+    Object.freeze({
+      candidateId: 'candidate001',
+      slot: 'slot-1',
+      provider: 'example',
+      upstreamBidId: 'upstream-1',
+      cpm: 1.25,
+      currency: 'USD' as const,
+      targeting: Object.freeze({}),
+      rendererReservationId: RESERVATION_ID,
+      renderSource: Object.freeze({
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>fictional creative</main>',
+        width: 300,
+        height: 250,
+      }),
+    }),
+    element,
+    () => true,
+    'trusted_server',
+    {},
+    Object.freeze({
+      slot: 'slot-1',
+      gamUnitPath: '/123/example',
+      divId: 'slot-1',
+      formats: Object.freeze([Object.freeze([300, 250] as const)]),
+      targeting: Object.freeze({}),
+    }),
+    'slot-1',
+    'gt1_1',
+  ]);
+  const timers = new Map<object, () => void>();
+  let now = 0;
+  const terminal = vi.fn();
+  const mutation = vi.fn(() => true);
+  const bridge = createTestFirstDisplayRenderBridge({
+    browser: dom.window as unknown as Window,
+    clearTimer: (handle) => timers.delete(handle as object),
+    createChannel: () => {
+      throw new Error('ADM fallback must not create an owner channel');
+    },
+    document: dom.window.document,
+    fillRandom: () => undefined,
+    getAps: () => undefined,
+    now: () => now,
+    onNativeMutation: mutation,
+    setTimer: (callback) => {
+      const handle = {};
+      timers.set(handle, callback);
+      return handle;
+    },
+  });
+  expect(bridge.bind(cycle, terminal)).toBe(true);
+  return {
+    bridge,
+    cycle,
+    dom,
+    element,
+    mutation,
+    setNow: (value: number) => {
+      now = value;
+    },
+    terminal,
+    timers,
+  };
+}
+
+describe('ADM-only shared first-display render journal', () => {
+  it('owns only the attributable empty-GAM ADM frame and transfers it once', () => {
+    const h = harness();
+
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    expect(frame?.srcdoc).toContain('fictional creative');
+    frame?.dispatchEvent(new h.dom.window.Event('load'));
+    expect(h.terminal).toHaveBeenCalledWith('accepted', null);
+
+    h.bridge.sealTsAdmission();
+    expect(h.bridge.closeIngress()).toBe(true);
+    expect(h.bridge.captureHandoff()?.[0]).toEqual([
+      [null, null, frame, 'gpt_adm', 'trusted_server', 'slot-1', RESERVATION_ID],
+    ]);
+    expect(h.bridge.detachCommittedArtifacts()).toBe(true);
+    h.bridge.dispose();
+    expect(frame?.isConnected).toBe(true);
+  });
+
+  it('retires one accepted ADM frame without repeating terminal settlement', () => {
+    const h = harness();
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    frame?.dispatchEvent(new h.dom.window.Event('load'));
+    expect(h.terminal).toHaveBeenCalledOnce();
+
+    expect(h.bridge.retire(h.cycle)).toBe(true);
+    expect(h.bridge.retire(h.cycle)).toBe(false);
+    expect(frame?.isConnected).toBe(false);
+    expect(h.terminal).toHaveBeenCalledOnce();
+  });
+
+  it('fails the owned frame at the bounded load deadline and rejects APS input', () => {
+    const h = harness();
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    expect(h.timers).toHaveLength(1);
+    [...h.timers.values()][0]?.();
+    expect(h.terminal).toHaveBeenCalledWith('failed', 'adm_document_no_load');
+    expect(h.element.querySelector('iframe')).toBeNull();
+
+    const aps = Object.freeze({
+      ...h.cycle,
+      bid: Object.freeze({
+        ...h.cycle[0],
+        rendererReservationId: `r1_${'b'.repeat(22)}`,
+        renderSource: Object.freeze({
+          type: 'aps' as const,
+          version: 1 as const,
+          accountId: 'publisher-account',
+          bidId: 'bid-1',
+          tagType: 'iframe' as const,
+          creativeUrl: 'https://creative.example/render',
+          width: 300,
+          height: 250,
+          aaxResponse: 'renderer-envelope',
+        }),
+      }),
+    });
+    expect(h.bridge.bind(aps, vi.fn())).toBe(false);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/agent.test.ts b/crates/trusted-server-js/lib/test/first_display/agent.test.ts
new file mode 100644
index 000000000..81856e587
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/agent.test.ts
@@ -0,0 +1,922 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  createFirstDisplayAgent,
+  prepareFirstDisplayBase,
+  type FirstDisplayAgentOptions,
+  type FirstDisplayAgentRegistrationHostV1,
+  type FirstDisplayBatchOutcomeV1,
+  type FirstDisplayDriver,
+  type FirstDisplayTerminalResult,
+} from '../../src/first_display/agent';
+import type { FirstDisplayRenderBridgeCapabilityV1 } from '../../src/first_display/driver';
+import type { FirstDisplayGptProtocolV1 } from '../../src/first_display/leaf/gpt_protocol';
+import type {
+  FirstDisplayGoogletagBatchCallbacks,
+  FirstDisplayGoogletagBatchInput,
+  FirstDisplayGptBoundCycleV1,
+} from '../../src/first_display/adapters/googletag';
+import { snapshotFirstDisplayBatchV1 } from '../../src/first_display/leaf/projection';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import { finalizeFirstDisplayAgentCaptureV1 } from '../../src/shared/first_display_handoff';
+
+function batch(
+  kinds: readonly ('no_bid' | 'failed' | 'gpt_adm' | 'aps')[]
+): Readonly<Record<string, unknown>> {
+  const decisions: object[] = [];
+  const slots: object[] = [];
+  const bids: object[] = [];
+  let winner = 0;
+  for (let index = 0; index < kinds.length; index += 1) {
+    const kind = kinds[index];
+    const slot = `slot-${index}`;
+    slots.push(
+      Object.freeze({
+        slot,
+        gamUnitPath: `/123/example-${index}`,
+        divId: slot,
+        formats: Object.freeze([Object.freeze([300, 250])]),
+        targeting: Object.freeze({ placement: `article-${index}` }),
+      })
+    );
+    if (kind === 'no_bid') {
+      decisions.push(Object.freeze({ slot, outcome: 'no_bid' }));
+      continue;
+    }
+    if (kind === 'failed') {
+      decisions.push(Object.freeze({ slot, outcome: 'failed', reason: 'internal_error' }));
+      continue;
+    }
+    const candidateId = `c${String(winner).padStart(11, '0')}`;
+    winner += 1;
+    decisions.push(Object.freeze({ slot, outcome: 'winner', candidateId }));
+    bids.push(
+      Object.freeze({
+        candidateId,
+        slot,
+        provider: 'example',
+        upstreamBidId: `upstream-${index}`,
+        cpm: 1.25,
+        currency: 'USD',
+        targeting: Object.freeze({ hb_pb: '1.25' }),
+        rendererReservationId: `r1_${String(index).padStart(22, 'a')}`,
+        renderSource:
+          kind === 'aps'
+            ? Object.freeze({
+                type: 'aps',
+                version: 1,
+                accountId: 'account-1',
+                bidId: `bid-${index}`,
+                tagType: 'iframe',
+                creativeUrl: 'https://creative.example/render',
+                aaxResponse: '',
+                width: 300,
+                height: 250,
+              })
+            : Object.freeze({
+                type: 'adm',
+                version: 1,
+                adm: '<div>example</div>',
+                width: 300,
+                height: 250,
+              }),
+      })
+    );
+  }
+  return Object.freeze({
+    version: 1,
+    projectionDigest: 'b'.repeat(64),
+    projection: Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'initial',
+        results: Object.freeze(decisions),
+      }),
+      slots: Object.freeze(slots),
+      bids: Object.freeze(bids),
+    }),
+  });
+}
+
+function harness(options: { now?: number; hidden?: boolean } = {}) {
+  let now = options.now ?? 0;
+  const marks: string[] = [];
+  const measures: Array<readonly [string, string, string]> = [];
+  const timers: Array<() => void> = [];
+  const frames: Array<() => void> = [];
+  const failures: string[] = [];
+  const performance = {
+    mark: (name: string) => marks.push(name),
+    measure: (name: string, start: string, end: string) => measures.push([name, start, end]),
+  };
+  const startedAtMs = now;
+  performance.mark('tsjs:bids-script');
+  const owner = Object.freeze({
+    startedAtMs,
+    now: () => now,
+    onSettled: () => undefined,
+  });
+  return {
+    owner,
+    failures,
+    frames,
+    marks,
+    measures,
+    timers,
+    performance,
+    now: () => now,
+    setNow: (value: number) => {
+      now = value;
+    },
+    paint: {
+      hidden: () => options.hidden === true,
+      requestFrame: (callback: () => void) => frames.push(callback),
+      scheduleHidden: (callback: () => void) => timers.push(callback),
+    },
+  };
+}
+
+function driver(events: string[]): FirstDisplayDriver & {
+  settleForTest: (slotId: string, result: 'accepted' | 'failed' | 'cancelled') => void;
+} {
+  let settle:
+    | ((slotId: string, result: 'accepted' | 'failed' | 'cancelled', reason: string | null) => void)
+    | undefined;
+  return Object.freeze({
+    captureHandoff: () =>
+      Object.freeze({
+        artifacts: Object.freeze([]),
+        clockEpochMs: 0,
+        cycles: Object.freeze([]),
+        diagnosticCycles: Object.freeze([]),
+        gptDiagnostics: Object.freeze({
+          facts: Object.freeze([]),
+          overflowCount: 0,
+          dropCount: 0,
+        }),
+        identities: Object.freeze([]),
+        nextReservationOrdinal: 1,
+        nextTraceTokenOrdinal: 1,
+        nextTicketOrdinal: 1,
+        tombstones: Object.freeze([]),
+      }),
+    closeIngress: () => true,
+    detachCommittedArtifacts: () => true,
+    sweepCommittedArtifacts: () => 0,
+    start: (
+      _outcomes: readonly FirstDisplayBatchOutcomeV1[],
+      onFirstAction: () => boolean,
+      onTerminal: (
+        slotId: string,
+        result: FirstDisplayTerminalResult,
+        reason: string | null
+      ) => void
+    ) => {
+      events.push('driver:start');
+      onFirstAction();
+      settle = onTerminal;
+    },
+    settleForTest: (slotId: string, result: FirstDisplayTerminalResult) =>
+      settle?.(slotId, result, result === 'accepted' ? null : 'internal_error'),
+    sealTsAdmission: () => events.push('driver:seal'),
+    dispose: () => events.push('driver:dispose'),
+  });
+}
+
+function production(
+  driver: FirstDisplayDriver
+): NonNullable<FirstDisplayAgentOptions['production']> {
+  let captured: ReturnType<FirstDisplayDriver['captureHandoff']>;
+  let closed: boolean | undefined;
+  let detached: boolean | undefined;
+  let disposed = false;
+  const terminals = new Map<
+    string,
+    (result: FirstDisplayTerminalResult, reason: string | null) => void
+  >();
+  const capture = () => {
+    if (captured === undefined) captured = driver.captureHandoff();
+    return captured;
+  };
+  const close = () => {
+    if (closed === undefined) closed = driver.closeIngress();
+    return closed;
+  };
+  const detach = () => {
+    if (detached === undefined) detached = driver.detachCommittedArtifacts();
+    return detached;
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    driver.dispose();
+  };
+  const gpt: FirstDisplayGptProtocolV1 = Object.freeze([
+    1,
+    'gpt',
+    (input: FirstDisplayGoogletagBatchInput) =>
+      Object.freeze([
+        (callbacks: FirstDisplayGoogletagBatchCallbacks) => {
+          const outcomes: FirstDisplayBatchOutcomeV1[] = [];
+          for (const decision of input[4].auction.results) {
+            if (decision.outcome !== 'winner') continue;
+            const bid = input[4].bids.find(
+              ({ candidateId }) => candidateId === decision.candidateId
+            );
+            if (bid) {
+              outcomes.push(
+                Object.freeze({
+                  kind: bid.renderSource.type === 'aps' ? 'aps' : 'gpt_adm',
+                  slotId: decision.slot,
+                })
+              );
+            }
+          }
+          for (const outcome of outcomes) {
+            const bid = input[4].bids.find(({ slot }) => slot === outcome.slotId)!;
+            const placement = input[4].slots.find(({ slot }) => slot === outcome.slotId)!;
+            callbacks[0](
+              Object.freeze([
+                bid,
+                document.createElement('div'),
+                () => true,
+                'trusted_server' as const,
+                {},
+                placement,
+                outcome.slotId,
+                `gt1_${outcome.slotId}`,
+              ])
+            );
+          }
+          driver.start(outcomes, callbacks[2], (slotId, result, reason) => {
+            terminals.get(slotId)?.(result, reason);
+          });
+          return true;
+        },
+        () => close(),
+        () =>
+          capture()?.cycles.map((cycle) =>
+            Object.freeze([cycle[6], cycle[1].id, cycle[3], cycle[8], cycle[7], cycle[4]] as const)
+          ),
+        () => {
+          const value = capture();
+          return value
+            ? Object.freeze([
+                value.diagnosticCycles.map((cycle) =>
+                  Object.freeze([
+                    cycle.slotId,
+                    cycle.token,
+                    cycle.nextCycleOrdinal,
+                    cycle.unknownPriorCycle,
+                    cycle.quarantines,
+                    cycle.records.map((record) =>
+                      Object.freeze([
+                        record.ordinal,
+                        record.responseIdentifier,
+                        record.seen,
+                        record.state,
+                      ] as const)
+                    ),
+                  ] as const)
+                ),
+                value.gptDiagnostics.facts,
+                value.nextTraceTokenOrdinal,
+                value.gptDiagnostics.overflowCount,
+                value.gptDiagnostics.dropCount,
+              ] as const)
+            : undefined;
+        },
+        () => detach(),
+        dispose,
+      ] as const),
+  ] as const);
+  const renderer: FirstDisplayRenderBridgeCapabilityV1 = Object.freeze([
+    (
+      cycle: FirstDisplayGptBoundCycleV1,
+      onTerminal: (result: FirstDisplayTerminalResult, reason: string | null) => void
+    ) => {
+      terminals.set(cycle[6], onTerminal);
+      return true;
+    },
+    () => true,
+    () => true,
+    () => true,
+    () => driver.sweepCommittedArtifacts(),
+    () => driver.sealTsAdmission(),
+    () => close(),
+    () => {
+      const value = capture();
+      return value
+        ? Object.freeze([
+            value.artifacts.map((artifact) =>
+              Object.freeze([
+                artifact.hostPosition,
+                artifact.hostPositionPriority,
+                artifact.identity,
+                artifact.kind,
+                artifact.owner,
+                artifact.slotId,
+                artifact.token,
+              ] as const)
+            ),
+            value.tombstones.map((entry) =>
+              Object.freeze([entry.kind, entry.value, entry.expiresAtMs, entry.ordinal] as const)
+            ),
+            value.clockEpochMs,
+            value.nextReservationOrdinal,
+            value.nextTicketOrdinal,
+          ] as const)
+        : undefined;
+    },
+    () => detach(),
+    dispose,
+  ] as const);
+  return Object.freeze({
+    gpt,
+    gptInput: Object.freeze([
+      window,
+      (handle: unknown) => window.clearTimeout(handle as number),
+      document,
+      (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+    ] as const),
+    renderer,
+  });
+}
+
+describe('bounded first-display agent', () => {
+  it.each(['gpt', 'render_owner'] as const)(
+    'accepts the exact two-field %s installer receipt after registering its full protocol',
+    (protocolId) => {
+      const sliceId = `${protocolId}_initial` as const;
+      const releases: Array<() => void> = [];
+      const prepared = prepareFirstDisplayBase({
+        options: {
+          handoff: { slices: [sliceId] },
+        },
+        sliceBindings: (
+          _id: string,
+          _observe: (key: unknown, value: unknown) => void,
+          register: ((protocol: unknown) => () => void) | undefined
+        ) => Object.freeze([Object.freeze({ register }), undefined]),
+      } as unknown as FirstDisplayAgentRegistrationHostV1);
+
+      expect(() =>
+        prepared.sliceHost.activate(
+          sliceId,
+          (release) => releases.push(release),
+          (bindings) => {
+            const register = (bindings as Readonly<{ register: (protocol: unknown) => () => void }>)
+              .register;
+            releases.push(register(Object.freeze([1, protocolId, Object.freeze({})] as const)));
+            return Object.freeze([1, protocolId] as const);
+          }
+        )
+      ).not.toThrow();
+      expect(releases).toHaveLength(1);
+    }
+  );
+
+  it('derives the protected action from the immutable projection and rejects outcome summaries', () => {
+    const accepted = harness();
+    const received: FirstDisplayBatchOutcomeV1[][] = [];
+    const projectionAgent = createFirstDisplayAgent({
+      batch: batch(['gpt_adm']),
+      ...accepted.owner,
+      production: production(
+        Object.freeze({
+          captureHandoff: () => undefined,
+          closeIngress: () => true,
+          detachCommittedArtifacts: () => true,
+          sweepCommittedArtifacts: () => 0,
+          start: (outcomes: readonly FirstDisplayBatchOutcomeV1[]) => {
+            received.push([...outcomes]);
+          },
+          sealTsAdmission: () => undefined,
+          dispose: () => undefined,
+        })
+      ),
+      performance: accepted.performance,
+      paint: accepted.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => accepted.failures.push(reason),
+    });
+
+    expect(projectionAgent.start()).toBe(true);
+    expect(received).toEqual([[{ slotId: 'slot-0', kind: 'gpt_adm' }]]);
+
+    const rejected = harness();
+    const summaryAgent = createFirstDisplayAgent({
+      batch: Object.freeze({
+        version: 1,
+        projectionDigest: 'b'.repeat(64),
+        requiredProtocols: Object.freeze(['gpt']),
+        outcomes: Object.freeze([Object.freeze({ slotId: 'slot-0', kind: 'gpt_adm' })]),
+      }),
+      ...rejected.owner,
+      production: production(driver([])),
+      performance: rejected.performance,
+      paint: rejected.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => rejected.failures.push(reason),
+    });
+    expect(summaryAgent.start()).toBe(false);
+    expect(rejected.failures).toEqual(['abi_mismatch']);
+  });
+
+  it('emits the four authoritative marks around one mixed protected batch', () => {
+    const h = harness();
+    const events: string[] = [];
+    const ownedDriver = driver(events);
+    const agent = createFirstDisplayAgent({
+      batch: batch(['no_bid', 'gpt_adm', 'aps']),
+      ...h.owner,
+      production: production(ownedDriver),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => events.push('protected:paint'),
+      onFailure: (reason) => h.failures.push(reason),
+    });
+
+    expect(agent.start()).toBe(true);
+    expect(h.marks).toEqual(['tsjs:bids-script', 'tsjs:first-display']);
+    expect(h.measures).toEqual([
+      ['tsjs:boot-to-first-display', 'tsjs:bids-script', 'tsjs:first-display'],
+    ]);
+    expect(events).toEqual(['driver:start']);
+    ownedDriver.settleForTest('slot-1', 'accepted');
+    expect(h.marks).toEqual(['tsjs:bids-script', 'tsjs:first-display']);
+    ownedDriver.settleForTest('slot-2', 'failed');
+    expect(h.marks).toEqual([
+      'tsjs:bids-script',
+      'tsjs:first-display',
+      'tsjs:first-display-terminal',
+    ]);
+    expect(h.frames).toHaveLength(1);
+    h.frames.shift()?.();
+    expect(h.frames).toHaveLength(1);
+    h.frames.shift()?.();
+    expect(h.marks).toEqual([
+      'tsjs:bids-script',
+      'tsjs:first-display',
+      'tsjs:first-display-terminal',
+      'tsjs:first-display-paint',
+    ]);
+    expect(events).toEqual(['driver:start', 'driver:seal', 'protected:paint']);
+    expect(agent.state).toBe('painted');
+  });
+
+  it('does not manufacture a first-action mark for an all-terminal empty action set', () => {
+    const h = harness({ hidden: true });
+    const events: string[] = [];
+    const agent = createFirstDisplayAgent({
+      batch: batch(['no_bid', 'failed', 'failed']),
+      ...h.owner,
+      production: production(driver(events)),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => events.push('protected:paint'),
+      onFailure: (reason) => h.failures.push(reason),
+    });
+
+    expect(agent.start()).toBe(true);
+    expect(h.marks).toEqual(['tsjs:bids-script', 'tsjs:first-display-terminal']);
+    h.timers.shift()?.();
+    h.timers.shift()?.();
+    expect(h.marks).toEqual([
+      'tsjs:bids-script',
+      'tsjs:first-display-terminal',
+      'tsjs:first-display-paint',
+    ]);
+    expect(events).toEqual(['driver:seal', 'protected:paint']);
+  });
+
+  it('records first-display only at the responsible action and rejects a late or replayed action', () => {
+    const h = harness();
+    let action: (() => boolean) | undefined;
+    const events: string[] = [];
+    const ownedDriver: FirstDisplayDriver = Object.freeze({
+      captureHandoff: () => undefined,
+      closeIngress: () => true,
+      detachCommittedArtifacts: () => true,
+      sweepCommittedArtifacts: () => 0,
+      start: (_outcomes: readonly FirstDisplayBatchOutcomeV1[], onFirstAction: () => boolean) => {
+        events.push('driver:prepared');
+        action = onFirstAction;
+      },
+      sealTsAdmission: () => undefined,
+      dispose: () => events.push('driver:dispose'),
+    });
+    const agent = createFirstDisplayAgent({
+      batch: batch(['gpt_adm']),
+      ...h.owner,
+      production: production(ownedDriver),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => h.failures.push(reason),
+    });
+
+    expect(agent.start()).toBe(true);
+    expect(events).toEqual(['driver:prepared']);
+    expect(h.marks).toEqual(['tsjs:bids-script']);
+    expect(action?.()).toBe(true);
+    expect(h.marks).toEqual(['tsjs:bids-script', 'tsjs:first-display']);
+    expect(action?.()).toBe(false);
+    expect(agent.state).toBe('failed');
+    expect(h.failures).toEqual(['bundle_partial']);
+
+    const late = harness();
+    let lateAction: (() => boolean) | undefined;
+    const lateAgent = createFirstDisplayAgent({
+      batch: batch(['aps']),
+      ...late.owner,
+      production: production(
+        Object.freeze({
+          captureHandoff: () => undefined,
+          closeIngress: () => true,
+          detachCommittedArtifacts: () => true,
+          sweepCommittedArtifacts: () => 0,
+          start: (
+            _outcomes: readonly FirstDisplayBatchOutcomeV1[],
+            onFirstAction: () => boolean
+          ) => {
+            lateAction = onFirstAction;
+          },
+          sealTsAdmission: () => undefined,
+          dispose: () => undefined,
+        })
+      ),
+      performance: late.performance,
+      paint: late.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => late.failures.push(reason),
+    });
+    expect(lateAgent.start()).toBe(true);
+    late.setNow(10_000);
+    expect(lateAction?.()).toBe(false);
+    expect(late.failures).toEqual(['bundle_partial']);
+    expect(late.marks).toEqual(['tsjs:bids-script']);
+  });
+
+  it('uses the same 10-second deadline for registration, activation, and action start', () => {
+    for (const [startedAt, accepted] of [
+      [9_999, true],
+      [10_000, false],
+      [10_001, false],
+    ] as const) {
+      const h = harness();
+      h.setNow(startedAt);
+      const events: string[] = [];
+      const agent = createFirstDisplayAgent({
+        batch: batch(['gpt_adm']),
+        ...h.owner,
+        production: production(driver(events)),
+        performance: h.performance,
+        paint: h.paint,
+        onProtectedPaint: () => undefined,
+        onFailure: (reason) => h.failures.push(reason),
+      });
+      expect(agent.start()).toBe(accepted);
+      expect(events).toEqual(accepted ? ['driver:start'] : ['driver:dispose']);
+      expect(h.failures).toEqual(accepted ? [] : ['bundle_partial']);
+    }
+  });
+
+  it('seals the immutable TS batch at paint while native activity remains observable', () => {
+    const h = harness();
+    const events: string[] = [];
+    const agent = createFirstDisplayAgent({
+      batch: batch(['no_bid']),
+      ...h.owner,
+      production: production(driver(events)),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => h.failures.push(reason),
+    });
+    agent.start();
+    h.frames.shift()?.();
+    h.frames.shift()?.();
+
+    expect(agent.observeNativeMutation()).toBe(true);
+    expect(agent.mutationRevision).toBe(1);
+  });
+
+  it('drains pending DOM mutation records into the final handoff revision', () => {
+    const h = harness();
+    const host = document.createElement('div');
+    document.body.append(host);
+    const issuer = createTestNavigationIdentityIssuer({
+      getRandomValues: (target) => target,
+    });
+    if (!issuer.ok) throw new Error('Expected first-display identity issuer');
+    const agent = createFirstDisplayAgent({
+      batch: batch(['no_bid']),
+      ...h.owner,
+      production: production(driver([])),
+      performance: h.performance,
+      paint: h.paint,
+      mutationDocument: document,
+      handoff: {
+        releaseId: 'a'.repeat(64),
+        generation: 1,
+        integrationConfigDigest: 'c'.repeat(64),
+        slices: ['first_display'],
+      },
+      identityIssuer: issuer.value,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => h.failures.push(reason),
+    });
+    expect(agent.start()).toBe(true);
+    h.frames.shift()?.();
+    h.frames.shift()?.();
+
+    host.append(document.createElement('span'));
+    const finalized = agent.finalizeHandoff(finalizeFirstDisplayAgentCaptureV1);
+    expect(finalized?.handoff.mutationRevision).toBe(1);
+    expect(h.failures).toEqual([]);
+
+    agent.dispose();
+    host.remove();
+  });
+
+  it('fails closed on malformed batches, driver throws, replay, and revision exhaustion', () => {
+    const malformed = harness();
+    const invalidAgent = createFirstDisplayAgent({
+      batch: { ...batch(['no_bid']), extra: true },
+      ...malformed.owner,
+      production: production(driver([])),
+      performance: malformed.performance,
+      paint: malformed.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => malformed.failures.push(reason),
+    });
+    expect(invalidAgent.start()).toBe(false);
+    expect(malformed.failures).toEqual(['abi_mismatch']);
+
+    const throwing = harness();
+    const throwingDriver: FirstDisplayDriver = Object.freeze({
+      captureHandoff: () => undefined,
+      closeIngress: () => true,
+      detachCommittedArtifacts: () => true,
+      sweepCommittedArtifacts: () => 0,
+      start: () => {
+        throw new Error('boom');
+      },
+      sealTsAdmission: () => undefined,
+      dispose: () => undefined,
+    });
+    const failedAgent = createFirstDisplayAgent({
+      batch: batch(['aps']),
+      ...throwing.owner,
+      production: production(throwingDriver),
+      performance: throwing.performance,
+      paint: throwing.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => throwing.failures.push(reason),
+    });
+    expect(failedAgent.start()).toBe(false);
+    expect(failedAgent.start()).toBe(false);
+    expect(throwing.failures).toEqual(['bundle_partial']);
+
+    const revision = harness();
+    const revisionAgent = createFirstDisplayAgent({
+      batch: batch(['no_bid']),
+      ...revision.owner,
+      production: production(driver([])),
+      performance: revision.performance,
+      paint: revision.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => revision.failures.push(reason),
+      initialMutationRevision: 4_294_967_295,
+    });
+    expect(revisionAgent.start()).toBe(true);
+    revision.frames.shift()?.();
+    revision.frames.shift()?.();
+    expect(revisionAgent.observeNativeMutation()).toBe(false);
+    expect(revision.failures).toEqual(['bundle_partial']);
+  });
+
+  it('runs every independent driver disposer when an earlier disposer throws', () => {
+    const h = harness();
+    const cleanup: string[] = [];
+    const gpt: FirstDisplayGptProtocolV1 = Object.freeze([
+      1,
+      'gpt',
+      () =>
+        Object.freeze([
+          (callbacks: FirstDisplayGoogletagBatchCallbacks) => callbacks[2](),
+          () => true,
+          () => undefined,
+          () => undefined,
+          () => true,
+          () => {
+            cleanup.push('gpt');
+            throw new Error('fictional GPT cleanup failure');
+          },
+        ] as const),
+    ]);
+    const renderer: FirstDisplayRenderBridgeCapabilityV1 = Object.freeze([
+      () => true,
+      () => true,
+      () => true,
+      () => true,
+      () => 0,
+      () => undefined,
+      () => true,
+      () => undefined,
+      () => true,
+      () => cleanup.push('renderer'),
+    ]);
+    const agent = createFirstDisplayAgent({
+      batch: batch(['gpt_adm']),
+      ...h.owner,
+      production: Object.freeze({
+        gpt,
+        gptInput: Object.freeze([
+          window,
+          (handle: unknown) => window.clearTimeout(handle as number),
+          document,
+          (callback: () => void, delayMs: number) => window.setTimeout(callback, delayMs),
+        ] as const),
+        renderer,
+      }),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => h.failures.push(reason),
+    });
+
+    expect(agent.start()).toBe(true);
+    expect(() => agent.dispose()).not.toThrow();
+    expect(cleanup).toEqual(['gpt', 'renderer']);
+    expect(agent.state).toBe('disposed');
+  });
+
+  it('mints the final immutable handoff only after paint and closes ingress before capture', () => {
+    const h = harness();
+    const events: string[] = [];
+    const physicalSlot = {};
+    const artifact = {};
+    const projectedBatch = snapshotFirstDisplayBatchV1(batch(['gpt_adm', 'gpt_adm']))!;
+    const issuer = createTestNavigationIdentityIssuer({
+      getRandomValues: (target) => {
+        target.set([0, 1, 2, 3, 4, 5, 6, 7]);
+        return target;
+      },
+    });
+    if (!issuer.ok) throw new Error('Expected first-display identity issuer');
+    const element = document.createElement('div');
+    element.id = 'slot-0';
+    const ownedDriver: FirstDisplayDriver = Object.freeze({
+      start: (
+        _outcomes: readonly FirstDisplayBatchOutcomeV1[],
+        onFirstAction: () => boolean,
+        onTerminal: (
+          slotId: string,
+          result: FirstDisplayTerminalResult,
+          reason: string | null
+        ) => void
+      ) => {
+        onFirstAction();
+        onTerminal('slot-0', 'accepted', null);
+        onTerminal('slot-1', 'failed', 'renderer_document_no_load');
+      },
+      sealTsAdmission: () => events.push('seal'),
+      closeIngress: () => {
+        events.push('close');
+        return true;
+      },
+      captureHandoff: () => {
+        events.push('capture');
+        return Object.freeze({
+          artifacts: Object.freeze([
+            Object.freeze({
+              hostPosition: null,
+              hostPositionPriority: null,
+              identity: artifact,
+              kind: 'gpt_adm' as const,
+              owner: 'trusted_server' as const,
+              slotId: 'slot-0',
+              token: projectedBatch.projection.bids[0]!.rendererReservationId,
+            }),
+          ]),
+          cycles: Object.freeze([
+            Object.freeze([
+              projectedBatch.projection.bids[0]!,
+              element,
+              () => true,
+              'trusted_server' as const,
+              physicalSlot,
+              projectedBatch.projection.slots[0]!,
+              'slot-0',
+              'gt1_1',
+              Object.freeze([]),
+            ] as const),
+          ]),
+          diagnosticCycles: Object.freeze([
+            Object.freeze({
+              nextCycleOrdinal: 2,
+              quarantines: Object.freeze([]),
+              records: Object.freeze([
+                Object.freeze({
+                  ordinal: 1,
+                  responseIdentifier: 'response-one',
+                  seen: Object.freeze(['slotRequested', 'slotRenderEnded'] as const),
+                  state: 'completed' as const,
+                }),
+              ]),
+              slotId: 'slot-0',
+              token: 'gt1_1',
+              unknownPriorCycle: false,
+            }),
+          ]),
+          gptDiagnostics: Object.freeze({
+            facts: Object.freeze([]),
+            overflowCount: 0,
+            dropCount: 0,
+          }),
+          identities: Object.freeze([physicalSlot, artifact]),
+          clockEpochMs: 0,
+          nextReservationOrdinal: 1,
+          nextTraceTokenOrdinal: 2,
+          nextTicketOrdinal: 1,
+          tombstones: Object.freeze([]),
+        });
+      },
+      detachCommittedArtifacts: () => {
+        events.push('detach');
+        return true;
+      },
+      sweepCommittedArtifacts: () => 0,
+      dispose: () => events.push('dispose'),
+    });
+    const agent = createFirstDisplayAgent({
+      batch: batch(['gpt_adm', 'gpt_adm']),
+      ...h.owner,
+      production: production(ownedDriver),
+      performance: h.performance,
+      paint: h.paint,
+      onProtectedPaint: () => undefined,
+      onFailure: (reason) => h.failures.push(reason),
+      identityIssuer: issuer.value,
+      parserState: () =>
+        Object.freeze([
+          Object.freeze([
+            'gpt_initial',
+            Object.freeze([
+              Object.freeze(['gam', false] as const),
+              Object.freeze(['v', 1] as const),
+            ]),
+          ] as const),
+        ]),
+      handoff: Object.freeze({
+        releaseId: 'a'.repeat(64),
+        generation: 1,
+        integrationConfigDigest: 'c'.repeat(64),
+        slices: Object.freeze(['first_display', 'gpt_initial'] as const),
+      }),
+    });
+    expect(agent.start()).toBe(true);
+    expect(agent.finalizeHandoff(finalizeFirstDisplayAgentCaptureV1)).toBeUndefined();
+    h.frames.shift()?.();
+    h.frames.shift()?.();
+
+    const finalized = agent.finalizeHandoff(finalizeFirstDisplayAgentCaptureV1);
+    expect(events.slice(-2)).toEqual(['close', 'capture']);
+    expect(finalized?.handoff).toMatchObject({
+      captureVersion: 1,
+      releaseId: 'a'.repeat(64),
+      generation: 1,
+      mutationRevision: 0,
+      identityCount: 2,
+    });
+    const data = finalized?.handoff['data'] as readonly unknown[];
+    expect(data).toHaveLength(14);
+    expect(data.slice(0, 3)).toEqual([
+      'b'.repeat(64),
+      'c'.repeat(64),
+      ['first_display', 'gpt_initial'],
+    ]);
+    expect(data[3]).toEqual([
+      ['accepted', null, 0, 1],
+      ['failed', 'renderer_document_no_load', null, null],
+    ]);
+    expect(data[4]).toEqual([['slot-0', 'slot-0', 'trusted_server', [], 'gt1_1']]);
+    expect(data[7]).toEqual([
+      [
+        'gpt_initial',
+        [
+          ['gam', false],
+          ['v', 1],
+        ],
+      ],
+    ]);
+    expect(finalized?.handoff).not.toHaveProperty('attempts');
+    expect(finalized?.capsule.consume('a'.repeat(64), 1)).toEqual([physicalSlot, artifact]);
+    expect(agent.detachCommittedArtifacts()).toBe(true);
+    agent.dispose();
+    expect(events).toContain('detach');
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/browser_route_owner.test.ts b/crates/trusted-server-js/lib/test/first_display/browser_route_owner.test.ts
new file mode 100644
index 000000000..06f8d0f2e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/browser_route_owner.test.ts
@@ -0,0 +1,249 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createFirstDisplayBrowserRouteOwner,
+  registerFirstDisplayBrowserRoute,
+} from '../../src/first_display/leaf/browser_route_owner';
+
+describe('first-display browser route owner', () => {
+  it('shares one DOM interceptor across rules and releases each rule independently', () => {
+    const nativeAppendChild = Element.prototype.appendChild;
+    const releaseAlpha = registerFirstDisplayBrowserRoute({
+      matches: (_kind, url) => url.includes('alpha.example'),
+      rewrite: () => 'https://publisher.example/alpha',
+    });
+    const sharedAppendChild = Element.prototype.appendChild;
+    const releaseBeta = registerFirstDisplayBrowserRoute({
+      matches: (_kind, url) => url.includes('beta.example'),
+      rewrite: () => 'https://publisher.example/beta',
+    });
+    const appendChildAfterSecondRegistration = Element.prototype.appendChild;
+
+    releaseAlpha();
+    const alpha = document.createElement('script');
+    alpha.src = 'https://alpha.example/sdk.js';
+    document.head.appendChild(alpha);
+    const beta = document.createElement('script');
+    beta.src = 'https://beta.example/sdk.js';
+    document.head.appendChild(beta);
+    releaseBeta();
+    const appendChildAfterFinalRelease = Element.prototype.appendChild;
+    alpha.remove();
+    beta.remove();
+
+    expect(appendChildAfterSecondRegistration).toBe(sharedAppendChild);
+    expect(alpha.src).toBe('https://alpha.example/sdk.js');
+    expect(beta.src).toBe('https://publisher.example/beta');
+    expect(appendChildAfterFinalRelease).toBe(nativeAppendChild);
+  });
+
+  it('rewrites matching scripts and preloads before native insertion and restores exactly once', () => {
+    const appendChild = Element.prototype.appendChild;
+    const insertBefore = Element.prototype.insertBefore;
+    const release = registerFirstDisplayBrowserRoute({
+      matches: (kind, url) =>
+        (kind === 'script' || kind === 'preload') && url.includes('vendor.example'),
+      rewrite: (url) => `/integrations/proxy?source=${encodeURIComponent(url)}`,
+    });
+
+    const script = document.createElement('script');
+    script.src = 'https://vendor.example/sdk.js?v=1';
+    document.head.appendChild(script);
+    expect(script.getAttribute('src')).toContain('/integrations/proxy?source=');
+
+    const preload = document.createElement('link');
+    preload.rel = 'preload';
+    preload.setAttribute('as', 'script');
+    preload.href = 'https://vendor.example/later.js';
+    document.head.insertBefore(preload, script);
+    expect(preload.getAttribute('href')).toContain('/integrations/proxy?source=');
+
+    release();
+    release();
+    expect(Element.prototype.appendChild).toBe(appendChild);
+    expect(Element.prototype.insertBefore).toBe(insertBefore);
+
+    const later = document.createElement('script');
+    later.src = 'https://vendor.example/unowned.js';
+    document.head.appendChild(later);
+    expect(later.src).toBe('https://vendor.example/unowned.js');
+    script.remove();
+    preload.remove();
+    later.remove();
+  });
+
+  it('rewrites variadic and fragment insertion paths synchronously and compare-restores them', () => {
+    const append = Element.prototype.append;
+    const prepend = Element.prototype.prepend;
+    const replaceChildren = Element.prototype.replaceChildren;
+    const release = registerFirstDisplayBrowserRoute({
+      matches: (kind, url) => kind === 'script' && url.includes('vendor.example'),
+      rewrite: (url) => `/integrations/proxy?source=${encodeURIComponent(url)}`,
+    });
+    const appended = document.createElement('script');
+    appended.src = 'https://vendor.example/append.js';
+    const prepended = document.createElement('script');
+    prepended.src = 'https://vendor.example/prepend.js';
+    const nested = document.createElement('script');
+    nested.src = 'https://vendor.example/fragment.js';
+    const fragment = document.createDocumentFragment();
+    fragment.appendChild(nested);
+
+    document.head.append(appended);
+    document.head.prepend(prepended);
+    document.head.replaceChildren(fragment);
+    const restoredAfterRelease = {
+      append: Element.prototype.append,
+      prepend: Element.prototype.prepend,
+      replaceChildren: Element.prototype.replaceChildren,
+    };
+    release();
+    nested.remove();
+
+    expect(appended.getAttribute('src')).toContain('/integrations/proxy?source=');
+    expect(prepended.getAttribute('src')).toContain('/integrations/proxy?source=');
+    expect(nested.getAttribute('src')).toContain('/integrations/proxy?source=');
+    expect(restoredAfterRelease.append).not.toBe(append);
+    expect(Element.prototype.append).toBe(append);
+    expect(Element.prototype.prepend).toBe(prepend);
+    expect(Element.prototype.replaceChildren).toBe(replaceChildren);
+  });
+
+  it('owns matching beacon and fetch routes without changing publisher replacements on release', async () => {
+    const originalBeacon = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const originalFetch = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const beacon = vi.fn(() => true);
+    const fetch = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => new Response());
+    Object.defineProperty(navigator, 'sendBeacon', {
+      configurable: true,
+      value: beacon,
+      writable: true,
+    });
+    Object.defineProperty(window, 'fetch', {
+      configurable: true,
+      value: fetch,
+      writable: true,
+    });
+    const release = registerFirstDisplayBrowserRoute(
+      {
+        matches: (kind, url) =>
+          (kind === 'beacon' || kind === 'fetch') && url.includes('analytics.example'),
+        rewrite: () => 'https://publisher.example/integrations/analytics',
+      },
+      true
+    );
+
+    expect(navigator.sendBeacon('https://analytics.example/collect')).toBe(true);
+    await window.fetch('https://analytics.example/fetch');
+    expect(beacon).toHaveBeenCalledWith(
+      'https://publisher.example/integrations/analytics',
+      undefined
+    );
+    expect(fetch).toHaveBeenCalledWith(
+      'https://publisher.example/integrations/analytics',
+      undefined
+    );
+
+    const publisherFetch = vi.fn(async () => new Response());
+    window.fetch = publisherFetch;
+    release();
+    expect(window.fetch).toBe(publisherFetch);
+    if (originalBeacon) Object.defineProperty(navigator, 'sendBeacon', originalBeacon);
+    else Reflect.deleteProperty(navigator, 'sendBeacon');
+    if (originalFetch) Object.defineProperty(window, 'fetch', originalFetch);
+    else Reflect.deleteProperty(window, 'fetch');
+  });
+
+  it('preserves Request identity when unmatched and metadata when rewriting its URL', async () => {
+    const originalFetch = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const fetch = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => new Response());
+    Object.defineProperty(window, 'fetch', {
+      configurable: true,
+      value: fetch,
+      writable: true,
+    });
+    const release = registerFirstDisplayBrowserRoute(
+      {
+        matches: (kind, url) => kind === 'fetch' && url.includes('analytics.example'),
+        rewrite: () => 'https://publisher.example/integrations/analytics',
+      },
+      true
+    );
+    const unmatched = new Request('https://publisher.example/content', {
+      body: 'unmatched-body',
+      headers: { 'x-owner': 'publisher' },
+      method: 'POST',
+    });
+    const matched = new Request('https://analytics.example/collect', {
+      body: 'matched-body',
+      headers: { 'x-owner': 'publisher' },
+      method: 'POST',
+    });
+
+    await window.fetch(unmatched);
+    await window.fetch(matched);
+    const unmatchedInput = fetch.mock.calls[0]?.[0];
+    const matchedInput = fetch.mock.calls[1]?.[0] as Request;
+    release();
+    if (originalFetch) Object.defineProperty(window, 'fetch', originalFetch);
+    else Reflect.deleteProperty(window, 'fetch');
+
+    expect(unmatchedInput).toBe(unmatched);
+    expect(matchedInput).toBeInstanceOf(Request);
+    expect(matchedInput.url).toBe('https://publisher.example/integrations/analytics');
+    expect(matchedInput.method).toBe('POST');
+    expect(matchedInput.headers.get('x-owner')).toBe('publisher');
+    await expect(matchedInput.text()).resolves.toBe('matched-body');
+  });
+
+  it('continues restoring every owned surface when one browser property rejects restoration', () => {
+    const appendChildDescriptor = Object.getOwnPropertyDescriptor(Element.prototype, 'appendChild');
+    const insertBefore = Element.prototype.insertBefore;
+    const append = Element.prototype.append;
+    const prepend = Element.prototype.prepend;
+    const replaceChildren = Element.prototype.replaceChildren;
+    const beaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const beacon = vi.fn(() => true);
+    const fetch = vi.fn(async () => new Response());
+    Object.defineProperty(navigator, 'sendBeacon', {
+      configurable: true,
+      value: beacon,
+      writable: true,
+    });
+    Object.defineProperty(window, 'fetch', {
+      configurable: true,
+      value: fetch,
+      writable: true,
+    });
+
+    try {
+      const owner = createFirstDisplayBrowserRouteOwner(document, window);
+      const release = owner.register({ matches: () => false, rewrite: (url) => url }, true);
+      const installedAppendChild = Element.prototype.appendChild;
+      Object.defineProperty(Element.prototype, 'appendChild', {
+        configurable: true,
+        get: () => installedAppendChild,
+        set: () => {
+          throw new TypeError('hostile browser surface');
+        },
+      });
+
+      expect(() => release()).not.toThrow();
+      expect(Element.prototype.insertBefore).toBe(insertBefore);
+      expect(Element.prototype.append).toBe(append);
+      expect(Element.prototype.prepend).toBe(prepend);
+      expect(Element.prototype.replaceChildren).toBe(replaceChildren);
+      expect(navigator.sendBeacon).toBe(beacon);
+      expect(window.fetch).toBe(fetch);
+    } finally {
+      if (appendChildDescriptor) {
+        Object.defineProperty(Element.prototype, 'appendChild', appendChildDescriptor);
+      }
+      if (beaconDescriptor) Object.defineProperty(navigator, 'sendBeacon', beaconDescriptor);
+      else Reflect.deleteProperty(navigator, 'sendBeacon');
+      if (fetchDescriptor) Object.defineProperty(window, 'fetch', fetchDescriptor);
+      else Reflect.deleteProperty(window, 'fetch');
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/contracts.test.ts b/crates/trusted-server-js/lib/test/first_display/contracts.test.ts
new file mode 100644
index 000000000..f8ab2c066
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/contracts.test.ts
@@ -0,0 +1,666 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  MAX_FIRST_DISPLAY_HANDOFF_BYTES,
+  MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES,
+  MAX_GPT_FACT_BYTES,
+  createFirstDisplayOwnershipCapsuleV1,
+  snapshotFirstDisplayHandoffV1,
+  snapshotOutlinedFirstDisplayCaptureV1,
+  snapshotTakeoverOutlineV1,
+} from '../../src/shared/first_display_contracts';
+
+const HASH = 'a'.repeat(64);
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+function outline(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    version: 1,
+    releaseId: HASH,
+    generation: 1,
+    projectionDigest: 'b'.repeat(64),
+    integrationConfigDigest: 'c'.repeat(64),
+    slices: ['first_display', 'gpt_initial'],
+    slotCount: 1,
+    outcomeCount: 1,
+    capabilities: ['gpt_slot', 'dom_artifact'],
+    objectKinds: ['gpt_slot', 'dom_artifact'],
+    ...overrides,
+  };
+}
+
+function handoff(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    version: 1,
+    releaseId: HASH,
+    generation: 1,
+    projectionDigest: 'b'.repeat(64),
+    integrationConfigDigest: 'c'.repeat(64),
+    slices: ['first_display', 'gpt_initial'],
+    slots: [
+      {
+        id: 'slot-1',
+        aliases: ['alias-1'],
+        domId: 'div-1',
+        gamPath: '/123/home',
+        formats: [[300, 250]],
+        owner: 'trusted_server',
+        outcome: 'accepted',
+        targeting: [['hb_adid', RESERVATION_ID]],
+        targetingOwnership: [],
+        committedArtifact: 'gpt_adm',
+        gptToken: 'gt1_1',
+      },
+    ],
+    attempts: [
+      {
+        id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+        slotId: 'slot-1',
+        ordinal: 1,
+        state: 'accepted',
+        reason: null,
+      },
+    ],
+    tombstones: [
+      {
+        kind: 'reservation',
+        value: RESERVATION_ID,
+        expiresAtMs: 1_000,
+        ordinal: 1,
+      },
+    ],
+    artifacts: [
+      {
+        hostPosition: null,
+        hostPositionPriority: null,
+        slotId: 'slot-1',
+        kind: 'gpt_adm',
+        owner: 'trusted_server',
+        token: RESERVATION_ID,
+      },
+    ],
+    parserState: [
+      {
+        sliceId: 'gpt_initial',
+        observations: ['gam', 'v'],
+        values: [
+          ['gam', false],
+          ['v', 1],
+        ],
+      },
+    ],
+    gptDiagnostics: {
+      facts: [
+        {
+          version: 1,
+          event: 'slotRenderEnded',
+          token: 'gt1_1',
+          runtimeSlotNumber: 1,
+          cycleOrdinal: 1,
+          disposition: 'matched',
+          issueReason: null,
+          capturedAtMs: 12,
+          elementId: 'div-1',
+          adUnitPath: '/123/home',
+          requestedSlotSizes: null,
+          isEmpty: false,
+          renderedSize: [300, 250],
+          isBackfill: false,
+          slotContentChanged: true,
+          visibilityPercent: null,
+        },
+      ],
+      overflowCount: 0,
+      dropCount: 0,
+    },
+    timing: {
+      bidsScriptMs: 1,
+      firstDisplayMs: 2,
+      terminalMs: 3,
+      paintMs: 4,
+    },
+    highWater: {
+      navigationAttemptPrefix: 'AAECAwQFBgc',
+      nextNavigationAttemptOrdinal: 2,
+      nextAttemptOrdinal: 2,
+      nextSlotRegistrationOrdinal: 2,
+      reservationClockEpochMs: 0,
+      nextReservationOrdinal: 2,
+      nextTicketOrdinal: 1,
+    },
+    cycles: [
+      {
+        slotId: 'slot-1',
+        token: 'gt1_1',
+        nextCycleOrdinal: 2,
+        unknownPriorCycle: false,
+        records: [
+          {
+            ordinal: 1,
+            responseIdentifier: 'response-one',
+            seen: ['slotRequested', 'slotRenderEnded'],
+            state: 'completed',
+          },
+        ],
+        quarantines: [],
+      },
+    ],
+    trace: {
+      nextSequence: 2,
+      nextGlobalSlotOrdinal: 2,
+      slots: [
+        {
+          slotId: 'slot-1',
+          impressions: 1,
+          bindings: [
+            {
+              atMs: 3,
+              cycleOrdinal: 1,
+              historySequence: 1,
+              state: 'completed',
+              token: 'gt1_1',
+            },
+          ],
+        },
+      ],
+    },
+    mutationRevision: 7,
+    ...overrides,
+  };
+}
+
+describe('first-display immutable contracts', () => {
+  it('expands one compact old-owner capture only against the validated boot projection', () => {
+    const full = handoff();
+    (full.slots as Array<Record<string, unknown>>)[0]!.aliases = [];
+    const compact = {
+      captureVersion: 1,
+      releaseId: HASH,
+      generation: 1,
+      data: [
+        'b'.repeat(64),
+        'c'.repeat(64),
+        ['first_display', 'gpt_initial'],
+        [['accepted', null, 3, 1]],
+        [['slot-1', 'div-1', 'trusted_server', [], 'gt1_1']],
+        [['reservation', RESERVATION_ID, 1_000, 1]],
+        [[null, null, 'slot-1', 'gpt_adm', 'trusted_server', RESERVATION_ID]],
+        [
+          [
+            'gpt_initial',
+            [
+              ['gam', false],
+              ['v', 1],
+            ],
+          ],
+        ],
+        [(full.gptDiagnostics as Record<string, unknown>).facts, 0, 0],
+        [1, 2, 3, 4],
+        [2, 0, 2, 1],
+        full.cycles,
+        2,
+        2,
+      ],
+      mutationRevision: 7,
+      identityCount: 2,
+    };
+    const boot = {
+      abi: 1,
+      releaseId: HASH,
+      manifest: {},
+      auctionProjection: {
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: 'initial',
+          results: [{ slot: 'slot-1', outcome: 'winner', candidateId: 'AAAAAAAAAAAA' }],
+        },
+        slots: [
+          {
+            slot: 'slot-1',
+            gamUnitPath: '/123/home',
+            divId: 'div-1',
+            formats: [[300, 250]],
+            targeting: {},
+          },
+        ],
+        bids: [
+          {
+            candidateId: 'AAAAAAAAAAAA',
+            slot: 'slot-1',
+            provider: 'trusted',
+            upstreamBidId: 'upstream-1',
+            cpm: 1,
+            currency: 'USD',
+            targeting: {},
+            rendererReservationId: RESERVATION_ID,
+            renderSource: {
+              type: 'adm',
+              version: 1,
+              adm: '<main>trusted</main>',
+              width: 300,
+              height: 250,
+            },
+          },
+        ],
+      },
+      integrations: {},
+      creative: {},
+      diagnostics: {},
+    };
+
+    const issuer = {
+      mintAttemptId: () => ({
+        ok: true as const,
+        value: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+      }),
+      snapshotPrefix: () => 'AAECAwQFBgc',
+    };
+    expect(snapshotOutlinedFirstDisplayCaptureV1(compact, outline(), boot, issuer)).toEqual(full);
+    compact.data[3] = [['accepted', null, null, 1]];
+    expect(snapshotOutlinedFirstDisplayCaptureV1(compact, outline(), boot, issuer)).toBeUndefined();
+  });
+
+  it('snapshots an exact takeover outline into a fresh recursively frozen value', () => {
+    const input = outline();
+    const accepted = snapshotTakeoverOutlineV1(input);
+
+    expect(accepted).toEqual(input);
+    expect(accepted).not.toBe(input);
+    expect(Object.isFrozen(accepted)).toBe(true);
+    expect(Object.isFrozen(accepted?.slices)).toBe(true);
+  });
+
+  it('rejects unknown, missing, inherited, accessor, malformed, and noncanonical outline data', () => {
+    expect(snapshotTakeoverOutlineV1({ ...outline(), extra: true })).toBeUndefined();
+    const missing = outline();
+    delete missing.projectionDigest;
+    expect(snapshotTakeoverOutlineV1(missing)).toBeUndefined();
+    expect(snapshotTakeoverOutlineV1(Object.create(outline()))).toBeUndefined();
+    const accessor = outline();
+    Object.defineProperty(accessor, 'generation', { enumerable: true, get: () => 1 });
+    expect(snapshotTakeoverOutlineV1(accessor)).toBeUndefined();
+    expect(snapshotTakeoverOutlineV1(outline({ releaseId: HASH.toUpperCase() }))).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(outline({ slices: ['gpt_initial', 'first_display'] }))
+    ).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(
+        outline({ slices: ['first_display', 'aps_initial', 'gpt_initial'] })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(outline({ slices: ['first_display', 'render_owner_initial'] }))
+    ).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(
+        outline({ slices: ['first_display', 'render_owner_initial', 'gpt_initial'] })
+      )?.slices
+    ).toEqual(['first_display', 'render_owner_initial', 'gpt_initial']);
+    expect(
+      snapshotTakeoverOutlineV1(outline({ capabilities: ['gpt_slot', 'gpt_slot'] }))
+    ).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(outline({ capabilities: ['a.0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_0_!'] }))
+    ).toBeUndefined();
+    expect(
+      snapshotTakeoverOutlineV1(outline({ capabilities: ['trace.presentation_v1'] }))?.capabilities
+    ).toEqual(['trace.presentation_v1']);
+  });
+
+  it('accepts the complete exact handoff and rejects payload or live-authority fields', () => {
+    const input = handoff();
+    const accepted = snapshotFirstDisplayHandoffV1(input);
+
+    expect(accepted).toEqual(input);
+    expect(accepted).not.toBe(input);
+    expect(Object.isFrozen(accepted)).toBe(true);
+    expect(Object.isFrozen(accepted?.slots[0]?.targeting)).toBe(true);
+
+    const withAdm = handoff();
+    (withAdm.slots as Array<Record<string, unknown>>)[0]!.adm = '<script>bad()</script>';
+    expect(snapshotFirstDisplayHandoffV1(withAdm)).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(handoff({ livePort: new MessageChannel().port1 }))
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          attempts: [{ ...((handoff().attempts as object[])[0] as object), state: 'pending' }],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(handoff({ slices: ['first_display'], parserState: [] }))
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          parserState: [
+            {
+              sliceId: 'gpt_initial',
+              observations: ['gam', 'v', 'extra'],
+              values: [
+                ['gam', false],
+                ['v', 1],
+                ['extra', true],
+              ],
+            },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          artifacts: [
+            {
+              ...((handoff().artifacts as object[])[0] as object),
+              token: `r1_${'b'.repeat(22)}`,
+            },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({ trace: { nextSequence: 2, nextGlobalSlotOrdinal: 2, slots: [] } })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          tombstones: [{ ...(handoff().tombstones as object[])[0], value: 'opaque-reservation' }],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          tombstones: [{ ...(handoff().tombstones as object[])[0], expiresAtMs: 0 }],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          timing: { bidsScriptMs: 2, firstDisplayMs: 1, terminalMs: 3, paintMs: 4 },
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          attempts: [
+            {
+              ...((handoff().attempts as object[])[0] as object),
+              id: 'attempt-1',
+            },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          attempts: [
+            {
+              ...((handoff().attempts as object[])[0] as object),
+              state: 'no_bid',
+            },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          attempts: [
+            {
+              ...((handoff().attempts as object[])[0] as object),
+              state: 'failed',
+              reason: null,
+            },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(snapshotFirstDisplayHandoffV1(handoff({ parserState: [] }))).toBeUndefined();
+    const parserRow = (handoff().parserState as object[])[0]!;
+    expect(
+      snapshotFirstDisplayHandoffV1(handoff({ parserState: [parserRow, parserRow] }))
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          parserState: [
+            { sliceId: 'gpt_initial', observations: ['ready'], values: [['other', true]] },
+          ],
+        })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({
+          highWater: {
+            ...(handoff().highWater as object),
+            navigationAttemptPrefix: 'nav1',
+          },
+        })
+      )
+    ).toBeUndefined();
+  });
+
+  it('validates the render-owner parser row inside a complete owner-to-GPT handoff', () => {
+    const gptParserState = (handoff().parserState as object[])[0]!;
+    const accepted = snapshotFirstDisplayHandoffV1(
+      handoff({
+        slices: ['first_display', 'render_owner_initial', 'gpt_initial'],
+        parserState: [
+          {
+            sliceId: 'render_owner_initial',
+            observations: ['protocol_version'],
+            values: [['protocol_version', 1]],
+          },
+          gptParserState,
+        ],
+      })
+    );
+
+    expect(accepted?.slices).toEqual(['first_display', 'render_owner_initial', 'gpt_initial']);
+  });
+
+  it('enforces 255/256/257 slot and outcome boundaries and strict high-water counters', () => {
+    const base = handoff();
+    const slot = (base.slots as object[])[0]!;
+    const attempt = (base.attempts as object[])[0]!;
+    for (const count of [255, 256]) {
+      const slots = Array.from({ length: count }, (_, index) => ({
+        ...(slot as Record<string, unknown>),
+        id: `slot-${index}`,
+        domId: `div-${index}`,
+        outcome: 'no_bid',
+        committedArtifact: 'none',
+        targetingOwnership: [],
+        gptToken: null,
+      }));
+      const attempts = Array.from({ length: count }, (_, index) => ({
+        ...(attempt as Record<string, unknown>),
+        id: `a1_AAECAwQFBgc${index.toString(36).padStart(11, 'A')}`,
+        slotId: `slot-${index}`,
+        ordinal: index + 1,
+        state: 'no_bid',
+      }));
+      expect(
+        snapshotFirstDisplayHandoffV1(
+          handoff({
+            slots,
+            attempts,
+            artifacts: [],
+            gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+            tombstones: [],
+            cycles: [],
+            trace: {
+              nextSequence: 1,
+              nextGlobalSlotOrdinal: count + 1,
+              slots: slots.map((entry) => ({
+                slotId: entry.id,
+                impressions: 0,
+                bindings: [],
+              })),
+            },
+            highWater: {
+              ...(base.highWater as object),
+              nextNavigationAttemptOrdinal: count + 1,
+              nextAttemptOrdinal: count + 1,
+              nextSlotRegistrationOrdinal: count + 1,
+            },
+          })
+        )
+      ).toBeDefined();
+    }
+
+    const tooMany = Array.from({ length: 257 }, (_, index) => ({
+      ...(slot as Record<string, unknown>),
+      id: `slot-${index}`,
+      domId: `div-${index}`,
+    }));
+    expect(snapshotFirstDisplayHandoffV1(handoff({ slots: tooMany }))).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({ highWater: { ...(base.highWater as object), nextAttemptOrdinal: 1 } })
+      )
+    ).toBeUndefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({ trace: { ...(base.trace as object), nextSequence: 1 } })
+      )
+    ).toBeUndefined();
+  });
+
+  it('publishes the exact independent size ceilings', () => {
+    expect(MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES).toBe(8 * 1024 * 1024);
+    expect(MAX_GPT_FACT_BYTES).toBe(512 * 1024);
+    expect(MAX_FIRST_DISPLAY_HANDOFF_BYTES).toBe(8.5 * 1024 * 1024);
+  });
+
+  it('enforces the exact normalized diagnostics shape and per-fact byte ceiling', () => {
+    const subsection = handoff().gptDiagnostics as {
+      facts: Array<Record<string, unknown>>;
+      overflowCount: number;
+      dropCount: number;
+    };
+    expect(snapshotFirstDisplayHandoffV1(handoff())).toBeDefined();
+    expect(
+      snapshotFirstDisplayHandoffV1(
+        handoff({ gptFacts: subsection.facts, gptFactOverflow: 0, gptDiagnostics: undefined })
+      )
+    ).toBeUndefined();
+    subsection.facts[0]!.elementId = 'x'.repeat(1_001);
+    expect(snapshotFirstDisplayHandoffV1(handoff({ gptDiagnostics: subsection }))).toBeUndefined();
+  });
+
+  it('advances the global GPT token high-water above retained diagnostics facts', () => {
+    const subsection = handoff().gptDiagnostics as {
+      facts: Array<Record<string, unknown>>;
+      overflowCount: number;
+      dropCount: number;
+    };
+    subsection.facts[0]!.token = 'gt1_3';
+    subsection.facts[0]!.runtimeSlotNumber = 3;
+
+    expect(snapshotFirstDisplayHandoffV1(handoff({ gptDiagnostics: subsection }))).toBeUndefined();
+  });
+
+  it('enforces the exact 8 MiB non-diagnostics canonical boundary', () => {
+    const base = handoff({
+      attempts: [],
+      tombstones: [],
+      artifacts: [],
+      gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+      cycles: [],
+      trace: { nextSequence: 1, nextGlobalSlotOrdinal: 257, slots: [] },
+      highWater: {
+        ...(handoff().highWater as object),
+        nextAttemptOrdinal: 1,
+        nextSlotRegistrationOrdinal: 257,
+      },
+    });
+    const slot = (handoff().slots as Array<Record<string, unknown>>)[0]!;
+    base.slots = Array.from({ length: 256 }, (_, slotIndex) => ({
+      ...slot,
+      id: `slot-${slotIndex}`,
+      aliases: [],
+      domId: `div-${slotIndex}`,
+      outcome: 'no_bid',
+      committedArtifact: 'none',
+      targetingOwnership: [],
+      gptToken: null,
+      targeting: Array.from({ length: 32 }, (_, targetingIndex) => [`k${targetingIndex}`, '']),
+    }));
+    base.attempts = Array.from({ length: 256 }, (_, slotIndex) => ({
+      id: `a1_AAECAwQFBgc${slotIndex.toString(36).padStart(11, 'A')}`,
+      slotId: `slot-${slotIndex}`,
+      ordinal: slotIndex + 1,
+      state: 'no_bid',
+      reason: null,
+    }));
+    base.highWater = {
+      ...(base.highWater as object),
+      nextNavigationAttemptOrdinal: 257,
+      nextAttemptOrdinal: 257,
+    };
+    base.trace = {
+      nextSequence: 1,
+      nextGlobalSlotOrdinal: 257,
+      slots: (base.slots as Array<Record<string, unknown>>).map((entry) => ({
+        slotId: entry.id,
+        impressions: 0,
+        bindings: [],
+      })),
+    };
+    const encoder = new TextEncoder();
+    let remaining =
+      MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES - encoder.encode(JSON.stringify(base)).byteLength;
+    expect(remaining).toBeGreaterThan(0);
+    for (const slotValue of base.slots as Array<Record<string, unknown>>) {
+      for (const pair of slotValue.targeting as string[][]) {
+        const next = Math.min(4096, remaining);
+        pair[1] = 'x'.repeat(next);
+        remaining -= next;
+        if (remaining === 0) break;
+      }
+      if (remaining === 0) break;
+    }
+    expect(remaining).toBe(0);
+    expect(encoder.encode(JSON.stringify(base))).toHaveLength(
+      MAX_FIRST_DISPLAY_NON_DIAGNOSTICS_BYTES
+    );
+    expect(snapshotFirstDisplayHandoffV1(base)).toBeDefined();
+
+    const firstPair = (
+      (base.slots as Array<Record<string, unknown>>)[0]!.targeting as string[][]
+    )[0]!;
+    firstPair[1] += 'x';
+    expect(snapshotFirstDisplayHandoffV1(base)).toBeUndefined();
+    firstPair[1] = firstPair[1]!.slice(0, -2);
+    expect(snapshotFirstDisplayHandoffV1(base)).toBeDefined();
+  });
+
+  it('mints a release-bound one-use capsule and clears every outcome', () => {
+    const physicalSlot = {};
+    const artifact = {};
+    const capsule = createFirstDisplayOwnershipCapsuleV1(HASH, 7, [physicalSlot, artifact]);
+    expect(capsule?.consume('b'.repeat(64), 7)).toBeUndefined();
+    expect(capsule?.consume(HASH, 8)).toBeUndefined();
+    expect(capsule?.consume(HASH, 7)).toEqual([physicalSlot, artifact]);
+    expect(capsule?.consume(HASH, 7)).toBeUndefined();
+
+    const cleared = createFirstDisplayOwnershipCapsuleV1(HASH, 7, [physicalSlot]);
+    cleared?.clear();
+    expect(cleared?.consume(HASH, 7)).toBeUndefined();
+    expect(
+      createFirstDisplayOwnershipCapsuleV1(HASH, 7, [physicalSlot, physicalSlot])
+    ).toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/driver.test.ts b/crates/trusted-server-js/lib/test/first_display/driver.test.ts
new file mode 100644
index 000000000..04edfe2c2
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/driver.test.ts
@@ -0,0 +1,373 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type {
+  FirstDisplayGoogletagBatchCallbacks,
+  FirstDisplayGptBoundCycleV1,
+  FirstDisplayGptHandoffCycleV1,
+} from '../../src/first_display/adapters/googletag';
+import { createFirstDisplayProjectedDriver } from '../../src/first_display/driver';
+import type { FirstDisplayGptProtocolV1 } from '../../src/first_display/leaf/gpt_protocol';
+import { snapshotFirstDisplayBatchV1 } from '../../src/first_display/leaf/projection';
+
+function batch() {
+  return snapshotFirstDisplayBatchV1(
+    Object.freeze({
+      version: 1,
+      projectionDigest: 'b'.repeat(64),
+      projection: Object.freeze({
+        version: 1,
+        auction: Object.freeze({
+          version: 1,
+          auctionId: 'initial',
+          results: Object.freeze([
+            Object.freeze({ slot: 'slot-1', outcome: 'winner', candidateId: 'candidate001' }),
+          ]),
+        }),
+        slots: Object.freeze([
+          Object.freeze({
+            slot: 'slot-1',
+            gamUnitPath: '/123/example',
+            divId: 'slot-1',
+            formats: Object.freeze([Object.freeze([300, 250])]),
+            targeting: Object.freeze({}),
+          }),
+        ]),
+        bids: Object.freeze([
+          Object.freeze({
+            candidateId: 'candidate001',
+            slot: 'slot-1',
+            provider: 'example',
+            upstreamBidId: 'upstream-1',
+            cpm: 1.25,
+            currency: 'USD',
+            targeting: Object.freeze({}),
+            rendererReservationId: `r1_${'a'.repeat(22)}`,
+            renderSource: Object.freeze({
+              type: 'adm',
+              version: 1,
+              adm: '<div>example</div>',
+              width: 300,
+              height: 250,
+            }),
+          }),
+        ]),
+      }),
+    })
+  )!;
+}
+
+function harness() {
+  const value = batch();
+  let gptCallbacks: FirstDisplayGoogletagBatchCallbacks | undefined;
+  let renderTerminal:
+    ((result: 'accepted' | 'failed' | 'cancelled', reason: string | null) => void) | undefined;
+  const gptBatch = {
+    start: vi.fn((callbacks: FirstDisplayGoogletagBatchCallbacks) => {
+      gptCallbacks = callbacks;
+      return true;
+    }),
+    captureDiagnosticsHandoff: vi.fn(() =>
+      Object.freeze([
+        [cycleOwner.value]
+          .filter((cycle): cycle is FirstDisplayGptHandoffCycleV1 => cycle !== undefined)
+          .map((cycle) =>
+            Object.freeze([
+              cycle[6],
+              cycle[7],
+              2,
+              false,
+              Object.freeze([]),
+              Object.freeze([
+                Object.freeze([
+                  1,
+                  'response-one',
+                  Object.freeze(['slotRequested', 'slotRenderEnded'] as const),
+                  'completed',
+                ] as const),
+              ]),
+            ] as const)
+          ),
+        Object.freeze([]),
+        2,
+        0,
+        0,
+      ] as const)
+    ),
+    captureHandoff: vi.fn(() =>
+      [cycleOwner.value]
+        .filter((cycle): cycle is FirstDisplayGptHandoffCycleV1 => cycle !== undefined)
+        .map((cycle) =>
+          Object.freeze([cycle[6], cycle[1].id, cycle[3], cycle[8], cycle[7], cycle[4]] as const)
+        )
+    ),
+    closeIngress: vi.fn(() => {
+      events.push('gpt:close');
+      return true;
+    }),
+    detachCommittedSlots: vi.fn(() => true),
+    dispose: vi.fn(),
+  };
+  const protocol: FirstDisplayGptProtocolV1 = Object.freeze([
+    1,
+    'gpt',
+    vi.fn(() =>
+      Object.freeze([
+        gptBatch.start,
+        gptBatch.closeIngress,
+        gptBatch.captureHandoff,
+        gptBatch.captureDiagnosticsHandoff,
+        gptBatch.detachCommittedSlots,
+        gptBatch.dispose,
+      ] as const)
+    ),
+  ]);
+  const events: string[] = [];
+  const cycleOwner: { value?: FirstDisplayGptHandoffCycleV1 } = {};
+  const renderer = {
+    bind: vi.fn((_cycle: FirstDisplayGptBoundCycleV1, terminal: typeof renderTerminal) => {
+      events.push('render:bind');
+      renderTerminal = terminal;
+      return true;
+    }),
+    recordGam: vi.fn((_cycle: FirstDisplayGptBoundCycleV1, result: string) => {
+      events.push(`render:gam:${result}`);
+      return true;
+    }),
+    recordFailure: vi.fn(() => true),
+    retire: vi.fn(() => true),
+    sweepCommittedArtifacts: vi.fn(() => 0),
+    captureHandoff: vi.fn(() => [[], [], 0, 1, 1] as const),
+    closeIngress: vi.fn(() => {
+      events.push('render:close');
+      return true;
+    }),
+    detachCommittedArtifacts: vi.fn(() => true),
+    sealTsAdmission: vi.fn(() => events.push('render:seal')),
+    dispose: vi.fn(() => events.push('render:dispose')),
+  };
+  const driver = createFirstDisplayProjectedDriver({
+    batch: value,
+    gpt: protocol,
+    gptInput: [window, () => undefined, document, (callback) => callback],
+    renderer,
+  });
+  const terminals: unknown[] = [];
+  driver.start(
+    value.outcomes,
+    () => {
+      events.push('action');
+      return true;
+    },
+    (slotId, result, reason) => terminals.push([slotId, result, reason])
+  );
+  const cycle: FirstDisplayGptBoundCycleV1 = Object.freeze([
+    value.projection.bids[0]!,
+    document.createElement('div'),
+    () => true,
+    'trusted_server' as const,
+    {},
+    value.projection.slots[0]!,
+    'slot-1',
+    'gt1_1',
+  ]);
+  cycleOwner.value = Object.freeze([...cycle, Object.freeze([])] as const);
+  return {
+    cycle,
+    driver,
+    events,
+    gptBatch,
+    getGptCallbacks: () => gptCallbacks!,
+    renderer,
+    setCapturedCycle: (cycle: FirstDisplayGptHandoffCycleV1) => {
+      cycleOwner.value = cycle;
+    },
+    getRenderTerminal: () => renderTerminal!,
+    terminals,
+  };
+}
+
+describe('projected first-display driver', () => {
+  it('joins exact GPT delivery with renderer-owned completion', () => {
+    const h = harness();
+    expect(h.getGptCallbacks()[0](h.cycle)).toBeUndefined();
+    expect(h.getGptCallbacks()[2]()).toBe(true);
+    h.getGptCallbacks()[3](h.cycle, 'nonempty_gam');
+    expect(h.terminals).toEqual([]);
+
+    h.getRenderTerminal()('accepted', null);
+    h.getRenderTerminal()('failed', 'internal_error');
+    expect(h.events).toEqual(['render:bind', 'action', 'render:gam:nonempty_gam']);
+    expect(h.terminals).toEqual([['slot-1', 'accepted', null]]);
+
+    h.getGptCallbacks()[4]?.(h.cycle);
+    h.getGptCallbacks()[4]?.(
+      Object.freeze([
+        h.cycle[0],
+        h.cycle[1],
+        h.cycle[2],
+        h.cycle[3],
+        {},
+        h.cycle[5],
+        h.cycle[6],
+        h.cycle[7],
+      ])
+    );
+    expect(h.renderer.retire).toHaveBeenCalledExactlyOnceWith(h.cycle);
+  });
+
+  it('fails an empty or mismatched physical GPT cycle without guessing', () => {
+    const empty = harness();
+    empty.getGptCallbacks()[0](empty.cycle);
+    empty.getGptCallbacks()[2]();
+    empty.getGptCallbacks()[3](empty.cycle, 'gam_empty');
+    expect(empty.renderer.recordGam).toHaveBeenCalledWith(empty.cycle, 'gam_empty');
+
+    const mismatched = harness();
+    mismatched.getGptCallbacks()[0](mismatched.cycle);
+    mismatched.getGptCallbacks()[2]();
+    mismatched.getGptCallbacks()[3](
+      Object.freeze([
+        mismatched.cycle[0],
+        mismatched.cycle[1],
+        mismatched.cycle[2],
+        mismatched.cycle[3],
+        {},
+        mismatched.cycle[5],
+        mismatched.cycle[6],
+        mismatched.cycle[7],
+      ]),
+      'nonempty_gam'
+    );
+    expect(mismatched.terminals).toEqual([['slot-1', 'failed', 'gpt_request_failed']]);
+    expect(mismatched.renderer.recordGam).not.toHaveBeenCalled();
+  });
+
+  it('owns exact-once sealing and disposal', () => {
+    const h = harness();
+    h.getGptCallbacks()[0](h.cycle);
+    h.getGptCallbacks()[2]();
+    h.getGptCallbacks()[1]('slot-1', 'gpt_request_timeout');
+    expect(h.terminals).toEqual([['slot-1', 'failed', 'gpt_request_timeout']]);
+
+    h.driver.sealTsAdmission();
+    h.driver.dispose();
+    h.driver.dispose();
+    expect(h.renderer.sealTsAdmission).toHaveBeenCalledOnce();
+    expect(h.gptBatch.dispose).toHaveBeenCalledOnce();
+    expect(h.renderer.dispose).toHaveBeenCalledOnce();
+  });
+
+  it('captures accepted objects before detaching them from both provisional owners', () => {
+    const h = harness();
+    h.getGptCallbacks()[0](h.cycle);
+    h.getGptCallbacks()[2]();
+    h.getGptCallbacks()[3](h.cycle, 'nonempty_gam');
+    h.getRenderTerminal()('accepted', null);
+    h.driver.sealTsAdmission();
+
+    expect(h.driver.closeIngress()).toBe(true);
+    expect(h.gptBatch.closeIngress).toHaveBeenCalledExactlyOnceWith(['slot-1']);
+    expect(h.events.slice(-2)).toEqual(['gpt:close', 'render:close']);
+    expect(h.driver.captureHandoff()).toEqual({
+      artifacts: [],
+      clockEpochMs: 0,
+      cycles: [[...h.cycle, []]],
+      diagnosticCycles: [
+        {
+          nextCycleOrdinal: 2,
+          quarantines: [],
+          records: [
+            {
+              ordinal: 1,
+              responseIdentifier: 'response-one',
+              seen: ['slotRequested', 'slotRenderEnded'],
+              state: 'completed',
+            },
+          ],
+          slotId: 'slot-1',
+          token: 'gt1_1',
+          unknownPriorCycle: false,
+        },
+      ],
+      gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+      identities: [h.cycle[4]],
+      nextReservationOrdinal: 1,
+      nextTraceTokenOrdinal: 2,
+      nextTicketOrdinal: 1,
+      tombstones: [],
+    });
+    expect(h.driver.detachCommittedArtifacts()).toBe(true);
+    expect(h.gptBatch.detachCommittedSlots).toHaveBeenCalledWith(['slot-1']);
+    expect(h.renderer.detachCommittedArtifacts).toHaveBeenCalledOnce();
+  });
+
+  it('captures live publisher ownership and a hydration replacement from late GPT handoff', () => {
+    const h = harness();
+    h.getGptCallbacks()[0](h.cycle);
+    h.getGptCallbacks()[2]();
+    h.getGptCallbacks()[3](h.cycle, 'nonempty_gam');
+    h.getRenderTerminal()('accepted', null);
+    h.driver.sealTsAdmission();
+    const replacement = document.createElement('div');
+    replacement.id = 'slot-1-hydrated';
+    document.body.append(replacement);
+    h.setCapturedCycle(
+      Object.freeze([
+        h.cycle[0],
+        replacement,
+        h.cycle[2],
+        'publisher',
+        h.cycle[4],
+        h.cycle[5],
+        h.cycle[6],
+        h.cycle[7],
+        Object.freeze([]),
+      ])
+    );
+
+    expect(h.driver.closeIngress()).toBe(true);
+    const captured = h.driver.captureHandoff();
+    expect(captured?.cycles[0]?.[1]).toBe(replacement);
+    expect(captured?.cycles[0]?.[3]).toBe('publisher');
+  });
+
+  it('rejects an action list that does not exactly match the immutable batch', () => {
+    const value = batch();
+    const driver = createFirstDisplayProjectedDriver({
+      batch: value,
+      gpt: Object.freeze([
+        1,
+        'gpt',
+        () =>
+          Object.freeze([
+            () => true,
+            () => true,
+            () => [],
+            () => undefined,
+            () => true,
+            () => undefined,
+          ] as const),
+      ]),
+      gptInput: [window, () => undefined, document, (callback) => callback],
+      renderer: {
+        bind: () => true,
+        recordGam: () => true,
+        recordFailure: () => true,
+        retire: () => true,
+        sweepCommittedArtifacts: () => 0,
+        captureHandoff: () => [[], [], 0, 1, 1] as const,
+        closeIngress: () => true,
+        detachCommittedArtifacts: () => true,
+        sealTsAdmission: () => undefined,
+        dispose: () => undefined,
+      },
+    });
+    expect(() =>
+      driver.start(
+        Object.freeze([{ slotId: 'other', kind: 'gpt_adm' }]),
+        () => true,
+        () => undefined
+      )
+    ).toThrow('tsjs');
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/gpt_adapter.test.ts b/crates/trusted-server-js/lib/test/first_display/gpt_adapter.test.ts
new file mode 100644
index 000000000..bd55feecb
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/gpt_adapter.test.ts
@@ -0,0 +1,1771 @@
+import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+
+import { createFirstDisplayGoogletagBatch } from '../../src/first_display/adapters/googletag';
+import { enqueueFirstDisplayGamAttribution } from '../../src/first_display/adapters/googletag';
+import type {
+  FirstDisplayGoogletagBatch,
+  FirstDisplayGoogletagBatchCallbacks,
+} from '../../src/first_display/adapters/googletag';
+import { snapshotFirstDisplayBatchV1 } from '../../src/first_display/leaf/projection';
+
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+function startAdapter(
+  adapter: FirstDisplayGoogletagBatch,
+  callbacks: Readonly<{
+    onBound: FirstDisplayGoogletagBatchCallbacks[0];
+    onFailure: FirstDisplayGoogletagBatchCallbacks[1];
+    onFirstAction: FirstDisplayGoogletagBatchCallbacks[2];
+    onRenderEnded: FirstDisplayGoogletagBatchCallbacks[3];
+    onRetire?: FirstDisplayGoogletagBatchCallbacks[4];
+  }>
+): boolean {
+  return adapter.start(
+    Object.freeze([
+      callbacks.onBound,
+      callbacks.onFailure,
+      callbacks.onFirstAction,
+      callbacks.onRenderEnded,
+      callbacks.onRetire,
+    ])
+  );
+}
+
+function fixture() {
+  return Object.freeze({
+    version: 1,
+    projectionDigest: 'b'.repeat(64),
+    projection: Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'initial',
+        results: Object.freeze([
+          Object.freeze({ slot: 'slot-1', outcome: 'winner', candidateId: 'candidate001' }),
+        ]),
+      }),
+      slots: Object.freeze([
+        Object.freeze({
+          slot: 'slot-1',
+          gamUnitPath: '/123/example',
+          divId: 'slot-1',
+          formats: Object.freeze([Object.freeze([300, 250])]),
+          targeting: Object.freeze({ placement: 'article' }),
+        }),
+      ]),
+      bids: Object.freeze([
+        Object.freeze({
+          candidateId: 'candidate001',
+          slot: 'slot-1',
+          provider: 'example',
+          upstreamBidId: 'upstream-1',
+          cpm: 1.25,
+          currency: 'USD',
+          targeting: Object.freeze({ hb_pb: '1.25' }),
+          rendererReservationId: RESERVATION_ID,
+          renderSource: Object.freeze({
+            type: 'adm',
+            version: 1,
+            adm: '<div>example</div>',
+            width: 300,
+            height: 250,
+          }),
+        }),
+      ]),
+    }),
+  });
+}
+
+function twoSlotFixture() {
+  const secondReservationId = `r1_${'b'.repeat(22)}`;
+  return Object.freeze({
+    version: 1,
+    projectionDigest: 'b'.repeat(64),
+    projection: Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'initial',
+        results: Object.freeze([
+          Object.freeze({ slot: 'slot-1', outcome: 'winner', candidateId: 'candidate001' }),
+          Object.freeze({ slot: 'slot-2', outcome: 'winner', candidateId: 'candidate002' }),
+        ]),
+      }),
+      slots: Object.freeze([
+        Object.freeze({
+          slot: 'slot-1',
+          gamUnitPath: '/123/example-one',
+          divId: 'slot-1',
+          formats: Object.freeze([Object.freeze([300, 250])]),
+          targeting: Object.freeze({ placement: 'article' }),
+        }),
+        Object.freeze({
+          slot: 'slot-2',
+          gamUnitPath: '/123/example-two',
+          divId: 'slot-2',
+          formats: Object.freeze([Object.freeze([728, 90])]),
+          targeting: Object.freeze({ placement: 'sidebar' }),
+        }),
+      ]),
+      bids: Object.freeze([
+        Object.freeze({
+          candidateId: 'candidate001',
+          slot: 'slot-1',
+          provider: 'example',
+          upstreamBidId: 'upstream-1',
+          cpm: 1.25,
+          currency: 'USD',
+          targeting: Object.freeze({ hb_pb: '1.25' }),
+          rendererReservationId: RESERVATION_ID,
+          renderSource: Object.freeze({
+            type: 'adm',
+            version: 1,
+            adm: '<div>example one</div>',
+            width: 300,
+            height: 250,
+          }),
+        }),
+        Object.freeze({
+          candidateId: 'candidate002',
+          slot: 'slot-2',
+          provider: 'example',
+          upstreamBidId: 'upstream-2',
+          cpm: 2.5,
+          currency: 'USD',
+          targeting: Object.freeze({ hb_pb: '2.50' }),
+          rendererReservationId: secondReservationId,
+          renderSource: Object.freeze({
+            type: 'adm',
+            version: 1,
+            adm: '<div>example two</div>',
+            width: 728,
+            height: 90,
+          }),
+        }),
+      ]),
+    }),
+  });
+}
+
+function protocol() {
+  return Object.freeze({
+    deadlines: Object.freeze({
+      externalReadyMs: 10_000 as const,
+      requestStartMs: 3_000 as const,
+      completionMs: 10_000 as const,
+    }),
+    requestPlan: (candidate: unknown) => {
+      const value = candidate as { initialLoadDisabled: boolean; ownership: string };
+      if (value.ownership === 'publisher') {
+        return Object.freeze({
+          operations: Object.freeze(['refresh'] as const),
+          requestOperation: 0,
+        });
+      }
+      return value.initialLoadDisabled
+        ? Object.freeze({
+            operations: Object.freeze(['display', 'refresh'] as const),
+            requestOperation: 1 as const,
+          })
+        : Object.freeze({ operations: Object.freeze(['display'] as const), requestOperation: 0 });
+    },
+    classifyRenderEnded: (candidate: unknown) => {
+      const value = candidate as { isEmpty?: unknown };
+      return value.isEmpty === true
+        ? ('gam_empty' as const)
+        : value.isEmpty === false
+          ? ('nonempty_gam' as const)
+          : undefined;
+    },
+  });
+}
+
+describe('first-display GPT adapter', () => {
+  it('owns enabled GAM attribution before publisher parser work without a winning bid', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const commands: Array<() => void> = [];
+    const order: string[] = [];
+    const setConfig = vi.fn(() => order.push('trusted-server'));
+    Object.defineProperty(dom.window, 'tsjs', {
+      configurable: true,
+      value: { adInit: true },
+    });
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: { cmd: commands, setConfig },
+      writable: true,
+    });
+    expect(enqueueFirstDisplayGamAttribution(dom.window as unknown as Window)).toBe(true);
+    commands.push(() => order.push('publisher'));
+    commands.splice(0).forEach((command) => command());
+
+    expect(order).toEqual(['trusted-server', 'publisher']);
+    expect(setConfig).toHaveBeenCalledExactlyOnceWith({ targeting: { ts: 'true' } });
+  });
+
+  it('creates an absent GPT queue and isolates a missing or throwing targeting API', () => {
+    const absent: { googletag?: unknown } = {};
+    expect(enqueueFirstDisplayGamAttribution(absent as unknown as Window)).toBe(true);
+    const created = absent.googletag as { cmd: Array<() => void> };
+    expect(created.cmd).toHaveLength(1);
+    expect(() => created.cmd[0]?.()).not.toThrow();
+
+    const publisher = vi.fn();
+    const commands: Array<() => void> = [];
+    const throwing = {
+      googletag: {
+        cmd: commands,
+        setConfig: () => {
+          throw new Error('targeting unavailable');
+        },
+      },
+    };
+    expect(enqueueFirstDisplayGamAttribution(throwing as unknown as Window)).toBe(true);
+    commands.push(publisher);
+    expect(() => commands.splice(0).forEach((command) => command())).not.toThrow();
+    expect(publisher).toHaveBeenCalledOnce();
+  });
+
+  it('observes publisher GPT calls, events, and targeting until ingress closes', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const mutations = vi.fn(() => true);
+    const retired = vi.fn();
+    const slot = {
+      clearTargeting: vi.fn(() => undefined),
+      getSlotElementId: () => 'slot-1',
+      getTargeting: () => [],
+      setTargeting: vi.fn((_key: string, _value: string) => slot),
+    };
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [slot],
+      refresh: vi.fn(),
+      removeEventListener: () => undefined,
+    };
+    const binding = {
+      pubadsReady: true,
+      cmd: { push: (command: () => void) => command() },
+      defineSlot: vi.fn(() => slot),
+      destroySlots: vi.fn(() => true),
+      display: vi.fn(),
+      getConfig: () => ({ disableInitialLoad: false }),
+      pubads: () => service,
+    };
+    Object.defineProperty(dom.window, 'googletag', { configurable: true, value: binding });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      onNativeMutation: mutations,
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+      onRetire: retired,
+    });
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    mutations.mockClear();
+
+    slot.setTargeting('publisher', 'value');
+    service.refresh([slot]);
+    binding.display('publisher-slot');
+    listeners.get('slotRequested')?.({ slot, responseIdentifier: 'response-two' });
+    listeners.get('slotRenderEnded')?.({
+      slot,
+      responseIdentifier: 'response-two',
+      isEmpty: false,
+    });
+    expect(mutations).toHaveBeenCalledTimes(5);
+    expect(retired).toHaveBeenCalledOnce();
+
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    const diagnostics = adapter.captureDiagnosticsHandoff();
+    const [cycle] = diagnostics?.[0] ?? [];
+    expect(cycle?.[2]).toBe(3);
+    expect(cycle?.[5]).toEqual([
+      expect.arrayContaining([1, 'completed']),
+      [2, 'response-two', ['slotRequested', 'slotRenderEnded'], 'completed'],
+    ]);
+    mutations.mockClear();
+    slot.setTargeting('publisher', 'later');
+    service.refresh([slot]);
+    binding.display('publisher-slot');
+    listeners.get('slotRequested')?.({ slot });
+    expect(mutations).not.toHaveBeenCalled();
+  });
+
+  it('defines, targets, and starts one TS slot before attributing its render event', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const events: string[] = [];
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slot = {
+      addService: vi.fn(() => slot),
+      getSlotElementId: vi.fn(() => 'slot-1'),
+      setTargeting: vi.fn((key: string) => {
+        events.push(`target:${key}`);
+        return slot;
+      }),
+    };
+    const service = {
+      addEventListener: vi.fn((name: string, listener: (event: unknown) => void) => {
+        listeners.set(name, listener);
+      }),
+      enableSingleRequest: vi.fn(() => {
+        events.push('sra');
+        return true;
+      }),
+      getSlots: vi.fn(() => []),
+      refresh: vi.fn(() => events.push('refresh')),
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: false,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: vi.fn(() => slot),
+        display: vi.fn(() => events.push('display')),
+        enableServices: vi.fn(() => events.push('services')),
+        getConfig: vi.fn(() => ({ disableInitialLoad: false })),
+        pubads: vi.fn(() => service),
+      },
+      writable: true,
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture());
+    expect(batch).toBeDefined();
+    const timers: Array<() => void> = [];
+    const renders: unknown[] = [];
+    const failures: unknown[] = [];
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch!.projection,
+      protocol: protocol(),
+      setTimer: (callback) => {
+        timers.push(callback);
+        return callback;
+      },
+      clearTimer: (handle) => {
+        const index = timers.indexOf(handle as () => void);
+        if (index >= 0) timers.splice(index, 1);
+      },
+    });
+
+    expect(
+      startAdapter(adapter, {
+        onBound: (cycle) => {
+          expect(cycle[1]).toBe(dom.window.document.getElementById('slot-1'));
+          events.push(`bound:${cycle[6]}:${cycle[3]}`);
+        },
+        onFailure: (slotId, reason) => failures.push([slotId, reason]),
+        onFirstAction: () => {
+          events.push('first-action');
+          return true;
+        },
+        onRenderEnded: (cycle, result) => renders.push([cycle[6], result]),
+      })
+    ).toBe(true);
+    expect(events).toEqual([
+      'bound:slot-1:trusted_server',
+      'target:hb_adid',
+      'target:hb_pb',
+      'target:placement',
+      'first-action',
+      'sra',
+      'services',
+      'display',
+    ]);
+    expect(slot.setTargeting.mock.calls).toEqual([
+      ['hb_adid', `r1_${'a'.repeat(22)}`],
+      ['hb_pb', '1.25'],
+      ['placement', 'article'],
+    ]);
+
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    expect(renders).toEqual([['slot-1', 'nonempty_gam']]);
+    expect(failures).toEqual([]);
+    expect(timers).toHaveLength(0);
+    adapter.dispose();
+    expect(service.removeEventListener.mock.calls.map(([name]) => name)).toEqual([
+      'slotRequested',
+      'slotRenderEnded',
+    ]);
+  });
+
+  it.each(['enableSingleRequest', 'enableServices'] as const)(
+    'fails the entire batch without a request when %s throws',
+    (failure) => {
+      const dom = new JSDOM('<!doctype html><div id="slot-1"></div><div id="slot-2"></div>', {
+        url: 'https://publisher.example/',
+      });
+      const slots = new Map<string, object>();
+      const display = vi.fn();
+      const refresh = vi.fn();
+      const service = {
+        addEventListener: vi.fn(),
+        enableSingleRequest: vi.fn(() => {
+          if (failure === 'enableSingleRequest') throw new Error('fictional SRA failure');
+          return true;
+        }),
+        getSlots: () => [],
+        refresh,
+        removeEventListener: vi.fn(),
+      };
+      const binding = {
+        pubadsReady: false,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: (_path: string, _sizes: unknown, elementId: string) => {
+          const targeting = new Map<string, string[]>();
+          const slot = {
+            addService: () => slot,
+            clearTargeting: (key: string) => targeting.delete(key),
+            getTargeting: (key: string) => targeting.get(key) ?? [],
+            setTargeting: (key: string, value: string) => {
+              targeting.set(key, [value]);
+              return slot;
+            },
+          };
+          slots.set(elementId, slot);
+          return slot;
+        },
+        display,
+        enableServices: () => {
+          if (failure === 'enableServices') throw new Error('fictional service failure');
+        },
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      };
+      Object.defineProperty(dom.window, 'googletag', { configurable: true, value: binding });
+      const failures: unknown[] = [];
+      const firstAction = vi.fn(() => true);
+      const batch = snapshotFirstDisplayBatchV1(twoSlotFixture())!;
+      const adapter = createFirstDisplayGoogletagBatch({
+        browser: dom.window as unknown as Window,
+        clearTimer: () => undefined,
+        document: dom.window.document,
+        projection: batch.projection,
+        protocol: protocol(),
+        setTimer: (callback) => callback,
+      });
+
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: (slotId, reason) => failures.push([slotId, reason]),
+        onFirstAction: firstAction,
+        onRenderEnded: () => undefined,
+      });
+
+      expect(firstAction).toHaveBeenCalledOnce();
+      expect(failures).toEqual([
+        ['slot-1', 'gpt_request_failed'],
+        ['slot-2', 'gpt_request_failed'],
+      ]);
+      expect(display).not.toHaveBeenCalled();
+      expect(refresh).not.toHaveBeenCalled();
+    }
+  );
+
+  it('arms every synchronous SRA display cycle before the first display requests all slots', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div><div id="slot-2"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slots: object[] = [];
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [],
+      refresh: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    const display = vi.fn(() => {
+      for (const slot of slots) listeners.get('slotRequested')?.({ slot });
+      for (const slot of slots) listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    });
+    const binding = {
+      pubadsReady: true,
+      cmd: { push: (command: () => void) => command() },
+      defineSlot: (_path: string, _sizes: unknown, _elementId: string) => {
+        const targeting = new Map<string, string[]>();
+        const slot = {
+          addService: () => slot,
+          clearTargeting: (key: string) => targeting.delete(key),
+          getTargeting: (key: string) => targeting.get(key) ?? [],
+          setTargeting: (key: string, value: string) => {
+            targeting.set(key, [value]);
+            return slot;
+          },
+        };
+        slots.push(slot);
+        return slot;
+      },
+      display,
+      getConfig: () => ({ disableInitialLoad: false }),
+      pubads: () => service,
+    };
+    Object.defineProperty(dom.window, 'googletag', { configurable: true, value: binding });
+    const rendered: string[] = [];
+    const failures: unknown[] = [];
+    const firstAction = vi.fn(() => true);
+    const batch = snapshotFirstDisplayBatchV1(twoSlotFixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      clearTimer: () => undefined,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+    });
+
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: (slotId, reason) => failures.push([slotId, reason]),
+      onFirstAction: firstAction,
+      onRenderEnded: (cycle) => rendered.push(cycle[6]),
+    });
+
+    expect(display).toHaveBeenCalledOnce();
+    expect(firstAction).toHaveBeenCalledOnce();
+    expect(rendered).toEqual(['slot-1', 'slot-2']);
+    expect(failures).toEqual([]);
+  });
+
+  it('invalidates the delayed-owner binding when a publisher replaces the physical slot', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slot = {
+      addService: () => slot,
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => slot,
+    };
+    const replacement = {
+      addService: () => replacement,
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => replacement,
+    };
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [],
+      removeEventListener: () => undefined,
+    };
+    const defineSlot = vi.fn().mockReturnValueOnce(slot).mockReturnValueOnce(replacement);
+    let destroyMode: 'throw' | 'false' | 'true' = 'throw';
+    const destroySlots = vi.fn((slots?: readonly object[]) => {
+      if (destroyMode === 'throw') throw new Error('fictional destroy failure');
+      if (destroyMode === 'false') return false;
+      if (Array.isArray(slots)) (slots as object[]).length = 0;
+      return true;
+    });
+    const binding = {
+      pubadsReady: true,
+      cmd: { push: (command: () => void) => command() },
+      defineSlot,
+      destroySlots,
+      display: (_elementId: string) => undefined,
+      getConfig: () => ({ disableInitialLoad: false }),
+      pubads: () => service,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: binding,
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const bound: { value?: Parameters<FirstDisplayGoogletagBatchCallbacks[0]>[0] } = {};
+    const retired = vi.fn();
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      clearTimer: () => undefined,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+    });
+    startAdapter(adapter, {
+      onBound: (cycle) => {
+        bound.value = cycle;
+      },
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+      onRetire: retired,
+    });
+
+    expect(bound.value?.[2]()).toBe(true);
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    expect(bound.value?.[2]()).toBe(true);
+
+    expect(() => binding.destroySlots([slot])).toThrow('fictional destroy failure');
+    expect(bound.value?.[2]()).toBe(true);
+    expect(retired).not.toHaveBeenCalled();
+    destroyMode = 'false';
+    expect(binding.destroySlots([slot])).toBe(false);
+    expect(bound.value?.[2]()).toBe(true);
+    expect(retired).not.toHaveBeenCalled();
+    destroyMode = 'true';
+    const targets = [slot];
+    expect(binding.destroySlots(targets)).toBe(true);
+    expect(targets).toEqual([]);
+    expect(binding.defineSlot('/publisher/replacement', [[300, 250]], 'slot-1')).toBe(replacement);
+    binding.display('slot-1');
+    expect(bound.value?.[2]()).toBe(false);
+    expect(retired).toHaveBeenCalledOnce();
+  });
+
+  it('cancels a pending command and compare-restores an adapter-created GPT queue', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture());
+    const timers: Array<() => void> = [];
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch!.projection,
+      protocol: protocol(),
+      setTimer: (callback) => {
+        timers.push(callback);
+        return callback;
+      },
+      clearTimer: () => undefined,
+    });
+    expect(
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: () => undefined,
+        onFirstAction: () => true,
+        onRenderEnded: () => undefined,
+      })
+    ).toBe(true);
+    expect(
+      (dom.window as unknown as { googletag?: { cmd?: unknown[] } }).googletag?.cmd
+    ).toHaveLength(1);
+
+    adapter.dispose();
+    expect(Object.prototype.hasOwnProperty.call(dom.window, 'googletag')).toBe(false);
+  });
+
+  it('uses publisher refresh and compare-restores only unchanged targeting', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+    const slot = {
+      clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+      getSlotElementId: vi.fn(() => 'slot-1'),
+      getTargeting: vi.fn((key: string) => targeting.get(key) ?? []),
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return slot;
+      }),
+    };
+    const listeners = new Map<string, (event: unknown) => void>();
+    const refresh = vi.fn();
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [slot],
+      refresh,
+      removeEventListener: vi.fn(),
+    };
+    const defineSlot = vi.fn();
+    const display = vi.fn();
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot,
+        display,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    const firstAction = vi.fn(() => true);
+
+    startAdapter(adapter, {
+      onBound: (cycle) => expect(cycle[3]).toBe('publisher'),
+      onFailure: () => undefined,
+      onFirstAction: firstAction,
+      onRenderEnded: () => undefined,
+    });
+    expect(defineSlot).not.toHaveBeenCalled();
+    expect(display).not.toHaveBeenCalled();
+    expect(refresh).toHaveBeenCalledWith([slot], { changeCorrelator: false });
+    expect(firstAction).toHaveBeenCalledOnce();
+
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    slot.setTargeting('placement', 'article');
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(adapter.captureHandoff()?.[0]?.[3]).toEqual([
+      { installed: RESERVATION_ID, key: 'hb_adid', prior: [] },
+      { installed: '1.25', key: 'hb_pb', prior: ['publisher-original'] },
+    ]);
+    adapter.dispose();
+    expect(targeting.get('placement')).toEqual(['article']);
+    expect(targeting.get('hb_pb')).toEqual(['publisher-original']);
+    expect(targeting.has('hb_adid')).toBe(false);
+  });
+
+  it.each(['reentrant_refresh', 'slot_object_display'] as const)(
+    'does not attribute a competing publisher %s to the pending TS request',
+    (competition) => {
+      const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+        url: 'https://publisher.example/',
+      });
+      const listeners = new Map<string, (event: unknown) => void>();
+      const slot = {
+        getSlotElementId: () => 'slot-1',
+        getTargeting: () => [],
+        setTargeting: () => slot,
+        clearTargeting: () => slot,
+      };
+      let reentered = false;
+      const refresh = vi.fn((_slots?: readonly object[]) => {
+        if (competition === 'reentrant_refresh' && !reentered) {
+          reentered = true;
+          service.refresh([slot]);
+        }
+      });
+      const service = {
+        addEventListener: (name: string, listener: (event: unknown) => void) =>
+          listeners.set(name, listener),
+        getSlots: () => [slot],
+        refresh,
+        removeEventListener: () => undefined,
+      };
+      const display = vi.fn((_slot?: unknown) => undefined);
+      const binding = {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => undefined,
+        display,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      };
+      Object.defineProperty(dom.window, 'googletag', {
+        configurable: true,
+        value: binding,
+      });
+      const batch = snapshotFirstDisplayBatchV1(fixture())!;
+      const failure = vi.fn();
+      const adapter = createFirstDisplayGoogletagBatch({
+        browser: dom.window as unknown as Window,
+        clearTimer: () => undefined,
+        diagnosticsActive: true,
+        document: dom.window.document,
+        projection: batch.projection,
+        protocol: protocol(),
+        setTimer: (callback) => callback,
+      });
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: failure,
+        onFirstAction: () => true,
+        onRenderEnded: () => undefined,
+      });
+
+      if (competition === 'slot_object_display') binding.display(slot as never);
+      listeners.get('slotRequested')?.({ slot });
+
+      expect(refresh).toHaveBeenCalledTimes(competition === 'reentrant_refresh' ? 2 : 1);
+      expect(display).toHaveBeenCalledTimes(competition === 'slot_object_display' ? 1 : 0);
+      expect(failure).toHaveBeenCalledWith('slot-1', 'cycle_unattributable');
+      expect(adapter.closeIngress([])).toBe(true);
+      expect(adapter.captureDiagnosticsHandoff()?.[1][0]).toMatchObject({
+        event: 'slotRequested',
+        requestedSlotSizes: null,
+      });
+      adapter.dispose();
+    }
+  );
+
+  it.each(['exact', 'hydration'] as const)(
+    'hands off a %s late publisher definition without creating a second GPT slot',
+    (mode) => {
+      const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+        url: 'https://publisher.example/',
+      });
+      const warning = vi.spyOn(dom.window.console, 'warn').mockImplementation(() => undefined);
+      const listeners = new Map<string, (event: unknown) => void>();
+      const targeting = new Map<string, string[]>();
+      const slot = {
+        addService: () => slot,
+        clearTargeting: (key: string) => targeting.delete(key),
+        getAdUnitPath: () => '/123/example',
+        getSlotElementId: () => 'slot-1',
+        getTargeting: (key: string) => targeting.get(key) ?? [],
+        setTargeting: (key: string, value: string | readonly string[]) => {
+          targeting.set(key, typeof value === 'string' ? [value] : [...value]);
+          return slot;
+        },
+      };
+      let defined = false;
+      let disabled = false;
+      const refresh = vi.fn((_slots?: readonly object[], _options?: unknown) => undefined);
+      const service = {
+        addEventListener: (name: string, listener: (event: unknown) => void) =>
+          listeners.set(name, listener),
+        getSlots: () => (defined ? [slot] : []),
+        refresh,
+        removeEventListener: () => undefined,
+      };
+      const defineSlot = vi.fn((_path?: unknown, _sizes?: unknown, _elementId?: unknown) => {
+        defined = true;
+        return slot;
+      });
+      const display = vi.fn((_target?: unknown) => undefined);
+      const binding = {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot,
+        destroySlots: vi.fn(() => true),
+        display,
+        getConfig: () => ({ disableInitialLoad: disabled }),
+        pubads: () => service,
+      };
+      Object.defineProperty(dom.window, 'googletag', {
+        configurable: true,
+        value: binding,
+      });
+      const batch = snapshotFirstDisplayBatchV1(fixture())!;
+      const adapter = createFirstDisplayGoogletagBatch({
+        browser: dom.window as unknown as Window,
+        clearTimer: () => undefined,
+        document: dom.window.document,
+        projection: batch.projection,
+        protocol: protocol(),
+        setTimer: (callback) => callback,
+      });
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: () => undefined,
+        onFirstAction: () => true,
+        onRenderEnded: () => undefined,
+      });
+      listeners.get('slotRequested')?.({ slot });
+      listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+      disabled = true;
+
+      let elementId = 'slot-1';
+      let path: string = '/publisher/mismatch';
+      let sizes: readonly (readonly [number, number])[] = [[728, 90]];
+      if (mode === 'hydration') {
+        dom.window.document.getElementById('slot-1')?.remove();
+        const replacement = dom.window.document.createElement('div');
+        replacement.id = 'slot-1-hydrated';
+        dom.window.document.body.append(replacement);
+        elementId = replacement.id;
+        path = '/123/example';
+        sizes = [[300, 250]];
+      }
+      expect(binding.defineSlot(path, sizes, elementId)).toBe(slot);
+      expect(defineSlot).toHaveBeenCalledTimes(1);
+      if (mode === 'exact') {
+        expect(warning).toHaveBeenCalledExactlyOnceWith('GPT publisher handoff metadata mismatch', {
+          formatsMismatch: true,
+          pathMismatch: true,
+        });
+        slot.setTargeting('hb_pb', 'publisher');
+      } else {
+        expect(warning).not.toHaveBeenCalled();
+      }
+
+      const displayCalls = display.mock.calls.length;
+      const refreshCalls = refresh.mock.calls.length;
+      binding.display(elementId);
+      service.refresh([slot], { changeCorrelator: false } as never);
+      expect(display).toHaveBeenCalledTimes(displayCalls);
+      expect(refresh).toHaveBeenCalledTimes(refreshCalls);
+      binding.display(elementId);
+      service.refresh([slot], { changeCorrelator: false } as never);
+      expect(display).toHaveBeenCalledTimes(displayCalls + 1);
+      expect(refresh).toHaveBeenCalledTimes(refreshCalls + 1);
+
+      expect(adapter.closeIngress(['slot-1'])).toBe(true);
+      expect(adapter.captureHandoff()?.[0]?.slice(0, 3)).toEqual([
+        'slot-1',
+        elementId,
+        'publisher',
+      ]);
+      expect(adapter.captureHandoff()?.[0]?.[3]).toEqual(
+        mode === 'exact'
+          ? [
+              { installed: RESERVATION_ID, key: 'hb_adid', prior: [] },
+              { installed: 'article', key: 'placement', prior: [] },
+            ]
+          : [
+              { installed: RESERVATION_ID, key: 'hb_adid', prior: [] },
+              { installed: '1.25', key: 'hb_pb', prior: [] },
+              { installed: 'article', key: 'placement', prior: [] },
+            ]
+      );
+      adapter.dispose();
+      expect(binding.destroySlots).not.toHaveBeenCalled();
+    }
+  );
+
+  it('rejects targeting handoff after a publisher replaces an observed method', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+    const slot = {
+      clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+      getSlotElementId: () => 'slot-1',
+      getTargeting: (key: string) => targeting.get(key) ?? [],
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return slot;
+      }),
+    };
+    const listeners = new Map<string, (event: unknown) => void>();
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [slot],
+      refresh: () => undefined,
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => undefined,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+
+    const replacement = vi.fn((key: string, value: string | string[]) => {
+      targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+      return slot;
+    });
+    Object.defineProperty(slot, 'setTargeting', {
+      configurable: true,
+      value: replacement,
+      writable: true,
+    });
+    slot.setTargeting('hb_pb', '1.25');
+
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(adapter.captureHandoff()?.[0]?.[3]).toEqual([]);
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(true);
+    adapter.dispose();
+    expect(replacement).toHaveBeenCalledWith('hb_pb', '1.25');
+    expect(targeting.get('hb_pb')).toEqual(['1.25']);
+  });
+
+  it.each(['close', 'dispose'] as const)(
+    'does not restore stale publisher targeting through a replacement during %s cleanup',
+    (cleanup) => {
+      const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+        url: 'https://publisher.example/',
+      });
+      const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+      const slot = {
+        clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+        getSlotElementId: () => 'slot-1',
+        getTargeting: (key: string) => targeting.get(key) ?? [],
+        setTargeting: vi.fn((key: string, value: string | string[]) => {
+          targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+          return slot;
+        }),
+      };
+      const listeners = new Map<string, (event: unknown) => void>();
+      const service = {
+        addEventListener: (name: string, listener: (event: unknown) => void) =>
+          listeners.set(name, listener),
+        getSlots: () => [slot],
+        refresh: () => undefined,
+        removeEventListener: () => undefined,
+      };
+      Object.defineProperty(dom.window, 'googletag', {
+        configurable: true,
+        value: {
+          pubadsReady: true,
+          cmd: { push: (command: () => void) => command() },
+          defineSlot: () => undefined,
+          display: () => undefined,
+          getConfig: () => ({ disableInitialLoad: false }),
+          pubads: () => service,
+        },
+      });
+      const batch = snapshotFirstDisplayBatchV1(fixture())!;
+      const adapter = createFirstDisplayGoogletagBatch({
+        browser: dom.window as unknown as Window,
+        document: dom.window.document,
+        projection: batch.projection,
+        protocol: protocol(),
+        setTimer: (callback) => callback,
+        clearTimer: () => undefined,
+      });
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: () => undefined,
+        onFirstAction: () => true,
+        onRenderEnded: () => undefined,
+      });
+      listeners.get('slotRequested')?.({ slot });
+      listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+
+      const replacement = vi.fn((key: string, value: string | string[]) => {
+        targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return slot;
+      });
+      Object.defineProperty(slot, 'setTargeting', {
+        configurable: true,
+        value: replacement,
+        writable: true,
+      });
+      slot.setTargeting('hb_pb', '1.25');
+
+      if (cleanup === 'close') {
+        expect(adapter.closeIngress([])).toBe(true);
+        adapter.dispose();
+      } else {
+        adapter.dispose();
+      }
+      expect(replacement).toHaveBeenCalledOnce();
+      expect(targeting.get('hb_pb')).toEqual(['1.25']);
+    }
+  );
+
+  it.each(['close', 'dispose'] as const)(
+    'honors a same-value publisher write from getTargeting during %s cleanup',
+    (cleanup) => {
+      const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+        url: 'https://publisher.example/',
+      });
+      const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+      let cleanupPhase = false;
+      let reentrantCleanupCalls = 0;
+      const slot = {
+        clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+        getSlotElementId: () => 'slot-1',
+        getTargeting: vi.fn((key: string) => {
+          if (cleanupPhase && key === 'hb_pb' && reentrantCleanupCalls === 0) {
+            reentrantCleanupCalls += 1;
+            slot.setTargeting('hb_pb', '1.25');
+          }
+          return targeting.get(key) ?? [];
+        }),
+        setTargeting: vi.fn((key: string, value: string | string[]) => {
+          targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+          return slot;
+        }),
+      };
+      const listeners = new Map<string, (event: unknown) => void>();
+      const service = {
+        addEventListener: (name: string, listener: (event: unknown) => void) =>
+          listeners.set(name, listener),
+        getSlots: () => [slot],
+        refresh: () => undefined,
+        removeEventListener: () => undefined,
+      };
+      Object.defineProperty(dom.window, 'googletag', {
+        configurable: true,
+        value: {
+          pubadsReady: true,
+          cmd: { push: (command: () => void) => command() },
+          defineSlot: () => undefined,
+          display: () => undefined,
+          getConfig: () => ({ disableInitialLoad: false }),
+          pubads: () => service,
+        },
+      });
+      const batch = snapshotFirstDisplayBatchV1(fixture())!;
+      const adapter = createFirstDisplayGoogletagBatch({
+        browser: dom.window as unknown as Window,
+        document: dom.window.document,
+        projection: batch.projection,
+        protocol: protocol(),
+        setTimer: (callback) => callback,
+        clearTimer: () => undefined,
+      });
+      startAdapter(adapter, {
+        onBound: () => undefined,
+        onFailure: () => undefined,
+        onFirstAction: () => true,
+        onRenderEnded: () => undefined,
+      });
+      listeners.get('slotRequested')?.({ slot });
+      listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+
+      cleanupPhase = true;
+      if (cleanup === 'close') {
+        expect(adapter.closeIngress([])).toBe(true);
+        adapter.dispose();
+      } else {
+        adapter.dispose();
+      }
+      expect(reentrantCleanupCalls).toBe(1);
+      expect(targeting.get('hb_pb')).toEqual(['1.25']);
+    }
+  );
+
+  it('seals retained targeting while same-value publisher writes are still observed', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+    let sealing = false;
+    let reentrantSealingCalls = 0;
+    const slot = {
+      clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+      getSlotElementId: () => 'slot-1',
+      getTargeting: vi.fn((key: string) => {
+        if (sealing && key === 'hb_pb' && reentrantSealingCalls === 0) {
+          reentrantSealingCalls += 1;
+          slot.setTargeting('hb_pb', '1.25');
+        }
+        return targeting.get(key) ?? [];
+      }),
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return slot;
+      }),
+    };
+    const listeners = new Map<string, (event: unknown) => void>();
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [slot],
+      refresh: () => undefined,
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => undefined,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+
+    sealing = true;
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(adapter.captureHandoff()?.[0]?.[3].some(({ key }) => key === 'hb_pb')).toBe(false);
+    expect(reentrantSealingCalls).toBe(1);
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(true);
+    adapter.dispose();
+    expect(targeting.get('hb_pb')).toEqual(['1.25']);
+  });
+
+  it('cleans failed TS slots while publisher targeting observation is still continuous', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div><div id="slot-2"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const targeting = new Map<string, string[]>([['hb_pb', ['publisher-original']]]);
+    const publisherSlot = {
+      clearTargeting: vi.fn((key: string) => targeting.delete(key)),
+      getSlotElementId: () => 'slot-1',
+      getTargeting: (key: string) => targeting.get(key) ?? [],
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        targeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return publisherSlot;
+      }),
+    };
+    const failedSlot = {
+      addService: () => failedSlot,
+      getSlotElementId: () => 'slot-2',
+      setTargeting: () => failedSlot,
+    };
+    const listeners = new Map<string, (event: unknown) => void>();
+    const destroySlots = vi.fn((slots: object[]) => {
+      expect(slots).toEqual([failedSlot]);
+      slots.length = 0;
+      publisherSlot.setTargeting('hb_pb', '1.25');
+      return true;
+    });
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [publisherSlot],
+      refresh: () => undefined,
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => failedSlot,
+        destroySlots,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(twoSlotFixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    for (const slot of [publisherSlot, failedSlot]) {
+      listeners.get('slotRequested')?.({ slot });
+      listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    }
+
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(destroySlots).toHaveBeenCalledOnce();
+    expect(adapter.captureHandoff()?.[0]?.[3].some(({ key }) => key === 'hb_pb')).toBe(false);
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(true);
+    adapter.dispose();
+    expect(destroySlots).toHaveBeenCalledOnce();
+    expect(targeting.get('hb_pb')).toEqual(['1.25']);
+  });
+
+  it('cleans failed publisher targeting before handoff with exact nested-write attribution', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div><div id="slot-2"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const acceptedTargeting = new Map<string, string[]>([['hb_pb', ['accepted-original']]]);
+    const failedTargeting = new Map<string, string[]>([['hb_pb', ['failed-original']]]);
+    let cleanupPhase = false;
+    let reentrantCleanupCalls = 0;
+    const acceptedSlot = {
+      clearTargeting: vi.fn((key: string) => acceptedTargeting.delete(key)),
+      getSlotElementId: () => 'slot-1',
+      getTargeting: (key: string) => acceptedTargeting.get(key) ?? [],
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        acceptedTargeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        return acceptedSlot;
+      }),
+    };
+    const reenterAcceptedSlot = () => {
+      if (!cleanupPhase || reentrantCleanupCalls > 0) return;
+      reentrantCleanupCalls += 1;
+      acceptedSlot.setTargeting('hb_pb', '1.25');
+    };
+    const failedSlot = {
+      clearTargeting: vi.fn((key: string) => {
+        failedTargeting.delete(key);
+        reenterAcceptedSlot();
+      }),
+      getSlotElementId: () => 'slot-2',
+      getTargeting: (key: string) => failedTargeting.get(key) ?? [],
+      setTargeting: vi.fn((key: string, value: string | string[]) => {
+        failedTargeting.set(key, Array.isArray(value) ? [...value] : [value]);
+        reenterAcceptedSlot();
+        return failedSlot;
+      }),
+    };
+    const listeners = new Map<string, (event: unknown) => void>();
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [acceptedSlot, failedSlot],
+      refresh: () => undefined,
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => undefined,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(twoSlotFixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    for (const slot of [acceptedSlot, failedSlot]) {
+      listeners.get('slotRequested')?.({ slot });
+      listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    }
+
+    cleanupPhase = true;
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(failedTargeting.get('hb_pb')).toEqual(['failed-original']);
+    expect(reentrantCleanupCalls).toBe(1);
+    expect(adapter.captureHandoff()?.[0]?.[3].some(({ key }) => key === 'hb_pb')).toBe(false);
+    const cleanupWrites =
+      failedSlot.clearTargeting.mock.calls.length + failedSlot.setTargeting.mock.calls.length;
+
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(true);
+    adapter.dispose();
+    expect(reentrantCleanupCalls).toBe(1);
+    expect(
+      failedSlot.clearTargeting.mock.calls.length + failedSlot.setTargeting.mock.calls.length
+    ).toBe(cleanupWrites);
+    expect(acceptedTargeting.get('hb_pb')).toEqual(['1.25']);
+  });
+
+  it('marks refresh as the first request when initial load is disabled', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const events: string[] = [];
+    const slot = {
+      addService: () => slot,
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => slot,
+    };
+    const service = {
+      addEventListener: (name: string) => events.push(`listen:${name}`),
+      getSlots: () => [],
+      refresh: () => events.push('refresh'),
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => slot,
+        display: () => events.push('display'),
+        getConfig: () => ({ disableInitialLoad: true }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => {
+        events.push('first-action');
+        return true;
+      },
+      onRenderEnded: () => undefined,
+    });
+    expect(events).toEqual([
+      'listen:slotRequested',
+      'listen:slotRenderEnded',
+      'display',
+      'first-action',
+      'refresh',
+    ]);
+  });
+
+  it('removes a timed-out command so it cannot act after the readiness deadline', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const timers: Array<() => void> = [];
+    const failures: unknown[] = [];
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => {
+        timers.push(callback);
+        return callback;
+      },
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: (slotId, reason) => failures.push([slotId, reason]),
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    const binding = (dom.window as unknown as { googletag: { cmd: Array<() => void> } }).googletag;
+    expect(binding.cmd).toHaveLength(1);
+
+    timers[0]?.();
+    expect(failures).toEqual([['slot-1', 'external_ready_timeout']]);
+    expect(binding.cmd).toHaveLength(0);
+  });
+
+  it('requires an attributable request before render completion and bounds request start', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const timers: Array<() => void> = [];
+    const failures: unknown[] = [];
+    const renders: unknown[] = [];
+    const slot = {
+      addService: () => slot,
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => slot,
+    };
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [],
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => slot,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => {
+        timers.push(callback);
+        return callback;
+      },
+      clearTimer: (handle) => {
+        const index = timers.indexOf(handle as () => void);
+        if (index >= 0) timers.splice(index, 1);
+      },
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: (slotId, reason) => failures.push([slotId, reason]),
+      onFirstAction: () => true,
+      onRenderEnded: (cycle, result) => renders.push([cycle[6], result]),
+    });
+
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    expect(renders).toEqual([]);
+    expect(timers).toHaveLength(2);
+    timers[0]?.();
+    expect(failures).toEqual([['slot-1', 'gpt_request_timeout']]);
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+    expect(renders).toEqual([]);
+  });
+
+  it('uses the unique hydrated element id for slot definition and display', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1-hydrated"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slot = {
+      addService: () => slot,
+      getSlotElementId: () => 'slot-1-hydrated',
+      setTargeting: () => slot,
+    };
+    const defineSlot = vi.fn(() => slot);
+    const display = vi.fn();
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot,
+        display,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => ({
+          addEventListener: (name: string, listener: (event: unknown) => void) =>
+            listeners.set(name, listener),
+          getSlots: () => [],
+          removeEventListener: () => undefined,
+        }),
+      },
+    });
+    const batch = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: batch.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+
+    expect(defineSlot).toHaveBeenCalledWith('/123/example', [[300, 250]], 'slot-1-hydrated');
+    expect(display).toHaveBeenCalledWith('slot-1-hydrated');
+  });
+
+  it('captures exact terminal slots, closes ingress, and detaches only committed identities', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slot = {
+      addService: () => slot,
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => slot,
+    };
+    const destroySlots = vi.fn(() => true);
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [],
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => slot,
+        destroySlots,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const value = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      document: dom.window.document,
+      projection: value.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+      clearTimer: () => undefined,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+    listeners.get('slotRequested')?.({ slot });
+    listeners.get('slotRenderEnded')?.({ slot, isEmpty: false });
+
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+    expect(adapter.captureHandoff()).toEqual([expect.arrayContaining(['slot-1', slot])]);
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(true);
+    expect(adapter.detachCommittedSlots(['slot-1'])).toBe(false);
+    adapter.dispose();
+
+    expect(service.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(destroySlots).not.toHaveBeenCalled();
+  });
+
+  it('captures six exact normalized diagnostics facts with stable slot identity', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    vi.spyOn(dom.window.performance, 'now').mockReturnValue(12.5);
+    const listeners = new Map<string, (event: unknown) => void>();
+    const slot = {
+      addService: () => slot,
+      getAdUnitPath: () => '/123/example',
+      getSlotElementId: () => 'slot-1',
+      setTargeting: () => slot,
+    };
+    const service = {
+      addEventListener: (name: string, listener: (event: unknown) => void) =>
+        listeners.set(name, listener),
+      getSlots: () => [],
+      removeEventListener: () => undefined,
+    };
+    Object.defineProperty(dom.window, 'googletag', {
+      configurable: true,
+      value: {
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => command() },
+        defineSlot: () => slot,
+        display: () => undefined,
+        getConfig: () => ({ disableInitialLoad: false }),
+        pubads: () => service,
+      },
+    });
+    const value = snapshotFirstDisplayBatchV1(fixture())!;
+    const adapter = createFirstDisplayGoogletagBatch({
+      browser: dom.window as unknown as Window,
+      clearTimer: () => undefined,
+      diagnosticsActive: true,
+      document: dom.window.document,
+      projection: value.projection,
+      protocol: protocol(),
+      setTimer: (callback) => callback,
+    });
+    startAdapter(adapter, {
+      onBound: () => undefined,
+      onFailure: () => undefined,
+      onFirstAction: () => true,
+      onRenderEnded: () => undefined,
+    });
+
+    listeners.get('slotRequested')?.({ slot, responseIdentifier: 'response-one' });
+    listeners.get('slotResponseReceived')?.({ slot, responseIdentifier: 'response-one' });
+    listeners.get('slotRenderEnded')?.({
+      slot,
+      responseIdentifier: 'response-one',
+      isEmpty: false,
+      size: [300, 250],
+      isBackfill: false,
+      slotContentChanged: true,
+    });
+    listeners.get('slotOnload')?.({ slot });
+    listeners.get('impressionViewable')?.({ slot });
+    listeners.get('slotVisibilityChanged')?.({ slot, inViewPercentage: 42 });
+    expect(adapter.closeIngress(['slot-1'])).toBe(true);
+
+    const diagnostics = adapter.captureDiagnosticsHandoff();
+    expect([...listeners.keys()]).toEqual([
+      'slotRequested',
+      'slotRenderEnded',
+      'slotResponseReceived',
+      'slotOnload',
+      'impressionViewable',
+      'slotVisibilityChanged',
+    ]);
+    expect(diagnostics?.[2]).toBe(2);
+    expect(diagnostics?.[3]).toBe(0);
+    expect(diagnostics?.[4]).toBe(0);
+    expect(diagnostics?.[1]).toHaveLength(6);
+    expect(diagnostics?.[0]).toEqual([
+      [
+        'slot-1',
+        'gt1_1',
+        2,
+        false,
+        [],
+        [
+          [
+            1,
+            'response-one',
+            [
+              'slotRequested',
+              'slotResponseReceived',
+              'slotRenderEnded',
+              'slotOnload',
+              'impressionViewable',
+              'slotVisibilityChanged',
+            ],
+            'completed',
+          ],
+        ],
+      ],
+    ]);
+    expect(diagnostics?.[1][0]).toEqual({
+      version: 1,
+      event: 'slotRequested',
+      token: 'gt1_1',
+      runtimeSlotNumber: 1,
+      cycleOrdinal: 1,
+      disposition: 'matched',
+      issueReason: null,
+      capturedAtMs: 12.5,
+      elementId: 'slot-1',
+      adUnitPath: '/123/example',
+      requestedSlotSizes: [[300, 250]],
+      isEmpty: null,
+      renderedSize: null,
+      isBackfill: null,
+      slotContentChanged: null,
+      visibilityPercent: null,
+    });
+    expect(diagnostics?.[1][2]).toMatchObject({
+      event: 'slotRenderEnded',
+      requestedSlotSizes: null,
+      isEmpty: false,
+      renderedSize: [300, 250],
+      isBackfill: false,
+      slotContentChanged: true,
+    });
+    expect(diagnostics?.[1][5]).toMatchObject({
+      event: 'slotVisibilityChanged',
+      visibilityPercent: 42,
+    });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/handoff.test.ts b/crates/trusted-server-js/lib/test/first_display/handoff.test.ts
new file mode 100644
index 000000000..2a02e9166
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/handoff.test.ts
@@ -0,0 +1,349 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createFirstDisplayHandoffOwner,
+  finalizeFirstDisplayAgentCaptureV1,
+} from '../../src/shared/first_display_handoff';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+function handoff(
+  revision: number,
+  overrides: Record<string, unknown> = {}
+): Record<string, unknown> {
+  return {
+    captureVersion: 1,
+    releaseId: RELEASE_ID,
+    generation: 1,
+    projectionDigest: 'b'.repeat(64),
+    integrationConfigDigest: 'c'.repeat(64),
+    slices: ['first_display'],
+    slots: [],
+    attempts: [],
+    tombstones: [],
+    artifacts: [],
+    parserState: [],
+    gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+    timing: { bidsScriptMs: 1, firstDisplayMs: null, terminalMs: 2, paintMs: 3 },
+    highWater: {
+      navigationAttemptPrefix: 'AAECAwQFBgc',
+      nextNavigationAttemptOrdinal: 1,
+      nextAttemptOrdinal: 1,
+      nextSlotRegistrationOrdinal: 1,
+      reservationClockEpochMs: 0,
+      nextReservationOrdinal: 1,
+      nextTicketOrdinal: 1,
+    },
+    cycles: [],
+    trace: { nextSequence: 1, nextGlobalSlotOrdinal: 1, slots: [] },
+    mutationRevision: revision,
+    identityCount: 0,
+    ...overrides,
+  };
+}
+
+function acceptedHandoff(revision: number): Record<string, unknown> {
+  return handoff(revision, {
+    identityCount: 2,
+    slices: ['first_display', 'gpt_initial'],
+    slots: [
+      {
+        id: 'slot-1',
+        aliases: [],
+        domId: 'div-1',
+        gamPath: '/123/slot-1',
+        formats: [[300, 250]],
+        owner: 'trusted_server',
+        outcome: 'accepted',
+        targeting: [['hb_adid', RESERVATION_ID]],
+        targetingOwnership: [],
+        committedArtifact: 'gpt_adm',
+        gptToken: 'gt1_1',
+      },
+    ],
+    attempts: [
+      {
+        id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+        slotId: 'slot-1',
+        ordinal: 1,
+        state: 'accepted',
+        reason: null,
+      },
+    ],
+    artifacts: [
+      {
+        hostPosition: null,
+        hostPositionPriority: null,
+        slotId: 'slot-1',
+        kind: 'gpt_adm',
+        owner: 'trusted_server',
+        token: RESERVATION_ID,
+      },
+    ],
+    parserState: [
+      {
+        sliceId: 'gpt_initial',
+        observations: ['gam', 'v'],
+        values: [
+          ['gam', false],
+          ['v', 1],
+        ],
+      },
+    ],
+    timing: { bidsScriptMs: 1, firstDisplayMs: 2, terminalMs: 3, paintMs: 4 },
+    highWater: {
+      navigationAttemptPrefix: 'AAECAwQFBgc',
+      nextNavigationAttemptOrdinal: 2,
+      nextAttemptOrdinal: 2,
+      nextSlotRegistrationOrdinal: 2,
+      reservationClockEpochMs: 0,
+      nextReservationOrdinal: 2,
+      nextTicketOrdinal: 1,
+    },
+    cycles: [
+      {
+        slotId: 'slot-1',
+        token: 'gt1_1',
+        nextCycleOrdinal: 2,
+        unknownPriorCycle: false,
+        records: [
+          {
+            ordinal: 1,
+            responseIdentifier: 'response-one',
+            seen: ['slotRequested', 'slotRenderEnded'],
+            state: 'completed',
+          },
+        ],
+        quarantines: [],
+      },
+    ],
+    trace: {
+      nextSequence: 2,
+      nextGlobalSlotOrdinal: 2,
+      slots: [
+        {
+          slotId: 'slot-1',
+          impressions: 1,
+          bindings: [
+            {
+              atMs: 3,
+              cycleOrdinal: 1,
+              historySequence: 1,
+              state: 'completed',
+              token: 'gt1_1',
+            },
+          ],
+        },
+      ],
+    },
+  });
+}
+
+function owner(options: { initialRevision?: number } = {}) {
+  const failures: string[] = [];
+  const events: string[] = [];
+  return {
+    events,
+    failures,
+    value: createFirstDisplayHandoffOwner({
+      releaseId: RELEASE_ID,
+      generation: 1,
+      ...(options.initialRevision === undefined
+        ? {}
+        : { initialMutationRevision: options.initialRevision }),
+      isCurrentGeneration: () => true,
+      isTerminal: () => true,
+      isPainted: () => true,
+      closeIngress: () => events.push('close-ingress'),
+      onFailure: (reason) => failures.push(reason),
+    }),
+  };
+}
+
+describe('first-display final handoff owner', () => {
+  it('materializes the compact data handoff and capsule only inside the finalizer call', () => {
+    const artifact = {};
+    const physicalSlot = {};
+    const finalized = finalizeFirstDisplayAgentCaptureV1([
+      {
+        releaseId: RELEASE_ID,
+        generation: 1,
+        integrationConfigDigest: 'c'.repeat(64),
+        slices: ['first_display'],
+      },
+      ['b'.repeat(64), []],
+      new Map(),
+      new Map(),
+      new Map(),
+      [],
+      [['slot-1', 'slot-1', 'trusted_server', [], 'gt1_1', physicalSlot]],
+      [[['slot-1', 'gt1_1', 2, false, [], []]], [], 2, 0, 0],
+      [
+        [[null, null, artifact, 'gpt_adm', 'trusted_server', 'slot-1', 'reservation-1']],
+        [],
+        3,
+        1,
+        1,
+      ],
+      [1, null, 2, 3, 3],
+      1,
+      0,
+    ]);
+
+    expect(finalized?.handoff).toMatchObject({
+      captureVersion: 1,
+      releaseId: RELEASE_ID,
+      generation: 1,
+      mutationRevision: 0,
+      identityCount: 2,
+    });
+    expect(finalized?.capsule.consume(RELEASE_ID, 1)).toEqual([physicalSlot, artifact]);
+    expect(finalized?.capsule.consume(RELEASE_ID, 1)).toBeUndefined();
+  });
+
+  it('seals the final revision and mints one release-bound capsule in the same task', () => {
+    const h = owner();
+    const physicalSlot = {};
+    const artifact = {};
+    expect(h.value.observeMutation()).toBe(true);
+    expect(h.value.observeMutation()).toBe(true);
+
+    const final = h.value.finalize(() => ({
+      candidate: acceptedHandoff(2),
+      identities: [physicalSlot, artifact],
+    }));
+    expect(final?.handoff.mutationRevision).toBe(2);
+    expect(Object.isFrozen(final?.handoff)).toBe(true);
+    expect(final?.capsule.consume(RELEASE_ID, 1)).toEqual([physicalSlot, artifact]);
+    expect(final?.capsule.consume(RELEASE_ID, 1)).toBeUndefined();
+    expect(h.value.state).toBe('finalized');
+    expect(h.events).toEqual(['close-ingress']);
+    expect(h.failures).toEqual([]);
+  });
+
+  it('drains a synchronous native mutation while closing ingress before final capture', () => {
+    const failures: string[] = [];
+    const value = createFirstDisplayHandoffOwner({
+      releaseId: RELEASE_ID,
+      generation: 1,
+      isCurrentGeneration: () => true,
+      isTerminal: () => true,
+      isPainted: () => true,
+      closeIngress: () => {
+        expect(value.observeMutation()).toBe(true);
+      },
+      onFailure: (reason) => failures.push(reason),
+    });
+
+    expect(
+      value.finalize(() => ({
+        candidate: handoff(1),
+        identities: [],
+      }))
+    ).toBeDefined();
+    expect(value.mutationRevision).toBe(1);
+    expect(failures).toEqual([]);
+  });
+
+  it('clears the capsule and fails closed on duplicate finalization or stale revision', () => {
+    const duplicate = owner();
+    const identity = {};
+    const artifact = {};
+    const final = duplicate.value.finalize(() => ({
+      candidate: acceptedHandoff(0),
+      identities: [identity, artifact],
+    }));
+    expect(final).toBeDefined();
+    expect(
+      duplicate.value.finalize(() => ({
+        candidate: acceptedHandoff(0),
+        identities: [identity, artifact],
+      }))
+    ).toBeUndefined();
+    expect(final?.capsule.consume(RELEASE_ID, 1)).toBeUndefined();
+    expect(duplicate.failures).toEqual(['bundle_partial']);
+
+    const extraIdentity = owner();
+    expect(
+      extraIdentity.value.finalize(() => ({ candidate: handoff(0), identities: [{}] }))
+    ).toBeUndefined();
+    expect(extraIdentity.failures).toEqual(['bundle_partial']);
+
+    const stale = owner();
+    stale.value.observeMutation();
+    expect(
+      stale.value.finalize(() => ({ candidate: handoff(0), identities: [{}] }))
+    ).toBeUndefined();
+    expect(stale.value.state).toBe('failed');
+    expect(stale.failures).toEqual(['bundle_partial']);
+  });
+
+  it('defers semantic validation but rejects wrong identity and revision exhaustion', () => {
+    const nonterminal = owner();
+    expect(
+      nonterminal.value.finalize(() => ({
+        candidate: handoff(0, {
+          slots: [
+            {
+              id: 'slot-1',
+              aliases: [],
+              domId: 'div-1',
+              gamPath: '/123/slot-1',
+              formats: [[300, 250]],
+              owner: 'trusted_server',
+              outcome: 'failed',
+              targeting: [],
+              targetingOwnership: [],
+              committedArtifact: 'none',
+              gptToken: null,
+            },
+          ],
+          attempts: [
+            { id: 'attempt-1', slotId: 'slot-1', ordinal: 1, state: 'pending', reason: null },
+          ],
+          highWater: {
+            ...((handoff(0).highWater as object) ?? {}),
+            nextAttemptOrdinal: 2,
+            nextSlotRegistrationOrdinal: 2,
+          },
+        }),
+        identities: [],
+      }))
+    ).toBeDefined();
+    expect(nonterminal.failures).toEqual([]);
+
+    const badIdentity = owner();
+    expect(
+      badIdentity.value.finalize(() => ({
+        candidate: handoff(0),
+        identities: [null as unknown as object],
+      }))
+    ).toBeUndefined();
+    expect(badIdentity.failures).toEqual(['bundle_partial']);
+
+    const exhausted = owner({ initialRevision: 4_294_967_295 });
+    expect(exhausted.value.observeMutation()).toBe(false);
+    expect(exhausted.value.state).toBe('failed');
+    expect(exhausted.failures).toEqual(['bundle_partial']);
+  });
+
+  it('requires terminal paint and the current generation before closing ingress', () => {
+    for (const failedGate of ['generation', 'terminal', 'paint'] as const) {
+      const closeIngress = vi.fn();
+      const failures: string[] = [];
+      const value = createFirstDisplayHandoffOwner({
+        releaseId: RELEASE_ID,
+        generation: 1,
+        isCurrentGeneration: () => failedGate !== 'generation',
+        isTerminal: () => failedGate !== 'terminal',
+        isPainted: () => failedGate !== 'paint',
+        closeIngress,
+        onFailure: (reason) => failures.push(reason),
+      });
+      expect(value.finalize(() => ({ candidate: handoff(0), identities: [] }))).toBeUndefined();
+      expect(closeIngress).not.toHaveBeenCalled();
+      expect(failures).toEqual(['bundle_partial']);
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/helpers/compact_takeover.ts b/crates/trusted-server-js/lib/test/first_display/helpers/compact_takeover.ts
new file mode 100644
index 000000000..0ab9bc76e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/helpers/compact_takeover.ts
@@ -0,0 +1,191 @@
+export function failedFirstDisplayTakeover(releaseId: string) {
+  const projectionDigest = 'b'.repeat(64);
+  const integrationConfigDigest = 'c'.repeat(64);
+  const projection = {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: 'initial',
+      results: [{ slot: 'slot-1', outcome: 'failed', reason: 'internal_error' }],
+    },
+    slots: [
+      {
+        slot: 'slot-1',
+        gamUnitPath: '/123/slot-1',
+        divId: 'div-1',
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [],
+  };
+  return {
+    capture: {
+      captureVersion: 1,
+      releaseId,
+      generation: 1,
+      data: [
+        projectionDigest,
+        integrationConfigDigest,
+        ['first_display'],
+        [['failed', 'internal_error', null, null]],
+        [],
+        [],
+        [],
+        [],
+        [[], 0, 0],
+        [0, null, 0, 0],
+        [2, 0, 1, 1],
+        [],
+        1,
+        2,
+      ],
+      mutationRevision: 0,
+      identityCount: 0,
+    },
+    outline: {
+      version: 1,
+      releaseId,
+      generation: 1,
+      projectionDigest,
+      integrationConfigDigest,
+      slices: ['first_display'],
+      slotCount: 1,
+      outcomeCount: 1,
+      capabilities: [],
+      objectKinds: [],
+    },
+    boot: {
+      abi: 1,
+      releaseId,
+      manifest: {},
+      auctionProjection: projection,
+      integrations: {},
+      creative: {},
+      diagnostics: {},
+    },
+  } as const;
+}
+
+export function acceptedGptFirstDisplayTakeover(
+  releaseId: string,
+  reservationId: string,
+  parserState: 'valid' | 'invalid' | 'absent',
+  gamAttributionEnabled: boolean
+) {
+  const projectionDigest = 'b'.repeat(64);
+  const integrationConfigDigest = 'c'.repeat(64);
+  const slices =
+    parserState === 'absent'
+      ? (['first_display'] as const)
+      : (['first_display', 'gpt_initial'] as const);
+  const projection = {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId: 'initial',
+      results: [{ slot: 'takeover-slot', outcome: 'winner', candidateId: 'AAAAAAAAAAAA' }],
+    },
+    slots: [
+      {
+        slot: 'takeover-slot',
+        gamUnitPath: '/123/takeover-slot',
+        divId: 'takeover-slot',
+        formats: [[300, 250]],
+        targeting: {},
+      },
+    ],
+    bids: [
+      {
+        candidateId: 'AAAAAAAAAAAA',
+        slot: 'takeover-slot',
+        provider: 'trusted',
+        upstreamBidId: 'bid-1',
+        cpm: 1,
+        currency: 'USD',
+        targeting: {},
+        rendererReservationId: reservationId,
+        renderSource: {
+          type: 'adm',
+          version: 1,
+          adm: '<div>creative</div>',
+          width: 300,
+          height: 250,
+        },
+      },
+    ],
+  };
+  const cycles = [
+    {
+      nextCycleOrdinal: 2,
+      quarantines: [],
+      records: [
+        {
+          ordinal: 1,
+          responseIdentifier: 'response-one',
+          seen: ['slotRequested', 'slotRenderEnded'],
+          state: 'completed',
+        },
+      ],
+      slotId: 'takeover-slot',
+      token: 'gt1_1',
+      unknownPriorCycle: false,
+    },
+  ];
+  return {
+    capture: {
+      captureVersion: 1,
+      releaseId,
+      generation: 1,
+      data: [
+        projectionDigest,
+        integrationConfigDigest,
+        slices,
+        [['accepted', null, 2, 1]],
+        [['takeover-slot', 'takeover-slot', 'publisher', [], 'gt1_1']],
+        [],
+        [[null, null, 'takeover-slot', 'gpt_adm', 'trusted_server', reservationId]],
+        parserState === 'valid'
+          ? [
+              [
+                'gpt_initial',
+                [
+                  ['gam', gamAttributionEnabled],
+                  ['v', 1],
+                ],
+              ],
+            ]
+          : [],
+        [[], 0, 0],
+        [1, 2, 3, 4],
+        [2, 0, 2, 1],
+        cycles,
+        2,
+        2,
+      ],
+      mutationRevision: 0,
+      identityCount: 2,
+    },
+    outline: {
+      version: 1,
+      releaseId,
+      generation: 1,
+      projectionDigest,
+      integrationConfigDigest,
+      slices,
+      slotCount: 1,
+      outcomeCount: 1,
+      capabilities: [],
+      objectKinds: ['gpt_slot', 'dom_artifact'],
+    },
+    boot: {
+      abi: 1,
+      releaseId,
+      manifest: {},
+      auctionProjection: projection,
+      integrations: {},
+      creative: {},
+      diagnostics: {},
+    },
+  } as const;
+}
diff --git a/crates/trusted-server-js/lib/test/first_display/helpers/render_owner_composition.ts b/crates/trusted-server-js/lib/test/first_display/helpers/render_owner_composition.ts
new file mode 100644
index 000000000..9243bffd6
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/helpers/render_owner_composition.ts
@@ -0,0 +1,36 @@
+import type { FirstDisplayApsPolicyV1 } from '../../../src/first_display/leaf/aps_protocol';
+import { createFirstDisplayApsRenderStrategy } from '../../../src/first_display/render_bridge';
+import {
+  createFirstDisplayRenderJournal,
+  type FirstDisplayRenderOwnerOptionsV1,
+} from '../../../src/first_display/render_journal';
+
+type TestRenderBridgeOptions = Readonly<{
+  browser: FirstDisplayRenderOwnerOptionsV1[0];
+  clearTimer: FirstDisplayRenderOwnerOptionsV1[1];
+  createChannel: FirstDisplayRenderOwnerOptionsV1[2];
+  document: FirstDisplayRenderOwnerOptionsV1[3];
+  fillRandom: FirstDisplayRenderOwnerOptionsV1[4];
+  now: FirstDisplayRenderOwnerOptionsV1[5];
+  onNativeMutation?: NonNullable<FirstDisplayRenderOwnerOptionsV1[6]>;
+  setTimer: FirstDisplayRenderOwnerOptionsV1[7];
+  getAps: () => FirstDisplayApsPolicyV1 | undefined;
+}>;
+
+/** Compose the production owner and APS capabilities without creating a production graph seam. */
+export function createTestFirstDisplayRenderBridge(options: TestRenderBridgeOptions) {
+  const { getAps, ...ownerOptions } = options;
+  const capabilities: FirstDisplayRenderOwnerOptionsV1 = Object.freeze([
+    ownerOptions.browser,
+    ownerOptions.clearTimer,
+    ownerOptions.createChannel,
+    ownerOptions.document,
+    ownerOptions.fillRandom,
+    ownerOptions.now,
+    ownerOptions.onNativeMutation,
+    ownerOptions.setTimer,
+  ]);
+  const aps = getAps();
+  const strategy = aps ? createFirstDisplayApsRenderStrategy(capabilities, aps) : undefined;
+  return createFirstDisplayRenderJournal(capabilities, strategy);
+}
diff --git a/crates/trusted-server-js/lib/test/first_display/projection.test.ts b/crates/trusted-server-js/lib/test/first_display/projection.test.ts
new file mode 100644
index 000000000..0de9fc5b9
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/projection.test.ts
@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseBrowserAuctionProjectionV1 } from '../../src/core/contracts/auction_projection';
+import {
+  acceptServerFirstDisplayBatchV1,
+  snapshotFirstDisplayBatchV1,
+} from '../../src/first_display/leaf/projection';
+
+function freezeTree<Value>(value: Value): Value {
+  if (typeof value !== 'object' || value === null || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value as Record<string, unknown>)) freezeTree(child);
+  return Object.freeze(value);
+}
+
+function winnerFixture(options: { provider?: string; source?: 'adm' | 'aps' | 'pbs_cache' } = {}) {
+  const source = options.source ?? 'adm';
+  const renderSource =
+    source === 'adm'
+      ? {
+          type: 'adm',
+          version: 1,
+          adm: '<div>example</div>',
+          width: 300,
+          height: 250,
+        }
+      : source === 'aps'
+        ? {
+            type: 'aps',
+            version: 1,
+            accountId: 'account-1',
+            bidId: 'bid-1',
+            tagType: 'iframe',
+            creativeUrl: 'https://creative.example/render',
+            aaxResponse: '',
+            width: 300,
+            height: 250,
+          }
+        : {
+            type: 'pbs_cache',
+            version: 1,
+            cacheId: 'cache-1',
+            cacheHost: 'cache.example',
+            cachePath: '/cache',
+            width: 300,
+            height: 250,
+          };
+  const bid = {
+    candidateId: 'candidate001',
+    slot: 'slot-1',
+    provider: options.provider ?? 'example',
+    upstreamBidId: 'upstream-1',
+    cpm: 1.25,
+    currency: 'USD',
+    targeting: { hb_pb: '1.25' } as Record<string, string>,
+    ...(source === 'pbs_cache' ? {} : { rendererReservationId: `r1_${'a'.repeat(22)}` }),
+    renderSource,
+  };
+  return {
+    version: 1,
+    projectionDigest: 'b'.repeat(64),
+    projection: {
+      version: 1,
+      auction: {
+        version: 1,
+        auctionId: 'initial',
+        results: [{ slot: 'slot-1', outcome: 'winner', candidateId: 'candidate001' }],
+      },
+      slots: [
+        {
+          slot: 'slot-1',
+          gamUnitPath: '/123/example',
+          divId: 'slot-1',
+          formats: [[300, 250]],
+          targeting: { placement: 'article' },
+        },
+      ],
+      bids: [bid],
+    },
+  };
+}
+
+describe('first-display projection snapshot', () => {
+  it('accepts only the already-frozen server envelope used by the production agent', () => {
+    const candidate = freezeTree(winnerFixture({ provider: 'prebid' }));
+
+    expect(acceptServerFirstDisplayBatchV1(candidate)?.slice(0, 3)).toEqual([
+      'b'.repeat(64),
+      ['gpt', 'prebid'],
+      [['slot-1', 'gpt_adm']],
+    ]);
+    expect(acceptServerFirstDisplayBatchV1(winnerFixture())).toBeUndefined();
+    expect(
+      acceptServerFirstDisplayBatchV1(freezeTree(winnerFixture({ source: 'pbs_cache' })))
+    ).toBeUndefined();
+  });
+
+  it('derives canonical protocol coverage and remains equal to the persistent ADM parser', () => {
+    const candidate = freezeTree(winnerFixture({ provider: 'prebid' }));
+    const snapshot = snapshotFirstDisplayBatchV1(candidate);
+
+    expect(snapshot?.requiredProtocols).toEqual(['gpt', 'prebid']);
+    expect(snapshot?.outcomes).toEqual([{ slotId: 'slot-1', kind: 'gpt_adm' }]);
+    expect(snapshot?.projection).toEqual(parseBrowserAuctionProjectionV1(candidate.projection));
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(Object.isFrozen(snapshot?.projection.bids[0]?.renderSource)).toBe(true);
+  });
+
+  it('derives APS plus GPT and never admits PBS Cache into the agent', () => {
+    const aps = snapshotFirstDisplayBatchV1(freezeTree(winnerFixture({ source: 'aps' })));
+    expect(aps?.requiredProtocols).toEqual(['aps', 'gpt']);
+    expect(aps?.outcomes).toEqual([{ slotId: 'slot-1', kind: 'aps' }]);
+
+    expect(
+      snapshotFirstDisplayBatchV1(freezeTree(winnerFixture({ source: 'pbs_cache' })))
+    ).toBeUndefined();
+  });
+
+  it('rejects duplicated summaries, mutable input, and non-data or extra fields', () => {
+    expect(
+      snapshotFirstDisplayBatchV1(
+        Object.freeze({
+          version: 1,
+          projectionDigest: 'b'.repeat(64),
+          requiredProtocols: Object.freeze(['gpt']),
+          outcomes: Object.freeze([{ slotId: 'slot-1', kind: 'gpt_adm' }]),
+        })
+      )
+    ).toBeUndefined();
+    expect(snapshotFirstDisplayBatchV1(winnerFixture())).toBeUndefined();
+
+    const extra = winnerFixture();
+    Object.assign(extra.projection.slots[0]!, { extra: true });
+    expect(snapshotFirstDisplayBatchV1(freezeTree(extra))).toBeUndefined();
+
+    const accessor = winnerFixture();
+    Object.defineProperty(accessor.projection.slots[0]!, 'slot', {
+      enumerable: true,
+      get: () => 'slot-1',
+    });
+    expect(snapshotFirstDisplayBatchV1(freezeTree(accessor))).toBeUndefined();
+  });
+
+  it('rejects broken winner joins, unknown failures, and bounded targeting overflow', () => {
+    const missingBid = winnerFixture();
+    missingBid.projection.bids = [];
+    expect(snapshotFirstDisplayBatchV1(freezeTree(missingBid))).toBeUndefined();
+
+    const failed = winnerFixture();
+    Object.assign(failed.projection.auction, {
+      results: [{ slot: 'slot-1', outcome: 'failed', reason: 'unknown' }],
+    });
+    failed.projection.bids = [];
+    expect(snapshotFirstDisplayBatchV1(freezeTree(failed))).toBeUndefined();
+
+    const targeting = winnerFixture();
+    targeting.projection.bids[0]!.targeting = Object.fromEntries(
+      Array.from({ length: 33 }, (_, index) => [`key_${index}`, 'value'])
+    );
+    expect(snapshotFirstDisplayBatchV1(freezeTree(targeting))).toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/render_bridge.test.ts b/crates/trusted-server-js/lib/test/first_display/render_bridge.test.ts
new file mode 100644
index 000000000..c7f1bce48
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/render_bridge.test.ts
@@ -0,0 +1,1014 @@
+import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+
+import type { FirstDisplayGptBoundCycleV1 } from '../../src/first_display/adapters/googletag';
+import { PUC_DYNAMIC_OWNER } from '../../src/kernel/contracts/puc_dynamic_owner';
+
+import { createTestFirstDisplayRenderBridge } from './helpers/render_owner_composition';
+
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+class FakePort {
+  public readonly addEventListener = vi.fn(
+    (name: string, listener: (event: { data: unknown; ports: readonly FakePort[] }) => void) => {
+      this.listeners.set(name, listener);
+    }
+  );
+  public readonly close = vi.fn();
+  public readonly postMessage = vi.fn();
+  public readonly removeEventListener = vi.fn();
+  public readonly start = vi.fn();
+  private readonly listeners = new Map<
+    string,
+    (event: { data: unknown; ports: readonly FakePort[] }) => void
+  >();
+
+  public dispatch(data: unknown, ports: readonly FakePort[] = []): void {
+    const listener = this.listeners.get('message');
+    if (!listener) throw new Error('expected a live port listener');
+    listener({ data, ports });
+  }
+
+  public dispatchError(): void {
+    const listener = this.listeners.get('messageerror');
+    if (!listener) throw new Error('expected a live port error listener');
+    listener({ data: undefined, ports: [] });
+  }
+}
+
+function fixture(kind: 'adm' | 'aps' = 'adm') {
+  const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+    url: 'https://publisher.example/',
+  });
+  const element = dom.window.document.getElementById('slot-1');
+  if (!(element instanceof dom.window.HTMLElement)) throw new Error('missing fixture element');
+  const bid = Object.freeze({
+    candidateId: 'candidate001',
+    slot: 'slot-1',
+    provider: 'example',
+    upstreamBidId: 'upstream-1',
+    cpm: 1.25,
+    currency: 'USD' as const,
+    targeting: Object.freeze({}),
+    rendererReservationId: RESERVATION_ID,
+    renderSource: Object.freeze(
+      kind === 'adm'
+        ? {
+            type: 'adm' as const,
+            version: 1 as const,
+            adm: '<main>fictional creative</main>',
+            width: 300,
+            height: 250,
+          }
+        : {
+            type: 'aps' as const,
+            version: 1 as const,
+            accountId: 'publisher-account',
+            bidId: 'bid-1',
+            tagType: 'iframe' as const,
+            creativeUrl: 'https://creative.example/render',
+            width: 300,
+            height: 250,
+            aaxResponse: 'renderer-envelope',
+          }
+    ),
+  });
+  const placement = Object.freeze({
+    slot: 'slot-1',
+    gamUnitPath: '/123/example',
+    divId: 'slot-1',
+    formats: Object.freeze([Object.freeze([300, 250] as const)]),
+    targeting: Object.freeze({}),
+  });
+  let cycleCurrent = true;
+  const cycle: FirstDisplayGptBoundCycleV1 = Object.freeze([
+    bid,
+    element,
+    () => cycleCurrent,
+    'trusted_server',
+    {},
+    placement,
+    'slot-1',
+    'gt1_1',
+  ]);
+  return { cycle, dom, element, invalidateCycle: () => (cycleCurrent = false) };
+}
+
+function harness(kind: 'adm' | 'aps' = 'adm', onNativeMutation?: () => boolean) {
+  const value = fixture(kind);
+  const listeners: Array<(event: Record<string, unknown>) => void> = [];
+  const target = {
+    addEventListener: vi.fn(
+      (name: string, next: (event: Record<string, unknown>) => void, capture: boolean) => {
+        expect(name).toBe('message');
+        expect(capture).toBe(true);
+        listeners.push(next);
+      }
+    ),
+    removeEventListener: vi.fn((_name: string, next: (event: Record<string, unknown>) => void) => {
+      const index = listeners.indexOf(next);
+      if (index >= 0) listeners.splice(index, 1);
+    }),
+  };
+  const channels: Array<{ port1: FakePort; port2: FakePort }> = [];
+  const timers = new Map<object, Readonly<{ callback: () => void; delayMs: number }>>();
+  let randomByte = 1;
+  let now = 0;
+  const bridge = createTestFirstDisplayRenderBridge({
+    getAps: () =>
+      kind === 'aps'
+        ? Object.freeze({
+            version: 1 as const,
+            id: 'aps' as const,
+            publisherOrigin: 'https://publisher.example',
+            rendererUrl: 'https://publisher.example/integrations/aps/renderer/v2',
+            sandbox:
+              'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation',
+            permanentSandbox:
+              'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation',
+            deadlines: Object.freeze({
+              documentAcceptanceMs: 3_000 as const,
+              completionMs: 10_000 as const,
+            }),
+            isBootstrapNonce: (candidate: unknown): candidate is string =>
+              typeof candidate === 'string' && /^b1_[A-Za-z0-9_-]{22}$/.test(candidate),
+            isRendererNonce: (candidate: unknown): candidate is string =>
+              typeof candidate === 'string' && /^n1_[A-Za-z0-9_-]{22}$/.test(candidate),
+            bootstrapPolicy: () =>
+              Object.freeze({
+                creativeOrigin: 'https://creative.example',
+                tagType: 'iframe' as const,
+              }),
+            createRenderStrategy: () => {
+              throw new Error('the legacy bridge fixture already owns construction');
+            },
+            parseWindowMessage: (candidate: unknown) => {
+              if (typeof candidate !== 'string') return undefined;
+              const message = JSON.parse(candidate) as Record<string, unknown>;
+              if (message.message === 'TS APS Bootstrap Ready') {
+                return Object.freeze({
+                  kind: 'bootstrap_ready' as const,
+                  bootstrap: message.bootstrapNonce as string,
+                });
+              }
+              if (message.message === 'TS APS Container Ready') {
+                return Object.freeze({
+                  kind: 'container_ready' as const,
+                  bootstrap: message.bootstrapNonce as string,
+                  renderer: message.rendererNonce as string,
+                });
+              }
+              return undefined;
+            },
+            parseDocumentMessage: (candidate: unknown, nonce: string) => {
+              const message = candidate as Record<string, unknown>;
+              if (message.version !== 1 || message.nonce !== nonce) return undefined;
+              if (message.message === 'TS APS Document Accepted') {
+                return Object.freeze({ kind: 'document_accepted' as const });
+              }
+              if (message.message === 'TS APS Runner Loaded') {
+                return Object.freeze({ kind: 'runner_loaded' as const });
+              }
+              if (message.message === 'TS APS Render Completed') {
+                return Object.freeze({ kind: 'render_completed' as const });
+              }
+              if (
+                message.message === 'TS APS Render Failed' &&
+                (message.reason === 'descriptor_invalid' ||
+                  message.reason === 'runner_no_load' ||
+                  message.reason === 'runner_failed')
+              ) {
+                return Object.freeze({
+                  kind: 'render_failed' as const,
+                  reason: message.reason,
+                });
+              }
+              return undefined;
+            },
+          })
+        : undefined,
+    now: () => now,
+    browser: target as unknown as Window,
+    clearTimer: (handle) => timers.delete(handle as object),
+    createChannel: () => {
+      const channel = { port1: new FakePort(), port2: new FakePort() };
+      channels.push(channel);
+      return channel;
+    },
+    document: value.dom.window.document,
+    fillRandom: (bytes) => {
+      bytes.fill(randomByte);
+      randomByte += 1;
+    },
+    ...(onNativeMutation ? { onNativeMutation } : {}),
+    setTimer: (callback, delayMs) => {
+      const handle = {};
+      timers.set(handle, Object.freeze({ callback, delayMs }));
+      return handle;
+    },
+  });
+  const terminals: string[] = [];
+  const terminalFacts: Array<readonly [string, string | null]> = [];
+  expect(
+    bridge.bind(value.cycle, (result, reason) => {
+      terminals.push(result);
+      terminalFacts.push([result, reason]);
+    })
+  ).toBe(true);
+  const dispatch = (event: Record<string, unknown>): void => {
+    if (listeners.length === 0) throw new Error('expected capture listener');
+    for (const listener of [...listeners]) listener(event);
+  };
+  const fire = (delayMs: number): void => {
+    const entry = [...timers.entries()].find(([, timer]) => timer.delayMs === delayMs);
+    if (!entry) throw new Error(`missing ${delayMs}ms timer`);
+    timers.delete(entry[0]);
+    now += delayMs;
+    entry[1].callback();
+  };
+  const fireLast = (delayMs: number): void => {
+    const entries = [...timers.entries()].filter(([, timer]) => timer.delayMs === delayMs);
+    const entry = entries[entries.length - 1];
+    if (!entry) throw new Error(`missing ${delayMs}ms timer`);
+    timers.delete(entry[0]);
+    now += delayMs;
+    entry[1].callback();
+  };
+  return {
+    ...value,
+    bridge,
+    channels,
+    dispatch,
+    fire,
+    fireLast,
+    target,
+    terminalFacts,
+    terminals,
+    timers,
+  };
+}
+
+function requestEvent(
+  responsePort: FakePort,
+  options: Readonly<{ adId?: string; data?: unknown; source?: object }> = {}
+) {
+  return {
+    data:
+      options.data ??
+      JSON.stringify({
+        message: 'Prebid Request',
+        adId: options.adId ?? RESERVATION_ID,
+        adServerDomain: 'ads.example',
+      }),
+    ports: [responsePort],
+    source: options.source ?? {},
+    stopImmediatePropagation: vi.fn(),
+  };
+}
+
+function ownerRegistration(ticket: string, responsePort: FakePort, source: object) {
+  return {
+    data: JSON.stringify({
+      message: 'TS Render Owner Register',
+      adId: RESERVATION_ID,
+      version: 1,
+      lifecycleTicket: ticket,
+    }),
+    ports: [responsePort],
+    source,
+    stopImmediatePropagation: vi.fn(),
+  };
+}
+
+function collapsedShell(h: ReturnType<typeof harness>) {
+  const wrapper = h.dom.window.document.createElement('div');
+  const frame = h.dom.window.document.createElement('iframe');
+  wrapper.style.width = '1px';
+  wrapper.style.height = '1px';
+  frame.setAttribute('width', '1');
+  frame.setAttribute('height', '1');
+  frame.style.width = '1px';
+  frame.style.height = '1px';
+  wrapper.appendChild(frame);
+  h.dom.window.document.body.appendChild(wrapper);
+  return { frame, wrapper };
+}
+
+function registerOwner(h: ReturnType<typeof harness>, ownerSource?: object) {
+  const source = ownerSource ?? {};
+  const responsePort = new FakePort();
+  h.dispatch(requestEvent(responsePort, { source }));
+  expect(h.bridge.recordGam(h.cycle, 'nonempty_gam')).toBe(true);
+  const outer = JSON.parse(responsePort.postMessage.mock.calls[0]?.[0] as string);
+  const ticket = outer.tsOwner.lifecycleTicket as string;
+  const registrationPort = new FakePort();
+  h.dispatch(ownerRegistration(ticket, registrationPort, source));
+  return { source, ticket };
+}
+
+function startApsDocument(h: ReturnType<typeof harness>) {
+  const frame = h.element.querySelector<HTMLIFrameElement>('iframe');
+  if (!frame?.contentWindow) throw new Error('expected the top-page APS frame');
+  const bootstrapNonce = new URL(frame.src).hash.slice(1);
+  const postMessage = vi
+    .spyOn(frame.contentWindow, 'postMessage')
+    .mockImplementation(() => undefined);
+  h.dispatch({
+    data: JSON.stringify({
+      message: 'TS APS Bootstrap Ready',
+      version: 1,
+      bootstrapNonce,
+    }),
+    origin: 'null',
+    ports: [],
+    source: frame.contentWindow,
+  });
+  expect(h.terminalFacts).toEqual([]);
+  const navigation = JSON.parse(postMessage.mock.calls[0]?.[0] as string) as Record<
+    string,
+    unknown
+  >;
+  const nonce = navigation.rendererNonce;
+  if (!nonce) throw new Error('expected the renderer nonce');
+  const documentPort = new FakePort();
+  h.dispatch({
+    data: JSON.stringify({
+      message: 'TS APS Container Ready',
+      version: 1,
+      bootstrapNonce,
+      rendererNonce: nonce,
+    }),
+    origin: 'null',
+    ports: [documentPort],
+    source: frame.contentWindow,
+  });
+  return { documentPort, frame, nonce };
+}
+
+function acceptPucAps(h: ReturnType<typeof harness>): HTMLIFrameElement {
+  registerOwner(h);
+  const { documentPort, frame, nonce } = startApsDocument(h);
+  documentPort.dispatch({
+    message: 'TS APS Document Accepted',
+    version: 1,
+    nonce,
+  });
+  documentPort.dispatch({
+    message: 'TS APS Render Completed',
+    version: 1,
+    nonce,
+  });
+  expect(h.terminals).toEqual(['accepted']);
+  return frame;
+}
+
+function bindMixedAdm(h: ReturnType<typeof harness>) {
+  const element = h.dom.window.document.createElement('div');
+  element.id = 'slot-2';
+  h.dom.window.document.body.appendChild(element);
+  const reservationId = `r1_${'b'.repeat(22)}`;
+  const cycle: FirstDisplayGptBoundCycleV1 = Object.freeze([
+    Object.freeze({
+      candidateId: 'candidate002',
+      slot: 'slot-2',
+      provider: 'example',
+      upstreamBidId: 'upstream-2',
+      cpm: 1.5,
+      currency: 'USD' as const,
+      targeting: Object.freeze({}),
+      rendererReservationId: reservationId,
+      renderSource: Object.freeze({
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: '<main>mixed ADM creative</main>',
+        width: 300,
+        height: 250,
+      }),
+    }),
+    element,
+    () => true,
+    'trusted_server',
+    {},
+    Object.freeze({
+      slot: 'slot-2',
+      gamUnitPath: '/123/example-2',
+      divId: 'slot-2',
+      formats: Object.freeze([Object.freeze([300, 250] as const)]),
+      targeting: Object.freeze({}),
+    }),
+    'slot-2',
+    'gt1_2',
+  ]);
+  const terminal = vi.fn();
+  expect(h.bridge.bind(cycle, terminal)).toBe(true);
+  return { cycle, element, reservationId, terminal };
+}
+
+describe('bounded first-display render bridge', () => {
+  it('isolates interleaved APS and ADM ownership in one shared journal', () => {
+    const h = harness('aps');
+    const adm = bindMixedAdm(h);
+    registerOwner(h);
+
+    expect(h.bridge.recordGam(adm.cycle, 'gam_empty')).toBe(true);
+    const admFrame = adm.element.querySelector<HTMLIFrameElement>('iframe');
+    expect(admFrame?.srcdoc).toContain('mixed ADM creative');
+    admFrame?.dispatchEvent(new h.dom.window.Event('load'));
+    expect(adm.terminal).toHaveBeenCalledWith('accepted', null);
+    expect(h.terminals).toEqual([]);
+
+    const { documentPort, frame: apsFrame, nonce } = startApsDocument(h);
+    documentPort.dispatch({ message: 'TS APS Document Accepted', version: 1, nonce });
+    documentPort.dispatch({ message: 'TS APS Render Completed', version: 1, nonce });
+    expect(h.terminals).toEqual(['accepted']);
+
+    h.bridge.sealTsAdmission();
+    expect(h.bridge.closeIngress()).toBe(true);
+    const handoff = h.bridge.captureHandoff();
+    expect(
+      handoff?.[0].map((artifact) => ({
+        kind: artifact[3],
+        slotId: artifact[5],
+        token: artifact[6],
+      }))
+    ).toEqual([
+      { kind: 'gpt_adm', slotId: 'slot-2', token: adm.reservationId },
+      { kind: 'aps', slotId: 'slot-1', token: RESERVATION_ID },
+    ]);
+    expect(
+      new Set(handoff?.[1].filter((entry) => entry[0] === 'reservation').map((entry) => entry[1]))
+    ).toEqual(new Set([adm.reservationId, RESERVATION_ID]));
+    expect(h.bridge.detachCommittedArtifacts()).toBe(true);
+    h.bridge.dispose();
+    expect(admFrame?.isConnected).toBe(true);
+    expect(apsFrame.isConnected).toBe(true);
+  });
+
+  it('observes admitted bridge activity and terminal tombstone expiry', () => {
+    const mutations = vi.fn(() => true);
+    const h = harness('adm', mutations);
+    const shell = collapsedShell(h);
+    const owner = registerOwner(h, shell.frame.contentWindow!);
+    h.channels[0]?.port1.dispatch({
+      message: 'TS Owner Inserted',
+      version: 1,
+      lifecycleTicket: owner.ticket,
+    });
+    h.channels[0]?.port1.dispatch({
+      message: 'TS ADM Loaded',
+      version: 1,
+      lifecycleTicket: owner.ticket,
+    });
+    expect(h.terminals).toEqual(['accepted']);
+    expect(shell.frame.isConnected).toBe(true);
+
+    mutations.mockClear();
+    h.fire(3_000);
+    expect(mutations).toHaveBeenCalledOnce();
+  });
+
+  it('passes native ids through and suppresses malformed recognized TS requests', () => {
+    const h = harness();
+    const nativePort = new FakePort();
+    const native = requestEvent(nativePort, { adId: `r1_${'z'.repeat(22)}` });
+    h.dispatch(native);
+    expect(native.stopImmediatePropagation).not.toHaveBeenCalled();
+    expect(nativePort.postMessage).not.toHaveBeenCalled();
+
+    const refusedPort = new FakePort();
+    const malformed = requestEvent(refusedPort, {
+      data: {
+        message: 'Prebid Request',
+        adId: RESERVATION_ID,
+        adServerDomain: 'ads.example',
+      },
+    });
+    h.dispatch(malformed);
+    expect(malformed.stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(JSON.parse(refusedPort.postMessage.mock.calls[0]?.[0] as string)).toEqual({
+      message: 'Prebid Response',
+      adId: RESERVATION_ID,
+      rendererVersion: '4',
+      tsOwner: { version: 1, status: 'refused' },
+    });
+    expect(refusedPort.close).toHaveBeenCalledOnce();
+  });
+
+  it('never recognizes inherited or accessor-backed message routing fields', () => {
+    const h = harness();
+    const read = vi.fn(() =>
+      JSON.stringify({
+        message: 'Prebid Request',
+        adId: RESERVATION_ID,
+        adServerDomain: 'ads.example',
+      })
+    );
+    const event = Object.create(
+      Object.defineProperty({}, 'data', {
+        configurable: true,
+        get: read,
+      })
+    ) as Record<string, unknown>;
+    event.ports = [new FakePort()];
+    event.source = {};
+    event.stopImmediatePropagation = vi.fn();
+
+    h.dispatch(event);
+    expect(read).not.toHaveBeenCalled();
+    expect(event.stopImmediatePropagation).not.toHaveBeenCalled();
+  });
+
+  it('joins an exact claim and nonempty GAM cycle through one-use ADM owner control', () => {
+    const h = harness('adm');
+    const shell = collapsedShell(h);
+    const source = shell.frame.contentWindow!;
+    const responsePort = new FakePort();
+    const claim = requestEvent(responsePort, { source });
+    h.dispatch(claim);
+    expect(claim.stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(responsePort.postMessage).not.toHaveBeenCalled();
+
+    expect(h.bridge.recordGam(h.cycle, 'nonempty_gam')).toBe(true);
+    const outer = JSON.parse(responsePort.postMessage.mock.calls[0]?.[0] as string) as Record<
+      string,
+      unknown
+    >;
+    expect(outer).toMatchObject({
+      message: 'Prebid Response',
+      adId: RESERVATION_ID,
+      renderer: PUC_DYNAMIC_OWNER,
+      rendererVersion: '4',
+      tsOwner: { version: 1, status: 'ready', kind: 'adm' },
+    });
+    const ticket = (outer.tsOwner as Record<string, unknown>).lifecycleTicket;
+    expect(ticket).toMatch(/^t1_[A-Za-z0-9_-]{22}$/);
+    expect(responsePort.close).toHaveBeenCalledOnce();
+    expect(shell.frame.style.width).toBe('300px');
+    expect(shell.frame.style.height).toBe('250px');
+    expect(shell.wrapper.style.width).toBe('300px');
+    expect(shell.wrapper.style.height).toBe('250px');
+
+    const registrationPort = new FakePort();
+    const registration = ownerRegistration(ticket as string, registrationPort, source);
+    h.dispatch(registration);
+    expect(registration.stopImmediatePropagation).toHaveBeenCalledOnce();
+    const registered = JSON.parse(registrationPort.postMessage.mock.calls[0]?.[0] as string);
+    expect(registered).toEqual({
+      message: 'TS Render Owner Registered',
+      adId: RESERVATION_ID,
+      version: 1,
+      lifecycleTicket: ticket,
+    });
+    expect(registrationPort.postMessage.mock.calls[0]?.[1]).toEqual([h.channels[0]?.port2]);
+    expect(h.channels[0]?.port1.postMessage.mock.calls[0]?.[0]).toEqual({
+      message: 'TS ADM Start',
+      version: 1,
+      lifecycleTicket: ticket,
+      source: h.cycle[0].renderSource,
+    });
+
+    h.channels[0]?.port1.dispatch({
+      message: 'TS Owner Inserted',
+      version: 1,
+      lifecycleTicket: ticket,
+    });
+    expect(h.terminals).toEqual([]);
+    h.channels[0]?.port1.dispatch({
+      message: 'TS ADM Loaded',
+      version: 1,
+      lifecycleTicket: ticket,
+    });
+    expect(h.terminals).toEqual(['accepted']);
+    const controlCalls = h.channels[0]?.port1.postMessage.mock.calls ?? [];
+    expect(controlCalls[controlCalls.length - 1]?.[0]).toEqual({
+      message: 'TS Owner Settled',
+      version: 1,
+      lifecycleTicket: ticket,
+      outcome: 'accepted',
+    });
+
+    const replayPort = new FakePort();
+    const replay = ownerRegistration(ticket as string, replayPort, source);
+    h.dispatch(replay);
+    expect(replay.stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(JSON.parse(replayPort.postMessage.mock.calls[0]?.[0] as string)).toEqual({
+      message: 'TS Render Owner Refused',
+      adId: RESERVATION_ID,
+      version: 1,
+    });
+  });
+
+  it('refuses delayed APS owner registration after a later physical GPT request', () => {
+    const h = harness('aps');
+    const source = {};
+    const responsePort = new FakePort();
+    h.dispatch(requestEvent(responsePort, { source }));
+    expect(h.bridge.recordGam(h.cycle, 'nonempty_gam')).toBe(true);
+    const response = JSON.parse(responsePort.postMessage.mock.calls[0]?.[0] as string);
+
+    h.invalidateCycle();
+    const registrationPort = new FakePort();
+    h.dispatch(
+      ownerRegistration(response.tsOwner.lifecycleTicket as string, registrationPort, source)
+    );
+
+    expect(h.terminals).toEqual(['failed']);
+    expect(h.terminalFacts).toEqual([['failed', 'slot_unresolved']]);
+    expect(h.element.querySelector('iframe')).toBeNull();
+  });
+
+  it('never resizes an anchored or already-expanded PUC shell', () => {
+    const cases = [
+      {
+        mutate: ({ wrapper }: ReturnType<typeof collapsedShell>) => {
+          wrapper.setAttribute('data-anchor-status', 'displayed');
+        },
+        wrapperWidth: '1px',
+      },
+      {
+        mutate: ({ wrapper }: ReturnType<typeof collapsedShell>) => {
+          wrapper.style.width = '2px';
+        },
+        wrapperWidth: '2px',
+      },
+    ];
+    for (const { mutate, wrapperWidth } of cases) {
+      const h = harness('adm');
+      const shell = collapsedShell(h);
+      mutate(shell);
+      const responsePort = new FakePort();
+      h.dispatch(requestEvent(responsePort, { source: shell.frame.contentWindow! }));
+      expect(h.bridge.recordGam(h.cycle, 'nonempty_gam')).toBe(true);
+      expect(shell.frame.style.width).toBe('1px');
+      expect(shell.wrapper.style.width).toBe(wrapperWidth);
+      h.bridge.dispose();
+    }
+  });
+
+  it('requires APS document acceptance and completion in a hidden top-page PUC overlay', () => {
+    const h = harness('aps');
+    h.element.innerHTML = '<span>publisher GAM content</span>';
+    const source = {};
+    const responsePort = new FakePort();
+    h.dispatch(requestEvent(responsePort, { source }));
+    expect(h.bridge.recordGam(h.cycle, 'nonempty_gam')).toBe(true);
+    const outer = JSON.parse(responsePort.postMessage.mock.calls[0]?.[0] as string);
+    const ticket = outer.tsOwner.lifecycleTicket as string;
+    const registrationPort = new FakePort();
+    h.dispatch(ownerRegistration(ticket, registrationPort, source));
+
+    const start = h.channels[0]?.port1.postMessage.mock.calls[0]?.[0] as Record<string, unknown>;
+    expect(start).toEqual({
+      message: 'TS APS Top Mount Started',
+      version: 1,
+      lifecycleTicket: ticket,
+    });
+    expect(h.channels[0]?.port1.postMessage.mock.calls[0]?.[1]).toEqual([]);
+    expect(h.channels).toHaveLength(1);
+    expect(h.element.querySelector('span')?.textContent).toBe('publisher GAM content');
+    const { documentPort, frame, nonce } = startApsDocument(h);
+    expect(frame.parentNode).toBe(h.element);
+    expect(frame.style.position).toBe('absolute');
+    expect(frame.style.visibility).toBe('hidden');
+    expect(h.element.style.position).toBe('relative');
+
+    documentPort.dispatch({
+      message: 'TS APS Document Accepted',
+      version: 1,
+      nonce,
+    });
+    documentPort.dispatch({
+      message: 'TS APS Runner Loaded',
+      version: 1,
+      nonce,
+    });
+    expect(h.terminals).toEqual([]);
+    expect(frame.style.visibility).toBe('hidden');
+    documentPort.dispatch({
+      message: 'TS APS Render Completed',
+      version: 1,
+      nonce,
+    });
+    expect(h.terminals).toEqual(['accepted']);
+    expect(frame.style.visibility).toBe('visible');
+    expect(h.element.querySelector('span')?.textContent).toBe('publisher GAM content');
+    expect(h.channels[0]?.port1.postMessage.mock.calls[1]?.[0]).toEqual({
+      message: 'TS Owner Settled',
+      version: 1,
+      lifecycleTicket: ticket,
+      outcome: 'accepted',
+    });
+    expect(h.bridge.retire(h.cycle)).toBe(true);
+    expect(h.bridge.retire(h.cycle)).toBe(false);
+    expect(frame.isConnected).toBe(false);
+    expect(h.element.style.getPropertyValue('position')).toBe('');
+    expect(h.element.querySelector('span')?.textContent).toBe('publisher GAM content');
+    expect(h.terminals).toEqual(['accepted']);
+  });
+
+  it.each(['removed', 'reparented', 'host_replaced'] as const)(
+    'retires an accepted APS overlay before handoff when its DOM is %s',
+    (mutation) => {
+      const h = harness('aps');
+      h.element.innerHTML = '<span>publisher</span>';
+      const frame = acceptPucAps(h);
+      const movedHost = h.dom.window.document.createElement('div');
+      movedHost.id = 'moved-host';
+      h.dom.window.document.body.appendChild(movedHost);
+
+      if (mutation === 'removed') frame.remove();
+      if (mutation === 'reparented') movedHost.appendChild(frame);
+      if (mutation === 'host_replaced') {
+        const replacement = h.element.cloneNode(false);
+        h.element.replaceWith(replacement);
+      }
+
+      expect(h.bridge.sweepCommittedArtifacts()).toBe(1);
+      expect(h.bridge.sweepCommittedArtifacts()).toBe(0);
+      expect(frame.isConnected).toBe(false);
+      expect(h.element.style.getPropertyValue('position')).toBe('');
+      expect(h.element.querySelector('span')?.textContent).toBe('publisher');
+      expect(h.terminals).toEqual(['accepted']);
+
+      h.bridge.sealTsAdmission();
+      expect(h.bridge.closeIngress()).toBe(true);
+      expect(h.bridge.captureHandoff()?.[0]).toEqual([]);
+      expect(h.bridge.detachCommittedArtifacts()).toBe(true);
+    }
+  );
+
+  it.each(['src', 'srcdoc', 'sandbox', 'frame_style', 'host_position'] as const)(
+    'retires an accepted APS overlay before handoff when its %s integrity changes',
+    (mutation) => {
+      const h = harness('aps');
+      h.element.innerHTML = '<span>publisher</span>';
+      const frame = acceptPucAps(h);
+
+      if (mutation === 'src') frame.setAttribute('src', 'https://publisher.example/replaced');
+      if (mutation === 'srcdoc') frame.srcdoc = '<!doctype html><title>Replacement</title>';
+      if (mutation === 'sandbox') frame.setAttribute('sandbox', 'allow-scripts');
+      if (mutation === 'frame_style') frame.style.setProperty('visibility', 'hidden');
+      if (mutation === 'host_position') h.element.style.setProperty('position', 'absolute');
+
+      expect(h.bridge.sweepCommittedArtifacts()).toBe(1);
+      expect(h.bridge.sweepCommittedArtifacts()).toBe(0);
+      expect(frame.isConnected).toBe(false);
+      expect(h.element.querySelector('span')?.textContent).toBe('publisher');
+      expect(h.terminals).toEqual(['accepted']);
+
+      h.bridge.sealTsAdmission();
+      expect(h.bridge.closeIngress()).toBe(true);
+      expect(h.bridge.captureHandoff()?.[0]).toEqual([]);
+      expect(h.bridge.detachCommittedArtifacts()).toBe(true);
+    }
+  );
+
+  it('renders an attributable empty-GAM ADM fallback directly into the bound element', () => {
+    const h = harness('adm');
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    expect(frame).not.toBeNull();
+    expect(frame?.srcdoc).toContain('fictional creative');
+    expect(frame?.getAttribute('sandbox')).toBe(
+      'allow-forms allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation'
+    );
+    expect(h.terminals).toEqual([]);
+    frame?.dispatchEvent(new h.dom.window.Event('load'));
+    expect(h.terminals).toEqual(['accepted']);
+    expect(h.element.contains(frame)).toBe(true);
+    expect(frame?.onload).toBeNull();
+    expect(frame?.onerror).toBeNull();
+    frame?.dispatchEvent(new h.dom.window.Event('load'));
+    expect(h.terminals).toEqual(['accepted']);
+    h.bridge.dispose();
+    expect(h.element.contains(frame)).toBe(false);
+  });
+
+  it('renders an attributable empty-GAM APS fallback through the exact document channel', () => {
+    const h = harness('aps');
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    expect(frame).not.toBeNull();
+    const bootstrapNonce = new URL(frame?.src ?? '').hash.slice(1);
+    expect(bootstrapNonce).toMatch(/^b1_[A-Za-z0-9_-]{22}$/);
+    expect(h.channels).toHaveLength(0);
+    const postMessage = vi
+      .spyOn(frame!.contentWindow!, 'postMessage')
+      .mockImplementation(() => undefined);
+    h.dispatch({
+      data: JSON.stringify({
+        message: 'TS APS Bootstrap Ready',
+        version: 1,
+        bootstrapNonce,
+      }),
+      origin: 'null',
+      ports: [],
+      source: frame?.contentWindow,
+    });
+    const navigation = JSON.parse(postMessage.mock.calls[0]?.[0] as string) as Record<
+      string,
+      unknown
+    >;
+    expect(navigation).toMatchObject({
+      message: 'TS APS Bootstrap Configure',
+      version: 2,
+      bootstrapNonce,
+      rendererNonce: expect.stringMatching(/^n1_[A-Za-z0-9_-]{22}$/),
+      creativeOrigin: 'https://creative.example',
+      tagType: 'iframe',
+    });
+    expect(navigation).not.toHaveProperty('containerUrl');
+    expect(postMessage.mock.calls[0]?.slice(1)).toEqual(['*', []]);
+    expect(frame?.getAttribute('sandbox')).toBe(
+      'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation'
+    );
+    const nonce = navigation.rendererNonce as string;
+    expect(nonce).toMatch(/^n1_[A-Za-z0-9_-]{22}$/);
+    const documentPort = new FakePort();
+    h.dispatch({
+      data: JSON.stringify({
+        message: 'TS APS Container Ready',
+        version: 1,
+        bootstrapNonce,
+        rendererNonce: nonce,
+      }),
+      origin: 'null',
+      ports: [documentPort],
+      source: frame?.contentWindow,
+    });
+    expect(documentPort.postMessage).toHaveBeenCalledWith(
+      {
+        version: 1,
+        nonce,
+        publisherOrigin: 'https://publisher.example',
+        renderer: h.cycle[0].renderSource,
+      },
+      []
+    );
+    documentPort.dispatch({
+      message: 'TS APS Document Accepted',
+      version: 1,
+      nonce,
+    });
+    documentPort.dispatch({
+      message: 'TS APS Runner Loaded',
+      version: 1,
+      nonce,
+    });
+    expect(h.terminals).toEqual([]);
+    documentPort.dispatch({
+      message: 'TS APS Render Completed',
+      version: 1,
+      nonce,
+    });
+    expect(h.terminals).toEqual(['accepted']);
+    expect(h.element.contains(frame)).toBe(true);
+    expect(frame?.onload).toBeNull();
+    expect(frame?.onerror).toBeNull();
+  });
+
+  it('fails closed when an APS document port reports a clone error', () => {
+    const h = harness('aps');
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    const bootstrapNonce = new URL(frame?.src ?? '').hash.slice(1);
+    const postMessage = vi
+      .spyOn(frame!.contentWindow!, 'postMessage')
+      .mockImplementation(() => undefined);
+    h.dispatch({
+      data: JSON.stringify({
+        message: 'TS APS Bootstrap Ready',
+        version: 1,
+        bootstrapNonce,
+      }),
+      origin: 'null',
+      ports: [],
+      source: frame?.contentWindow,
+    });
+    const navigation = JSON.parse(postMessage.mock.calls[0]?.[0] as string) as Record<
+      string,
+      unknown
+    >;
+    const rendererNonce = navigation.rendererNonce;
+    const documentPort = new FakePort();
+    h.dispatch({
+      data: JSON.stringify({
+        message: 'TS APS Container Ready',
+        version: 1,
+        bootstrapNonce,
+        rendererNonce,
+      }),
+      origin: 'null',
+      ports: [documentPort],
+      source: frame?.contentWindow,
+    });
+    documentPort.dispatchError();
+    expect(h.terminals).toEqual(['failed']);
+    expect(h.element.querySelector('iframe')).toBeNull();
+  });
+
+  it('bounds claim waiting and disposes every listener, timer, port, and pending frame once', () => {
+    const timeout = harness('adm');
+    expect(timeout.bridge.recordGam(timeout.cycle, 'nonempty_gam')).toBe(true);
+    timeout.fire(3_000);
+    expect(timeout.terminals).toEqual(['failed']);
+    expect(timeout.terminalFacts).toEqual([['failed', 'bridge_claim_timeout']]);
+
+    const pending = harness('adm');
+    expect(pending.bridge.recordGam(pending.cycle, 'gam_empty')).toBe(true);
+    const frame = pending.element.querySelector('iframe');
+    expect(frame).not.toBeNull();
+    pending.bridge.dispose();
+    pending.bridge.dispose();
+    expect(pending.terminals).toEqual(['cancelled']);
+    expect(pending.terminalFacts).toEqual([['cancelled', 'navigation_disposed']]);
+    expect(pending.element.contains(frame)).toBe(false);
+    expect(pending.target.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(pending.target.removeEventListener).toHaveBeenCalledWith(
+      'message',
+      expect.any(Function),
+      true
+    );
+    expect(pending.timers).toHaveLength(0);
+  });
+
+  it('enforces ticket, insertion, ADM load, APS document, and APS completion deadlines', () => {
+    const ticket = harness('adm');
+    const ticketPort = new FakePort();
+    ticket.dispatch(requestEvent(ticketPort));
+    expect(ticket.bridge.recordGam(ticket.cycle, 'nonempty_gam')).toBe(true);
+    ticket.fire(3_000);
+    expect(ticket.terminals).toEqual(['failed']);
+    expect(ticket.terminalFacts).toEqual([['failed', 'owner_registration_timeout']]);
+
+    const insertion = harness('adm');
+    registerOwner(insertion);
+    insertion.fire(1_000);
+    expect(insertion.terminals).toEqual(['failed']);
+    expect(insertion.terminalFacts).toEqual([['failed', 'owner_insertion_timeout']]);
+
+    const adm = harness('adm');
+    const admOwner = registerOwner(adm);
+    adm.channels[0]?.port1.dispatch({
+      message: 'TS Owner Inserted',
+      version: 1,
+      lifecycleTicket: admOwner.ticket,
+    });
+    adm.fire(5_000);
+    expect(adm.terminals).toEqual(['failed']);
+    expect(adm.terminalFacts).toEqual([['failed', 'adm_document_no_load']]);
+
+    const document = harness('aps');
+    registerOwner(document);
+    document.fireLast(3_000);
+    expect(document.terminals).toEqual(['failed']);
+    expect(document.terminalFacts).toEqual([['failed', 'renderer_document_no_load']]);
+
+    const completion = harness('aps');
+    registerOwner(completion);
+    const { documentPort, nonce } = startApsDocument(completion);
+    documentPort.dispatch({
+      message: 'TS APS Document Accepted',
+      version: 1,
+      nonce,
+    });
+    completion.fire(10_000);
+    expect(completion.terminals).toEqual(['failed']);
+    expect(completion.terminalFacts).toEqual([['failed', 'runner_failed']]);
+  });
+
+  it('seals only after every attempt is terminal and refuses later authority', () => {
+    const active = harness('adm');
+    expect(() => active.bridge.sealTsAdmission()).toThrow('tsjs');
+
+    const terminal = harness('adm');
+    expect(terminal.bridge.recordGam(terminal.cycle, 'gam_empty')).toBe(true);
+    terminal.element.querySelector('iframe')?.dispatchEvent(new terminal.dom.window.Event('load'));
+    expect(() => terminal.bridge.sealTsAdmission()).not.toThrow();
+    expect(terminal.bridge.bind(terminal.cycle, () => undefined)).toBe(false);
+  });
+
+  it('captures and detaches an accepted direct frame without retaining provisional authority', () => {
+    const h = harness('adm');
+    expect(h.bridge.recordGam(h.cycle, 'gam_empty')).toBe(true);
+    const frame = h.element.querySelector('iframe');
+    frame?.dispatchEvent(new h.dom.window.Event('load'));
+    h.bridge.sealTsAdmission();
+
+    expect(h.bridge.closeIngress()).toBe(true);
+    expect(h.bridge.captureHandoff()).toEqual([
+      [[null, null, frame, 'gpt_adm', 'trusted_server', 'slot-1', RESERVATION_ID]],
+      [['reservation', RESERVATION_ID, 900_000, 1]],
+      0,
+      2,
+      1,
+    ]);
+    expect(h.bridge.detachCommittedArtifacts()).toBe(true);
+    expect(h.bridge.detachCommittedArtifacts()).toBe(false);
+    h.bridge.dispose();
+
+    expect(frame?.isConnected).toBe(true);
+    expect(h.target.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(h.timers).toHaveLength(0);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/slices.test.ts b/crates/trusted-server-js/lib/test/first_display/slices.test.ts
new file mode 100644
index 000000000..efcbd3de4
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/slices.test.ts
@@ -0,0 +1,1424 @@
+import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+
+import {
+  APS_INITIAL_SLICE,
+  CREATIVE_INITIAL_SLICE,
+  DATADOME_INITIAL_SLICE,
+  DIDOMI_INITIAL_SLICE,
+  GOOGLE_TAG_MANAGER_INITIAL_SLICE,
+  GPT_INITIAL_SLICE,
+  INITIAL_SLICE_DEFINITIONS,
+  LOCKR_INITIAL_SLICE,
+  OSANO_INITIAL_SLICE,
+  PERMUTIVE_INITIAL_SLICE,
+  PREBID_INITIAL_SLICE,
+  selectInitialSliceDefinitions,
+  SOURCEPOINT_INITIAL_SLICE,
+  TESTLIGHT_INITIAL_SLICE,
+} from '../../src/first_display/composition';
+import type {
+  FirstDisplaySliceHost,
+  InitialSliceDefinition,
+  InitialSliceInstaller,
+} from '../../src/first_display/slices/definition';
+import type { FirstDisplaySliceActivationContext } from '../../src/shared/first_display_transaction';
+import type { FirstDisplayRouteRuleV1 } from '../../src/first_display/leaf/route_guard';
+import { installDidomiInitial } from '../../src/first_display/leaf/config_guard';
+import {
+  installApsInitial,
+  type FirstDisplayApsProtocolV1,
+} from '../../src/first_display/leaf/aps_protocol';
+import {
+  installGptInitial,
+  type FirstDisplayGptBatchPolicyV1,
+  type FirstDisplayGptProtocolV1,
+} from '../../src/first_display/leaf/gpt_protocol';
+import {
+  installPrebidInitial,
+  type FirstDisplayPrebidProtocolV1,
+} from '../../src/first_display/leaf/prebid_protocol';
+import {
+  installPermutiveInitial,
+  snapshotPermutiveInitialSegments,
+  type FirstDisplayContextRouteRuleV1,
+} from '../../src/first_display/leaf/context_snapshot';
+import {
+  installOsanoInitial,
+  installSourcepointInitial,
+  type FirstDisplayConsentRouteRuleV1,
+} from '../../src/first_display/leaf/consent_snapshot';
+import {
+  captureMutationObservedBindings,
+  createFirstDisplayParserStateCollector,
+  registerFirstDisplayComponent,
+  type FirstDisplayComponentRegistrationV1,
+} from '../../src/shared/first_display_registration';
+import { createDidomiRuntime } from '../../src/integrations/didomi/module';
+import { getPermutiveSegments } from '../../src/integrations/permutive/segments';
+import { mirrorSourcepointConsent } from '../../src/integrations/sourcepoint/consent_mirror';
+import {
+  installRenderOwnerInitial,
+  type FirstDisplayRenderOwnerProtocolV1,
+} from '../../src/first_display/render_journal';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+function clearAllCookies(): void {
+  for (const cookie of document.cookie.split(';')) {
+    const name = cookie.split('=')[0]?.trim();
+    if (name) document.cookie = `${name}=; path=/; Max-Age=0`;
+  }
+}
+
+function readCookie(name: string): string | undefined {
+  const prefix = `${name}=`;
+  return document.cookie
+    .split('; ')
+    .find((entry) => entry.startsWith(prefix))
+    ?.slice(prefix.length);
+}
+
+function componentRegistration(): FirstDisplayComponentRegistrationV1 {
+  return Object.freeze({
+    abi: 1,
+    id: 'gpt_initial',
+    releaseId: RELEASE_ID,
+    order: 7,
+    install: () => undefined,
+  });
+}
+
+function activateInitialSlice(
+  definition: InitialSliceDefinition,
+  host: FirstDisplaySliceHost,
+  context: FirstDisplaySliceActivationContext
+): void {
+  host.activate(definition.id, context.own, definition.install);
+}
+
+describe('first-display initial slice definitions', () => {
+  it('captures bounded parser observations once per key in canonical slice order', () => {
+    const collector = createFirstDisplayParserStateCollector();
+
+    expect(collector.register('lockr_initial')).toBe(true);
+    expect(collector.observe('gpt_initial', 'protocol_version', 1)).toBe(true);
+    expect(collector.observe('creative_initial', 'guard_count', 1)).toBe(true);
+    expect(collector.observe('gpt_initial', 'protocol_version', 2)).toBe(true);
+    expect(collector.observe('gpt_initial', '', 3)).toBe(false);
+
+    const snapshot = collector.snapshot();
+    expect(snapshot).toEqual([
+      {
+        sliceId: 'creative_initial',
+        observations: ['guard_count'],
+        values: [['guard_count', 1]],
+      },
+      {
+        sliceId: 'gpt_initial',
+        observations: ['protocol_version'],
+        values: [['protocol_version', 2]],
+      },
+      { sliceId: 'lockr_initial', observations: [], values: [] },
+    ]);
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(Object.isFrozen(snapshot[0]?.values[0])).toBe(true);
+  });
+
+  it('preserves exact frozen bindings while observing each successful parser update', () => {
+    const events: string[] = [];
+    const candidate = Object.freeze({
+      observe: (name: string, value: unknown) => events.push(`observe:${name}:${String(value)}`),
+      register: () => () => undefined,
+    });
+    const observations: unknown[] = [];
+    const captured = captureMutationObservedBindings(
+      candidate,
+      () => {
+        events.push('mutation');
+        return true;
+      },
+      (key, value) => observations.push([key, value])
+    ) as typeof candidate;
+
+    expect(captured).not.toBe(candidate);
+    expect(Object.isFrozen(captured)).toBe(true);
+    expect(Reflect.ownKeys(captured)).toEqual(['observe', 'register']);
+    captured.observe('segment_count', 2);
+    expect(events).toEqual(['observe:segment_count:2', 'mutation']);
+    expect(observations).toEqual([['segment_count', 2]]);
+  });
+
+  it('returns exact protocol activation receipts while registering full protocols', () => {
+    const own = vi.fn();
+    const register = vi.fn((_protocol: object) => () => undefined);
+    const observe = vi.fn();
+
+    const receipts = [
+      installApsInitial(
+        Object.freeze({
+          observe,
+          publisherOrigin: 'https://publisher.example',
+          register,
+        }),
+        own
+      ),
+      installGptInitial(
+        Object.freeze({ browser: {} as Window, observe, register }),
+        own,
+        () =>
+          Object.freeze({
+            start: () => true,
+            closeIngress: () => true,
+            captureHandoff: () => Object.freeze([]),
+            captureDiagnosticsHandoff: () =>
+              Object.freeze([Object.freeze([]), Object.freeze([]), 1, 0, 0] as const),
+            detachCommittedSlots: () => true,
+            dispose: () => undefined,
+          }),
+        Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled: true })
+      ),
+      installPrebidInitial(Object.freeze({ observe, register }), own),
+    ];
+
+    expect(receipts).toEqual([
+      [1, 'aps'],
+      [1, 'gpt'],
+      [1, 'prebid'],
+    ]);
+    for (const receipt of receipts) {
+      expect(Reflect.ownKeys(receipt)).toEqual(['0', '1', 'length']);
+      expect(Object.isFrozen(receipt)).toBe(true);
+    }
+    expect(register).toHaveBeenCalledTimes(3);
+    for (const [protocol] of register.mock.calls) {
+      expect(Reflect.ownKeys(protocol).length).toBeGreaterThan(2);
+      expect(Object.isFrozen(protocol)).toBe(true);
+    }
+  });
+
+  it('installs one source-neutral render journal and gives its slice disposer final ownership', () => {
+    const dom = new JSDOM('<!doctype html><div id="slot-1"></div>', {
+      url: 'https://publisher.example/',
+    });
+    const removeEventListener = vi.spyOn(dom.window, 'removeEventListener');
+    const release = vi.fn();
+    const owned: Array<() => void> = [];
+    let protocol: FirstDisplayRenderOwnerProtocolV1 | undefined;
+
+    expect(
+      installRenderOwnerInitial(
+        Object.freeze({
+          observe: vi.fn(),
+          register: (candidate: FirstDisplayRenderOwnerProtocolV1) => {
+            protocol = candidate;
+            return release;
+          },
+        }),
+        (dispose) => owned.push(dispose)
+      )
+    ).toEqual([1, 'render_owner']);
+    expect(protocol).toEqual([1, 'render_owner', expect.any(Function)]);
+    expect(Object.isFrozen(protocol)).toBe(true);
+    const createRenderBridge = protocol?.[2];
+    const bridge = createRenderBridge?.([
+      dom.window as unknown as Window,
+      () => undefined,
+      () => {
+        throw new Error('unused');
+      },
+      dom.window.document,
+      () => undefined,
+      () => 0,
+      undefined,
+      () => ({}),
+    ]);
+
+    expect(bridge).toHaveLength(10);
+    expect(Object.isFrozen(bridge)).toBe(true);
+    expect(() =>
+      createRenderBridge?.([
+        dom.window as unknown as Window,
+        () => undefined,
+        () => {
+          throw new Error('unused');
+        },
+        dom.window.document,
+        () => undefined,
+        () => 0,
+        undefined,
+        () => ({}),
+      ])
+    ).toThrow(TypeError);
+
+    expect(owned).toHaveLength(1);
+    owned[0]?.();
+    expect(release).toHaveBeenCalledOnce();
+    expect(removeEventListener).toHaveBeenCalledWith('message', expect.any(Function), true);
+    dom.window.close();
+  });
+
+  it.each([false, true])(
+    'projects the typed GAM attribution flag into the first-display GPT owner (%s)',
+    (gamAttributionEnabled) => {
+      const observe = vi.fn();
+      const commands: Array<() => void> = [];
+      const setConfig = vi.fn();
+      const browser = {
+        googletag: { cmd: commands, setConfig },
+      } as unknown as Window;
+      let protocol: FirstDisplayGptProtocolV1 | undefined;
+      let policy: FirstDisplayGptBatchPolicyV1 | undefined;
+      const createBatch = vi.fn((_input: unknown, candidate: FirstDisplayGptBatchPolicyV1) => {
+        policy = candidate;
+        return Object.freeze({
+          start: () => true,
+          closeIngress: () => true,
+          captureHandoff: () => Object.freeze([]),
+          captureDiagnosticsHandoff: () =>
+            Object.freeze([Object.freeze([]), Object.freeze([]), 1, 0, 0] as const),
+          detachCommittedSlots: () => true,
+          dispose: () => undefined,
+        });
+      });
+      installGptInitial(
+        Object.freeze({
+          browser,
+          observe,
+          register: (candidate: FirstDisplayGptProtocolV1) => {
+            protocol = candidate;
+            return () => undefined;
+          },
+        }),
+        () => undefined,
+        createBatch,
+        Object.freeze({ gamAttributionEnabled, pageBidsEnabled: true })
+      );
+
+      expect(protocol).toEqual([1, 'gpt', expect.any(Function)]);
+      expect(Object.isFrozen(protocol)).toBe(true);
+      const batch = protocol?.[2]({} as never);
+      expect(batch).toHaveLength(6);
+      expect(Object.isFrozen(batch)).toBe(true);
+
+      expect(createBatch).toHaveBeenCalledOnce();
+      expect(createBatch.mock.calls[0]?.[0]).toEqual({});
+      expect(policy?.deadlines).toEqual({
+        externalReadyMs: 10_000,
+        requestStartMs: 3_000,
+        completionMs: 10_000,
+      });
+      expect(
+        policy?.requestPlan(
+          Object.freeze({ initialLoadDisabled: true, ownership: 'trusted_server' })
+        )
+      ).toEqual({ operations: ['display', 'refresh'], requestOperation: 1 });
+      expect(policy?.classifyRenderEnded(Object.freeze({ isEmpty: false }))).toBe('nonempty_gam');
+      expect(commands).toHaveLength(gamAttributionEnabled ? 1 : 0);
+      commands.splice(0).forEach((command) => command());
+      expect(setConfig).toHaveBeenCalledTimes(gamAttributionEnabled ? 1 : 0);
+      if (gamAttributionEnabled) {
+        expect(setConfig).toHaveBeenCalledExactlyOnceWith({ targeting: { ts: 'true' } });
+      }
+      expect(observe).toHaveBeenCalledWith('gam', gamAttributionEnabled);
+    }
+  );
+
+  it('pins the exact thirteen optional slices in build order', () => {
+    expect(INITIAL_SLICE_DEFINITIONS.map(({ id }) => id)).toEqual([
+      'render_owner_initial',
+      'aps_initial',
+      'creative_initial',
+      'datadome_initial',
+      'didomi_initial',
+      'google_tag_manager_initial',
+      'gpt_initial',
+      'lockr_initial',
+      'osano_initial',
+      'permutive_initial',
+      'sourcepoint_initial',
+      'prebid_initial',
+      'testlight_initial',
+    ]);
+  });
+
+  it('exposes only each exact initial-slice installer obligation', () => {
+    const events: string[] = [];
+    const dispose = vi.fn();
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (callback: () => void) => void,
+        _install: InitialSliceInstaller
+      ) => {
+        own(dispose);
+        events.push(id);
+      },
+    });
+
+    for (const definition of INITIAL_SLICE_DEFINITIONS) {
+      host.activate(definition.id, () => undefined, definition.install);
+    }
+    expect(events).toEqual(INITIAL_SLICE_DEFINITIONS.map(({ id }) => id));
+    expect(
+      INITIAL_SLICE_DEFINITIONS.every(
+        (definition) => Reflect.ownKeys(definition).join(',') === 'id,install'
+      )
+    ).toBe(true);
+  });
+
+  it('rejects unknown, duplicate, omitted-base, and misordered selections', () => {
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'gpt_initial'])?.map(({ id }) => id)
+    ).toEqual(['gpt_initial']);
+    expect(selectInitialSliceDefinitions(['gpt_initial'])).toBeUndefined();
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'gpt_initial', 'gpt_initial'])
+    ).toBeUndefined();
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'prebid_initial', 'gpt_initial'])
+    ).toBeUndefined();
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'aps_initial', 'gpt_initial'])
+    ).toBeUndefined();
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'render_owner_initial'])
+    ).toBeUndefined();
+    expect(
+      selectInitialSliceDefinitions(['first_display', 'unknown_initial' as 'gpt_initial'])
+    ).toBeUndefined();
+  });
+
+  it('registers through only the bootstrap-owned sink on the exact current script', () => {
+    const dom = new JSDOM(
+      `<!doctype html><script id="trustedserver-js" src="/static/tsjs=tsjs-first-display.min.js?m=0041&v=${'b'.repeat(64)}"></script>`,
+      { url: 'https://publisher.example/' }
+    );
+    const script = dom.window.document.querySelector('script') as HTMLScriptElement;
+    Object.defineProperty(dom.window.document, 'currentScript', {
+      configurable: true,
+      value: script,
+    });
+    const target = {};
+    const sink = vi.fn(function (this: unknown, registration: unknown, source: unknown) {
+      expect(this).toBe(target);
+      expect(registration).toBe(componentRegistrationValue);
+      expect(source).toBe(script);
+      return true;
+    });
+    Object.defineProperty(target, '_registerFirstDisplay', {
+      configurable: true,
+      enumerable: false,
+      value: sink,
+      writable: false,
+    });
+    Object.defineProperty(dom.window, 'tsjs', {
+      configurable: true,
+      enumerable: true,
+      value: target,
+      writable: true,
+    });
+    const componentRegistrationValue = componentRegistration();
+
+    expect(
+      registerFirstDisplayComponent(dom.window as unknown as Window, componentRegistrationValue)
+    ).toBe(true);
+    expect(sink).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects an accessor/inherited sink and a noncanonical or detached current script', () => {
+    const make = () => {
+      const dom = new JSDOM(
+        `<!doctype html><script id="trustedserver-js" src="/static/tsjs=tsjs-first-display.min.js?m=0041&v=${'b'.repeat(64)}"></script>`,
+        { url: 'https://publisher.example/' }
+      );
+      const script = dom.window.document.querySelector('script') as HTMLScriptElement;
+      Object.defineProperty(dom.window.document, 'currentScript', {
+        configurable: true,
+        value: script,
+      });
+      return { dom, script };
+    };
+
+    const accessor = make();
+    Object.defineProperty(accessor.dom.window, 'tsjs', {
+      configurable: true,
+      value: Object.defineProperty({}, '_registerFirstDisplay', {
+        configurable: true,
+        get: vi.fn(),
+      }),
+    });
+    expect(
+      registerFirstDisplayComponent(
+        accessor.dom.window as unknown as Window,
+        componentRegistration()
+      )
+    ).toBe(false);
+
+    const inherited = make();
+    const prototype = Object.defineProperty({}, '_registerFirstDisplay', {
+      value: () => true,
+    });
+    Object.defineProperty(inherited.dom.window, 'tsjs', {
+      configurable: true,
+      value: Object.create(prototype),
+    });
+    expect(
+      registerFirstDisplayComponent(
+        inherited.dom.window as unknown as Window,
+        componentRegistration()
+      )
+    ).toBe(false);
+
+    const wrongSource = make();
+    wrongSource.script.src = `https://publisher.example/static/tsjs=tsjs-first-display.min.js?v=${'b'.repeat(64)}&m=0041`;
+    Object.defineProperty(wrongSource.dom.window, 'tsjs', {
+      configurable: true,
+      value: Object.defineProperty({}, '_registerFirstDisplay', {
+        value: () => true,
+      }),
+    });
+    expect(
+      registerFirstDisplayComponent(
+        wrongSource.dom.window as unknown as Window,
+        componentRegistration()
+      )
+    ).toBe(false);
+
+    const detached = make();
+    detached.script.remove();
+    Object.defineProperty(detached.dom.window, 'tsjs', {
+      configurable: true,
+      value: Object.defineProperty({}, '_registerFirstDisplay', {
+        value: () => true,
+      }),
+    });
+    expect(
+      registerFirstDisplayComponent(
+        detached.dom.window as unknown as Window,
+        componentRegistration()
+      )
+    ).toBe(false);
+  });
+
+  it('owns the initial Didomi SDK path without clobbering publisher configuration', () => {
+    const publisherConfig = { notice: 'publisher-owned' };
+    const target = {
+      didomiConfig: publisherConfig,
+      location: { origin: 'https://publisher.example' },
+    };
+    const observations: Array<readonly [string, string]> = [];
+    const disposers: Array<() => void> = [];
+    const bindings = Object.freeze({
+      config: Object.freeze({ proxyPath: '/integrations/didomi/consent/' }),
+      observe: (name: string, value: string) => observations.push([name, value]),
+      target,
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('didomi_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+    activateInitialSlice(
+      DIDOMI_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(target.didomiConfig).toBe(publisherConfig);
+    expect(target.didomiConfig).toEqual({
+      notice: 'publisher-owned',
+      sdkPath: 'https://publisher.example/integrations/didomi/consent/',
+    });
+    expect(observations).toEqual([
+      ['sdk_path', 'https://publisher.example/integrations/didomi/consent/'],
+    ]);
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(target.didomiConfig).toEqual({ notice: 'publisher-owned' });
+  });
+
+  it('keeps the Didomi initial config/rollback corpus equal to the persistent owner', () => {
+    const validCases = [
+      { config: Object.freeze({ proxyPath: '/consent/' }), initial: undefined },
+      {
+        config: Object.freeze({ proxyPath: '/consent/sdk/' }),
+        initial: { notice: 'publisher' },
+      },
+      {
+        config: Object.freeze({ proxyPath: '/consent/sdk/' }),
+        initial: { notice: 'publisher', sdkPath: 'https://publisher.example/original.js' },
+      },
+    ] as const;
+    for (const fixture of validCases) {
+      const persistentTarget = {
+        ...(fixture.initial ? { didomiConfig: { ...fixture.initial } } : {}),
+        location: { origin: 'https://publisher.example' },
+      };
+      const initialTarget = {
+        ...(fixture.initial ? { didomiConfig: { ...fixture.initial } } : {}),
+        location: { origin: 'https://publisher.example' },
+      };
+      const persistentDispose = createDidomiRuntime({
+        started: () => undefined,
+        target: persistentTarget,
+      }).activate(fixture.config);
+      const initialDisposers: Array<() => void> = [];
+      installDidomiInitial(
+        Object.freeze({
+          config: fixture.config,
+          observe: () => undefined,
+          target: initialTarget,
+        }),
+        (dispose) => initialDisposers.push(dispose)
+      );
+      expect(initialTarget.didomiConfig).toEqual(persistentTarget.didomiConfig);
+
+      persistentDispose();
+      initialDisposers.reverse().forEach((dispose) => dispose());
+      expect(initialTarget.didomiConfig).toEqual(persistentTarget.didomiConfig);
+      expect(Object.prototype.hasOwnProperty.call(initialTarget, 'didomiConfig')).toBe(
+        Object.prototype.hasOwnProperty.call(persistentTarget, 'didomiConfig')
+      );
+    }
+
+    for (const config of [
+      { proxyPath: '/not-frozen/' },
+      Object.freeze({ proxyPath: '//attacker.example/sdk.js' }),
+      Object.freeze({ proxyPath: '/consent/?publisher=1' }),
+    ]) {
+      const persistent = () =>
+        createDidomiRuntime({
+          started: () => undefined,
+          target: { location: { origin: 'https://publisher.example' } },
+        }).activate(config);
+      const initial = () =>
+        installDidomiInitial(
+          Object.freeze({
+            config,
+            observe: () => undefined,
+            target: { location: { origin: 'https://publisher.example' } },
+          }),
+          () => undefined
+        );
+      expect(persistent).toThrow();
+      expect(initial).toThrow();
+    }
+  });
+
+  it('captures preexisting and later Testlight callbacks once without draining user work itself', () => {
+    const calls: string[] = [];
+    const first = () => calls.push('first');
+    const throwing = () => {
+      calls.push('throwing');
+      throw new Error('publisher callback failed');
+    };
+    const second = () => calls.push('second');
+    const later = () => calls.push('later');
+    const original = [first, 'invalid', throwing, second];
+    const target = { testlight: { publisher: true, que: original } };
+    const observations: number[] = [];
+    const disposers: Array<() => void> = [];
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('testlight_initial');
+        install?.(
+          Object.freeze({
+            enqueue: (callback: () => void) => callback(),
+            observe: (_name: string, count: number) => observations.push(count),
+            target,
+          }),
+          own,
+          undefined
+        );
+      },
+    });
+
+    activateInitialSlice(
+      TESTLIGHT_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(calls).toEqual(['first', 'throwing', 'second']);
+    expect(original).toEqual([]);
+    expect(target.testlight.que).not.toBe(original);
+    expect(target.testlight.que.push(later)).toBe(1);
+    expect(calls).toEqual(['first', 'throwing', 'second', 'later']);
+    expect(target.testlight.que).toHaveLength(0);
+    expect(observations).toEqual([3, 4]);
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(target.testlight).toEqual({ publisher: true, que: original });
+    expect(original).toEqual([]);
+  });
+
+  it('registers exact DataDome and GTM route matchers with first-party path preservation', () => {
+    const cases = [
+      {
+        definition: DATADOME_INITIAL_SLICE,
+        id: 'datadome',
+        accepted: [
+          ['script', 'https://js.datadome.co/tags.js?x=1'],
+          ['preload', '//js.datadome.co/js/check'],
+        ],
+        rejected: [
+          ['script', 'https://cdn.example/js.datadome.co.js'],
+          ['beacon', 'https://js.datadome.co/tags.js'],
+        ],
+        rewritten: 'https://publisher.example/integrations/datadome/tags.js?x=1',
+      },
+      {
+        definition: GOOGLE_TAG_MANAGER_INITIAL_SLICE,
+        id: 'google_tag_manager',
+        accepted: [
+          ['script', 'https://www.googletagmanager.com/gtm.js?id=GTM-1'],
+          ['fetch', 'https://www.google-analytics.com/g/collect?v=2'],
+          ['beacon', 'https://analytics.google.com/collect?v=2'],
+        ],
+        rejected: [
+          ['script', 'https://googletagmanager.com/gtm.js'],
+          ['script', 'https://www.googletagmanager.com/ns.html'],
+        ],
+        rewritten: 'https://publisher.example/integrations/google_tag_manager/gtm.js?id=GTM-1',
+      },
+    ] as const;
+
+    for (const fixture of cases) {
+      let rule: FirstDisplayRouteRuleV1 | undefined;
+      const dispose = vi.fn();
+      const disposers: Array<() => void> = [];
+      const host = Object.freeze({
+        activate: (
+          _id: string,
+          own: (release: () => void) => void,
+          install?: InitialSliceInstaller
+        ) =>
+          install?.(
+            Object.freeze({
+              observe: () => undefined,
+              origin: 'https://publisher.example',
+              register: (candidate: FirstDisplayRouteRuleV1) => {
+                rule = candidate;
+                return dispose;
+              },
+            }),
+            own,
+            undefined
+          ),
+      });
+      activateInitialSlice(
+        fixture.definition,
+        host,
+        Object.freeze({
+          own: (release: () => void) => disposers.push(release),
+          afterActivate: () => undefined,
+        })
+      );
+      expect(rule?.id).toBe(fixture.id);
+      for (const [kind, url] of fixture.accepted) expect(rule?.matches(kind, url)).toBe(true);
+      for (const [kind, url] of fixture.rejected) expect(rule?.matches(kind, url)).toBe(false);
+      expect(rule?.rewrite(fixture.accepted[0][1])).toBe(fixture.rewritten);
+      disposers.reverse().forEach((release) => release());
+      expect(dispose).toHaveBeenCalledOnce();
+    }
+  });
+
+  it('owns Lockr route matching and the bounded initial SDK host rewrite', () => {
+    const sdk = { host: 'https://identity.loc.kr' };
+    const timers: Array<() => void> = [];
+    const disposers: Array<() => void> = [];
+    let rule: FirstDisplayRouteRuleV1 | undefined;
+    const unregister = vi.fn();
+    const observations: Array<readonly [string, string | number]> = [];
+    const bindings = Object.freeze({
+      clearTimer: (handle: unknown) => {
+        const index = timers.indexOf(handle as () => void);
+        if (index >= 0) timers.splice(index, 1);
+      },
+      getSdk: () => sdk,
+      host: 'publisher.example',
+      observe: (name: string, value: string | number) => observations.push([name, value]),
+      origin: 'https://publisher.example',
+      protocol: 'https:',
+      register: (candidate: FirstDisplayRouteRuleV1) => {
+        rule = candidate;
+        return unregister;
+      },
+      setTimer: (callback: () => void) => {
+        timers.push(callback);
+        return callback;
+      },
+    });
+    const host = Object.freeze({
+      activate: (
+        _id: string,
+        own: (release: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => install?.(bindings, own, undefined),
+    });
+
+    activateInitialSlice(
+      LOCKR_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (release: () => void) => disposers.push(release),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(rule?.matches('script', 'https://aim.loc.kr/sdk.js')).toBe(true);
+    expect(rule?.matches('preload', 'https://identity.loc.kr/identity-lockr.js')).toBe(true);
+    expect(rule?.matches('script', 'https://identity.loc.kr/other.js')).toBe(false);
+    expect(rule?.rewrite('https://aim.loc.kr/sdk.js')).toBe(
+      'https://publisher.example/integrations/lockr/sdk'
+    );
+    expect(sdk.host).toBe('https://publisher.example/integrations/lockr/api');
+    expect(observations).toContainEqual(['sdk_host', sdk.host]);
+
+    disposers.reverse().forEach((release) => release());
+    expect(sdk.host).toBe('https://identity.loc.kr');
+    expect(unregister).toHaveBeenCalledOnce();
+    expect(timers).toEqual([]);
+  });
+
+  it('captures Permutive segments and owns its initial route/readiness mutations', () => {
+    localStorage.setItem(
+      'permutive-app',
+      JSON.stringify({ core: { cohorts: { all: ['one', 2, false, ...Array(110).fill('x')] } } })
+    );
+    const sdk = {
+      config: {
+        apiHost: 'api.permutive.com',
+        apiProtocol: 'https',
+        cdnBaseUrl: 'cdn.permutive.com',
+        cdnProtocol: 'https',
+        secureSignalsApiHost: 'signals.permutive.com',
+        segmentSyncApiHost: 'sync.permutive.com',
+      },
+    };
+    const previous = { ...sdk.config };
+    const disposers: Array<() => void> = [];
+    let route: FirstDisplayContextRouteRuleV1 | undefined;
+    const unregisterRoute = vi.fn();
+    const observations: Array<readonly [string, string | number]> = [];
+    const bindings = Object.freeze({
+      clearTimer: () => undefined,
+      getSdk: () => sdk,
+      host: 'publisher.example',
+      observe: (name: string, value: string | number) => observations.push([name, value]),
+      origin: 'https://publisher.example',
+      protocol: 'https:',
+      readStorage: (key: string) => localStorage.getItem(key),
+      registerRoute: (candidate: FirstDisplayContextRouteRuleV1) => {
+        route = candidate;
+        return unregisterRoute;
+      },
+      setTimer: (_callback: () => void, _delayMs: number) => 1,
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (release: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('permutive_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+
+    activateInitialSlice(
+      PERMUTIVE_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (release: () => void) => disposers.push(release),
+        afterActivate: () => undefined,
+      })
+    );
+
+    const segmentObservation = observations.find(([name]) => name === 'segments');
+    expect(segmentObservation).toBeDefined();
+    expect(JSON.parse(String(segmentObservation?.[1]))).toEqual(getPermutiveSegments());
+    expect(JSON.parse(String(segmentObservation?.[1]))).toHaveLength(100);
+    expect(route?.matches('script', 'https://cdn.permutive.com/example-web.js')).toBe(true);
+    expect(
+      route?.matches('script', 'https://cdn.permutive.com.attacker.example/example-web.js')
+    ).toBe(false);
+    expect(
+      route?.matches('script', 'https://cdn.permutive.com@attacker.example/example-web.js')
+    ).toBe(false);
+    expect(route?.matches('script', 'https://cdn.permutive.com/example.js')).toBe(false);
+    expect(route?.rewrite('https://cdn.permutive.com/example-web.js')).toBe(
+      'https://publisher.example/integrations/permutive/sdk'
+    );
+    expect(sdk.config).toEqual({
+      apiHost: 'publisher.example/integrations/permutive/api',
+      apiProtocol: 'https',
+      cdnBaseUrl: 'publisher.example/integrations/permutive/cdn',
+      cdnProtocol: 'https',
+      secureSignalsApiHost: 'publisher.example/integrations/permutive/secure-signal',
+      segmentSyncApiHost: 'publisher.example/integrations/permutive/sync',
+    });
+
+    disposers.reverse().forEach((release) => release());
+    expect(sdk.config).toEqual(previous);
+    expect(unregisterRoute).toHaveBeenCalledOnce();
+    localStorage.clear();
+  });
+
+  it('mirrors only the one-shot Sourcepoint consent snapshot and owns its SDK route', () => {
+    clearAllCookies();
+    localStorage.clear();
+    localStorage.setItem(
+      '_sp_user_consent_123',
+      JSON.stringify({
+        gppData: { gppString: 'DBABLA~BVQqAAAAAgA.QA', applicableSections: [7, 8] },
+      })
+    );
+    expect(mirrorSourcepointConsent()).toBe(true);
+    const persistentCookies = document.cookie;
+    clearAllCookies();
+
+    const disposers: Array<() => void> = [];
+    let route: FirstDisplayConsentRouteRuleV1 | undefined;
+    const unregisterRoute = vi.fn();
+    const bindings = Object.freeze({
+      config: Object.freeze({ rewriteSdk: true }),
+      document,
+      observe: () => undefined,
+      origin: 'https://publisher.example',
+      registerRoute: (candidate: FirstDisplayConsentRouteRuleV1) => {
+        route = candidate;
+        return unregisterRoute;
+      },
+      storage: localStorage,
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (release: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('sourcepoint_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+
+    activateInitialSlice(
+      SOURCEPOINT_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (release: () => void) => disposers.push(release),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(document.cookie).toBe(persistentCookies);
+    expect(
+      route?.matches('script', 'https://cdn.privacy-mgmt.com/wrapperMessagingWithoutDetection.js')
+    ).toBe(true);
+    expect(route?.matches('script', 'https://cdn.privacy-mgmt.com.evil.example/sdk.js')).toBe(
+      false
+    );
+    expect(route?.rewrite('https://cdn.privacy-mgmt.com/path/sdk.js?x=1')).toBe(
+      'https://publisher.example/integrations/sourcepoint/cdn/path/sdk.js?x=1'
+    );
+
+    disposers.reverse().forEach((release) => release());
+    expect(readCookie('__gpp')).toBeUndefined();
+    expect(readCookie('__gpp_sid')).toBeUndefined();
+    expect(readCookie('_ts_gpp_src')).toBeUndefined();
+    expect(unregisterRoute).toHaveBeenCalledOnce();
+    localStorage.clear();
+    clearAllCookies();
+  });
+
+  it('captures one Osano USP/GPP/TCF snapshot without installing maintenance listeners', () => {
+    clearAllCookies();
+    const disposers: Array<() => void> = [];
+    const timers = new Set<() => void>();
+    const target = {
+      addEventListener: vi.fn(),
+      __uspapi: (
+        _command: string,
+        _version: number,
+        callback: (data: unknown, success: boolean) => void
+      ) => callback({ uspString: '1YN-' }, true),
+      __gpp: (_command: string, callback: (data: unknown, success: boolean) => void) =>
+        callback(
+          { signalStatus: 'ready', gppString: 'DBABLA~BVQqAAAAAgA.QA', applicableSections: [7] },
+          true
+        ),
+      __tcfapi: (
+        _command: string,
+        _version: number,
+        callback: (data: unknown, success: boolean) => void
+      ) => callback({ eventStatus: 'tcloaded', tcString: 'consent-string' }, true),
+    };
+    const bindings = Object.freeze({
+      clearTimer: (handle: unknown) => timers.delete(handle as () => void),
+      document,
+      observe: () => undefined,
+      setTimer: (callback: () => void, _delayMs: number) => {
+        timers.add(callback);
+        return callback;
+      },
+      target,
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (release: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('osano_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+
+    activateInitialSlice(
+      OSANO_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (release: () => void) => disposers.push(release),
+        afterActivate: () => undefined,
+      })
+    );
+
+    expect(readCookie('us_privacy')).toBe('1YN-');
+    expect(readCookie('__gpp')).toBe('DBABLA~BVQqAAAAAgA.QA');
+    expect(readCookie('__gpp_sid')).toBe('7');
+    expect(readCookie('euconsent-v2')).toBe('consent-string');
+    expect(readCookie('_ts_consent_src')).toBe('osano');
+    expect(target.addEventListener).not.toHaveBeenCalled();
+    expect(timers.size).toBe(0);
+
+    disposers.reverse().forEach((release) => release());
+    expect(document.cookie).toBe('');
+  });
+
+  it('keeps Permutive fallback parsing bounded and releases a pending readiness check', () => {
+    const raw = JSON.stringify({
+      eventPublication: {
+        eventUpload: [
+          ['old', { event: { properties: { segments: ['old'] } } }],
+          ['new', { event: { properties: { segments: [9, 'new', false] } } }],
+        ],
+      },
+    });
+    expect(snapshotPermutiveInitialSegments(raw)).toEqual(['9', 'new']);
+    expect(snapshotPermutiveInitialSegments('{bad-json')).toEqual([]);
+
+    const timers: Array<() => void> = [];
+    const disposers: Array<() => void> = [];
+    const unregisterRoute = vi.fn();
+    installPermutiveInitial(
+      Object.freeze({
+        clearTimer: (handle: unknown) => {
+          const index = timers.indexOf(handle as () => void);
+          if (index >= 0) timers.splice(index, 1);
+        },
+        getSdk: () => undefined,
+        host: 'publisher.example',
+        observe: () => undefined,
+        origin: 'https://publisher.example',
+        protocol: 'https:',
+        readStorage: () => raw,
+        registerRoute: () => unregisterRoute,
+        setTimer: (callback: () => void) => {
+          timers.push(callback);
+          return callback;
+        },
+      }),
+      (release) => disposers.push(release)
+    );
+    expect(timers).toHaveLength(1);
+
+    disposers.reverse().forEach((release) => release());
+    expect(timers).toEqual([]);
+    expect(unregisterRoute).toHaveBeenCalledOnce();
+  });
+
+  it('preserves a foreign GPP owner and skips the disabled Sourcepoint SDK route', () => {
+    clearAllCookies();
+    localStorage.clear();
+    document.cookie = '__gpp=publisher-owned; path=/';
+    document.cookie = '__gpp_sid=2; path=/';
+    localStorage.setItem(
+      '_sp_user_consent_123',
+      JSON.stringify({ gppData: { gppString: 'sourcepoint', applicableSections: [7] } })
+    );
+    const registerRoute = vi.fn();
+    const disposers: Array<() => void> = [];
+    installSourcepointInitial(
+      Object.freeze({
+        config: Object.freeze({ rewriteSdk: false }),
+        document,
+        observe: () => undefined,
+        origin: 'https://publisher.example',
+        registerRoute,
+        storage: localStorage,
+      }),
+      (release) => disposers.push(release)
+    );
+
+    expect(readCookie('__gpp')).toBe('publisher-owned');
+    expect(readCookie('__gpp_sid')).toBe('2');
+    expect(readCookie('_ts_gpp_src')).toBeUndefined();
+    expect(registerRoute).not.toHaveBeenCalled();
+    disposers.reverse().forEach((release) => release());
+    expect(readCookie('__gpp')).toBe('publisher-owned');
+    clearAllCookies();
+    localStorage.clear();
+  });
+
+  it('cancels a pending Osano API snapshot without later work or cookie mutation', () => {
+    clearAllCookies();
+    const timers = new Set<() => void>();
+    const disposers: Array<() => void> = [];
+    const target = {
+      addEventListener: vi.fn(),
+      __uspapi: vi.fn(),
+    };
+    installOsanoInitial(
+      Object.freeze({
+        clearTimer: (handle: unknown) => timers.delete(handle as () => void),
+        document,
+        observe: () => undefined,
+        setTimer: (callback: () => void) => {
+          timers.add(callback);
+          return callback;
+        },
+        target,
+      }),
+      (release) => disposers.push(release)
+    );
+    expect(timers.size).toBe(1);
+    expect(target.addEventListener).not.toHaveBeenCalled();
+
+    disposers.reverse().forEach((release) => release());
+    expect(timers.size).toBe(0);
+    expect(document.cookie).toBe('');
+  });
+
+  it('installs the selected creative parser guards and owns their rollback', () => {
+    const observations: Array<readonly [string, number]> = [];
+    const disposers: Array<() => void> = [];
+    const clickHandle = Object.freeze({ dispose: vi.fn(), scan: vi.fn() });
+    const imageHandle = Object.freeze({ dispose: vi.fn(), scan: vi.fn() });
+    const iframeHandle = Object.freeze({ dispose: vi.fn(), scan: vi.fn() });
+    const installClickGuard = vi.fn(() => clickHandle);
+    const installDynamicImageProxy = vi.fn(() => imageHandle);
+    const installDynamicIframeProxy = vi.fn(() => iframeHandle);
+    const bindings = Object.freeze({
+      config: Object.freeze({
+        version: 1,
+        enabled: true,
+        clickGuard: true,
+        renderGuard: true,
+      }),
+      document,
+      installClickGuard,
+      installDynamicIframeProxy,
+      installDynamicImageProxy,
+      observe: (name: string, value: number) => observations.push([name, value]),
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('creative_initial');
+        install?.(bindings, own, bindings.config);
+      },
+    });
+
+    activateInitialSlice(
+      CREATIVE_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(installClickGuard).toHaveBeenCalledOnce();
+    expect(installDynamicImageProxy).toHaveBeenCalledOnce();
+    expect(installDynamicIframeProxy).toHaveBeenCalledOnce();
+    expect(clickHandle.scan).not.toHaveBeenCalled();
+    expect(imageHandle.scan).not.toHaveBeenCalled();
+    expect(iframeHandle.scan).not.toHaveBeenCalled();
+    expect(observations).toEqual([['guard_count', 3]]);
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(clickHandle.dispose).toHaveBeenCalledOnce();
+    expect(imageHandle.dispose).toHaveBeenCalledOnce();
+    expect(iframeHandle.dispose).toHaveBeenCalledOnce();
+  });
+
+  it('rejects malformed creative config before installing any initial guard', () => {
+    for (const config of [
+      { version: 1, enabled: true, clickGuard: true, renderGuard: false },
+      Object.freeze({ version: 1, enabled: false, clickGuard: true, renderGuard: false }),
+      Object.freeze({
+        version: 1,
+        enabled: true,
+        clickGuard: true,
+        renderGuard: false,
+        extra: true,
+      }),
+    ]) {
+      const installClickGuard = vi.fn();
+      const host = Object.freeze({
+        activate: (
+          _id: string,
+          own: (dispose: () => void) => void,
+          install?: InitialSliceInstaller
+        ) =>
+          install?.(
+            Object.freeze({
+              config,
+              document,
+              installClickGuard,
+              installDynamicIframeProxy: vi.fn(),
+              installDynamicImageProxy: vi.fn(),
+              observe: () => undefined,
+            }),
+            own,
+            config
+          ),
+      });
+      expect(() =>
+        activateInitialSlice(
+          CREATIVE_INITIAL_SLICE,
+          host,
+          Object.freeze({ own: () => undefined, afterActivate: () => undefined })
+        )
+      ).toThrow();
+      expect(installClickGuard).not.toHaveBeenCalled();
+    }
+  });
+
+  it('registers the closed APS nonce, policy, and document-channel protocol', () => {
+    const release = vi.fn();
+    const disposers: Array<() => void> = [];
+    let protocol: FirstDisplayApsProtocolV1 | undefined;
+    const bindings = Object.freeze({
+      observe: vi.fn(),
+      publisherOrigin: 'https://publisher.example',
+      register: (candidate: FirstDisplayApsProtocolV1) => {
+        protocol = candidate;
+        return release;
+      },
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('aps_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+
+    activateInitialSlice(
+      APS_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    const policy = protocol?.[2];
+    expect(policy?.rendererUrl).toBe('https://publisher.example/integrations/aps/renderer/v2');
+    expect(policy?.publisherOrigin).toBe('https://publisher.example');
+    expect(policy?.sandbox).toBe(
+      'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation'
+    );
+    expect(policy?.permanentSandbox).toBe(
+      'allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation'
+    );
+    expect(policy?.deadlines).toEqual({
+      documentAcceptanceMs: 3_000,
+      completionMs: 10_000,
+    });
+    expect(policy?.isBootstrapNonce(`b1_${'a'.repeat(22)}`)).toBe(true);
+    expect(policy?.isRendererNonce(`n1_${'a'.repeat(22)}`)).toBe(true);
+    expect(policy?.isBootstrapNonce(`n1_${'a'.repeat(22)}`)).toBe(false);
+    const nonce = `n1_${'b'.repeat(22)}`;
+    expect(
+      policy?.parseDocumentMessage(
+        Object.freeze({ message: 'TS APS Document Accepted', version: 1, nonce }),
+        nonce
+      )
+    ).toEqual({ kind: 'document_accepted' });
+    expect(
+      policy?.parseDocumentMessage(
+        Object.freeze({ message: 'TS APS Runner Loaded', version: 1, nonce }),
+        nonce
+      )
+    ).toEqual({ kind: 'runner_loaded' });
+    expect(
+      policy?.parseDocumentMessage(
+        Object.freeze({ message: 'TS APS Render Completed', version: 1, nonce }),
+        nonce
+      )
+    ).toEqual({ kind: 'render_completed' });
+    expect(
+      policy?.parseDocumentMessage(
+        Object.freeze({
+          message: 'TS APS Render Failed',
+          version: 1,
+          nonce,
+          reason: 'runner_failed',
+        }),
+        nonce
+      )
+    ).toEqual({ kind: 'render_failed', reason: 'runner_failed' });
+    for (const message of [
+      { message: 'TS APS Render Completed', version: 1, nonce: `n1_${'c'.repeat(22)}` },
+      { message: 'TS APS Render Completed', version: 1, nonce, extra: true },
+      { message: 'TS APS Render Failed', version: 1, nonce, reason: 'unknown' },
+      Object.create({ message: 'TS APS Render Completed', version: 1, nonce }),
+    ]) {
+      expect(policy?.parseDocumentMessage(Object.freeze(message), nonce)).toBeUndefined();
+    }
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it('registers only the attenuated GPT batch factory before any initial action', () => {
+    const release = vi.fn();
+    const disposers: Array<() => void> = [];
+    let protocol: FirstDisplayGptProtocolV1 | undefined;
+    const bindings = Object.freeze({
+      browser: {} as Window,
+      observe: vi.fn(),
+      register: (candidate: FirstDisplayGptProtocolV1) => {
+        protocol = candidate;
+        return release;
+      },
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('gpt_initial');
+        install?.(
+          bindings,
+          own,
+          Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled: true })
+        );
+      },
+    });
+
+    activateInitialSlice(
+      GPT_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    expect(protocol).toEqual([1, 'gpt', expect.any(Function)]);
+    expect(Object.isFrozen(protocol)).toBe(true);
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it('registers the Prebid admission policy for the protected batch only', () => {
+    const release = vi.fn();
+    const disposers: Array<() => void> = [];
+    let protocol: FirstDisplayPrebidProtocolV1 | undefined;
+    const bindings = Object.freeze({
+      observe: vi.fn(),
+      register: (candidate: FirstDisplayPrebidProtocolV1) => {
+        protocol = candidate;
+        return release;
+      },
+    });
+    const host = Object.freeze({
+      activate: (
+        id: string,
+        own: (dispose: () => void) => void,
+        install?: InitialSliceInstaller
+      ) => {
+        expect(id).toBe('prebid_initial');
+        install?.(bindings, own, undefined);
+      },
+    });
+
+    activateInitialSlice(
+      PREBID_INITIAL_SLICE,
+      host,
+      Object.freeze({
+        own: (dispose: () => void) => disposers.push(dispose),
+        afterActivate: () => undefined,
+      })
+    );
+    const policy = protocol?.[2];
+    expect(policy).toMatchObject({
+      bidderCode: 'trustedServer',
+      maxPendingOperations: 64,
+      externalReadyMs: 10_000,
+      admissionLeaseMs: 10_000,
+      renderReservationMs: 15 * 60 * 1_000,
+    });
+    expect(policy?.normalizeEidSource('  ID5-SYNC.COM ')).toBe('id5-sync.com');
+    expect(policy?.normalizeEidSource('   ')).toBeUndefined();
+    const prepared = policy?.snapshotTrustedBid(
+      Object.freeze({
+        auctionId: 'auction-1',
+        adUnitCode: 'slot-1',
+        bid: Object.freeze({
+          requestId: 'request-1',
+          adId: `r1_${'a'.repeat(22)}`,
+          cpm: 1.25,
+          width: 300,
+          height: 250,
+          ad: '',
+          ttl: 300,
+          creativeId: 'creative-1',
+          netRevenue: true,
+          currency: 'USD',
+          bidderCode: 'trustedServer',
+          meta: Object.freeze({
+            advertiserDomains: Object.freeze(['advertiser.example']),
+            tsAuctionId: 'auction-1',
+            tsBidId: 'bid-1',
+          }),
+        }),
+      })
+    );
+    expect(prepared).toBeDefined();
+    expect(Object.isFrozen(prepared)).toBe(true);
+    expect(prepared?.bid.adId).toBe(`r1_${'a'.repeat(22)}`);
+    expect(
+      policy?.snapshotTrustedBid(
+        Object.freeze({
+          ...prepared,
+          bid: Object.freeze({ ...prepared?.bid, bidderCode: 'publisherBidder' }),
+        })
+      )
+    ).toBeUndefined();
+
+    disposers.reverse().forEach((dispose) => dispose());
+    expect(release).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/takeover.test.ts b/crates/trusted-server-js/lib/test/first_display/takeover.test.ts
new file mode 100644
index 000000000..9db761fb3
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/takeover.test.ts
@@ -0,0 +1,442 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  coordinatePreparedFirstDisplayTakeoverV1,
+  createFirstDisplayHandoffOwner,
+  performFirstDisplayTakeoverV1,
+  type FinalizedFirstDisplayHandoffV1,
+} from '../../src/shared/first_display_handoff';
+import { snapshotOutlinedFirstDisplayHandoffV1 } from '../../src/shared/first_display_contracts';
+import {
+  consumeFirstDisplayTakeoverTransport,
+  installFirstDisplayTakeoverTransport,
+} from '../../src/shared/takeover';
+
+const RELEASE_ID = 'a'.repeat(64);
+const DIGEST = 'b'.repeat(64);
+const CONFIG_DIGEST = 'c'.repeat(64);
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+
+function handoff(revision = 0): Record<string, unknown> {
+  return {
+    captureVersion: 1,
+    identityCount: 2,
+    version: 1,
+    releaseId: RELEASE_ID,
+    generation: 1,
+    projectionDigest: DIGEST,
+    integrationConfigDigest: CONFIG_DIGEST,
+    slices: ['first_display', 'gpt_initial'],
+    slots: [
+      {
+        id: 'slot-1',
+        aliases: [],
+        domId: 'div-1',
+        gamPath: '/123/slot-1',
+        formats: [[300, 250]],
+        owner: 'trusted_server',
+        outcome: 'accepted',
+        targeting: [['hb_adid', RESERVATION_ID]],
+        targetingOwnership: [],
+        committedArtifact: 'gpt_adm',
+        gptToken: 'gt1_1',
+      },
+    ],
+    attempts: [
+      {
+        id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+        slotId: 'slot-1',
+        ordinal: 1,
+        state: 'accepted',
+        reason: null,
+      },
+    ],
+    tombstones: [],
+    artifacts: [
+      {
+        hostPosition: null,
+        hostPositionPriority: null,
+        slotId: 'slot-1',
+        kind: 'gpt_adm',
+        owner: 'trusted_server',
+        token: RESERVATION_ID,
+      },
+    ],
+    parserState: [
+      {
+        sliceId: 'gpt_initial',
+        observations: ['gam', 'v'],
+        values: [
+          ['gam', false],
+          ['v', 1],
+        ],
+      },
+    ],
+    gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+    timing: { bidsScriptMs: 1, firstDisplayMs: 2, terminalMs: 3, paintMs: 4 },
+    highWater: {
+      navigationAttemptPrefix: 'AAECAwQFBgc',
+      nextNavigationAttemptOrdinal: 2,
+      nextAttemptOrdinal: 2,
+      nextSlotRegistrationOrdinal: 2,
+      reservationClockEpochMs: 0,
+      nextReservationOrdinal: 2,
+      nextTicketOrdinal: 1,
+    },
+    cycles: [
+      {
+        slotId: 'slot-1',
+        token: 'gt1_1',
+        nextCycleOrdinal: 2,
+        unknownPriorCycle: false,
+        records: [
+          {
+            ordinal: 1,
+            responseIdentifier: 'response-one',
+            seen: ['slotRequested', 'slotRenderEnded'],
+            state: 'completed',
+          },
+        ],
+        quarantines: [],
+      },
+    ],
+    trace: {
+      nextSequence: 2,
+      nextGlobalSlotOrdinal: 2,
+      slots: [
+        {
+          slotId: 'slot-1',
+          impressions: 1,
+          bindings: [
+            {
+              atMs: 3,
+              cycleOrdinal: 1,
+              historySequence: 1,
+              state: 'completed',
+              token: 'gt1_1',
+            },
+          ],
+        },
+      ],
+    },
+    mutationRevision: revision,
+  };
+}
+
+function validateCapturedHandoff(candidate: unknown, outlineValue: unknown) {
+  if (typeof candidate !== 'object' || candidate === null) return undefined;
+  const {
+    captureVersion: _captureVersion,
+    identityCount: _identityCount,
+    ...full
+  } = candidate as Record<string, unknown>;
+  return snapshotOutlinedFirstDisplayHandoffV1(full, outlineValue);
+}
+
+function outline(): Record<string, unknown> {
+  return {
+    version: 1,
+    releaseId: RELEASE_ID,
+    generation: 1,
+    projectionDigest: DIGEST,
+    integrationConfigDigest: CONFIG_DIGEST,
+    slices: ['first_display', 'gpt_initial'],
+    slotCount: 1,
+    outcomeCount: 1,
+    capabilities: [],
+    objectKinds: ['gpt_slot', 'dom_artifact'],
+  };
+}
+
+function finalized(
+  physicalSlot: object = {},
+  artifact: object = {}
+): FinalizedFirstDisplayHandoffV1 {
+  const owner = createFirstDisplayHandoffOwner({
+    releaseId: RELEASE_ID,
+    generation: 1,
+    isCurrentGeneration: () => true,
+    isTerminal: () => true,
+    isPainted: () => true,
+    closeIngress: () => undefined,
+    onFailure: () => undefined,
+  });
+  const value = owner.finalize(() => ({
+    candidate: handoff(),
+    identities: [physicalSlot, artifact],
+  }));
+  if (!value) throw new Error('should finalize test handoff');
+  return value;
+}
+
+describe('atomic first-display takeover', () => {
+  it('uses a non-replaceable one-shot rendezvous on the runtime script', () => {
+    const runtimeScript = {};
+    const lease = Object.freeze([]);
+    const claim = vi.fn(() => lease);
+    const release = installFirstDisplayTakeoverTransport(runtimeScript, claim as never);
+
+    expect(release).toBeTypeOf('function');
+    expect(Object.getOwnPropertyDescriptor(runtimeScript, '_firstDisplayTakeover')).toMatchObject({
+      configurable: false,
+      enumerable: false,
+      writable: false,
+    });
+    expect(() =>
+      Object.defineProperty(runtimeScript, '_firstDisplayTakeover', {
+        configurable: true,
+        value: () => undefined,
+      })
+    ).toThrow();
+
+    const transport = consumeFirstDisplayTakeoverTransport(runtimeScript);
+    expect(transport.status).toBe('accepted');
+    if (transport.status !== 'accepted') throw new Error('should accept transport');
+    expect(transport.claim({}, (() => undefined) as never)).toBe(lease);
+    expect(transport.claim({}, (() => undefined) as never)).toBeUndefined();
+    expect(claim).toHaveBeenCalledOnce();
+  });
+
+  it('binds the exact handoff and one-use identities to the prepared persistent barrier', () => {
+    const physicalSlot = {};
+    const artifact = {};
+    const events: string[] = [];
+    let adoption: unknown;
+    const prepared = Object.freeze({
+      validateHandoff: validateCapturedHandoff,
+      activate: (candidate?: unknown) => {
+        adoption = candidate;
+        events.push('activate');
+      },
+      commit: () => events.push('commit'),
+      rollback: () => events.push('rollback'),
+    });
+
+    expect(
+      coordinatePreparedFirstDisplayTakeoverV1({
+        prepared,
+        finalized: finalized(physicalSlot, artifact),
+        outline: outline(),
+        isCurrentGeneration: () => true,
+        authenticateRuntimeScript: () => true,
+        currentMutationRevision: () => 0,
+        quiesceAgent: () => events.push('quiesce'),
+        detachCommittedArtifacts: () => events.push('detach'),
+        disposeAgent: () => events.push('dispose'),
+        onFailure: () => events.push('fallback'),
+      })
+    ).toBe(true);
+    expect(adoption).toMatchObject({
+      version: 1,
+      adoptInitialDisplay: true,
+      identities: [physicalSlot, artifact],
+      handoff: { releaseId: RELEASE_ID, generation: 1 },
+    });
+    expect(Object.isFrozen(adoption)).toBe(true);
+    expect(events).toEqual(['quiesce', 'detach', 'dispose', 'activate', 'commit']);
+  });
+
+  it('transfers one-use identities and commits in the exact non-yielding order', () => {
+    const events: string[] = [];
+    const physicalSlot = {};
+    const artifact = {};
+    const result = performFirstDisplayTakeoverV1({
+      validateHandoff: validateCapturedHandoff,
+      finalized: finalized(physicalSlot, artifact),
+      outline: outline(),
+      isCurrentGeneration: () => true,
+      authenticateRuntimeScript: () => true,
+      currentMutationRevision: () => 0,
+      quiesceAgent: () => events.push('quiesce-agent'),
+      detachCommittedArtifacts: () => events.push('detach-artifacts'),
+      disposeAgent: () => events.push('dispose-agent'),
+      activatePersistent: (_snapshot, identities, own) => {
+        expect(identities).toEqual([physicalSlot, artifact]);
+        own(() => events.push('rollback-persistent'));
+        events.push('activate-persistent');
+      },
+      commitPersistent: () => events.push('commit-persistent'),
+      onFailure: () => events.push('fallback'),
+    });
+
+    expect(result).toBe(true);
+    expect(events).toEqual([
+      'quiesce-agent',
+      'detach-artifacts',
+      'dispose-agent',
+      'activate-persistent',
+      'commit-persistent',
+    ]);
+  });
+
+  it('rolls back partial persistent effects without resurrecting the agent', () => {
+    const events: string[] = [];
+    const result = performFirstDisplayTakeoverV1({
+      validateHandoff: validateCapturedHandoff,
+      finalized: finalized(),
+      outline: outline(),
+      isCurrentGeneration: () => true,
+      authenticateRuntimeScript: () => true,
+      currentMutationRevision: () => 0,
+      quiesceAgent: () => events.push('quiesce-agent'),
+      detachCommittedArtifacts: () => events.push('detach-artifacts'),
+      disposeAgent: () => events.push('dispose-agent'),
+      activatePersistent: (_snapshot, _identities, own) => {
+        own(() => events.push('rollback-a'));
+        own(() => events.push('rollback-b'));
+        throw new Error('activation failed');
+      },
+      commitPersistent: () => events.push('commit-persistent'),
+      onFailure: () => events.push('fallback'),
+    });
+
+    expect(result).toBe(false);
+    expect(events).toEqual([
+      'quiesce-agent',
+      'detach-artifacts',
+      'dispose-agent',
+      'rollback-b',
+      'rollback-a',
+      'fallback',
+    ]);
+  });
+
+  it('rejects a mutation during quiesce or persistent activation', () => {
+    for (const phase of ['quiesce', 'activate'] as const) {
+      let revision = 0;
+      const events: string[] = [];
+      const result = performFirstDisplayTakeoverV1({
+        validateHandoff: validateCapturedHandoff,
+        finalized: finalized(),
+        outline: outline(),
+        isCurrentGeneration: () => true,
+        authenticateRuntimeScript: () => true,
+        currentMutationRevision: () => revision,
+        quiesceAgent: () => {
+          events.push('quiesce');
+          if (phase === 'quiesce') revision += 1;
+        },
+        detachCommittedArtifacts: () => events.push('detach'),
+        disposeAgent: () => events.push('dispose'),
+        activatePersistent: (_snapshot, _identities, own) => {
+          own(() => events.push('rollback'));
+          if (phase === 'activate') revision += 1;
+        },
+        commitPersistent: () => events.push('commit'),
+        onFailure: () => events.push('fallback'),
+      });
+      expect(result).toBe(false);
+      expect(events).not.toContain('commit');
+      expect(events[events.length - 1]).toBe('fallback');
+    }
+  });
+
+  it('revalidates runtime authentication immediately before persistent commit', () => {
+    let authenticated = true;
+    const events: string[] = [];
+    expect(
+      performFirstDisplayTakeoverV1({
+        validateHandoff: validateCapturedHandoff,
+        finalized: finalized(),
+        outline: outline(),
+        isCurrentGeneration: () => true,
+        authenticateRuntimeScript: () => authenticated,
+        currentMutationRevision: () => 0,
+        quiesceAgent: () => events.push('quiesce'),
+        detachCommittedArtifacts: () => events.push('detach'),
+        disposeAgent: () => events.push('dispose'),
+        activatePersistent: (_snapshot, _identities, own) => {
+          own(() => events.push('rollback'));
+          events.push('activate');
+          authenticated = false;
+        },
+        commitPersistent: () => events.push('commit'),
+        onFailure: () => events.push('fallback'),
+      })
+    ).toBe(false);
+    expect(events).toEqual(['quiesce', 'detach', 'dispose', 'activate', 'rollback', 'fallback']);
+  });
+
+  it('fails before quiesce for a stale outline, generation, or runtime script', () => {
+    for (const failure of ['outline', 'generation', 'script'] as const) {
+      const events: string[] = [];
+      const candidate = outline();
+      if (failure === 'outline') candidate.projectionDigest = 'c'.repeat(64);
+      expect(
+        performFirstDisplayTakeoverV1({
+          validateHandoff: validateCapturedHandoff,
+          finalized: finalized(),
+          outline: candidate,
+          isCurrentGeneration: () => failure !== 'generation',
+          authenticateRuntimeScript: () => failure !== 'script',
+          currentMutationRevision: () => 0,
+          quiesceAgent: () => events.push('quiesce'),
+          detachCommittedArtifacts: () => events.push('detach'),
+          disposeAgent: () => events.push('dispose'),
+          activatePersistent: () => events.push('activate'),
+          commitPersistent: () => events.push('commit'),
+          onFailure: () => events.push('fallback'),
+        })
+      ).toBe(false);
+      expect(events).toEqual(['fallback']);
+    }
+  });
+
+  it('performs full semantic handoff validation at takeover before any owner effect', () => {
+    const owner = createFirstDisplayHandoffOwner({
+      releaseId: RELEASE_ID,
+      generation: 1,
+      isCurrentGeneration: () => true,
+      isTerminal: () => true,
+      isPainted: () => true,
+      closeIngress: () => undefined,
+      onFailure: () => undefined,
+    });
+    const candidate = handoff();
+    candidate.trace = { ...(candidate.trace as object), nextSequence: 1 };
+    const sealed = owner.finalize(() => ({ candidate, identities: [{}, {}] }));
+    expect(sealed).toBeDefined();
+
+    const events: string[] = [];
+    expect(
+      performFirstDisplayTakeoverV1({
+        validateHandoff: validateCapturedHandoff,
+        finalized: sealed!,
+        outline: outline(),
+        isCurrentGeneration: () => true,
+        authenticateRuntimeScript: () => true,
+        currentMutationRevision: () => 0,
+        quiesceAgent: () => events.push('quiesce'),
+        detachCommittedArtifacts: () => events.push('detach'),
+        disposeAgent: () => events.push('dispose'),
+        activatePersistent: () => events.push('activate'),
+        commitPersistent: () => events.push('commit'),
+        onFailure: () => events.push('fallback'),
+      })
+    ).toBe(false);
+    expect(events).toEqual(['fallback']);
+  });
+
+  it('rejects an outline that did not prepare every transferred object kind', () => {
+    for (const objectKinds of [[], ['gpt_slot'], ['dom_artifact']] as const) {
+      const events: string[] = [];
+      expect(
+        performFirstDisplayTakeoverV1({
+          validateHandoff: validateCapturedHandoff,
+          finalized: finalized(),
+          outline: { ...outline(), objectKinds },
+          isCurrentGeneration: () => true,
+          authenticateRuntimeScript: () => true,
+          currentMutationRevision: () => 0,
+          quiesceAgent: () => events.push('quiesce'),
+          detachCommittedArtifacts: () => events.push('detach'),
+          disposeAgent: () => events.push('dispose'),
+          activatePersistent: () => events.push('activate'),
+          commitPersistent: () => events.push('commit'),
+          onFailure: () => events.push('fallback'),
+        })
+      ).toBe(false);
+      expect(events).toEqual(['fallback']);
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/first_display/transaction.test.ts b/crates/trusted-server-js/lib/test/first_display/transaction.test.ts
new file mode 100644
index 000000000..f9b2cb62b
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/first_display/transaction.test.ts
@@ -0,0 +1,250 @@
+import { JSDOM } from 'jsdom';
+import { describe, expect, it, vi } from 'vitest';
+
+import { createFirstDisplayTransaction } from '../../src/shared/first_display_transaction';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+function documentWithScript(): { document: Document; script: HTMLScriptElement } {
+  const dom = new JSDOM(
+    '<!doctype html><script id="trustedserver-js" src="https://publisher.example/static/tsjs=tsjs-first-display.min.js?m=0041&v=' +
+      'b'.repeat(64) +
+      '"></script>',
+    { url: 'https://publisher.example/' }
+  );
+  const document = dom.window.document;
+  const script = document.querySelector('script') as HTMLScriptElement;
+  Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+  return { document, script };
+}
+
+function registration(
+  id: string,
+  order: number,
+  activate: (own: (dispose: () => void) => void) => void = () => undefined
+): Record<string, unknown> {
+  return {
+    abi: 1,
+    id,
+    releaseId: RELEASE_ID,
+    generation: 7,
+    order,
+    prepare: () => ({
+      activate: ({ own }: { own: (dispose: () => void) => void }) => activate(own),
+    }),
+  };
+}
+
+describe('release-private first-display transaction', () => {
+  it('accepts exact ordered registrations and activates in one synchronous transaction', () => {
+    const { document, script } = documentWithScript();
+    const events: string[] = [];
+    const transaction = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display', 'gpt_initial'],
+      isCurrentGeneration: () => true,
+    });
+
+    expect(
+      transaction.register(
+        registration('first_display', 1, (own) => {
+          own(() => events.push('dispose-base'));
+          events.push('activate-base');
+        })
+      )
+    ).toBe(true);
+    expect(
+      transaction.register(
+        registration('gpt_initial', 8, (own) => {
+          own(() => events.push('dispose-gpt'));
+          events.push('activate-gpt');
+        })
+      )
+    ).toBe(true);
+    expect(transaction.activate()).toBe(true);
+    expect(events).toEqual(['activate-base', 'activate-gpt']);
+    transaction.dispose();
+    expect(events).toEqual(['activate-base', 'activate-gpt', 'dispose-gpt', 'dispose-base']);
+  });
+
+  it('starts the responsible action only after every selected slice has activated', () => {
+    const { document, script } = documentWithScript();
+    const events: string[] = [];
+    const transaction = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display', 'gpt_initial'],
+      isCurrentGeneration: () => true,
+    });
+    transaction.register({
+      ...registration('first_display', 1),
+      prepare: () => ({
+        activate: ({ afterActivate }: { afterActivate: (callback: () => void) => void }) => {
+          events.push('activate-base');
+          afterActivate(() => events.push('start-action'));
+        },
+      }),
+    });
+    transaction.register(
+      registration('gpt_initial', 8, () => {
+        events.push('activate-gpt');
+      })
+    );
+
+    expect(transaction.activate()).toBe(true);
+    expect(events).toEqual(['activate-base', 'activate-gpt', 'start-action']);
+  });
+
+  it('rejects unknown, duplicate, omitted, misordered, late, wrong-release, and accessor registrations', () => {
+    const make = () => {
+      const { document, script } = documentWithScript();
+      return createFirstDisplayTransaction({
+        document,
+        script,
+        releaseId: RELEASE_ID,
+        generation: 7,
+        expectedSliceIds: ['first_display', 'gpt_initial'],
+        isCurrentGeneration: () => true,
+      });
+    };
+
+    expect(make().register(registration('unknown_initial', 1))).toBe(false);
+    const duplicate = make();
+    expect(duplicate.register(registration('first_display', 1))).toBe(true);
+    expect(duplicate.register(registration('first_display', 1))).toBe(false);
+    const omitted = make();
+    expect(omitted.register(registration('first_display', 1))).toBe(true);
+    expect(omitted.activate()).toBe(false);
+    expect(make().register(registration('gpt_initial', 8))).toBe(false);
+    expect(
+      make().register({ ...registration('first_display', 1), releaseId: 'b'.repeat(64) })
+    ).toBe(false);
+    const accessor = registration('first_display', 1);
+    Object.defineProperty(accessor, 'prepare', { enumerable: true, get: vi.fn() });
+    expect(make().register(accessor)).toBe(false);
+    const late = make();
+    expect(late.register(registration('first_display', 1))).toBe(true);
+    expect(late.register(registration('gpt_initial', 8))).toBe(true);
+    expect(late.activate()).toBe(true);
+    expect(late.register(registration('gpt_initial', 8))).toBe(false);
+  });
+
+  it('authenticates the exact parser-inserted current script and current generation', () => {
+    const { document, script } = documentWithScript();
+    const replaced = document.createElement('script');
+    document.head.append(replaced);
+    const wrongScript = createFirstDisplayTransaction({
+      document,
+      script: replaced,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display'],
+      isCurrentGeneration: () => true,
+    });
+    expect(wrongScript.register(registration('first_display', 1))).toBe(false);
+
+    const stale = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display'],
+      isCurrentGeneration: () => false,
+    });
+    expect(stale.register(registration('first_display', 1))).toBe(false);
+  });
+
+  it('rolls back every owned effect in reverse order after an activation failure', () => {
+    const { document, script } = documentWithScript();
+    const events: string[] = [];
+    const transaction = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display', 'gpt_initial'],
+      isCurrentGeneration: () => true,
+    });
+    transaction.register(
+      registration('first_display', 1, (own) => {
+        own(() => events.push('dispose-a'));
+        own(() => events.push('dispose-b'));
+      })
+    );
+    transaction.register(
+      registration('gpt_initial', 8, (own) => {
+        own(() => events.push('dispose-c'));
+        throw new Error('boom');
+      })
+    );
+
+    expect(transaction.activate()).toBe(false);
+    expect(events).toEqual(['dispose-c', 'dispose-b', 'dispose-a']);
+    expect(transaction.state).toBe('failed');
+  });
+
+  it('cannot continue activation or resurrect after a slice disposes reentrantly', () => {
+    const { document, script } = documentWithScript();
+    const events: string[] = [];
+    const transaction = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display', 'gpt_initial'],
+      isCurrentGeneration: () => true,
+    });
+    transaction.register(
+      registration('first_display', 1, (own) => {
+        own(() => events.push('dispose-base'));
+        events.push('activate-base');
+        transaction.dispose();
+      })
+    );
+    transaction.register(
+      registration('gpt_initial', 8, () => {
+        events.push('activate-gpt');
+      })
+    );
+
+    expect(transaction.activate()).toBe(false);
+    expect(transaction.state).toBe('disposed');
+    expect(events).toEqual(['activate-base', 'dispose-base']);
+  });
+
+  it('removes each disposer before invoking it during recursive rollback', () => {
+    const { document, script } = documentWithScript();
+    const events: string[] = [];
+    const transaction = createFirstDisplayTransaction({
+      document,
+      script,
+      releaseId: RELEASE_ID,
+      generation: 7,
+      expectedSliceIds: ['first_display', 'gpt_initial'],
+      isCurrentGeneration: () => true,
+    });
+    transaction.register(
+      registration('first_display', 1, (own) => {
+        own(() => events.push('dispose-a'));
+        own(() => {
+          events.push('dispose-b');
+          transaction.dispose();
+        });
+      })
+    );
+    transaction.register(
+      registration('gpt_initial', 8, () => {
+        throw new Error('boom');
+      })
+    );
+
+    expect(transaction.activate()).toBe(false);
+    expect(transaction.state).toBe('disposed');
+    expect(events).toEqual(['dispose-b', 'dispose-a']);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json b/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json
new file mode 100644
index 000000000..b782f99f4
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json
@@ -0,0 +1,511 @@
+{
+  "schemaVersion": 1,
+  "publisherOrigin": "https://publisher.example",
+  "baseDescriptor": {
+    "type": "aps",
+    "version": 1,
+    "accountId": "example-account-id",
+    "bidId": "fictional-selected-bid-id",
+    "creativeId": "fictional-creative-id",
+    "tagType": "iframe",
+    "creativeUrl": "https://creative.example/render",
+    "width": 300,
+    "height": 250
+  },
+  "vectors": [
+    {
+      "id": "valid-complete",
+      "expected": "accepted",
+      "operation": {
+        "kind": "none"
+      }
+    },
+    {
+      "id": "valid-without-optional-creative-id",
+      "expected": "accepted",
+      "operation": {
+        "kind": "descriptor-delete",
+        "field": "creativeId"
+      }
+    },
+    {
+      "id": "missing-required-account-id",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-delete",
+        "field": "accountId"
+      }
+    },
+    {
+      "id": "unknown-descriptor-key",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "adm",
+        "value": "<div>forbidden</div>"
+      }
+    },
+    {
+      "id": "account-id-utf8-byte-limit",
+      "expected": "accepted",
+      "operation": {
+        "kind": "descriptor-repeat",
+        "field": "accountId",
+        "unit": "é",
+        "count": 512
+      }
+    },
+    {
+      "id": "account-id-utf8-byte-over-limit",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-repeat",
+        "field": "accountId",
+        "unit": "é",
+        "count": 512,
+        "suffix": "x"
+      }
+    },
+    {
+      "id": "creative-id-utf8-byte-limit",
+      "expected": "accepted",
+      "operation": {
+        "kind": "descriptor-repeat",
+        "field": "creativeId",
+        "unit": "é",
+        "count": 512
+      }
+    },
+    {
+      "id": "creative-id-utf8-byte-over-limit",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-repeat",
+        "field": "creativeId",
+        "unit": "é",
+        "count": 512,
+        "suffix": "x"
+      }
+    },
+    {
+      "id": "bid-id-utf8-byte-limit",
+      "expected": "accepted",
+      "operation": {
+        "kind": "bid-id-repeat",
+        "unit": "é",
+        "count": 32
+      }
+    },
+    {
+      "id": "bid-id-utf8-byte-over-limit",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "bid-id-repeat",
+        "unit": "é",
+        "count": 32,
+        "suffix": "x"
+      }
+    },
+    {
+      "id": "bid-id-nul",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "bid-id-repeat",
+        "unit": "bid\u0000id",
+        "count": 1
+      }
+    },
+    {
+      "id": "bid-id-ascii-control",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "bid-id-repeat",
+        "unit": "bid\n-id",
+        "count": 1
+      }
+    },
+    {
+      "id": "width-zero",
+      "expected": "invalid_dimensions",
+      "operation": {
+        "kind": "dimension",
+        "field": "width",
+        "value": 0
+      }
+    },
+    {
+      "id": "height-negative",
+      "expected": "invalid_dimensions",
+      "operation": {
+        "kind": "dimension",
+        "field": "height",
+        "value": -1
+      }
+    },
+    {
+      "id": "width-fractional",
+      "expected": "invalid_dimensions",
+      "operation": {
+        "kind": "dimension",
+        "field": "width",
+        "value": 1.5
+      }
+    },
+    {
+      "id": "height-wrong-type",
+      "expected": "invalid_dimensions",
+      "operation": {
+        "kind": "dimension",
+        "field": "height",
+        "value": "250"
+      }
+    },
+    {
+      "id": "dimensions-minimum",
+      "expected": "accepted",
+      "operation": {
+        "kind": "dimensions",
+        "width": 1,
+        "height": 1
+      }
+    },
+    {
+      "id": "dimensions-maximum",
+      "expected": "accepted",
+      "operation": {
+        "kind": "dimensions",
+        "width": 4096,
+        "height": 4096
+      }
+    },
+    {
+      "id": "width-over-maximum",
+      "expected": "dimensions_out_of_range",
+      "operation": {
+        "kind": "dimension",
+        "field": "width",
+        "value": 4097
+      }
+    },
+    {
+      "id": "height-over-maximum",
+      "expected": "dimensions_out_of_range",
+      "operation": {
+        "kind": "dimension",
+        "field": "height",
+        "value": 4097
+      }
+    },
+    {
+      "id": "creative-url-http",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "creative-url",
+        "value": "http://creative.example/render"
+      }
+    },
+    {
+      "id": "creative-url-credentials",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "creative-url",
+        "value": "https://user:password@creative.example/render"
+      }
+    },
+    {
+      "id": "creative-url-publisher-origin",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "creative-url",
+        "value": "https://publisher.example/render"
+      }
+    },
+    {
+      "id": "creative-url-byte-limit",
+      "expected": "accepted",
+      "operation": {
+        "kind": "creative-url-bytes",
+        "bytes": 4096
+      }
+    },
+    {
+      "id": "creative-url-byte-over-limit",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "creative-url-bytes",
+        "bytes": 4097
+      }
+    },
+    {
+      "id": "aax-empty",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-literal",
+        "value": ""
+      }
+    },
+    {
+      "id": "aax-invalid-alphabet",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-literal",
+        "value": "not-base64"
+      }
+    },
+    {
+      "id": "aax-missing-padding",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-literal",
+        "value": "e30"
+      }
+    },
+    {
+      "id": "aax-noncanonical-trailing-bits",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-literal",
+        "value": "Zh=="
+      }
+    },
+    {
+      "id": "aax-invalid-utf8",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-bytes",
+        "values": [195, 40]
+      }
+    },
+    {
+      "id": "aax-malformed-json",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-raw-json",
+        "value": "{not json}"
+      }
+    },
+    {
+      "id": "aax-decoded-byte-limit",
+      "expected": "accepted",
+      "operation": {
+        "kind": "aax-decoded-bytes",
+        "bytes": 262144
+      }
+    },
+    {
+      "id": "aax-decoded-byte-over-limit",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-decoded-bytes",
+        "bytes": 262145
+      }
+    },
+    {
+      "id": "envelope-unknown-root-key",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["forbidden"],
+        "value": true
+      }
+    },
+    {
+      "id": "envelope-missing-seatbid",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-delete",
+        "path": ["seatbid"]
+      }
+    },
+    {
+      "id": "envelope-zero-seats",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid"],
+        "value": []
+      }
+    },
+    {
+      "id": "envelope-two-seats",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "duplicate-seat"
+      }
+    },
+    {
+      "id": "envelope-unknown-seat-key",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "seat"],
+        "value": "forbidden"
+      }
+    },
+    {
+      "id": "envelope-missing-bid-array",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-delete",
+        "path": ["seatbid", 0, "bid"]
+      }
+    },
+    {
+      "id": "envelope-zero-bids",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "bid"],
+        "value": []
+      }
+    },
+    {
+      "id": "envelope-two-bids",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "duplicate-bid"
+      }
+    },
+    {
+      "id": "envelope-unknown-bid-key",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "bid", 0, "adm"],
+        "value": "<div>forbidden</div>"
+      }
+    },
+    {
+      "id": "envelope-missing-ext",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-delete",
+        "path": ["seatbid", 0, "bid", 0, "ext"]
+      }
+    },
+    {
+      "id": "envelope-unknown-ext-key",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "bid", 0, "ext", "forbidden"],
+        "value": true
+      }
+    },
+    {
+      "id": "envelope-missing-tagtype",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-delete",
+        "path": ["seatbid", 0, "bid", 0, "ext", "tagtype"]
+      }
+    },
+    {
+      "id": "bid-id-disagreement",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "bidId",
+        "value": "different-bid-id"
+      }
+    },
+    {
+      "id": "width-disagreement",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "width",
+        "value": 728
+      }
+    },
+    {
+      "id": "height-disagreement",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "height",
+        "value": 90
+      }
+    },
+    {
+      "id": "creative-url-disagreement",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "creativeUrl",
+        "value": "https://different.example/render"
+      }
+    },
+    {
+      "id": "tag-type-disagreement",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "tagType",
+        "value": "script"
+      }
+    },
+    {
+      "id": "price-negative",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "bid", 0, "price"],
+        "value": -0.01
+      }
+    },
+    {
+      "id": "price-wrong-type",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "envelope-set",
+        "path": ["seatbid", 0, "bid", 0, "price"],
+        "value": "1.23"
+      }
+    },
+    {
+      "id": "price-nonfinite",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "aax-raw-price",
+        "value": "1e400"
+      }
+    },
+    {
+      "id": "unknown-descriptor-type",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "type",
+        "value": "renderer"
+      }
+    },
+    {
+      "id": "equivalent-decimal-version",
+      "expected": "accepted",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "version",
+        "value": 1.0
+      }
+    },
+    {
+      "id": "unknown-descriptor-version",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "version",
+        "value": 2
+      }
+    },
+    {
+      "id": "unknown-tag-type",
+      "expected": "descriptor_invalid",
+      "operation": {
+        "kind": "descriptor-set",
+        "field": "tagType",
+        "value": "video"
+      }
+    }
+  ]
+}
diff --git a/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.schema.json b/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.schema.json
new file mode 100644
index 000000000..4fe6c0445
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.schema.json
@@ -0,0 +1,89 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://iabtechlab.com/trusted-server/aps-renderer-v1.schema.json",
+  "$comment": "The x-* semantic markers are documentation only; scripts/generate-aps-renderer-contract.mjs hard-codes these checks and does not read marker values, so editing a marker does not change enforcement.",
+  "title": "Trusted Server APS renderer descriptor version 1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "type",
+    "version",
+    "accountId",
+    "bidId",
+    "tagType",
+    "creativeUrl",
+    "width",
+    "height",
+    "aaxResponse"
+  ],
+  "properties": {
+    "type": {
+      "const": "aps"
+    },
+    "version": {
+      "const": 1
+    },
+    "accountId": {
+      "type": "string",
+      "minLength": 1,
+      "x-utf8MaxBytes": 1024
+    },
+    "bidId": {
+      "type": "string",
+      "minLength": 1,
+      "x-utf8MaxBytes": 64,
+      "x-forbidNulAndAsciiControl": true
+    },
+    "creativeId": {
+      "type": "string",
+      "minLength": 1,
+      "x-utf8MaxBytes": 1024
+    },
+    "tagType": {
+      "enum": ["iframe", "script"]
+    },
+    "creativeUrl": {
+      "type": "string",
+      "format": "uri",
+      "x-utf8MaxBytes": 4096,
+      "x-requiredScheme": "https",
+      "x-forbidCredentials": true,
+      "x-forbidPublisherOrigin": true
+    },
+    "width": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 4096
+    },
+    "height": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 4096
+    },
+    "aaxResponse": {
+      "type": "string",
+      "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
+      "x-canonicalStandardBase64": true,
+      "x-decodedMaxBytes": 262144
+    }
+  },
+  "x-envelope": {
+    "rootKeys": ["seatbid"],
+    "seatCount": 1,
+    "seatKeys": ["bid"],
+    "bidCount": 1,
+    "bidKeys": ["ext", "h", "id", "price", "w"],
+    "extKeys": ["creativeurl", "tagtype"],
+    "price": {
+      "finite": true,
+      "minimum": 0
+    },
+    "duplicatedFields": {
+      "bidId": ["seatbid", 0, "bid", 0, "id"],
+      "width": ["seatbid", 0, "bid", 0, "w"],
+      "height": ["seatbid", 0, "bid", 0, "h"],
+      "creativeUrl": ["seatbid", 0, "bid", 0, "ext", "creativeurl"],
+      "tagType": ["seatbid", 0, "bid", 0, "ext", "tagtype"]
+    }
+  }
+}
diff --git a/crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json b/crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json
new file mode 100644
index 000000000..ca74daef0
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json
@@ -0,0 +1,581 @@
+{
+  "version": 2,
+  "historicalMain": {
+    "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+    "rows": [
+      {
+        "id": "RCJ-CORE-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/core/auction.ts",
+          "crates/trusted-server-js/lib/src/core/render.ts",
+          "crates/trusted-server-js/lib/src/core/request.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/core/auction.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/core/auction.test.ts test/core/request.test.ts test/core/render.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-CORE-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/core/config.ts",
+          "crates/trusted-server-js/lib/src/core/index.ts",
+          "crates/trusted-server-js/lib/src/core/log.ts",
+          "crates/trusted-server-js/lib/src/core/registry.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/core/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/core/index.test.ts test/core/config.test.ts test/core/registry.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-BOOT-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/html_processor.rs",
+          "crates/trusted-server-js/lib/src/integrations/gpt/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/gpt_bootstrap.test.ts test/integrations/gpt/schedule_initial_ad_init.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-TRACE-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "implementation-gap",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/core/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "node --test --test-name-pattern='RCJ-TRACE-01' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-GPT-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-GPT-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-GPT-03",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/index.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-GPT-04",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "implementation-gap",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "node --test --test-name-pattern='RCJ-GPT-04' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/build-prebid-external.mjs",
+          "crates/trusted-server-js/lib/src/integrations/prebid/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/build-prebid-external.test.mjs test/prebid-artifact-integration.test.mjs",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/prebid/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/index.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-03",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/build-prebid-external.mjs",
+          "crates/trusted-server-js/lib/src/integrations/prebid/user_id_modules.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/user_id_modules.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/user_id_modules.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-PREBID-04",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/prebid/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/index.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-core/src/integrations/aps.rs",
+        "command": "cargo test-fastly integrations::aps::tests",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts",
+          "crates/trusted-server-js/lib/src/integrations/gpt/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/prebid/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-APS-03",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "node --test --test-name-pattern='RCJ-APS-03' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-04",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "node --test --test-name-pattern='RCJ-APS-04' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-CREATIVE-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-core/src/publisher.rs"],
+        "testPath": "crates/trusted-server-core/src/publisher.rs",
+        "command": "cargo test-fastly build_bid_map_",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-CREATIVE-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/integrations/creative/click.ts",
+          "crates/trusted-server-js/lib/src/shared/origin.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/creative/click.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/creative/click.test.ts test/integrations/creative/image.test.ts test/integrations/creative/iframe.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-CREATIVE-03",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/creative/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/creative/image.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/creative/click.test.ts test/integrations/creative/image.test.ts test/integrations/creative/iframe.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-DIAG-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt_diagnostics",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-INT-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/testlight.rs",
+          "crates/trusted-server-js/lib/src/integrations/datadome/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/didomi/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/google_tag_manager/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/osano/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/permutive/segments.ts",
+          "crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/datadome/script_guard.test.ts",
+        "command": "cargo test-fastly integrations::testlight && npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/datadome/script_guard.test.ts test/integrations/didomi/index.test.ts test/integrations/google_tag_manager/script_guard.test.ts test/integrations/lockr/script_guard.test.ts test/integrations/osano/index.test.ts test/integrations/permutive/segments.test.ts test/integrations/sourcepoint/index.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-INT-02",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "main-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/shared/async.ts",
+          "crates/trusted-server-js/lib/src/shared/beacon_guard.ts",
+          "crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts",
+          "crates/trusted-server-js/lib/src/shared/origin.ts",
+          "crates/trusted-server-js/lib/src/shared/scheduler.ts",
+          "crates/trusted-server-js/lib/src/shared/script_guard.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/shared",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-QUAL-01",
+        "mainSha": "f6a2fb85ce623bf8a574e3941e1ee349acc3412d",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/eslint.config.js",
+          "crates/trusted-server-js/lib/package.json",
+          "crates/trusted-server-js/lib/vitest.config.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "node --test --test-name-pattern='RCJ-QUAL-01' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "preserve"
+      }
+    ]
+  },
+  "rcBaseline": {
+    "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+    "rows": [
+      {
+        "id": "RCJ-CORE-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/core/auction.ts",
+          "crates/trusted-server-js/lib/src/core/render.ts",
+          "crates/trusted-server-js/lib/src/core/request.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/core/auction.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/core/auction.test.ts test/core/request.test.ts test/core/render.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-CORE-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/core/config.ts",
+          "crates/trusted-server-js/lib/src/core/index.ts",
+          "crates/trusted-server-js/lib/src/core/log.ts",
+          "crates/trusted-server-js/lib/src/core/registry.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/core/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/core/index.test.ts test/core/config.test.ts test/core/registry.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-BOOT-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/html_processor.rs",
+          "crates/trusted-server-js/lib/src/integrations/gpt/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/gpt_bootstrap.test.ts test/integrations/gpt/schedule_initial_ad_init.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-TRACE-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "implementation-gap",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/core/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "TSJS_CONCEPT_PROOF_LIB_ROOT=\"$TSJS_RC_BASELINE_ROOT/crates/trusted-server-js/lib\" node --test --test-name-pattern='RCJ-TRACE-01' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-GPT-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-GPT-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-GPT-03",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/index.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-GPT-04",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "TSJS_CONCEPT_PROOF_LIB_ROOT=\"$TSJS_RC_BASELINE_ROOT/crates/trusted-server-js/lib\" node --test --test-name-pattern='RCJ-GPT-04' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/build-prebid-external.mjs",
+          "crates/trusted-server-js/lib/src/integrations/prebid/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/build-prebid-external.test.mjs test/prebid-artifact-integration.test.mjs",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/prebid/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/index.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-PREBID-03",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/build-prebid-external.mjs",
+          "crates/trusted-server-js/lib/src/integrations/prebid/user_id_modules.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/user_id_modules.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/user_id_modules.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-PREBID-04",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/prebid/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/prebid/index.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-core/src/integrations/aps.rs",
+        "command": "cargo test --package trusted-server-core --target \"$(rustc -vV | sed -n 's/^host: //p')\" integrations::aps::tests",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts",
+          "crates/trusted-server-js/lib/src/integrations/gpt/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/prebid/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/ad_init.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-APS-03",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "TSJS_CONCEPT_PROOF_LIB_ROOT=\"$TSJS_RC_BASELINE_ROOT/crates/trusted-server-js/lib\" node --test --test-name-pattern='RCJ-APS-03' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-APS-04",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/aps.rs",
+          "crates/trusted-server-js/lib/src/integrations/aps/render.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "TSJS_CONCEPT_PROOF_LIB_ROOT=\"$TSJS_RC_BASELINE_ROOT/crates/trusted-server-js/lib\" node --test --test-name-pattern='RCJ-APS-04' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-CREATIVE-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-core/src/publisher.rs"],
+        "testPath": "crates/trusted-server-core/src/publisher.rs",
+        "command": "cargo test --package trusted-server-core --target \"$(rustc -vV | sed -n 's/^host: //p')\" build_bid_map_",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-CREATIVE-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/integrations/creative/click.ts",
+          "crates/trusted-server-js/lib/src/shared/origin.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/creative/click.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/creative/click.test.ts test/integrations/creative/image.test.ts test/integrations/creative/iframe.test.ts",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-CREATIVE-03",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/creative/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/creative/image.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/creative/click.test.ts test/integrations/creative/image.test.ts test/integrations/creative/iframe.test.ts",
+        "result": "pass",
+        "disposition": "supersede"
+      },
+      {
+        "id": "RCJ-DIAG-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": ["crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts"],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt_diagnostics",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-INT-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-core/src/integrations/testlight.rs",
+          "crates/trusted-server-js/lib/src/integrations/datadome/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/didomi/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/google_tag_manager/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts",
+          "crates/trusted-server-js/lib/src/integrations/osano/index.ts",
+          "crates/trusted-server-js/lib/src/integrations/permutive/segments.ts",
+          "crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/integrations/datadome/script_guard.test.ts",
+        "command": "cargo test --package trusted-server-core --target \"$(rustc -vV | sed -n 's/^host: //p')\" integrations::testlight && npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/datadome/script_guard.test.ts test/integrations/didomi/index.test.ts test/integrations/google_tag_manager/script_guard.test.ts test/integrations/lockr/script_guard.test.ts test/integrations/osano/index.test.ts test/integrations/permutive/segments.test.ts test/integrations/sourcepoint/index.test.ts",
+        "result": "pass",
+        "disposition": "preserve"
+      },
+      {
+        "id": "RCJ-INT-02",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "baseline-owned",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/src/shared/async.ts",
+          "crates/trusted-server-js/lib/src/shared/beacon_guard.ts",
+          "crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts",
+          "crates/trusted-server-js/lib/src/shared/origin.ts",
+          "crates/trusted-server-js/lib/src/shared/scheduler.ts",
+          "crates/trusted-server-js/lib/src/shared/script_guard.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts",
+        "command": "npm --prefix crates/trusted-server-js/lib test -- --run test/shared",
+        "result": "pass",
+        "disposition": "rebuild"
+      },
+      {
+        "id": "RCJ-QUAL-01",
+        "baselineSha": "07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf",
+        "classification": "implementation-gap",
+        "ownerPaths": [
+          "crates/trusted-server-js/lib/eslint.config.js",
+          "crates/trusted-server-js/lib/package.json",
+          "crates/trusted-server-js/lib/vitest.config.ts"
+        ],
+        "testPath": "crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "command": "TSJS_CONCEPT_PROOF_LIB_ROOT=\"$TSJS_RC_BASELINE_ROOT/crates/trusted-server-js/lib\" node --test --test-name-pattern='RCJ-QUAL-01' crates/trusted-server-js/lib/test/contract/current-main-concept-gaps.proof.mjs",
+        "result": "fail",
+        "disposition": "preserve"
+      }
+    ]
+  }
+}
diff --git a/crates/trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json b/crates/trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json
new file mode 100644
index 000000000..418c2cfa2
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json
@@ -0,0 +1,39 @@
+[
+  { "name": "negative zero", "input": "{\"n\":-0.0}", "expected": "{\"n\":0}" },
+  { "name": "integral float", "input": "{\"n\":1.0}", "expected": "{\"n\":1}" },
+  {
+    "name": "upper decimal threshold",
+    "input": "{\"n\":1e20}",
+    "expected": "{\"n\":100000000000000000000}"
+  },
+  {
+    "name": "upper exponent threshold",
+    "input": "{\"n\":1e21}",
+    "expected": "{\"n\":1e+21}"
+  },
+  {
+    "name": "lower decimal threshold",
+    "input": "{\"n\":1e-6}",
+    "expected": "{\"n\":0.000001}"
+  },
+  {
+    "name": "lower exponent threshold",
+    "input": "{\"n\":1e-7}",
+    "expected": "{\"n\":1e-7}"
+  },
+  {
+    "name": "binary64 integer rounding",
+    "input": "{\"n\":9007199254740993}",
+    "expected": "{\"n\":9007199254740992}"
+  },
+  {
+    "name": "integer index enumeration",
+    "input": "{\"a\":1,\"10\":10,\"2\":2,\"01\":1}",
+    "expected": "{\"2\":2,\"10\":10,\"a\":1,\"01\":1}"
+  },
+  {
+    "name": "nested number and key ordering",
+    "input": "{\"values\":[-0.0,1e20,1e-7],\"3\":{\"20\":20,\"4\":4}}",
+    "expected": "{\"3\":{\"4\":4,\"20\":20},\"values\":[0,100000000000000000000,1e-7]}"
+  }
+]
diff --git a/crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json b/crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json
new file mode 100644
index 000000000..a67a96c5d
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json
@@ -0,0 +1,2221 @@
+{
+  "schemaVersion": 1,
+  "mode": "baseline",
+  "source": {
+    "ref": "spec/aps-tsjs-resilience-design",
+    "sha": "88f1432e33f310a202177feb656eba21ff0173de"
+  },
+  "environment": {
+    "node": "v24.12.0",
+    "npm": "11.6.2",
+    "typescript": "5.9.3",
+    "chromium": "145.0.7632.6",
+    "ciMachineClass": "github-hosted:ubuntu-24.04",
+    "fixture": "tsjs-core-placeholder-v1"
+  },
+  "sampling": {
+    "warmups": 5,
+    "samples": 50,
+    "percentile": 90
+  },
+  "bundles": {
+    "minimal": {
+      "files": [
+        "tsjs-core.js"
+      ],
+      "rawBytes": 23317,
+      "gzipBytes": 8687,
+      "brotliBytes": 7686,
+      "sha256": "1e027cfb238cb6eed090b7addcdba5042059737cb319fbdef1b50e286689b851"
+    },
+    "reference": {
+      "files": [
+        "tsjs-core.js",
+        "tsjs-creative.js",
+        "tsjs-gpt.js",
+        "tsjs-prebid.js",
+        "tsjs-datadome.js"
+      ],
+      "rawBytes": 113756,
+      "gzipBytes": 35163,
+      "brotliBytes": 26051,
+      "sha256": "232b734406d9baec8f244d5ab1501535d0296d9f1e0d87e30fc9e30b6c96d204"
+    },
+    "maximal": {
+      "files": [
+        "tsjs-core.js",
+        "tsjs-creative.js",
+        "tsjs-datadome.js",
+        "tsjs-didomi.js",
+        "tsjs-google_tag_manager.js",
+        "tsjs-gpt.js",
+        "tsjs-gpt_diagnostics.js",
+        "tsjs-lockr.js",
+        "tsjs-osano.js",
+        "tsjs-permutive.js",
+        "tsjs-prebid.js",
+        "tsjs-sourcepoint.js",
+        "tsjs-testlight.js"
+      ],
+      "rawBytes": 187224,
+      "gzipBytes": 53799,
+      "brotliBytes": 37790,
+      "sha256": "ce5fa29ba8914ad7074221ae777b12c0f496c00b19c42171e42a3d6005c378d3"
+    }
+  },
+  "performance": {
+    "bootToFirstDisplayMs": {
+      "samples": [
+        23,
+        24.099999999976717,
+        23.20000000001164,
+        25.100000000034925,
+        26.699999999953434,
+        25.20000000001164,
+        24.79999999998836,
+        22.900000000023283,
+        23.79999999998836,
+        26.899999999965075,
+        26,
+        26.300000000046566,
+        22.20000000001164,
+        25.29999999998836,
+        24.100000000034925,
+        23.099999999976717,
+        25,
+        25.70000000001164,
+        24.70000000001164,
+        23.599999999976717,
+        24.199999999953434,
+        25.400000000023283,
+        26.70000000001164,
+        24.20000000001164,
+        24.5,
+        23.5,
+        24.79999999998836,
+        23.79999999998836,
+        26,
+        25.5,
+        22.599999999976717,
+        24.70000000001164,
+        24.79999999998836,
+        24.400000000023283,
+        25,
+        24.899999999965075,
+        23.5,
+        23.400000000023283,
+        24.099999999976717,
+        24.79999999998836,
+        23.29999999998836,
+        24,
+        23.5,
+        27.20000000001164,
+        25.899999999965075,
+        23.5,
+        24.20000000001164,
+        22.5,
+        23.599999999976717,
+        25
+      ],
+      "p90": 26
+    },
+    "retainedHeapBytes": {
+      "afterBoot": 1208816,
+      "afterFirstRender": 1212016,
+      "afterRefresh": 1212016,
+      "afterSpaNavigation": 1219472
+    }
+  },
+  "evidence": {
+    "evidenceId": "aps-tsjs-baseline-88f1432e33f310a202177feb656eba21ff0173de",
+    "workflowRunId": 31074816129
+  },
+  "roleCorrectTransfer": {
+    "schemaVersion": 1,
+    "source": {
+      "ref": "spec/aps-tsjs-resilience-design",
+      "sha": "4e2c307923b838716d95e2feeebb994a37bb8025"
+    },
+    "originalTopLevelSha256": "53f762603ad49239f1756171440be422e190cc231efafc56cf37a11e1a38ddf4",
+    "tools": {
+      "node": "v24.12.0",
+      "npm": "11.6.2",
+      "typescript": "6.0.3",
+      "vite": "8.2.1",
+      "esbuild": "0.28.1",
+      "packageLockSha256": "083ef76165b0518a3157d56dc4fd2697c8ab67ebf43efad1e9f9b06c2edafad5"
+    },
+    "compression": {
+      "concatenationSeparator": ";\n",
+      "gzip": {
+        "implementation": "node:zlib.gzipSync",
+        "version": "zlib 1.3.1-470d3a2",
+        "level": 9,
+        "mtime": 0
+      },
+      "brotli": {
+        "implementation": "node:zlib.brotliCompressSync",
+        "version": "brotli 1.1.0",
+        "mode": "text",
+        "quality": 11,
+        "sizeHint": "input-bytes"
+      }
+    },
+    "release": {
+      "version": 1,
+      "releaseId": "adb06ad34897d0601c1119bf4f193c8175ab32cfe24a718fdc1da89f081c1104",
+      "artifacts": [
+        {
+          "id": "bootstrap",
+          "role": "bootstrap",
+          "phase": null,
+          "trigger": null,
+          "inputs": [],
+          "outputs": [],
+          "file": "gpt-bootstrap-fallback.js",
+          "bytes": 42399,
+          "hash": "6527456d289006e48ed527d897992b0cc0598498f09ca6cacec743ddb4d4915a"
+        },
+        {
+          "id": "core",
+          "role": "core",
+          "phase": null,
+          "trigger": null,
+          "inputs": [],
+          "outputs": [
+            "runtime.v1"
+          ],
+          "file": "tsjs-core.js",
+          "bytes": 85581,
+          "hash": "da8246724c005eb9db51e3c610f5de712583b706b11eea54257a5fe119944515"
+        },
+        {
+          "id": "render_runtime",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1",
+            "trace.presentation.v1",
+            "direct.v1"
+          ],
+          "file": "tsjs-render_runtime.js",
+          "bytes": 166996,
+          "hash": "77a0a1510a35eb77012fffb8f75c7268d05b7e9743f89b532a254484dbfd90d7"
+        },
+        {
+          "id": "aps",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1"
+          ],
+          "outputs": [
+            "aps.v1"
+          ],
+          "file": "tsjs-aps.js",
+          "bytes": 16782,
+          "hash": "b389cb85572c2a20c36112e079e67558eb2931ff15a2ae44d07f621c2b9c85e1"
+        },
+        {
+          "id": "creative",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-creative.js",
+          "bytes": 22226,
+          "hash": "41d3b46e1a95400ba23c7c77d82aacc9d34d43a81ba9d2b1cc80313a49465a6d"
+        },
+        {
+          "id": "datadome",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-datadome.js",
+          "bytes": 23375,
+          "hash": "f847c3264415bdbd3d7a87a0c1254b7c7c7895dcad62ac61ef94728485e87d3c"
+        },
+        {
+          "id": "didomi",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-didomi.js",
+          "bytes": 15489,
+          "hash": "87dbbb6e7d7ba3f65497eaacca1a38c31b8b4603d15cc8f53ec42b0eb7673763"
+        },
+        {
+          "id": "google_tag_manager",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-google_tag_manager.js",
+          "bytes": 26343,
+          "hash": "07eeb0087257f17ad219527af1d76d5726452dc2856022e2ee98fbed97a609fc"
+        },
+        {
+          "id": "gpt",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1"
+          ],
+          "outputs": [
+            "gpt.v1",
+            "gpt.events.v1",
+            "pbs_cache.baseline.v1"
+          ],
+          "file": "tsjs-gpt.js",
+          "bytes": 180256,
+          "hash": "9572f7fd8cdbca00e562591a0306de1a914e1394bbadf384eb08a64ee446a064"
+        },
+        {
+          "id": "gpt_diagnostics",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "gpt.events.v1"
+          ],
+          "outputs": [
+            "gpt_diag.v1"
+          ],
+          "file": "tsjs-gpt_diagnostics.js",
+          "bytes": 29975,
+          "hash": "dc5e1946fd5badd0ad6554bf38cf916e37e7ec30403450a6f89e8f2cdc8785db"
+        },
+        {
+          "id": "lockr",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-lockr.js",
+          "bytes": 24031,
+          "hash": "9c78aca92b0e372dc31d714f71d87b0563ffa06a87c292b8899aadbb23f33f1e"
+        },
+        {
+          "id": "osano_consent",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "osano_consent.v1"
+          ],
+          "file": "tsjs-osano_consent.js",
+          "bytes": 10511,
+          "hash": "f72879b5f40d8929a5d82f78d37be4304ddbf1616cde777e501b47b81381940c"
+        },
+        {
+          "id": "permutive_context",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "permutive_context.v1"
+          ],
+          "file": "tsjs-permutive_context.js",
+          "bytes": 17818,
+          "hash": "55f074193ae0c2250d6a87d0caa4fae7fd927c328b8bb48693814020a93af29c"
+        },
+        {
+          "id": "sourcepoint_consent",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "sourcepoint_consent.v1"
+          ],
+          "file": "tsjs-sourcepoint_consent.js",
+          "bytes": 18789,
+          "hash": "2d00eb50fd7996004148778cd42a2bd2f12c37d6d5a8593bacf0dba4d7e9c88a"
+        },
+        {
+          "id": "prebid",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "render.v1",
+            "messages.v1",
+            "aps.v1?aps"
+          ],
+          "outputs": [
+            "prebid.v1"
+          ],
+          "file": "tsjs-prebid.js",
+          "bytes": 36716,
+          "hash": "d1a7cf9b9a864711b4e1f01e25a088b388bd02a33227b88230a6b0e43c358846"
+        },
+        {
+          "id": "testlight",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-testlight.js",
+          "bytes": 16232,
+          "hash": "53b8915eb544313ee41a84a096c1e1d7a7a5475cf5165cef6fc0ee238f15d752"
+        },
+        {
+          "id": "diagnostics_presentation",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "trace.presentation.v1",
+            "gpt_diag.v1?gpt_diagnostics_active"
+          ],
+          "outputs": [],
+          "file": "tsjs-diagnostics_presentation.js",
+          "bytes": 39944,
+          "hash": "15b4c83f7baf222bfac34ed02f1b85e69dff58c0004b53ce80e7a36325a490d2"
+        },
+        {
+          "id": "gpt_later",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "gpt.v1",
+            "trace.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-gpt_later.js",
+          "bytes": 5420,
+          "hash": "7c870dd3c623f2fd468327fbcdc79dd3a0ab3a99001bfb0d99542dc24a7f3af6"
+        },
+        {
+          "id": "osano_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "osano_consent.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-osano_lifecycle.js",
+          "bytes": 3663,
+          "hash": "38fb9af941cfbe6b1808144277f05f360b0f9278c87220045534b031fa30b845"
+        },
+        {
+          "id": "permutive_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "permutive_context.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-permutive_lifecycle.js",
+          "bytes": 3675,
+          "hash": "7182fe24f7d6cee7e7c0621ac30eee069fe959bdc64d0c3d381b5e9f89d73740"
+        },
+        {
+          "id": "prebid_later",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "gpt.v1",
+            "prebid.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-prebid_later.js",
+          "bytes": 11160,
+          "hash": "c2d8695d1a2e26039d760f86566840b167a2cd899783528d7d9dfdb3f065bff4"
+        },
+        {
+          "id": "sourcepoint_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "sourcepoint_consent.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-sourcepoint_lifecycle.js",
+          "bytes": 3681,
+          "hash": "eca9fc0410f214ffc8268cdbf682f7ddeed20c7aa0ad704d34d08b72a3900ddd"
+        }
+      ]
+    },
+    "sourceOwners": {
+      "src/adapters/googletag.ts": [
+        "gpt"
+      ],
+      "src/adapters/messaging.ts": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/adapters/prebid.ts": [
+        "prebid"
+      ],
+      "src/composition/browser.ts": [
+        "core"
+      ],
+      "src/composition/index.ts": [
+        "core"
+      ],
+      "src/core/auction.ts": [
+        "render_runtime"
+      ],
+      "src/core/config.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "gpt"
+      ],
+      "src/core/contracts/aps_renderer.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "aps",
+        "gpt"
+      ],
+      "src/core/contracts/auction_projection.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "gpt",
+        "prebid",
+        "prebid_later"
+      ],
+      "src/core/contracts/generated/renderer_validator_v1.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "aps",
+        "gpt"
+      ],
+      "src/core/contracts/request_ads.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime"
+      ],
+      "src/core/index.ts": [
+        "core"
+      ],
+      "src/core/log.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "creative",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "gpt",
+        "gpt_diagnostics",
+        "lockr",
+        "osano_consent",
+        "permutive_context",
+        "sourcepoint_consent",
+        "testlight",
+        "diagnostics_presentation"
+      ],
+      "src/core/queue.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/core/registry.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime"
+      ],
+      "src/core/release.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "aps",
+        "creative",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "gpt",
+        "gpt_diagnostics",
+        "lockr",
+        "osano_consent",
+        "permutive_context",
+        "sourcepoint_consent",
+        "prebid",
+        "testlight",
+        "diagnostics_presentation",
+        "gpt_later",
+        "osano_lifecycle",
+        "permutive_lifecycle",
+        "prebid_later",
+        "sourcepoint_lifecycle"
+      ],
+      "src/core/render.ts": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/core/styles/normalize.css?inline": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/core/templates/iframe.html?raw": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/core/trace.ts": [
+        "render_runtime",
+        "gpt_diagnostics"
+      ],
+      "src/integrations/aps/index.ts": [
+        "aps"
+      ],
+      "src/integrations/aps/module.ts": [
+        "aps"
+      ],
+      "src/integrations/aps/render.ts": [
+        "aps"
+      ],
+      "src/integrations/creative/click.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/dynamic_src_guard.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/iframe.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/image.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/index.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/module.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/proxy_sign.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/startup.ts": [
+        "creative"
+      ],
+      "src/integrations/datadome/index.ts": [
+        "datadome"
+      ],
+      "src/integrations/datadome/module.ts": [
+        "datadome"
+      ],
+      "src/integrations/datadome/script_guard.ts": [
+        "datadome"
+      ],
+      "src/integrations/didomi/index.ts": [
+        "didomi"
+      ],
+      "src/integrations/didomi/module.ts": [
+        "didomi"
+      ],
+      "src/integrations/google_tag_manager/index.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/google_tag_manager/module.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/google_tag_manager/script_guard.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/gpt/bootstrap_fallback.ts": [
+        "bootstrap"
+      ],
+      "src/integrations/gpt/diagnostics_facts.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/index.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/later.ts": [
+        "gpt_later"
+      ],
+      "src/integrations/gpt/module.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/script_guard.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/startup.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt_diagnostics/badges.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/binding.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/data_api.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/exhaustive.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/index.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/module.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/observer.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/overlay.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/presentation.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/store.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/lockr/index.ts": [
+        "lockr"
+      ],
+      "src/integrations/lockr/module.ts": [
+        "lockr"
+      ],
+      "src/integrations/lockr/script_guard.ts": [
+        "lockr"
+      ],
+      "src/integrations/osano/consent.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/osano/consent_mirror.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/osano/lifecycle.ts": [
+        "osano_lifecycle"
+      ],
+      "src/integrations/osano/module.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/permutive/context.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/lifecycle.ts": [
+        "permutive_lifecycle"
+      ],
+      "src/integrations/permutive/module.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/script_guard.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/segments.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/prebid/index.ts": [
+        "prebid"
+      ],
+      "src/integrations/prebid/later.ts": [
+        "prebid_later"
+      ],
+      "src/integrations/prebid/module.ts": [
+        "prebid"
+      ],
+      "src/integrations/prebid/refresh.ts": [
+        "prebid",
+        "prebid_later"
+      ],
+      "src/integrations/prebid/startup.ts": [
+        "prebid"
+      ],
+      "src/integrations/render_runtime/index.ts": [
+        "render_runtime"
+      ],
+      "src/integrations/render_runtime/module.ts": [
+        "render_runtime"
+      ],
+      "src/integrations/sourcepoint/consent.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/consent_mirror.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/lifecycle.ts": [
+        "sourcepoint_lifecycle"
+      ],
+      "src/integrations/sourcepoint/module.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/script_guard.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/testlight/index.ts": [
+        "testlight"
+      ],
+      "src/integrations/testlight/module.ts": [
+        "testlight"
+      ],
+      "src/kernel/diagnostics.ts": [
+        "render_runtime"
+      ],
+      "src/kernel/disposable.ts": [
+        "core",
+        "render_runtime",
+        "gpt"
+      ],
+      "src/kernel/fallback.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/kernel/identity.ts": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/kernel/integration_registry.ts": [
+        "core"
+      ],
+      "src/kernel/lifecycle_module.ts": [
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "lockr",
+        "testlight"
+      ],
+      "src/kernel/phase_loader.ts": [
+        "core"
+      ],
+      "src/kernel/release_catalog.ts": [
+        "bootstrap",
+        "core",
+        "render_runtime",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "lockr",
+        "testlight"
+      ],
+      "src/kernel/runtime.ts": [
+        "core"
+      ],
+      "src/kernel/sessions.ts": [
+        "render_runtime"
+      ],
+      "src/services/auction_batch.ts": [
+        "render_runtime"
+      ],
+      "src/services/context.ts": [
+        "render_runtime"
+      ],
+      "src/services/projections.ts": [
+        "render_runtime",
+        "gpt"
+      ],
+      "src/services/puc_bridge.ts": [
+        "gpt"
+      ],
+      "src/services/render.ts": [
+        "render_runtime"
+      ],
+      "src/services/reservations.ts": [
+        "render_runtime"
+      ],
+      "src/services/slots.ts": [
+        "gpt"
+      ],
+      "src/services/targeting.ts": [
+        "gpt"
+      ],
+      "src/shared/async.ts": [
+        "creative"
+      ],
+      "src/shared/beacon_guard.ts": [
+        "google_tag_manager"
+      ],
+      "src/shared/dom_insertion_dispatcher.ts": [
+        "datadome",
+        "google_tag_manager",
+        "gpt",
+        "lockr",
+        "permutive_context",
+        "sourcepoint_consent"
+      ],
+      "src/shared/globals.ts": [
+        "creative"
+      ],
+      "src/shared/origin.ts": [
+        "render_runtime",
+        "creative"
+      ],
+      "src/shared/realm.ts": [
+        "gpt_diagnostics",
+        "diagnostics_presentation"
+      ],
+      "src/shared/scheduler.ts": [
+        "creative"
+      ],
+      "src/shared/script_guard.ts": [
+        "datadome",
+        "google_tag_manager",
+        "gpt",
+        "lockr",
+        "permutive_context",
+        "sourcepoint_consent"
+      ]
+    },
+    "sets": {
+      "bootstrap": {
+        "artifactIds": [
+          "bootstrap"
+        ],
+        "files": [
+          "gpt-bootstrap-fallback.js"
+        ],
+        "rawBytes": 42399,
+        "gzipBytes": 11870,
+        "brotliBytes": 10537,
+        "sha256": "6527456d289006e48ed527d897992b0cc0598498f09ca6cacec743ddb4d4915a"
+      },
+      "minimal": {
+        "artifactIds": [
+          "core",
+          "render_runtime"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js"
+        ],
+        "rawBytes": 252579,
+        "gzipBytes": 67933,
+        "brotliBytes": 51467,
+        "sha256": "99da81c445b54060b57a64ff65337008d98b1e597e0006cdbd3bab584d9b6f1e"
+      },
+      "reference": {
+        "artifactIds": [
+          "core",
+          "render_runtime",
+          "creative",
+          "gpt",
+          "prebid",
+          "datadome"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js",
+          "tsjs-creative.js",
+          "tsjs-gpt.js",
+          "tsjs-prebid.js",
+          "tsjs-datadome.js"
+        ],
+        "rawBytes": 515160,
+        "gzipBytes": 140684,
+        "brotliBytes": 100577,
+        "sha256": "3d3ec6b4d11555ee2906c4dc1532cc7e716f4914089667754a1c06f2a1877c8a"
+      },
+      "maximal": {
+        "artifactIds": [
+          "core",
+          "render_runtime",
+          "aps",
+          "creative",
+          "datadome",
+          "didomi",
+          "google_tag_manager",
+          "gpt",
+          "gpt_diagnostics",
+          "lockr",
+          "osano_consent",
+          "permutive_context",
+          "sourcepoint_consent",
+          "prebid",
+          "testlight",
+          "diagnostics_presentation",
+          "gpt_later",
+          "osano_lifecycle",
+          "permutive_lifecycle",
+          "prebid_later",
+          "sourcepoint_lifecycle"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js",
+          "tsjs-aps.js",
+          "tsjs-creative.js",
+          "tsjs-datadome.js",
+          "tsjs-didomi.js",
+          "tsjs-google_tag_manager.js",
+          "tsjs-gpt.js",
+          "tsjs-gpt_diagnostics.js",
+          "tsjs-lockr.js",
+          "tsjs-osano_consent.js",
+          "tsjs-permutive_context.js",
+          "tsjs-sourcepoint_consent.js",
+          "tsjs-prebid.js",
+          "tsjs-testlight.js",
+          "tsjs-diagnostics_presentation.js",
+          "tsjs-gpt_later.js",
+          "tsjs-osano_lifecycle.js",
+          "tsjs-permutive_lifecycle.js",
+          "tsjs-prebid_later.js",
+          "tsjs-sourcepoint_lifecycle.js"
+        ],
+        "rawBytes": 758703,
+        "gzipBytes": 188753,
+        "brotliBytes": 128205,
+        "sha256": "67310e0c47fea3011ba193ed79c03e6e50c574a3704c35eb636114cd3a3b88f9"
+      }
+    }
+  },
+  "reviewRemediationTransfer": {
+    "schemaVersion": 1,
+    "source": {
+      "ref": "spec/aps-tsjs-resilience-design",
+      "sha": "91b3533ae7c07e03fa77441e0d94f27e31965d9e"
+    },
+    "originalTopLevelSha256": "53f762603ad49239f1756171440be422e190cc231efafc56cf37a11e1a38ddf4",
+    "roleCorrectTransferSha256": "f1d73d517e4888ef4dc3a84b34166e9aeb6a2bde99dec1c835f151f4e070f64a",
+    "tools": {
+      "node": "v24.12.0",
+      "npm": "11.6.2",
+      "typescript": "6.0.3",
+      "vite": "8.2.1",
+      "esbuild": "0.28.1",
+      "packageLockSha256": "083ef76165b0518a3157d56dc4fd2697c8ab67ebf43efad1e9f9b06c2edafad5"
+    },
+    "compression": {
+      "concatenationSeparator": ";\n",
+      "gzip": {
+        "implementation": "node:zlib.gzipSync",
+        "version": "zlib 1.3.1-470d3a2",
+        "level": 9,
+        "mtime": 0
+      },
+      "brotli": {
+        "implementation": "node:zlib.brotliCompressSync",
+        "version": "brotli 1.1.0",
+        "mode": "text",
+        "quality": 11,
+        "sizeHint": "input-bytes"
+      }
+    },
+    "release": {
+      "version": 1,
+      "releaseId": "da6237db414516d27426d1ae0be03c024274dd0e869a335fb3c00bbc52afc0bd",
+      "artifacts": [
+        {
+          "id": "bootstrap",
+          "role": "bootstrap",
+          "phase": null,
+          "trigger": null,
+          "inputs": [],
+          "outputs": [],
+          "file": "gpt-bootstrap-fallback.js",
+          "bytes": 42838,
+          "hash": "cfc25ea32119a0193bb2ace190b61be255b488157ca8ceef64347676d10193d9"
+        },
+        {
+          "id": "core",
+          "role": "core",
+          "phase": null,
+          "trigger": null,
+          "inputs": [],
+          "outputs": [
+            "runtime.v1"
+          ],
+          "file": "tsjs-core.js",
+          "bytes": 217966,
+          "hash": "b5bdbe0ac89d0d0d1fe29f522ae58aa23fc443597a21d096e4ee63c33daad248"
+        },
+        {
+          "id": "render_runtime",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1",
+            "trace.presentation.v1",
+            "direct.v1"
+          ],
+          "file": "tsjs-render_runtime.js",
+          "bytes": 74,
+          "hash": "c803f320271dbd668bbf23328fd1769331c0579f6bbbb137027e30bea26b9a7e"
+        },
+        {
+          "id": "aps",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1"
+          ],
+          "outputs": [
+            "aps.v1"
+          ],
+          "file": "tsjs-aps.js",
+          "bytes": 16782,
+          "hash": "f6747dee35a9502ca15f3390b47c400e4b1be0ce83c25bd57c7294a6b97c5d8b"
+        },
+        {
+          "id": "creative",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-creative.js",
+          "bytes": 22226,
+          "hash": "5703db52100117da3b2304734957db9327903e2ee70371e9150a19553ac2f894"
+        },
+        {
+          "id": "datadome",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-datadome.js",
+          "bytes": 23375,
+          "hash": "95abf1300724721c0ad4ec82098e71e25afbc79c28d89888e4b9c3a86993e0c8"
+        },
+        {
+          "id": "didomi",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-didomi.js",
+          "bytes": 15489,
+          "hash": "c631026551448ca2c59c669ae05842da2a8b29ff49da08e9ace760d240cc24d5"
+        },
+        {
+          "id": "google_tag_manager",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-google_tag_manager.js",
+          "bytes": 26343,
+          "hash": "ba91a352dc9658a33e58ee4c742d91ef7ad37cc77685e32b9804d879042a9e45"
+        },
+        {
+          "id": "gpt",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "messages.v1",
+            "trace.v1"
+          ],
+          "outputs": [
+            "gpt.v1",
+            "gpt.events.v1",
+            "pbs_cache.baseline.v1"
+          ],
+          "file": "tsjs-gpt.js",
+          "bytes": 154575,
+          "hash": "710640b3dfdb0779bba6444da66c9b2245c011686a6c42e5542022c6dab8742b"
+        },
+        {
+          "id": "gpt_diagnostics",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "gpt.events.v1"
+          ],
+          "outputs": [
+            "gpt_diag.v1"
+          ],
+          "file": "tsjs-gpt_diagnostics.js",
+          "bytes": 29975,
+          "hash": "6703f7ab1fe6ed1ff9a90f1d3511ff858f75170dca7ec6a6f686f2c59004869d"
+        },
+        {
+          "id": "lockr",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-lockr.js",
+          "bytes": 24031,
+          "hash": "19952a6888923f35852ec8e76bea525082874a36d3fda3e801311a6f6dde49ed"
+        },
+        {
+          "id": "osano_consent",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "osano_consent.v1"
+          ],
+          "file": "tsjs-osano_consent.js",
+          "bytes": 10511,
+          "hash": "aad62189a6d5018f90c72e68593adeab7a9dd3d8d87649032a4a5499135da99a"
+        },
+        {
+          "id": "permutive_context",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "permutive_context.v1"
+          ],
+          "file": "tsjs-permutive_context.js",
+          "bytes": 17818,
+          "hash": "bab701c0ef96bc68fce41afefa7f49be114a139b92f6eee62f48c07f7a19f6e2"
+        },
+        {
+          "id": "sourcepoint_consent",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [
+            "sourcepoint_consent.v1"
+          ],
+          "file": "tsjs-sourcepoint_consent.js",
+          "bytes": 18789,
+          "hash": "9378603d6e43c77c3e3975c9dfb1c4229bbd9b0d63bc7ab74dc303492a248eb9"
+        },
+        {
+          "id": "prebid",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "render.v1",
+            "messages.v1",
+            "aps.v1?aps"
+          ],
+          "outputs": [
+            "prebid.v1"
+          ],
+          "file": "tsjs-prebid.js",
+          "bytes": 36569,
+          "hash": "9492a7e41aa4ebe484fbbd2fac6681c7080437d1ed7cfaefc4120a3270967763"
+        },
+        {
+          "id": "testlight",
+          "role": "integration",
+          "phase": "critical",
+          "trigger": null,
+          "inputs": [
+            "runtime.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-testlight.js",
+          "bytes": 16232,
+          "hash": "e788888a96b102adc9444030ab43a152e4fec375134ba5135961c11f4fd9b947"
+        },
+        {
+          "id": "diagnostics_presentation",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "trace.presentation.v1",
+            "gpt_diag.v1?gpt_diagnostics_active"
+          ],
+          "outputs": [],
+          "file": "tsjs-diagnostics_presentation.js",
+          "bytes": 39926,
+          "hash": "3f0735bba5a334e4638c48dae6fbd51db4db769e74a0251775eda0362b739fab"
+        },
+        {
+          "id": "gpt_later",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "auction.v1",
+            "render.v1",
+            "gpt.v1",
+            "trace.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-gpt_later.js",
+          "bytes": 5420,
+          "hash": "20ff6c4178fc7c7346f634027476b14435905b31fbbc70261b73dcc37c7ccd37"
+        },
+        {
+          "id": "osano_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "osano_consent.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-osano_lifecycle.js",
+          "bytes": 3663,
+          "hash": "39878189d45b8472047969a9ea5faa83e9f464c95bac32ce97646075f6d8dff4"
+        },
+        {
+          "id": "permutive_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "permutive_context.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-permutive_lifecycle.js",
+          "bytes": 3675,
+          "hash": "9b4049d8054bc0b5f2cd0d6824532ed15d004ffd592a734d4ec4229e09f5c49b"
+        },
+        {
+          "id": "prebid_later",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "slots.v1",
+            "gpt.v1",
+            "prebid.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-prebid_later.js",
+          "bytes": 11160,
+          "hash": "92c5f09add1a39cca6431d758927f9245e2c211af15536f9bac8ab11d9380f66"
+        },
+        {
+          "id": "sourcepoint_lifecycle",
+          "role": "integration",
+          "phase": "deferred",
+          "trigger": "first_display_or_idle",
+          "inputs": [
+            "runtime.v1",
+            "sourcepoint_consent.v1"
+          ],
+          "outputs": [],
+          "file": "tsjs-sourcepoint_lifecycle.js",
+          "bytes": 3681,
+          "hash": "31ecc5a68e7602f7222c8efe6001b64427d770101a3ddb31610d13ad49776efd"
+        }
+      ]
+    },
+    "sourceOwners": {
+      "src/core/log.ts": [
+        "bootstrap",
+        "core",
+        "creative",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "gpt",
+        "gpt_diagnostics",
+        "lockr",
+        "osano_consent",
+        "permutive_context",
+        "sourcepoint_consent",
+        "testlight",
+        "diagnostics_presentation"
+      ],
+      "src/core/queue.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/core/release.ts": [
+        "bootstrap",
+        "core",
+        "aps",
+        "creative",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "gpt",
+        "gpt_diagnostics",
+        "lockr",
+        "osano_consent",
+        "permutive_context",
+        "sourcepoint_consent",
+        "prebid",
+        "testlight",
+        "diagnostics_presentation",
+        "gpt_later",
+        "osano_lifecycle",
+        "permutive_lifecycle",
+        "prebid_later",
+        "sourcepoint_lifecycle"
+      ],
+      "src/core/config.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/core/contracts/generated/renderer_validator_v1.ts": [
+        "bootstrap",
+        "core",
+        "aps"
+      ],
+      "src/core/contracts/aps_renderer.ts": [
+        "bootstrap",
+        "core",
+        "aps"
+      ],
+      "src/core/contracts/auction_projection.ts": [
+        "bootstrap",
+        "core",
+        "prebid",
+        "prebid_later"
+      ],
+      "src/core/contracts/request_ads.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/core/registry.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/kernel/release_catalog.ts": [
+        "bootstrap",
+        "core",
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "lockr",
+        "testlight"
+      ],
+      "src/kernel/fallback.ts": [
+        "bootstrap",
+        "core"
+      ],
+      "src/integrations/gpt/bootstrap_fallback.ts": [
+        "bootstrap"
+      ],
+      "src/core/index.ts": [
+        "core"
+      ],
+      "src/kernel/contracts/message_protocol.ts": [
+        "core",
+        "gpt"
+      ],
+      "src/adapters/messaging.ts": [
+        "core"
+      ],
+      "src/core/auction.ts": [
+        "core"
+      ],
+      "src/core/styles/normalize.css?inline": [
+        "core"
+      ],
+      "src/core/templates/iframe.html?raw": [
+        "core"
+      ],
+      "src/core/render.ts": [
+        "core"
+      ],
+      "src/core/trace.ts": [
+        "core",
+        "gpt_diagnostics"
+      ],
+      "src/kernel/disposable.ts": [
+        "core",
+        "gpt"
+      ],
+      "src/kernel/identity.ts": [
+        "core"
+      ],
+      "src/kernel/diagnostics.ts": [
+        "core"
+      ],
+      "src/kernel/sessions.ts": [
+        "core"
+      ],
+      "src/services/auction_batch.ts": [
+        "core"
+      ],
+      "src/services/context.ts": [
+        "core"
+      ],
+      "src/services/projections.ts": [
+        "core"
+      ],
+      "src/services/reservations.ts": [
+        "core"
+      ],
+      "src/services/render.ts": [
+        "core"
+      ],
+      "src/shared/origin.ts": [
+        "core",
+        "creative"
+      ],
+      "src/integrations/render_runtime/module.ts": [
+        "core"
+      ],
+      "src/kernel/integration_registry.ts": [
+        "core"
+      ],
+      "src/kernel/phase_loader.ts": [
+        "core"
+      ],
+      "src/kernel/runtime.ts": [
+        "core"
+      ],
+      "src/composition/browser.ts": [
+        "core"
+      ],
+      "src/composition/critical_transport.ts": [
+        "core"
+      ],
+      "src/integrations/render_runtime/transport_marker.ts": [
+        "render_runtime"
+      ],
+      "src/integrations/aps/render.ts": [
+        "aps"
+      ],
+      "src/integrations/aps/module.ts": [
+        "aps"
+      ],
+      "src/integrations/aps/index.ts": [
+        "aps"
+      ],
+      "src/shared/globals.ts": [
+        "creative"
+      ],
+      "src/shared/async.ts": [
+        "creative"
+      ],
+      "src/shared/scheduler.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/click.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/dynamic_src_guard.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/proxy_sign.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/iframe.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/image.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/startup.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/module.ts": [
+        "creative"
+      ],
+      "src/integrations/creative/index.ts": [
+        "creative"
+      ],
+      "src/kernel/lifecycle_module.ts": [
+        "datadome",
+        "didomi",
+        "google_tag_manager",
+        "lockr",
+        "testlight"
+      ],
+      "src/shared/dom_insertion_dispatcher.ts": [
+        "datadome",
+        "google_tag_manager",
+        "gpt",
+        "lockr",
+        "permutive_context",
+        "sourcepoint_consent"
+      ],
+      "src/shared/script_guard.ts": [
+        "datadome",
+        "google_tag_manager",
+        "gpt",
+        "lockr",
+        "permutive_context",
+        "sourcepoint_consent"
+      ],
+      "src/integrations/datadome/script_guard.ts": [
+        "datadome"
+      ],
+      "src/integrations/datadome/module.ts": [
+        "datadome"
+      ],
+      "src/integrations/datadome/index.ts": [
+        "datadome"
+      ],
+      "src/integrations/didomi/module.ts": [
+        "didomi"
+      ],
+      "src/integrations/didomi/index.ts": [
+        "didomi"
+      ],
+      "src/shared/beacon_guard.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/google_tag_manager/script_guard.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/google_tag_manager/module.ts": [
+        "google_tag_manager"
+      ],
+      "src/integrations/google_tag_manager/index.ts": [
+        "google_tag_manager"
+      ],
+      "src/adapters/googletag.ts": [
+        "gpt"
+      ],
+      "src/core/puc_shell.ts": [
+        "gpt"
+      ],
+      "src/services/puc_bridge.ts": [
+        "gpt"
+      ],
+      "src/services/slots.ts": [
+        "gpt"
+      ],
+      "src/services/targeting.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/diagnostics_facts.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/script_guard.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/startup.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/module.ts": [
+        "gpt"
+      ],
+      "src/integrations/gpt/index.ts": [
+        "gpt"
+      ],
+      "src/shared/realm.ts": [
+        "gpt_diagnostics",
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/data_api.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/observer.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/store.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/module.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/gpt_diagnostics/index.ts": [
+        "gpt_diagnostics"
+      ],
+      "src/integrations/lockr/script_guard.ts": [
+        "lockr"
+      ],
+      "src/integrations/lockr/module.ts": [
+        "lockr"
+      ],
+      "src/integrations/lockr/index.ts": [
+        "lockr"
+      ],
+      "src/integrations/osano/consent_mirror.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/osano/module.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/osano/consent.ts": [
+        "osano_consent"
+      ],
+      "src/integrations/permutive/script_guard.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/segments.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/module.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/permutive/context.ts": [
+        "permutive_context"
+      ],
+      "src/integrations/sourcepoint/consent_mirror.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/script_guard.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/module.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/integrations/sourcepoint/consent.ts": [
+        "sourcepoint_consent"
+      ],
+      "src/adapters/prebid.ts": [
+        "prebid"
+      ],
+      "src/integrations/prebid/startup.ts": [
+        "prebid"
+      ],
+      "src/integrations/prebid/module.ts": [
+        "prebid"
+      ],
+      "src/integrations/prebid/index.ts": [
+        "prebid"
+      ],
+      "src/integrations/testlight/module.ts": [
+        "testlight"
+      ],
+      "src/integrations/testlight/index.ts": [
+        "testlight"
+      ],
+      "src/integrations/gpt_diagnostics/exhaustive.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/badges.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/binding.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/overlay.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt_diagnostics/presentation.ts": [
+        "diagnostics_presentation"
+      ],
+      "src/integrations/gpt/later.ts": [
+        "gpt_later"
+      ],
+      "src/integrations/osano/lifecycle.ts": [
+        "osano_lifecycle"
+      ],
+      "src/integrations/permutive/lifecycle.ts": [
+        "permutive_lifecycle"
+      ],
+      "src/integrations/prebid/refresh.ts": [
+        "prebid_later"
+      ],
+      "src/integrations/prebid/later.ts": [
+        "prebid_later"
+      ],
+      "src/integrations/sourcepoint/lifecycle.ts": [
+        "sourcepoint_lifecycle"
+      ]
+    },
+    "logicalProviderSources": {
+      "core": [
+        "src/kernel/runtime.ts"
+      ],
+      "render_runtime": [
+        "src/integrations/render_runtime/module.ts",
+        "src/services/render.ts"
+      ],
+      "gpt": [
+        "src/integrations/gpt/module.ts",
+        "src/integrations/gpt/startup.ts"
+      ],
+      "gpt_diagnostics": [
+        "src/integrations/gpt_diagnostics/store.ts"
+      ],
+      "osano_consent": [
+        "src/integrations/osano/consent.ts"
+      ],
+      "prebid": [
+        "src/integrations/prebid/module.ts",
+        "src/integrations/prebid/startup.ts"
+      ],
+      "sourcepoint_consent": [
+        "src/integrations/sourcepoint/consent.ts"
+      ]
+    },
+    "physicalMarkerOwners": {
+      "render_runtime": "core"
+    },
+    "graphReport": {
+      "largestContributions": [
+        {
+          "artifact": "gpt",
+          "source": "src/services/slots.ts",
+          "renderedBytes": 94703
+        },
+        {
+          "artifact": "core",
+          "source": "src/services/render.ts",
+          "renderedBytes": 79493
+        },
+        {
+          "artifact": "gpt",
+          "source": "src/adapters/googletag.ts",
+          "renderedBytes": 72088
+        },
+        {
+          "artifact": "gpt",
+          "source": "src/services/puc_bridge.ts",
+          "renderedBytes": 71834
+        },
+        {
+          "artifact": "prebid",
+          "source": "src/adapters/prebid.ts",
+          "renderedBytes": 40422
+        },
+        {
+          "artifact": "core",
+          "source": "src/adapters/messaging.ts",
+          "renderedBytes": 35826
+        },
+        {
+          "artifact": "gpt",
+          "source": "src/integrations/gpt/module.ts",
+          "renderedBytes": 33449
+        },
+        {
+          "artifact": "core",
+          "source": "src/kernel/integration_registry.ts",
+          "renderedBytes": 31919
+        },
+        {
+          "artifact": "core",
+          "source": "src/services/reservations.ts",
+          "renderedBytes": 31726
+        },
+        {
+          "artifact": "gpt_diagnostics",
+          "source": "src/integrations/gpt_diagnostics/store.ts",
+          "renderedBytes": 28251
+        },
+        {
+          "artifact": "prebid",
+          "source": "src/integrations/prebid/module.ts",
+          "renderedBytes": 24292
+        },
+        {
+          "artifact": "diagnostics_presentation",
+          "source": "src/integrations/gpt_diagnostics/overlay.ts",
+          "renderedBytes": 23379
+        },
+        {
+          "artifact": "core",
+          "source": "src/integrations/render_runtime/module.ts",
+          "renderedBytes": 23342
+        },
+        {
+          "artifact": "core",
+          "source": "src/core/trace.ts",
+          "renderedBytes": 20652
+        },
+        {
+          "artifact": "aps",
+          "source": "src/integrations/aps/render.ts",
+          "renderedBytes": 19831
+        },
+        {
+          "artifact": "core",
+          "source": "src/kernel/runtime.ts",
+          "renderedBytes": 19173
+        },
+        {
+          "artifact": "core",
+          "source": "src/core/registry.ts",
+          "renderedBytes": 18979
+        },
+        {
+          "artifact": "core",
+          "source": "src/core/contracts/auction_projection.ts",
+          "renderedBytes": 18781
+        },
+        {
+          "artifact": "bootstrap",
+          "source": "src/core/contracts/auction_projection.ts",
+          "renderedBytes": 18747
+        },
+        {
+          "artifact": "diagnostics_presentation",
+          "source": "src/integrations/gpt_diagnostics/presentation.ts",
+          "renderedBytes": 16668
+        }
+      ],
+      "repeatedAttributions": [
+        {
+          "source": "src/core/config.ts",
+          "owners": [
+            "bootstrap",
+            "core"
+          ]
+        },
+        {
+          "source": "src/core/contracts/aps_renderer.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "aps"
+          ]
+        },
+        {
+          "source": "src/core/contracts/auction_projection.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "prebid",
+            "prebid_later"
+          ]
+        },
+        {
+          "source": "src/core/contracts/generated/renderer_validator_v1.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "aps"
+          ]
+        },
+        {
+          "source": "src/core/contracts/request_ads.ts",
+          "owners": [
+            "bootstrap",
+            "core"
+          ]
+        },
+        {
+          "source": "src/core/log.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "creative",
+            "datadome",
+            "didomi",
+            "google_tag_manager",
+            "gpt",
+            "gpt_diagnostics",
+            "lockr",
+            "osano_consent",
+            "permutive_context",
+            "sourcepoint_consent",
+            "testlight",
+            "diagnostics_presentation"
+          ]
+        },
+        {
+          "source": "src/core/queue.ts",
+          "owners": [
+            "bootstrap",
+            "core"
+          ]
+        },
+        {
+          "source": "src/core/registry.ts",
+          "owners": [
+            "bootstrap",
+            "core"
+          ]
+        },
+        {
+          "source": "src/core/release.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "aps",
+            "creative",
+            "datadome",
+            "didomi",
+            "google_tag_manager",
+            "gpt",
+            "gpt_diagnostics",
+            "lockr",
+            "osano_consent",
+            "permutive_context",
+            "sourcepoint_consent",
+            "prebid",
+            "testlight",
+            "diagnostics_presentation",
+            "gpt_later",
+            "osano_lifecycle",
+            "permutive_lifecycle",
+            "prebid_later",
+            "sourcepoint_lifecycle"
+          ]
+        },
+        {
+          "source": "src/core/trace.ts",
+          "owners": [
+            "core",
+            "gpt_diagnostics"
+          ]
+        },
+        {
+          "source": "src/kernel/contracts/message_protocol.ts",
+          "owners": [
+            "core",
+            "gpt"
+          ]
+        },
+        {
+          "source": "src/kernel/disposable.ts",
+          "owners": [
+            "core",
+            "gpt"
+          ]
+        },
+        {
+          "source": "src/kernel/fallback.ts",
+          "owners": [
+            "bootstrap",
+            "core"
+          ]
+        },
+        {
+          "source": "src/kernel/lifecycle_module.ts",
+          "owners": [
+            "datadome",
+            "didomi",
+            "google_tag_manager",
+            "lockr",
+            "testlight"
+          ]
+        },
+        {
+          "source": "src/kernel/release_catalog.ts",
+          "owners": [
+            "bootstrap",
+            "core",
+            "datadome",
+            "didomi",
+            "google_tag_manager",
+            "lockr",
+            "testlight"
+          ]
+        },
+        {
+          "source": "src/shared/dom_insertion_dispatcher.ts",
+          "owners": [
+            "datadome",
+            "google_tag_manager",
+            "gpt",
+            "lockr",
+            "permutive_context",
+            "sourcepoint_consent"
+          ]
+        },
+        {
+          "source": "src/shared/origin.ts",
+          "owners": [
+            "core",
+            "creative"
+          ]
+        },
+        {
+          "source": "src/shared/realm.ts",
+          "owners": [
+            "gpt_diagnostics",
+            "diagnostics_presentation"
+          ]
+        },
+        {
+          "source": "src/shared/script_guard.ts",
+          "owners": [
+            "datadome",
+            "google_tag_manager",
+            "gpt",
+            "lockr",
+            "permutive_context",
+            "sourcepoint_consent"
+          ]
+        }
+      ]
+    },
+    "sets": {
+      "bootstrap": {
+        "artifactIds": [
+          "bootstrap"
+        ],
+        "files": [
+          "gpt-bootstrap-fallback.js"
+        ],
+        "rawBytes": 42838,
+        "gzipBytes": 12000,
+        "brotliBytes": 10652,
+        "sha256": "cfc25ea32119a0193bb2ace190b61be255b488157ca8ceef64347676d10193d9"
+      },
+      "minimal": {
+        "artifactIds": [
+          "core",
+          "render_runtime"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js"
+        ],
+        "rawBytes": 218042,
+        "gzipBytes": 58973,
+        "brotliBytes": 49660,
+        "sha256": "e015d3147557b8084ba42ea9a0b625c28950c4fbbd09322666404b883fabf974"
+      },
+      "reference": {
+        "artifactIds": [
+          "core",
+          "render_runtime",
+          "creative",
+          "gpt",
+          "prebid",
+          "datadome"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js",
+          "tsjs-creative.js",
+          "tsjs-gpt.js",
+          "tsjs-prebid.js",
+          "tsjs-datadome.js"
+        ],
+        "rawBytes": 454795,
+        "gzipBytes": 124552,
+        "brotliBytes": 96460,
+        "sha256": "b7ee65c7fddc813e895840d92d10c14e01d1f0ca09d95c9d2a8654f33ba57e52"
+      },
+      "maximal": {
+        "artifactIds": [
+          "core",
+          "render_runtime",
+          "aps",
+          "creative",
+          "datadome",
+          "didomi",
+          "google_tag_manager",
+          "gpt",
+          "gpt_diagnostics",
+          "lockr",
+          "osano_consent",
+          "permutive_context",
+          "sourcepoint_consent",
+          "prebid",
+          "testlight",
+          "diagnostics_presentation",
+          "gpt_later",
+          "osano_lifecycle",
+          "permutive_lifecycle",
+          "prebid_later",
+          "sourcepoint_lifecycle"
+        ],
+        "files": [
+          "tsjs-core.js",
+          "tsjs-render_runtime.js",
+          "tsjs-aps.js",
+          "tsjs-creative.js",
+          "tsjs-datadome.js",
+          "tsjs-didomi.js",
+          "tsjs-google_tag_manager.js",
+          "tsjs-gpt.js",
+          "tsjs-gpt_diagnostics.js",
+          "tsjs-lockr.js",
+          "tsjs-osano_consent.js",
+          "tsjs-permutive_context.js",
+          "tsjs-sourcepoint_consent.js",
+          "tsjs-prebid.js",
+          "tsjs-testlight.js",
+          "tsjs-diagnostics_presentation.js",
+          "tsjs-gpt_later.js",
+          "tsjs-osano_lifecycle.js",
+          "tsjs-permutive_lifecycle.js",
+          "tsjs-prebid_later.js",
+          "tsjs-sourcepoint_lifecycle.js"
+        ],
+        "rawBytes": 698320,
+        "gzipBytes": 172718,
+        "brotliBytes": 124679,
+        "sha256": "9a2c29b5e7054ca4bcfa49ca0493a8de5b75a1891739b6febaaa4c7aa3b5d99c"
+      }
+    }
+  }
+}
diff --git a/crates/trusted-server-js/lib/test/helpers/legacy_gpt_registration.ts b/crates/trusted-server-js/lib/test/helpers/legacy_gpt_registration.ts
new file mode 100644
index 000000000..f6a6e2675
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/helpers/legacy_gpt_registration.ts
@@ -0,0 +1,84 @@
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  IntegrationRegistration,
+} from '../../src/kernel/integration_registry';
+import { installGptGuard, resetGuardState } from '../../src/integrations/gpt/script_guard';
+
+interface TestGptRuntime {
+  readonly activate: () => () => void;
+  readonly start: (config: unknown) => void;
+}
+
+function recursivelyFrozen(candidate: unknown, seen = new Set<object>()): boolean {
+  if (candidate === null || (typeof candidate !== 'object' && typeof candidate !== 'function')) {
+    return typeof candidate !== 'number' || Number.isFinite(candidate);
+  }
+  if (seen.has(candidate) || !Object.isFrozen(candidate)) return false;
+  const prototype = Object.getPrototypeOf(candidate);
+  if (
+    prototype !== Object.prototype &&
+    prototype !== null &&
+    !(Array.isArray(candidate) && prototype === Array.prototype)
+  ) {
+    return false;
+  }
+  seen.add(candidate);
+  try {
+    return Reflect.ownKeys(candidate).every((key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+      return (
+        descriptor !== undefined &&
+        'value' in descriptor &&
+        recursivelyFrozen(descriptor.value, seen)
+      );
+    });
+  } catch {
+    return false;
+  }
+}
+
+function runtime(interfaces: Readonly<Record<string, unknown>>): TestGptRuntime | undefined {
+  const candidate = interfaces['gpt'];
+  if (
+    typeof candidate !== 'object' ||
+    candidate === null ||
+    !Object.isFrozen(candidate) ||
+    typeof (candidate as TestGptRuntime).activate !== 'function' ||
+    typeof (candidate as TestGptRuntime).start !== 'function'
+  ) {
+    return undefined;
+  }
+  return candidate as TestGptRuntime;
+}
+
+/** Legacy composition seam retained only in tests; never reachable from a shipped entry point. */
+export function createLegacyGptRegistrationForTest(releaseId: string): IntegrationRegistration {
+  const prepare = ({ config, interfaces }: IntegrationPrepareContext) => {
+    if (!recursivelyFrozen(config)) throw new TypeError('GPT integration config is invalid');
+    const preparedRuntime = runtime(interfaces);
+    if (!preparedRuntime) throw new TypeError('GPT integration runtime is unavailable');
+    return Object.freeze({
+      activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+        onDispose(resetGuardState);
+        const releaseHolder: { current?: () => void } = {};
+        onDispose(() => releaseHolder.current?.());
+        const release = preparedRuntime.activate();
+        if (typeof release !== 'function') {
+          throw new TypeError('GPT integration activation disposer is unavailable');
+        }
+        releaseHolder.current = release;
+        installGptGuard();
+        afterCommit(() => preparedRuntime.start(config));
+      },
+    });
+  };
+  return Object.freeze({
+    abi: 1,
+    id: 'gpt',
+    phase: 'takeover',
+    releaseId,
+    prepareSync: prepare,
+    prepare,
+  });
+}
diff --git a/crates/trusted-server-js/lib/test/integrations/aps/documents.test.ts b/crates/trusted-server-js/lib/test/integrations/aps/documents.test.ts
new file mode 100644
index 000000000..2f091e8d5
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/aps/documents.test.ts
@@ -0,0 +1,364 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import envelopeFixture from '../../fixtures/aps-renderer-v1.json';
+import type { ApsRendererV1 } from '../../../src/core/types';
+import { parseApsDocumentEnvelopeV1 } from '../../../src/core/contracts/aps_renderer';
+import {
+  APS_IFRAME_INNER_CSP,
+  APS_IFRAME_OUTER_CSP,
+  APS_PERMANENT_SANDBOX,
+  APS_SCRIPT_INNER_CSP,
+  APS_SCRIPT_OUTER_CSP,
+  MAX_APS_CONTAINER_DOCUMENT_BYTES,
+  MAX_APS_INNER_DOCUMENT_BYTES,
+  generateApsDataDocumentsV1,
+} from '../../../src/integrations/aps/documents';
+
+const publisherOrigin = 'https://publisher.example';
+const creativeOrigin = 'https://creative.example';
+const bootstrapNonce = `b1_${'b'.repeat(22)}`;
+const rendererNonce = `n1_${'n'.repeat(22)}`;
+
+function encodeEnvelope(value: unknown): string {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+function renderer(tagType: 'iframe' | 'script' = 'iframe'): ApsRendererV1 {
+  const envelope = structuredClone(envelopeFixture);
+  envelope.seatbid[0]!.bid[0]!.ext.tagtype = tagType;
+  const bid = envelope.seatbid[0]!.bid[0]!;
+  return {
+    type: 'aps',
+    version: 1,
+    accountId: 'document-account',
+    bidId: bid.id,
+    creativeId: 'document-creative',
+    tagType,
+    creativeUrl: bid.ext.creativeurl,
+    width: bid.w,
+    height: bid.h,
+    aaxResponse: encodeEnvelope(envelope),
+  };
+}
+
+function decodeDataDocument(url: string, nonce: string): string {
+  const prefix = 'data:text/html;charset=utf-8,';
+  const suffix = `#${nonce}`;
+  expect(url.startsWith(prefix)).toBe(true);
+  expect(url.endsWith(suffix)).toBe(true);
+  return decodeURIComponent(url.slice(prefix.length, -suffix.length));
+}
+
+function inlineScript(documentSource: string): string {
+  const start = documentSource.indexOf('<script>');
+  const end = documentSource.lastIndexOf('</script>');
+  if (start < 0 || end <= start) throw new Error('document should contain one inline script');
+  return documentSource.slice(start + '<script>'.length, end);
+}
+
+function executeDocumentScript(
+  documentSource: string,
+  bindings: Readonly<Record<string, unknown>>
+): void {
+  const names = Object.keys(bindings);
+  const run = new Function(...names, inlineScript(documentSource));
+  run(...names.map((name) => bindings[name]));
+}
+
+describe('APS data documents', () => {
+  it('generates detached bounded iframe documents with exact nonces and CSPs', () => {
+    const documents = generateApsDataDocumentsV1({
+      renderer: renderer(),
+      publisherOrigin,
+      bootstrapNonce,
+      rendererNonce,
+    });
+
+    expect(documents).toBeDefined();
+    expect(Object.isFrozen(documents)).toBe(true);
+    expect(documents?.sandbox).toBe(APS_PERMANENT_SANDBOX);
+    expect(documents?.outerCsp).toBe(APS_IFRAME_OUTER_CSP(publisherOrigin, creativeOrigin));
+    expect(documents?.innerCsp).toBe(APS_IFRAME_INNER_CSP(publisherOrigin, creativeOrigin));
+    expect(decodeDataDocument(documents!.outerUrl, bootstrapNonce)).toBe(documents?.outerDocument);
+    expect(decodeDataDocument(documents!.innerUrl, rendererNonce)).toBe(documents?.innerDocument);
+    expect(new TextEncoder().encode(documents?.outerDocument).byteLength).toBeLessThanOrEqual(
+      MAX_APS_CONTAINER_DOCUMENT_BYTES
+    );
+    expect(new TextEncoder().encode(documents?.innerDocument).byteLength).toBeLessThanOrEqual(
+      MAX_APS_INNER_DOCUMENT_BYTES
+    );
+    expect(documents?.outerDocument).toContain(bootstrapNonce);
+    expect(documents?.outerDocument).toContain(rendererNonce);
+    expect(documents?.outerDocument).toContain(encodeURIComponent(documents!.innerDocument));
+    expect(documents?.outerDocument).not.toContain('fictional-bid-1');
+    expect(documents?.outerDocument).not.toContain('/render');
+    expect(documents?.outerDocument).not.toMatch(/__TS_[A-Z0-9_]+__/);
+    expect(documents?.innerDocument).not.toMatch(/__TS_[A-Z0-9_]+__/);
+    expect(documents?.outerCsp).not.toContain(
+      `script-src 'unsafe-inline' ${publisherOrigin} ${creativeOrigin}`
+    );
+  });
+
+  it('adds the validated creative origin to script-src only for script creatives', () => {
+    const documents = generateApsDataDocumentsV1({
+      renderer: renderer('script'),
+      publisherOrigin,
+      bootstrapNonce,
+      rendererNonce,
+    });
+
+    expect(documents?.outerCsp).toBe(APS_SCRIPT_OUTER_CSP(publisherOrigin, creativeOrigin));
+    expect(documents?.innerCsp).toBe(APS_SCRIPT_INNER_CSP(publisherOrigin, creativeOrigin));
+    expect(documents?.outerCsp).toContain(
+      `script-src 'unsafe-inline' ${publisherOrigin} ${creativeOrigin}`
+    );
+    expect(documents?.innerCsp).toContain(
+      `script-src 'unsafe-inline' ${publisherOrigin} ${creativeOrigin}`
+    );
+  });
+
+  it('binds one exact inner window and transfers opposite channel endpoints', () => {
+    const documents = generateApsDataDocumentsV1({
+      renderer: renderer(),
+      publisherOrigin,
+      bootstrapNonce,
+      rendererNonce,
+    });
+    if (!documents) throw new Error('expected generated documents');
+    let receive: ((event: Record<string, unknown>) => void) | undefined;
+    const innerWindow = { postMessage: vi.fn() };
+    const frame = {
+      contentWindow: innerWindow,
+      setAttribute: vi.fn(),
+      src: '',
+    };
+    const parentWindow = { postMessage: vi.fn() };
+    const port1 = { close: vi.fn() };
+    const port2 = { close: vi.fn() };
+    class FakeMessageChannel {
+      readonly port1 = port1;
+      readonly port2 = port2;
+    }
+    executeDocumentScript(documents.outerDocument, {
+      document: {
+        createElement: () => frame,
+        body: { appendChild: vi.fn() },
+      },
+      location: { hash: `#${bootstrapNonce}`, pathname: '', search: '' },
+      history: { replaceState: vi.fn() },
+      parent: parentWindow,
+      MessageChannel: FakeMessageChannel,
+      TextEncoder,
+      addEventListener: (_type: string, listener: (event: Record<string, unknown>) => void) => {
+        receive = listener;
+      },
+      removeEventListener: vi.fn(),
+    });
+
+    expect(frame.src).toBe(documents.innerUrl);
+    expect(frame.setAttribute).toHaveBeenCalledWith('sandbox', APS_PERMANENT_SANDBOX);
+    receive?.({
+      source: {},
+      origin: 'null',
+      ports: [],
+      data: JSON.stringify({ message: 'TS APS Inner Ready', version: 1, rendererNonce }),
+    });
+    expect(parentWindow.postMessage).not.toHaveBeenCalled();
+    receive?.({
+      source: innerWindow,
+      origin: 'null',
+      ports: [],
+      data: JSON.stringify({ message: 'TS APS Inner Ready', version: 1, rendererNonce }),
+    });
+    expect(innerWindow.postMessage).toHaveBeenCalledWith(
+      JSON.stringify({ message: 'TS APS Inner Bind', version: 1, rendererNonce }),
+      '*',
+      [port1]
+    );
+    expect(parentWindow.postMessage).toHaveBeenCalledWith(
+      JSON.stringify({
+        message: 'TS APS Container Ready',
+        version: 1,
+        bootstrapNonce,
+        rendererNonce,
+      }),
+      '*',
+      [port2]
+    );
+    receive?.({
+      source: innerWindow,
+      origin: 'null',
+      ports: [],
+      data: JSON.stringify({ message: 'TS APS Inner Ready', version: 1, rendererNonce }),
+    });
+    expect(parentWindow.postMessage).toHaveBeenCalledOnce();
+  });
+
+  it('accepts one exact port envelope and completes only after runner load and callback', async () => {
+    const source = renderer();
+    const documents = generateApsDataDocumentsV1({
+      renderer: source,
+      publisherOrigin,
+      bootstrapNonce,
+      rendererNonce,
+    });
+    if (!documents) throw new Error('expected generated documents');
+    let receive: ((event: Record<string, unknown>) => void) | undefined;
+    let appendedScript: Record<string, unknown> | undefined;
+    const parentWindow = { postMessage: vi.fn() };
+    const port = {
+      close: vi.fn(),
+      onmessage: undefined as ((event: { data: unknown }) => void) | null | undefined,
+      onmessageerror: undefined as (() => void) | undefined,
+      postMessage: vi.fn(),
+      start: vi.fn(),
+    };
+    const innerWindow: { _aps?: Map<string, { queue: CustomEvent[] }> } = {};
+    executeDocumentScript(documents.innerDocument, {
+      window: innerWindow,
+      document: {
+        createElement: () => ({}),
+        head: {
+          appendChild: (script: Record<string, unknown>) => {
+            appendedScript = script;
+          },
+        },
+      },
+      location: { hash: `#${rendererNonce}`, pathname: '', search: '' },
+      history: { replaceState: vi.fn() },
+      parent: parentWindow,
+      TextEncoder,
+      TextDecoder,
+      URL,
+      atob,
+      btoa,
+      addEventListener: (_type: string, listener: (event: Record<string, unknown>) => void) => {
+        receive = listener;
+      },
+      removeEventListener: vi.fn(),
+    });
+
+    expect(parentWindow.postMessage).toHaveBeenCalledWith(
+      JSON.stringify({ message: 'TS APS Inner Ready', version: 1, rendererNonce }),
+      '*'
+    );
+    receive?.({
+      source: parentWindow,
+      origin: 'null',
+      ports: [port],
+      data: JSON.stringify({ message: 'TS APS Inner Bind', version: 1, rendererNonce }),
+    });
+    expect(port.start).toHaveBeenCalledOnce();
+    const receiveEnvelope = port.onmessage;
+    receiveEnvelope?.({
+      data: { version: 1, nonce: rendererNonce, publisherOrigin, renderer: source },
+    });
+
+    expect(port.postMessage).toHaveBeenCalledWith({
+      message: 'TS APS Document Accepted',
+      version: 1,
+      nonce: rendererNonce,
+    });
+    expect(appendedScript?.['src']).toBe(`${publisherOrigin}/integrations/aps/runner.js`);
+    expect(appendedScript?.['crossOrigin']).toBe('anonymous');
+    expect(appendedScript?.['referrerPolicy']).toBe('no-referrer');
+    expect(port.postMessage).not.toHaveBeenCalledWith(
+      expect.objectContaining({ message: 'TS APS Render Completed' })
+    );
+    (appendedScript?.['onload'] as (() => void) | undefined)?.();
+    expect(port.postMessage).toHaveBeenCalledWith({
+      message: 'TS APS Runner Loaded',
+      version: 1,
+      nonce: rendererNonce,
+    });
+    const event = innerWindow._aps?.get(source.accountId)?.queue[0];
+    expect(event?.type).toBe('prebid/creative/render');
+    (event?.detail as { resolve?: () => void } | undefined)?.resolve?.();
+    await Promise.resolve();
+    expect(port.postMessage).toHaveBeenCalledWith({
+      message: 'TS APS Render Completed',
+      version: 1,
+      nonce: rendererNonce,
+    });
+    expect(port.close).toHaveBeenCalledOnce();
+  });
+
+  it('fails closed for crossed capabilities, unsafe origins, and invalid descriptors', () => {
+    const valid = renderer();
+    for (const candidate of [
+      { renderer: valid, publisherOrigin, bootstrapNonce: rendererNonce, rendererNonce },
+      { renderer: valid, publisherOrigin, bootstrapNonce, rendererNonce: bootstrapNonce },
+      {
+        renderer: valid,
+        publisherOrigin: 'http://publisher.example',
+        bootstrapNonce,
+        rendererNonce,
+      },
+      {
+        renderer: { ...valid, creativeUrl: publisherOrigin },
+        publisherOrigin,
+        bootstrapNonce,
+        rendererNonce,
+      },
+      {
+        renderer: { ...valid, unknown: true },
+        publisherOrigin,
+        bootstrapNonce,
+        rendererNonce,
+      },
+    ]) {
+      expect(generateApsDataDocumentsV1(candidate)).toBeUndefined();
+    }
+  });
+});
+
+describe('APS document envelope', () => {
+  it('copies and freezes one exact nonce- and origin-bound envelope', () => {
+    const source = renderer();
+    const parsed = parseApsDocumentEnvelopeV1(
+      { version: 1, nonce: rendererNonce, publisherOrigin, renderer: source },
+      rendererNonce,
+      publisherOrigin
+    );
+
+    expect(parsed).toEqual({ version: 1, nonce: rendererNonce, publisherOrigin, renderer: source });
+    expect(Object.isFrozen(parsed)).toBe(true);
+    expect(Object.isFrozen(parsed?.renderer)).toBe(true);
+    expect(parsed?.renderer).not.toBe(source);
+  });
+
+  it('rejects unknown keys, accessors, wrong prototypes, nonces, origins, and descriptors', () => {
+    const source = renderer();
+    const accessor = { version: 1, nonce: rendererNonce, publisherOrigin } as Record<
+      string,
+      unknown
+    >;
+    Object.defineProperty(accessor, 'renderer', {
+      enumerable: true,
+      get: () => source,
+    });
+    for (const candidate of [
+      { version: 1, nonce: rendererNonce, publisherOrigin, renderer: source, extra: true },
+      Object.assign(Object.create({ inherited: true }), {
+        version: 1,
+        nonce: rendererNonce,
+        publisherOrigin,
+        renderer: source,
+      }),
+      accessor,
+      { version: 1, nonce: `n1_${'x'.repeat(22)}`, publisherOrigin, renderer: source },
+      {
+        version: 1,
+        nonce: rendererNonce,
+        publisherOrigin: 'https://wrong.example',
+        renderer: source,
+      },
+      { version: 1, nonce: rendererNonce, publisherOrigin, renderer: { ...source, version: 2 } },
+    ]) {
+      expect(parseApsDocumentEnvelopeV1(candidate, rendererNonce, publisherOrigin)).toBeUndefined();
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/aps/module.test.ts b/crates/trusted-server-js/lib/test/integrations/aps/module.test.ts
new file mode 100644
index 000000000..4912702b2
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/aps/module.test.ts
@@ -0,0 +1,133 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createApsIntegrationRegistration } from '../../../src/integrations/aps/module';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+import {
+  createArtifactHostPositionLeaseRegistry,
+  type RenderAttempt,
+} from '../../../src/services/render';
+import type { PucApsMountInput } from '../../../src/services/puc_bridge';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+describe('APS provider', () => {
+  it('prepares inertly, registers exact owned state during activation, and removes it on rollback', () => {
+    const preparationRelease: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    let registeredRenderer:
+      ((attempt: RenderAttempt, container: HTMLElement) => boolean) | undefined;
+    let registeredValidation: Readonly<Record<string, unknown>> | undefined;
+    const releaseRenderer = vi.fn(() => {
+      registeredRenderer = undefined;
+    });
+    const releaseValidation = vi.fn(() => {
+      registeredValidation = undefined;
+    });
+    const render = Object.freeze({
+      bindArtifactGuard: vi.fn(() => true),
+      bootstrapNonces: Object.freeze({}),
+      hostPositions: createArtifactHostPositionLeaseRegistry(),
+      publisherOrigin: window.location.origin,
+      rendererNonces: Object.freeze({}),
+      registerRenderer: vi.fn(
+        (_type: 'aps', renderer: (attempt: RenderAttempt, container: HTMLElement) => boolean) => {
+          registeredRenderer = renderer;
+          return releaseRenderer;
+        }
+      ),
+    });
+    const messages = Object.freeze({
+      messaging: Object.freeze({}),
+      registerApsValidation: vi.fn((validation: Readonly<Record<string, unknown>>) => {
+        registeredValidation = validation;
+        return releaseValidation;
+      }),
+    });
+    const registration = createApsIntegrationRegistration(RELEASE_ID);
+    const prepared = registration.prepare(
+      Object.freeze({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({ 'render.v1': render, 'messages.v1': messages }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => preparationRelease.push(callback),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+    const aps = prepared.interfaces?.['aps.v1'] as {
+      render: (attempt: RenderAttempt, container: HTMLElement) => boolean;
+      renderPuc: (input: PucApsMountInput) => boolean;
+    };
+
+    expect(Object.isFrozen(aps)).toBe(true);
+    expect(render.registerRenderer).not.toHaveBeenCalled();
+    expect(messages.registerApsValidation).not.toHaveBeenCalled();
+    expect(aps.render({} as RenderAttempt, document.createElement('div'))).toBe(false);
+    expect(aps.renderPuc({} as PucApsMountInput)).toBe(false);
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    expect(render.registerRenderer).toHaveBeenCalledOnce();
+    expect(messages.registerApsValidation).toHaveBeenCalledOnce();
+    expect(registeredRenderer).toBe(aps.render);
+    expect(registeredValidation).toMatchObject({
+      expectedPublisherOrigin: window.location.origin,
+      expectedRendererUrl: new URL('/integrations/aps/renderer/v2', window.location.origin).href,
+    });
+
+    activationRelease.reverse().forEach((callback) => callback());
+    expect(releaseRenderer).toHaveBeenCalledOnce();
+    expect(releaseValidation).toHaveBeenCalledOnce();
+    expect(registeredRenderer).toBeUndefined();
+    expect(registeredValidation).toBeUndefined();
+    expect(aps.render({} as RenderAttempt, document.createElement('div'))).toBe(false);
+    expect(aps.renderPuc({} as PucApsMountInput)).toBe(false);
+    preparationRelease.reverse().forEach((callback) => callback());
+  });
+
+  it('pre-registers rollback before either activation mutation can throw', () => {
+    const activationRelease: Array<() => void> = [];
+    const releaseValidation = vi.fn();
+    const render = Object.freeze({
+      bindArtifactGuard: vi.fn(() => true),
+      bootstrapNonces: Object.freeze({}),
+      hostPositions: createArtifactHostPositionLeaseRegistry(),
+      publisherOrigin: window.location.origin,
+      rendererNonces: Object.freeze({}),
+      registerRenderer: vi.fn(() => {
+        throw new Error('renderer collision');
+      }),
+    });
+    const messages = Object.freeze({
+      messaging: Object.freeze({}),
+      registerApsValidation: vi.fn(() => releaseValidation),
+    });
+    const prepared = createApsIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({ 'render.v1': render, 'messages.v1': messages }),
+        signal: new AbortController().signal,
+        onDispose: vi.fn(),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+
+    expect(() =>
+      prepared.activate(
+        Object.freeze({
+          signal: new AbortController().signal,
+          onDispose: (callback: () => void) => activationRelease.push(callback),
+          afterCommit: vi.fn(),
+        } satisfies IntegrationActivationContext)
+      )
+    ).toThrow('renderer collision');
+    activationRelease.reverse().forEach((callback) => callback());
+    expect(releaseValidation).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/aps/render.test.ts b/crates/trusted-server-js/lib/test/integrations/aps/render.test.ts
index d9a92742b..747d5149f 100644
--- a/crates/trusted-server-js/lib/test/integrations/aps/render.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/aps/render.test.ts
@@ -1,39 +1,15 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
+import corpusFixture from '../../fixtures/aps-renderer-v1-corpus.json';
 import envelope from '../../fixtures/aps-renderer-v1.json';
 import type { ApsRendererV1 } from '../../../src/core/types';
-import { log } from '../../../src/core/log';
+import { classifyApsRendererV1 } from '../../../src/core/contracts/generated/renderer_validator_v1';
 import {
-  APS_NATIVE_RENDERER_TIMEOUT_MS,
-  APS_PREBID_CREATIVE_RUNNER_URL,
-  APS_RENDERER_PATH,
-  APS_RENDERER_SANDBOX,
-  APS_RENDERING_MODE_ATTRIBUTE_NAME,
-  APS_UNIVERSAL_CREATIVE_RENDERER,
-  APS_UNIVERSAL_CREATIVE_RENDERER_VERSION,
-  apsRendererUrl,
-  dispatchApsRendering as dispatchDefaultApsRendering,
-  getApsPrebidRenderer,
   parseApsRendererDescriptor,
-  registerApsPrebidRenderer,
-  renderApsCreative,
+  prepareApsRenderSource,
   validateApsRenderer,
 } from '../../../src/integrations/aps/render';
 
-function nativeRunnerState(frame: HTMLIFrameElement): {
-  runner: HTMLScriptElement;
-  event: CustomEvent<{ aaxResponse: string; seatBidId: string }>;
-} {
-  const runner = frame.contentDocument?.querySelector<HTMLScriptElement>('script');
-  const frameWindow = frame.contentWindow as unknown as {
-    _aps: Map<string, { queue: Array<CustomEvent<{ aaxResponse: string; seatBidId: string }>> }>;
-  };
-  const account = frameWindow._aps.get('example-account-id');
-  expect(runner).not.toBeNull();
-  expect(account?.queue).toHaveLength(1);
-  return { runner: runner!, event: account!.queue[0] };
-}
-
 function encodeBytes(bytes: Uint8Array): string {
   let binary = '';
   for (const byte of bytes) binary += String.fromCharCode(byte);
@@ -52,7 +28,7 @@ function encodeEnvelopeAtSize(size: number): string {
 }
 
 function descriptor(overrides: Partial<ApsRendererV1> = {}): ApsRendererV1 {
-  const bid = envelope.seatbid[0].bid[0];
+  const bid = envelope.seatbid[0]!.bid[0]!;
   return {
     type: 'aps',
     version: 1,
@@ -68,7 +44,265 @@ function descriptor(overrides: Partial<ApsRendererV1> = {}): ApsRendererV1 {
   };
 }
 
+type CorpusResult =
+  'accepted' | 'descriptor_invalid' | 'invalid_dimensions' | 'dimensions_out_of_range';
+
+interface CorpusVector {
+  id: string;
+  expected: CorpusResult;
+  operation: Record<string, unknown>;
+}
+
+interface RendererCorpus {
+  publisherOrigin: string;
+  baseDescriptor: Record<string, unknown>;
+  vectors: CorpusVector[];
+}
+
+interface MaterializedCorpusVector {
+  id: string;
+  expected: CorpusResult;
+  publisherOrigin: string;
+  descriptor: Record<string, unknown>;
+}
+
+const rendererCorpus = corpusFixture as unknown as RendererCorpus;
+
+function mutableRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function jsonPathParent(
+  root: unknown,
+  path: readonly (string | number)[]
+): { parent: unknown; key: string | number } {
+  if (path.length === 0) throw new Error('corpus path should not be empty');
+  let parent = root;
+  for (const segment of path.slice(0, -1)) {
+    if (typeof segment === 'number') {
+      if (!Array.isArray(parent)) throw new Error('corpus numeric path should address an array');
+      parent = parent[segment];
+    } else {
+      if (!mutableRecord(parent)) throw new Error('corpus string path should address an object');
+      parent = parent[segment];
+    }
+  }
+  const key = path[path.length - 1];
+  if (key === undefined) throw new Error('corpus path should have a final key');
+  return { parent, key };
+}
+
+function setJsonPath(root: unknown, path: readonly (string | number)[], value: unknown): void {
+  const { parent, key } = jsonPathParent(root, path);
+  if (typeof key === 'number') {
+    if (!Array.isArray(parent)) throw new Error('corpus numeric key should address an array');
+    parent[key] = value;
+    return;
+  }
+  if (!mutableRecord(parent)) throw new Error('corpus string key should address an object');
+  parent[key] = value;
+}
+
+function deleteJsonPath(root: unknown, path: readonly (string | number)[]): void {
+  const { parent, key } = jsonPathParent(root, path);
+  if (typeof key !== 'string' || !mutableRecord(parent)) {
+    throw new Error('corpus delete should address an object field');
+  }
+  delete parent[key];
+}
+
+function operationString(operation: Record<string, unknown>, field: string): string {
+  const value = operation[field];
+  if (typeof value !== 'string') throw new Error(`corpus ${field} should be a string`);
+  return value;
+}
+
+function operationNumber(operation: Record<string, unknown>, field: string): number {
+  const value = operation[field];
+  if (typeof value !== 'number') throw new Error(`corpus ${field} should be a number`);
+  return value;
+}
+
+function operationPath(operation: Record<string, unknown>): Array<string | number> {
+  const value = operation.path;
+  if (
+    !Array.isArray(value) ||
+    !value.every((segment) => typeof segment === 'string' || typeof segment === 'number')
+  ) {
+    throw new Error('corpus path should contain only string and number segments');
+  }
+  return value;
+}
+
+function materializeCorpusVector(vector: CorpusVector): MaterializedCorpusVector {
+  const descriptor = structuredClone(rendererCorpus.baseDescriptor);
+  const decodedEnvelope = structuredClone(envelope) as unknown;
+  const operation = vector.operation;
+  const kind = operationString(operation, 'kind');
+  let encodedEnvelope: string | undefined;
+
+  switch (kind) {
+    case 'none':
+      break;
+    case 'descriptor-delete':
+      delete descriptor[operationString(operation, 'field')];
+      break;
+    case 'descriptor-set':
+      descriptor[operationString(operation, 'field')] = operation.value;
+      break;
+    case 'descriptor-repeat': {
+      const repeated =
+        operationString(operation, 'unit').repeat(operationNumber(operation, 'count')) +
+        (typeof operation.suffix === 'string' ? operation.suffix : '');
+      descriptor[operationString(operation, 'field')] = repeated;
+      break;
+    }
+    case 'bid-id-repeat': {
+      const repeated =
+        operationString(operation, 'unit').repeat(operationNumber(operation, 'count')) +
+        (typeof operation.suffix === 'string' ? operation.suffix : '');
+      descriptor.bidId = repeated;
+      setJsonPath(decodedEnvelope, ['seatbid', 0, 'bid', 0, 'id'], repeated);
+      break;
+    }
+    case 'dimension': {
+      const field = operationString(operation, 'field');
+      if (field !== 'width' && field !== 'height') {
+        throw new Error('corpus dimension field should be width or height');
+      }
+      descriptor[field] = operation.value;
+      setJsonPath(
+        decodedEnvelope,
+        ['seatbid', 0, 'bid', 0, field === 'width' ? 'w' : 'h'],
+        operation.value
+      );
+      break;
+    }
+    case 'dimensions':
+      descriptor.width = operation.width;
+      descriptor.height = operation.height;
+      setJsonPath(decodedEnvelope, ['seatbid', 0, 'bid', 0, 'w'], operation.width);
+      setJsonPath(decodedEnvelope, ['seatbid', 0, 'bid', 0, 'h'], operation.height);
+      break;
+    case 'creative-url': {
+      const value = operationString(operation, 'value');
+      descriptor.creativeUrl = value;
+      setJsonPath(decodedEnvelope, ['seatbid', 0, 'bid', 0, 'ext', 'creativeurl'], value);
+      break;
+    }
+    case 'creative-url-bytes': {
+      const prefix = 'https://creative.example/';
+      const value = prefix + 'a'.repeat(operationNumber(operation, 'bytes') - prefix.length);
+      descriptor.creativeUrl = value;
+      setJsonPath(decodedEnvelope, ['seatbid', 0, 'bid', 0, 'ext', 'creativeurl'], value);
+      break;
+    }
+    case 'aax-literal':
+      encodedEnvelope = operationString(operation, 'value');
+      break;
+    case 'aax-bytes': {
+      const values = operation.values;
+      if (!Array.isArray(values) || !values.every((value) => Number.isInteger(value))) {
+        throw new Error('corpus byte vector should contain integers');
+      }
+      encodedEnvelope = encodeBytes(Uint8Array.from(values as number[]));
+      break;
+    }
+    case 'aax-raw-json':
+      encodedEnvelope = encodeBytes(new TextEncoder().encode(operationString(operation, 'value')));
+      break;
+    case 'aax-decoded-bytes': {
+      const serialized = JSON.stringify(decodedEnvelope);
+      const target = operationNumber(operation, 'bytes');
+      if (serialized.length > target) throw new Error('corpus decoded size is below fixture size');
+      encodedEnvelope = encodeBytes(
+        new TextEncoder().encode(serialized + ' '.repeat(target - serialized.length))
+      );
+      break;
+    }
+    case 'aax-raw-price': {
+      const serialized = JSON.stringify(decodedEnvelope);
+      const price = operationString(operation, 'value');
+      const raw = serialized.replace('"price":1.23', `"price":${price}`);
+      if (raw === serialized) throw new Error('corpus should replace the fixture price');
+      encodedEnvelope = encodeBytes(new TextEncoder().encode(raw));
+      break;
+    }
+    case 'envelope-set':
+      setJsonPath(decodedEnvelope, operationPath(operation), operation.value);
+      break;
+    case 'envelope-delete':
+      deleteJsonPath(decodedEnvelope, operationPath(operation));
+      break;
+    case 'duplicate-seat': {
+      if (!mutableRecord(decodedEnvelope) || !Array.isArray(decodedEnvelope.seatbid)) {
+        throw new Error('corpus fixture should contain seatbid');
+      }
+      decodedEnvelope.seatbid.push(structuredClone(decodedEnvelope.seatbid[0]));
+      break;
+    }
+    case 'duplicate-bid': {
+      const seatbid = mutableRecord(decodedEnvelope) ? decodedEnvelope.seatbid : undefined;
+      const seat = Array.isArray(seatbid) ? seatbid[0] : undefined;
+      const bids = mutableRecord(seat) ? seat.bid : undefined;
+      if (!Array.isArray(bids)) throw new Error('corpus fixture should contain a bid array');
+      bids.push(structuredClone(bids[0]));
+      break;
+    }
+    default:
+      throw new Error(`unknown APS renderer corpus operation: ${kind}`);
+  }
+
+  descriptor.aaxResponse = encodedEnvelope ?? encodeEnvelope(decodedEnvelope);
+  return {
+    id: vector.id,
+    expected: vector.expected,
+    publisherOrigin: rendererCorpus.publisherOrigin,
+    descriptor,
+  };
+}
+
 describe('APS renderer validation', () => {
+  it('prepares a copied frozen tagged source without retaining projection input', () => {
+    const input = descriptor();
+    const prepared = prepareApsRenderSource(input);
+
+    expect(prepared).toEqual(input);
+    expect(prepared).not.toBe(input);
+    expect(Object.isFrozen(prepared)).toBe(true);
+    input.width = 1;
+    expect(prepared?.width).toBe(300);
+  });
+
+  it('prepares a cached validated source after Object.freeze is poisoned', () => {
+    const validated = validateApsRenderer(descriptor());
+    if (!validated) throw new Error('Expected a validated renderer');
+    const originalFreeze = Object.freeze;
+    let prepared: ReturnType<typeof prepareApsRenderSource> | undefined;
+    let thrown: unknown;
+    Object.freeze = function poisonedFreeze() {
+      throw new Error('poisoned Object.freeze');
+    };
+    try {
+      prepared = prepareApsRenderSource(validated);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      Object.freeze = originalFreeze;
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(prepared).toBe(validated);
+    expect(Object.isFrozen(prepared)).toBe(true);
+  });
+
+  it('matches every shared cross-language contract vector', () => {
+    for (const vector of rendererCorpus.vectors.map(materializeCorpusVector)) {
+      const actual = classifyApsRendererV1(vector.descriptor, vector.publisherOrigin);
+      expect(actual, vector.id).toBe(vector.expected);
+    }
+  });
+
   it('consumes the shared fictional golden envelope and supports an omitted creative ID', () => {
     const withCreativeId = descriptor();
     const withoutCreativeId = descriptor();
@@ -111,19 +345,19 @@ describe('APS renderer validation', () => {
     ['sibling seat', { seatbid: [...envelope.seatbid, envelope.seatbid[0]] }],
     [
       'sibling bid',
-      { seatbid: [{ bid: [...envelope.seatbid[0].bid, envelope.seatbid[0].bid[0]] }] },
+      { seatbid: [{ bid: [...envelope.seatbid[0]!.bid, envelope.seatbid[0]!.bid[0]!] }] },
     ],
     [
       'markup',
       {
         seatbid: [
-          { bid: [{ ...envelope.seatbid[0].bid[0], adm: '<script>forbidden()</script>' }] },
+          { bid: [{ ...envelope.seatbid[0]!.bid[0]!, adm: '<script>forbidden()</script>' }] },
         ],
       },
     ],
     [
       'notification',
-      { seatbid: [{ bid: [{ ...envelope.seatbid[0].bid[0], nurl: 'https://notify.example' }] }] },
+      { seatbid: [{ bid: [{ ...envelope.seatbid[0]!.bid[0]!, nurl: 'https://notify.example' }] }] },
     ],
     [
       'unknown extension',
@@ -132,8 +366,8 @@ describe('APS renderer validation', () => {
           {
             bid: [
               {
-                ...envelope.seatbid[0].bid[0],
-                ext: { ...envelope.seatbid[0].bid[0].ext, userSyncs: [] },
+                ...envelope.seatbid[0]!.bid[0]!,
+                ext: { ...envelope.seatbid[0]!.bid[0]!.ext, userSyncs: [] },
               },
             ],
           },
@@ -171,8 +405,8 @@ describe('APS renderer validation', () => {
     const canonical = encodeBytes(new TextEncoder().encode(`${JSON.stringify(envelope)} `));
     const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
     const finalDataIndex = canonical.length - 3;
-    const canonicalIndex = alphabet.indexOf(canonical[finalDataIndex]);
-    const nonCanonical = `${canonical.slice(0, finalDataIndex)}${alphabet[canonicalIndex + 1]}==`;
+    const canonicalIndex = alphabet.indexOf(canonical[finalDataIndex]!);
+    const nonCanonical = `${canonical.slice(0, finalDataIndex)}${alphabet[canonicalIndex + 1]!}==`;
 
     expect(atob(nonCanonical)).toBe(atob(canonical));
     expect(validateApsRenderer(descriptor({ aaxResponse: canonical }))).toBeDefined();
@@ -185,7 +419,7 @@ describe('APS renderer validation', () => {
     `${window.location.origin}/creative`,
   ])('rejects an unsafe creative URL', (creativeUrl) => {
     const invalidEnvelope = structuredClone(envelope);
-    invalidEnvelope.seatbid[0].bid[0].ext.creativeurl = creativeUrl;
+    invalidEnvelope.seatbid[0]!.bid[0]!.ext.creativeurl = creativeUrl;
     expect(
       validateApsRenderer(descriptor({ creativeUrl, aaxResponse: encodeEnvelope(invalidEnvelope) }))
     ).toBeUndefined();
@@ -210,9 +444,9 @@ describe('APS renderer validation', () => {
     const atLimit = `${prefix}${'a'.repeat(4096 - prefix.length)}`;
     const overLimit = `${atLimit}x`;
     const atLimitEnvelope = structuredClone(envelope);
-    atLimitEnvelope.seatbid[0].bid[0].ext.creativeurl = atLimit;
+    atLimitEnvelope.seatbid[0]!.bid[0]!.ext.creativeurl = atLimit;
     const overLimitEnvelope = structuredClone(envelope);
-    overLimitEnvelope.seatbid[0].bid[0].ext.creativeurl = overLimit;
+    overLimitEnvelope.seatbid[0]!.bid[0]!.ext.creativeurl = overLimit;
 
     expect(
       validateApsRenderer(
@@ -239,568 +473,3 @@ describe('APS renderer validation', () => {
     ).toBeUndefined();
   });
 });
-
-describe('Prebid APS renderer registry', () => {
-  afterEach(() => {
-    delete window.tsjs;
-  });
-
-  it('bounds entries and evicts the oldest capability', () => {
-    for (let index = 0; index <= 256; index += 1) {
-      expect(
-        registerApsPrebidRenderer(`prebid-${index}`, 'fictional-slot', descriptor(), 300, {
-          markUsed: vi.fn(),
-        })
-      ).toBe(true);
-    }
-
-    expect(Object.keys(window.tsjs?.apsPrebidRenderers ?? {})).toHaveLength(256);
-    expect(getApsPrebidRenderer('prebid-0')).toBeUndefined();
-    expect(getApsPrebidRenderer('prebid-256')).toEqual(
-      expect.objectContaining({ adUnitCode: 'fictional-slot', renderer: descriptor() })
-    );
-  });
-
-  it('rejects unsafe Prebid IDs and invalid descriptors', () => {
-    const lifecycle = { markUsed: vi.fn() };
-    expect(
-      registerApsPrebidRenderer('__proto__', 'fictional-slot', descriptor(), 300, lifecycle)
-    ).toBe(false);
-    expect(
-      registerApsPrebidRenderer(
-        'safe-prebid-id',
-        'fictional-slot',
-        descriptor({ aaxResponse: 'invalid' }),
-        300,
-        lifecycle
-      )
-    ).toBe(false);
-    expect(window.tsjs?.apsPrebidRenderers).toBeUndefined();
-  });
-});
-
-describe('APS rendering-mode authorization', () => {
-  it('ignores mode markers and duplicate script tags injected after module initialization', () => {
-    document.body.innerHTML = '<div id="fictional-slot"></div>';
-    document.head.insertAdjacentHTML(
-      'beforeend',
-      '<meta name="trusted-server-aps-rendering-mode" content="publisher_native">' +
-        '<script data-ts-aps-rendering-mode="publisher_native"></script>'
-    );
-    const trustedServer = vi.fn(() => true);
-
-    expect(
-      dispatchDefaultApsRendering({
-        slotId: 'fictional-slot',
-        renderer: descriptor(),
-        trustedServer,
-      })
-    ).toBe(true);
-    expect(trustedServer).toHaveBeenCalledOnce();
-    expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-
-    document.head
-      .querySelectorAll(
-        'meta[name="trusted-server-aps-rendering-mode"], script[data-ts-aps-rendering-mode]'
-      )
-      .forEach((element) => element.remove());
-    document.body.innerHTML = '';
-  });
-});
-
-describe('publisher-native APS runner contract tests', () => {
-  let dispatchApsRendering: typeof dispatchDefaultApsRendering;
-
-  beforeEach(async () => {
-    vi.resetModules();
-    document.body.innerHTML = '<div id="fictional-slot"><span>existing</span></div>';
-    const publisherScript = document.createElement('script');
-    publisherScript.setAttribute(APS_RENDERING_MODE_ATTRIBUTE_NAME, 'publisher_native');
-    const currentScriptSpy = vi
-      .spyOn(document, 'currentScript', 'get')
-      .mockReturnValue(publisherScript);
-    ({ dispatchApsRendering } = await import('../../../src/integrations/aps/render'));
-    currentScriptSpy.mockRestore();
-  });
-
-  afterEach(() => {
-    delete window.tsjs;
-    vi.restoreAllMocks();
-    document.body.innerHTML = '';
-  });
-
-  it('queues the exact selected response for the fixed APS runner and commits on load', async () => {
-    const trustedServer = vi.fn(() => true);
-    const accepted = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor(),
-      trustedServer,
-    });
-    const slot = document.getElementById('fictional-slot')!;
-    const frame = slot.querySelector('iframe')!;
-    const { runner, event } = nativeRunnerState(frame);
-
-    expect(frame.getAttribute('sandbox')).toBeNull();
-    expect(frame.style.display).toBe('none');
-    expect(runner.src).toBe(APS_PREBID_CREATIVE_RUNNER_URL);
-    expect(event.type).toBe('prebid/creative/render');
-    expect(event.detail).toEqual({
-      aaxResponse: descriptor().aaxResponse,
-      seatBidId: descriptor().bidId,
-    });
-    expect(slot.querySelector('span')).not.toBeNull();
-    expect(trustedServer).not.toHaveBeenCalled();
-
-    const runnerDocument = frame.contentDocument!;
-    expect(runnerDocument.querySelector('meta[name="referrer"]')?.getAttribute('content')).toBe(
-      'no-referrer'
-    );
-    expect(runnerDocument.documentElement.style.margin).toBe('0px');
-    expect(runnerDocument.documentElement.style.padding).toBe('0px');
-    expect(runnerDocument.body.style.margin).toBe('0px');
-    expect(runnerDocument.body.style.padding).toBe('0px');
-    const creativeFrame = runnerDocument.createElement('iframe');
-    runnerDocument.body.appendChild(creativeFrame);
-    await vi.waitFor(() => expect(creativeFrame.style.display).toBe('block'));
-
-    runner.dispatchEvent(new Event('load'));
-    await expect(accepted).resolves.toBe(true);
-    expect(slot.querySelector('span')).toBeNull();
-    expect(frame.style.display).toBe('');
-  });
-
-  it('fails closed when the runner fails without clearing publisher content', async () => {
-    const trustedServer = vi.fn(() => true);
-    const accepted = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor(),
-      trustedServer,
-    });
-    const frame = document.querySelector<HTMLIFrameElement>('#fictional-slot iframe')!;
-    const { runner } = nativeRunnerState(frame);
-
-    runner.dispatchEvent(new Event('error'));
-
-    await expect(accepted).resolves.toBe(false);
-    expect(trustedServer).not.toHaveBeenCalled();
-    expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-    expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-  });
-
-  it('cancels a pending runner when a newer dispatch replaces it', async () => {
-    const first = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor(),
-      trustedServer: () => true,
-    });
-    const firstFrame = document.querySelector<HTMLIFrameElement>('#fictional-slot iframe')!;
-
-    const second = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor(),
-      trustedServer: () => true,
-    });
-    const secondFrame = document.querySelector<HTMLIFrameElement>('#fictional-slot iframe')!;
-
-    expect(firstFrame.isConnected).toBe(false);
-    expect(secondFrame).not.toBe(firstFrame);
-    await expect(first).resolves.toBe(false);
-    nativeRunnerState(secondFrame).runner.dispatchEvent(new Event('load'));
-    await expect(second).resolves.toBe(true);
-  });
-
-  it('lets an invalid replacement cancel an older pending runner', async () => {
-    const first = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor(),
-      trustedServer: () => true,
-    });
-    const second = dispatchApsRendering({
-      slotId: 'fictional-slot',
-      renderer: descriptor({ aaxResponse: 'invalid' }),
-      trustedServer: () => true,
-    });
-
-    expect(second).toBe(false);
-    await expect(first).resolves.toBe(false);
-    expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-    expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-  });
-
-  it('resolves a logical GPT slot through the injected div mapping', async () => {
-    document.body.innerHTML = '<div id="div-header"><span>existing</span></div>';
-    window.tsjs = { divToSlotId: { 'div-header': 'homepage_header' } } as typeof window.tsjs;
-
-    const accepted = dispatchApsRendering({
-      slotId: 'homepage_header',
-      renderer: descriptor(),
-      trustedServer: () => true,
-    });
-    const frame = document.querySelector<HTMLIFrameElement>('#div-header iframe')!;
-    nativeRunnerState(frame).runner.dispatchEvent(new Event('load'));
-
-    await expect(accepted).resolves.toBe(true);
-    expect(document.querySelector('#div-header span')).toBeNull();
-  });
-
-  it('renders inside the inner slot when Prebid uses its container ID', async () => {
-    document.body.innerHTML =
-      '<div id="div-header-container"><div id="div-header"><iframe></iframe></div></div>';
-    const source = document.querySelector<HTMLIFrameElement>('#div-header > iframe')!.contentWindow;
-
-    const accepted = dispatchApsRendering({
-      slotId: 'div-header-container',
-      renderer: descriptor(),
-      source,
-      trustedServer: () => true,
-    });
-    const frame = Array.from(
-      document.querySelectorAll<HTMLIFrameElement>('#div-header > iframe')
-    ).find((candidate) => candidate.title === 'Ad content')!;
-    nativeRunnerState(frame).runner.dispatchEvent(new Event('load'));
-
-    await expect(accepted).resolves.toBe(true);
-    expect(document.getElementById('div-header-container')).not.toBeNull();
-    expect(document.getElementById('div-header')).not.toBeNull();
-    expect(document.querySelectorAll('#div-header > iframe')).toHaveLength(1);
-  });
-
-  it('uses the requesting frame to resolve a dynamic slot prefix', async () => {
-    document.body.innerHTML =
-      '<div id="div-header-first"><iframe></iframe></div>' +
-      '<div id="div-header-second"><iframe></iframe></div>';
-    const source = document.querySelector<HTMLIFrameElement>(
-      '#div-header-second > iframe'
-    )!.contentWindow;
-
-    const accepted = dispatchApsRendering({
-      slotId: 'div-header-',
-      renderer: descriptor(),
-      source,
-      trustedServer: () => true,
-    });
-    const frame = Array.from(
-      document.querySelectorAll<HTMLIFrameElement>('#div-header-second > iframe')
-    ).find((candidate) => candidate.title === 'Ad content')!;
-    nativeRunnerState(frame).runner.dispatchEvent(new Event('load'));
-
-    await expect(accepted).resolves.toBe(true);
-    expect(document.querySelector('#div-header-first > iframe')).not.toBeNull();
-    expect(document.querySelectorAll('#div-header-second > iframe')).toHaveLength(1);
-  });
-
-  it('contains throwing publisher slot mappings without falling back', async () => {
-    const tsjs = {} as NonNullable<typeof window.tsjs>;
-    Object.defineProperty(tsjs, 'divToSlotId', {
-      get: () => {
-        throw new Error('fictional mapping lookup failure');
-      },
-    });
-    window.tsjs = tsjs;
-    const trustedServer = vi.fn(() => true);
-
-    await expect(
-      dispatchApsRendering({
-        slotId: 'logical-slot',
-        renderer: descriptor(),
-        trustedServer,
-      })
-    ).resolves.toBe(false);
-    expect(trustedServer).not.toHaveBeenCalled();
-    expect(document.querySelector('iframe')).toBeNull();
-  });
-
-  it('times out an unacknowledged runner without clearing publisher content', async () => {
-    vi.useFakeTimers();
-    try {
-      const result = dispatchApsRendering({
-        slotId: 'fictional-slot',
-        renderer: descriptor(),
-        trustedServer: () => true,
-      });
-      await vi.advanceTimersByTimeAsync(APS_NATIVE_RENDERER_TIMEOUT_MS);
-
-      await expect(result).resolves.toBe(false);
-      expect(vi.getTimerCount()).toBe(0);
-      expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-      expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-describe('direct APS rendering', () => {
-  beforeEach(() => {
-    document.body.innerHTML = '<div id="fictional-slot"><span>existing</span></div>';
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    document.body.innerHTML = '';
-  });
-
-  it('keeps a valid default frame when an invalid replacement is rejected', () => {
-    const trustedServer = (renderer: ApsRendererV1): boolean =>
-      renderApsCreative({ slotId: 'fictional-slot', renderer });
-    expect(
-      dispatchDefaultApsRendering({
-        slotId: 'fictional-slot',
-        renderer: descriptor(),
-        trustedServer,
-      })
-    ).toBe(true);
-
-    const slot = document.getElementById('fictional-slot')!;
-    const iframe = slot.querySelector('iframe')!;
-    const postMessage = vi.spyOn(iframe.contentWindow!, 'postMessage');
-    iframe.dispatchEvent(new Event('load'));
-    const sent = postMessage.mock.calls[0][0] as { nonce: string };
-
-    expect(
-      dispatchDefaultApsRendering({
-        slotId: 'fictional-slot',
-        renderer: descriptor({ aaxResponse: 'invalid' }),
-        trustedServer,
-      })
-    ).toBe(false);
-    expect(iframe.isConnected).toBe(true);
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-        source: iframe.contentWindow,
-      })
-    );
-    expect(slot.querySelector('span')).toBeNull();
-    expect(iframe.style.display).toBe('');
-  });
-
-  it('loads the static route with a fragment-bound 128-bit nonce and opaque sandbox', () => {
-    expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-
-    const slot = document.getElementById('fictional-slot')!;
-    const iframe = slot.querySelector('iframe')!;
-    const existing = slot.querySelector('span');
-    expect(existing).not.toBeNull();
-    expect(iframe.src).toMatch(/\/integrations\/aps\/renderer#tsaps=[A-Za-z0-9_-]{22}$/);
-    expect(iframe.getAttribute('sandbox')).toBe(APS_RENDERER_SANDBOX);
-    expect(iframe.getAttribute('sandbox')).not.toContain('allow-same-origin');
-    expect(iframe.srcdoc).toBe('');
-
-    const postMessage = vi.spyOn(iframe.contentWindow!, 'postMessage');
-    iframe.dispatchEvent(new Event('load'));
-
-    expect(slot.querySelector('span')).not.toBeNull();
-    expect(iframe.style.display).toBe('none');
-    expect(postMessage).toHaveBeenCalledTimes(1);
-    expect(postMessage).toHaveBeenCalledWith(
-      {
-        nonce: expect.stringMatching(/^[A-Za-z0-9_-]{22}$/),
-        renderer: descriptor(),
-      },
-      '*'
-    );
-
-    const message = postMessage.mock.calls[0][0] as { nonce: string };
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: {
-          message: 'trusted-server/aps/renderer-ready',
-          nonce: `wrong-${message.nonce}`,
-        },
-        source: iframe.contentWindow,
-      })
-    );
-    expect(slot.querySelector('span')).not.toBeNull();
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { message: 'trusted-server/aps/renderer-ready', nonce: message.nonce },
-        source: iframe.contentWindow,
-      })
-    );
-    expect(slot.querySelector('span')).toBeNull();
-    expect(iframe.style.display).toBe('');
-  });
-
-  it('rejects a ready message with the correct nonce from a foreign window', () => {
-    expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-
-    const slot = document.getElementById('fictional-slot')!;
-    const rendererFrame = slot.querySelector('iframe')!;
-    const postMessage = vi.spyOn(rendererFrame.contentWindow!, 'postMessage');
-    rendererFrame.dispatchEvent(new Event('load'));
-    const sent = postMessage.mock.calls[0][0] as { nonce: string };
-    const foreignFrame = document.createElement('iframe');
-    document.body.appendChild(foreignFrame);
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-        source: foreignFrame.contentWindow,
-      })
-    );
-
-    expect(slot.querySelector('span')).not.toBeNull();
-    expect(rendererFrame.style.display).toBe('none');
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-        source: rendererFrame.contentWindow,
-      })
-    );
-
-    expect(slot.querySelector('span')).toBeNull();
-    expect(rendererFrame.style.display).toBe('');
-  });
-
-  it('leaves existing slot content intact when validation or loading fails', () => {
-    expect(
-      renderApsCreative({
-        slotId: 'fictional-slot',
-        renderer: descriptor({ aaxResponse: 'invalid' }),
-      })
-    ).toBe(false);
-    expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-    expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-
-    expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-    const iframe = document.querySelector('#fictional-slot iframe')!;
-    iframe.dispatchEvent(new Event('error'));
-    expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-    expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-  });
-
-  it('removes an unacknowledged frame without clearing publisher content', () => {
-    vi.useFakeTimers();
-    try {
-      expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-      const iframe = document.querySelector('#fictional-slot iframe')!;
-      iframe.dispatchEvent(new Event('load'));
-
-      vi.advanceTimersByTime(10_000);
-
-      expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-      expect(document.querySelector('#fictional-slot iframe')).toBeNull();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('immediately cancels a superseded pending frame and its timeout', () => {
-    vi.useFakeTimers();
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-    try {
-      const baselineTimers = vi.getTimerCount();
-      expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-      const firstFrame = document.querySelector('#fictional-slot iframe')!;
-      const firstPostMessage = vi.spyOn(firstFrame.contentWindow!, 'postMessage');
-      firstFrame.dispatchEvent(new Event('load'));
-      const firstSent = firstPostMessage.mock.calls[0][0] as { nonce: string };
-      const timersAfterFirst = vi.getTimerCount();
-      expect(timersAfterFirst).toBeGreaterThan(baselineTimers);
-
-      expect(renderApsCreative({ slotId: 'fictional-slot', renderer: descriptor() })).toBe(true);
-      const secondFrame = document.querySelector('#fictional-slot iframe')!;
-      expect(firstFrame.isConnected).toBe(false);
-      expect(vi.getTimerCount()).toBe(timersAfterFirst);
-      const postMessage = vi.spyOn(secondFrame.contentWindow!, 'postMessage');
-      secondFrame.dispatchEvent(new Event('load'));
-      const sent = postMessage.mock.calls[0][0] as { nonce: string };
-
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: { message: 'trusted-server/aps/renderer-ready', nonce: firstSent.nonce },
-          source: firstFrame.contentWindow,
-        })
-      );
-      expect(document.querySelector('#fictional-slot span')).not.toBeNull();
-      expect((secondFrame as HTMLIFrameElement).style.display).toBe('none');
-
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-          source: secondFrame.contentWindow,
-        })
-      );
-
-      vi.advanceTimersByTime(10_000);
-      expect(warnSpy).not.toHaveBeenCalled();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-});
-
-describe('Universal Creative APS source', () => {
-  it('uses the deployed dynamic renderer protocol and only creates the opaque route frame', () => {
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER_VERSION).toBeGreaterThanOrEqual(4);
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).toContain('window.render=function');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).toContain('d&&d.apsRenderer');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).toContain('d&&d.rendererUrl');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).toContain(APS_RENDERER_PATH);
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).toContain(APS_RENDERER_SANDBOX);
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('allow-same-origin');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('srcdoc');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('document.write');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('creativeUrl');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('aaxResponse');
-    expect(APS_UNIVERSAL_CREATIVE_RENDERER).not.toContain('example-account-id');
-  });
-
-  it('computes an absolute renderer URL from the publisher origin', () => {
-    expect(apsRendererUrl()).toBe(new URL(APS_RENDERER_PATH, window.location.origin).href);
-    expect(apsRendererUrl('http://publisher.example')).toBe(
-      `http://publisher.example${APS_RENDERER_PATH}`
-    );
-    expect(apsRendererUrl('not an origin')).toBeUndefined();
-  });
-
-  it('creates the opaque route frame and resolves only after the bound acknowledgement', async () => {
-    const dynamicWindow = window as unknown as {
-      render?: (data: Record<string, unknown>, helper: unknown, target: Window) => Promise<void>;
-    };
-    window.eval(APS_UNIVERSAL_CREATIVE_RENDERER);
-
-    try {
-      const renderer = descriptor();
-      const rendered = dynamicWindow.render!(
-        {
-          apsRenderer: renderer,
-          rendererUrl: apsRendererUrl(),
-        },
-        undefined,
-        window
-      );
-      const iframe = document.body.querySelector('iframe')!;
-      expect(iframe.src).toMatch(/\/integrations\/aps\/renderer#tsaps=[A-Za-z0-9_-]{22}$/);
-      expect(iframe.getAttribute('sandbox')).toBe(APS_RENDERER_SANDBOX);
-      expect(iframe.getAttribute('sandbox')).not.toContain('allow-same-origin');
-
-      const postMessage = vi.spyOn(iframe.contentWindow!, 'postMessage');
-      iframe.dispatchEvent(new Event('load'));
-      const sent = postMessage.mock.calls[0][0] as { nonce: string; renderer: ApsRendererV1 };
-      expect(sent.renderer).toEqual(renderer);
-
-      let settled = false;
-      void rendered.then(() => {
-        settled = true;
-      });
-      await Promise.resolve();
-      expect(settled).toBe(false);
-
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-          source: iframe.contentWindow,
-        })
-      );
-      await expect(rendered).resolves.toBeUndefined();
-    } finally {
-      delete dynamicWindow.render;
-      document.body.innerHTML = '';
-    }
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/click.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/click.test.ts
index 85a231553..024f24475 100644
--- a/crates/trusted-server-js/lib/test/integrations/creative/click.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/creative/click.test.ts
@@ -1,6 +1,12 @@
 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 
-import { FIRST_PARTY_CLICK, MUTATED_CLICK, PROXY_RESPONSE, importCreativeModule } from './helpers';
+import {
+  FIRST_PARTY_CLICK,
+  MUTATED_CLICK,
+  PROXY_RESPONSE,
+  activateCreativeRuntime,
+  disposeImportedCreativeModule,
+} from './helpers';
 
 const ORIGINAL_FETCH = global.fetch;
 
@@ -11,15 +17,47 @@ const REBUILD_PREFIX = absolute('/first-party/proxy-rebuild?');
 
 describe('creative/click.ts', () => {
   beforeEach(() => {
+    disposeImportedCreativeModule();
     vi.resetModules();
     document.body.innerHTML = '';
   });
 
   afterEach(() => {
+    disposeImportedCreativeModule();
     global.fetch = ORIGINAL_FETCH;
     vi.useRealTimers();
   });
 
+  it('owns click listeners and defers the baseline scan until requested', async () => {
+    vi.useFakeTimers();
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ href: PROXY_RESPONSE }),
+    });
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const anchor = document.createElement('a');
+    anchor.setAttribute('data-tsclick', FIRST_PARTY_CLICK);
+    anchor.setAttribute('href', MUTATED_CLICK);
+    document.body.appendChild(anchor);
+    const removeEventListener = vi.spyOn(document, 'removeEventListener');
+    const { installClickGuard } = await import('../../../src/integrations/creative/click');
+
+    const handle = installClickGuard(false);
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+    expect(fetchMock).not.toHaveBeenCalled();
+
+    handle.scan();
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+
+    handle.dispose();
+    handle.dispose();
+    expect(removeEventListener.mock.calls.filter(([type]) => type === 'click')).toHaveLength(1);
+    expect(removeEventListener.mock.calls.filter(([type]) => type === 'auxclick')).toHaveLength(1);
+  });
+
   it('repairs anchors via proxy rebuild fallback when fetch is unavailable', async () => {
     vi.useFakeTimers();
     global.fetch = undefined as unknown as typeof fetch;
@@ -29,7 +67,7 @@ describe('creative/click.ts', () => {
     anchor.setAttribute('href', FIRST_PARTY_CLICK);
     document.body.appendChild(anchor);
 
-    await importCreativeModule();
+    await activateCreativeRuntime();
 
     anchor.setAttribute('href', MUTATED_CLICK);
 
@@ -56,7 +94,7 @@ describe('creative/click.ts', () => {
     anchor.setAttribute('href', FIRST_PARTY_CLICK);
     document.body.appendChild(anchor);
 
-    await importCreativeModule();
+    await activateCreativeRuntime();
 
     anchor.setAttribute('href', MUTATED_CLICK);
 
@@ -64,7 +102,7 @@ describe('creative/click.ts', () => {
     await vi.runAllTimersAsync();
 
     expect(fetchMock).toHaveBeenCalled();
-    const call = fetchMock.mock.calls[0];
+    const call = fetchMock.mock.calls[0]!;
     expect(call[0]).toBe('/first-party/proxy-rebuild');
     const payload = JSON.parse(call[1]?.body as string);
     expect(payload).toEqual({
@@ -74,37 +112,27 @@ describe('creative/click.ts', () => {
     });
 
     expect(anchor.getAttribute('href')).toBe(absolute(PROXY_RESPONSE));
-    // data-tsclick keeps the server's root-relative shape: it is echoed back as
-    // the rebuild payload's `tsclick`, which the server parses as a click path.
     expect(anchor.getAttribute('data-tsclick')).toBe(PROXY_RESPONSE);
   });
 
   it('sends a root-relative tsclick on a second rebuild after a successful one', async () => {
-    // Regression: persisting an absolute canonical click made the next rebuild
-    // POST a value the server rejects as an invalid click path, so the second
-    // mutation was silently lost on non-opaque consumers.
     vi.useFakeTimers();
-
     const fetchMock = vi.fn().mockResolvedValue({
       ok: true,
       json: async () => ({ href: PROXY_RESPONSE }),
     });
     global.fetch = fetchMock as unknown as typeof fetch;
-
     const anchor = document.createElement('a');
     anchor.setAttribute('data-tsclick', FIRST_PARTY_CLICK);
     anchor.setAttribute('href', FIRST_PARTY_CLICK);
     document.body.appendChild(anchor);
 
-    await importCreativeModule();
-
+    await activateCreativeRuntime();
     anchor.setAttribute('href', MUTATED_CLICK);
     await Promise.resolve();
     await vi.runAllTimersAsync();
-
     expect(anchor.getAttribute('data-tsclick')).toBe(PROXY_RESPONSE);
 
-    // A second mutation now diffs against the rebuilt canonical click.
     anchor.setAttribute('href', 'https://example.com/landing?baz=3');
     await Promise.resolve();
     await vi.runAllTimersAsync();
@@ -113,11 +141,9 @@ describe('creative/click.ts', () => {
     const payloads = fetchMock.mock.calls.map(
       (call) => JSON.parse(call[1]?.body as string) as { tsclick: string }
     );
-    // Every payload must carry the server's root-relative click form: an
-    // absolute one is rejected as an invalid click path.
-    for (const payload of payloads) {
-      expect(payload.tsclick.startsWith('/first-party/click?')).toBe(true);
-    }
+    expect(payloads.every((payload) => payload.tsclick.startsWith('/first-party/click?'))).toBe(
+      true
+    );
     expect(payloads.some((payload) => payload.tsclick === PROXY_RESPONSE)).toBe(true);
   });
 
@@ -142,7 +168,7 @@ describe('creative/click.ts', () => {
       anchor.setAttribute('href', FIRST_PARTY_CLICK);
       document.body.appendChild(anchor);
 
-      await importCreativeModule();
+      await activateCreativeRuntime();
 
       anchor.setAttribute('href', MUTATED_CLICK);
 
@@ -182,7 +208,7 @@ describe('creative/click.ts', () => {
       anchor.setAttribute('href', FIRST_PARTY_CLICK);
       document.body.appendChild(anchor);
 
-      await importCreativeModule();
+      await activateCreativeRuntime();
 
       anchor.setAttribute('href', MUTATED_CLICK);
       await Promise.resolve();
@@ -231,7 +257,7 @@ describe('creative/click.ts', () => {
       anchor.setAttribute('target', '_blank');
       document.body.appendChild(anchor);
 
-      await importCreativeModule();
+      await activateCreativeRuntime();
 
       // Wave 1: creative mutates the link, observer repairs it.
       anchor.setAttribute('href', MUTATED_CLICK);
@@ -247,7 +273,7 @@ describe('creative/click.ts', () => {
       await vi.runAllTimersAsync();
 
       expect(openMock).toHaveBeenCalled();
-      const navigated = String(openMock.mock.calls[0][0]);
+      const navigated = String(openMock.mock.calls[0]![0]);
       expect(navigated.startsWith(REBUILD_PREFIX)).toBe(true);
       expect(navigated).toContain('add=%7B%22bar%22%3A%222%22%7D');
       expect(navigated).not.toBe(absolute(FIRST_PARTY_CLICK));
@@ -261,17 +287,62 @@ describe('creative/click.ts', () => {
     }
   });
 
-  it('navigates an over-long rebuild through a form POST instead of a GET URL', async () => {
-    // Fastly rejects request URLs over 8192 bytes before the handler runs, and
-    // a signed click with many tracking params exceeds that once nested in
-    // another query string. A form body has no such bound, and a submission is
-    // a navigation — so it is not blocked by CORS from the opaque origin.
+  it('does not reuse an opaque rebuild from a disposed guard generation', async () => {
     vi.useFakeTimers();
-
+    const nextClick =
+      '/first-party/click?tsurl=https%3A%2F%2Fexample.com%2Fnext&wave=2&tstoken=nexttoken';
     const originDescriptor = Object.getOwnPropertyDescriptor(window, 'origin');
     Object.defineProperty(window, 'origin', { value: 'null', configurable: true });
     global.fetch = undefined as unknown as typeof fetch;
+    const openMock = vi.fn();
+    const originalOpen = window.open;
+    window.open = openMock as unknown as typeof window.open;
+    let firstGeneration: { dispose(): void; scan(): void } | undefined;
+    let secondGeneration: { dispose(): void; scan(): void } | undefined;
+
+    try {
+      const anchor = document.createElement('a');
+      anchor.setAttribute('data-tsclick', FIRST_PARTY_CLICK);
+      anchor.setAttribute('href', MUTATED_CLICK);
+      anchor.setAttribute('target', '_blank');
+      document.body.appendChild(anchor);
+      const { installClickGuard } = await import('../../../src/integrations/creative/click');
 
+      firstGeneration = installClickGuard(false);
+      firstGeneration.scan();
+      await Promise.resolve();
+      await vi.runAllTimersAsync();
+      const firstFallback = anchor.getAttribute('href') ?? '';
+      expect(firstFallback.startsWith(REBUILD_PREFIX)).toBe(true);
+
+      firstGeneration.dispose();
+      anchor.setAttribute('data-tsclick', nextClick);
+      expect(anchor.getAttribute('href')).toBe(firstFallback);
+
+      secondGeneration = installClickGuard(false);
+      anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+      await Promise.resolve();
+      await vi.runAllTimersAsync();
+
+      expect(openMock).toHaveBeenCalledWith(absolute(nextClick), '_blank', 'noopener,noreferrer');
+      expect(openMock).not.toHaveBeenCalledWith(firstFallback, '_blank', 'noopener,noreferrer');
+    } finally {
+      secondGeneration?.dispose();
+      firstGeneration?.dispose();
+      window.open = originalOpen;
+      if (originDescriptor) {
+        Object.defineProperty(window, 'origin', originDescriptor);
+      } else {
+        delete (window as { origin?: string }).origin;
+      }
+    }
+  });
+
+  it('navigates an over-long opaque-origin rebuild through a form POST', async () => {
+    vi.useFakeTimers();
+    const originDescriptor = Object.getOwnPropertyDescriptor(window, 'origin');
+    Object.defineProperty(window, 'origin', { value: 'null', configurable: true });
+    global.fetch = undefined as unknown as typeof fetch;
     const submits: HTMLFormElement[] = [];
     const originalSubmit = HTMLFormElement.prototype.submit;
     HTMLFormElement.prototype.submit = function patched(this: HTMLFormElement) {
@@ -279,7 +350,6 @@ describe('creative/click.ts', () => {
     };
 
     try {
-      // A signed click long enough that the nested rebuild URL crosses the cap.
       const filler = 'a'.repeat(6800);
       const longClick = `/first-party/click?tsurl=https%3A%2F%2Fexample.com%2Flanding&foo=1&pad=${filler}&tstoken=token123`;
       const anchor = document.createElement('a');
@@ -287,24 +357,21 @@ describe('creative/click.ts', () => {
       anchor.setAttribute('href', longClick);
       document.body.appendChild(anchor);
 
-      await importCreativeModule();
-
+      await activateCreativeRuntime();
       anchor.setAttribute('href', `https://example.com/landing?pad=${filler}&bar=2`);
       await Promise.resolve();
       await vi.runAllTimersAsync();
-
       anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
       await Promise.resolve();
       await vi.runAllTimersAsync();
 
       expect(submits.length).toBeGreaterThan(0);
       const form = submits[0];
-      expect(form.method.toLowerCase()).toBe('post');
-      expect(form.action).toContain('/first-party/proxy-rebuild');
-      const tsclick = form.querySelector('input[name="tsclick"]') as HTMLInputElement | null;
-      expect(tsclick?.value).toBe(longClick);
-      const add = form.querySelector('input[name="add"]') as HTMLInputElement | null;
-      expect(add?.value).toContain('bar');
+      expect(form?.method.toLowerCase()).toBe('post');
+      expect(form?.action).toContain('/first-party/proxy-rebuild');
+      expect(form?.rel).toBe('noopener noreferrer');
+      expect(form?.querySelector<HTMLInputElement>('input[name="tsclick"]')?.value).toBe(longClick);
+      expect(form?.querySelector<HTMLInputElement>('input[name="add"]')?.value).toContain('bar');
     } finally {
       HTMLFormElement.prototype.submit = originalSubmit;
       if (originDescriptor) {
@@ -315,6 +382,38 @@ describe('creative/click.ts', () => {
     }
   });
 
+  it('does not form-submit a long non-rebuild URL containing the rebuild path', async () => {
+    vi.useFakeTimers();
+    const submits: HTMLFormElement[] = [];
+    const originalSubmit = HTMLFormElement.prototype.submit;
+    HTMLFormElement.prototype.submit = function patched(this: HTMLFormElement) {
+      submits.push(this);
+    };
+    const openMock = vi.fn();
+    const originalOpen = window.open;
+    window.open = openMock as unknown as typeof window.open;
+
+    try {
+      const targetUrl = `/first-party/landing?next=/first-party/proxy-rebuild&tsclick=fictional&pad=${'a'.repeat(7000)}`;
+      const anchor = document.createElement('a');
+      anchor.setAttribute('data-tsclick', targetUrl);
+      anchor.setAttribute('href', targetUrl);
+      anchor.setAttribute('target', '_blank');
+      document.body.appendChild(anchor);
+
+      await activateCreativeRuntime();
+      anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+      await Promise.resolve();
+      await vi.runAllTimersAsync();
+
+      expect(submits).toHaveLength(0);
+      expect(openMock).toHaveBeenCalledWith(absolute(targetUrl), '_blank', 'noopener,noreferrer');
+    } finally {
+      HTMLFormElement.prototype.submit = originalSubmit;
+      window.open = originalOpen;
+    }
+  });
+
   it('refuses to navigate to or persist non-http(s) URLs', async () => {
     // The guard reads creative-controlled attributes; a javascript: value must
     // never reach location.href or an href write.
@@ -326,7 +425,7 @@ describe('creative/click.ts', () => {
     anchor.setAttribute('href', 'javascript:evil()');
     document.body.appendChild(anchor);
 
-    await importCreativeModule();
+    await activateCreativeRuntime();
 
     anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
     await Promise.resolve();
@@ -337,4 +436,96 @@ describe('creative/click.ts', () => {
     // unhandled navigation error is the assertion that location.href was
     // never assigned the javascript: URL.
   });
+
+  it.each([
+    'https://user@example.com/landing',
+    'https://:password@example.com/landing',
+    'https://%75ser:%70assword@example.com/landing',
+  ])('refuses a credential-bearing navigation URL: %s', async (targetUrl) => {
+    vi.useFakeTimers();
+    const openMock = vi.fn();
+    const originalOpen = window.open;
+    window.open = openMock as unknown as typeof window.open;
+    const anchor = document.createElement('a');
+    anchor.setAttribute('data-tsclick', targetUrl);
+    anchor.setAttribute('href', targetUrl);
+    anchor.setAttribute('target', '_blank');
+    document.body.appendChild(anchor);
+
+    try {
+      await activateCreativeRuntime();
+      anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+      await Promise.resolve();
+      await vi.runAllTimersAsync();
+
+      expect(openMock).not.toHaveBeenCalled();
+      expect(anchor.getAttribute('href')).toBe(targetUrl);
+    } finally {
+      window.open = originalOpen;
+    }
+  });
+
+  it.each([
+    ['absolute', 'https://example.com/landing?campaign=fictional'],
+    ['root-relative', '/first-party/landing?campaign=fictional'],
+  ])('preserves valid %s HTTP(S) navigation', async (_caseName, targetUrl) => {
+    vi.useFakeTimers();
+    const openMock = vi.fn();
+    const originalOpen = window.open;
+    window.open = openMock as unknown as typeof window.open;
+    const anchor = document.createElement('a');
+    anchor.setAttribute('data-tsclick', targetUrl);
+    anchor.setAttribute('href', targetUrl);
+    anchor.setAttribute('target', '_blank');
+    document.body.appendChild(anchor);
+
+    try {
+      await activateCreativeRuntime();
+      anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+      await Promise.resolve();
+      await vi.runAllTimersAsync();
+
+      expect(openMock).toHaveBeenCalledWith(absolute(targetUrl), '_blank', 'noopener,noreferrer');
+    } finally {
+      window.open = originalOpen;
+    }
+  });
+
+  it.each(['success', 'error'] as const)(
+    'does not persist a late proxy-rebuild %s after disposal',
+    async (outcome) => {
+      let resolveFetch: ((response: Response) => void) | undefined;
+      let rejectFetch: ((reason: unknown) => void) | undefined;
+      global.fetch = vi.fn(
+        () =>
+          new Promise<Response>((resolve, reject) => {
+            resolveFetch = resolve;
+            rejectFetch = reject;
+          })
+      );
+      const anchor = document.createElement('a');
+      anchor.setAttribute('data-tsclick', FIRST_PARTY_CLICK);
+      anchor.setAttribute('href', MUTATED_CLICK);
+      document.body.appendChild(anchor);
+      const { installClickGuard } = await import('../../../src/integrations/creative/click');
+      const handle = installClickGuard(false);
+
+      handle.scan();
+      await vi.waitFor(() => expect(global.fetch).toHaveBeenCalledTimes(1));
+      handle.dispose();
+      if (outcome === 'success') {
+        resolveFetch?.({
+          ok: true,
+          json: async () => ({ href: PROXY_RESPONSE }),
+        } as Response);
+      } else {
+        rejectFetch?.(new Error('fictional late proxy failure'));
+      }
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(anchor.getAttribute('href')).toBe(MUTATED_CLICK);
+      expect(anchor.getAttribute('data-tsclick')).toBe(FIRST_PARTY_CLICK);
+    }
+  );
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/helpers.ts b/crates/trusted-server-js/lib/test/integrations/creative/helpers.ts
index 176a5e5ab..8e86675fd 100644
--- a/crates/trusted-server-js/lib/test/integrations/creative/helpers.ts
+++ b/crates/trusted-server-js/lib/test/integrations/creative/helpers.ts
@@ -17,19 +17,43 @@ export const MUTATED_CLICK = 'https://example.com/landing?bar=2';
 export const PROXY_RESPONSE =
   '/first-party/click?tsurl=https%3A%2F%2Fexample.com%2Flanding&bar=2&tstoken=newtoken';
 
-import type { TsCreativeConfig } from '../../../src/shared/globals';
+import type { CreativeBootV1 } from '../../../src/core/types';
 
-export async function importCreativeModule(config?: TsCreativeConfig): Promise<void> {
-  const globalRef = globalThis as {
-    __ts_creative_installed?: boolean;
-    tsCreativeConfig?: TsCreativeConfig;
-  };
-  delete globalRef.__ts_creative_installed;
-  if (config) {
-    globalRef.tsCreativeConfig = config;
-  }
-  await import('../../../src/integrations/creative/index');
-  if (config) {
-    delete globalRef.tsCreativeConfig;
-  }
+let disposeLastImportedCreative: (() => void) | undefined;
+
+export function disposeImportedCreativeModule(): void {
+  const dispose = disposeLastImportedCreative;
+  disposeLastImportedCreative = undefined;
+  dispose?.();
+}
+
+export async function activateCreativeRuntime(
+  config: Partial<Pick<CreativeBootV1, 'clickGuard' | 'renderGuard'>> = {}
+): Promise<void> {
+  disposeImportedCreativeModule();
+  const [
+    { installClickGuard },
+    { installDynamicIframeProxy },
+    { installDynamicImageProxy },
+    startup,
+  ] = await Promise.all([
+    import('../../../src/integrations/creative/click'),
+    import('../../../src/integrations/creative/iframe'),
+    import('../../../src/integrations/creative/image'),
+    import('../../../src/integrations/creative/startup'),
+  ]);
+  const boot = Object.freeze({
+    version: 1 as const,
+    enabled: true,
+    clickGuard: config.clickGuard ?? true,
+    renderGuard: config.renderGuard ?? false,
+  });
+  const runtime = startup.createCreativeStartup({
+    document,
+    installClickGuard: () => installClickGuard(false),
+    installDynamicIframeProxy: () => installDynamicIframeProxy(false),
+    installDynamicImageProxy: () => installDynamicImageProxy(false),
+  });
+  disposeLastImportedCreative = runtime.activate(boot);
+  runtime.start(boot);
 }
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/iframe.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/iframe.test.ts
index f4b985532..b9cac6939 100644
--- a/crates/trusted-server-js/lib/test/integrations/creative/iframe.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/creative/iframe.test.ts
@@ -1,16 +1,18 @@
 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 
-import { importCreativeModule, waitForExpect } from './helpers';
+import { activateCreativeRuntime, disposeImportedCreativeModule, waitForExpect } from './helpers';
 
 describe('creative/iframe.ts', () => {
   const ORIGINAL_FETCH = global.fetch;
 
   beforeEach(() => {
+    disposeImportedCreativeModule();
     vi.resetModules();
     document.body.innerHTML = '';
   });
 
   afterEach(() => {
+    disposeImportedCreativeModule();
     global.fetch = ORIGINAL_FETCH;
   });
 
@@ -23,7 +25,7 @@ describe('creative/iframe.ts', () => {
     });
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const iframe = document.createElement('iframe');
     iframe.src = 'https://frame.example/widget.html?cb=1';
@@ -45,7 +47,7 @@ describe('creative/iframe.ts', () => {
     });
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const iframe = document.createElement('iframe');
     iframe.src = 'https://blocked.example.com/rejected.html';
@@ -61,7 +63,7 @@ describe('creative/iframe.ts', () => {
     const fetchMock = vi.fn().mockRejectedValue(new Error('network'));
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const iframe = document.createElement('iframe');
     iframe.src = 'https://frame.example/fallback.html';
@@ -71,4 +73,24 @@ describe('creative/iframe.ts', () => {
       expect(iframe.src).toContain('https://frame.example/fallback.html');
     });
   });
+
+  it('cancels queued and future iframe rewrites on disposal', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ href: '/first-party/proxy?tsurl=iframe&tstoken=token&tsexp=1' }),
+    });
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const { installDynamicIframeProxy } = await import('../../../src/integrations/creative/iframe');
+    const handle = installDynamicIframeProxy(false);
+    const iframe = document.createElement('iframe');
+    iframe.setAttribute('src', 'https://frame.example/queued.html');
+
+    handle.dispose();
+    await Promise.resolve();
+    iframe.setAttribute('src', 'https://frame.example/later.html');
+    await Promise.resolve();
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(iframe.src).toContain('https://frame.example/later.html');
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/image.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/image.test.ts
index 7459d0a11..01cbac0d7 100644
--- a/crates/trusted-server-js/lib/test/integrations/creative/image.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/creative/image.test.ts
@@ -1,16 +1,18 @@
 import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
 
-import { importCreativeModule, waitForExpect } from './helpers';
+import { activateCreativeRuntime, disposeImportedCreativeModule, waitForExpect } from './helpers';
 
 const ORIGINAL_FETCH = global.fetch;
 
 describe('creative/image.ts', () => {
   beforeEach(() => {
+    disposeImportedCreativeModule();
     vi.resetModules();
     document.body.innerHTML = '';
   });
 
   afterEach(() => {
+    disposeImportedCreativeModule();
     global.fetch = ORIGINAL_FETCH;
   });
 
@@ -23,7 +25,7 @@ describe('creative/image.ts', () => {
     });
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const img = new Image();
     img.src = 'https://img.example/pixel.gif?cb=1';
@@ -45,7 +47,7 @@ describe('creative/image.ts', () => {
     });
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const img = new Image();
     img.src = '/existing.png';
@@ -62,7 +64,7 @@ describe('creative/image.ts', () => {
     const fetchMock = vi.fn().mockRejectedValue(new Error('network'));
     global.fetch = fetchMock as unknown as typeof fetch;
 
-    await importCreativeModule({ renderGuard: true });
+    await activateCreativeRuntime({ renderGuard: true });
 
     const img = new Image();
     img.src = 'https://img.example/fallback.png';
@@ -72,4 +74,30 @@ describe('creative/image.ts', () => {
       expect(img.src).toContain('https://img.example/fallback.png');
     });
   });
+
+  it('defers the baseline scan and restores only its exact hooks on disposal', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ href: '/first-party/proxy?tsurl=image&tstoken=token&tsexp=1' }),
+    });
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const image = document.createElement('img');
+    image.setAttribute('src', 'https://img.example/preexisting.png');
+    document.body.appendChild(image);
+    const baselineSrc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
+    const baselineSetAttribute = HTMLImageElement.prototype.setAttribute;
+    const { installDynamicImageProxy } = await import('../../../src/integrations/creative/image');
+
+    const handle = installDynamicImageProxy(false);
+    await Promise.resolve();
+    expect(fetchMock).not.toHaveBeenCalled();
+
+    handle.scan();
+    await waitForExpect(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+    handle.dispose();
+    handle.dispose();
+
+    expect(Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src')).toEqual(baselineSrc);
+    expect(HTMLImageElement.prototype.setAttribute).toBe(baselineSetAttribute);
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/module.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/module.test.ts
new file mode 100644
index 000000000..cbae6e301
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/creative/module.test.ts
@@ -0,0 +1,364 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const ownedGuards = vi.hoisted(() => ({
+  installClick: vi.fn(),
+  installIframe: vi.fn(),
+  installImage: vi.fn(),
+}));
+
+vi.mock('../../../src/integrations/creative/click', () => ({
+  installClickGuard: ownedGuards.installClick,
+}));
+vi.mock('../../../src/integrations/creative/iframe', () => ({
+  installDynamicIframeProxy: ownedGuards.installIframe,
+}));
+vi.mock('../../../src/integrations/creative/image', () => ({
+  installDynamicImageProxy: ownedGuards.installImage,
+}));
+
+import { createCreativeIntegrationRegistration } from '../../../src/integrations/creative/module';
+import {
+  createIntegrationRegistry,
+  type IntegrationInstallCallbacks,
+  type IntegrationRegistration,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+function manifest(ids: readonly string[]) {
+  return {
+    version: 1,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) => ({ id, phase: 'takeover' as const })),
+  };
+}
+
+function catalog(ids: readonly string[]) {
+  return Object.freeze(
+    ids.map((id) =>
+      Object.freeze({
+        id,
+        phase: 'takeover' as const,
+        trigger: null,
+        consumes: Object.freeze(id === 'creative' ? ['runtime.v1'] : []),
+        provides: Object.freeze([]),
+      })
+    )
+  );
+}
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+function registration(
+  id: string,
+  prepare: IntegrationRegistration['prepare']
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id,
+    phase: 'takeover',
+    releaseId: RELEASE_ID,
+    prepareSync: () => Object.freeze({ activate: () => undefined }),
+    prepare,
+  });
+}
+
+function runtimeCapability() {
+  return Object.freeze({ document });
+}
+
+function guard(name: string, order: string[]) {
+  return Object.freeze({
+    dispose: vi.fn(() => order.push(`dispose:${name}`)),
+    scan: vi.fn(() => order.push(`scan:${name}`)),
+  });
+}
+
+describe('transactional creative integration module', () => {
+  beforeEach(() => {
+    ownedGuards.installClick.mockReset();
+    ownedGuards.installIframe.mockReset();
+    ownedGuards.installImage.mockReset();
+  });
+
+  it('prepares inertly, activates reversible guards, and scans only after commit', async () => {
+    const config = Object.freeze({
+      version: 1,
+      enabled: true,
+      clickGuard: true,
+      renderGuard: true,
+    });
+    const order: string[] = [];
+    const click = guard('click', order);
+    const image = guard('image', order);
+    const iframe = guard('iframe', order);
+    ownedGuards.installClick.mockImplementation(() => {
+      order.push('install:click');
+      return click;
+    });
+    ownedGuards.installImage.mockImplementation(() => {
+      order.push('install:image');
+      return image;
+    });
+    ownedGuards.installIframe.mockImplementation(() => {
+      order.push('install:iframe');
+      return iframe;
+    });
+    let finishPreparation: (() => void) | undefined;
+    const preparationGate = new Promise<void>((resolve) => {
+      finishPreparation = resolve;
+    });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative', 'gate']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative', 'gate']),
+      catalog: catalog(['creative', 'gate']),
+      startedAtMs: 0,
+      now: () => 0,
+      runtimeCapability: runtimeCapability(),
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+    registry.register(
+      registration('gate', async () => {
+        order.push('gate:prepare');
+        await preparationGate;
+        return Object.freeze({ activate: () => order.push('gate:activate') });
+      })
+    );
+
+    const installing = registry.install(callbacks(order));
+    await vi.waitFor(() => expect(order).toEqual(['gate:prepare']));
+    expect(ownedGuards.installClick).not.toHaveBeenCalled();
+
+    finishPreparation?.();
+    const result = await installing;
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'gate:prepare',
+      'core',
+      'install:click',
+      'install:image',
+      'install:iframe',
+      'gate:activate',
+      'publish',
+      'scan:click',
+      'scan:image',
+      'scan:iframe',
+      'drain',
+    ]);
+    if (result.state === 'kernel') {
+      result.dispose();
+      result.dispose();
+    }
+    expect(order.slice(-3)).toEqual(['dispose:iframe', 'dispose:image', 'dispose:click']);
+  });
+
+  it('performs no runtime work when enabled with both guards false', async () => {
+    const config = Object.freeze({
+      version: 1 as const,
+      enabled: true,
+      clickGuard: false,
+      renderGuard: false,
+    });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative']),
+      catalog: catalog(['creative']),
+      startedAtMs: 0,
+      now: () => 0,
+      runtimeCapability: runtimeCapability(),
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({ state: 'kernel' });
+    expect(ownedGuards.installClick).not.toHaveBeenCalled();
+    expect(ownedGuards.installImage).not.toHaveBeenCalled();
+    expect(ownedGuards.installIframe).not.toHaveBeenCalled();
+  });
+
+  it('unwinds creative activation before a later module failure', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    ownedGuards.installClick.mockReturnValue(click);
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative', 'broken']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative', 'broken']),
+      catalog: catalog(['creative', 'broken']),
+      startedAtMs: 0,
+      now: () => 0,
+      runtimeCapability: runtimeCapability(),
+      getBindings: () => ({
+        config: Object.freeze({
+          version: 1,
+          enabled: true,
+          clickGuard: true,
+          renderGuard: false,
+        }),
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+    registry.register(
+      registration('broken', () => ({
+        activate: () => {
+          throw new Error('fictional creative peer failure');
+        },
+      }))
+    );
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(click.dispose).toHaveBeenCalledTimes(1);
+    expect(click.scan).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['missing field', Object.freeze({ version: 1, enabled: true, clickGuard: true })],
+    [
+      'unknown field',
+      Object.freeze({
+        version: 1,
+        enabled: true,
+        clickGuard: true,
+        renderGuard: false,
+        extra: true,
+      }),
+    ],
+    [
+      'accessor',
+      Object.freeze(
+        Object.defineProperty({ version: 1, enabled: true, clickGuard: true }, 'renderGuard', {
+          enumerable: true,
+          get: () => false,
+        })
+      ),
+    ],
+    [
+      'non-plain object',
+      Object.freeze(
+        Object.assign(Object.create({ inherited: true }) as object, {
+          version: 1,
+          enabled: true,
+          clickGuard: true,
+          renderGuard: false,
+        })
+      ),
+    ],
+    ['mutable object', { version: 1, enabled: true, clickGuard: true, renderGuard: false }],
+    [
+      'disabled click guard',
+      Object.freeze({ version: 1, enabled: false, clickGuard: true, renderGuard: false }),
+    ],
+    [
+      'disabled render guard',
+      Object.freeze({ version: 1, enabled: false, clickGuard: false, renderGuard: true }),
+    ],
+  ])('rejects %s configuration during inert preparation', async (_caseName, config) => {
+    const activate = vi.fn();
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative']),
+      catalog: catalog(['creative']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({ creative: Object.freeze({ activate, start }) }),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activate).not.toHaveBeenCalled();
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('fails preparation without effects when composition omits runtime.v1', async () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative']),
+      catalog: catalog(['creative']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({
+          version: 1,
+          enabled: true,
+          clickGuard: true,
+          renderGuard: false,
+        }),
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+  });
+
+  it('contains a post-commit guard scan failure inside the creative module', async () => {
+    const runtimeFailures: unknown[] = [];
+    const order: string[] = [];
+    const click = guard('click', order);
+    vi.mocked(click.scan).mockImplementation(() => {
+      throw new Error('fictional creative scan failure');
+    });
+    ownedGuards.installClick.mockReturnValue(click);
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['creative']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['creative']),
+      catalog: catalog(['creative']),
+      startedAtMs: 0,
+      now: () => 0,
+      runtimeCapability: runtimeCapability(),
+      onRuntimeFailure: (failure) => runtimeFailures.push(failure),
+      getBindings: () => ({
+        config: Object.freeze({
+          version: 1,
+          enabled: true,
+          clickGuard: true,
+          renderGuard: false,
+        }),
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createCreativeIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'kernel',
+      runtimeFailures: [],
+    });
+    expect(click.scan).toHaveBeenCalledOnce();
+    expect(runtimeFailures).toEqual([]);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/ownership.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/ownership.test.ts
new file mode 100644
index 000000000..6e1b8bcb5
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/creative/ownership.test.ts
@@ -0,0 +1,120 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { FIRST_PARTY_CLICK, MUTATED_CLICK, waitForExpect } from './helpers';
+
+const ORIGINAL_FETCH = global.fetch;
+
+describe('creative guard ownership', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    document.body.innerHTML = '';
+  });
+
+  afterEach(() => {
+    global.fetch = ORIGINAL_FETCH;
+    vi.useRealTimers();
+  });
+
+  it('defers the click scan and releases its observer and capture listeners', async () => {
+    vi.useFakeTimers();
+    global.fetch = undefined as unknown as typeof fetch;
+    const anchor = document.createElement('a');
+    anchor.setAttribute('data-tsclick', FIRST_PARTY_CLICK);
+    anchor.setAttribute('href', MUTATED_CLICK);
+    document.body.appendChild(anchor);
+    const { installClickGuard } = await import('../../../src/integrations/creative/click');
+
+    const guard = installClickGuard(false);
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+    expect(anchor.getAttribute('href')).toBe(MUTATED_CLICK);
+
+    guard.scan();
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+    expect(anchor.getAttribute('href')).toContain('/first-party/proxy-rebuild?');
+
+    guard.dispose();
+    guard.dispose();
+    anchor.setAttribute('href', MUTATED_CLICK);
+    const click = new MouseEvent('click', { bubbles: true, cancelable: true });
+    anchor.dispatchEvent(click);
+    await Promise.resolve();
+    await vi.runAllTimersAsync();
+
+    expect(click.defaultPrevented).toBe(false);
+    expect(anchor.getAttribute('href')).toBe(MUTATED_CLICK);
+  });
+
+  it('defers image scans, cancels late signing, and compare-restores owned hooks', async () => {
+    let resolveSigning: ((value: unknown) => void) | undefined;
+    const fetchMock = vi.fn(
+      () =>
+        new Promise((resolve) => {
+          resolveSigning = resolve;
+        })
+    );
+    global.fetch = fetchMock as unknown as typeof fetch;
+    const image = document.createElement('img');
+    image.setAttribute('src', 'https://img.example/existing.gif');
+    document.body.appendChild(image);
+    const descriptorBefore = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src');
+    const { installDynamicImageProxy } = await import('../../../src/integrations/creative/image');
+
+    const guard = installDynamicImageProxy(false);
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src')).not.toEqual(
+      descriptorBefore
+    );
+
+    guard.scan();
+    await waitForExpect(() => expect(fetchMock).toHaveBeenCalledTimes(1));
+    guard.dispose();
+    resolveSigning?.({
+      ok: true,
+      json: async () => ({ href: '/first-party/proxy?late=1' }),
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(image.getAttribute('src')).toBe('https://img.example/existing.gif');
+    expect(Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src')).toEqual(
+      descriptorBefore
+    );
+
+    const replacement = installDynamicImageProxy(false);
+    expect(replacement).not.toBe(guard);
+    expect(Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src')).not.toEqual(
+      descriptorBefore
+    );
+    replacement.dispose();
+    expect(Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, 'src')).toEqual(
+      descriptorBefore
+    );
+  });
+
+  it('does not overwrite a foreign iframe hook installed after activation', async () => {
+    const { installDynamicIframeProxy } = await import('../../../src/integrations/creative/iframe');
+    const guard = installDynamicIframeProxy(false);
+    const owned = Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'src');
+    expect(owned).toBeDefined();
+    const foreignGet = function (this: HTMLIFrameElement): string {
+      return this.getAttribute('src') ?? '';
+    };
+    const foreignSet = function (this: HTMLIFrameElement, value: string): void {
+      this.setAttribute('src', value);
+    };
+    Object.defineProperty(HTMLIFrameElement.prototype, 'src', {
+      configurable: true,
+      enumerable: owned?.enumerable ?? true,
+      get: foreignGet,
+      set: foreignSet,
+    });
+
+    guard.dispose();
+
+    const current = Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'src');
+    expect(current?.get).toBe(foreignGet);
+    expect(current?.set).toBe(foreignSet);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/creative/startup.test.ts b/crates/trusted-server-js/lib/test/integrations/creative/startup.test.ts
new file mode 100644
index 000000000..1989af611
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/creative/startup.test.ts
@@ -0,0 +1,208 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { CreativeBootV1 } from '../../../src/core/types';
+import {
+  createCreativeStartup,
+  type CreativeGuardHandle,
+} from '../../../src/integrations/creative/startup';
+
+function config(overrides: Partial<CreativeBootV1> = {}): Readonly<CreativeBootV1> {
+  return Object.freeze({
+    version: 1 as const,
+    enabled: true,
+    clickGuard: true,
+    renderGuard: true,
+    ...overrides,
+  });
+}
+
+function guard(name: string, order: string[]): CreativeGuardHandle {
+  return Object.freeze({
+    dispose: vi.fn(() => order.push(`dispose:${name}`)),
+    scan: vi.fn(() => order.push(`scan:${name}`)),
+  });
+}
+
+function readyDocument(readyState: DocumentReadyState = 'complete') {
+  let listener: (() => void) | undefined;
+  return {
+    document: {
+      readyState,
+      addEventListener: vi.fn(
+        (_type: 'DOMContentLoaded', next: () => void, _options: { once: true }) => {
+          listener = next;
+        }
+      ),
+      removeEventListener: vi.fn((_type: 'DOMContentLoaded', candidate: () => void) => {
+        if (listener === candidate) listener = undefined;
+      }),
+    },
+    dispatchReady: (): void => {
+      const current = listener;
+      listener = undefined;
+      current?.();
+    },
+  };
+}
+
+describe('creative startup ownership', () => {
+  it('installs selected guards synchronously, scans after commit, and disposes in reverse', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    const image = guard('image', order);
+    const iframe = guard('iframe', order);
+    const target = readyDocument();
+    const startup = createCreativeStartup({
+      document: target.document,
+      installClickGuard: vi.fn(() => (order.push('install:click'), click)),
+      installDynamicImageProxy: vi.fn(() => (order.push('install:image'), image)),
+      installDynamicIframeProxy: vi.fn(() => (order.push('install:iframe'), iframe)),
+    });
+    const boot = config();
+
+    const release = startup.activate(boot);
+    expect(order).toEqual(['install:click', 'install:image', 'install:iframe']);
+
+    startup.start(boot);
+    expect(order).toEqual([
+      'install:click',
+      'install:image',
+      'install:iframe',
+      'scan:click',
+      'scan:image',
+      'scan:iframe',
+    ]);
+
+    release();
+    release();
+    expect(order.slice(-3)).toEqual(['dispose:iframe', 'dispose:image', 'dispose:click']);
+  });
+
+  it('owns one loading-document rescan and removes it on disposal', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    const target = readyDocument('loading');
+    const startup = createCreativeStartup({
+      document: target.document,
+      installClickGuard: () => click,
+      installDynamicImageProxy: () => guard('image', order),
+      installDynamicIframeProxy: () => guard('iframe', order),
+    });
+    const boot = config({ renderGuard: false });
+
+    const release = startup.activate(boot);
+    expect(target.document.addEventListener).toHaveBeenCalledExactlyOnceWith(
+      'DOMContentLoaded',
+      expect.any(Function),
+      { once: true }
+    );
+    startup.start(boot);
+    expect(click.scan).not.toHaveBeenCalled();
+
+    target.dispatchReady();
+    target.dispatchReady();
+    expect(click.scan).toHaveBeenCalledTimes(1);
+
+    release();
+    expect(target.document.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(click.dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it('rolls back earlier guards when a later installer throws', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    const image = guard('image', order);
+    const target = readyDocument();
+    const startup = createCreativeStartup({
+      document: target.document,
+      installClickGuard: () => click,
+      installDynamicImageProxy: () => image,
+      installDynamicIframeProxy: () => {
+        throw new Error('fictional iframe installation failure');
+      },
+    });
+
+    expect(() => startup.activate(config())).toThrow('fictional iframe installation failure');
+    expect(order).toEqual(['dispose:image', 'dispose:click']);
+  });
+
+  it('removes an exact ready listener when hostile registration throws after installing it', () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    let listener: (() => void) | undefined;
+    const document = {
+      readyState: 'loading' as const,
+      addEventListener: vi.fn(
+        (_type: 'DOMContentLoaded', candidate: () => void, _options: { once: true }) => {
+          listener = candidate;
+          throw new Error('fictional ready listener registration failure');
+        }
+      ),
+      removeEventListener: vi.fn((_type: 'DOMContentLoaded', candidate: () => void) => {
+        if (listener === candidate) listener = undefined;
+      }),
+    };
+    const startup = createCreativeStartup({
+      document,
+      installClickGuard: () => click,
+      installDynamicImageProxy: () => guard('image', order),
+      installDynamicIframeProxy: () => guard('iframe', order),
+    });
+
+    expect(() => startup.activate(config({ renderGuard: false }))).toThrow(
+      'fictional ready listener registration failure'
+    );
+    expect(document.removeEventListener).toHaveBeenCalledExactlyOnceWith(
+      'DOMContentLoaded',
+      expect.any(Function)
+    );
+    expect(click.dispose).toHaveBeenCalledTimes(1);
+
+    listener?.();
+    expect(click.scan).not.toHaveBeenCalled();
+  });
+
+  it('contains hostile scans and still visits every active guard', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    const image = guard('image', order);
+    const iframe = guard('iframe', order);
+    vi.mocked(click.scan).mockImplementation(() => {
+      order.push('scan:click');
+      throw new Error('fictional click scan failure');
+    });
+    const target = readyDocument();
+    const startup = createCreativeStartup({
+      document: target.document,
+      installClickGuard: () => click,
+      installDynamicImageProxy: () => image,
+      installDynamicIframeProxy: () => iframe,
+    });
+    const boot = config();
+    startup.activate(boot);
+
+    expect(() => startup.start(boot)).not.toThrow();
+    expect(image.scan).toHaveBeenCalledTimes(1);
+    expect(iframe.scan).toHaveBeenCalledTimes(1);
+  });
+
+  it('prevents a late start after release and rejects duplicate lifecycle calls', async () => {
+    const order: string[] = [];
+    const click = guard('click', order);
+    const target = readyDocument();
+    const startup = createCreativeStartup({
+      document: target.document,
+      installClickGuard: () => click,
+      installDynamicImageProxy: () => guard('image', order),
+      installDynamicIframeProxy: () => guard('iframe', order),
+    });
+    const boot = config({ renderGuard: false });
+    const release = startup.activate(boot);
+    expect(() => startup.activate(boot)).toThrow('already activated');
+    release();
+
+    startup.start(boot);
+    expect(click.scan).not.toHaveBeenCalled();
+    expect(() => startup.start(boot)).toThrow('already started');
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/datadome/module.test.ts b/crates/trusted-server-js/lib/test/integrations/datadome/module.test.ts
new file mode 100644
index 000000000..1fa9b1e34
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/datadome/module.test.ts
@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const ownedGuard = vi.hoisted(() => ({
+  install: vi.fn(),
+  reset: vi.fn(),
+}));
+
+vi.mock('../../../src/integrations/datadome/script_guard', () => ({
+  installDataDomeGuard: ownedGuard.install,
+  resetGuardState: ownedGuard.reset,
+}));
+
+import {
+  createDataDomeIntegrationRegistration,
+  createDataDomeRuntime,
+} from '../../../src/integrations/datadome/module';
+import {
+  createIntegrationRegistry,
+  type IntegrationInstallCallbacks,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+describe('transactional DataDome integration module', () => {
+  beforeEach(() => {
+    ownedGuard.install.mockReset();
+    ownedGuard.reset.mockReset();
+  });
+
+  it('prepares inertly, activates before publication, and releases exactly once', async () => {
+    const order: string[] = [];
+    ownedGuard.install.mockImplementation(() => order.push('datadome:activate'));
+    ownedGuard.reset.mockImplementation(() => order.push('datadome:release'));
+    const registry = createIntegrationRegistry({
+      manifest: {
+        version: 1,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: 'datadome', phase: 'takeover' }],
+      },
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['datadome']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createDataDomeIntegrationRegistration(RELEASE_ID));
+
+    expect(ownedGuard.install).not.toHaveBeenCalled();
+    const result = await registry.install(callbacks(order));
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual(['core', 'datadome:activate', 'publish', 'drain']);
+    if (result.state === 'kernel') {
+      result.dispose();
+      result.dispose();
+    }
+    expect(ownedGuard.reset).toHaveBeenCalledOnce();
+    expect(order[order.length - 1]).toBe('datadome:release');
+  });
+
+  it.each([undefined, null, false, Object.freeze({ extra: true })])(
+    'rejects non-exact config %j',
+    async (config) => {
+      const activate = vi.fn(() => vi.fn());
+      const registry = createIntegrationRegistry({
+        manifest: {
+          version: 1,
+          releaseId: RELEASE_ID,
+          firstDisplay: null,
+          runtimeSrc: RUNTIME_SRC,
+          integrations: [{ id: 'datadome', phase: 'takeover' }],
+        },
+        releaseId: RELEASE_ID,
+        knownIntegrationIds: Object.freeze(['datadome']),
+        startedAtMs: 0,
+        now: () => 0,
+        getBindings: () => ({
+          config,
+          interfaces: Object.freeze({
+            datadome: Object.freeze({ activate, start: vi.fn() }),
+          }),
+        }),
+      });
+      registry.register(createDataDomeIntegrationRegistration(RELEASE_ID));
+
+      await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+      expect(activate).not.toHaveBeenCalled();
+    }
+  );
+
+  it('owns and reverses the concrete DataDome guard', () => {
+    const order: string[] = [];
+    const runtime = createDataDomeRuntime({
+      installGuard: () => order.push('install'),
+      resetGuard: () => order.push('reset'),
+      started: () => order.push('started'),
+    });
+
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+    release();
+    release();
+
+    expect(order).toEqual(['install', 'started', 'reset']);
+  });
+
+  it('rolls back an attempted guard installation that throws', () => {
+    const resetGuard = vi.fn();
+    const runtime = createDataDomeRuntime({
+      installGuard: () => {
+        throw new Error('fictional guard failure');
+      },
+      resetGuard,
+      started: vi.fn(),
+    });
+
+    expect(() => runtime.activate(undefined)).toThrowError('fictional guard failure');
+    expect(resetGuard).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/didomi/index.test.ts b/crates/trusted-server-js/lib/test/integrations/didomi/index.test.ts
deleted file mode 100644
index 5ca9d7598..000000000
--- a/crates/trusted-server-js/lib/test/integrations/didomi/index.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { installDidomiSdkProxy } from '../../../src/integrations/didomi';
-
-const ORIGINAL_WINDOW = global.window;
-
-// Mirrors the non-exported DidomiConfig shape in src/integrations/didomi.
-type TestDidomiConfig = {
-  sdkPath?: string;
-  [key: string]: unknown;
-};
-
-type TestDidomiWindow = Window & {
-  didomiConfig?: TestDidomiConfig;
-  __tsjs_didomi?: { proxyPath?: string };
-};
-
-function createWindow(url: string) {
-  return {
-    location: new URL(url) as unknown as Location,
-  } as TestDidomiWindow;
-}
-
-describe('integrations/didomi', () => {
-  let testWindow: ReturnType<typeof createWindow>;
-
-  beforeEach(() => {
-    testWindow = createWindow('https://example.com/page');
-    Object.assign(globalThis, { window: testWindow });
-  });
-
-  afterEach(() => {
-    Object.assign(globalThis, { window: ORIGINAL_WINDOW });
-  });
-
-  it('initializes didomiConfig and forces sdkPath through trusted server proxy', () => {
-    installDidomiSdkProxy();
-
-    expect(testWindow.didomiConfig).toBeDefined();
-    expect(testWindow.didomiConfig!.sdkPath).toBe(
-      'https://example.com/integrations/didomi/consent/'
-    );
-  });
-
-  it('preserves existing config fields while overriding sdkPath', () => {
-    testWindow.didomiConfig = { apiKey: 'abc', sdkPath: 'https://sdk.privacy-center.org/' };
-
-    installDidomiSdkProxy();
-
-    expect(testWindow.didomiConfig.apiKey).toBe('abc');
-    expect(testWindow.didomiConfig.sdkPath).toBe(
-      'https://example.com/integrations/didomi/consent/'
-    );
-  });
-
-  it('uses the server-injected custom proxy path', () => {
-    testWindow.__tsjs_didomi = { proxyPath: '/my-custom-consent/' };
-
-    installDidomiSdkProxy();
-
-    expect(testWindow.didomiConfig!.sdkPath).toBe('https://example.com/my-custom-consent/');
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/didomi/module.test.ts b/crates/trusted-server-js/lib/test/integrations/didomi/module.test.ts
new file mode 100644
index 000000000..b2780ec0e
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/didomi/module.test.ts
@@ -0,0 +1,84 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createDidomiIntegrationRegistration,
+  createDidomiRuntime,
+} from '../../../src/integrations/didomi/module';
+import { createIntegrationRegistry } from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+describe('transactional Didomi integration module', () => {
+  it('sets an absolute SDK path without clobbering publisher config and compare-restores it', () => {
+    const config = { custom: 'publisher', sdkPath: 'https://publisher.example/sdk/' };
+    const target = {
+      didomiConfig: config,
+      location: { origin: 'https://news.example' },
+    };
+    const started = vi.fn();
+    const runtime = createDidomiRuntime({ started, target });
+    const boot = Object.freeze({ proxyPath: '/integrations/didomi/consent/' });
+
+    const release = runtime.activate(boot);
+
+    expect(config).toEqual({
+      custom: 'publisher',
+      sdkPath: 'https://news.example/integrations/didomi/consent/',
+    });
+    runtime.start(boot);
+    expect(started).toHaveBeenCalledOnce();
+    release();
+    release();
+    expect(config).toEqual({ custom: 'publisher', sdkPath: 'https://publisher.example/sdk/' });
+  });
+
+  it('does not overwrite a publisher replacement during disposal', () => {
+    const config = { sdkPath: 'https://publisher.example/original/' };
+    const runtime = createDidomiRuntime({
+      started: vi.fn(),
+      target: { didomiConfig: config, location: { origin: 'https://news.example' } },
+    });
+    const release = runtime.activate(Object.freeze({ proxyPath: '/integrations/didomi/consent/' }));
+    config.sdkPath = 'https://publisher.example/replacement/';
+
+    release();
+
+    expect(config.sdkPath).toBe('https://publisher.example/replacement/');
+  });
+
+  it.each([
+    ['mutable', { proxyPath: '/integrations/didomi/consent/' }],
+    ['relative', Object.freeze({ proxyPath: 'integrations/didomi/consent/' })],
+    ['protocol relative', Object.freeze({ proxyPath: '//attacker.example/consent/' })],
+    ['backslash authority', Object.freeze({ proxyPath: '/\\attacker.example/consent/' })],
+    ['extra', Object.freeze({ proxyPath: '/integrations/didomi/consent/', legacy: true })],
+  ])('rejects %s boot config before activation', async (_name, config) => {
+    const activate = vi.fn(() => vi.fn());
+    const registry = createIntegrationRegistry({
+      manifest: {
+        version: 1,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: 'didomi', phase: 'takeover' }],
+      },
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['didomi']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({
+          didomi: Object.freeze({ activate, start: vi.fn() }),
+        }),
+      }),
+    });
+    registry.register(createDidomiIntegrationRegistration(RELEASE_ID));
+
+    await expect(
+      registry.install({ activateCore: vi.fn(), publish: vi.fn(), drainPreload: vi.fn() })
+    ).resolves.toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(activate).not.toHaveBeenCalled();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/google_tag_manager/module.test.ts b/crates/trusted-server-js/lib/test/integrations/google_tag_manager/module.test.ts
new file mode 100644
index 000000000..e1cb1c055
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/google_tag_manager/module.test.ts
@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const ownedGuards = vi.hoisted(() => ({
+  installBeacon: vi.fn(),
+  installScript: vi.fn(),
+  resetBeacon: vi.fn(),
+  resetScript: vi.fn(),
+}));
+
+vi.mock('../../../src/integrations/google_tag_manager/script_guard', () => ({
+  installGtmBeaconGuard: ownedGuards.installBeacon,
+  installGtmGuard: ownedGuards.installScript,
+  resetBeaconGuardState: ownedGuards.resetBeacon,
+  resetGuardState: ownedGuards.resetScript,
+}));
+
+import {
+  createGoogleTagManagerIntegrationRegistration,
+  createGoogleTagManagerRuntime,
+} from '../../../src/integrations/google_tag_manager/module';
+import {
+  createIntegrationRegistry,
+  type IntegrationInstallCallbacks,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+describe('transactional Google Tag Manager integration module', () => {
+  beforeEach(() => {
+    ownedGuards.installBeacon.mockReset();
+    ownedGuards.installScript.mockReset();
+    ownedGuards.resetBeacon.mockReset();
+    ownedGuards.resetScript.mockReset();
+  });
+
+  it('activates both guards before publication and releases them in reverse order', async () => {
+    const order: string[] = [];
+    ownedGuards.installBeacon.mockImplementation(() => order.push('beacon:install'));
+    ownedGuards.installScript.mockImplementation(() => order.push('script:install'));
+    ownedGuards.resetBeacon.mockImplementation(() => order.push('beacon:reset'));
+    ownedGuards.resetScript.mockImplementation(() => order.push('script:reset'));
+    const registry = createIntegrationRegistry({
+      manifest: {
+        version: 1,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: 'google_tag_manager', phase: 'takeover' }],
+      },
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['google_tag_manager']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({}),
+      }),
+    });
+    registry.register(createGoogleTagManagerIntegrationRegistration(RELEASE_ID));
+
+    expect(order).toEqual([]);
+    const result = await registry.install(callbacks(order));
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual(['core', 'script:install', 'beacon:install', 'publish', 'drain']);
+    if (result.state === 'kernel') result.dispose();
+    expect(order.slice(-2)).toEqual(['beacon:reset', 'script:reset']);
+  });
+
+  it('rolls back the script guard when beacon activation throws', () => {
+    const resetBeaconGuard = vi.fn();
+    const resetScriptGuard = vi.fn();
+    const runtime = createGoogleTagManagerRuntime({
+      installBeaconGuard: () => {
+        throw new Error('fictional beacon failure');
+      },
+      installScriptGuard: vi.fn(),
+      resetBeaconGuard,
+      resetScriptGuard,
+      started: vi.fn(),
+    });
+
+    expect(() => runtime.activate(undefined)).toThrowError('fictional beacon failure');
+    expect(resetBeaconGuard).toHaveBeenCalledOnce();
+    expect(resetScriptGuard).toHaveBeenCalledOnce();
+  });
+
+  it('rolls back an attempted script guard installation that throws', () => {
+    const resetBeaconGuard = vi.fn();
+    const resetScriptGuard = vi.fn();
+    const runtime = createGoogleTagManagerRuntime({
+      installBeaconGuard: vi.fn(),
+      installScriptGuard: () => {
+        throw new Error('fictional script failure');
+      },
+      resetBeaconGuard,
+      resetScriptGuard,
+      started: vi.fn(),
+    });
+
+    expect(() => runtime.activate(undefined)).toThrowError('fictional script failure');
+    expect(resetBeaconGuard).not.toHaveBeenCalled();
+    expect(resetScriptGuard).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/google_tag_manager/script_guard.test.ts b/crates/trusted-server-js/lib/test/integrations/google_tag_manager/script_guard.test.ts
index 971d396f4..933ece79c 100644
--- a/crates/trusted-server-js/lib/test/integrations/google_tag_manager/script_guard.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/google_tag_manager/script_guard.test.ts
@@ -372,10 +372,10 @@ describe('GTM Beacon Guard', () => {
     originalFetch = window.fetch;
 
     sendBeaconSpy = vi.fn(() => true);
-    navigator.sendBeacon = sendBeaconSpy;
+    navigator.sendBeacon = sendBeaconSpy as typeof navigator.sendBeacon;
 
     fetchSpy = vi.fn(() => Promise.resolve(new Response('', { status: 200 })));
-    window.fetch = fetchSpy;
+    window.fetch = fetchSpy as typeof window.fetch;
 
     resetBeaconGuardState();
   });
@@ -397,7 +397,7 @@ describe('GTM Beacon Guard', () => {
 
     navigator.sendBeacon('https://www.google-analytics.com/g/collect?v=2&tid=G-JGPCNWGVHC', '');
 
-    const calledUrl = sendBeaconSpy.mock.calls[0][0];
+    const calledUrl = sendBeaconSpy.mock.calls[0]![0];
     expect(calledUrl).toContain('/integrations/google_tag_manager/g/collect');
     expect(calledUrl).not.toContain('google-analytics.com');
   });
@@ -407,7 +407,7 @@ describe('GTM Beacon Guard', () => {
 
     navigator.sendBeacon('https://analytics.google.com/g/collect?v=2&tid=G-DQMZGMPHXN', '');
 
-    const calledUrl = sendBeaconSpy.mock.calls[0][0];
+    const calledUrl = sendBeaconSpy.mock.calls[0]![0];
     expect(calledUrl).toContain('/integrations/google_tag_manager/g/collect');
     expect(calledUrl).not.toContain('analytics.google.com');
   });
@@ -417,7 +417,7 @@ describe('GTM Beacon Guard', () => {
 
     await window.fetch('https://www.google-analytics.com/g/collect?v=2&tid=G-TEST');
 
-    const calledUrl = fetchSpy.mock.calls[0][0];
+    const calledUrl = fetchSpy.mock.calls[0]![0];
     expect(calledUrl).toContain('/integrations/google_tag_manager/g/collect');
     expect(calledUrl).not.toContain('google-analytics.com');
   });
@@ -435,7 +435,7 @@ describe('GTM Beacon Guard', () => {
 
     navigator.sendBeacon('https://www.google-analytics.com/g/collect?v=2&tid=G-TEST&cid=123', '');
 
-    const calledUrl = sendBeaconSpy.mock.calls[0][0];
+    const calledUrl = sendBeaconSpy.mock.calls[0]![0];
     expect(calledUrl).toContain('v=2&tid=G-TEST&cid=123');
   });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts
deleted file mode 100644
index e034a8ba4..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts
+++ /dev/null
@@ -1,5387 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { resolve } from 'node:path';
-
-import { describe, it, expect, vi, beforeEach, afterEach, afterAll } from 'vitest';
-
-import envelope from '../../fixtures/aps-renderer-v1.json';
-import {
-  registerPublisherFirstImpressionAuctions,
-  resolveFirstImpressionElement,
-} from '../../../src/core/first_impression';
-import type { AuctionBidData, TsjsApi } from '../../../src/core/types';
-import {
-  APS_PREBID_CREATIVE_RUNNER_URL,
-  APS_RENDERING_MODE_ATTRIBUTE_NAME,
-} from '../../../src/integrations/aps/render';
-
-let publisherNativeScript: HTMLScriptElement | undefined;
-
-function enablePublisherNativeMode(): { remove(): void } {
-  publisherNativeScript = document.createElement('script');
-  publisherNativeScript.setAttribute(APS_RENDERING_MODE_ATTRIBUTE_NAME, 'publisher_native');
-  return {
-    remove: () => {
-      publisherNativeScript = undefined;
-    },
-  };
-}
-
-function nativeRunnerIn(divId: string): {
-  frame: HTMLIFrameElement;
-  runner: HTMLScriptElement;
-  event: CustomEvent<{ aaxResponse: string; seatBidId: string }>;
-} {
-  const container = document.getElementById(divId)!;
-  const frame = Array.from(container.querySelectorAll('iframe')).find(
-    (candidate) => candidate.title === 'Ad content'
-  );
-  expect(frame).not.toBeUndefined();
-  const runner = frame!.contentDocument?.querySelector<HTMLScriptElement>('script');
-  const frameWindow = frame!.contentWindow as unknown as {
-    _aps: Map<string, { queue: Array<CustomEvent<{ aaxResponse: string; seatBidId: string }>> }>;
-  };
-  const event = Array.from(frameWindow._aps.values())[0]?.queue[0];
-  expect(runner?.src).toBe(APS_PREBID_CREATIVE_RUNNER_URL);
-  expect(event).not.toBeUndefined();
-  return { frame: frame!, runner: runner!, event };
-}
-
-function apsRenderer() {
-  const bid = envelope.seatbid[0].bid[0];
-  return {
-    type: 'aps' as const,
-    version: 1 as const,
-    accountId: 'example-account-id',
-    bidId: bid.id,
-    creativeId: 'fictional-creative-id',
-    tagType: 'iframe' as const,
-    creativeUrl: bid.ext.creativeurl,
-    aaxResponse: btoa(JSON.stringify(envelope)),
-    width: bid.w,
-    height: bid.h,
-  };
-}
-
-// Track every 'message' EventListener added to window across the entire test
-// file.  This lets the installTsRenderBridge suite remove all accumulated
-// handlers (registered by each vi.resetModules() + module re-import in the
-// installTsAdInit suite) before dispatching its own events. The spy is
-// restored and remaining handlers are detached in the afterAll below so the
-// patch never leaks past this file.
-const allMessageHandlers: EventListener[] = [];
-const originalWindowAddEventListener = window.addEventListener.bind(window);
-// Plain wrapper, deliberately not vi.spyOn: the render-bridge suite spies on
-// window.addEventListener itself, and vi.spyOn on an already-spied method
-// returns the same mock instance — its "original" would alias the inner
-// implementation and recurse.
-(window as { addEventListener: typeof window.addEventListener }).addEventListener = ((
-  type: string,
-  handler: EventListenerOrEventListenerObject,
-  options?: boolean | AddEventListenerOptions
-) => {
-  if (type === 'message' && handler) {
-    allMessageHandlers.push(handler as EventListener);
-  }
-  return originalWindowAddEventListener(type, handler, options);
-}) as typeof window.addEventListener;
-
-afterAll(() => {
-  for (const handler of allMessageHandlers) {
-    window.removeEventListener('message', handler);
-  }
-  allMessageHandlers.length = 0;
-  (window as { addEventListener: typeof window.addEventListener }).addEventListener =
-    originalWindowAddEventListener;
-});
-
-interface SlotRenderEvent {
-  isEmpty: boolean;
-  slot: {
-    getSlotElementId(): string;
-    getTargeting(key: string): string[];
-  };
-}
-
-// The `Prebid Response` payload the render bridge posts back to the Prebid
-// Universal Creative over the message port.
-interface PrebidResponseMessage {
-  message?: string;
-  adId?: string;
-  ad?: string;
-  width?: number;
-  height?: number;
-}
-
-// `tsjs` is declared globally as the full `TsjsApi` (core/types.ts). Omitting
-// it from `Window` before re-adding it as a `Partial` avoids the intersection
-// that would force every fixture below to satisfy the whole `TsjsApi` shape.
-type TestWindow = Omit<Window, 'tsjs'> & {
-  googletag?: unknown;
-  apstag?: { setDisplayBids?: () => void };
-  tsjs?: Partial<TsjsApi>;
-};
-
-async function runGptBootstrapWithGoogleTag(googletag: object): Promise<void> {
-  const bootstrapUrl = new URL(
-    '../../../../../trusted-server-core/src/integrations/gpt_bootstrap.js',
-    import.meta.url
-  );
-  const urlPath = decodeURIComponent(bootstrapUrl.pathname);
-  let bootstrapPath: string;
-  if (urlPath.startsWith('/@fs/')) {
-    bootstrapPath = urlPath.slice('/@fs'.length);
-  } else if (bootstrapUrl.protocol === 'file:') {
-    bootstrapPath = urlPath;
-  } else {
-    bootstrapPath = path.resolve(process.cwd(), `.${urlPath}`);
-  }
-  const bootstrap = await readFile(bootstrapPath, 'utf8');
-  const runBootstrap = new Function('window', 'googletag', bootstrap) as (
-    window: Window,
-    googletag: object
-  ) => void;
-  runBootstrap(window, googletag);
-}
-
-type HandoffImplementation = 'bootstrap' | 'bundle';
-
-async function installHandoff(implementation: HandoffImplementation): Promise<void> {
-  if (implementation === 'bootstrap') {
-    const bootstrap = readFileSync(
-      resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-      'utf8'
-    );
-    window.eval(bootstrap);
-    return;
-  }
-
-  const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-  installTsAdInit();
-}
-
-interface ResponsiveSlotElementOptions {
-  containerVisible?: boolean;
-  containerWidth?: number;
-  containerHeight?: number;
-  elementHidden?: boolean;
-  elementWidth?: number;
-  elementHeight?: number;
-  checkVisibility?: boolean;
-}
-
-function appendResponsiveSlotElement(
-  id: string,
-  {
-    containerVisible = false,
-    containerWidth = 0,
-    containerHeight = 0,
-    elementHidden = false,
-    elementWidth = 0,
-    elementHeight = 0,
-    checkVisibility,
-  }: ResponsiveSlotElementOptions = {}
-): HTMLDivElement {
-  const container = document.createElement('div');
-  container.id = `${id}-container`;
-  container.dataset.responsiveSlotTest = 'true';
-  container.style.display = containerVisible ? 'block' : 'none';
-  container.getBoundingClientRect = () =>
-    ({ width: containerWidth, height: containerHeight }) as DOMRect;
-
-  const element = document.createElement('div');
-  element.id = id;
-  element.style.display = elementHidden ? 'none' : 'block';
-  element.getBoundingClientRect = () => ({ width: elementWidth, height: elementHeight }) as DOMRect;
-  if (checkVisibility !== undefined) {
-    (element as HTMLElement & { checkVisibility?: () => boolean }).checkVisibility = vi
-      .fn()
-      .mockReturnValue(checkVisibility);
-  }
-  container.appendChild(element);
-  document.body.appendChild(container);
-  return element;
-}
-
-function runGptBootstrap(): void {
-  const bootstrap = readFileSync(
-    resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-    'utf8'
-  );
-  window.eval(bootstrap);
-}
-
-describe('installTsAdInit', () => {
-  beforeEach(() => {
-    vi.resetModules();
-    const tw = window as TestWindow;
-    delete tw.tsjs;
-    // jsdom does not implement navigator.sendBeacon; polyfill it for tests
-    if (!('sendBeacon' in navigator)) {
-      Object.defineProperty(navigator, 'sendBeacon', {
-        value: vi.fn().mockReturnValue(true),
-        writable: true,
-        configurable: true,
-      });
-    }
-    // adInit now queries the DOM for div elements by id/prefix — create the
-    // test div so getElementById and querySelector both resolve correctly.
-    if (!document.getElementById('div-atf-sidebar')) {
-      const div = document.createElement('div');
-      div.id = 'div-atf-sidebar';
-      document.body.appendChild(div);
-    }
-  });
-
-  afterEach(() => {
-    document.getElementById('div-atf-sidebar')?.remove();
-    document.getElementById('div-new-slot')?.remove();
-    document.getElementById('div-atf-sidebar-2')?.remove();
-    document.getElementById('div-size-hydrated')?.remove();
-    document.getElementById('ad-header-0-_r_1_')?.remove();
-    document.getElementById("ad'prefix-real")?.remove();
-    document.querySelectorAll('[data-responsive-slot-test]').forEach((element) => element.remove());
-  });
-
-  function configureOpportunityDiagnostics(
-    bid: AuctionBidData | undefined,
-    recordTrustedServerOpportunity: ReturnType<typeof vi.fn>,
-    formats: Array<[number, number]> = [[300, 250]]
-  ) {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      clearTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats,
-          targeting: {},
-        },
-      ],
-      bids: bid ? { atf_sidebar_ad: bid } : {},
-      gptDiagnosticsRecorder: {
-        recordTrustedServerOpportunity,
-      } as unknown as TsjsApi['gptDiagnosticsRecorder'],
-    };
-
-    return { mockPubads, mockSlot };
-  }
-
-  it('leaves a publisher-auctioned slot untouched when delayed adInit receives no candidate', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-      undefined,
-      recordTrustedServerOpportunity
-    );
-    const ts = (window as TestWindow).tsjs as TsjsApi;
-    registerPublisherFirstImpressionAuctions(ts, ['div-atf-sidebar']);
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    ts.adInit!();
-
-    expect(mockSlot.setTargeting).not.toHaveBeenCalled();
-    expect(mockPubads.refresh).not.toHaveBeenCalled();
-    expect(recordTrustedServerOpportunity).not.toHaveBeenCalled();
-    expect(ts.divToSlotId).toEqual({});
-    expect(ts.prevSlotTargetingKeys).toEqual({});
-  });
-
-  it('falls back once when a publisher auction abandons its first-impression claim', async () => {
-    vi.useFakeTimers();
-    try {
-      const recordTrustedServerOpportunity = vi.fn();
-      const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-        { hb_pb: '1.10', hb_adid: 'example-fallback-ad', adm: '<div>Fallback</div>' },
-        recordTrustedServerOpportunity
-      );
-      const ts = (window as TestWindow).tsjs as TsjsApi;
-      registerPublisherFirstImpressionAuctions(ts, ['div-atf-sidebar']);
-      const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-      installTsAdInit();
-      ts.adInit!();
-
-      expect(mockPubads.refresh).not.toHaveBeenCalled();
-      vi.advanceTimersByTime(5001);
-
-      expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-      expect(mockPubads.refresh).toHaveBeenCalledOnce();
-      expect(mockPubads.refresh).toHaveBeenCalledWith([mockSlot]);
-      expect(recordTrustedServerOpportunity).toHaveBeenCalledOnce();
-
-      vi.advanceTimersByTime(10_000);
-      expect(mockPubads.refresh).toHaveBeenCalledOnce();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('does not clear targeting or request again after TS claims an existing slot', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-      undefined,
-      recordTrustedServerOpportunity
-    );
-    const ts = (window as TestWindow).tsjs as TsjsApi;
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    ts.adInit!();
-    const clearCalls = mockSlot.clearTargeting.mock.calls.length;
-    const targetingCalls = mockSlot.setTargeting.mock.calls.length;
-    ts.adInit!();
-
-    expect(mockSlot.clearTargeting).toHaveBeenCalledTimes(clearCalls);
-    expect(mockSlot.setTargeting).toHaveBeenCalledTimes(targetingCalls);
-    expect(mockPubads.refresh).toHaveBeenCalledOnce();
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledOnce();
-  });
-
-  it.each(['slotRequested', 'slotRenderEnded'] as const)(
-    'leaves a publisher slot untouched after an earlier %s event',
-    async (eventName) => {
-      const recordTrustedServerOpportunity = vi.fn();
-      const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-        { hb_pb: '2.00', hb_adid: 'late-page-bid', adm: '<div>Late</div>' },
-        recordTrustedServerOpportunity
-      );
-      const ts = (window as TestWindow).tsjs as TsjsApi;
-      const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-      installTsAdInit();
-      const lifecycleListener = mockPubads.addEventListener.mock.calls.find(
-        ([registeredEvent]) => registeredEvent === eventName
-      )?.[1] as ((event: SlotRenderEvent) => void) | undefined;
-      expect(lifecycleListener).toBeDefined();
-      lifecycleListener!({ isEmpty: false, slot: mockSlot });
-
-      ts.adInit!();
-
-      expect(mockSlot.setTargeting).not.toHaveBeenCalled();
-      expect(mockPubads.refresh).not.toHaveBeenCalled();
-      expect(recordTrustedServerOpportunity).not.toHaveBeenCalled();
-      expect(ts.firstImpression?.slots['div-atf-sidebar']?.owner).toBe('publisher');
-      expect(ts.firstImpression?.slots['div-atf-sidebar']?.phase).toBe(
-        eventName === 'slotRequested' ? 'requested' : 'rendered'
-      );
-    }
-  );
-
-  it.each([
-    [
-      'inline markup',
-      { hb_pb: '1.00', hb_adid: 'abc-uuid', adm: '<div>Creative</div>' },
-      'renderable_candidate',
-    ],
-    [
-      'complete cache coordinates',
-      {
-        hb_bidder: 'example-bidder',
-        hb_adid: 'abc-uuid',
-        hb_cache_host: 'cache.example.com',
-        hb_cache_path: '/cache',
-      },
-      'renderable_candidate',
-    ],
-    [
-      'an ad ID without a render source',
-      { hb_pb: '1.00', hb_adid: 'abc-uuid' },
-      'unrenderable_candidate',
-    ],
-    [
-      'a render source without an ad ID',
-      { hb_pb: '1.00', adm: '<div>Creative</div>' },
-      'unrenderable_candidate',
-    ],
-    [
-      'no non-empty Trusted Server bid targeting',
-      { hb_pb: '', hb_bidder: '', hb_adid: '', adm: '<div>Creative</div>' },
-      'no_candidate',
-    ],
-  ] as const)(
-    'records exactly one %s opportunity for every resolved GPT slot',
-    async (_description, bid, expectedOpportunity) => {
-      const recordTrustedServerOpportunity = vi.fn();
-      const { mockSlot } = configureOpportunityDiagnostics(
-        bid as AuctionBidData,
-        recordTrustedServerOpportunity
-      );
-
-      const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-      installTsAdInit();
-      (window as TestWindow).tsjs!.adInit!();
-
-      expect(recordTrustedServerOpportunity).toHaveBeenCalledTimes(1);
-      expect(recordTrustedServerOpportunity).toHaveBeenCalledWith(
-        mockSlot,
-        'atf_sidebar_ad',
-        expectedOpportunity,
-        undefined,
-        undefined
-      );
-    }
-  );
-
-  it('forwards winning bid auction metadata to diagnostics only when present', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const { mockSlot } = configureOpportunityDiagnostics(
-      {
-        hb_pb: '1.00',
-        hb_bidder: 'example',
-        hb_adid: 'creative-1',
-        hb_auction_id: 'auction-123',
-      },
-      recordTrustedServerOpportunity
-    );
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledWith(
-      mockSlot,
-      'atf_sidebar_ad',
-      'unrenderable_candidate',
-      'auction-123',
-      undefined
-    );
-  });
-
-  it('retains handoff formats when reusing a Trusted Server-defined GPT slot', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const formats: Array<[number, number]> = [
-      [300, 250],
-      [728, 90],
-      [320, 50],
-    ];
-    const { mockSlot } = configureOpportunityDiagnostics(
-      undefined,
-      recordTrustedServerOpportunity,
-      formats
-    );
-    (window as TestWindow).tsjs!.gptSlotHandoffs = {
-      'div-atf-sidebar': {
-        gamUnitPath: '/123/atf',
-        formats,
-        divIdPrefix: 'div-atf-sidebar',
-        slotElementId: 'div-atf-sidebar',
-        publisherClaimed: true,
-        suppressPublisherDisplay: false,
-        suppressPublisherRefresh: false,
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledWith(
-      mockSlot,
-      'atf_sidebar_ad',
-      'no_candidate',
-      undefined,
-      formats
-    );
-  });
-
-  it('forwards configured formats when defining a Trusted Server GPT slot', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const formats: Array<[number, number]> = [
-      [300, 250],
-      [728, 90],
-    ];
-    const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-      undefined,
-      recordTrustedServerOpportunity,
-      formats
-    );
-    mockPubads.getSlots.mockReturnValue([]);
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledWith(
-      mockSlot,
-      'atf_sidebar_ad',
-      'no_candidate',
-      undefined,
-      formats
-    );
-  });
-
-  it('keeps slot delivery running when requested-size diagnostics access throws', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const { mockPubads, mockSlot } = configureOpportunityDiagnostics(
-      undefined,
-      recordTrustedServerOpportunity
-    );
-    Object.defineProperty((window as TestWindow).tsjs!, 'gptSlotHandoffs', {
-      configurable: true,
-      get: () => {
-        throw new Error('diagnostics handoff unavailable');
-      },
-    });
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    expect(() => (window as TestWindow).tsjs!.adInit!()).not.toThrow();
-    expect(recordTrustedServerOpportunity).not.toHaveBeenCalled();
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-    expect(mockPubads.refresh).toHaveBeenCalledWith([mockSlot]);
-  });
-
-  it('records no_candidate when the resolved slot has no bid', async () => {
-    const recordTrustedServerOpportunity = vi.fn();
-    const { mockSlot } = configureOpportunityDiagnostics(undefined, recordTrustedServerOpportunity);
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledWith(
-      mockSlot,
-      'atf_sidebar_ad',
-      'no_candidate',
-      undefined,
-      undefined
-    );
-  });
-
-  it('keeps targeting, display, and refresh running when opportunity diagnostics throws', async () => {
-    const existingSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const definedSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-new-slot'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const refresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([existingSlot]),
-      addEventListener: vi.fn(),
-      refresh,
-    };
-    const display = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(definedSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      display,
-    };
-    const newSlotDiv = document.createElement('div');
-    newSlotDiv.id = 'div-new-slot';
-    document.body.appendChild(newSlotDiv);
-    const recordTrustedServerOpportunity = vi.fn(() => {
-      throw new Error('diagnostics unavailable');
-    });
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-        {
-          id: 'new_slot_ad',
-          gam_unit_path: '/123/new',
-          div_id: 'div-new-slot',
-          formats: [[728, 90]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.00',
-          hb_adid: 'existing-id',
-          adm: '<div>Existing</div>',
-        },
-        new_slot_ad: {
-          hb_pb: '2.00',
-          hb_adid: 'new-id',
-          adm: '<div>New</div>',
-        },
-      },
-      gptDiagnosticsRecorder: {
-        recordTrustedServerOpportunity,
-      } as unknown as TsjsApi['gptDiagnosticsRecorder'],
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    expect(() => (window as TestWindow).tsjs!.adInit!()).not.toThrow();
-
-    expect(recordTrustedServerOpportunity).toHaveBeenCalledTimes(2);
-    expect(existingSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '1.00');
-    expect(definedSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '2.00');
-    expect(display).toHaveBeenCalledWith('div-new-slot');
-    expect(refresh).toHaveBeenCalledWith([existingSlot]);
-  });
-
-  it('reads window.tsjs.bids synchronously and applies bid targeting before refresh', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['abc']),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: { pos: 'atf' },
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.00',
-          hb_bidder: 'kargo',
-          hb_adid: 'abc-uuid',
-          hb_cache_host: 'cache.example.com',
-          hb_cache_path: '/pbc/v1/cache',
-          nurl: 'https://ssp/win',
-          burl: 'https://ssp/bill',
-        },
-      },
-    };
-
-    const fetchSpy = vi.spyOn(global, 'fetch');
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(fetchSpy).not.toHaveBeenCalled();
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '1.00');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_bidder', 'kargo');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_adid', 'abc-uuid');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_cache_host', 'cache.example.com');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_cache_path', '/pbc/v1/cache');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-    expect(mockPubads.enableSingleRequest).toHaveBeenCalledOnce();
-    expect(mockPubads.refresh).toHaveBeenCalled();
-
-    fetchSpy.mockRestore();
-  });
-
-  it('displays TS-defined slots and does not include them in refresh', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      // Publisher has not defined this slot, so TS defines (owns) it.
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: nativeRefresh,
-    };
-    const defineSlotMock = vi.fn().mockReturnValue(mockSlot);
-    const displayMock = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: defineSlotMock,
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(defineSlotMock).toHaveBeenCalled();
-    // GPT requires display() to register/render a freshly-defined slot.
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    // TS-owned slots are displayed, not refreshed (refresh() no-ops for a slot
-    // that was never displayed).
-    expect(nativeRefresh).not.toHaveBeenCalled();
-  });
-
-  it('hands a late publisher definition the TS inner-div slot without a second request', async () => {
-    type FakeSlot = {
-      addService(service: unknown): FakeSlot;
-      setTargeting(key: string, value: string | string[]): FakeSlot;
-      getSlotElementId(): string;
-      getTargeting(key?: string): string[];
-    };
-    const slots = new Map<string, FakeSlot>();
-    const requests: string[] = [];
-    const makeSlot = (elementId: string): FakeSlot => ({
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-      getTargeting: vi.fn().mockReturnValue([]),
-    });
-    const pubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => Array.from(slots.values())),
-      addEventListener: vi.fn(),
-      refresh: vi.fn((requestedSlots?: FakeSlot[]) => {
-        (requestedSlots ?? Array.from(slots.values())).forEach((slot) =>
-          requests.push(slot.getSlotElementId())
-        );
-      }),
-    };
-    const nativeDefineSlot = vi.fn(
-      (_adUnitPath: string, _formats: number[][], elementId: string) => {
-        if (slots.has(elementId)) return null;
-        const slot = makeSlot(elementId);
-        slots.set(elementId, slot);
-        return slot;
-      }
-    );
-    const nativeDisplay = vi.fn((elementId: string) => requests.push(elementId));
-    const destroySlots = vi.fn();
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: nativeDisplay,
-      pubads: vi.fn().mockReturnValue(pubads),
-      destroySlots,
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    const publisherDefineSlot = googletag.defineSlot as unknown as (
-      adUnitPath: string,
-      formats: number[][],
-      elementId: string
-    ) => FakeSlot;
-    const publisherDisplay = googletag.display as unknown as (elementId: string) => void;
-    const publisherSlot = publisherDefineSlot('/123/atf', [[300, 250]], 'div-atf-sidebar');
-    publisherSlot.addService(pubads);
-    publisherDisplay('div-atf-sidebar');
-
-    expect(nativeDefineSlot).toHaveBeenCalledTimes(1);
-    expect(nativeDisplay).toHaveBeenCalledTimes(1);
-    expect(requests).toEqual(['div-atf-sidebar']);
-    expect((window as TestWindow).tsjs!.prevGptSlots).toEqual([]);
-
-    const duplicatePublisherSlot = publisherDefineSlot('/123/atf', [[300, 250]], 'div-atf-sidebar');
-    expect(duplicatePublisherSlot).toBeNull();
-    expect(nativeDefineSlot).toHaveBeenCalledTimes(2);
-
-    (window as TestWindow).tsjs!.adSlots = [];
-    (window as TestWindow).tsjs!.adInit!();
-    expect(destroySlots).not.toHaveBeenCalled();
-  });
-
-  it.each(['slot', 'element'] as const)(
-    'hands a hydrated publisher ID off when it displays by %s',
-    async (displayMode) => {
-      type FakeSlot = {
-        addService(service: unknown): FakeSlot;
-        setTargeting(key: string, value: string | string[]): FakeSlot;
-        getSlotElementId(): string;
-        getTargeting(key?: string): string[];
-      };
-      const ssrDiv = document.getElementById('div-atf-sidebar')!;
-      ssrDiv.id = 'ad-header-0-_R_0_';
-      const hydratedId = 'ad-header-0-_r_1_';
-      const slots = new Map<string, FakeSlot>();
-      const requests: string[] = [];
-      const makeSlot = (elementId: string): FakeSlot => ({
-        addService: vi.fn().mockReturnThis(),
-        setTargeting: vi.fn().mockReturnThis(),
-        getSlotElementId: vi.fn().mockReturnValue(elementId),
-        getTargeting: vi.fn().mockReturnValue([]),
-      });
-      const pubads = {
-        enableSingleRequest: vi.fn(),
-        getSlots: vi.fn(() => Array.from(slots.values())),
-        addEventListener: vi.fn(),
-        refresh: vi.fn(),
-      };
-      const nativeDefineSlot = vi.fn(
-        (_adUnitPath: string, _formats: number[][], elementId: string) => {
-          const slot = makeSlot(elementId);
-          slots.set(elementId, slot);
-          return slot;
-        }
-      );
-      const nativeDisplay = vi.fn((target: string | Element | FakeSlot) => {
-        if (typeof target === 'string') {
-          requests.push(target);
-        } else if ('getSlotElementId' in target) {
-          requests.push(target.getSlotElementId());
-        } else {
-          requests.push(target.id);
-        }
-      });
-      const googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot: nativeDefineSlot,
-        display: nativeDisplay,
-        pubads: vi.fn().mockReturnValue(pubads),
-        enableServices: vi.fn(),
-      };
-      (window as TestWindow).googletag = googletag;
-      (window as TestWindow).tsjs = {
-        adSlots: [
-          {
-            id: 'header_ad',
-            gam_unit_path: '/123/header',
-            div_id: 'ad-header-0-',
-            formats: [[970, 250]],
-            targeting: {},
-          },
-        ],
-        bids: {},
-      };
-
-      const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-      installTsAdInit();
-      (window as TestWindow).tsjs!.adInit!();
-      ssrDiv.id = hydratedId;
-
-      const publisherSlot = (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId: string
-        ) => FakeSlot
-      )('/123/header', [[970, 250]], hydratedId);
-      publisherSlot.addService(pubads);
-      const publisherDisplay = googletag.display as unknown as (
-        target: string | Element | FakeSlot
-      ) => void;
-      publisherDisplay(displayMode === 'slot' ? publisherSlot : ssrDiv);
-
-      expect(nativeDefineSlot).toHaveBeenCalledTimes(1);
-      expect(requests).toEqual(['ad-header-0-_R_0_']);
-      expect((window as TestWindow).tsjs!.gptSlotHandoffs[hydratedId]).toBe(
-        (window as TestWindow).tsjs!.gptSlotHandoffs['ad-header-0-_R_0_']
-      );
-    }
-  );
-
-  it('does not transfer an ambiguous hydrated publisher definition', async () => {
-    type FakeSlot = {
-      addService(service: unknown): FakeSlot;
-      setTargeting(key: string, value: string | string[]): FakeSlot;
-      getSlotElementId(): string;
-      getTargeting(key?: string): string[];
-    };
-    const makeSlot = (elementId: string): FakeSlot => ({
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-      getTargeting: vi.fn().mockReturnValue([]),
-    });
-    const firstSlot = makeSlot('ad-header-0-_R_0_');
-    const secondSlot = makeSlot('ad-header-0-_R_1_');
-    const nativeDefineSlot = vi.fn((_adUnitPath: string, _formats: number[][], elementId: string) =>
-      makeSlot(elementId)
-    );
-    const pubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => [firstSlot, secondSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-      enableServices: vi.fn(),
-    };
-    const firstHandoff = {
-      gamUnitPath: '/123/header',
-      formats: [[970, 250]],
-      divIdPrefix: 'ad-header-0-',
-      slotElementId: 'ad-header-0-_R_0_',
-      publisherClaimed: false,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: false,
-    };
-    const secondHandoff = { ...firstHandoff, slotElementId: 'ad-header-0-_R_1_' };
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: {
-        'ad-header-0-_R_0_': firstHandoff,
-        'ad-header-0-_R_1_': secondHandoff,
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    const defined = (
-      (window as TestWindow).googletag as {
-        defineSlot(adUnitPath: string, formats: number[][], elementId: string): FakeSlot;
-      }
-    ).defineSlot('/123/header', [[970, 250]], 'ad-header-0-_r_1_');
-
-    expect(nativeDefineSlot).toHaveBeenCalledOnce();
-    expect(defined).not.toBe(firstSlot);
-    expect(defined).not.toBe(secondSlot);
-    expect(firstHandoff.publisherClaimed).toBe(false);
-    expect(secondHandoff.publisherClaimed).toBe(false);
-  });
-
-  it('delegates a div-less publisher definition with an unclaimed bundle handoff', async () => {
-    const fallbackSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-ts-fallback'),
-    };
-    const nativeDefineSlot = vi.fn().mockReturnValue(null);
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([fallbackSlot]),
-      refresh: vi.fn(),
-    };
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    const handoff = {
-      gamUnitPath: '/123/fallback',
-      formats: [[300, 250]],
-      divIdPrefix: 'div-ts-',
-      slotElementId: 'div-ts-fallback',
-      publisherClaimed: false,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: false,
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: { 'div-ts-fallback': handoff },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    expect(() =>
-      (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId?: string
-        ) => unknown
-      )('/123/unrelated', [[728, 90]])
-    ).not.toThrow();
-    expect(nativeDefineSlot).toHaveBeenCalledWith('/123/unrelated', [[728, 90]]);
-    expect(handoff.publisherClaimed).toBe(false);
-  });
-
-  it('prunes destroyed TS-owned handoffs and their aliases on SPA navigation', async () => {
-    const slots = new Map<
-      string,
-      {
-        addService(service: unknown): unknown;
-        getSlotElementId(): string;
-        getTargeting(key?: string): string[];
-        setTargeting(key: string, value: string | string[]): unknown;
-      }
-    >();
-    const makeSlot = (elementId: string) => ({
-      addService: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-      getTargeting: vi.fn().mockReturnValue([]),
-      setTargeting: vi.fn().mockReturnThis(),
-    });
-    const destroySlots = vi.fn();
-    const pubads = {
-      addEventListener: vi.fn(),
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => Array.from(slots.values())),
-      refresh: vi.fn(),
-    };
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn((_adUnitPath: string, _formats: number[][], elementId: string) => {
-        const slot = makeSlot(elementId);
-        slots.set(elementId, slot);
-        return slot;
-      }),
-      destroySlots,
-      display: vi.fn(),
-      enableServices: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    const handoff = (window as TestWindow).tsjs!.gptSlotHandoffs['div-atf-sidebar'];
-    (window as TestWindow).tsjs!.gptSlotHandoffs['div-atf-sidebar-hydrated'] = handoff;
-    (window as TestWindow).tsjs!.gptSlotHandoffs.unrelated = {
-      ...handoff,
-      slotElementId: 'div-unrelated',
-    };
-    const ownedSlot = slots.get('div-atf-sidebar')!;
-
-    (window as TestWindow).tsjs!.adSlots = [];
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(destroySlots).toHaveBeenCalledWith([ownedSlot]);
-    expect((window as TestWindow).tsjs!.gptSlotHandoffs).toEqual({
-      unrelated: expect.objectContaining({ slotElementId: 'div-unrelated' }),
-    });
-  });
-
-  it('suppresses a cross-realm element display without throwing', async () => {
-    const nativeDisplay = vi.fn();
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([]),
-      refresh: vi.fn(),
-    };
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      display: nativeDisplay,
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    const iframe = document.createElement('iframe');
-    document.body.appendChild(iframe);
-    const crossRealmElement = iframe.contentDocument!.createElement('div');
-    crossRealmElement.id = 'div-cross-realm';
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: {
-        'div-cross-realm': {
-          gamUnitPath: '/123/cross-realm',
-          formats: [[300, 250]],
-          divIdPrefix: 'div-cross-realm',
-          slotElementId: 'div-cross-realm',
-          publisherClaimed: true,
-          suppressPublisherDisplay: true,
-          suppressPublisherRefresh: false,
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    expect(() =>
-      (googletag.display as unknown as (target: Element) => void)(crossRealmElement)
-    ).not.toThrow();
-    expect(nativeDisplay).not.toHaveBeenCalled();
-    iframe.remove();
-  });
-
-  it('runs the embedded bootstrap handoff for a hydrated publisher ID', async () => {
-    type FakeSlot = {
-      addService(service: unknown): FakeSlot;
-      setTargeting(key: string, value: string | string[]): FakeSlot;
-      getSlotElementId(): string;
-    };
-    const ssrDiv = document.getElementById('div-atf-sidebar')!;
-    const hydratedId = 'ad-header-0-_r_1_';
-    ssrDiv.id = 'ad-header-0-_R_0_';
-    const slots = new Map<string, FakeSlot>();
-    const requests: string[] = [];
-    const makeSlot = (elementId: string): FakeSlot => ({
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-    });
-    const pubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => Array.from(slots.values())),
-      refresh: vi.fn(),
-    };
-    const nativeDefineSlot = vi.fn(
-      (_adUnitPath: string, _formats: number[][], elementId: string) => {
-        if (slots.has(elementId) || elementId === hydratedId) return null;
-        const slot = makeSlot(elementId);
-        slots.set(elementId, slot);
-        return slot;
-      }
-    );
-    const nativeDisplay = vi.fn((target: string | FakeSlot) => {
-      requests.push(typeof target === 'string' ? target : target.getSlotElementId());
-    });
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: nativeDisplay,
-      pubads: vi.fn().mockReturnValue(pubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'header_ad',
-          gam_unit_path: '/123/header',
-          div_id: 'ad-header-0-',
-          formats: [[970, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    runGptBootstrap();
-    (window as TestWindow).tsjs!.adInit!();
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    ssrDiv.id = hydratedId;
-
-    const googletag = (window as TestWindow).googletag as {
-      defineSlot(adUnitPath: string, formats: number[][], elementId: string): FakeSlot | null;
-      display(target: FakeSlot): void;
-    };
-    const publisherSlot = googletag.defineSlot('/123/header', [[970, 250]], ssrDiv.id);
-    expect(publisherSlot).not.toBeNull();
-    googletag.display(publisherSlot!);
-
-    expect(nativeDefineSlot).toHaveBeenCalledTimes(1);
-    expect(requests).toEqual(['ad-header-0-_R_0_']);
-
-    const duplicatePublisherSlot = googletag.defineSlot('/123/header', [[970, 250]], ssrDiv.id);
-    expect(duplicatePublisherSlot).toBeNull();
-    expect(nativeDefineSlot).toHaveBeenCalledTimes(2);
-  });
-
-  it('delegates a div-less publisher definition with an unclaimed bootstrap handoff', () => {
-    const fallbackSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-ts-fallback'),
-    };
-    const nativeDefineSlot = vi.fn().mockReturnValue(null);
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([fallbackSlot]),
-      refresh: vi.fn(),
-    };
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    const handoff = {
-      gamUnitPath: '/123/fallback',
-      formats: [[300, 250]],
-      divIdPrefix: 'div-ts-',
-      slotElementId: 'div-ts-fallback',
-      publisherClaimed: false,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: false,
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: { 'div-ts-fallback': handoff },
-    };
-
-    const bootstrap = readFileSync(
-      resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-      'utf8'
-    );
-    window.eval(bootstrap);
-
-    expect(() =>
-      (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId?: string
-        ) => unknown
-      )('/123/unrelated', [[728, 90]])
-    ).not.toThrow();
-    expect(nativeDefineSlot).toHaveBeenCalledWith('/123/unrelated', [[728, 90]]);
-    expect(handoff.publisherClaimed).toBe(false);
-  });
-
-  it.each(['bootstrap', 'bundle'] as const)(
-    'does not hand a sibling slot to a TS fallback through the %s prefix path',
-    async (implementation) => {
-      const fallbackSlot = {
-        getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      };
-      const siblingSlot = {
-        getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar-2'),
-      };
-      const nativeDefineSlot = vi.fn().mockReturnValue(siblingSlot);
-      const nativeDisplay = vi.fn();
-      const pubads = {
-        getSlots: vi.fn().mockReturnValue([fallbackSlot]),
-        refresh: vi.fn(),
-      };
-      const googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot: nativeDefineSlot,
-        display: nativeDisplay,
-        pubads: vi.fn().mockReturnValue(pubads),
-      };
-      const handoff = {
-        gamUnitPath: '/123/mpu',
-        formats: [[300, 250]],
-        divIdPrefix: 'div-atf-sidebar',
-        slotElementId: 'div-atf-sidebar',
-        publisherClaimed: false,
-        suppressPublisherDisplay: false,
-        suppressPublisherRefresh: false,
-      };
-      const siblingElement = document.createElement('div');
-      siblingElement.id = 'div-atf-sidebar-2';
-      document.body.appendChild(siblingElement);
-      (window as TestWindow).googletag = googletag;
-      (window as TestWindow).tsjs = {
-        gptSlotHandoffs: { 'div-atf-sidebar': handoff },
-      };
-
-      await installHandoff(implementation);
-
-      const publisherSlot = (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId: string
-        ) => typeof siblingSlot
-      )('/123/mpu', [[300, 250]], siblingElement.id);
-      (googletag.display as unknown as (target: string) => void)(siblingElement.id);
-
-      expect(publisherSlot).toBe(siblingSlot);
-      expect(nativeDefineSlot).toHaveBeenCalledOnce();
-      expect(nativeDisplay).toHaveBeenCalledWith(siblingElement.id);
-      expect(handoff.publisherClaimed).toBe(false);
-      expect(handoff.suppressPublisherDisplay).toBe(false);
-    }
-  );
-
-  it.each(['bootstrap', 'bundle'] as const)(
-    'hands a publisher shorthand size to the TS fallback through the %s prefix path',
-    async (implementation) => {
-      const fallbackSlot = {
-        getSlotElementId: vi.fn().mockReturnValue('div-size-original'),
-      };
-      const nativeDefineSlot = vi.fn();
-      const nativeDisplay = vi.fn();
-      const pubads = {
-        getSlots: vi.fn().mockReturnValue([fallbackSlot]),
-        refresh: vi.fn(),
-      };
-      const googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot: nativeDefineSlot,
-        display: nativeDisplay,
-        pubads: vi.fn().mockReturnValue(pubads),
-      };
-      const handoff = {
-        gamUnitPath: '/123/size',
-        formats: [[300, 250]],
-        divIdPrefix: 'div-size-',
-        slotElementId: 'div-size-original',
-        publisherClaimed: false,
-        suppressPublisherDisplay: false,
-        suppressPublisherRefresh: false,
-      };
-      const hydratedElement = document.createElement('div');
-      hydratedElement.id = 'div-size-hydrated';
-      document.body.appendChild(hydratedElement);
-      (window as TestWindow).googletag = googletag;
-      (window as TestWindow).tsjs = {
-        gptSlotHandoffs: { 'div-size-original': handoff },
-      };
-
-      await installHandoff(implementation);
-
-      const publisherSlot = (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[],
-          elementId: string
-        ) => typeof fallbackSlot
-      )('/123/size', [300, 250], hydratedElement.id);
-      (googletag.display as unknown as (target: string) => void)(hydratedElement.id);
-
-      expect(publisherSlot).toBe(fallbackSlot);
-      expect(nativeDefineSlot).not.toHaveBeenCalled();
-      expect(nativeDisplay).not.toHaveBeenCalled();
-      expect(handoff.publisherClaimed).toBe(true);
-      expect(handoff.suppressPublisherDisplay).toBe(false);
-    }
-  );
-
-  it('filters only the claimed slot from the first bootstrap global refresh', () => {
-    const claimedSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-claimed'),
-    };
-    const unrelatedSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-unrelated'),
-    };
-    const nativeRefresh = vi.fn();
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([claimedSlot, unrelatedSlot]),
-      refresh: nativeRefresh,
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: {
-        'div-claimed': {
-          gamUnitPath: '/123/claimed',
-          formats: [[300, 250]],
-          divIdPrefix: 'div-claimed',
-          slotElementId: 'div-claimed',
-          publisherClaimed: true,
-          suppressPublisherDisplay: false,
-          suppressPublisherRefresh: true,
-        },
-      },
-    };
-
-    return installHandoff('bootstrap').then(() => {
-      (pubads.refresh as () => void)();
-
-      expect(nativeRefresh).toHaveBeenCalledWith([unrelatedSlot]);
-      expect((window as TestWindow).tsjs!.gptSlotHandoffs['div-claimed']).toEqual(
-        expect.objectContaining({ suppressPublisherRefresh: false })
-      );
-    });
-  });
-
-  it('preserves refresh options while filtering a claimed bootstrap slot', () => {
-    const claimedSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-claimed'),
-    };
-    const unrelatedSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-unrelated'),
-    };
-    const nativeRefresh = vi.fn();
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([claimedSlot, unrelatedSlot]),
-      refresh: nativeRefresh,
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: {
-        'div-claimed': {
-          gamUnitPath: '/123/claimed',
-          formats: [[300, 250]],
-          divIdPrefix: 'div-claimed',
-          slotElementId: 'div-claimed',
-          publisherClaimed: true,
-          suppressPublisherDisplay: false,
-          suppressPublisherRefresh: true,
-        },
-      },
-    };
-    const refreshOptions = { changeCorrelator: false };
-
-    return installHandoff('bootstrap').then(() => {
-      (pubads.refresh as (slots: (typeof claimedSlot)[], options: typeof refreshOptions) => void)(
-        [claimedSlot, unrelatedSlot],
-        refreshOptions
-      );
-
-      expect(nativeRefresh).toHaveBeenCalledWith([unrelatedSlot], refreshOptions);
-    });
-  });
-
-  it('does not transfer an ambiguous hydrated publisher definition through bootstrap', () => {
-    const firstSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-prefix-original-a'),
-    };
-    const secondSlot = {
-      getSlotElementId: vi.fn().mockReturnValue('div-prefix-original-b'),
-    };
-    const nativeDefineSlot = vi.fn().mockReturnValue(null);
-    const pubads = {
-      getSlots: vi.fn().mockReturnValue([firstSlot, secondSlot]),
-      refresh: vi.fn(),
-    };
-    const firstHandoff = {
-      gamUnitPath: '/123/prefix',
-      formats: [[300, 250]],
-      divIdPrefix: 'div-prefix-',
-      slotElementId: 'div-prefix-original-a',
-      publisherClaimed: false,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: false,
-    };
-    const secondHandoff = {
-      ...firstHandoff,
-      slotElementId: 'div-prefix-original-b',
-    };
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      gptSlotHandoffs: {
-        'div-prefix-original-a': firstHandoff,
-        'div-prefix-original-b': secondHandoff,
-      },
-    };
-
-    return installHandoff('bootstrap').then(() => {
-      const defined = (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId: string
-        ) => null
-      )('/123/prefix', [[300, 250]], 'div-prefix-hydrated');
-
-      expect(defined).toBeNull();
-      expect(nativeDefineSlot).toHaveBeenCalledOnce();
-      expect(firstHandoff.publisherClaimed).toBe(false);
-      expect(secondHandoff.publisherClaimed).toBe(false);
-    });
-  });
-
-  it('preserves refresh options while filtering a claimed disabled-load slot', async () => {
-    type FakeSlot = {
-      addService(service: unknown): FakeSlot;
-      setTargeting(key: string, value: string | string[]): FakeSlot;
-      getSlotElementId(): string;
-      getTargeting(key?: string): string[];
-    };
-    const slots = new Map<string, FakeSlot>();
-    const makeSlot = (elementId: string): FakeSlot => ({
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-      getTargeting: vi.fn().mockReturnValue([]),
-    });
-    const nativeRefresh = vi.fn();
-    const pubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => Array.from(slots.values())),
-      addEventListener: vi.fn(),
-      refresh: nativeRefresh,
-      disableInitialLoad: vi.fn(),
-    };
-    const nativeDefineSlot = vi.fn(
-      (_adUnitPath: string, _formats: number[][], elementId: string) => {
-        const slot = makeSlot(elementId);
-        slots.set(elementId, slot);
-        return slot;
-      }
-    );
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    pubads.disableInitialLoad();
-    (window as TestWindow).tsjs!.adInit!();
-
-    const publisherSlot = (
-      googletag.defineSlot as unknown as (
-        adUnitPath: string,
-        formats: number[][],
-        elementId: string
-      ) => FakeSlot
-    )('/123/atf', [[300, 250]], 'div-atf-sidebar');
-    const unrelatedSlot = makeSlot('div-unrelated');
-    const refreshOptions = { changeCorrelator: false };
-    (
-      pubads.refresh as unknown as (
-        requestedSlots: FakeSlot[],
-        options: { changeCorrelator: boolean }
-      ) => void
-    )([publisherSlot, unrelatedSlot], refreshOptions);
-
-    expect(nativeRefresh).toHaveBeenLastCalledWith([unrelatedSlot], refreshOptions);
-  });
-
-  it('suppresses only the claimed slot from the first disabled-load publisher refresh', async () => {
-    type FakeSlot = {
-      addService(service: unknown): FakeSlot;
-      setTargeting(key: string, value: string | string[]): FakeSlot;
-      getSlotElementId(): string;
-      getTargeting(key?: string): string[];
-    };
-    const slots = new Map<string, FakeSlot>();
-    const requests: string[] = [];
-    let initialLoadDisabled = false;
-    const makeSlot = (elementId: string): FakeSlot => ({
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue(elementId),
-      getTargeting: vi.fn().mockReturnValue([]),
-    });
-    const pubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn(() => Array.from(slots.values())),
-      addEventListener: vi.fn(),
-      refresh: vi.fn((requestedSlots?: FakeSlot[]) => {
-        (requestedSlots ?? Array.from(slots.values())).forEach((slot) =>
-          requests.push(slot.getSlotElementId())
-        );
-      }),
-      disableInitialLoad: vi.fn(() => {
-        initialLoadDisabled = true;
-      }),
-    };
-    const nativeDefineSlot = vi.fn(
-      (_adUnitPath: string, _formats: number[][], elementId: string) => {
-        const slot = makeSlot(elementId);
-        slots.set(elementId, slot);
-        return slot;
-      }
-    );
-    const nativeDisplay = vi.fn((elementId: string) => {
-      if (!initialLoadDisabled) requests.push(elementId);
-    });
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: nativeDefineSlot,
-      display: nativeDisplay,
-      pubads: vi.fn().mockReturnValue(pubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    pubads.disableInitialLoad();
-    (window as TestWindow).tsjs!.adInit!();
-
-    const publisherDefineSlot = googletag.defineSlot as unknown as (
-      adUnitPath: string,
-      formats: number[][],
-      elementId: string
-    ) => FakeSlot;
-    const publisherDisplay = googletag.display as unknown as (elementId: string) => void;
-    const publisherRefresh = pubads.refresh as unknown as () => void;
-    const publisherSlot = publisherDefineSlot('/123/atf', [[300, 250]], 'div-atf-sidebar');
-    publisherSlot.addService(pubads);
-    publisherDisplay('div-atf-sidebar');
-    slots.set('div-unrelated', makeSlot('div-unrelated'));
-    publisherRefresh();
-
-    expect(nativeDefineSlot).toHaveBeenCalledTimes(1);
-    expect(nativeDisplay).toHaveBeenCalledTimes(1);
-    expect(requests.filter((elementId) => elementId === 'div-atf-sidebar')).toHaveLength(1);
-    expect(requests).toContain('div-unrelated');
-  });
-
-  it('refreshes TS-defined slots when the publisher disabled GPT initial load', async () => {
-    // With pubads().disableInitialLoad(), display() only registers a freshly
-    // defined slot — the ad request must come from refresh(). A TS-owned slot
-    // must therefore be refreshed too, or it renders blank.
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      // Publisher has not defined this slot, so TS defines (owns) it.
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: nativeRefresh,
-      disableInitialLoad: vi.fn(),
-    };
-    const getConfigMock = vi.fn().mockReturnValue(undefined);
-    const displayMock = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      // Exercise the wrapper fallback used when the getter has no value.
-      getConfig: getConfigMock,
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    // Publisher disables initial load — goes through the wrapper the detector
-    // installed, recording the state on window.tsjs.
-    mockPubads.disableInitialLoad();
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    // The slot is still registered via display(), and additionally refreshed so
-    // it actually requests an ad under disableInitialLoad().
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-  });
-
-  it('preserves legacy state in the edge bootstrap when getConfig does not report it', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-    };
-    const disableInitialLoadMock = vi.fn();
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      refresh: nativeRefresh,
-      disableInitialLoad: disableInitialLoadMock,
-    };
-    const displayMock = vi.fn();
-    const getConfigMock = vi.fn().mockReturnValue(undefined);
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      getConfig: getConfigMock,
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    await runGptBootstrapWithGoogleTag(googletag);
-
-    mockPubads.disableInitialLoad();
-    expect(disableInitialLoadMock).toHaveBeenCalledOnce();
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-  });
-
-  it('tracks setConfig state and re-enabling in the edge bootstrap', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-    };
-    type InitialLoadConfig = {
-      disableInitialLoad?: boolean | null;
-    };
-    let effectiveConfig: { disableInitialLoad?: boolean } = {};
-    const setConfigMock = vi.fn((config: InitialLoadConfig) => {
-      if ('disableInitialLoad' in config) {
-        effectiveConfig = { disableInitialLoad: config.disableInitialLoad === true };
-      }
-    });
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      refresh: nativeRefresh,
-    };
-    const displayMock = vi.fn();
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      getConfig: undefined as undefined | (() => { disableInitialLoad?: boolean }),
-      setConfig: setConfigMock,
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    await runGptBootstrapWithGoogleTag(googletag);
-
-    // Older GPT runtimes may expose setConfig without getConfig. In that case,
-    // the wrapper tracks explicit initial-load updates directly.
-    googletag.setConfig({ disableInitialLoad: true });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-    googletag.setConfig({ disableInitialLoad: false });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    googletag.getConfig = vi.fn(() => effectiveConfig);
-    setConfigMock.mockClear();
-    googletag.setConfig({ disableInitialLoad: true });
-    expect(setConfigMock).toHaveBeenCalledOnce();
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-
-    nativeRefresh.mockClear();
-    googletag.setConfig({ disableInitialLoad: false });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    googletag.setConfig({ disableInitialLoad: true });
-    googletag.setConfig({ disableInitialLoad: null });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-  });
-
-  it('tracks the effective initial-load state from setConfig', async () => {
-    // Modern GPT configuration uses googletag.setConfig() rather than the
-    // legacy pubads().disableInitialLoad() method. TS must detect both forms.
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    type InitialLoadConfig = {
-      disableInitialLoad?: boolean | null;
-      singleRequest?: boolean;
-    };
-    let effectiveConfig: { disableInitialLoad?: boolean } = {};
-    const setConfigMock = vi.fn((config: InitialLoadConfig) => {
-      if ('disableInitialLoad' in config) {
-        effectiveConfig = { disableInitialLoad: config.disableInitialLoad === true };
-      }
-    });
-    const disableInitialLoadMock = vi.fn(() => {
-      effectiveConfig = { disableInitialLoad: true };
-    });
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      // Publisher has not defined this slot, so TS defines (owns) it.
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: nativeRefresh,
-      disableInitialLoad: disableInitialLoadMock,
-    };
-    const displayMock = vi.fn();
-    const getConfigMock = vi.fn(() => effectiveConfig);
-    const googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      getConfig: undefined as undefined | typeof getConfigMock,
-      setConfig: setConfigMock,
-    };
-    (window as TestWindow).googletag = googletag;
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    installTsAdInit();
-
-    const gpt = (window as TestWindow).googletag as {
-      setConfig(config: InitialLoadConfig): void;
-    };
-    gpt.setConfig({ singleRequest: true });
-    expect(setConfigMock).toHaveBeenCalledOnce();
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).not.toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    // Fall back to the explicit setConfig value when getConfig is unavailable.
-    gpt.setConfig({ disableInitialLoad: true });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-    gpt.setConfig({ disableInitialLoad: false });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    googletag.getConfig = getConfigMock;
-    setConfigMock.mockClear();
-    const config = { disableInitialLoad: true, singleRequest: true };
-    gpt.setConfig(config);
-    expect(setConfigMock).toHaveBeenCalledOnce();
-    expect(setConfigMock).toHaveBeenLastCalledWith(config);
-    expect(getConfigMock).toHaveBeenCalledWith('disableInitialLoad');
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    // The slot already spent its first impression above. Changing GPT's
-    // initial-load mode must not make a repeated adInit request it again.
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    nativeRefresh.mockClear();
-    gpt.setConfig({ disableInitialLoad: false });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-    gpt.setConfig({ disableInitialLoad: null });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    // GPT exposes one effective setting across the modern and legacy APIs.
-    // A legacy call made after setConfig(false) disables initial load.
-    mockPubads.disableInitialLoad();
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    // A later modern call can re-enable initial load after the legacy API.
-    nativeRefresh.mockClear();
-    gpt.setConfig({ disableInitialLoad: false });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-
-    // Resetting the setting to its default has the same effective result.
-    mockPubads.disableInitialLoad();
-    gpt.setConfig({ disableInitialLoad: null });
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(false);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(nativeRefresh).not.toHaveBeenCalled();
-  });
-
-  it('reads initial-load configuration effective before detector installation', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: nativeRefresh,
-    };
-    const displayMock = vi.fn();
-    const getConfigMock = vi.fn().mockReturnValue({ disableInitialLoad: true });
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      display: displayMock,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      getConfig: getConfigMock,
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    expect(getConfigMock).toHaveBeenCalledWith('disableInitialLoad');
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(displayMock).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-  });
-
-  it('sets adInitRefreshInProgress only for the duration of the internal refresh', async () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    let flagDuringRefresh: boolean | undefined;
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      // Publisher-owned slot reused by TS, so it goes through refresh() (which
-      // carries the bypass flag) rather than display().
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(() => {
-        flagDuringRefresh = (window as TestWindow).tsjs!.adInitRefreshInProgress;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } as any;
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(mockPubads.refresh).toHaveBeenCalled();
-    expect(flagDuringRefresh).toBe(true);
-    expect((window as TestWindow).tsjs!.adInitRefreshInProgress).toBe(false);
-  });
-
-  it('clears stale TS targeting from previously touched slots when the new route has no TS slots', async () => {
-    const clearTargeting = vi.fn().mockReturnThis();
-    const staleSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      clearTargeting,
-      getSlotElementId: vi.fn().mockReturnValue('div-old-route'),
-      getTargeting: vi.fn((key: string) => (key === 'ts' ? ['publisher-value'] : [])),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([staleSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      // New route has no matching TS slots.
-      adSlots: [],
-      bids: {},
-      // Previous route touched the publisher-owned slot on div-old-route.
-      divToSlotId: { 'div-old-route': 'old_slot' },
-      prevSlotTargetingKeys: { 'div-old-route': ['pos'] },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(clearTargeting).toHaveBeenCalledWith('hb_pb');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_bidder');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_host');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_path');
-    expect(clearTargeting).toHaveBeenCalledWith('ts_initial');
-    expect(clearTargeting).toHaveBeenCalledWith('pos');
-    expect(clearTargeting).not.toHaveBeenCalledWith('ts');
-    expect(mockPubads.refresh).not.toHaveBeenCalled();
-    expect((window as TestWindow).tsjs!.divToSlotId).toEqual({});
-    expect((window as TestWindow).tsjs!.prevSlotTargetingKeys).toEqual({});
-  });
-
-  it('does not enable GPT services when the page-bids response has no slots', async () => {
-    // A gated page-bids response returns no slots. With nothing to display or
-    // refresh and services not already enabled, adInit() must not call
-    // enableSingleRequest()/enableServices() and activate the publisher's GPT
-    // services on a consent-denied or kill-switched navigation.
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    const enableServices = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices,
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(mockPubads.enableSingleRequest).not.toHaveBeenCalled();
-    expect(enableServices).not.toHaveBeenCalled();
-    expect((window as TestWindow).tsjs!.servicesEnabled).toBeFalsy();
-    expect(mockPubads.refresh).not.toHaveBeenCalled();
-  });
-
-  it('keeps the GAM path when a bid carries inline adm (adInit does not inject)', async () => {
-    const slotEl = document.getElementById('div-atf-sidebar')!;
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['debug-uuid']),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    const destroySlots = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      destroySlots,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: { pos: 'atf' },
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '0.20',
-          hb_bidder: 'mocktioneer',
-          hb_adid: 'debug-uuid',
-          adm: '<div>Inline creative</div>',
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(slotEl.innerHTML).toBe('');
-    expect(destroySlots).not.toHaveBeenCalledWith([mockSlot]);
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '0.20');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_bidder', 'mocktioneer');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_adid', 'debug-uuid');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-    expect(mockPubads.refresh).toHaveBeenCalledWith([mockSlot]);
-  });
-
-  // Helper: full adInit setup for a single slot whose bid carries an iframe adm.
-  // `debugBid` toggles the per-bid `debug_bid` field that gates the testing bypass.
-  async function fireSlotRenderWithAdm(debugBid: boolean): Promise<HTMLIFrameElement> {
-    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['abc']),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      refresh: vi.fn(),
-      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
-        if (event === 'slotRenderEnded') capturedListener = fn;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.00',
-          hb_bidder: 'kargo',
-          hb_adid: 'abc',
-          adm: '<iframe src="https://cdn.example/creative.html"></iframe>',
-          ...(debugBid ? { debug_bid: { slot_id: 'atf_sidebar_ad' } } : {}),
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    // A pre-existing GAM iframe; the bypass, if it runs, rewrites its src.
-    const slotEl = document.getElementById('div-atf-sidebar')!;
-    const gamIframe = document.createElement('iframe');
-    gamIframe.src = 'about:blank';
-    slotEl.appendChild(gamIframe);
-
-    expect(capturedListener).toBeDefined();
-    capturedListener!({ isEmpty: false, slot: mockSlot });
-    return gamIframe;
-  }
-
-  it('does not run the GAM-replace bypass without debug_bid (production)', async () => {
-    const gamIframe = await fireSlotRenderWithAdm(false);
-    // No debug_bid ⇒ testing bypass is off; the render bridge handles the creative
-    // and GAM stays in the loop, so the GAM iframe src is untouched.
-    expect(gamIframe.src).toBe('about:blank');
-  });
-
-  it('runs the GAM-replace bypass when debug_bid is present (testing)', async () => {
-    const gamIframe = await fireSlotRenderWithAdm(true);
-    // debug_bid present ⇒ inject_adm_for_testing on ⇒ direct GAM replace fires,
-    // rewriting the iframe to the creative URL from the adm.
-    expect(gamIframe.src).toBe('https://cdn.example/creative.html');
-  });
-
-  it('does not fire win/billing beacons from slotRenderEnded targeting alone', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
-
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['abc']),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      refresh: vi.fn(),
-      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
-        if (event === 'slotRenderEnded') capturedListener = fn;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.00',
-          hb_bidder: 'kargo',
-          hb_adid: 'abc',
-          nurl: 'https://ssp/win',
-          burl: 'https://ssp/bill',
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(capturedListener).toBeDefined();
-    capturedListener!({ isEmpty: false, slot: mockSlot });
-
-    expect(beaconSpy).not.toHaveBeenCalled();
-
-    // GPT slot targeting is request state, not proof that the TS creative
-    // rendered. A repeated non-empty render must still not bill from this path.
-    capturedListener!({ isEmpty: false, slot: mockSlot });
-    expect(beaconSpy).not.toHaveBeenCalled();
-
-    beaconSpy.mockRestore();
-  });
-
-  it('does not fire beacons for an APS-style bid that carries no hb_adid', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
-
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      refresh: vi.fn(),
-      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
-        if (event === 'slotRenderEnded') capturedListener = fn;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.50',
-          hb_bidder: 'aps',
-          nurl: 'https://aps/win',
-          burl: 'https://aps/bill',
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(capturedListener).toBeDefined();
-
-    // Without an hb_adid to confirm the rendered creative is ours, a non-empty
-    // render is not proof of a TS win: the slot could have been filled by other
-    // GAM demand. The beacon must not fire, so we never over-report billing.
-    capturedListener!({ isEmpty: false, slot: mockSlot });
-    expect(beaconSpy).not.toHaveBeenCalled();
-
-    beaconSpy.mockRestore();
-  });
-
-  it('does not fire nurl/burl when bid did not win GAM line item', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
-
-    const mockSlotNoMatch = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['OTHER_BID_ID']),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlotNoMatch]),
-      refresh: vi.fn(),
-      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
-        if (event === 'slotRenderEnded') capturedListener = fn;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlotNoMatch),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.00',
-          hb_bidder: 'kargo',
-          hb_adid: 'abc',
-          nurl: 'https://ssp/win',
-          burl: 'https://ssp/bill',
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-    capturedListener!({ isEmpty: false, slot: mockSlotNoMatch });
-
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('does not fire beacons for slotRenderEnded on slots not owned by TS', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
-
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue(['abc']),
-    };
-    const arenaSlot = {
-      getSlotElementId: () => 'arena-owned-div',
-      getTargeting: () => [],
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      refresh: vi.fn(),
-      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
-        if (event === 'slotRenderEnded') capturedListener = fn;
-      }),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: { hb_pb: '1.00', hb_bidder: 'kargo', hb_adid: 'abc' },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    capturedListener!({ isEmpty: false, slot: arenaSlot });
-
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('does not call native apstag for a Trusted Server APS renderer winner', async () => {
-    const setDisplayBidsSpy = vi.fn();
-    (window as TestWindow).apstag = { setDisplayBids: setDisplayBidsSpy };
-
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: {
-          hb_pb: '1.50',
-          hb_bidder: 'aps',
-          hb_adid: envelope.seatbid[0].bid[0].id,
-          renderer: apsRenderer(),
-        },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(setDisplayBidsSpy).not.toHaveBeenCalled();
-    expect((window as TestWindow).apstag).toEqual({ setDisplayBids: setDisplayBidsSpy });
-
-    delete (window as TestWindow).apstag;
-  });
-
-  it('does not call apstag.setDisplayBids when hb_bidder is not aps', async () => {
-    const setDisplayBidsSpy = vi.fn();
-    (window as TestWindow).apstag = { setDisplayBids: setDisplayBidsSpy };
-
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(mockSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {
-        atf_sidebar_ad: { hb_pb: '1.00', hb_bidder: 'kargo' },
-      },
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(setDisplayBidsSpy).not.toHaveBeenCalled();
-
-    delete (window as TestWindow).apstag;
-  });
-
-  it('calls refresh even when tsjs.bids is empty (graceful fallback)', async () => {
-    const emptyTestSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([emptyTestSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue({
-        addService: vi.fn().mockReturnThis(),
-        setTargeting: vi.fn().mockReturnThis(),
-      }),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'atf_sidebar_ad',
-          gam_unit_path: '/123/atf',
-          div_id: 'div-atf-sidebar',
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-    (window as TestWindow).tsjs!.adInit!();
-
-    expect(mockPubads.refresh).toHaveBeenCalled();
-  });
-
-  it.each([
-    { implementation: 'runtime', activeIndexes: [2], publisherOwned: true, selectedIndex: 2 },
-    { implementation: 'runtime', activeIndexes: [], selectedIndex: null },
-    {
-      implementation: 'runtime',
-      candidateIndexes: [2],
-      activeIndexes: [],
-      selectedIndex: null,
-    },
-    {
-      implementation: 'runtime',
-      activeIndexes: [],
-      elementLayoutIndexes: [1],
-      visibleContainerIndexes: [1],
-      selectedIndex: 1,
-    },
-    { implementation: 'runtime', activeIndexes: [0, 2], selectedIndex: null },
-    {
-      implementation: 'runtime',
-      activeIndexes: [2, 3],
-      hiddenElementIndexes: [2],
-      selectedIndex: 3,
-    },
-    {
-      implementation: 'runtime',
-      activeIndexes: [],
-      hiddenElementIndexes: [0, 1, 3],
-      visibleContainerIndexes: [2],
-      selectedIndex: 2,
-    },
-    {
-      implementation: 'runtime',
-      activeIndexes: [],
-      hiddenElementIndexes: [0, 1, 3],
-      visibleContainerIndexes: [1, 2],
-      containerWidthIndexes: [2],
-      selectedIndex: 2,
-    },
-    { implementation: 'runtime', activeIndexes: [2], divId: '', selectedIndex: null },
-    { implementation: 'bootstrap', activeIndexes: [2], publisherOwned: true, selectedIndex: 2 },
-    { implementation: 'bootstrap', activeIndexes: [], selectedIndex: null },
-    {
-      implementation: 'bootstrap',
-      candidateIndexes: [2],
-      activeIndexes: [],
-      selectedIndex: null,
-    },
-    {
-      implementation: 'bootstrap',
-      activeIndexes: [],
-      elementLayoutIndexes: [1],
-      visibleContainerIndexes: [1],
-      selectedIndex: 1,
-    },
-    { implementation: 'bootstrap', activeIndexes: [0, 2], selectedIndex: null },
-    {
-      implementation: 'bootstrap',
-      activeIndexes: [2, 3],
-      hiddenElementIndexes: [2],
-      selectedIndex: 3,
-    },
-    {
-      implementation: 'bootstrap',
-      activeIndexes: [],
-      hiddenElementIndexes: [0, 1, 3],
-      visibleContainerIndexes: [2],
-      selectedIndex: 2,
-    },
-    {
-      implementation: 'bootstrap',
-      activeIndexes: [],
-      hiddenElementIndexes: [0, 1, 3],
-      visibleContainerIndexes: [1, 2],
-      containerWidthIndexes: [2],
-      selectedIndex: 2,
-    },
-    { implementation: 'bootstrap', activeIndexes: [2], divId: '', selectedIndex: null },
-  ] as const)(
-    '$implementation resolves responsive matches $activeIndexes to $selectedIndex',
-    async (testCase) => {
-      const { implementation, activeIndexes, selectedIndex } = testCase;
-      const hiddenElementIndexes =
-        'hiddenElementIndexes' in testCase ? testCase.hiddenElementIndexes : [];
-      const elementLayoutIndexes =
-        'elementLayoutIndexes' in testCase ? testCase.elementLayoutIndexes : [];
-      const visibleContainerIndexes =
-        'visibleContainerIndexes' in testCase ? testCase.visibleContainerIndexes : activeIndexes;
-      const containerWidthIndexes =
-        'containerWidthIndexes' in testCase ? testCase.containerWidthIndexes : activeIndexes;
-      const containerHeightIndexes =
-        'containerHeightIndexes' in testCase ? testCase.containerHeightIndexes : activeIndexes;
-      const elementWidthIndexes =
-        'elementWidthIndexes' in testCase ? testCase.elementWidthIndexes : elementLayoutIndexes;
-      const elementHeightIndexes =
-        'elementHeightIndexes' in testCase ? testCase.elementHeightIndexes : elementLayoutIndexes;
-      const candidateIndexes =
-        'candidateIndexes' in testCase ? testCase.candidateIndexes : [0, 1, 2, 3];
-      const divId = 'divId' in testCase ? testCase.divId : 'ad-responsive-';
-      const publisherOwned = 'publisherOwned' in testCase && testCase.publisherOwned;
-      const elements = ['a', 'b', 'c', 'd'].map((suffix, index) =>
-        appendResponsiveSlotElement(
-          (candidateIndexes as readonly number[]).includes(index)
-            ? `ad-responsive-${suffix}`
-            : `unrelated-responsive-${suffix}`,
-          {
-            containerVisible: (visibleContainerIndexes as readonly number[]).includes(index),
-            containerWidth: (containerWidthIndexes as readonly number[]).includes(index) ? 320 : 0,
-            containerHeight: (containerHeightIndexes as readonly number[]).includes(index)
-              ? 100
-              : 0,
-            elementHidden: (hiddenElementIndexes as readonly number[]).includes(index),
-            elementWidth: (elementWidthIndexes as readonly number[]).includes(index) ? 300 : 0,
-            elementHeight: (elementHeightIndexes as readonly number[]).includes(index) ? 250 : 0,
-          }
-        )
-      );
-      const selectedElement = selectedIndex === null ? undefined : elements[selectedIndex];
-      expect(resolveFirstImpressionElement(divId)).toBe(selectedElement);
-      const mockSlot = {
-        addService: vi.fn().mockReturnThis(),
-        setTargeting: vi.fn().mockReturnThis(),
-        getSlotElementId: vi.fn().mockReturnValue(selectedElement?.id ?? elements[0]!.id),
-        getTargeting: vi.fn().mockReturnValue([]),
-      };
-      const nativeRefresh = vi.fn();
-      const mockPubads = {
-        enableSingleRequest: vi.fn(),
-        getSlots: vi.fn().mockReturnValue(publisherOwned ? [mockSlot] : []),
-        addEventListener: vi.fn(),
-        refresh: nativeRefresh,
-      };
-      const defineSlot = vi.fn().mockReturnValue(mockSlot);
-      const nativeDisplay = vi.fn();
-      (window as TestWindow).googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot,
-        display: nativeDisplay,
-        pubads: vi.fn().mockReturnValue(mockPubads),
-        enableServices: vi.fn(),
-      };
-      (window as TestWindow).tsjs = {
-        adSlots: [
-          {
-            id: 'responsive_slot',
-            gam_unit_path: '/123/responsive',
-            div_id: divId,
-            formats: [[300, 250]],
-            targeting: {},
-          },
-        ],
-        bids: {},
-      };
-
-      if (implementation === 'runtime') {
-        const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-        installTsAdInit();
-      } else {
-        runGptBootstrap();
-      }
-      (window as TestWindow).tsjs!.adInit!();
-
-      if (selectedElement) {
-        if (publisherOwned) {
-          expect(defineSlot).not.toHaveBeenCalled();
-          expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-        } else {
-          expect(defineSlot).toHaveBeenCalledWith(
-            '/123/responsive',
-            [[300, 250]],
-            selectedElement.id
-          );
-          expect(nativeDisplay).toHaveBeenCalledWith(selectedElement.id);
-        }
-        expect((window as TestWindow).tsjs!.divToSlotId).toEqual({
-          [selectedElement.id]: 'responsive_slot',
-        });
-      } else {
-        expect(defineSlot).not.toHaveBeenCalled();
-        expect((window as TestWindow).tsjs!.divToSlotId).toEqual({});
-      }
-    }
-  );
-
-  it.each(['runtime', 'bootstrap'] as const)(
-    '$implementation reports an ambiguous prefix once during adInit',
-    async (implementation) => {
-      const elements = ['a', 'b', 'c', 'd'].map((suffix) =>
-        appendResponsiveSlotElement(`ad-warning-${suffix}`, { containerVisible: true })
-      );
-      const mockSlot = {
-        addService: vi.fn().mockReturnThis(),
-        setTargeting: vi.fn().mockReturnThis(),
-        getSlotElementId: vi.fn().mockReturnValue(elements[0]!.id),
-        getTargeting: vi.fn().mockReturnValue([]),
-      };
-      const mockPubads = {
-        enableSingleRequest: vi.fn(),
-        getSlots: vi.fn().mockReturnValue([]),
-        addEventListener: vi.fn(),
-        refresh: vi.fn(),
-      };
-      (window as TestWindow).googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot: vi.fn().mockReturnValue(mockSlot),
-        display: vi.fn(),
-        pubads: vi.fn().mockReturnValue(mockPubads),
-        enableServices: vi.fn(),
-      };
-      const bootstrapWarn = vi.fn();
-      (window as TestWindow).tsjs = {
-        adSlots: [
-          {
-            id: 'warning_slot',
-            gam_unit_path: '/123/warning',
-            div_id: 'ad-warning-',
-            formats: [[300, 250]],
-            targeting: {},
-          },
-          {
-            id: 'warning_slot_duplicate',
-            gam_unit_path: '/123/warning',
-            div_id: 'ad-warning-',
-            formats: [[300, 250]],
-            targeting: {},
-          },
-        ],
-        bids: {},
-        ...(implementation === 'bootstrap' ? { log: { warn: bootstrapWarn } } : {}),
-      };
-
-      const runtimeWarn = vi.spyOn(console, 'warn');
-      if (implementation === 'runtime') {
-        const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-        installTsAdInit();
-      } else {
-        runGptBootstrap();
-      }
-      (window as TestWindow).tsjs!.adInit!();
-
-      if (implementation === 'runtime') {
-        const warningCall = runtimeWarn.mock.calls.find((call) =>
-          call.includes('GPT slot prefix did not resolve to one active element')
-        );
-        expect(runtimeWarn).toHaveBeenCalledTimes(1);
-        expect(warningCall).toEqual(
-          expect.arrayContaining([
-            expect.objectContaining({
-              divId: 'ad-warning-',
-              prefixMatchCount: 4,
-              activeMatchCount: 0,
-            }),
-          ])
-        );
-      } else {
-        expect(bootstrapWarn).toHaveBeenCalledTimes(1);
-        expect(bootstrapWarn).toHaveBeenCalledWith(
-          'GPT slot prefix did not resolve to one active element',
-          {
-            divId: 'ad-warning-',
-            prefixMatchCount: 4,
-            activeMatchCount: 0,
-          }
-        );
-      }
-      runtimeWarn.mockRestore();
-    }
-  );
-
-  it.each(['runtime', 'bootstrap'] as const)(
-    '$implementation trusts checkVisibility when resolving a visible slot',
-    async (implementation) => {
-      const element = appendResponsiveSlotElement('ad-native-slot', {
-        checkVisibility: true,
-      });
-      const mockSlot = {
-        addService: vi.fn().mockReturnThis(),
-        setTargeting: vi.fn().mockReturnThis(),
-        getSlotElementId: vi.fn().mockReturnValue(element.id),
-        getTargeting: vi.fn().mockReturnValue([]),
-      };
-      const defineSlot = vi.fn().mockReturnValue(mockSlot);
-      const mockPubads = {
-        enableSingleRequest: vi.fn(),
-        getSlots: vi.fn().mockReturnValue([]),
-        addEventListener: vi.fn(),
-        refresh: vi.fn(),
-      };
-      (window as TestWindow).googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot,
-        display: vi.fn(),
-        pubads: vi.fn().mockReturnValue(mockPubads),
-        enableServices: vi.fn(),
-      };
-      (window as TestWindow).tsjs = {
-        adSlots: [
-          {
-            id: 'native_visibility_slot',
-            gam_unit_path: '/123/native-visibility',
-            div_id: 'ad-native-',
-            formats: [[300, 250]],
-            targeting: {},
-          },
-        ],
-        bids: {},
-      };
-
-      if (implementation === 'runtime') {
-        const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-        installTsAdInit();
-      } else {
-        runGptBootstrap();
-      }
-      (window as TestWindow).tsjs!.adInit!();
-
-      expect(defineSlot).toHaveBeenCalledWith('/123/native-visibility', [[300, 250]], element.id);
-    }
-  );
-
-  it('resolves dynamic div prefixes without interpolating div_id into a CSS selector', async () => {
-    const dynamicDiv = document.createElement('div');
-    dynamicDiv.id = "ad'prefix-real";
-    document.body.appendChild(dynamicDiv);
-
-    const dynamicSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue("ad'prefix-real"),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([dynamicSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(dynamicSlot),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    (window as TestWindow).tsjs = {
-      adSlots: [
-        {
-          id: 'dynamic_slot',
-          gam_unit_path: '/123/dynamic',
-          div_id: "ad'prefix-",
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ],
-      bids: {},
-    };
-
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    installTsAdInit();
-
-    expect(() => (window as TestWindow).tsjs!.adInit!()).not.toThrow();
-    expect(mockPubads.refresh).toHaveBeenCalledWith([dynamicSlot]);
-  });
-});
-
-describe('parseCachedBid', () => {
-  async function parseCachedBid(body: string) {
-    const mod = await import('../../../src/integrations/gpt/index');
-    return mod.parseCachedBid(body);
-  }
-
-  it('decodes adm, dimensions, and price from a PBS Cache bid object', async () => {
-    const bid = await parseCachedBid(
-      JSON.stringify({ adm: '<div>cached</div>', w: 300, h: 250, price: 1.23 })
-    );
-    expect(bid).toEqual({ adm: '<div>cached</div>', width: 300, height: 250, price: 1.23 });
-  });
-
-  it('accepts width/height as an alternate dimension spelling', async () => {
-    const bid = await parseCachedBid(
-      JSON.stringify({ adm: '<div>cached</div>', width: 728, height: 90 })
-    );
-    expect(bid?.width).toBe(728);
-    expect(bid?.height).toBe(90);
-  });
-
-  it('treats zero dimensions as absent so the caller falls back', async () => {
-    const bid = await parseCachedBid(JSON.stringify({ adm: '<div>cached</div>', w: 0, h: 0 }));
-    expect(bid?.width).toBeUndefined();
-    expect(bid?.height).toBeUndefined();
-  });
-
-  it('treats a non-JSON body as raw creative markup with no metadata', async () => {
-    const bid = await parseCachedBid('<div>raw</div>');
-    expect(bid).toEqual({ adm: '<div>raw</div>' });
-  });
-
-  it('returns undefined when the JSON payload carries no usable adm', async () => {
-    expect(await parseCachedBid(JSON.stringify({ w: 300, h: 250 }))).toBeUndefined();
-    expect(await parseCachedBid('   ')).toBeUndefined();
-  });
-});
-
-describe('installTsRenderBridge', () => {
-  let fetchStub: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.resetModules();
-    publisherNativeScript = undefined;
-    // Remove ALL accumulated 'message' handlers from previous test module imports
-    // to prevent stale bridge listeners from intercepting our test event.
-    for (const handler of allMessageHandlers) {
-      window.removeEventListener('message', handler);
-    }
-    allMessageHandlers.length = 0;
-
-    fetchStub = vi.fn();
-    vi.stubGlobal('fetch', fetchStub);
-    if (typeof navigator.sendBeacon !== 'function') {
-      Object.defineProperty(navigator, 'sendBeacon', {
-        value: vi.fn().mockReturnValue(true),
-        writable: true,
-        configurable: true,
-      });
-    }
-
-    (window as TestWindow).tsjs = {
-      bids: {
-        homepage_header: {
-          hb_adid: 'test-cache-uuid',
-          hb_bidder: 'kargo',
-          hb_pb: '1.50',
-          hb_cache_host: 'openads.example.com',
-          hb_cache_path: '/cache',
-          nurl: 'https://ssp.example/win',
-          burl: 'https://ssp.example/bill',
-        },
-      },
-      adSlots: [
-        {
-          id: 'homepage_header',
-          formats: [[728, 90]] as [number, number][],
-          gam_unit_path: '/a/b/c',
-          div_id: 'div-header',
-          targeting: {},
-        },
-      ],
-      divToSlotId: { 'div-header': 'homepage_header' },
-    };
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    document.getElementById('div-header')?.remove();
-    delete (window as TestWindow).tsjs;
-  });
-
-  function createTrustedSlotIframe(divId = 'div-header'): Window {
-    const slot = document.createElement('div');
-    slot.id = divId;
-    const iframe = document.createElement('iframe');
-    slot.appendChild(iframe);
-    document.body.appendChild(slot);
-    return iframe.contentWindow!;
-  }
-
-  function createCollapsedTrustedSlotIframe(divId = 'div-header') {
-    const slot = document.createElement('div');
-    slot.id = divId;
-    const wrapper = document.createElement('div');
-    wrapper.style.width = '1px';
-    wrapper.style.height = '1px';
-    const iframe = document.createElement('iframe');
-    iframe.width = '1';
-    iframe.height = '1';
-    iframe.style.width = '1px';
-    iframe.style.height = '1px';
-    wrapper.appendChild(iframe);
-    slot.appendChild(wrapper);
-    document.body.appendChild(slot);
-    return { iframe, slot, source: iframe.contentWindow!, wrapper };
-  }
-
-  async function captureBridgeListener(): Promise<(e: MessageEvent) => unknown> {
-    let bridgeListener: ((e: MessageEvent) => unknown) | undefined;
-    const origAdd = window.addEventListener.bind(window);
-    const currentScriptSpy = publisherNativeScript
-      ? vi.spyOn(document, 'currentScript', 'get').mockReturnValue(publisherNativeScript)
-      : undefined;
-    const addSpy = vi
-      .spyOn(window, 'addEventListener')
-      .mockImplementation(
-        (type: string, handler: EventListenerOrEventListenerObject, opts?: unknown) => {
-          if (type === 'message') bridgeListener = handler as (e: MessageEvent) => unknown;
-          origAdd(
-            type,
-            handler as EventListener,
-            opts as boolean | AddEventListenerOptions | undefined
-          );
-        }
-      );
-    await import('../../../src/integrations/gpt/index');
-    addSpy.mockRestore();
-    currentScriptSpy?.mockRestore();
-
-    expect(bridgeListener, 'bridge listener should be registered').toBeDefined();
-    return bridgeListener!;
-  }
-
-  it('records an inline creative request and response with the same opaque attempt ID', async () => {
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(41);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    tsjs.bids.homepage_header.adm = '<div>Creative</div>';
-    delete tsjs.bids.homepage_header.nurl;
-    delete tsjs.bids.homepage_header.burl;
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const postMessage = vi.fn();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-
-    expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-    expect(postMessage).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeResponse).toHaveBeenCalledWith(41);
-    expect(postMessage.mock.invocationCallOrder[0]).toBeLessThan(
-      recordTrustedServerCreativeResponse.mock.invocationCallOrder[0]
-    );
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-  });
-
-  it('expands an authenticated collapsed inline creative shell after response delivery', async () => {
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.bids.homepage_header.adm = '<div>Fictional creative</div>';
-    tsjs.bids.homepage_header.w = 728;
-    tsjs.bids.homepage_header.h = 90;
-    delete tsjs.bids.homepage_header.nurl;
-    delete tsjs.bids.homepage_header.burl;
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const postMessage = vi.fn();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source: collapsed.iframe.contentWindow!,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-
-    expect(postMessage).toHaveBeenCalledOnce();
-    expect(collapsed.iframe.width).toBe('728');
-    expect(collapsed.iframe.height).toBe('90');
-    expect(collapsed.wrapper.style.width).toBe('728px');
-    expect(collapsed.wrapper.style.height).toBe('90px');
-  });
-
-  it('expands every collapsed ancestor through the authenticated slot root', async () => {
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.bids.homepage_header.adm = '<div>Fictional creative</div>';
-    tsjs.bids.homepage_header.w = 728;
-    tsjs.bids.homepage_header.h = 90;
-    delete tsjs.bids.homepage_header.nurl;
-    delete tsjs.bids.homepage_header.burl;
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const outerWrapper = document.createElement('div');
-    outerWrapper.style.width = '1px';
-    outerWrapper.style.height = '1px';
-    collapsed.slot.insertBefore(outerWrapper, collapsed.wrapper);
-    outerWrapper.appendChild(collapsed.wrapper);
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage: vi.fn() }],
-        source: collapsed.iframe.contentWindow!,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-
-    expect(collapsed.wrapper.style.width).toBe('728px');
-    expect(collapsed.wrapper.style.height).toBe('90px');
-    expect(outerWrapper.style.width).toBe('728px');
-    expect(outerWrapper.style.height).toBe('90px');
-  });
-
-  it.each(['fixed', 'anchor', 'expanded', 'oversized'] as const)(
-    'does not resize a %s Universal Creative shell',
-    async (guard) => {
-      const tsjs = (window as TestWindow).tsjs!;
-      tsjs.bids.homepage_header.adm = '<div>Fictional creative</div>';
-      tsjs.bids.homepage_header.w = guard === 'oversized' ? 10_001 : 300;
-      tsjs.bids.homepage_header.h = 250;
-      delete tsjs.bids.homepage_header.nurl;
-      delete tsjs.bids.homepage_header.burl;
-      const bridgeListener = await captureBridgeListener();
-      const collapsed = createCollapsedTrustedSlotIframe();
-      if (guard === 'fixed') collapsed.iframe.style.position = 'fixed';
-      if (guard === 'expanded') collapsed.iframe.style.width = '300px';
-      if (guard === 'anchor') {
-        const anchor = document.createElement('ins');
-        anchor.dataset.anchorStatus = 'displayed';
-        collapsed.slot.insertBefore(anchor, collapsed.wrapper);
-        anchor.appendChild(collapsed.wrapper);
-      }
-
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-          ports: [{ postMessage: vi.fn() }],
-          source: collapsed.source,
-          stopImmediatePropagation: vi.fn(),
-        }) as unknown as MessageEvent
-      );
-
-      expect(collapsed.iframe.width).toBe('1');
-      expect(collapsed.iframe.height).toBe('1');
-      expect(collapsed.wrapper.style.width).toBe('1px');
-      expect(collapsed.wrapper.style.height).toBe('1px');
-    }
-  );
-
-  it('records no creative evidence for an ad ID the requesting slot does not own', async () => {
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(42);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'someone-elses-ad-id' }),
-        ports: [{ postMessage: vi.fn() }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-
-    expect(recordTrustedServerCreativeRequest).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ['missing cache coordinates', {}],
-    ['incomplete cache coordinates', { hb_cache_host: 'cache.example.com' }],
-  ] as const)(
-    'records missing_render_source for an exact-owned request with %s',
-    async (_description, cacheFields) => {
-      const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(45);
-      const recordTrustedServerCreativeResponse = vi.fn();
-      const recordTrustedServerCreativeFailure = vi.fn();
-      const tsjs = (window as TestWindow).tsjs!;
-      tsjs.gptDiagnosticsRecorder = {
-        recordTrustedServerCreativeRequest,
-        recordTrustedServerCreativeResponse,
-        recordTrustedServerCreativeFailure,
-      } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-      delete tsjs.bids.homepage_header.hb_cache_host;
-      delete tsjs.bids.homepage_header.hb_cache_path;
-      Object.assign(tsjs.bids.homepage_header, cacheFields);
-
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const stopImmediatePropagation = vi.fn();
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-          ports: [{ postMessage: vi.fn() }],
-          source,
-          stopImmediatePropagation,
-        }) as unknown as MessageEvent
-      );
-
-      expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-      expect(recordTrustedServerCreativeFailure).toHaveBeenCalledTimes(1);
-      expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(45, 'missing_render_source');
-      expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-      expect(stopImmediatePropagation).not.toHaveBeenCalled();
-      expect(fetchStub).not.toHaveBeenCalled();
-    }
-  );
-
-  it('records no failure when diagnostics declined to open a creative attempt', async () => {
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(undefined);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    delete tsjs.bids.homepage_header.hb_cache_host;
-    delete tsjs.bids.homepage_header.hb_cache_path;
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const stopImmediatePropagation = vi.fn();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage: vi.fn() }],
-        source,
-        stopImmediatePropagation,
-      }) as unknown as MessageEvent
-    );
-
-    // Without an attempt ID there is nothing to attribute the failure to, and
-    // the missing-source fallback must still run untouched.
-    expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(stopImmediatePropagation).not.toHaveBeenCalled();
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('records response_post_failed without resizing when posting inline markup throws', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(46);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    tsjs.bids.homepage_header.adm = '<div>Creative</div>';
-
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const stopImmediatePropagation = vi.fn();
-    expect(() =>
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-          ports: [
-            {
-              postMessage: vi.fn(() => {
-                throw new Error('port closed');
-              }),
-            },
-          ],
-          source: collapsed.source,
-          stopImmediatePropagation,
-        }) as unknown as MessageEvent
-      )
-    ).not.toThrow();
-
-    expect(stopImmediatePropagation).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(46, 'response_post_failed');
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(collapsed.iframe.width).toBe('1');
-    expect(collapsed.iframe.height).toBe('1');
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('serves a server APS renderer once and rejects a repeated request', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      hb_bidder: 'aps',
-      hb_pb: '1.23',
-      renderer,
-      // These must not be used even if unexpected legacy fields coexist.
-      nurl: 'https://notify.example/win',
-      burl: 'https://notify.example/bill',
-      hb_cache_host: 'cache.example.com',
-      hb_cache_path: '/cache',
-    };
-
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const source = collapsed.source;
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (message: string) => portMessages.push(message) };
-    const event = Object.assign(new Event('message'), {
-      data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-      ports: [fakePort],
-      source,
-      stopImmediatePropagation: stopSpy,
-    }) as unknown as MessageEvent;
-
-    bridgeListener(event);
-    bridgeListener(event);
-
-    expect(stopSpy).toHaveBeenCalledTimes(2);
-    expect(fetchStub).not.toHaveBeenCalled();
-    expect(beaconSpy).not.toHaveBeenCalled();
-    // Server-rendered APS capabilities are one-shot per slot and ad ID. A
-    // repeated Universal Creative request is claimed but receives no payload.
-    expect(portMessages).toHaveLength(1);
-    const response = JSON.parse(portMessages[0]) as Record<string, unknown>;
-    expect(Object.keys(response).sort()).toEqual(
-      [
-        'adId',
-        'apsRenderer',
-        'height',
-        'message',
-        'renderer',
-        'rendererUrl',
-        'rendererVersion',
-        'width',
-      ].sort()
-    );
-    expect(response).toEqual({
-      message: 'Prebid Response',
-      adId: renderer.bidId,
-      renderer: expect.stringContaining('window.render=function'),
-      rendererVersion: 4,
-      rendererUrl: new URL('/integrations/aps/renderer', window.location.origin).href,
-      apsRenderer: renderer,
-      width: 300,
-      height: 250,
-    });
-    expect(String(response.renderer)).not.toContain(renderer.accountId);
-    expect(String(response.renderer)).not.toContain(renderer.aaxResponse);
-    expect(collapsed.iframe.width).toBe('300');
-    expect(collapsed.iframe.height).toBe('250');
-    expect(collapsed.wrapper.style.width).toBe('300px');
-    expect(collapsed.wrapper.style.height).toBe('250px');
-
-    // Universal Creative's dynamic-renderer path evaluates the returned static
-    // source and calls window.render(response, helper, targetWindow). Consume
-    // the exact bridge response through that deployed protocol shape.
-    const dynamicWindow = window as unknown as {
-      render?: (data: Record<string, unknown>, helper: unknown, target: Window) => Promise<void>;
-    };
-    window.eval(String(response.renderer));
-    try {
-      const rendered = dynamicWindow.render!(response, undefined, window);
-      const outerFrame = document.querySelector<HTMLIFrameElement>(
-        'iframe[src*="/integrations/aps/renderer#tsaps="]'
-      )!;
-      expect(outerFrame).not.toBeNull();
-      expect(outerFrame.getAttribute('sandbox')).not.toContain('allow-same-origin');
-
-      const rendererPost = vi.spyOn(outerFrame.contentWindow!, 'postMessage');
-      outerFrame.dispatchEvent(new Event('load'));
-      const sent = rendererPost.mock.calls[0][0] as { nonce: string };
-      window.dispatchEvent(
-        new MessageEvent('message', {
-          data: { message: 'trusted-server/aps/renderer-ready', nonce: sent.nonce },
-          source: outerFrame.contentWindow,
-        })
-      );
-      await expect(rendered).resolves.toBeUndefined();
-      outerFrame.remove();
-    } finally {
-      delete dynamicWindow.render;
-    }
-    beaconSpy.mockRestore();
-  });
-
-  it('contract test: renders a server APS owner with the injected runner and no Universal Creative response', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      renderer,
-    };
-    const marker = enablePublisherNativeMode();
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const portMessages: string[] = [];
-      const request = Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent;
-
-      bridgeListener(request);
-      bridgeListener(request);
-      const native = nativeRunnerIn('div-header');
-      expect(native.event.type).toBe('prebid/creative/render');
-      expect(native.event.detail).toEqual({
-        aaxResponse: renderer.aaxResponse,
-        seatBidId: renderer.bidId,
-      });
-      native.runner.dispatchEvent(new Event('load'));
-      await Promise.resolve();
-      await Promise.resolve();
-
-      expect(native.frame.style.display).toBe('');
-      expect(portMessages).toEqual([]);
-      expect(document.querySelector('iframe[src*="/integrations/aps/renderer"]')).toBeNull();
-    } finally {
-      marker.remove();
-    }
-  });
-
-  it('contract test: fails a server APS runner without a Universal Creative response or fallback', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      renderer,
-    };
-    const marker = enablePublisherNativeMode();
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const portMessages: string[] = [];
-      const request = Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent;
-
-      bridgeListener(request);
-      nativeRunnerIn('div-header').runner.dispatchEvent(new Event('error'));
-      await Promise.resolve();
-      await Promise.resolve();
-      bridgeListener(request);
-
-      expect(portMessages).toEqual([]);
-      expect(document.querySelector('iframe[title="Ad content"]')).toBeNull();
-      expect(document.querySelector('iframe[src*="/integrations/aps/renderer"]')).toBeNull();
-    } finally {
-      marker.remove();
-    }
-  });
-
-  it('serves a registered Prebid APS renderer when its generated ad ID differs from the APS bid ID', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'prebid-generated-ad-id';
-    const markUsed = vi.fn();
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed,
-      },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const source = collapsed.source;
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const event = Object.assign(new Event('message'), {
-      data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-      ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-      source,
-      stopImmediatePropagation: stopSpy,
-    }) as unknown as MessageEvent;
-
-    bridgeListener(event);
-    const foreignIframe = document.createElement('iframe');
-    document.body.appendChild(foreignIframe);
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source: foreignIframe.contentWindow,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).toHaveBeenCalledTimes(2);
-    expect(portMessages).toHaveLength(1);
-    expect(markUsed).toHaveBeenCalledTimes(1);
-    expect(JSON.parse(portMessages[0])).toEqual(
-      expect.objectContaining({
-        message: 'Prebid Response',
-        adId: prebidAdId,
-        apsRenderer: renderer,
-        width: renderer.width,
-        height: renderer.height,
-      })
-    );
-    expect(renderer.bidId).not.toBe(prebidAdId);
-    expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeUndefined();
-    expect(collapsed.iframe.width).toBe('300');
-    expect(collapsed.iframe.height).toBe('250');
-    expect(collapsed.wrapper.style.width).toBe('300px');
-    expect(collapsed.wrapper.style.height).toBe('250px');
-    expect(fetchStub).not.toHaveBeenCalled();
-    foreignIframe.remove();
-  });
-
-  it('contract test: fails a registered APS runner without a Universal Creative response or markUsed', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'native-prebid-decline-ad-id';
-    const markUsed = vi.fn();
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed,
-      },
-    };
-    const marker = enablePublisherNativeMode();
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const portMessages: string[] = [];
-      const request = Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent;
-
-      bridgeListener(request);
-      nativeRunnerIn('div-header').runner.dispatchEvent(new Event('error'));
-      await Promise.resolve();
-      await Promise.resolve();
-      bridgeListener(request);
-
-      expect(markUsed).not.toHaveBeenCalled();
-      expect(portMessages).toEqual([]);
-      expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeUndefined();
-      expect(document.querySelector('iframe[title="Ad content"]')).toBeNull();
-      expect(document.querySelector('iframe[src*="/integrations/aps/renderer"]')).toBeNull();
-    } finally {
-      marker.remove();
-    }
-  });
-
-  it('contract test: consumes a registered APS capability and marks it used only after runner load', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'native-prebid-ad-id';
-    const markUsed = vi.fn();
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed,
-      },
-    };
-    const marker = enablePublisherNativeMode();
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const portMessages: string[] = [];
-      const request = Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent;
-
-      bridgeListener(request);
-      expect(markUsed).not.toHaveBeenCalled();
-      const native = nativeRunnerIn('div-header');
-      native.runner.dispatchEvent(new Event('load'));
-      await Promise.resolve();
-      await Promise.resolve();
-      bridgeListener(request);
-
-      expect(native.frame.style.display).toBe('');
-      expect(markUsed).toHaveBeenCalledOnce();
-      expect(portMessages).toEqual([]);
-      expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeUndefined();
-    } finally {
-      marker.remove();
-    }
-  });
-
-  it('uses the requesting frame to disambiguate a registered APS slot prefix', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'native-dynamic-prebid-ad-id';
-    const markUsed = vi.fn();
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-native-',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed,
-      },
-    };
-    const marker = enablePublisherNativeMode();
-    createTrustedSlotIframe('div-native-first');
-    const source = createTrustedSlotIframe('div-native-second');
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-          ports: [{ postMessage: vi.fn() }],
-          source,
-          stopImmediatePropagation: vi.fn(),
-        }) as unknown as MessageEvent
-      );
-
-      const native = nativeRunnerIn('div-native-second');
-      native.runner.dispatchEvent(new Event('load'));
-      await Promise.resolve();
-      await Promise.resolve();
-
-      expect(native.frame.style.display).toBe('');
-      expect(markUsed).toHaveBeenCalledOnce();
-      expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeUndefined();
-    } finally {
-      marker.remove();
-      document.getElementById('div-native-first')?.remove();
-      document.getElementById('div-native-second')?.remove();
-    }
-  });
-
-  it('still serves the APS renderer when markUsed throws', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'throwing-mark-used-ad-id';
-    const markUsed = vi.fn(() => {
-      throw new Error('fictional markUsed failure');
-    });
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed,
-      },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const portMessages: string[] = [];
-
-    expect(() =>
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-          ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-          source,
-          stopImmediatePropagation: vi.fn(),
-        }) as unknown as MessageEvent
-      )
-    ).not.toThrow();
-
-    expect(portMessages).toHaveLength(1);
-    expect(JSON.parse(portMessages[0])).toEqual(
-      expect.objectContaining({
-        message: 'Prebid Response',
-        adId: prebidAdId,
-        apsRenderer: renderer,
-      })
-    );
-    expect(markUsed).toHaveBeenCalledTimes(1);
-  });
-
-  it('prunes expired consumed APS renderer IDs', async () => {
-    vi.useFakeTimers();
-    try {
-      const renderer = apsRenderer();
-      const prebidAdId = 'expiring-consumed-ad-id';
-      const start = Date.now();
-      const firstMarkUsed = vi.fn();
-      const secondMarkUsed = vi.fn();
-      (window as TestWindow).tsjs.apsPrebidRenderers = {
-        [prebidAdId]: {
-          adUnitCode: 'div-header',
-          renderer,
-          registeredAt: start,
-          expiresAt: start + 60_000,
-          markUsed: firstMarkUsed,
-        },
-      };
-
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const stopImmediatePropagation = vi.fn();
-      const portMessages: string[] = [];
-      const sendRequest = (): void => {
-        bridgeListener(
-          Object.assign(new Event('message'), {
-            data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-            ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-            source,
-            stopImmediatePropagation,
-          }) as unknown as MessageEvent
-        );
-      };
-
-      sendRequest();
-      vi.advanceTimersByTime(60_001);
-      (window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId] = {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed: secondMarkUsed,
-      };
-      sendRequest();
-
-      expect(portMessages).toHaveLength(2);
-      expect(stopImmediatePropagation).toHaveBeenCalledTimes(2);
-      expect(firstMarkUsed).toHaveBeenCalledTimes(1);
-      expect(secondMarkUsed).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('fails closed when consumed APS renderer tombstones reach capacity', async () => {
-    const renderer = apsRenderer();
-    const capacity = 256;
-    const callbacks = Array.from({ length: capacity + 1 }, () => ({
-      markUsed: vi.fn(),
-    }));
-    const entries = Object.fromEntries(
-      callbacks.map((lifecycle, index) => [
-        `capacity-ad-${index}`,
-        {
-          adUnitCode: 'div-header',
-          renderer,
-          registeredAt: Date.now(),
-          expiresAt: Date.now() + 60_000,
-          ...lifecycle,
-        },
-      ])
-    );
-    (window as TestWindow).tsjs.apsPrebidRenderers = entries;
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const stopImmediatePropagation = vi.fn();
-    const portMessages: string[] = [];
-    const sendRequest = (adId: string): void => {
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId }),
-          ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-          source,
-          stopImmediatePropagation,
-        }) as unknown as MessageEvent
-      );
-    };
-
-    for (let index = 0; index < capacity; index += 1) {
-      sendRequest(`capacity-ad-${index}`);
-    }
-    sendRequest(`capacity-ad-${capacity}`);
-    sendRequest('capacity-ad-0');
-
-    expect(portMessages).toHaveLength(capacity);
-    expect(callbacks[capacity].markUsed).not.toHaveBeenCalled();
-    expect(entries[`capacity-ad-${capacity}`]).toBeDefined();
-    expect(callbacks[0].markUsed).toHaveBeenCalledTimes(1);
-    expect(stopImmediatePropagation).toHaveBeenCalledTimes(capacity + 2);
-  });
-
-  it('does not expose a registered Prebid APS renderer to another slot iframe', async () => {
-    const renderer = apsRenderer();
-    const prebidAdId = 'prebid-generated-ad-id';
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer,
-        registeredAt: Date.now(),
-        expiresAt: Date.now() + 60_000,
-        markUsed: vi.fn(),
-      },
-    };
-
-    const footer = document.createElement('div');
-    footer.id = 'div-footer';
-    const foreignIframe = document.createElement('iframe');
-    footer.appendChild(foreignIframe);
-    document.body.appendChild(footer);
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source: foreignIframe.contentWindow,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).toHaveBeenCalledTimes(1);
-    expect(portMessages).toEqual([]);
-    expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeDefined();
-    footer.remove();
-  });
-
-  it('drops an expired Prebid APS renderer without claiming the creative request', async () => {
-    const prebidAdId = 'expired-prebid-ad-id';
-    (window as TestWindow).tsjs.apsPrebidRenderers = {
-      [prebidAdId]: {
-        adUnitCode: 'div-header',
-        renderer: apsRenderer(),
-        registeredAt: Date.now() - 61_000,
-        expiresAt: Date.now() - 1_000,
-        markUsed: vi.fn(),
-      },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: prebidAdId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).not.toHaveBeenCalled();
-    expect(portMessages).toEqual([]);
-    expect((window as TestWindow).tsjs.apsPrebidRenderers[prebidAdId]).toBeUndefined();
-  });
-
-  it('claims a TS-owned request before rejecting invalid APS data', async () => {
-    const renderer = { ...apsRenderer(), aaxResponse: 'invalid' };
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      hb_bidder: 'aps',
-      renderer,
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).toHaveBeenCalledOnce();
-    expect(portMessages).toEqual([]);
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('accepts an APS request from a dynamic slot root resolved from its configured prefix', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      hb_bidder: 'aps',
-      renderer,
-    };
-    (window as TestWindow).tsjs.adSlots[0].div_id = 'div-header-';
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe('div-header-dynamic');
-    const portMessages: string[] = [];
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-
-    expect(portMessages).toHaveLength(1);
-    document.getElementById('div-header-dynamic')?.remove();
-  });
-
-  it('does not let an overlapping slot prefix claim another slot iframe', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      hb_bidder: 'aps',
-      renderer,
-    };
-    (window as TestWindow).tsjs.adSlots.push({
-      id: 'homepage_header_mobile',
-      formats: [[320, 50]],
-      gam_unit_path: '/a/b/mobile',
-      div_id: 'div-header-mobile',
-      targeting: {},
-    });
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe('div-header-mobile');
-    const portMessages: string[] = [];
-    const stopSpy = vi.fn();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).not.toHaveBeenCalled();
-    expect(portMessages).toEqual([]);
-    document.getElementById('div-header-mobile')?.remove();
-  });
-
-  it('ignores an APS ad ID requested by another configured slot', async () => {
-    const renderer = apsRenderer();
-    (window as TestWindow).tsjs.bids.homepage_header = {
-      hb_adid: renderer.bidId,
-      hb_bidder: 'aps',
-      renderer,
-    };
-    (window as TestWindow).tsjs.adSlots.push({
-      id: 'homepage_footer',
-      formats: [[300, 250]],
-      gam_unit_path: '/a/b/footer',
-      div_id: 'div-footer',
-      targeting: {},
-    });
-    const footer = document.createElement('div');
-    footer.id = 'div-footer';
-    const foreignIframe = document.createElement('iframe');
-    footer.appendChild(foreignIframe);
-    document.body.appendChild(footer);
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: renderer.bidId }),
-        ports: [{ postMessage: (message: string) => portMessages.push(message) }],
-        source: foreignIframe.contentWindow,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    expect(stopSpy).not.toHaveBeenCalled();
-    expect(portMessages).toEqual([]);
-    expect(fetchStub).not.toHaveBeenCalled();
-    footer.remove();
-  });
-
-  it('calls stopImmediatePropagation and fetches PBS Cache for a TS bid', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(43);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    const mockAd = '<div>Test Creative</div>';
-    // PBS Cache (returnCreative=false) returns the cached bid as a JSON object;
-    // the creative lives under `adm`, not as the raw response body. The bridge
-    // must parse it and forward `adm`, mirroring the Prebid Universal Creative.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ adm: mockAd, width: 728, height: 90 })),
-    } as Response);
-
-    // Capture the bridge's 'message' listener at module-init time.
-    let bridgeListener: ((e: MessageEvent) => unknown) | undefined;
-    const origAdd = window.addEventListener.bind(window);
-    const addSpy = vi
-      .spyOn(window, 'addEventListener')
-      .mockImplementation(
-        (type: string, handler: EventListenerOrEventListenerObject, opts?: unknown) => {
-          if (type === 'message') bridgeListener = handler as (e: MessageEvent) => unknown;
-          origAdd(
-            type,
-            handler as EventListener,
-            opts as boolean | AddEventListenerOptions | undefined
-          );
-        }
-      );
-    await import('../../../src/integrations/gpt/index');
-    addSpy.mockRestore(); // Restore only addEventListener — fetchStub must stay stubbed
-
-    expect(bridgeListener, 'bridge listener should be registered').toBeDefined();
-
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const postMessage = vi.fn((message: string) => portMessages.push(message));
-    const fakePort = { postMessage };
-    const source = createTrustedSlotIframe();
-
-    // Dispatch the fake event — bridge listener fires synchronously, then runs
-    // fire-and-forget fetch().then() chains asynchronously.
-    bridgeListener!(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    // Flush microtasks so the fetch mock resolves and .then chains fire.
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(fetchStub).toHaveBeenCalledWith(
-      'https://openads.example.com/cache?uuid=test-cache-uuid',
-      { mode: 'cors' }
-    );
-    expect(stopSpy).toHaveBeenCalled();
-    expect(portMessages).toHaveLength(1);
-
-    const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-    expect(parsed.message).toBe('Prebid Response');
-    expect(parsed.adId).toBe('test-cache-uuid');
-    expect(parsed.ad).toBe(mockAd);
-    expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-    expect(recordTrustedServerCreativeResponse).toHaveBeenCalledWith(43);
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    expect(postMessage.mock.invocationCallOrder[0]).toBeLessThan(
-      recordTrustedServerCreativeResponse.mock.invocationCallOrder[0]
-    );
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/win');
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/bill');
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-
-    bridgeListener!(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('does not classify a downstream cache-processing throw as cache_fetch_failed', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(54);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ adm: '<div>Creative</div>' })),
-    } as Response);
-    const { log } = await import('../../../src/core/log');
-    const debugSpy = vi.spyOn(log, 'debug').mockImplementation(() => {
-      throw new Error('success logging unavailable');
-    });
-
-    try {
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const postMessage = vi.fn();
-      const dispatch = () =>
-        bridgeListener(
-          Object.assign(new Event('message'), {
-            data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-            ports: [{ postMessage }],
-            source,
-            stopImmediatePropagation: vi.fn(),
-          }) as unknown as MessageEvent
-        );
-
-      dispatch();
-      await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-      expect(postMessage).toHaveBeenCalledTimes(1);
-      expect(recordTrustedServerCreativeResponse).toHaveBeenCalledWith(54);
-      expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-
-      // A second request must run after the first downstream failure, proving
-      // the in-flight key was still cleared by the promise's finally handler.
-      dispatch();
-      await new Promise<void>((resolve) => setTimeout(resolve, 50));
-      expect(fetchStub).toHaveBeenCalledTimes(2);
-      expect(postMessage).toHaveBeenCalledTimes(2);
-      expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    } finally {
-      debugSpy.mockRestore();
-      beaconSpy.mockRestore();
-    }
-  });
-
-  it.each([
-    [
-      'an HTTP non-ok response',
-      (stub: ReturnType<typeof vi.fn>) =>
-        stub.mockResolvedValue({ ok: false, status: 503 } as Response),
-    ],
-    [
-      'a response body read rejection',
-      (stub: ReturnType<typeof vi.fn>) =>
-        stub.mockResolvedValue({
-          ok: true,
-          text: () => Promise.reject(new Error('body unavailable')),
-        } as Response),
-    ],
-    [
-      'a network rejection',
-      (stub: ReturnType<typeof vi.fn>) => stub.mockRejectedValue(new Error('network unavailable')),
-    ],
-  ] as const)('records cache_fetch_failed once for %s', async (_description, arrangeFetch) => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(47);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    arrangeFetch(fetchStub);
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage: vi.fn() }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(47, 'cache_fetch_failed');
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('records only response_post_failed when posting cached markup throws', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(48);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ adm: '<div>Creative</div>' })),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [
-          {
-            postMessage: vi.fn(() => {
-              throw new Error('port closed');
-            }),
-          },
-        ],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(48, 'response_post_failed');
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it.each(['request', 'response'] as const)(
-    'keeps inline delivery and beacons unchanged when the diagnostics %s writer throws',
-    async (throwingWriter) => {
-      const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-      const recordTrustedServerCreativeRequest = vi.fn(() => {
-        if (throwingWriter === 'request') throw new Error('diagnostics request failed');
-        return 49;
-      });
-      const recordTrustedServerCreativeResponse = vi.fn(() => {
-        if (throwingWriter === 'response') throw new Error('diagnostics response failed');
-      });
-      const recordTrustedServerCreativeFailure = vi.fn();
-      const tsjs = (window as TestWindow).tsjs!;
-      tsjs.gptDiagnosticsRecorder = {
-        recordTrustedServerCreativeRequest,
-        recordTrustedServerCreativeResponse,
-        recordTrustedServerCreativeFailure,
-      } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-      tsjs.bids.homepage_header.adm = '<div>Creative</div>';
-
-      const bridgeListener = await captureBridgeListener();
-      const source = createTrustedSlotIframe();
-      const stopImmediatePropagation = vi.fn();
-      const postMessage = vi.fn();
-      expect(() =>
-        bridgeListener(
-          Object.assign(new Event('message'), {
-            data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-            ports: [{ postMessage }],
-            source,
-            stopImmediatePropagation,
-          }) as unknown as MessageEvent
-        )
-      ).not.toThrow();
-
-      expect(stopImmediatePropagation).toHaveBeenCalledTimes(1);
-      expect(postMessage).toHaveBeenCalledTimes(1);
-      expect(beaconSpy).toHaveBeenCalledTimes(2);
-      expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-      if (throwingWriter === 'response') {
-        expect(recordTrustedServerCreativeResponse).toHaveBeenCalledWith(49);
-      } else {
-        expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-      }
-      beaconSpy.mockRestore();
-    }
-  );
-
-  it('does not turn a throwing cache response diagnostic into a cache failure', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(50);
-    const recordTrustedServerCreativeResponse = vi.fn(() => {
-      throw new Error('diagnostics response failed');
-    });
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ adm: '<div>Creative</div>' })),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const postMessage = vi.fn();
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(postMessage).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeResponse).toHaveBeenCalledWith(50);
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('preserves missing-source fallback when the failure diagnostic throws', async () => {
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(51);
-    const recordTrustedServerCreativeFailure = vi.fn(() => {
-      throw new Error('diagnostics failure writer failed');
-    });
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse: vi.fn(),
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    delete tsjs.bids.homepage_header.hb_cache_host;
-    delete tsjs.bids.homepage_header.hb_cache_path;
-
-    const bridgeListener = await captureBridgeListener();
-    const source = createTrustedSlotIframe();
-    const stopImmediatePropagation = vi.fn();
-    expect(() =>
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-          ports: [{ postMessage: vi.fn() }],
-          source,
-          stopImmediatePropagation,
-        }) as unknown as MessageEvent
-      )
-    ).not.toThrow();
-
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(51, 'missing_render_source');
-    expect(stopImmediatePropagation).not.toHaveBeenCalled();
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('uses the requesting frame to resolve inline adm under an ambiguous prefix', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.bids.homepage_header.adm = '<div>Prefix inline creative</div>';
-    delete tsjs.bids.homepage_header.hb_cache_host;
-    delete tsjs.bids.homepage_header.hb_cache_path;
-    tsjs.adSlots = [
-      {
-        id: 'homepage_header',
-        formats: [[728, 90]],
-        gam_unit_path: '/a/b/c',
-        div_id: 'div-inline-prefix-',
-        targeting: {},
-      },
-    ];
-    tsjs.divToSlotId = {};
-    createTrustedSlotIframe('div-inline-prefix-first');
-    const source = createTrustedSlotIframe('div-inline-prefix-second');
-    const bridgeListener = await captureBridgeListener();
-    const postMessage = vi.fn();
-    const stopImmediatePropagation = vi.fn();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source,
-        stopImmediatePropagation,
-      }) as unknown as MessageEvent
-    );
-
-    expect(postMessage).toHaveBeenCalledOnce();
-    expect(JSON.parse(postMessage.mock.calls[0]![0])).toEqual(
-      expect.objectContaining({ ad: '<div>Prefix inline creative</div>' })
-    );
-    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
-    expect(fetchStub).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('rejects a requesting frame owned by multiple prefix candidates', async () => {
-    const tsjs = (window as TestWindow).tsjs!;
-    tsjs.bids.homepage_header.adm = '<div>Ambiguous inline creative</div>';
-    tsjs.adSlots = [
-      {
-        id: 'homepage_header',
-        formats: [[728, 90]],
-        gam_unit_path: '/a/b/c',
-        div_id: 'div-nested-prefix-',
-        targeting: {},
-      },
-    ];
-    tsjs.divToSlotId = {};
-    const outer = document.createElement('div');
-    outer.id = 'div-nested-prefix-outer';
-    const inner = document.createElement('div');
-    inner.id = 'div-nested-prefix-inner';
-    const iframe = document.createElement('iframe');
-    inner.appendChild(iframe);
-    outer.appendChild(inner);
-    document.body.appendChild(outer);
-    const bridgeListener = await captureBridgeListener();
-    const postMessage = vi.fn();
-    const stopImmediatePropagation = vi.fn();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source: iframe.contentWindow,
-        stopImmediatePropagation,
-      }) as unknown as MessageEvent
-    );
-
-    expect(postMessage).not.toHaveBeenCalled();
-    expect(stopImmediatePropagation).not.toHaveBeenCalled();
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('uses the requesting frame when a responsive prefix is ambiguous', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve('<div>Responsive Creative</div>'),
-    } as Response);
-
-    const resolvedSlot = document.createElement('div');
-    resolvedSlot.id = 'div-responsive-a';
-    const iframe = document.createElement('iframe');
-    resolvedSlot.appendChild(iframe);
-    document.body.appendChild(resolvedSlot);
-    const laterSibling = document.createElement('div');
-    laterSibling.id = 'div-responsive-b';
-    document.body.appendChild(laterSibling);
-
-    (window as TestWindow).tsjs!.adSlots = [
-      {
-        id: 'homepage_header',
-        formats: [[728, 90]] as [number, number][],
-        gam_unit_path: '/a/b/c',
-        div_id: 'div-responsive-',
-        targeting: {},
-      },
-    ];
-    (window as TestWindow).tsjs!.divToSlotId = {};
-
-    const bridgeListener = await captureBridgeListener();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const stopSpy = vi.fn();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source: iframe.contentWindow,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(fetchStub).toHaveBeenCalledWith(
-      'https://openads.example.com/cache?uuid=test-cache-uuid',
-      { mode: 'cors' }
-    );
-    expect(portMessages).toHaveLength(1);
-    expect(stopSpy).toHaveBeenCalled();
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/win');
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/bill');
-    beaconSpy.mockRestore();
-  });
-
-  it('declines to render when the PBS Cache response carries no adm', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(44);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    // A returnCreative=false JSON entry with no `adm` (VAST-only, or malformed).
-    // The bridge must NOT forward the serialized bid document to PUC.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ width: 728, height: 90 })),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    // TS owns the adId so Prebid is still stopped, but with nothing renderable
-    // the bridge sends no Prebid Response and fires no win/billing beacons.
-    expect(fetchStub).toHaveBeenCalled();
-    expect(stopSpy).toHaveBeenCalled();
-    expect(portMessages).toHaveLength(0);
-    expect(recordTrustedServerCreativeRequest).toHaveBeenCalledWith('homepage_header');
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledTimes(1);
-    expect(recordTrustedServerCreativeFailure).toHaveBeenCalledWith(44, 'invalid_cache_payload');
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(beaconSpy).not.toHaveBeenCalled();
-    beaconSpy.mockRestore();
-  });
-
-  it('renders a non-JSON PBS Cache body as raw creative markup', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const rawAd = '<div>Raw Cached Creative</div>';
-    // Backward compatibility: a cache that returns the creative markup directly
-    // (not a JSON bid object) is still rendered as-is.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(rawAd),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(portMessages).toHaveLength(1);
-
-    const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-    expect(parsed.ad).toBe(rawAd);
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('sizes a PBS Cache render and its collapsed shell from cached bid dimensions', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    // Cached bid is 300x250 while the slot's first format is 728x90 (from the
-    // default setup). The response must use the cached dimensions.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () => Promise.resolve(JSON.stringify({ adm: '<div>cached</div>', w: 300, h: 250 })),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const collapsed = createCollapsedTrustedSlotIframe();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source: collapsed.source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(portMessages).toHaveLength(1);
-
-    const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-    expect(parsed.width).toBe(300);
-    expect(parsed.height).toBe(250);
-    expect(collapsed.iframe.width).toBe('300');
-    expect(collapsed.iframe.height).toBe('250');
-    expect(collapsed.wrapper.style.width).toBe('300px');
-    expect(collapsed.wrapper.style.height).toBe('250px');
-    beaconSpy.mockRestore();
-  });
-
-  it('does not resize a stale cache response after navigation', async () => {
-    const recordTrustedServerCreativeResponse = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest: vi.fn().mockReturnValue(91),
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure: vi.fn(),
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    let resolveText: ((body: string) => void) | undefined;
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () =>
-        new Promise<string>((resolve) => {
-          resolveText = resolve;
-        }),
-    } as Response);
-    const bridgeListener = await captureBridgeListener();
-    const collapsed = createCollapsedTrustedSlotIframe();
-    const postMessage = vi.fn();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [{ postMessage }],
-        source: collapsed.source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await Promise.resolve();
-    expect(resolveText).toBeDefined();
-    (window as TestWindow).tsjs!.navGeneration = 1;
-    resolveText?.(JSON.stringify({ adm: '<div>cached</div>', w: 300, h: 250 }));
-    await new Promise<void>((resolve) => setTimeout(resolve, 0));
-
-    expect(postMessage).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(beaconSpy).not.toHaveBeenCalled();
-    expect(collapsed.iframe.width).toBe('1');
-    expect(collapsed.iframe.height).toBe('1');
-    beaconSpy.mockRestore();
-  });
-
-  it('expands ${AUCTION_PRICE} from the cached bid price before responding', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    fetchStub.mockResolvedValue({
-      ok: true,
-      text: () =>
-        Promise.resolve(
-          JSON.stringify({
-            adm: '<a href="https://t.example/win?p=${AUCTION_PRICE}">go</a>',
-            price: 2.5,
-          })
-        ),
-    } as Response);
-
-    const bridgeListener = await captureBridgeListener();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    bridgeListener(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: vi.fn(),
-      }) as unknown as MessageEvent
-    );
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(portMessages).toHaveLength(1);
-
-    const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-    expect(parsed.ad).toContain('p=2.5');
-    expect(parsed.ad).not.toContain('${AUCTION_PRICE}');
-    beaconSpy.mockRestore();
-  });
-
-  it('fetches PBS Cache once when two same-adId messages race before the fetch resolves', async () => {
-    // Concurrent render double-fire guard: two 'Prebid Request' messages for the
-    // same adId can arrive before the first cache fetch settles. The in-flight
-    // `renderingAdIds` gate must collapse them to a single fetch — the persistent
-    // firedBeacons dedup only engages after a fetch resolves, so it cannot stop
-    // the second fetch on its own. Deferring the fetch keeps both messages in the
-    // window where only the in-flight gate can prevent the duplicate.
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const mockAd = '<div>Test Creative</div>';
-    let resolveFetch: (value: Response) => void = () => {};
-    fetchStub.mockReturnValue(
-      new Promise<Response>((resolve) => {
-        resolveFetch = resolve;
-      })
-    );
-
-    const bridgeListener = await captureBridgeListener();
-
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    const dispatch = (): unknown =>
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-          ports: [fakePort],
-          source,
-          stopImmediatePropagation: stopSpy,
-        }) as unknown as MessageEvent
-      );
-
-    // Both messages dispatched before the deferred fetch resolves.
-    dispatch();
-    dispatch();
-
-    // The second message hit the in-flight gate — only one fetch launched.
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-
-    // Resolve the single fetch and flush its .then chain.
-    resolveFetch({ ok: true, text: () => Promise.resolve(mockAd) } as Response);
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-    expect(portMessages).toHaveLength(1);
-    // A single render still fires both win and billing beacons exactly once.
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/win');
-    expect(beaconSpy).toHaveBeenCalledWith('https://ssp.example/bill');
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('does not let one slot block a PBS Cache render for another slot sharing an adId', async () => {
-    // The in-flight guard must be scoped to the requesting slot, not the shared
-    // adId: two distinct slots sharing one hb_adid must each fetch and render.
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    // Deferred fetch that stays pending, so both messages are in flight when we
-    // assert the launched-fetch count.
-    fetchStub.mockReturnValue(new Promise<Response>(() => {}));
-    (window as TestWindow).tsjs = {
-      bids: {
-        slot_a: {
-          hb_adid: 'shared-uuid',
-          hb_bidder: 'ix',
-          hb_pb: '1.00',
-          hb_cache_host: 'cache.example.com',
-          hb_cache_path: '/cache',
-        },
-        slot_b: {
-          hb_adid: 'shared-uuid',
-          hb_bidder: 'ix',
-          hb_pb: '1.00',
-          hb_cache_host: 'cache.example.com',
-          hb_cache_path: '/cache',
-        },
-      },
-      adSlots: [
-        {
-          id: 'slot_a',
-          formats: [[728, 90]] as [number, number][],
-          gam_unit_path: '/a',
-          div_id: 'div-a',
-          targeting: {},
-        },
-        {
-          id: 'slot_b',
-          formats: [[300, 250]] as [number, number][],
-          gam_unit_path: '/a',
-          div_id: 'div-b',
-          targeting: {},
-        },
-      ],
-      divToSlotId: { 'div-a': 'slot_a', 'div-b': 'slot_b' },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-
-    const mkIframe = (divId: string): Window => {
-      const slot = document.createElement('div');
-      slot.id = divId;
-      const iframe = document.createElement('iframe');
-      slot.appendChild(iframe);
-      document.body.appendChild(slot);
-      return iframe.contentWindow!;
-    };
-    const sourceA = mkIframe('div-a');
-    const sourceB = mkIframe('div-b');
-
-    try {
-      for (const source of [sourceA, sourceB]) {
-        bridgeListener(
-          Object.assign(new Event('message'), {
-            data: JSON.stringify({ message: 'Prebid Request', adId: 'shared-uuid' }),
-            ports: [{ postMessage: () => {} }],
-            source,
-            stopImmediatePropagation: vi.fn(),
-          }) as unknown as MessageEvent
-        );
-      }
-
-      // Each slot launches its own fetch — the shared adId does not cross-block.
-      expect(fetchStub).toHaveBeenCalledTimes(2);
-    } finally {
-      document.getElementById('div-a')?.remove();
-      document.getElementById('div-b')?.remove();
-      beaconSpy.mockRestore();
-    }
-  });
-
-  it('serves inline adm without fetching PBS Cache even when cache coords are present', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const inlineAdm = '<div>Inline Creative</div>';
-    (window as TestWindow).tsjs = {
-      bids: {
-        homepage_header: {
-          hb_adid: 'debug-adid',
-          hb_bidder: 'mocktioneer',
-          hb_pb: '0.20',
-          // Production shape: cache coordinates ARE present, but the bridge must
-          // prefer the local inline adm and skip the PBS Cache fetch.
-          hb_cache_host: 'cache.example.com',
-          hb_cache_path: '/pbc/v1/cache',
-          nurl: 'https://debug.example/win',
-          burl: 'https://debug.example/bill',
-          adm: inlineAdm,
-        },
-      },
-      adSlots: [
-        {
-          id: 'homepage_header',
-          formats: [[728, 90]] as [number, number][],
-          gam_unit_path: '/a/b/c',
-          div_id: 'div-header',
-          targeting: {},
-        },
-      ],
-      divToSlotId: { 'div-header': 'homepage_header' },
-    };
-
-    let bridgeListener: ((e: MessageEvent) => unknown) | undefined;
-    const origAdd = window.addEventListener.bind(window);
-    const addSpy = vi
-      .spyOn(window, 'addEventListener')
-      .mockImplementation(
-        (type: string, handler: EventListenerOrEventListenerObject, opts?: unknown) => {
-          if (type === 'message') bridgeListener = handler as (e: MessageEvent) => unknown;
-          origAdd(
-            type,
-            handler as EventListener,
-            opts as boolean | AddEventListenerOptions | undefined
-          );
-        }
-      );
-    await import('../../../src/integrations/gpt/index');
-    addSpy.mockRestore();
-
-    expect(bridgeListener, 'bridge listener should be registered').toBeDefined();
-
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    bridgeListener!(
-      Object.assign(new Event('message'), {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'debug-adid' }),
-        ports: [fakePort],
-        source,
-        stopImmediatePropagation: stopSpy,
-      }) as unknown as MessageEvent
-    );
-
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-    expect(fetchStub).not.toHaveBeenCalled();
-    expect(stopSpy).toHaveBeenCalled();
-    expect(portMessages).toHaveLength(1);
-
-    const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-    expect(parsed.message).toBe('Prebid Response');
-    expect(parsed.adId).toBe('debug-adid');
-    expect(parsed.ad).toBe(inlineAdm);
-    expect(parsed.width).toBe(728);
-    expect(parsed.height).toBe(90);
-    expect(beaconSpy).toHaveBeenCalledWith('https://debug.example/win');
-    expect(beaconSpy).toHaveBeenCalledWith('https://debug.example/bill');
-    expect(beaconSpy).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('sizes the inline response from the winning bid, not the first slot format', async () => {
-    // Multi-size slot whose winner is the SECOND configured format. Sizing from
-    // slot.formats[0] would render the 300x250 winner in a 728x90 box.
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const winnerAdm = '<div>Winner 300x250</div>';
-    (window as TestWindow).tsjs = {
-      bids: {
-        homepage_header: {
-          hb_adid: 'winner-adid',
-          hb_bidder: 'ix',
-          hb_pb: '2.00',
-          w: 300,
-          h: 250,
-          adm: winnerAdm,
-        },
-      },
-      adSlots: [
-        {
-          id: 'homepage_header',
-          formats: [
-            [728, 90],
-            [300, 250],
-          ] as [number, number][],
-          gam_unit_path: '/a/b/c',
-          div_id: 'div-header',
-          targeting: {},
-        },
-      ],
-      divToSlotId: { 'div-header': 'homepage_header' },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-
-    try {
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'winner-adid' }),
-          ports: [fakePort],
-          source,
-          stopImmediatePropagation: stopSpy,
-        }) as unknown as MessageEvent
-      );
-      await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-      expect(portMessages).toHaveLength(1);
-
-      const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-      expect(parsed.width).toBe(300);
-      expect(parsed.height).toBe(250);
-    } finally {
-      beaconSpy.mockRestore();
-    }
-  });
-
-  it('resolves the requesting slot bid when two slots share one hb_adid', async () => {
-    // Duplicate hb_adid across slots: PBS Cache is absent, so hb_adid falls back
-    // to a creative id that a bidder reuses across slots. The bridge must resolve
-    // the bid by the requesting slot, not the first bid whose hb_adid matches —
-    // otherwise every slot but the first renders blank.
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const headerAdm = '<div>Header Creative</div>';
-    const inContentAdm = '<div>In-Content Creative</div>';
-    (window as TestWindow).tsjs = {
-      bids: {
-        homepage_header: {
-          hb_adid: 'shared-creative-id',
-          hb_bidder: 'ix',
-          hb_pb: '0.53',
-          adm: headerAdm,
-        },
-        homepage_in_content: {
-          hb_adid: 'shared-creative-id',
-          hb_bidder: 'ix',
-          hb_pb: '0.40',
-          adm: inContentAdm,
-        },
-      },
-      adSlots: [
-        {
-          id: 'homepage_header',
-          formats: [[728, 90]] as [number, number][],
-          gam_unit_path: '/a/b/c',
-          div_id: 'div-header',
-          targeting: {},
-        },
-        {
-          id: 'homepage_in_content',
-          formats: [[300, 250]] as [number, number][],
-          gam_unit_path: '/a/b/c',
-          div_id: 'div-in-content',
-          targeting: {},
-        },
-      ],
-      divToSlotId: { 'div-header': 'homepage_header', 'div-in-content': 'homepage_in_content' },
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const stopSpy = vi.fn();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-
-    // Iframe belongs to the SECOND slot, whose bid is not the first hb_adid match.
-    const slot = document.createElement('div');
-    slot.id = 'div-in-content';
-    const iframe = document.createElement('iframe');
-    slot.appendChild(iframe);
-    document.body.appendChild(slot);
-    const source = iframe.contentWindow!;
-
-    try {
-      bridgeListener(
-        Object.assign(new Event('message'), {
-          data: JSON.stringify({ message: 'Prebid Request', adId: 'shared-creative-id' }),
-          ports: [fakePort],
-          source,
-          stopImmediatePropagation: stopSpy,
-        }) as unknown as MessageEvent
-      );
-      await new Promise<void>((resolve) => setTimeout(resolve, 50));
-
-      expect(portMessages).toHaveLength(1);
-
-      const parsed = JSON.parse(portMessages[0]) as PrebidResponseMessage;
-      // The requesting slot's own creative and dimensions, not the first match's.
-      expect(parsed.ad).toBe(inContentAdm);
-      expect(parsed.width).toBe(300);
-      expect(parsed.height).toBe(250);
-    } finally {
-      slot.remove();
-      beaconSpy.mockRestore();
-    }
-  });
-
-  it('falls back to keepalive fetch when sendBeacon is unavailable', async () => {
-    const originalSendBeacon = navigator.sendBeacon;
-    Object.defineProperty(navigator, 'sendBeacon', {
-      value: undefined,
-      writable: true,
-      configurable: true,
-    });
-
-    try {
-      (window as TestWindow).tsjs!.bids!.homepage_header = {
-        hb_adid: 'debug-no-beacon',
-        hb_bidder: 'mocktioneer',
-        hb_pb: '0.20',
-        nurl: 'https://debug.example/win',
-        burl: 'https://debug.example/bill',
-        adm: '<div>Debug Creative</div>',
-      };
-
-      const bridgeListener = await captureBridgeListener();
-      const portMessages: string[] = [];
-      const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-      const source = createTrustedSlotIframe();
-
-      expect(() =>
-        bridgeListener(
-          Object.assign(new Event('message'), {
-            data: JSON.stringify({ message: 'Prebid Request', adId: 'debug-no-beacon' }),
-            ports: [fakePort],
-            source,
-            stopImmediatePropagation: vi.fn(),
-          }) as unknown as MessageEvent
-        )
-      ).not.toThrow();
-
-      expect(fetchStub).toHaveBeenCalledWith('https://debug.example/win', {
-        method: 'POST',
-        keepalive: true,
-        mode: 'no-cors',
-      });
-      expect(fetchStub).toHaveBeenCalledWith('https://debug.example/bill', {
-        method: 'POST',
-        keepalive: true,
-        mode: 'no-cors',
-      });
-    } finally {
-      Object.defineProperty(navigator, 'sendBeacon', {
-        value: originalSendBeacon,
-        writable: true,
-        configurable: true,
-      });
-    }
-  });
-
-  it('falls back to keepalive fetch when sendBeacon rejects the payload', async () => {
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(false);
-    (window as TestWindow).tsjs!.bids!.homepage_header = {
-      hb_adid: 'debug-rejected-beacon',
-      hb_bidder: 'mocktioneer',
-      hb_pb: '0.20',
-      nurl: 'https://debug.example/win',
-      burl: 'https://debug.example/bill',
-      adm: '<div>Debug Creative</div>',
-    };
-
-    const bridgeListener = await captureBridgeListener();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const source = createTrustedSlotIframe();
-    const event = Object.assign(new Event('message'), {
-      data: JSON.stringify({ message: 'Prebid Request', adId: 'debug-rejected-beacon' }),
-      ports: [fakePort],
-      source,
-      stopImmediatePropagation: vi.fn(),
-    }) as unknown as MessageEvent;
-
-    bridgeListener(event);
-
-    expect(beaconSpy).toHaveBeenCalledWith('https://debug.example/win');
-    expect(beaconSpy).toHaveBeenCalledWith('https://debug.example/bill');
-    expect(fetchStub).toHaveBeenCalledWith('https://debug.example/win', {
-      method: 'POST',
-      keepalive: true,
-      mode: 'no-cors',
-    });
-    expect(fetchStub).toHaveBeenCalledWith('https://debug.example/bill', {
-      method: 'POST',
-      keepalive: true,
-      mode: 'no-cors',
-    });
-
-    bridgeListener(event);
-    expect(fetchStub).toHaveBeenCalledTimes(2);
-    beaconSpy.mockRestore();
-  });
-
-  it('ignores message when adId does not match any TS bid', async () => {
-    await import('../../../src/integrations/gpt/index');
-    fetchStub.mockResolvedValue({ ok: true, text: () => Promise.resolve('') } as Response);
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'unknown-id' }),
-        ports: [],
-      })
-    );
-
-    await new Promise<void>((r) => setTimeout(r, 100));
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('ignores matching adId messages from outside configured slot iframes', async () => {
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(52);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-    await import('../../../src/integrations/gpt/index');
-    fetchStub.mockResolvedValue({ ok: true, text: () => Promise.resolve('') } as Response);
-
-    const foreignIframe = document.createElement('iframe');
-    document.body.appendChild(foreignIframe);
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-    const stopSpy = vi.fn();
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
-        ports: [fakePort as unknown as MessagePort],
-        source: foreignIframe.contentWindow,
-      })
-    );
-
-    await new Promise<void>((r) => setTimeout(r, 50));
-    expect(fetchStub).not.toHaveBeenCalled();
-    expect(stopSpy).not.toHaveBeenCalled();
-    expect(portMessages).toHaveLength(0);
-    expect(recordTrustedServerCreativeRequest).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    foreignIframe.remove();
-  });
-
-  it('ignores a request whose source slot does not own the resolved adId', async () => {
-    // Two configured slots; slot A's iframe requests slot B's hb_adid. The
-    // bridge must not return slot B's creative or fire slot B's beacons.
-    (window as TestWindow).tsjs!.bids!.homepage_footer = {
-      hb_adid: 'footer-uuid',
-      hb_bidder: 'kargo',
-      hb_pb: '2.00',
-      hb_cache_host: 'openads.example.com',
-      hb_cache_path: '/cache',
-      nurl: 'https://ssp.example/footer-win',
-      burl: 'https://ssp.example/footer-bill',
-    };
-    (window as TestWindow).tsjs!.adSlots!.push({
-      id: 'homepage_footer',
-      formats: [[300, 250]] as [number, number][],
-      gam_unit_path: '/a/b/footer',
-      div_id: 'div-footer',
-      targeting: {},
-    });
-    const recordTrustedServerCreativeRequest = vi.fn().mockReturnValue(53);
-    const recordTrustedServerCreativeResponse = vi.fn();
-    const recordTrustedServerCreativeFailure = vi.fn();
-    (window as TestWindow).tsjs!.gptDiagnosticsRecorder = {
-      recordTrustedServerCreativeRequest,
-      recordTrustedServerCreativeResponse,
-      recordTrustedServerCreativeFailure,
-    } as unknown as TsjsApi['gptDiagnosticsRecorder'];
-
-    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    await import('../../../src/integrations/gpt/index');
-    fetchStub.mockResolvedValue({ ok: true, text: () => Promise.resolve('') } as Response);
-
-    // Source iframe lives under slot A (div-header).
-    const source = createTrustedSlotIframe();
-    const portMessages: string[] = [];
-    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
-
-    window.dispatchEvent(
-      new MessageEvent('message', {
-        // adId belongs to slot B (homepage_footer), not slot A's iframe.
-        data: JSON.stringify({ message: 'Prebid Request', adId: 'footer-uuid' }),
-        ports: [fakePort as unknown as MessagePort],
-        source,
-      })
-    );
-
-    await new Promise<void>((r) => setTimeout(r, 50));
-    expect(fetchStub).not.toHaveBeenCalled();
-    expect(portMessages).toHaveLength(0);
-    expect(beaconSpy).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeRequest).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeResponse).not.toHaveBeenCalled();
-    expect(recordTrustedServerCreativeFailure).not.toHaveBeenCalled();
-    document.getElementById('div-footer')?.remove();
-  });
-
-  it('ignores non-Prebid messages', async () => {
-    await import('../../../src/integrations/gpt/index');
-    window.dispatchEvent(
-      new MessageEvent('message', { data: JSON.stringify({ message: 'Other' }) })
-    );
-    await new Promise<void>((r) => setTimeout(r, 50));
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/diagnostics_facts.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/diagnostics_facts.test.ts
new file mode 100644
index 000000000..e6a5144e5
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt/diagnostics_facts.test.ts
@@ -0,0 +1,584 @@
+import { describe, expect, expectTypeOf, it, vi } from 'vitest';
+
+import type {
+  GoogletagAdapter,
+  GoogletagDiagnosticsFact,
+  GoogletagDiagnosticsObserver,
+  GoogletagFacade,
+} from '../../../src/adapters/googletag';
+import {
+  activateGptDiagnosticsEventListeners,
+  activateGptDiagnosticsFactCapture,
+  createGptDiagnosticsFactBuffer,
+  createTrustedServerOpportunityFact,
+  publishTrustedServerRequestFact,
+  projectGptTraceFact,
+  type GptDiagnosticsFact,
+} from '../../../src/integrations/gpt/diagnostics_facts';
+
+function fact(index: number): Readonly<GoogletagDiagnosticsFact> {
+  return Object.freeze({
+    kind: 'slotRequested',
+    observedAtMs: index,
+    slot: Object.freeze({
+      token: Object.freeze(Object.create(null) as object),
+      elementId: `slot-${index}`,
+    }),
+  });
+}
+
+describe('GPT diagnostics fact transport', () => {
+  it('publishes one production request-intent fact from the exact projection and slot identity', () => {
+    const physicalSlot = Object.freeze({});
+    const identity = Object.freeze({
+      token: Object.freeze({}),
+      traceToken: 'gt1_1' as never,
+      runtimeSlotNumber: 1,
+      elementId: 'slot-1',
+      adUnitPath: '/123/slot-1',
+    });
+    const publish = vi.fn(() => true);
+    const projection = Object.freeze({
+      version: 1 as const,
+      auction: Object.freeze({
+        version: 1 as const,
+        auctionId: 'auction-1',
+        results: Object.freeze([
+          Object.freeze({
+            slot: 'slot-1',
+            outcome: 'winner' as const,
+            candidateId: 'candidate001',
+          }),
+        ]),
+      }),
+      slots: Object.freeze([
+        Object.freeze({
+          slot: 'slot-1',
+          gamUnitPath: '/123/slot-1',
+          divId: 'slot-1',
+          formats: Object.freeze([
+            Object.freeze([300, 250] as const),
+            Object.freeze([728, 90] as const),
+          ]),
+          targeting: Object.freeze({}),
+        }),
+      ]),
+      bids: Object.freeze([
+        Object.freeze({
+          candidateId: 'candidate001',
+          slot: 'slot-1',
+          provider: 'gpt',
+          upstreamBidId: 'upstream-1',
+          cpm: 1,
+          currency: 'USD' as const,
+          targeting: Object.freeze({}),
+          rendererReservationId: `r1_${'a'.repeat(22)}`,
+          renderSource: Object.freeze({
+            type: 'adm' as const,
+            version: 1 as const,
+            adm: '<div>creative</div>',
+            width: 300,
+            height: 250,
+          }),
+        }),
+      ]),
+    });
+
+    expect(
+      publishTrustedServerRequestFact({
+        adapter: { diagnosticsIdentity: (slot) => (slot === physicalSlot ? identity : undefined) },
+        buffer: { publish },
+        physicalSlot,
+        projection,
+        registeredSlotId: 'slot-1',
+      })
+    ).toBe(true);
+    expect(publish).toHaveBeenCalledExactlyOnceWith({
+      kind: 'trustedServerOpportunity',
+      auctionSlotId: 'slot-1',
+      opportunity: 'renderable_candidate',
+      requestedSlotSizes: [
+        [300, 250],
+        [728, 90],
+      ],
+      slot: identity,
+      trustedServerAuctionId: 'auction-1',
+    });
+  });
+
+  it('copies and delivers exact Trusted Server requested-size evidence before GPT callbacks', () => {
+    const slot = Object.freeze({
+      token: Object.freeze(Object.create(null) as object),
+      traceToken: 'gt1_1' as never,
+      runtimeSlotNumber: 1,
+      cycleOrdinal: 1 as never,
+      elementId: 'fictional-slot',
+    });
+    const formats: Array<[number, number]> = [
+      [300, 250],
+      [728, 90],
+    ];
+    const opportunity = createTrustedServerOpportunityFact({
+      auctionSlotId: 'fictional-slot',
+      opportunity: 'renderable_candidate',
+      requestedSlotSizes: formats,
+      slot,
+      trustedServerAuctionId: 'fictional-auction',
+    });
+    formats[0]![0] = 1;
+    const received: Readonly<GptDiagnosticsFact>[] = [];
+    const buffer = createGptDiagnosticsFactBuffer();
+
+    expect(opportunity).toEqual({
+      kind: 'trustedServerOpportunity',
+      auctionSlotId: 'fictional-slot',
+      opportunity: 'renderable_candidate',
+      requestedSlotSizes: [
+        [300, 250],
+        [728, 90],
+      ],
+      slot,
+      trustedServerAuctionId: 'fictional-auction',
+    });
+    expect(Object.isFrozen(opportunity)).toBe(true);
+    expect(Object.isFrozen(opportunity?.requestedSlotSizes)).toBe(true);
+    expect(Object.isFrozen(opportunity?.requestedSlotSizes?.[0])).toBe(true);
+    expect(buffer.publish(opportunity!)).toBe(true);
+    buffer.activate((candidate) => received.push(candidate));
+    expect(received).toEqual([opportunity]);
+  });
+
+  it('projects only the data-safe exact trace identity and preserves event fields', () => {
+    const opaqueToken = Object.freeze(Object.create(null) as object);
+    const projected = projectGptTraceFact(
+      Object.freeze({
+        kind: 'slotRenderEnded',
+        observedAtMs: 12.5,
+        slot: Object.freeze({
+          token: opaqueToken,
+          traceToken: 'gt1_z',
+          cycleOrdinal: 7,
+          elementId: 'fictional-slot',
+          adUnitPath: '/example/fictional-slot',
+        }),
+        isEmpty: false,
+        responseIdentifier: 'fictional-response',
+      }) as Readonly<GoogletagDiagnosticsFact>
+    );
+
+    expect(projected).toEqual({
+      kind: 'slotRenderEnded',
+      observedAtMs: 12.5,
+      slot: { token: 'gt1_z', cycleOrdinal: 7, elementId: 'fictional-slot' },
+      isEmpty: false,
+      responseIdentifier: 'fictional-response',
+    });
+    expect(Object.isFrozen(projected)).toBe(true);
+    expect(Object.isFrozen(projected?.slot)).toBe(true);
+    expect(Reflect.ownKeys(projected?.slot ?? {}).sort()).toEqual([
+      'cycleOrdinal',
+      'elementId',
+      'token',
+    ]);
+    expect(Object.values(projected?.slot ?? {})).not.toContain(opaqueToken);
+    expect(JSON.stringify(projected)).not.toContain('/example/fictional-slot');
+  });
+
+  it.each([
+    ['missing cycle', Object.freeze({ token: Object.freeze({}), traceToken: 'gt1_1' })],
+    [
+      'zero cycle',
+      Object.freeze({ token: Object.freeze({}), traceToken: 'gt1_1', cycleOrdinal: 0 }),
+    ],
+    [
+      'overflow cycle',
+      Object.freeze({
+        token: Object.freeze({}),
+        traceToken: 'gt1_1',
+        cycleOrdinal: 4_294_967_296,
+      }),
+    ],
+    [
+      'noncanonical token',
+      Object.freeze({ token: Object.freeze({}), traceToken: 'gt1_01', cycleOrdinal: 1 }),
+    ],
+    [
+      'overflow token',
+      Object.freeze({ token: Object.freeze({}), traceToken: 'gt1_10000000', cycleOrdinal: 1 }),
+    ],
+  ])('omits %s trace projections without changing the raw fact', (_label, slot) => {
+    const raw = Object.freeze({ kind: 'slotRequested', observedAtMs: 1, slot });
+
+    expect(projectGptTraceFact(raw as Readonly<GoogletagDiagnosticsFact>)).toBeUndefined();
+    expect(raw.slot).toBe(slot);
+  });
+
+  it('requires diagnostics observation on every GPT adapter', () => {
+    expectTypeOf<GoogletagAdapter>().toMatchTypeOf<{
+      observeDiagnostics(observer: GoogletagDiagnosticsObserver): (() => void) | undefined;
+    }>();
+  });
+
+  it('buffers 512 facts, evicts the oldest, replays in order, then releases the buffer', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    for (let index = 0; index < 513; index += 1) expect(buffer.publish(fact(index))).toBe(true);
+    const received: number[] = [];
+
+    const release = buffer.activate((item) => {
+      received.push(Number(item.slot.elementId?.slice('slot-'.length)));
+    });
+
+    expect(received).toHaveLength(512);
+    expect(received[0]).toBe(1);
+    expect(received[511]).toBe(512);
+    expect(buffer.publish(fact(513))).toBe(true);
+    expect(received[512]).toBe(513);
+    release?.();
+    expect(buffer.publish(fact(514))).toBe(true);
+    expect(received).toHaveLength(513);
+    const replacement = vi.fn();
+    expect(buffer.activate(replacement)).toEqual(expect.any(Function));
+    expect(replacement).toHaveBeenCalledWith(fact(514));
+    buffer.dispose();
+    expect(buffer.publish(fact(515))).toBe(false);
+  });
+
+  it('validates and rehydrates the bounded first-display fact buffer once', () => {
+    const overflows = vi.fn();
+    const buffer = createGptDiagnosticsFactBuffer({ onOverflow: overflows });
+    const transferredToken = Object.freeze(Object.create(null) as object);
+    const base = {
+      version: 1 as const,
+      token: 'gt1_5',
+      runtimeSlotNumber: 5,
+      cycleOrdinal: 1,
+      disposition: 'matched' as const,
+      issueReason: null,
+      capturedAtMs: 1,
+      elementId: 'slot-1',
+      adUnitPath: '/example/slot-1',
+      requestedSlotSizes: Object.freeze([Object.freeze([300, 250] as const)]),
+      isEmpty: null,
+      renderedSize: null,
+      isBackfill: null,
+      slotContentChanged: null,
+      visibilityPercent: null,
+    };
+    const adopted = Object.freeze({
+      facts: Object.freeze([
+        Object.freeze({ ...base, event: 'slotRequested' as const }),
+        Object.freeze({
+          ...base,
+          event: 'slotRenderEnded' as const,
+          capturedAtMs: 2,
+          requestedSlotSizes: null,
+          isEmpty: false,
+          renderedSize: Object.freeze([300, 250] as const),
+          isBackfill: false,
+          slotContentChanged: true,
+        }),
+      ]),
+      overflowCount: 7,
+      dropCount: 3,
+    });
+    const received: Readonly<GptDiagnosticsFact>[] = [];
+
+    expect(
+      buffer.adoptFirstDisplay(
+        adopted,
+        (traceToken) =>
+          traceToken === 'gt1_5'
+            ? Object.freeze({
+                token: transferredToken,
+                traceToken: 'gt1_5' as never,
+                runtimeSlotNumber: 5,
+                cycleOrdinal: 1 as never,
+                elementId: 'slot-1',
+                adUnitPath: '/example/slot-1',
+              })
+            : undefined,
+        (traceToken, slot) =>
+          traceToken === 'gt1_5'
+            ? createTrustedServerOpportunityFact({
+                auctionSlotId: 'slot-1',
+                opportunity: 'renderable_candidate',
+                requestedSlotSizes: [[300, 250]],
+                slot,
+              })
+            : undefined
+      )
+    ).toBe(true);
+    const release = buffer.activate((value) => received.push(value));
+    expect(received).toHaveLength(3);
+    expect(received[0]).toMatchObject({
+      kind: 'trustedServerOpportunity',
+      auctionSlotId: 'slot-1',
+      requestedSlotSizes: [[300, 250]],
+    });
+    expect(received.slice(1).map((value) => projectGptTraceFact(value as never))).toEqual([
+      {
+        kind: 'slotRequested',
+        observedAtMs: 1,
+        slot: { token: 'gt1_5', cycleOrdinal: 1, elementId: 'slot-1' },
+      },
+      {
+        kind: 'slotRenderEnded',
+        observedAtMs: 2,
+        slot: { token: 'gt1_5', cycleOrdinal: 1, elementId: 'slot-1' },
+        isEmpty: false,
+      },
+    ]);
+    expect(typeof received[0]?.slot.token).toBe('object');
+    expect(received[0]?.slot.token).toBe(received[1]?.slot.token);
+    expect(received[0]?.slot.token).toBe(received[2]?.slot.token);
+    expect(received[0]?.slot.token).toBe(transferredToken);
+    expect(received[0]?.slot.runtimeSlotNumber).toBe(5);
+    expect(Object.isFrozen(received[0])).toBe(true);
+    expect(Object.isFrozen(received[0]?.slot)).toBe(true);
+    release?.();
+    for (let index = 0; index < 513; index += 1) buffer.publish(fact(index + 3));
+    expect(overflows).toHaveBeenLastCalledWith(8);
+    expect(
+      buffer.adoptFirstDisplay(
+        Object.freeze({ facts: Object.freeze([]), overflowCount: 0, dropCount: 0 })
+      )
+    ).toBe(false);
+  });
+
+  it('rehydrates separate cycles for one transferred physical GPT slot', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    const transferredToken = Object.freeze(Object.create(null) as object);
+    const transferredFact = (
+      cycleOrdinal: number,
+      event: 'slotRequested' | 'slotRenderEnded',
+      capturedAtMs: number
+    ) =>
+      Object.freeze({
+        version: 1 as const,
+        event,
+        token: 'gt1_5',
+        runtimeSlotNumber: 5,
+        cycleOrdinal,
+        disposition: 'matched' as const,
+        issueReason: null,
+        capturedAtMs,
+        elementId: 'slot-1',
+        adUnitPath: '/example/slot-1',
+        requestedSlotSizes:
+          event === 'slotRequested' ? Object.freeze([Object.freeze([300, 250] as const)]) : null,
+        isEmpty: event === 'slotRenderEnded' ? false : null,
+        renderedSize: event === 'slotRenderEnded' ? Object.freeze([300, 250] as const) : null,
+        isBackfill: null,
+        slotContentChanged: null,
+        visibilityPercent: null,
+      });
+    const received: Readonly<GptDiagnosticsFact>[] = [];
+
+    expect(
+      buffer.adoptFirstDisplay(
+        Object.freeze({
+          facts: Object.freeze([
+            transferredFact(1, 'slotRequested', 1),
+            transferredFact(1, 'slotRenderEnded', 2),
+            transferredFact(2, 'slotRequested', 3),
+            transferredFact(2, 'slotRenderEnded', 4),
+          ]),
+          overflowCount: 0,
+          dropCount: 0,
+        }),
+        () =>
+          Object.freeze({
+            token: transferredToken,
+            traceToken: 'gt1_5' as never,
+            runtimeSlotNumber: 5,
+            cycleOrdinal: 2 as never,
+            elementId: 'slot-1',
+            adUnitPath: '/example/slot-1',
+          }),
+        (_traceToken, slot) =>
+          createTrustedServerOpportunityFact({
+            auctionSlotId: 'slot-1',
+            opportunity: 'renderable_candidate',
+            requestedSlotSizes: [[300, 250]],
+            slot,
+          })
+      )
+    ).toBe(true);
+    buffer.activate((value) => received.push(value));
+
+    expect(
+      received.map((value) => ({
+        kind: value.kind,
+        cycleOrdinal: value.slot.cycleOrdinal,
+      }))
+    ).toEqual([
+      { kind: 'trustedServerOpportunity', cycleOrdinal: 1 },
+      { kind: 'slotRequested', cycleOrdinal: 1 },
+      { kind: 'slotRenderEnded', cycleOrdinal: 1 },
+      { kind: 'trustedServerOpportunity', cycleOrdinal: 2 },
+      { kind: 'slotRequested', cycleOrdinal: 2 },
+      { kind: 'slotRenderEnded', cycleOrdinal: 2 },
+    ]);
+    expect(received.every((value) => value.slot.token === transferredToken)).toBe(true);
+  });
+
+  it('rejects malformed first-display facts without consuming adoption', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    const malformed = Object.freeze({
+      facts: Object.freeze([
+        Object.freeze({
+          version: 1,
+          event: 'slotRequested',
+          token: 'gt1_01',
+          runtimeSlotNumber: 1,
+          cycleOrdinal: 1,
+          disposition: 'matched',
+          issueReason: null,
+          capturedAtMs: 1,
+          elementId: null,
+          adUnitPath: null,
+          requestedSlotSizes: null,
+          isEmpty: null,
+          renderedSize: null,
+          isBackfill: null,
+          slotContentChanged: null,
+          visibilityPercent: null,
+        }),
+      ]),
+      overflowCount: 0,
+      dropCount: 0,
+    });
+
+    expect(buffer.adoptFirstDisplay(malformed)).toBe(false);
+    expect(
+      buffer.adoptFirstDisplay(
+        Object.freeze({ facts: Object.freeze([]), overflowCount: 0, dropCount: 0 })
+      )
+    ).toBe(true);
+  });
+
+  it('isolates consumer throws and admits only one live module consumer', () => {
+    const errors: unknown[] = [];
+    const buffer = createGptDiagnosticsFactBuffer({
+      onConsumerError: (error) => errors.push(error),
+    });
+    buffer.publish(fact(1));
+    const release = buffer.activate(() => {
+      throw new Error('fictional consumer failure');
+    });
+
+    expect(errors).toHaveLength(1);
+    expect(buffer.activate(vi.fn())).toBeUndefined();
+    expect(buffer.publish(fact(2))).toBe(true);
+    expect(errors).toHaveLength(2);
+    release?.();
+    expect(buffer.activate(vi.fn())).toEqual(expect.any(Function));
+    buffer.dispose();
+  });
+
+  it('adds four diagnostics-only listeners while active and disposes all ownership', async () => {
+    const subscriptions: Array<readonly [string, boolean | undefined]> = [];
+    const releases: Array<ReturnType<typeof vi.fn>> = [];
+    let observer: GoogletagDiagnosticsObserver | undefined;
+    const operationDispose = vi.fn();
+    const facade = Object.freeze({
+      subscribe: (
+        eventType: string,
+        _listener: (event: unknown) => void,
+        diagnosticsOwner?: boolean
+      ) => {
+        subscriptions.push([eventType, diagnosticsOwner]);
+        const release = vi.fn();
+        releases.push(release);
+        return release;
+      },
+    }) as unknown as Readonly<GoogletagFacade>;
+    const adapter = Object.freeze({
+      observeDiagnostics: (candidate: GoogletagDiagnosticsObserver) => {
+        observer = candidate;
+        return () => {
+          observer = undefined;
+        };
+      },
+      run: <Value>(command: (gpt: Readonly<GoogletagFacade>) => Value) =>
+        Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(command(facade)),
+          dispose: operationDispose,
+        }),
+    }) as unknown as GoogletagAdapter;
+    const buffer = createGptDiagnosticsFactBuffer();
+
+    const dispose = activateGptDiagnosticsFactCapture(adapter, buffer);
+    await Promise.resolve();
+
+    expect(observer).toEqual(expect.any(Function));
+    expect(subscriptions).toEqual([
+      ['slotResponseReceived', true],
+      ['slotOnload', true],
+      ['impressionViewable', true],
+      ['slotVisibilityChanged', true],
+    ]);
+    dispose?.();
+    dispose?.();
+    expect(operationDispose).toHaveBeenCalledOnce();
+    expect(releases.every((release) => release.mock.calls.length === 1)).toBe(true);
+    expect(observer).toBeUndefined();
+  });
+
+  it('rejects capture when another diagnostics observer owns the adapter', () => {
+    const run = vi.fn();
+    const adapter = Object.freeze({
+      observeDiagnostics: () => undefined,
+      run,
+    }) as unknown as Pick<GoogletagAdapter, 'observeDiagnostics' | 'run'>;
+
+    expect(
+      activateGptDiagnosticsFactCapture(adapter, createGptDiagnosticsFactBuffer())
+    ).toBeUndefined();
+    expect(run).not.toHaveBeenCalled();
+  });
+
+  it('lets the GPT owner install four diagnostics-only publishers without claiming observation', async () => {
+    const subscriptions: Array<readonly [string, boolean | undefined]> = [];
+    const releases: Array<ReturnType<typeof vi.fn>> = [];
+    const operationDispose = vi.fn();
+    const facade = Object.freeze({
+      subscribe: (
+        eventType: string,
+        _listener: (event: unknown) => void,
+        diagnosticsOwner?: boolean
+      ) => {
+        subscriptions.push([eventType, diagnosticsOwner]);
+        const release = vi.fn();
+        releases.push(release);
+        return release;
+      },
+    }) as unknown as Readonly<GoogletagFacade>;
+    const observeDiagnostics = vi.fn();
+    const adapter = Object.freeze({
+      observeDiagnostics,
+      run: <Value>(command: (gpt: Readonly<GoogletagFacade>) => Value) =>
+        Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(command(facade)),
+          dispose: operationDispose,
+        }),
+    }) as unknown as GoogletagAdapter;
+
+    const dispose = activateGptDiagnosticsEventListeners(adapter);
+    await Promise.resolve();
+
+    expect(observeDiagnostics).not.toHaveBeenCalled();
+    expect(subscriptions).toEqual([
+      ['slotResponseReceived', true],
+      ['slotOnload', true],
+      ['impressionViewable', true],
+      ['slotVisibilityChanged', true],
+    ]);
+    dispose?.();
+    dispose?.();
+    expect(operationDispose).toHaveBeenCalledOnce();
+    expect(releases.every((release) => release.mock.calls.length === 1)).toBe(true);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts
deleted file mode 100644
index 55fd61634..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts
+++ /dev/null
@@ -1,811 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { FIRST_IMPRESSION_LEASE_MS } from '../../../src/core/first_impression';
-import type { FirstImpressionSlotClaim, TsjsApi } from '../../../src/core/types';
-
-/**
- * Executable coverage for the edge-injected `gpt_bootstrap.js` — the
- * head-inline fallback that keeps initial server-side ads working when the
- * main TSJS bundle fails to load. The file ships from
- * `crates/trusted-server-core/src/integrations/gpt_bootstrap.js` and is
- * evaluated here verbatim, so the degradation path (fallback `adInit` and
- * fallback `scheduleInitialAdInit`) is executed, not string-matched.
- *
- * Vitest runs with the lib directory as cwd (the vitest.config.ts root), so
- * the bootstrap is resolved relative to it rather than via import.meta.url,
- * which the jsdom environment rewrites to a non-file scheme.
- */
-const BOOTSTRAP_SOURCE = readFileSync(
-  path.resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-  'utf8'
-);
-
-// The command queue the bootstrap pushes into: a real array once GPT has
-// loaded, or the bare `push`-only stub GPT installs before then.
-type MockCommandQueue = Array<() => void> | { push: (fn: () => void) => unknown };
-
-// Minimal googletag surface the bootstrap touches.
-interface MockGoogleTag {
-  cmd: MockCommandQueue;
-  defineSlot: (adUnitPath: string, sizes: Array<[number, number]>, divId: string) => unknown;
-  pubads: () => unknown;
-  enableServices: () => void;
-  display: (divId: string) => void;
-  getConfig?: (key: string) => Record<string, unknown>;
-  setConfig?: (config: Record<string, unknown>) => void;
-}
-
-// `tsjs` is declared globally as the full `TsjsApi`; `Omit` drops it from
-// `Window` so the fixtures below only have to satisfy the fields they set.
-type TestWindow = Omit<Window, 'tsjs'> & {
-  googletag?: MockGoogleTag;
-  tsjs?: Partial<TsjsApi>;
-  __tsjs_gam_attribution_enabled?: boolean;
-};
-
-function makeGoogleTag(overrides: Partial<MockGoogleTag> = {}): MockGoogleTag {
-  const pubads = {
-    getSlots: vi.fn(() => []),
-    refresh: vi.fn(),
-  };
-
-  return {
-    cmd: [],
-    defineSlot: vi.fn(),
-    pubads: vi.fn(() => pubads),
-    enableServices: vi.fn(),
-    display: vi.fn(),
-    ...overrides,
-  };
-}
-
-function runBootstrap(): void {
-  // Evaluate in the jsdom global scope, exactly as an inline <script> would.
-  new Function(BOOTSTRAP_SOURCE)();
-}
-
-describe('gpt_bootstrap.js fallback', () => {
-  let rafQueue: FrameRequestCallback[];
-  let readyState: DocumentReadyState;
-
-  function flushFrame(): void {
-    const queued = [...rafQueue];
-    rafQueue.length = 0;
-    queued.forEach((cb) => cb(0));
-  }
-
-  beforeEach(() => {
-    delete (window as TestWindow).tsjs;
-    delete (window as TestWindow).googletag;
-    delete (window as TestWindow).__tsjs_gam_attribution_enabled;
-    rafQueue = [];
-    (
-      window as { requestAnimationFrame: typeof window.requestAnimationFrame }
-    ).requestAnimationFrame = ((cb: FrameRequestCallback) => {
-      rafQueue.push(cb);
-      return rafQueue.length;
-    }) as typeof window.requestAnimationFrame;
-    readyState = 'loading';
-    Object.defineProperty(document, 'readyState', {
-      configurable: true,
-      get: () => readyState,
-    });
-  });
-
-  afterEach(() => {
-    document.body.innerHTML = '';
-    delete (document as unknown as Record<string, unknown>).readyState;
-    delete (document as unknown as Record<string, unknown>).hidden;
-    delete (window as unknown as Record<string, unknown>).requestAnimationFrame;
-    delete (window as TestWindow).tsjs;
-    delete (window as TestWindow).googletag;
-    delete (window as TestWindow).__tsjs_gam_attribution_enabled;
-    vi.restoreAllMocks();
-  });
-
-  it('does not create googletag before the guard when attribution is omitted or false', () => {
-    for (const flag of [undefined, false]) {
-      const bundleAdInit = vi.fn();
-      (window as TestWindow).tsjs = { adInit: bundleAdInit };
-      delete (window as TestWindow).googletag;
-      if (flag === undefined) {
-        delete (window as TestWindow).__tsjs_gam_attribution_enabled;
-      } else {
-        (window as TestWindow).__tsjs_gam_attribution_enabled = flag;
-      }
-
-      runBootstrap();
-
-      expect((window as TestWindow).googletag).toBeUndefined();
-      expect((window as TestWindow).tsjs!.adInit).toBe(bundleAdInit);
-    }
-  });
-
-  it('queues string-valued page targeting before a later publisher command', () => {
-    const queue: Array<() => void> = [];
-    const setConfig = vi.fn();
-    (window as TestWindow).googletag = makeGoogleTag({ cmd: queue, setConfig });
-    (window as TestWindow).__tsjs_gam_attribution_enabled = true;
-
-    runBootstrap();
-    const publisherCommand = vi.fn();
-    queue.push(publisherCommand);
-    [...queue].forEach((command) => command());
-
-    expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-    expect(setConfig.mock.invocationCallOrder[0]).toBeLessThan(
-      publisherCommand.mock.invocationCallOrder[0]
-    );
-  });
-
-  it('queues targeting before the preinstalled adInit guard without replacing bundle APIs', () => {
-    const queue: Array<() => void> = [];
-    const setConfig = vi.fn();
-    const bundleAdInit = vi.fn();
-    (window as TestWindow).googletag = makeGoogleTag({ cmd: queue, setConfig });
-    (window as TestWindow).tsjs = { adInit: bundleAdInit };
-    (window as TestWindow).__tsjs_gam_attribution_enabled = true;
-
-    runBootstrap();
-
-    expect(queue).toHaveLength(1);
-    expect((window as TestWindow).tsjs!.adInit).toBe(bundleAdInit);
-    expect((window as TestWindow).tsjs!.scheduleInitialAdInit).toBeUndefined();
-    queue.forEach((command) => command());
-    expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-  });
-
-  it('keeps bootstrap installation working when setConfig is unavailable', () => {
-    const queue: Array<() => void> = [];
-    (window as TestWindow).googletag = makeGoogleTag({ cmd: queue });
-    (window as TestWindow).__tsjs_gam_attribution_enabled = true;
-
-    runBootstrap();
-
-    expect(() => [...queue].forEach((command) => command())).not.toThrow();
-    expect(typeof (window as TestWindow).tsjs!.adInit).toBe('function');
-    expect(typeof (window as TestWindow).tsjs!.scheduleInitialAdInit).toBe('function');
-  });
-
-  it('isolates a throwing setConfig from later publisher commands', () => {
-    const queue: Array<() => void> = [];
-    const setConfig = vi.fn(() => {
-      throw new Error('publisher setConfig failed');
-    });
-    const warn = vi.fn();
-    const disableInitialLoad = vi.fn();
-    const pubads = {
-      disableInitialLoad,
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    const publisherCommand = vi.fn();
-    (window as TestWindow).tsjs = {
-      log: {
-        setLevel: vi.fn(),
-        getLevel: vi.fn(() => 'warn'),
-        info: vi.fn(),
-        warn,
-        error: vi.fn(),
-        debug: vi.fn(),
-      },
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      setConfig,
-      pubads: vi.fn(() => pubads),
-    });
-    (window as TestWindow).__tsjs_gam_attribution_enabled = true;
-
-    runBootstrap();
-    queue.push(publisherCommand);
-
-    expect(() => [...queue].forEach((command) => command())).not.toThrow();
-    expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-    expect(warn).toHaveBeenCalledWith('GAM attribution targeting failed', expect.any(Error));
-    expect(publisherCommand).toHaveBeenCalledTimes(1);
-    expect(typeof (window as TestWindow).tsjs!.adInit).toBe('function');
-    pubads.disableInitialLoad();
-    expect(disableInitialLoad).toHaveBeenCalledTimes(1);
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-  });
-
-  it('still tracks the wrapped legacy disableInitialLoad path', () => {
-    const queue: Array<() => void> = [];
-    const disableInitialLoad = vi.fn();
-    const pubads = {
-      disableInitialLoad,
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      pubads: vi.fn(() => pubads),
-    });
-    (window as TestWindow).__tsjs_gam_attribution_enabled = true;
-
-    runBootstrap();
-    [...queue].forEach((command) => command());
-    pubads.disableInitialLoad();
-
-    expect(disableInitialLoad).toHaveBeenCalledTimes(1);
-    expect((window as TestWindow).tsjs!.gptInitialLoadDisabled).toBe(true);
-  });
-
-  it('keeps the bootstrap lease synchronized with the bundle contract', () => {
-    const bootstrapLease = /var FIRST_IMPRESSION_LEASE_MS = (\d+);/.exec(BOOTSTRAP_SOURCE);
-
-    expect(Number(bootstrapLease?.[1])).toBe(FIRST_IMPRESSION_LEASE_MS);
-  });
-
-  it('clears the bootstrap fallback reservation when transitioned slot setup fails', () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(100);
-    try {
-      const pubads = {
-        getSlots: vi.fn(() => []),
-        refresh: vi.fn(),
-      };
-      (window as TestWindow).googletag = makeGoogleTag({
-        cmd: { push: (command) => command() },
-        defineSlot: vi.fn(() => null),
-        pubads: vi.fn(() => pubads),
-      });
-      document.body.innerHTML = '<div id="failed-bootstrap-fallback"></div>';
-
-      runBootstrap();
-      const ts = (window as TestWindow).tsjs!;
-      const element = document.getElementById('failed-bootstrap-fallback')!;
-      const publisherClaim: FirstImpressionSlotClaim = {
-        generation: 0,
-        slotElementId: element.id,
-        element,
-        owner: 'publisher',
-        phase: 'auctioning',
-        expiresAt: 5_100,
-        publisherAuctions: {
-          original: {
-            token: 'original',
-            adUnitCode: element.id,
-            phase: 'auctioning',
-            expiresAt: 5_100,
-            adIds: [],
-            suppressDelivery: false,
-          },
-        },
-      };
-      ts.firstImpression = {
-        generation: 0,
-        nextToken: 1,
-        slots: { [element.id]: publisherClaim },
-        fallbackSlots: {},
-      };
-      ts.adSlots = [
-        {
-          id: 'failed-bootstrap-fallback-ad',
-          gam_unit_path: '/123/failed-bootstrap-fallback',
-          div_id: element.id,
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ];
-      ts.bids = { 'failed-bootstrap-fallback-ad': { hb_pb: '1.00' } };
-
-      ts.adInit!();
-      expect(ts.firstImpression.fallbackSlots[element.id]).toBe(element);
-
-      vi.advanceTimersByTime(5_001);
-
-      expect(ts.firstImpression.slots[element.id]).toBeUndefined();
-      expect(ts.firstImpression.fallbackSlots[element.id]).toBeUndefined();
-    } finally {
-      vi.clearAllTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('retains an expired TS suppression tombstone in the persistent bootstrap listener', () => {
-    const queue: Array<() => void> = [];
-    const listeners = new Map<string, (event: { slot: { getSlotElementId(): string } }) => void>();
-    const pubads = {
-      addEventListener: vi.fn((name: string, listener: (event: never) => void) => {
-        listeners.set(name, listener as (event: { slot: { getSlotElementId(): string } }) => void);
-      }),
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      pubads: vi.fn(() => pubads),
-    });
-    document.body.innerHTML = '<div id="persistent-slot"></div>';
-
-    runBootstrap();
-    [...queue].forEach((command) => command());
-    const element = document.getElementById('persistent-slot')!;
-    const claim: FirstImpressionSlotClaim = {
-      generation: 0,
-      slotElementId: element.id,
-      element,
-      owner: 'trusted_server',
-      phase: 'delivery_pending',
-      expiresAt: 0,
-      publisherAuctions: {
-        late: {
-          token: 'late',
-          adUnitCode: element.id,
-          phase: 'delivery_pending',
-          expiresAt: 0,
-          adIds: ['late-ad'],
-          suppressDelivery: true,
-        },
-      },
-    };
-    (window as TestWindow).tsjs!.firstImpression = {
-      generation: 0,
-      nextToken: 1,
-      slots: { [element.id]: claim },
-      fallbackSlots: {},
-    };
-
-    listeners.get('slotRequested')!({ slot: { getSlotElementId: () => element.id } });
-
-    expect(claim.publisherAuctions.late).toBeDefined();
-    expect(claim.publisherRegistrationClosed).toBe(true);
-  });
-
-  it('prunes a malformed bootstrap registry key before recording the main-document slot', () => {
-    const queue: Array<() => void> = [];
-    const listeners = new Map<string, (event: { slot: { getSlotElementId(): string } }) => void>();
-    const pubads = {
-      addEventListener: vi.fn((name: string, listener: (event: never) => void) => {
-        listeners.set(name, listener as (event: { slot: { getSlotElementId(): string } }) => void);
-      }),
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      pubads: vi.fn(() => pubads),
-    });
-    document.body.innerHTML = '<div id="malformed-bootstrap-slot"></div>';
-
-    runBootstrap();
-    [...queue].forEach((command) => command());
-    const element = document.getElementById('malformed-bootstrap-slot')!;
-    const malformedClaim: FirstImpressionSlotClaim = {
-      generation: 0,
-      slotElementId: element.id,
-      element,
-      owner: 'trusted_server',
-      phase: 'delivery_pending',
-      expiresAt: Number.POSITIVE_INFINITY,
-      publisherAuctions: {},
-    };
-    (window as TestWindow).tsjs!.firstImpression = {
-      generation: 0,
-      nextToken: 0,
-      slots: { 'wrong-registry-key': malformedClaim },
-      fallbackSlots: {},
-    };
-
-    listeners.get('slotRequested')!({ slot: { getSlotElementId: () => element.id } });
-
-    const slots = (window as TestWindow).tsjs!.firstImpression!.slots;
-    expect(slots['wrong-registry-key']).toBeUndefined();
-    expect(slots[element.id]).toEqual(
-      expect.objectContaining({ element, owner: 'publisher', phase: 'requested' })
-    );
-  });
-
-  it('rejects a connected same-ID bootstrap claim from a foreign document', () => {
-    const queue: Array<() => void> = [];
-    const listeners = new Map<string, (event: { slot: { getSlotElementId(): string } }) => void>();
-    const pubads = {
-      addEventListener: vi.fn((name: string, listener: (event: never) => void) => {
-        listeners.set(name, listener as (event: { slot: { getSlotElementId(): string } }) => void);
-      }),
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      pubads: vi.fn(() => pubads),
-    });
-    document.body.innerHTML = '<div id="foreign-bootstrap-slot"></div>';
-
-    runBootstrap();
-    [...queue].forEach((command) => command());
-    const element = document.getElementById('foreign-bootstrap-slot')!;
-    const foreignDocument = document.implementation.createHTMLDocument('foreign');
-    const foreignElement = foreignDocument.createElement('div');
-    foreignElement.id = element.id;
-    foreignDocument.body.appendChild(foreignElement);
-    const foreignClaim: FirstImpressionSlotClaim = {
-      generation: 0,
-      slotElementId: element.id,
-      element: foreignElement,
-      owner: 'trusted_server',
-      phase: 'delivery_pending',
-      expiresAt: 0,
-      publisherAuctions: {
-        foreign: {
-          token: 'foreign',
-          adUnitCode: element.id,
-          phase: 'delivery_pending',
-          expiresAt: 0,
-          adIds: ['foreign-ad'],
-          suppressDelivery: true,
-        },
-      },
-    };
-    (window as TestWindow).tsjs!.firstImpression = {
-      generation: 0,
-      nextToken: 1,
-      slots: { [element.id]: foreignClaim },
-      fallbackSlots: {},
-    };
-
-    expect(foreignElement.isConnected).toBe(true);
-    listeners.get('slotRequested')!({ slot: { getSlotElementId: () => element.id } });
-
-    const currentClaim = (window as TestWindow).tsjs!.firstImpression!.slots[element.id];
-    expect(currentClaim).toEqual(
-      expect.objectContaining({ element, owner: 'publisher', phase: 'requested' })
-    );
-    expect(currentClaim!.publisherAuctions).toEqual({});
-  });
-
-  it('refuses a 257th bootstrap lifecycle claim without evicting live claims', () => {
-    const queue: Array<() => void> = [];
-    const listeners = new Map<string, (event: { slot: { getSlotElementId(): string } }) => void>();
-    const pubads = {
-      addEventListener: vi.fn((name: string, listener: (event: never) => void) => {
-        listeners.set(name, listener as (event: { slot: { getSlotElementId(): string } }) => void);
-      }),
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = makeGoogleTag({
-      cmd: queue,
-      pubads: vi.fn(() => pubads),
-    });
-
-    runBootstrap();
-    [...queue].forEach((command) => command());
-    const slots: Record<string, FirstImpressionSlotClaim> = {};
-    for (let index = 0; index < 256; index += 1) {
-      const element = document.createElement('div');
-      element.id = `bounded-slot-${index}`;
-      document.body.appendChild(element);
-      slots[element.id] = {
-        generation: 0,
-        slotElementId: element.id,
-        element,
-        owner: 'publisher',
-        phase: 'rendered',
-        expiresAt: Number.POSITIVE_INFINITY,
-        publisherAuctions: {},
-      };
-    }
-    (window as TestWindow).tsjs!.firstImpression = {
-      generation: 0,
-      nextToken: 0,
-      slots,
-      fallbackSlots: {},
-    };
-    const overflow = document.createElement('div');
-    overflow.id = 'bounded-slot-overflow';
-    document.body.appendChild(overflow);
-
-    listeners.get('slotRequested')!({ slot: { getSlotElementId: () => overflow.id } });
-
-    expect(Object.keys(slots)).toHaveLength(256);
-    expect(slots[overflow.id]).toBeUndefined();
-  });
-
-  it('installs fallback adInit and scheduleInitialAdInit when the bundle is absent', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    expect(typeof ts.adInit).toBe('function');
-    expect(typeof ts.scheduleInitialAdInit).toBe('function');
-  });
-
-  it('does not override an already-installed bundle implementation', () => {
-    const bundleAdInit = vi.fn();
-    (window as TestWindow).tsjs = { adInit: bundleAdInit };
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    expect(ts.adInit).toBe(bundleAdInit);
-    // The whole bootstrap stands down when the bundle already installed
-    // adInit — it must not shadow the bundle's scheduler either.
-    expect(ts.scheduleInitialAdInit).toBeUndefined();
-  });
-
-  it('fallback scheduler applies the SSR payload and defers adInit past load plus two frames', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ atf: { hb_pb: '1.00' } });
-    expect(ts.bids).toEqual({ atf: { hb_pb: '1.00' } });
-    expect(adInit).not.toHaveBeenCalled();
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('fallback scheduler accepts only the first schedule call', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ first: { hb_pb: '1.00' } });
-    ts.scheduleInitialAdInit!({ second: { hb_pb: '2.00' } });
-    expect(ts.bids).toEqual({ first: { hb_pb: '1.00' } });
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('fallback scheduler preserves head-injected slots when initialSlots is omitted', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    const headSlot = {
-      id: 'head_slot',
-      gam_unit_path: '/123/head',
-      div_id: 'div-head',
-      formats: [[300, 250]] as Array<[number, number]>,
-    };
-    ts.adSlots = [headSlot];
-
-    ts.scheduleInitialAdInit!({ head_slot: { hb_pb: '1.00' } });
-
-    expect(ts.adSlots).toEqual([headSlot]);
-  });
-
-  it('fallback scheduler replaces existing slots when initialSlots is explicitly empty', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    ts.adSlots = [
-      {
-        id: 'stale_slot',
-        gam_unit_path: '/123/stale',
-        div_id: 'div-stale',
-        formats: [[300, 250]],
-      },
-    ];
-
-    ts.scheduleInitialAdInit!({}, []);
-
-    expect(ts.adSlots).toEqual([]);
-  });
-
-  it('fallback scheduler rides animation frames in a hidden document, holding adInit until first view', () => {
-    // Mirrors the bundle scheduler's intended hidden-tab behavior: rAF is not
-    // serviced while hidden, so a background-tab load holds the initial
-    // adInit until first view — the fallback must not diverge to a timer.
-    Object.defineProperty(document, 'hidden', {
-      configurable: true,
-      get: () => true,
-    });
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ atf: { hb_pb: '1.00' } });
-    window.dispatchEvent(new Event('load'));
-    expect(rafQueue.length).toBeGreaterThan(0);
-    expect(adInit).not.toHaveBeenCalled();
-
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('fallback scheduler stands down when a navigation generation has advanced', () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-    ts.bids = { live_slot: { hb_pb: '2.50' } };
-    ts.navGeneration = 1;
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } });
-    expect(ts.bids).toEqual({ live_slot: { hb_pb: '2.50' } });
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('fallback scheduler guards the SSR slot definitions with the same generation check', () => {
-    // The shared-template seam hands slots to the scheduler rather than assigning
-    // them itself, so the fallback has to honour the same guard as the bundle. If it
-    // applied them unconditionally, a page whose bundle failed to load would take the
-    // stale SSR slots over a committed navigation's.
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    const liveSlot = {
-      id: 'live_slot',
-      gam_unit_path: '/123/live',
-      div_id: 'div-live',
-      formats: [[300, 250]] as Array<[number, number]>,
-    };
-    const ssrSlot = {
-      id: 'ssr_slot',
-      gam_unit_path: '/123/ssr',
-      div_id: 'div-ssr',
-      formats: [[728, 90]] as Array<[number, number]>,
-    };
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } }, [ssrSlot]);
-    expect(ts.adSlots).toEqual([ssrSlot]);
-
-    ts.adSlots = [liveSlot];
-    ts.navGeneration = 1;
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } }, [ssrSlot]);
-    expect(ts.adSlots).toEqual([liveSlot]);
-  });
-
-  it('fallback adInit defines, targets, and displays a TS slot through the command queue', () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      refresh: vi.fn(),
-    };
-    const defineSlot = vi.fn().mockReturnValue(mockSlot);
-    const display = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      display,
-    };
-    document.body.innerHTML =
-      '<div id="div-atf-sidebar-container"><div id="div-atf-sidebar"></div></div>';
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adSlots = [
-      {
-        id: 'atf_sidebar_ad',
-        gam_unit_path: '/123/atf',
-        div_id: 'div-atf-sidebar',
-        formats: [[300, 250]],
-        targeting: { ts_route: 'home' },
-      },
-    ];
-    ts.bids = { atf_sidebar_ad: { hb_pb: '1.00' } };
-
-    ts.adInit!();
-
-    expect(defineSlot).toHaveBeenCalledWith('/123/atf', [[300, 250]], 'div-atf-sidebar');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '1.00');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_route', 'home');
-    expect(ts.prevSlotTargetingKeys).toEqual({ 'div-atf-sidebar': ['ts_route'] });
-    expect(display).toHaveBeenCalledWith('div-atf-sidebar');
-    expect(ts.servicesEnabled).toBe(true);
-  });
-
-  it('fallback adInit leaves a publisher-rendered slot untouched', () => {
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-    };
-    const mockPubads = {
-      addEventListener: vi.fn(),
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      refresh: vi.fn(),
-    };
-    const nativeRefresh = mockPubads.refresh;
-    const defineSlot = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      display: vi.fn(),
-    };
-    document.body.innerHTML = '<div id="div-atf-sidebar"></div>';
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const element = document.getElementById('div-atf-sidebar')!;
-    ts.firstImpression = {
-      generation: 0,
-      nextToken: 0,
-      fallbackSlots: {},
-      slots: {
-        'div-atf-sidebar': {
-          generation: 0,
-          slotElementId: 'div-atf-sidebar',
-          element,
-          owner: 'publisher',
-          phase: 'rendered',
-          expiresAt: Number.POSITIVE_INFINITY,
-          publisherAuctions: {},
-        },
-      },
-    };
-    ts.adSlots = [
-      {
-        id: 'atf_sidebar_ad',
-        gam_unit_path: '/123/atf',
-        div_id: 'div-atf-sidebar',
-        formats: [[300, 250]],
-      },
-    ];
-    ts.bids = { atf_sidebar_ad: { hb_pb: '1.00' } };
-
-    ts.adInit!();
-
-    expect(mockSlot.setTargeting).not.toHaveBeenCalled();
-    expect(nativeRefresh).not.toHaveBeenCalled();
-    expect(defineSlot).not.toHaveBeenCalled();
-    expect(ts.servicesEnabled).not.toBe(true);
-  });
-
-  it('fallback adInit cancels queued work when the generation advances before the queue drains', () => {
-    const commandQueue: Array<() => void> = [];
-    const nativeRefresh = vi.fn();
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      refresh: nativeRefresh,
-    };
-    const defineSlot = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: commandQueue,
-      defineSlot,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-      display: vi.fn(),
-    };
-    document.body.innerHTML = '<div id="div-atf-sidebar"></div>';
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adSlots = [
-      {
-        id: 'atf_sidebar_ad',
-        gam_unit_path: '/123/atf',
-        div_id: 'div-atf-sidebar',
-        formats: [[300, 250]],
-      },
-    ];
-
-    // GPT not loaded: adInit's work sits queued.
-    ts.adInit!();
-    expect(commandQueue.length).toBeGreaterThan(0);
-
-    // A navigation commits (the bundle's SPA hook advances the generation),
-    // then GPT loads and drains the queue: the stale work must stand down.
-    ts.navGeneration = 1;
-    commandQueue.splice(0).forEach((fn) => fn());
-    expect(defineSlot).not.toHaveBeenCalled();
-    expect(nativeRefresh).not.toHaveBeenCalled();
-    expect(mockPubads.enableSingleRequest).not.toHaveBeenCalled();
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts
deleted file mode 100644
index 1b6488f73..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts
+++ /dev/null
@@ -1,674 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { Mock } from 'vitest';
-
-import type { TsjsApi } from '../../../src/core/types';
-
-// We import installGptShim dynamically so each test can control whether the
-// GPT enable flag is present before module evaluation.
-
-async function importGuardModule() {
-  return import('../../../src/integrations/gpt/script_guard');
-}
-
-type GptWindow = Window & {
-  googletag?: {
-    // The shim marks the queue it patched; `push` itself comes from `Array`,
-    // which GPT replaces with its own execute-immediately implementation.
-    cmd: Array<() => void> & { __tsPushed?: boolean };
-    _loaded_?: boolean;
-  };
-};
-
-describe('GPT shim – patchCommandQueue', () => {
-  let win: GptWindow;
-  let installGptShim: () => boolean;
-
-  beforeEach(async () => {
-    // Reset any prior state
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    win = window as GptWindow;
-    delete win.googletag;
-
-    // Dynamic import to get a fresh reference (the module self-init already
-    // ran at first import, but installGptShim is idempotent via the guard).
-    const mod = await import('../../../src/integrations/gpt/index');
-    installGptShim = mod.installGptShim;
-  });
-
-  afterEach(async () => {
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    delete (window as GptWindow).googletag;
-  });
-
-  it('preserves googletag.cmd array identity', () => {
-    const originalCmd: Array<() => void> = [];
-    win.googletag = { cmd: originalCmd } as GptWindow['googletag'];
-
-    installGptShim();
-
-    expect(win.googletag!.cmd).toBe(originalCmd);
-  });
-
-  it('preserves custom cmd.push when GPT is already loaded', () => {
-    // Simulate GPT's loaded state: cmd.push executes callbacks immediately.
-    const executed: string[] = [];
-    const cmd: Array<() => void> = [];
-    const gptCustomPush = (...fns: Array<() => void>): number => {
-      // GPT's custom push executes immediately and appends to the array.
-      for (const fn of fns) {
-        fn();
-        cmd[cmd.length] = fn;
-      }
-      return cmd.length;
-    };
-    cmd.push = gptCustomPush;
-
-    win.googletag = { cmd, _loaded_: true } as GptWindow['googletag'];
-
-    installGptShim();
-
-    // Push a new callback after patching — it should still delegate to
-    // GPT's custom push (which executes immediately).
-    win.googletag!.cmd.push(() => {
-      executed.push('post-patch');
-    });
-
-    expect(executed).toContain('post-patch');
-  });
-
-  it('wraps callbacks pushed after patching with error handling', () => {
-    win.googletag = { cmd: [] } as GptWindow['googletag'];
-
-    installGptShim();
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    // Push a callback that throws
-    win.googletag!.cmd.push(() => {
-      throw new Error('test error');
-    });
-
-    // The wrapped callback should be in the queue — execute it.
-    const wrappedFn = win.googletag!.cmd[win.googletag!.cmd.length - 1];
-    expect(() => wrappedFn()).not.toThrow();
-
-    errorSpy.mockRestore();
-  });
-
-  it('re-wraps already-queued pending callbacks in place', () => {
-    const callOrder: string[] = [];
-    const pending = [() => callOrder.push('first'), () => callOrder.push('second')];
-
-    win.googletag = { cmd: pending } as GptWindow['googletag'];
-
-    installGptShim();
-
-    // The pending callbacks should have been wrapped in place.
-    // Execute them — they should not throw even if one of them did.
-    for (const fn of win.googletag!.cmd) {
-      fn();
-    }
-
-    expect(callOrder).toEqual(['first', 'second']);
-  });
-
-  it('handles pending callback that throws without breaking the queue', () => {
-    const callOrder: string[] = [];
-    const pending = [
-      () => {
-        throw new Error('boom');
-      },
-      () => callOrder.push('after-error'),
-    ];
-
-    win.googletag = { cmd: pending } as GptWindow['googletag'];
-
-    installGptShim();
-
-    // Execute all wrapped callbacks — the error should be caught.
-    for (const fn of win.googletag!.cmd) {
-      expect(() => fn()).not.toThrow();
-    }
-
-    expect(callOrder).toEqual(['after-error']);
-  });
-
-  it('is idempotent — calling installGptShim twice does not double-wrap', () => {
-    const calls: number[] = [];
-    win.googletag = { cmd: [] } as GptWindow['googletag'];
-
-    installGptShim();
-    const pushAfterFirst = win.googletag!.cmd.push;
-
-    installGptShim();
-    const pushAfterSecond = win.googletag!.cmd.push;
-
-    // The push function should be the same reference (not re-wrapped).
-    expect(pushAfterSecond).toBe(pushAfterFirst);
-
-    // Push a callback and verify it only executes once (not double-wrapped).
-    win.googletag!.cmd.push(() => calls.push(1));
-    const fn = win.googletag!.cmd[win.googletag!.cmd.length - 1];
-    fn();
-
-    expect(calls).toEqual([1]);
-  });
-
-  it('creates googletag.cmd if it does not exist', () => {
-    // No googletag at all on window.
-    delete win.googletag;
-
-    installGptShim();
-
-    expect(win.googletag).toBeDefined();
-    expect(Array.isArray(win.googletag!.cmd)).toBe(true);
-  });
-});
-
-describe('GPT – installSlimPrebidLoader', () => {
-  type SlimWindow = Window & { __tsjs_slim_prebid_url?: string };
-
-  afterEach(() => {
-    delete (window as SlimWindow).__tsjs_slim_prebid_url;
-  });
-
-  it('is a no-op when __tsjs_slim_prebid_url is not set', async () => {
-    const { installSlimPrebidLoader } = await import('../../../src/integrations/gpt/index');
-    const addEventListenerSpy = vi.spyOn(window, 'addEventListener');
-    installSlimPrebidLoader();
-    expect(addEventListenerSpy).not.toHaveBeenCalledWith('load', expect.any(Function));
-    addEventListenerSpy.mockRestore();
-  });
-
-  it('appends a deferred script tag when __tsjs_slim_prebid_url is set and load fires', async () => {
-    (window as SlimWindow).__tsjs_slim_prebid_url = 'https://cdn.example.com/slim-prebid.js';
-    const { installSlimPrebidLoader } = await import('../../../src/integrations/gpt/index');
-
-    installSlimPrebidLoader();
-
-    // Simulate the window load event.
-    window.dispatchEvent(new Event('load'));
-
-    const scripts = Array.from(document.querySelectorAll('script[defer]'));
-    const injected = scripts.find(
-      (s) => (s as HTMLScriptElement).src === 'https://cdn.example.com/slim-prebid.js'
-    );
-    expect(injected).toBeDefined();
-
-    // Clean up
-    injected?.parentNode?.removeChild(injected);
-  });
-
-  it('module init calls installSlimPrebidLoader — script injected when URL is preset', async () => {
-    vi.resetModules();
-    (window as SlimWindow).__tsjs_slim_prebid_url = 'https://cdn.example.com/slim-prebid-init.js';
-
-    await import('../../../src/integrations/gpt/index');
-    window.dispatchEvent(new Event('load'));
-
-    const scripts = Array.from(document.querySelectorAll('script[defer]'));
-    const injected = scripts.find(
-      (s) => (s as HTMLScriptElement).src === 'https://cdn.example.com/slim-prebid-init.js'
-    );
-    expect(injected).toBeDefined();
-
-    injected?.parentNode?.removeChild(injected);
-  });
-});
-
-describe('GPT – installTsAdInit', () => {
-  // GPT slot mock: setTargeting/clearTargeting are chainable, so both return
-  // the slot itself.
-  interface MockGptSlot {
-    getSlotElementId: Mock<() => string>;
-    getTargeting: Mock<(key: string) => string[]>;
-    setTargeting: Mock<(key: string, value: string | string[]) => MockGptSlot>;
-    clearTargeting: Mock<(key?: string) => MockGptSlot>;
-  }
-
-  // Minimal pubads surface adInit() drives.
-  interface MockPubAds {
-    getSlots: () => MockGptSlot[];
-    enableSingleRequest: () => void;
-    addEventListener: (event: string, fn: (e: unknown) => void) => void;
-    refresh: (slots?: MockGptSlot[]) => void;
-  }
-
-  interface MockGoogleTag {
-    cmd: Array<() => void>;
-    pubads: () => MockPubAds;
-    defineSlot: Mock;
-    destroySlots: Mock;
-    enableServices: Mock;
-  }
-
-  // `tsjs` is declared globally as the full `TsjsApi`; `Omit` drops it from
-  // `Window` so the fixture below only has to satisfy the fields it sets.
-  type AdInitWindow = Omit<Window, 'tsjs'> & {
-    tsjs?: Partial<TsjsApi>;
-    googletag?: MockGoogleTag;
-  };
-
-  beforeEach(() => {
-    document.body.innerHTML = '';
-    delete (window as AdInitWindow).tsjs;
-    delete (window as AdInitWindow).googletag;
-  });
-
-  afterEach(() => {
-    document.body.innerHTML = '';
-    delete (window as AdInitWindow).tsjs;
-    delete (window as AdInitWindow).googletag;
-  });
-
-  it('clears stale TS-managed targeting before applying a new route to a reused GPT slot', async () => {
-    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
-    const slotTargeting = new Map<string, string[]>([
-      ['hb_pb', ['1.20']],
-      ['hb_bidder', ['kargo']],
-      ['hb_adid', ['old-ad']],
-      ['hb_cache_host', ['cache.example.com']],
-      ['hb_cache_path', ['/cache']],
-      ['ts_initial', ['1']],
-      ['pos', ['old-pos']],
-    ]);
-    const gptSlot: MockGptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn((key: string) => slotTargeting.get(key) ?? []),
-      setTargeting: vi.fn((key: string, value: string | string[]) => {
-        slotTargeting.set(key, Array.isArray(value) ? value : [value]);
-        return gptSlot;
-      }),
-      clearTargeting: vi.fn((key?: string) => {
-        if (key) {
-          slotTargeting.delete(key);
-        } else {
-          slotTargeting.clear();
-        }
-        return gptSlot;
-      }),
-    };
-    const pubads = {
-      getSlots: vi.fn(() => [gptSlot]),
-      enableSingleRequest: vi.fn(),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    const cmd: Array<() => void> = [];
-    cmd.push = (...callbacks: Array<() => void>) => {
-      callbacks.forEach((callback) => callback());
-      return cmd.length;
-    };
-
-    document.body.innerHTML = '<div id="div-ad-homepage-header"></div>';
-    (window as AdInitWindow).googletag = {
-      cmd,
-      pubads: () => pubads,
-      defineSlot: vi.fn(),
-      destroySlots: vi.fn(),
-      enableServices: vi.fn(),
-    };
-    (window as AdInitWindow).tsjs = {
-      prevSlotTargetingKeys: {
-        'div-ad-homepage-header': ['pos'],
-      },
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [[728, 90]],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-      bids: {},
-    };
-
-    installTsAdInit();
-    (window as AdInitWindow).tsjs!.adInit!();
-
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('hb_pb');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('hb_bidder');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('hb_cache_host');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('hb_cache_path');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('ts_initial');
-    expect(gptSlot.clearTargeting).toHaveBeenCalledWith('pos');
-    expect(slotTargeting.get('hb_pb')).toBeUndefined();
-    expect(slotTargeting.get('hb_bidder')).toBeUndefined();
-    expect(slotTargeting.get('hb_adid')).toBeUndefined();
-    expect(slotTargeting.get('hb_cache_host')).toBeUndefined();
-    expect(slotTargeting.get('hb_cache_path')).toBeUndefined();
-    expect(slotTargeting.get('pos')).toBeUndefined();
-    expect(slotTargeting.get('zone')).toEqual(['homepage']);
-    expect(slotTargeting.get('ts_initial')).toEqual(['1']);
-  });
-});
-
-describe('GPT shim – runtime gating', () => {
-  type GatedWindow = Window & {
-    __tsjs_gpt_enabled?: boolean;
-    googletag?: { cmd: Array<() => void> };
-    // Activation hook the module registers; the tests only assert its typeof.
-    __tsjs_installGptShim?: unknown;
-  };
-
-  let win: GatedWindow;
-
-  beforeEach(async () => {
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    win = window as GatedWindow;
-    delete win.googletag;
-    delete win.__tsjs_gpt_enabled;
-  });
-
-  afterEach(async () => {
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    delete (window as GatedWindow).googletag;
-    delete (window as GatedWindow).__tsjs_gpt_enabled;
-    delete (window as GatedWindow).__tsjs_installGptShim;
-  });
-
-  it('installs the shim when activation function is called (simulates server inline script)', async () => {
-    const guard = await importGuardModule();
-    const { installGptShim } = await import('../../../src/integrations/gpt/index');
-
-    // Simulate what the server-injected inline script does:
-    // set the flag then call the activation function.
-    win.__tsjs_gpt_enabled = true;
-    installGptShim();
-
-    expect(guard.isGuardInstalled()).toBe(true);
-    expect(win.googletag).toBeDefined();
-  });
-
-  it('registers __tsjs_installGptShim on window after import', async () => {
-    vi.resetModules();
-    await import('../../../src/integrations/gpt/index');
-
-    expect(typeof (window as GatedWindow).__tsjs_installGptShim).toBe('function');
-  });
-
-  it('auto-installs the shim when the enable flag is set before import', async () => {
-    vi.resetModules();
-    win.__tsjs_gpt_enabled = true;
-
-    const guard = await importGuardModule();
-    await import('../../../src/integrations/gpt/index');
-
-    expect(guard.isGuardInstalled()).toBe(true);
-    expect(win.googletag).toBeDefined();
-  });
-
-  it('does not install the shim when only imported (no explicit activation)', async () => {
-    // Reset modules so the next dynamic import re-evaluates the module.
-    vi.resetModules();
-
-    const guard = await importGuardModule();
-    // Import a fresh copy — the module should register the activation
-    // function on `window` but NOT call `installGptShim()` on its own.
-    await import('../../../src/integrations/gpt/index');
-
-    // Assert immediately — the guard must not be installed because the
-    // module only registers `__tsjs_installGptShim`, it does not auto-init.
-    expect(guard.isGuardInstalled()).toBe(false);
-    expect(win.googletag).toBeUndefined();
-  });
-});
-
-describe('GPT GAM attribution bundle fallback', () => {
-  interface AttributionPubAds {
-    getSlots: () => unknown[];
-    refresh: (...args: unknown[]) => void;
-  }
-
-  interface AttributionGoogleTag {
-    cmd: Array<() => void>;
-    pubads: () => AttributionPubAds;
-    defineSlot: (...args: unknown[]) => unknown;
-    display: (...args: unknown[]) => void;
-    getConfig?: (keys: string | string[]) => Record<string, unknown> | undefined;
-    setConfig?: (config: Record<string, unknown>) => void;
-  }
-
-  type AttributionWindow = Omit<Window, 'tsjs'> & {
-    tsjs?: Partial<TsjsApi>;
-    googletag?: AttributionGoogleTag;
-    __tsjs_gpt_enabled?: boolean;
-    __tsjs_installGptShim?: unknown;
-    __tsjs_slim_prebid_url?: string;
-  };
-
-  let win: AttributionWindow;
-  let executingScript: HTMLScriptElement | null;
-  let originalCurrentScriptDescriptor: PropertyDescriptor | undefined;
-  let originalPushState: History['pushState'];
-  let originalReplaceState: History['replaceState'];
-  let addEventListenerSpy: ReturnType<typeof vi.spyOn>;
-
-  function makeGoogleTag(overrides: Partial<AttributionGoogleTag> = {}): AttributionGoogleTag {
-    const pubads: AttributionPubAds = {
-      getSlots: vi.fn(() => []),
-      refresh: vi.fn(),
-    };
-
-    return {
-      cmd: [],
-      pubads: vi.fn(() => pubads),
-      defineSlot: vi.fn(),
-      display: vi.fn(),
-      ...overrides,
-    };
-  }
-
-  function attributedScript(ownerDocument: Document = document): HTMLScriptElement {
-    const script = ownerDocument.createElement('script');
-    script.id = 'trustedserver-js';
-    script.setAttribute('data-ts-gam-attribution', 'true');
-    return script;
-  }
-
-  async function importFreshGptBundle(): Promise<void> {
-    await import('../../../src/integrations/gpt/index');
-  }
-
-  beforeEach(async () => {
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    vi.resetModules();
-
-    win = window as AttributionWindow;
-    delete win.tsjs;
-    delete win.googletag;
-    delete win.__tsjs_gpt_enabled;
-    delete win.__tsjs_installGptShim;
-    delete win.__tsjs_slim_prebid_url;
-
-    executingScript = null;
-    originalCurrentScriptDescriptor = Object.getOwnPropertyDescriptor(document, 'currentScript');
-    Object.defineProperty(document, 'currentScript', {
-      configurable: true,
-      get: () => executingScript,
-    });
-
-    originalPushState = history.pushState;
-    originalReplaceState = history.replaceState;
-    addEventListenerSpy = vi.spyOn(window, 'addEventListener').mockImplementation(() => {});
-  });
-
-  afterEach(async () => {
-    const guard = await importGuardModule();
-    guard.resetGuardState();
-    history.pushState = originalPushState;
-    history.replaceState = originalReplaceState;
-    if (originalCurrentScriptDescriptor) {
-      Object.defineProperty(document, 'currentScript', originalCurrentScriptDescriptor);
-    } else {
-      delete (document as unknown as Record<string, unknown>).currentScript;
-    }
-    delete win.tsjs;
-    delete win.googletag;
-    delete win.__tsjs_gpt_enabled;
-    delete win.__tsjs_installGptShim;
-    delete win.__tsjs_slim_prebid_url;
-    vi.restoreAllMocks();
-  });
-
-  it('reuses the existing queue and pushes exact targeting before adInit exists', async () => {
-    const queue: Array<() => void> = [];
-    const adInitAtPush: Array<unknown> = [];
-    const arrayPush = queue.push.bind(queue);
-    queue.push = (...callbacks: Array<() => void>) => {
-      callbacks.forEach(() => adInitAtPush.push(win.tsjs?.adInit));
-      return arrayPush(...callbacks);
-    };
-    const setConfig = vi.fn();
-    const tag = makeGoogleTag({ cmd: queue, setConfig });
-    win.googletag = tag;
-    executingScript = attributedScript();
-    const initialScriptCount = document.scripts.length;
-    const fetchSpy = vi.spyOn(globalThis, 'fetch');
-
-    await importFreshGptBundle();
-
-    expect(win.googletag!.cmd).toBe(queue);
-    expect(adInitAtPush[0]).toBeUndefined();
-    expect(queue.length).toBeGreaterThan(0);
-    queue[0]();
-    expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-    expect(document.scripts).toHaveLength(initialScriptCount);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ['no current script', null],
-    ['missing attribute', undefined],
-    ['empty attribute', ''],
-    ['false attribute', 'false'],
-    ['non-exact attribute', 'TRUE'],
-  ])('fails closed for %s', async (_label, attributeValue) => {
-    if (attributeValue === null) {
-      executingScript = null;
-    } else {
-      executingScript = document.createElement('script');
-      if (attributeValue !== undefined) {
-        executingScript.setAttribute('data-ts-gam-attribution', attributeValue);
-      }
-    }
-
-    await importFreshGptBundle();
-
-    expect(win.googletag).toBeUndefined();
-  });
-
-  it('ignores a marked duplicate-ID decoy when the executing tag is unmarked', async () => {
-    const decoy = attributedScript();
-    document.head.appendChild(decoy);
-    executingScript = document.createElement('script');
-    executingScript.id = 'trustedserver-js';
-
-    await importFreshGptBundle();
-
-    expect(win.googletag).toBeUndefined();
-    decoy.remove();
-  });
-
-  it('characterizes a marked document.write clone as able to activate', async () => {
-    const clonedDocument = document.implementation.createHTMLDocument('nested clone');
-    clonedDocument.write('<script id="trustedserver-js" data-ts-gam-attribution="true"></script>');
-    clonedDocument.close();
-    executingScript = clonedDocument.querySelector('script');
-    const queue: Array<() => void> = [];
-    const setConfig = vi.fn();
-    win.googletag = makeGoogleTag({ cmd: queue, setConfig });
-
-    await importFreshGptBundle();
-    queue[0]();
-
-    expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-  });
-
-  it.each(['missing', 'throwing'])(
-    'keeps module installation working with %s setConfig',
-    async (setConfigMode) => {
-      const queue: Array<() => void> = [];
-      const setConfig =
-        setConfigMode === 'throwing'
-          ? vi.fn(() => {
-              throw new Error('publisher setConfig failed');
-            })
-          : undefined;
-      win.googletag = makeGoogleTag({ cmd: queue, setConfig });
-      win.__tsjs_slim_prebid_url = 'https://cdn.example.com/slim-prebid.js';
-      executingScript = attributedScript();
-
-      await importFreshGptBundle();
-
-      expect(() => [...queue].forEach((command) => command())).not.toThrow();
-      expect(typeof win.tsjs?.adInit).toBe('function');
-      expect(typeof win.tsjs?.scheduleInitialAdInit).toBe('function');
-      expect(win.tsjs?.spaHookInstalled).toBe(true);
-      expect(addEventListenerSpy).toHaveBeenCalledWith('popstate', expect.any(Function), true);
-      expect(addEventListenerSpy).toHaveBeenCalledWith('load', expect.any(Function));
-      expect(addEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
-      if (setConfig) {
-        expect(setConfig).toHaveBeenCalledWith({ targeting: { ts: 'true' } });
-      }
-    }
-  );
-
-  it('preserves GPT-enabled shim behavior without queuing attribution when unmarked', async () => {
-    const queue: Array<() => void> = [];
-    const setConfig = vi.fn();
-    const tag = makeGoogleTag({ cmd: queue, setConfig });
-    win.googletag = tag;
-    win.__tsjs_gpt_enabled = true;
-    executingScript = document.createElement('script');
-
-    await importFreshGptBundle();
-    [...queue].forEach((command) => command());
-    const guard = await importGuardModule();
-
-    expect(guard.isGuardInstalled()).toBe(true);
-    expect(win.googletag).toBe(tag);
-    expect(win.googletag!.cmd).toBe(queue);
-    expect(setConfig).not.toHaveBeenCalled();
-    expect(typeof win.tsjs?.adInit).toBe('function');
-  });
-});
-
-describe('GPT debug ADM iframe hardening', () => {
-  it('sandbox token list omits allow-same-origin', async () => {
-    const mod = await import('../../../src/integrations/gpt/index');
-
-    expect(mod.ADM_IFRAME_SANDBOX).toContain('allow-scripts');
-    // allow-scripts + allow-same-origin on srcdoc content removes the
-    // sandbox's origin isolation — the pair must never be reintroduced.
-    expect(mod.ADM_IFRAME_SANDBOX).not.toContain('allow-same-origin');
-  });
-
-  it('safeAdmIframeSrc accepts http(s), relative, and protocol-relative URLs', async () => {
-    const { safeAdmIframeSrc } = await import('../../../src/integrations/gpt/index');
-
-    expect(safeAdmIframeSrc('https://ads.example.com/creative')).toBe(
-      'https://ads.example.com/creative'
-    );
-    expect(safeAdmIframeSrc('http://ads.example.com/creative')).toBe(
-      'http://ads.example.com/creative'
-    );
-    expect(safeAdmIframeSrc('//ads.example.com/creative')).toBe('https://ads.example.com/creative');
-    expect(safeAdmIframeSrc('/first-party/creative?sig=abc')).toBe('/first-party/creative?sig=abc');
-  });
-
-  it('safeAdmIframeSrc rejects script-executing and opaque schemes', async () => {
-    const { safeAdmIframeSrc } = await import('../../../src/integrations/gpt/index');
-
-    expect(safeAdmIframeSrc('javascript:alert(1)')).toBeUndefined();
-    expect(safeAdmIframeSrc('data:text/html,<script>alert(1)</script>')).toBeUndefined();
-    expect(safeAdmIframeSrc('blob:https://example.com/uuid')).toBeUndefined();
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/later.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/later.test.ts
new file mode 100644
index 000000000..9f214a6d7
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt/later.test.ts
@@ -0,0 +1,266 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createGptLaterIntegrationRegistration } from '../../../src/integrations/gpt/later';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+type NavigationResult =
+  | Readonly<{
+      status: 'committed';
+      navigationGeneration: object;
+      current: true;
+    }>
+  | Readonly<{
+      status: 'rejected';
+      navigationGeneration: object;
+      current: boolean;
+    }>;
+
+function harness(pageBidsEnabled = true) {
+  const navigationGeneration = Object.freeze({});
+  const navigate = vi.fn<(_path: string) => Promise<NavigationResult>>(async (_path: string) =>
+    Object.freeze({ status: 'committed', navigationGeneration, current: true })
+  );
+  const release = vi.fn();
+  const activateLaterLifecycle = vi.fn(() => Object.freeze({ navigate, release }));
+  const preparationDisposers: Array<() => void> = [];
+  const activationDisposers: Array<() => void> = [];
+  const interfaces = Object.freeze({
+    'runtime.v1': Object.freeze({ document }),
+    'slots.v1': Object.freeze({}),
+    'auction.v1': Object.freeze({}),
+    'render.v1': Object.freeze({}),
+    'trace.v1': Object.freeze({}),
+    'gpt.v1': Object.freeze({ activateLaterLifecycle }),
+  });
+  const prepared = createGptLaterIntegrationRegistration(RELEASE_ID).prepare(
+    Object.freeze({
+      config: Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled }),
+      interfaces,
+      onDispose: (callback: () => void) => preparationDisposers.push(callback),
+      signal: new AbortController().signal,
+    } satisfies IntegrationPrepareContext)
+  ) as PreparedIntegration;
+  return Object.freeze({
+    activateLaterLifecycle,
+    activationContext: Object.freeze({
+      afterCommit: vi.fn(),
+      onDispose: (callback: () => void) => activationDisposers.push(callback),
+      signal: new AbortController().signal,
+    } satisfies IntegrationActivationContext),
+    activationDisposers,
+    navigate,
+    navigationGeneration,
+    prepared,
+    preparationDisposers,
+    release,
+  });
+}
+
+describe('GPT deferred navigation and reconciliation owner', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    window.history.replaceState({}, '', '/');
+  });
+
+  it('leaves takeover history, listeners, timers, and reconciliation unchanged before activation', () => {
+    vi.useFakeTimers();
+    const beforePush = window.history.pushState;
+    const beforeReplace = window.history.replaceState;
+    const owner = harness();
+
+    expect(owner.activateLaterLifecycle).not.toHaveBeenCalled();
+    expect(window.history.pushState).toBe(beforePush);
+    expect(window.history.replaceState).toBe(beforeReplace);
+    expect(vi.getTimerCount()).toBe(0);
+
+    owner.preparationDisposers.reverse().forEach((release) => release());
+    expect(owner.activateLaterLifecycle).not.toHaveBeenCalled();
+  });
+
+  it('owns reconciliation without installing SPA hooks when page-bids delivery is disabled', async () => {
+    vi.useFakeTimers();
+    const beforePush = Object.getOwnPropertyDescriptor(window.history, 'pushState');
+    const beforeReplace = Object.getOwnPropertyDescriptor(window.history, 'replaceState');
+    const owner = harness(false);
+
+    owner.prepared.activate(owner.activationContext);
+
+    expect(owner.activateLaterLifecycle).toHaveBeenCalledOnce();
+    expect(Object.getOwnPropertyDescriptor(window.history, 'pushState')).toEqual(beforePush);
+    expect(Object.getOwnPropertyDescriptor(window.history, 'replaceState')).toEqual(beforeReplace);
+    window.history.pushState({}, '', '/disabled-page-bids');
+    window.dispatchEvent(new PopStateEvent('popstate'));
+    await vi.runAllTimersAsync();
+    expect(owner.navigate).not.toHaveBeenCalled();
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    expect(owner.release).toHaveBeenCalledOnce();
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('owns one deferred history listener and coalesced navigation timer across repeated routes', async () => {
+    vi.useFakeTimers();
+    const owner = harness();
+    owner.prepared.activate(owner.activationContext);
+
+    expect(owner.activateLaterLifecycle).toHaveBeenCalledOnce();
+    expect(owner.navigate).not.toHaveBeenCalled();
+    window.history.pushState({}, '', '/first?section=one');
+    expect(owner.navigate).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenLastCalledWith('/first?section=one');
+
+    window.history.pushState({}, '', '/second');
+    window.history.replaceState({}, '', '/third?latest=yes');
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenLastCalledWith('/third?latest=yes');
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+
+    window.dispatchEvent(new PopStateEvent('popstate'));
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('restores exact history ownership and cancels a pending navigation on disposal', async () => {
+    vi.useFakeTimers();
+    const beforePush = Object.getOwnPropertyDescriptor(window.history, 'pushState');
+    const beforeReplace = Object.getOwnPropertyDescriptor(window.history, 'replaceState');
+    const owner = harness();
+    owner.prepared.activate(owner.activationContext);
+    window.history.pushState({}, '', '/pending');
+    expect(vi.getTimerCount()).toBe(1);
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    expect(owner.release).toHaveBeenCalledOnce();
+    expect(Object.getOwnPropertyDescriptor(window.history, 'pushState')).toEqual(beforePush);
+    expect(Object.getOwnPropertyDescriptor(window.history, 'replaceState')).toEqual(beforeReplace);
+    expect(vi.getTimerCount()).toBe(0);
+    window.dispatchEvent(new PopStateEvent('popstate'));
+    await vi.runAllTimersAsync();
+    expect(owner.navigate).not.toHaveBeenCalled();
+
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('retries the same current route after its page-bids navigation is rejected', async () => {
+    vi.useFakeTimers();
+    const owner = harness();
+    owner.navigate.mockResolvedValueOnce(
+      Object.freeze({
+        status: 'rejected' as const,
+        navigationGeneration: owner.navigationGeneration,
+        current: true as const,
+      })
+    );
+    owner.prepared.activate(owner.activationContext);
+
+    window.history.pushState({}, '', '/retry-current');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledExactlyOnceWith('/retry-current');
+
+    window.history.replaceState({}, '', '/retry-current');
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+    expect(owner.navigate).toHaveBeenLastCalledWith('/retry-current');
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('retries the same current route after the navigation promise rejects', async () => {
+    vi.useFakeTimers();
+    const owner = harness();
+    owner.navigate.mockRejectedValueOnce(new Error('fictional current navigation failure'));
+    owner.prepared.activate(owner.activationContext);
+
+    window.history.pushState({}, '', '/retry-rejection');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledExactlyOnceWith('/retry-rejection');
+
+    window.history.replaceState({}, '', '/retry-rejection');
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+    expect(owner.navigate).toHaveBeenLastCalledWith('/retry-rejection');
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('does not let a stale generation failure roll back a newer committed route', async () => {
+    vi.useFakeTimers();
+    const owner = harness();
+    const firstGeneration = Object.freeze({});
+    const secondGeneration = Object.freeze({});
+    let rejectFirst!: (
+      result: Readonly<{
+        status: 'rejected';
+        navigationGeneration: object;
+        current: false;
+      }>
+    ) => void;
+    let commitSecond!: (
+      result: Readonly<{
+        status: 'committed';
+        navigationGeneration: object;
+        current: true;
+      }>
+    ) => void;
+    owner.navigate
+      .mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            rejectFirst = resolve;
+          })
+      )
+      .mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            commitSecond = resolve;
+          })
+      );
+    owner.prepared.activate(owner.activationContext);
+
+    window.history.pushState({}, '', '/stale-first');
+    await vi.advanceTimersByTimeAsync(0);
+    window.history.pushState({}, '', '/committed-second');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+
+    commitSecond(
+      Object.freeze({
+        status: 'committed',
+        navigationGeneration: secondGeneration,
+        current: true,
+      })
+    );
+    await Promise.resolve();
+    rejectFirst(
+      Object.freeze({
+        status: 'rejected',
+        navigationGeneration: firstGeneration,
+        current: false,
+      })
+    );
+    await Promise.resolve();
+
+    window.history.replaceState({}, '', '/committed-second');
+    await vi.runAllTimersAsync();
+    expect(owner.navigate).toHaveBeenCalledTimes(2);
+
+    owner.activationDisposers.reverse().forEach((release) => release());
+    owner.preparationDisposers.reverse().forEach((release) => release());
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts
new file mode 100644
index 000000000..d9f307a74
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts
@@ -0,0 +1,2467 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  adoptInitialGptDiagnosticsFromHandoff,
+  adoptInitialGptFactsFromHandoff,
+  adoptInitialGptSlotsFromHandoff,
+  adoptInitialPucTicketsFromHandoff,
+  installPbsCacheBridge,
+  publishGptWinner,
+  publishInitialGptProjection,
+  startGptSlotOperation,
+  type GptWinnerPublicationInput,
+  type GptSlotOperationInput,
+} from '../../../src/integrations/gpt/module';
+import type { BrowserAuctionProjectionV1 } from '../../../src/core/types';
+import { createLegacyGptRegistrationForTest as createGptIntegrationRegistration } from '../../helpers/legacy_gpt_registration';
+import { createGptIntegrationRegistration as createProductionGptRegistration } from '../../../src/integrations/gpt/module';
+import { createRenderRuntimeIntegrationRegistration } from '../../../src/integrations/render_runtime/module';
+import type { RuntimeCapabilityV1 } from '../../../src/kernel/runtime';
+import { createNoopGoogletagAdapter, type GoogletagFacade } from '../../../src/adapters/googletag';
+import { isGuardInstalled, resetGuardState } from '../../../src/integrations/gpt/script_guard';
+import { createTestNavigationIdentityIssuer } from '../../../src/kernel/identity';
+import {
+  createIntegrationRegistry,
+  type IntegrationInstallCallbacks,
+  type IntegrationRegistration,
+} from '../../../src/kernel/integration_registry';
+import { createRuntimeSession } from '../../../src/kernel/sessions';
+import {
+  createCommittedArtifactStore,
+  createRenderAttempt,
+  createSlotOperation,
+  type CommittedRenderArtifact,
+  type RenderAttempt,
+} from '../../../src/services/render';
+import { createTargetingService } from '../../../src/services/targeting';
+import { createReservationService } from '../../../src/services/reservations';
+import type { SlotRequestOutcome } from '../../../src/services/slots';
+import { acceptedGptFirstDisplayTakeover } from '../../first_display/helpers/compact_takeover';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RESERVATION_ID = `r1_${'a'.repeat(22)}`;
+const GPT_CONFIG = Object.freeze({ gamAttributionEnabled: false, pageBidsEnabled: true });
+
+describe('GPT first-display diagnostics adoption', () => {
+  it('hydrates exact physical-slot cycle state before slot adoption', () => {
+    const physicalSlot = {};
+    const adoptDiagnosticsState = vi.fn(() => true);
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        artifacts: Object.freeze([]),
+        cycles: Object.freeze([
+          Object.freeze({
+            nextCycleOrdinal: 3,
+            records: Object.freeze([
+              Object.freeze({
+                ordinal: 1,
+                responseIdentifier: 'response-one',
+                seen: Object.freeze(['slotRequested', 'slotRenderEnded'] as const),
+                state: 'completed' as const,
+              }),
+            ]),
+            token: 'gt1_4',
+            unknownPriorCycle: false,
+          }),
+        ]),
+        trace: Object.freeze({ nextGlobalSlotOrdinal: 7 }),
+      }),
+      identities: Object.freeze([physicalSlot]),
+    });
+
+    expect(adoptInitialGptDiagnosticsFromHandoff(adoption, { adoptDiagnosticsState })).toBe(
+      adoption
+    );
+    expect(adoptDiagnosticsState).toHaveBeenCalledWith({
+      nextTraceTokenOrdinal: 7,
+      slots: [
+        {
+          nextCycleOrdinal: 3,
+          physicalSlot,
+          records: [
+            {
+              ordinal: 1,
+              responseIdentifier: 'response-one',
+              seen: ['slotRequested', 'slotRenderEnded'],
+              state: 'completed',
+            },
+          ],
+          traceToken: 'gt1_4',
+          unknownPriorCycle: false,
+        },
+      ],
+    });
+  });
+
+  it('restores diagnostics facts only when the diagnostics owner is selected', () => {
+    const adoptFirstDisplay = vi.fn((..._arguments: unknown[]) => true);
+    const physicalSlot = {};
+    const diagnosticsToken = Object.freeze(Object.create(null) as object);
+    const fact = Object.freeze({
+      version: 1 as const,
+      event: 'slotRequested' as const,
+      token: 'gt1_1',
+      runtimeSlotNumber: 1,
+      cycleOrdinal: 1,
+      disposition: 'matched' as const,
+      issueReason: null,
+      capturedAtMs: 5,
+      elementId: 'slot-1',
+      adUnitPath: '/123/slot-1',
+      requestedSlotSizes: Object.freeze([Object.freeze([300, 250] as const)]),
+      isEmpty: null,
+      renderedSize: null,
+      isBackfill: null,
+      slotContentChanged: null,
+      visibilityPercent: null,
+    });
+    const diagnostics = Object.freeze({
+      facts: Object.freeze([fact]),
+      overflowCount: 3,
+      dropCount: 2,
+    });
+    const adapter = {
+      diagnosticsIdentity: (slot: object) =>
+        slot === physicalSlot
+          ? Object.freeze({
+              token: diagnosticsToken,
+              traceToken: 'gt1_1' as never,
+              runtimeSlotNumber: 1,
+              cycleOrdinal: 1 as never,
+            })
+          : undefined,
+    };
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        artifacts: Object.freeze([]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1', token: 'gt1_1' })]),
+        gptDiagnostics: diagnostics,
+        slots: Object.freeze([
+          Object.freeze({ id: 'slot-1', formats: Object.freeze([Object.freeze([300, 250])]) }),
+        ]),
+      }),
+      identities: Object.freeze([physicalSlot]),
+    });
+
+    const projection = Object.freeze({
+      auction: Object.freeze({ auctionId: 'initial-auction' }),
+    }) as unknown as Readonly<BrowserAuctionProjectionV1>;
+    expect(
+      adoptInitialGptFactsFromHandoff(adoption, { adoptFirstDisplay }, adapter, projection)
+    ).toBe(adoption);
+    expect(adoptFirstDisplay).toHaveBeenCalledWith(
+      diagnostics,
+      expect.any(Function),
+      expect.any(Function)
+    );
+    const resolve = adoptFirstDisplay.mock.calls[0]?.[1] as (token: string) => unknown;
+    expect(resolve('gt1_1')).toMatchObject({ token: diagnosticsToken, runtimeSlotNumber: 1 });
+    const resolveOpportunity = adoptFirstDisplay.mock.calls[0]?.[2] as (
+      token: string,
+      slot: Readonly<object>
+    ) => unknown;
+    expect(resolveOpportunity('gt1_1', resolve('gt1_1') as Readonly<object>)).toMatchObject({
+      kind: 'trustedServerOpportunity',
+      auctionSlotId: 'slot-1',
+      opportunity: 'renderable_candidate',
+      requestedSlotSizes: [[300, 250]],
+      trustedServerAuctionId: 'initial-auction',
+    });
+    expect(
+      adoptInitialGptFactsFromHandoff(adoption, undefined, adapter, projection)
+    ).toBeUndefined();
+  });
+
+  it('transfers only lifecycle-ticket tombstones to the persistent PUC owner', () => {
+    const adoptFirstDisplayTickets = vi.fn(() => true);
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        highWater: Object.freeze({ reservationClockEpochMs: 40, nextTicketOrdinal: 8 }),
+        tombstones: Object.freeze([
+          Object.freeze({ expiresAtMs: 80, kind: 'ticket', value: `t1_${'a'.repeat(22)}` }),
+          Object.freeze({ expiresAtMs: 90, kind: 'reservation', value: RESERVATION_ID }),
+        ]),
+      }),
+      identities: Object.freeze([]),
+    });
+
+    expect(adoptInitialPucTicketsFromHandoff(adoption, { adoptFirstDisplayTickets })).toBe(
+      adoption
+    );
+    expect(adoptFirstDisplayTickets).toHaveBeenCalledWith({
+      clockEpochMs: 40,
+      nextTicketOrdinal: 8,
+      tombstones: [{ expiresAtMs: 80, ticket: `t1_${'a'.repeat(22)}` }],
+    });
+  });
+});
+
+function createAttemptHarness() {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(1);
+          return target;
+        },
+      }),
+  });
+  const navigationResult = runtime.startInitialNavigation();
+  if (!navigationResult.ok) throw new Error('Expected navigation creation');
+  const batch = navigationResult.value.createAuctionBatch('gpt-cycle');
+  if (!batch) throw new Error('Expected batch creation');
+  const artifacts = createCommittedArtifactStore();
+  const reservations = createReservationService({
+    prepareRenderSource: (candidate) =>
+      typeof candidate === 'object' &&
+      candidate !== null &&
+      Object.isFrozen(candidate) &&
+      'type' in candidate &&
+      'version' in candidate
+        ? (candidate as Readonly<{ type: 'aps' | 'adm'; version: 1 }>)
+        : undefined,
+  });
+  const createAttemptWithOwner = (parentAttemptId?: string) => {
+    const owner = batch.createRenderAttempt('slot-one');
+    if (!owner.ok) throw new Error(`Expected attempt owner: ${owner.reason}`);
+    const created = createRenderAttempt({
+      artifacts,
+      owner: owner.value,
+      prepareRenderSource: (candidate) =>
+        typeof candidate === 'object' &&
+        candidate !== null &&
+        Object.isFrozen(candidate) &&
+        'type' in candidate &&
+        'version' in candidate
+          ? (candidate as Readonly<{ type: 'aps' | 'adm'; version: 1 }>)
+          : undefined,
+      reservations,
+      ...(parentAttemptId === undefined ? {} : { parentAttemptId }),
+    });
+    if (!created.ok) throw new Error(`Expected render attempt: ${created.reason}`);
+    return { attempt: created.value, owner: owner.value };
+  };
+  const primaryCreated = createAttemptWithOwner();
+  const primary = primaryCreated.attempt;
+  const artifact = Object.freeze({
+    kind: 'puc' as const,
+    attemptId: primary.id,
+    slot: primary.slot,
+    navigationGeneration: primary.navigationGeneration,
+    dispose: vi.fn(),
+  }) satisfies CommittedRenderArtifact;
+  return {
+    artifact,
+    createAttempt: (parentAttemptId: string): RenderAttempt =>
+      createAttemptWithOwner(parentAttemptId).attempt,
+    navigation: navigationResult.value,
+    primary,
+    primaryOwner: primaryCreated.owner,
+    reservations,
+    runtime,
+  };
+}
+
+function deferredSlotOutcome() {
+  let resolve!: (outcome: SlotRequestOutcome) => void;
+  const result = new Promise<SlotRequestOutcome>((resolveResult) => {
+    resolve = resolveResult;
+  });
+  const dispose = vi.fn();
+  return {
+    dispose,
+    request: vi.fn(() => Object.freeze({ status: 'active' as const, result, dispose })),
+    resolve,
+  };
+}
+
+function manifest(ids: readonly string[]) {
+  return {
+    version: 1,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) => ({ id, phase: 'takeover' as const })),
+  };
+}
+
+function registration(
+  id: string,
+  prepare: IntegrationRegistration['prepare']
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id,
+    phase: 'takeover',
+    releaseId: RELEASE_ID,
+    prepareSync: () => Object.freeze({ activate: () => undefined }),
+    prepare,
+  });
+}
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+function pbsCacheProjection(
+  sources: readonly Readonly<{
+    cacheHost: string;
+    cacheId: string;
+    cachePath: string;
+    divId: string;
+    slot: string;
+  }>[]
+): Readonly<BrowserAuctionProjectionV1> {
+  return Object.freeze({
+    version: 1 as const,
+    auction: Object.freeze({
+      version: 1 as const,
+      auctionId: 'pbs-cache-auction',
+      results: Object.freeze(
+        sources.map((source, index) =>
+          Object.freeze({
+            slot: source.slot,
+            outcome: 'winner' as const,
+            candidateId: `CACHEBID${String(index).padStart(4, '0')}`,
+          })
+        )
+      ),
+    }),
+    slots: Object.freeze(
+      sources.map((source) =>
+        Object.freeze({
+          slot: source.slot,
+          gamUnitPath: `/123/${source.slot}`,
+          divId: source.divId,
+          formats: Object.freeze([Object.freeze([300, 250] as const)]),
+          targeting: Object.freeze({}),
+        })
+      )
+    ),
+    bids: Object.freeze(
+      sources.map((source, index) =>
+        Object.freeze({
+          candidateId: `CACHEBID${String(index).padStart(4, '0')}`,
+          slot: source.slot,
+          provider: 'prebid',
+          upstreamBidId: `upstream-${index}`,
+          cpm: 1.25,
+          currency: 'USD' as const,
+          targeting: Object.freeze({}),
+          renderSource: Object.freeze({
+            type: 'pbs_cache' as const,
+            version: 1 as const,
+            cacheId: source.cacheId,
+            cacheHost: source.cacheHost,
+            cachePath: source.cachePath,
+            width: 300,
+            height: 250,
+          }),
+        })
+      )
+    ),
+  }) as unknown as Readonly<BrowserAuctionProjectionV1>;
+}
+
+function pbsCacheSourceFrame(divId: string): HTMLIFrameElement {
+  const root = document.createElement('div');
+  root.id = divId;
+  root.style.width = '1px';
+  root.style.height = '1px';
+  const frame = document.createElement('iframe');
+  frame.setAttribute('width', '1');
+  frame.setAttribute('height', '1');
+  frame.style.width = '1px';
+  frame.style.height = '1px';
+  root.appendChild(frame);
+  document.body.appendChild(root);
+  return frame;
+}
+
+function startPbsCacheBridge(projection: Readonly<BrowserAuctionProjectionV1>) {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(3);
+          return target;
+        },
+      }),
+  });
+  const navigation = runtime.startInitialNavigation(projection);
+  if (!navigation.ok) throw new Error('Expected PBS Cache test navigation');
+  const observe = vi.fn(() => true);
+  const release = installPbsCacheBridge(
+    document,
+    Object.freeze({
+      navigation: navigation.value,
+      projection,
+      session: runtime,
+    }),
+    () => true,
+    observe
+  );
+  return { navigation: navigation.value, observe, release, runtime };
+}
+
+function dispatchPbsCacheRequest(
+  source: Window,
+  adId: string,
+  postMessage: ReturnType<typeof vi.fn>
+): ReturnType<typeof vi.spyOn> {
+  const event = new MessageEvent('message', {
+    data: JSON.stringify({ message: 'Prebid Request', adId }),
+    ports: [Object.freeze({ postMessage }) as unknown as MessagePort],
+    source,
+  });
+  const stopped = vi.spyOn(event, 'stopImmediatePropagation');
+  window.dispatchEvent(event);
+  return stopped;
+}
+
+describe('GPT-owned PBS Cache bridge', () => {
+  const sharedCacheId = 'shared cache/id';
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    document.getElementById('cache-slot-one')?.remove();
+    document.getElementById('cache-slot-two')?.remove();
+    document.getElementById('foreign-cache-slot')?.remove();
+  });
+
+  it('binds duplicate cache ids to the requesting slot and preserves current-main parse, macro, and resize behavior', async () => {
+    const projection = pbsCacheProjection([
+      {
+        cacheId: sharedCacheId,
+        cacheHost: 'first-cache.example',
+        cachePath: '/first',
+        divId: 'cache-slot-one',
+        slot: 'slot-one',
+      },
+      {
+        cacheId: sharedCacheId,
+        cacheHost: 'second-cache.example:8443',
+        cachePath: '/opaque%2Fpath',
+        divId: 'cache-slot-two',
+        slot: 'slot-two',
+      },
+    ]);
+    const first = pbsCacheSourceFrame('cache-slot-one');
+    const second = pbsCacheSourceFrame('cache-slot-two');
+    const foreign = pbsCacheSourceFrame('foreign-cache-slot');
+    const fetchCache = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      text: async () =>
+        JSON.stringify({
+          adm: '<main data-price="${AUCTION_PRICE}" data-b64="${AUCTION_PRICE:B64}">cached</main>',
+          width: 320,
+          height: 100,
+          price: 2.75,
+        }),
+    }));
+    vi.stubGlobal('fetch', fetchCache);
+    const bridge = startPbsCacheBridge(projection);
+    const foreignPost = vi.fn();
+    const foreignStopped = dispatchPbsCacheRequest(
+      foreign.contentWindow!,
+      sharedCacheId,
+      foreignPost
+    );
+    expect(foreignStopped).not.toHaveBeenCalled();
+    expect(fetchCache).not.toHaveBeenCalled();
+
+    const postMessage = vi.fn();
+    const stopped = dispatchPbsCacheRequest(second.contentWindow!, sharedCacheId, postMessage);
+    await vi.waitFor(() => expect(postMessage).toHaveBeenCalledOnce());
+    expect(stopped).toHaveBeenCalledOnce();
+    expect(fetchCache).toHaveBeenCalledExactlyOnceWith(
+      'https://second-cache.example:8443/opaque%2Fpath?uuid=shared%20cache%2Fid',
+      { mode: 'cors' }
+    );
+    expect(JSON.parse(String(postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'Prebid Response',
+      adId: sharedCacheId,
+      ad: '<main data-price="2.75" data-b64="${AUCTION_PRICE:B64}">cached</main>',
+      renderer: expect.any(String),
+      width: 320,
+      height: 100,
+    });
+    expect(second.style.width).toBe('320px');
+    expect(second.style.height).toBe('100px');
+    expect(first.style.width).toBe('1px');
+    expect(bridge.observe).not.toHaveBeenCalled();
+    bridge.release();
+    bridge.runtime.dispose();
+  });
+
+  it('keeps fetch, payload, and response-post failures typed and suppresses duplicate in-flight work', async () => {
+    const projection = pbsCacheProjection([
+      {
+        cacheId: sharedCacheId,
+        cacheHost: 'cache.example',
+        cachePath: '/pbc/v1/cache',
+        divId: 'cache-slot-one',
+        slot: 'slot-one',
+      },
+    ]);
+    const frame = pbsCacheSourceFrame('cache-slot-one');
+    let resolveResponse!: (
+      response: Readonly<{ ok: boolean; status: number; text: () => Promise<string> }>
+    ) => void;
+    const fetchCache = vi.fn(
+      () =>
+        new Promise<Readonly<{ ok: boolean; status: number; text: () => Promise<string> }>>(
+          (resolve) => {
+            resolveResponse = resolve;
+          }
+        )
+    );
+    vi.stubGlobal('fetch', fetchCache);
+    const bridge = startPbsCacheBridge(projection);
+    const firstPost = vi.fn();
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, firstPost);
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, vi.fn());
+    expect(fetchCache).toHaveBeenCalledOnce();
+    resolveResponse({ ok: true, status: 200, text: async () => '{"not_adm":true}' });
+    await vi.waitFor(() =>
+      expect(bridge.observe).toHaveBeenCalledWith(
+        Object.freeze({
+          kind: 'pbs_cache_bridge',
+          slotId: 'slot-one',
+          reason: 'invalid_cache_payload',
+        })
+      )
+    );
+    expect(firstPost).not.toHaveBeenCalled();
+
+    fetchCache.mockResolvedValueOnce({ ok: false, status: 503, text: async () => '' });
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, vi.fn());
+    await vi.waitFor(() =>
+      expect(bridge.observe).toHaveBeenCalledWith(
+        Object.freeze({
+          kind: 'pbs_cache_bridge',
+          slotId: 'slot-one',
+          reason: 'cache_fetch_failed',
+        })
+      )
+    );
+
+    fetchCache.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: async () => '<main>raw cached creative</main>',
+    });
+    const throwingPost = vi.fn(() => {
+      throw new Error('closed port');
+    });
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, throwingPost);
+    await vi.waitFor(() =>
+      expect(bridge.observe).toHaveBeenCalledWith(
+        Object.freeze({
+          kind: 'pbs_cache_bridge',
+          slotId: 'slot-one',
+          reason: 'response_post_failed',
+        })
+      )
+    );
+    expect(frame.style.width).toBe('1px');
+    bridge.release();
+    bridge.runtime.dispose();
+  });
+
+  it('makes late cache completion and post-disposal messages inert', async () => {
+    const projection = pbsCacheProjection([
+      {
+        cacheId: sharedCacheId,
+        cacheHost: 'cache.example',
+        cachePath: '/pbc/v1/cache',
+        divId: 'cache-slot-one',
+        slot: 'slot-one',
+      },
+    ]);
+    const frame = pbsCacheSourceFrame('cache-slot-one');
+    let resolveResponse!: (
+      response: Readonly<{ ok: boolean; status: number; text: () => Promise<string> }>
+    ) => void;
+    const fetchCache = vi.fn(
+      () =>
+        new Promise<Readonly<{ ok: boolean; status: number; text: () => Promise<string> }>>(
+          (resolve) => {
+            resolveResponse = resolve;
+          }
+        )
+    );
+    vi.stubGlobal('fetch', fetchCache);
+    const bridge = startPbsCacheBridge(projection);
+    const postMessage = vi.fn();
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, postMessage);
+    expect(fetchCache).toHaveBeenCalledOnce();
+    expect(bridge.runtime.replaceNavigation()).toMatchObject({ ok: true });
+    resolveResponse({
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ adm: '<main>late</main>' }),
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(postMessage).not.toHaveBeenCalled();
+    expect(bridge.observe).not.toHaveBeenCalled();
+
+    bridge.release();
+    dispatchPbsCacheRequest(frame.contentWindow!, sharedCacheId, vi.fn());
+    expect(fetchCache).toHaveBeenCalledOnce();
+    bridge.runtime.dispose();
+  });
+});
+
+describe('transactional GPT integration module', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    resetGuardState();
+    delete (window as Window & { googletag?: unknown }).googletag;
+    document.getElementById('takeover-slot')?.remove();
+    document.getElementById('spa-winner')?.remove();
+  });
+
+  it('adopts exact first-display GPT identities without issuing a second GPT action', () => {
+    const physicalSlot = {};
+    const frame = {};
+    const navigationGeneration = {};
+    const committedArtifact: CommittedRenderArtifact = Object.freeze({
+      attemptId: `a1_${'d'.repeat(22)}`,
+      dispose: vi.fn(),
+      kind: 'puc',
+      navigationGeneration,
+      slot: 'slot-1',
+    });
+    const artifactStore = createCommittedArtifactStore();
+    expect(artifactStore.promote(committedArtifact)).toBe(true);
+    const adoptCommittedArtifact = vi.fn(() => true);
+    const adoptGptSlot = vi.fn(() => Object.freeze({ ok: true as const }));
+    const adoptRegistrationHighWater = vi.fn(() => true);
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        highWater: Object.freeze({ nextSlotRegistrationOrdinal: 2 }),
+        slots: Object.freeze([
+          Object.freeze({
+            id: 'slot-1',
+            owner: 'trusted_server',
+            domId: 'div-1',
+            gamPath: '/123/slot-1',
+            formats: Object.freeze([Object.freeze([300, 250])]),
+            targetingOwnership: Object.freeze([]),
+          }),
+        ]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        artifacts: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+      }),
+      identities: Object.freeze([physicalSlot, frame]),
+    });
+
+    expect(
+      adoptInitialGptSlotsFromHandoff(
+        adoption,
+        navigationGeneration,
+        {
+          adoptCommittedArtifact,
+          adoptGptSlot,
+          adoptRegistrationHighWater,
+        },
+        artifactStore,
+        {
+          adopt: vi.fn(),
+          observePublisherMutations: vi.fn(),
+        },
+        {} as never
+      )
+    ).toBe(adoption);
+    expect(adoptRegistrationHighWater).toHaveBeenCalledExactlyOnceWith(navigationGeneration, 2);
+    expect(adoptGptSlot).toHaveBeenCalledExactlyOnceWith(navigationGeneration, 'slot-1', {
+      definition: {
+        adUnitPath: '/123/slot-1',
+        elementId: 'div-1',
+        sizes: [[300, 250]],
+      },
+      ownership: 'trusted_server',
+      slot: physicalSlot,
+    });
+    expect(adoptCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      navigationGeneration,
+      'slot-1',
+      committedArtifact,
+      expect.any(Function)
+    );
+  });
+
+  it.each(['unchanged', 'same_publisher_write', 'different_publisher_write'] as const)(
+    'transfers first-display targeting ownership and preserves %s semantics',
+    (mutation) => {
+      const physicalSlot = {};
+      const frame = {};
+      const navigationGeneration = {};
+      const values = new Map<string, readonly string[]>([['hb_adid', ['trusted']]]);
+      const setTargeting = vi.fn((slot: object, key: string, value: string | readonly string[]) => {
+        expect(slot).toBe(physicalSlot);
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      });
+      const clearTargeting = vi.fn((_slot: object, key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      });
+      let publisherObserver:
+        Readonly<{ beforePublisherMutation: (slot: object, key?: string) => void }> | undefined;
+      const releaseObservation = Object.assign(vi.fn(), { isCurrent: () => true });
+      const facade = {
+        clearTargeting,
+        getTargeting: (_slot: object, key: string) => Object.freeze([...(values.get(key) ?? [])]),
+        observeTargeting: (
+          slot: object,
+          observer: Readonly<{ beforePublisherMutation: (slot: object, key?: string) => void }>
+        ) => {
+          expect(slot).toBe(physicalSlot);
+          publisherObserver = observer;
+          return releaseObservation;
+        },
+        setTargeting,
+      };
+      const adapter = {
+        run: (command: (gpt: typeof facade) => unknown) => {
+          const result = command(facade);
+          return Object.freeze({
+            status: 'present' as const,
+            result: Promise.resolve(result),
+            dispose: vi.fn(),
+          });
+        },
+      } as never;
+      const artifact: CommittedRenderArtifact = Object.freeze({
+        attemptId: `a1_${'e'.repeat(22)}`,
+        dispose: vi.fn(),
+        kind: 'aps_mount',
+        navigationGeneration,
+        slot: 'slot-1',
+      });
+      const artifactStore = createCommittedArtifactStore();
+      expect(artifactStore.promote(artifact)).toBe(true);
+      let retireTargeting: (() => void) | undefined;
+      const service = {
+        adoptCommittedArtifact: vi.fn(
+          (
+            _generation: object,
+            _slotId: string,
+            _artifact: CommittedRenderArtifact,
+            onRetire?: () => void
+          ) => {
+            retireTargeting = onRetire;
+            return true;
+          }
+        ),
+        adoptGptSlot: vi.fn(() => Object.freeze({ ok: true as const })),
+        adoptRegistrationHighWater: vi.fn(() => true),
+      };
+      const adoption = Object.freeze({
+        version: 1 as const,
+        adoptInitialDisplay: true as const,
+        handoff: Object.freeze({
+          highWater: Object.freeze({ nextSlotRegistrationOrdinal: 2 }),
+          slots: Object.freeze([
+            Object.freeze({
+              id: 'slot-1',
+              owner: 'publisher' as const,
+              targetingOwnership: Object.freeze([
+                Object.freeze({
+                  installed: 'trusted',
+                  key: 'hb_adid',
+                  prior: Object.freeze(['publisher-original']),
+                }),
+              ]),
+            }),
+          ]),
+          cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+          artifacts: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        }),
+        identities: Object.freeze([physicalSlot, frame]),
+      });
+      const targeting = createTargetingService();
+
+      expect(
+        adoptInitialGptSlotsFromHandoff(
+          adoption,
+          navigationGeneration,
+          service,
+          artifactStore,
+          targeting,
+          adapter
+        )
+      ).toBe(adoption);
+      expect(setTargeting).not.toHaveBeenCalled();
+
+      if (mutation !== 'unchanged') {
+        publisherObserver?.beforePublisherMutation(physicalSlot, 'hb_adid');
+        values.set(
+          'hb_adid',
+          Object.freeze([mutation === 'same_publisher_write' ? 'trusted' : 'publisher-new'])
+        );
+      }
+      retireTargeting?.();
+
+      expect(values.get('hb_adid')).toEqual([
+        mutation === 'unchanged'
+          ? 'publisher-original'
+          : mutation === 'same_publisher_write'
+            ? 'trusted'
+            : 'publisher-new',
+      ]);
+      expect(setTargeting).toHaveBeenCalledTimes(mutation === 'unchanged' ? 1 : 0);
+      expect(releaseObservation).toHaveBeenCalledOnce();
+    }
+  );
+
+  it.each([
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: false,
+      parserStateValid: true,
+      gamAttributionEnabled: false,
+    },
+    {
+      diagnosticsActive: true,
+      adoptInitialDisplay: false,
+      parserStateValid: true,
+      gamAttributionEnabled: false,
+    },
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: false,
+      parserStateValid: true,
+      gamAttributionEnabled: true,
+    },
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: true,
+      parserStateValid: true,
+      gamAttributionEnabled: false,
+    },
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: true,
+      parserStateValid: true,
+      gamAttributionEnabled: true,
+    },
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: true,
+      parserStateValid: false,
+      gamAttributionEnabled: false,
+    },
+    {
+      diagnosticsActive: false,
+      adoptInitialDisplay: true,
+      parserStateValid: 'absent',
+      gamAttributionEnabled: false,
+    },
+  ])(
+    'uses only catalog capabilities without replaying adopted display (diagnostics=$diagnosticsActive, adoption=$adoptInitialDisplay, parser=$parserStateValid, attribution=$gamAttributionEnabled)',
+    async ({ diagnosticsActive, adoptInitialDisplay, parserStateValid, gamAttributionEnabled }) => {
+      vi.useFakeTimers();
+      const NativeMutationObserver = window.MutationObserver;
+      const activeMutationObservers = new Set<MutationObserver>();
+      class TrackingMutationObserver implements MutationObserver {
+        readonly inner: MutationObserver;
+
+        constructor(callback: MutationCallback) {
+          this.inner = new NativeMutationObserver(callback);
+        }
+
+        disconnect(): void {
+          activeMutationObservers.delete(this);
+          this.inner.disconnect();
+        }
+
+        observe(target: Node, options?: MutationObserverInit): void {
+          activeMutationObservers.add(this);
+          this.inner.observe(target, options);
+        }
+
+        takeRecords(): MutationRecord[] {
+          return this.inner.takeRecords();
+        }
+      }
+      vi.stubGlobal('MutationObserver', TrackingMutationObserver);
+      const listenerTypes: string[] = [];
+      const removedTypes: string[] = [];
+      const targeting = new Map<string, readonly string[]>();
+      const publisherSlot = {
+        clearTargeting: vi.fn((key?: string) => {
+          if (key === undefined) targeting.clear();
+          else targeting.delete(key);
+          return publisherSlot;
+        }),
+        getAdUnitPath: () => '/123/spa-winner',
+        getSlotElementId: () => 'spa-winner',
+        getTargeting: (key: string) => targeting.get(key) ?? [],
+        setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+          targeting.set(key, typeof value === 'string' ? [value] : value);
+          return publisherSlot;
+        }),
+      };
+      const definedSlots: object[] = [];
+      const createDefinedSlot = (adUnitPath: string, elementId: string) => ({
+        addService: vi.fn(),
+        clearTargeting: vi.fn(),
+        getAdUnitPath: () => adUnitPath,
+        getSlotElementId: () => elementId,
+        getTargeting: () => [],
+        setTargeting: vi.fn(),
+      });
+      const defineSlot = vi.fn((adUnitPath: string, _sizes: unknown, elementId: string) => {
+        const slot = createDefinedSlot(adUnitPath, elementId);
+        definedSlots.push(slot);
+        return slot;
+      });
+      const destroySlots = vi.fn((slots: readonly object[]) => {
+        for (const slot of slots) {
+          const index = definedSlots.indexOf(slot);
+          if (index >= 0) definedSlots.splice(index, 1);
+        }
+        return true;
+      });
+      const display = vi.fn();
+      const refresh = vi.fn();
+      const pubads = {
+        addEventListener: vi.fn((type: string, _listener: (event: unknown) => void) => {
+          listenerTypes.push(type);
+        }),
+        disableInitialLoad: vi.fn(),
+        getSlots: vi.fn(() => [publisherSlot, ...definedSlots]),
+        refresh,
+        removeEventListener: vi.fn((type: string, _listener: (event: unknown) => void) => {
+          removedTypes.push(type);
+        }),
+      };
+      const setConfig = vi.fn();
+      (window as Window & { googletag?: unknown }).googletag = {
+        apiReady: true,
+        pubadsReady: true,
+        cmd: { push: (command: () => void) => (command(), 0) },
+        defineSlot,
+        destroySlots,
+        display,
+        getConfig: vi.fn(() => ({ disableInitialLoad: false })),
+        pubads: () => pubads,
+        setConfig,
+      };
+      const providerFacades = new Map<string, Readonly<Record<string, unknown>>>();
+      const protect = vi.fn(() => true);
+      const bootManifest = Object.freeze({
+        version: 1 as const,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+        integrations: Object.freeze([
+          Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+          Object.freeze({ id: 'gpt', phase: 'takeover' as const }),
+        ]),
+      });
+      const runtime = Object.freeze({
+        attachAuctionContextService: () => () => undefined,
+        boot: () =>
+          Object.freeze({
+            auctionProjection: Object.freeze({
+              version: 1,
+              auction: Object.freeze({
+                version: 1,
+                auctionId: 'initial',
+                results: Object.freeze([
+                  Object.freeze({
+                    slot: 'takeover-slot',
+                    outcome: 'no_bid' as const,
+                  }),
+                ]),
+              }),
+              slots: Object.freeze([
+                Object.freeze({
+                  slot: 'takeover-slot',
+                  gamUnitPath: '/123/takeover-slot',
+                  divId: 'takeover-slot',
+                  formats: Object.freeze([Object.freeze([300, 250] as const)]),
+                  targeting: Object.freeze({}),
+                }),
+              ]),
+              bids: Object.freeze([]),
+            }),
+            diagnostics: Object.freeze({
+              version: 1,
+              renderTraceOverlay: false,
+              gpt: Object.freeze({ active: diagnosticsActive }),
+            }),
+            manifest: bootManifest,
+          }),
+        document,
+        enqueue: () => true,
+        generation: Object.freeze({}),
+        protectFirstDisplayAttemptBatch: protect,
+        registerAuctionContext: () => () => undefined,
+      } satisfies RuntimeCapabilityV1);
+      const registry = createIntegrationRegistry({
+        manifest: bootManifest,
+        releaseId: RELEASE_ID,
+        knownIntegrationIds: Object.freeze(['render_runtime', 'gpt']),
+        catalog: Object.freeze([
+          Object.freeze({
+            id: 'render_runtime',
+            phase: 'takeover' as const,
+            trigger: null,
+            consumes: Object.freeze(['runtime.v1']),
+            provides: Object.freeze([
+              'slots.v1',
+              'auction.v1',
+              'render.v1',
+              'messages.v1',
+              'trace.v1',
+              'trace.presentation.v1',
+              'direct.v1',
+            ]),
+          }),
+          Object.freeze({
+            id: 'gpt',
+            phase: 'takeover' as const,
+            trigger: null,
+            consumes: Object.freeze([
+              'runtime.v1',
+              'slots.v1',
+              'auction.v1',
+              'render.v1',
+              'messages.v1',
+              'trace.v1',
+            ]),
+            provides: Object.freeze(['gpt.v1', 'gpt.events.v1', 'pbs_cache.baseline.v1']),
+          }),
+        ]),
+        runtimeCapability: runtime,
+        getBindings: (id) =>
+          Object.freeze({
+            config:
+              id === 'gpt' ? Object.freeze({ ...GPT_CONFIG, gamAttributionEnabled }) : undefined,
+            interfaces: Object.freeze({}),
+          }),
+        onCapabilityStaged: (key, facade) => {
+          providerFacades.set(key, facade);
+          return () => {
+            if (providerFacades.get(key) === facade) providerFacades.delete(key);
+          };
+        },
+        startedAtMs: 0,
+        now: () => 0,
+      });
+      const takeoverElement = document.createElement('div');
+      takeoverElement.id = 'takeover-slot';
+      document.body.appendChild(takeoverElement);
+      const adoptedFrame = document.createElement('iframe');
+      takeoverElement.appendChild(adoptedFrame);
+      expect(registry.register(createRenderRuntimeIntegrationRegistration(RELEASE_ID))).toBe(true);
+      expect(registry.register(createProductionGptRegistration(RELEASE_ID))).toBe(true);
+
+      const installCallbacks: IntegrationInstallCallbacks = {
+        ...callbacks([]),
+        ...(adoptInitialDisplay
+          ? {
+              coordinateTakeover: (
+                prepared: Parameters<
+                  NonNullable<IntegrationInstallCallbacks['coordinateTakeover']>
+                >[0]
+              ) => {
+                const slices = Object.freeze(
+                  parserStateValid === 'absent'
+                    ? (['first_display'] as const)
+                    : (['first_display', 'gpt_initial'] as const)
+                );
+                const candidate = acceptedGptFirstDisplayTakeover(
+                  RELEASE_ID,
+                  RESERVATION_ID,
+                  parserStateValid === true
+                    ? 'valid'
+                    : parserStateValid === false
+                      ? 'invalid'
+                      : 'absent',
+                  gamAttributionEnabled
+                );
+                const handoff = prepared.validateHandoff(
+                  candidate.capture ||
+                    Object.freeze({
+                      version: 1 as const,
+                      releaseId: RELEASE_ID,
+                      generation: 1,
+                      projectionDigest: 'b'.repeat(64),
+                      integrationConfigDigest: 'c'.repeat(64),
+                      slices,
+                      slots: Object.freeze([
+                        Object.freeze({
+                          id: 'takeover-slot',
+                          aliases: Object.freeze([]),
+                          owner: 'publisher',
+                          domId: 'takeover-slot',
+                          gamPath: '/123/takeover-slot',
+                          formats: Object.freeze([Object.freeze([300, 250])]),
+                          outcome: 'accepted' as const,
+                          targeting: Object.freeze([
+                            Object.freeze(['hb_adid', RESERVATION_ID] as const),
+                          ]),
+                          committedArtifact: 'gpt_adm' as const,
+                          targetingOwnership: Object.freeze([]),
+                          gptToken: 'gt1_1',
+                        }),
+                      ]),
+                      attempts: Object.freeze([
+                        Object.freeze({
+                          id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+                          slotId: 'takeover-slot',
+                          ordinal: 1,
+                          state: 'accepted' as const,
+                          reason: null,
+                        }),
+                      ]),
+                      tombstones: Object.freeze([]),
+                      artifacts: Object.freeze([
+                        Object.freeze({
+                          hostPosition: null,
+                          hostPositionPriority: null,
+                          slotId: 'takeover-slot',
+                          kind: 'gpt_adm' as const,
+                          owner: 'trusted_server' as const,
+                          token: RESERVATION_ID,
+                        }),
+                      ]),
+                      parserState:
+                        parserStateValid === true
+                          ? Object.freeze([
+                              Object.freeze({
+                                sliceId: 'gpt_initial',
+                                observations: Object.freeze(['gam', 'v']),
+                                values: Object.freeze([
+                                  Object.freeze(['gam', gamAttributionEnabled] as const),
+                                  Object.freeze(['v', 1] as const),
+                                ]),
+                              }),
+                            ])
+                          : Object.freeze([]),
+                      gptDiagnostics: Object.freeze({
+                        facts: Object.freeze([]),
+                        overflowCount: 0,
+                        dropCount: 0,
+                      }),
+                      timing: Object.freeze({
+                        bidsScriptMs: 1,
+                        firstDisplayMs: 2,
+                        terminalMs: 3,
+                        paintMs: 4,
+                      }),
+                      highWater: Object.freeze({
+                        navigationAttemptPrefix: 'AAECAwQFBgc',
+                        nextAttemptOrdinal: 2,
+                        nextNavigationAttemptOrdinal: 2,
+                        nextSlotRegistrationOrdinal: 2,
+                        nextReservationOrdinal: 2,
+                        nextTicketOrdinal: 1,
+                        reservationClockEpochMs: 0,
+                      }),
+                      cycles: Object.freeze([
+                        Object.freeze({
+                          nextCycleOrdinal: 2,
+                          quarantines: Object.freeze([]),
+                          records: Object.freeze([
+                            Object.freeze({
+                              ordinal: 1,
+                              responseIdentifier: 'response-one',
+                              seen: Object.freeze(['slotRequested', 'slotRenderEnded'] as const),
+                              state: 'completed' as const,
+                            }),
+                          ]),
+                          slotId: 'takeover-slot',
+                          token: 'gt1_1',
+                          unknownPriorCycle: false,
+                        }),
+                      ]),
+                      trace: Object.freeze({
+                        nextGlobalSlotOrdinal: 2,
+                        nextSequence: 2,
+                        slots: Object.freeze([
+                          Object.freeze({
+                            bindings: Object.freeze([
+                              Object.freeze({
+                                atMs: 2,
+                                cycleOrdinal: 1,
+                                historySequence: 1,
+                                state: 'completed' as const,
+                                token: 'gt1_1',
+                              }),
+                            ]),
+                            impressions: 1,
+                            slotId: 'takeover-slot',
+                          }),
+                        ]),
+                      }),
+                      mutationRevision: 0,
+                    }),
+                  Object.freeze({
+                    version: 1 as const,
+                    releaseId: RELEASE_ID,
+                    generation: 1,
+                    projectionDigest: 'b'.repeat(64),
+                    integrationConfigDigest: 'c'.repeat(64),
+                    slices,
+                    slotCount: 1,
+                    outcomeCount: 1,
+                    capabilities: Object.freeze([]),
+                    objectKinds: Object.freeze(['gpt_slot', 'dom_artifact']),
+                  }),
+                  candidate.boot
+                );
+                if (!handoff) throw new Error('should validate test handoff');
+                prepared.activate(
+                  Object.freeze({
+                    version: 1 as const,
+                    adoptInitialDisplay: true as const,
+                    handoff,
+                    identities: Object.freeze([publisherSlot, adoptedFrame]),
+                  })
+                );
+                prepared.commit();
+              },
+            }
+          : {}),
+      };
+      const result = await registry.install(installCallbacks);
+      if (adoptInitialDisplay && parserStateValid !== true) {
+        expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+        expect(setConfig).not.toHaveBeenCalled();
+        expect(defineSlot).not.toHaveBeenCalled();
+        expect(display).not.toHaveBeenCalled();
+        expect(refresh).not.toHaveBeenCalled();
+        vi.useRealTimers();
+        return;
+      }
+      expect(result.state).toBe('kernel');
+      expect(setConfig).toHaveBeenCalledTimes(
+        gamAttributionEnabled && !adoptInitialDisplay ? 1 : 0
+      );
+      if (gamAttributionEnabled && !adoptInitialDisplay) {
+        expect(setConfig).toHaveBeenCalledExactlyOnceWith({ targeting: { ts: 'true' } });
+      }
+      const gpt = providerFacades.get('gpt.v1') as {
+        activateLaterLifecycle: () => Readonly<{
+          navigate: (path: string) => Promise<unknown>;
+          release: () => void;
+        }>;
+        navigation: () => Readonly<{
+          generation: object;
+          currentAuctionProjection?: Readonly<{ auction?: Readonly<{ auctionId?: string }> }>;
+        }>;
+        slots: {
+          request: (input: Readonly<Record<string, unknown>>) => unknown;
+        };
+      };
+      if (adoptInitialDisplay) {
+        await Promise.resolve();
+        expect(defineSlot).not.toHaveBeenCalled();
+        expect(display).not.toHaveBeenCalled();
+        expect(refresh).not.toHaveBeenCalled();
+        expect(protect).not.toHaveBeenCalled();
+        if (result.state === 'kernel') result.dispose();
+        expect(providerFacades.size).toBe(0);
+        return;
+      }
+      await vi.waitFor(() => expect(definedSlots).toHaveLength(1));
+      const takeoverNavigation = gpt.navigation();
+      gpt.slots.request({
+        intentId: 'takeover-request',
+        navigationGeneration: takeoverNavigation.generation,
+        operation: 'display',
+        registeredSlotId: 'takeover-slot',
+        requestClass: 'initial',
+      });
+      await vi.waitFor(() => expect(display).toHaveBeenCalledOnce());
+      expect(protect).not.toHaveBeenCalled();
+      expect(activeMutationObservers.size).toBe(3);
+      const firstPhysicalSlot = definedSlots[0];
+      expect(firstPhysicalSlot).toBeDefined();
+      takeoverElement.remove();
+      const replacementElement = document.createElement('div');
+      replacementElement.id = 'takeover-slot';
+      document.body.appendChild(replacementElement);
+      await Promise.resolve();
+      await vi.advanceTimersByTimeAsync(250);
+      expect(destroySlots).toHaveBeenCalledOnce();
+      const destroyedPhysicalSlot = destroySlots.mock.calls[0]?.[0]?.[0];
+      expect(destroyedPhysicalSlot).toBeDefined();
+      expect(destroyedPhysicalSlot).not.toBe(publisherSlot);
+      expect(definedSlots).toHaveLength(1);
+      expect(definedSlots).not.toContain(destroyedPhysicalSlot);
+      expect(activeMutationObservers.size).toBe(3);
+      expect(vi.getTimerCount()).toBe(0);
+      vi.useRealTimers();
+      expect([...providerFacades.keys()]).toEqual([
+        'slots.v1',
+        'auction.v1',
+        'render.v1',
+        'messages.v1',
+        'trace.v1',
+        'trace.presentation.v1',
+        'direct.v1',
+        'gpt.v1',
+        'gpt.events.v1',
+        'pbs_cache.baseline.v1',
+      ]);
+      expect(Reflect.ownKeys(providerFacades.get('pbs_cache.baseline.v1') ?? {})).toEqual([]);
+      const render = providerFacades.get('render.v1') as {
+        attachPucGamAttemptRegistrar: (registrar: (input: unknown) => boolean) => () => void;
+      };
+      expect(() => render.attachPucGamAttemptRegistrar(() => true)).toThrow('duplicated');
+      expect(protect).not.toHaveBeenCalled();
+      expect([...listenerTypes].sort()).toEqual(
+        (diagnosticsActive
+          ? [
+              'slotRequested',
+              'slotRenderEnded',
+              'slotResponseReceived',
+              'slotOnload',
+              'impressionViewable',
+              'slotVisibilityChanged',
+            ]
+          : ['slotRequested', 'slotRenderEnded']
+        ).sort()
+      );
+      expect(listenerTypes.slice(0, 2)).toEqual(['slotRequested', 'slotRenderEnded']);
+
+      const placement = {
+        slot: 'spa-winner',
+        gamUnitPath: '/123/spa-winner',
+        divId: 'spa-winner',
+        formats: [[300, 250]],
+        targeting: {},
+      };
+      const bid = {
+        candidateId: 'BBBBBBBBBBBB',
+        slot: placement.slot,
+        provider: 'trusted',
+        upstreamBidId: 'spa-upstream',
+        cpm: 2,
+        currency: 'USD',
+        targeting: { hb_bidder: 'trusted' },
+        renderSource: {
+          type: 'pbs_cache',
+          version: 1,
+          cacheId: 'cache id/with reserved bytes',
+          cacheHost: 'cache.example:8443',
+          cachePath: '/pbc/v1/cache',
+          width: 300,
+          height: 250,
+        },
+      };
+      const pageBids = {
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: 'spa-production',
+          results: [{ slot: placement.slot, outcome: 'winner', candidateId: bid.candidateId }],
+        },
+        slots: [placement],
+        bids: [bid],
+      };
+      const slotElement = document.createElement('div');
+      slotElement.id = placement.divId;
+      document.body.appendChild(slotElement);
+      const fetchPageBids = vi
+        .spyOn(globalThis, 'fetch')
+        .mockResolvedValue({ ok: true, json: async () => pageBids } as Response);
+      const initialNavigation = gpt.navigation();
+      expect(refresh).not.toHaveBeenCalled();
+      const later = gpt.activateLaterLifecycle();
+      expect(Object.isFrozen(later)).toBe(true);
+      expect(activeMutationObservers.size).toBe(3);
+      expect(() => gpt.activateLaterLifecycle()).toThrow('unavailable');
+      const navigationResult = await later.navigate('/spa-production?route=one');
+      expect(navigationResult).toEqual({
+        status: 'committed',
+        navigationGeneration: expect.any(Object),
+        current: true,
+      });
+      expect(fetchPageBids).toHaveBeenCalledExactlyOnceWith(
+        '/_ts/page-bids?path=%2Fspa-production%3Froute%3Done',
+        expect.objectContaining({
+          credentials: 'include',
+          headers: { 'X-TSJS-Page-Bids': '1' },
+          signal: expect.any(AbortSignal),
+        })
+      );
+      expect(gpt.navigation()).not.toBe(initialNavigation);
+      expect(gpt.navigation()?.currentAuctionProjection?.auction?.auctionId).toBe('spa-production');
+      expect(refresh).toHaveBeenCalledExactlyOnceWith(
+        [publisherSlot],
+        Object.freeze({ changeCorrelator: false })
+      );
+      expect(publisherSlot.setTargeting).toHaveBeenCalledWith('hb_adid', bid.renderSource.cacheId);
+      expect(publisherSlot.setTargeting).toHaveBeenCalledWith(
+        'hb_cache_host',
+        bid.renderSource.cacheHost
+      );
+      expect(publisherSlot.setTargeting).toHaveBeenCalledWith(
+        'hb_cache_path',
+        bid.renderSource.cachePath
+      );
+
+      const sourceFrame = document.createElement('iframe');
+      slotElement.appendChild(sourceFrame);
+      const responsePort = Object.freeze({ postMessage: vi.fn() });
+      fetchPageBids.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: async () =>
+          JSON.stringify({
+            adm: '<main data-price="${AUCTION_PRICE}" data-b64="${AUCTION_PRICE:B64}">cached</main>',
+            w: 320,
+            h: 100,
+            price: 2.75,
+          }),
+      } as Response);
+      const requestEvent = new MessageEvent('message', {
+        data: JSON.stringify({ message: 'Prebid Request', adId: bid.renderSource.cacheId }),
+        ports: [responsePort as unknown as MessagePort],
+        source: sourceFrame.contentWindow,
+      });
+      const stopImmediatePropagation = vi.spyOn(requestEvent, 'stopImmediatePropagation');
+      window.dispatchEvent(requestEvent);
+      await vi.waitFor(() => expect(responsePort.postMessage).toHaveBeenCalledOnce());
+      expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+      expect(fetchPageBids).toHaveBeenNthCalledWith(
+        2,
+        'https://cache.example:8443/pbc/v1/cache?uuid=cache%20id%2Fwith%20reserved%20bytes',
+        { mode: 'cors' }
+      );
+      expect(JSON.parse(String(responsePort.postMessage.mock.calls[0]?.[0]))).toEqual({
+        message: 'Prebid Response',
+        adId: bid.renderSource.cacheId,
+        ad: '<main data-price="2.75" data-b64="${AUCTION_PRICE:B64}">cached</main>',
+        renderer: expect.any(String),
+        width: 320,
+        height: 100,
+      });
+
+      let resolveStaleResponse!: (response: Response) => void;
+      const concurrentPageBids = {
+        version: 1,
+        auction: {
+          version: 1,
+          auctionId: 'concurrent-current',
+          results: [],
+        },
+        slots: [],
+        bids: [],
+      };
+      fetchPageBids
+        .mockReturnValueOnce(
+          new Promise<Response>((resolve) => {
+            resolveStaleResponse = resolve;
+          })
+        )
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => concurrentPageBids,
+        } as Response);
+      const staleNavigation = later.navigate('/stale-generation');
+      await vi.waitFor(() => expect(fetchPageBids).toHaveBeenCalledTimes(3));
+      const currentNavigation = later.navigate('/current-generation');
+      await expect(currentNavigation).resolves.toEqual({
+        status: 'committed',
+        navigationGeneration: expect.any(Object),
+        current: true,
+      });
+      resolveStaleResponse({ ok: true, json: async () => pageBids } as Response);
+      const staleResult = await staleNavigation;
+      expect(staleResult).toEqual({
+        status: 'rejected',
+        navigationGeneration: expect.any(Object),
+        current: false,
+      });
+      expect((staleResult as { navigationGeneration: object }).navigationGeneration).not.toBe(
+        ((await currentNavigation) as { navigationGeneration: object }).navigationGeneration
+      );
+      later.release();
+      expect(activeMutationObservers.size).toBe(2);
+      await later.navigate('/disposed-owner');
+      expect(fetchPageBids).toHaveBeenCalledTimes(4);
+      fetchPageBids.mockRestore();
+      sourceFrame.remove();
+      slotElement.remove();
+
+      expect(setConfig.mock.calls).toEqual(
+        gamAttributionEnabled ? [[{ targeting: { ts: 'true' } }]] : []
+      );
+
+      if (result.state === 'kernel') result.dispose();
+      expect(activeMutationObservers.size).toBe(0);
+      expect(removedTypes.sort()).toEqual([...listenerTypes].sort());
+      expect(providerFacades.size).toBe(0);
+      expect(() => render.attachPucGamAttemptRegistrar(() => true)).toThrow('unavailable');
+    }
+  );
+
+  it('protects the complete immutable initial winner batch before starting either GPT request', async () => {
+    const candidateIds = ['candidate001', 'candidate002'] as const;
+    const projection = Object.freeze({
+      version: 1 as const,
+      auction: Object.freeze({
+        version: 1 as const,
+        auctionId: 'initial-winners',
+        results: Object.freeze(
+          candidateIds.map((candidateId, index) =>
+            Object.freeze({
+              slot: `slot-${index + 1}`,
+              outcome: 'winner' as const,
+              candidateId,
+            })
+          )
+        ),
+      }),
+      slots: Object.freeze(
+        candidateIds.map((_candidateId, index) =>
+          Object.freeze({
+            slot: `slot-${index + 1}`,
+            gamUnitPath: `/123/slot-${index + 1}`,
+            divId: `slot-${index + 1}`,
+            formats: Object.freeze([Object.freeze([300, 250] as const)]),
+            targeting: Object.freeze({}),
+          })
+        )
+      ),
+      bids: Object.freeze(
+        candidateIds.map((candidateId, index) =>
+          Object.freeze({
+            candidateId,
+            slot: `slot-${index + 1}`,
+            provider: 'fictional',
+            upstreamBidId: `upstream-${index + 1}`,
+            cpm: index + 1,
+            currency: 'USD' as const,
+            targeting: Object.freeze({}),
+            rendererReservationId: `r1_${String(index + 1).repeat(22)}`,
+            renderSource: Object.freeze({
+              type: 'adm' as const,
+              version: 1 as const,
+              adm: `<p>${index + 1}</p>`,
+              width: 300,
+              height: 250,
+            }),
+          })
+        )
+      ),
+    });
+    for (const placement of projection.slots) {
+      const element = document.createElement('div');
+      element.id = placement.divId;
+      document.body.appendChild(element);
+    }
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(7);
+            return target;
+          },
+        }),
+    });
+    const navigationResult = runtime.startInitialNavigation(projection);
+    if (!navigationResult.ok) throw new Error(navigationResult.reason);
+    const navigation = navigationResult.value;
+    const artifacts = createCommittedArtifactStore();
+    const reservations = createReservationService({
+      prepareRenderSource: (candidate) =>
+        typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+          ? (candidate as never)
+          : undefined,
+    });
+    const physical = new Map<string, object>();
+    const requestHandle = () =>
+      Object.freeze({
+        status: 'active' as const,
+        result: Promise.resolve(
+          Object.freeze({ status: 'failed' as const, reason: 'gpt_request_failed' as const })
+        ),
+        dispose: vi.fn(),
+      });
+    const request = vi.fn(requestHandle);
+    const requestBatch = vi.fn((inputs: readonly unknown[]) =>
+      Object.freeze(inputs.map(() => requestHandle()))
+    );
+    const slots = Object.freeze({
+      adoptGptSlot: (
+        _generation: object,
+        registeredSlotId: string,
+        binding: Readonly<{ slot: object }>
+      ) => {
+        physical.set(registeredSlotId, binding.slot);
+        return Object.freeze({ ok: true as const });
+      },
+      isBoundGptSlot: (_generation: object, registeredSlotId: string, slot: object) =>
+        physical.get(registeredSlotId) === slot,
+      recordPublisherDestruction: vi.fn(() => true),
+      request,
+      requestBatch,
+    });
+    const targeting = Object.freeze({
+      observePublisherMutations: () =>
+        Object.freeze({ status: 'completed', result: Promise.resolve(), dispose: vi.fn() }),
+      own: (_slot: object, _key: string, _value: string, ownerId: string) =>
+        Object.freeze({ ownerId, release: vi.fn() }),
+    });
+    const facade = Object.freeze({
+      slots: () => Object.freeze([]),
+      slotElementId: () => undefined,
+      transactionalDefine: (
+        definition: Readonly<{ elementId: string }>,
+        _current: () => boolean,
+        prepare: (slot: object) => Readonly<{ commit: () => boolean }>
+      ) => {
+        const slot = Object.freeze({ elementId: definition.elementId });
+        if (!prepare(slot).commit()) return Object.freeze({ status: 'failed' as const });
+        return Object.freeze({ status: 'defined' as const, slot });
+      },
+      clearTargeting: vi.fn(),
+      getTargeting: vi.fn(() => Object.freeze([])),
+      setTargeting: vi.fn(),
+    });
+    const googletag = Object.freeze({
+      run: (command: (gpt: typeof facade) => unknown) =>
+        Object.freeze({
+          status: 'completed',
+          result: Promise.resolve(command(facade)),
+          dispose: vi.fn(),
+        }),
+    });
+    let protectedLatches: readonly PromiseLike<unknown>[] | undefined;
+    const protect = vi.fn((latches: readonly PromiseLike<unknown>[]) => {
+      expect(Object.isFrozen(latches)).toBe(true);
+      expect(latches).toHaveLength(2);
+      expect(request).not.toHaveBeenCalled();
+      expect(requestBatch).not.toHaveBeenCalled();
+      protectedLatches = latches;
+      return true;
+    });
+
+    await publishInitialGptProjection(document, {
+      googletag: googletag as never,
+      navigation,
+      projection: projection as never,
+      protect,
+      pucBridge: Object.freeze({
+        registerGamAttempt: vi.fn(() => true),
+        recordNonemptyGam: vi.fn(() => true),
+      }),
+      render: Object.freeze({
+        artifacts,
+        createAttempt: (owner: Parameters<typeof createRenderAttempt>[0]['owner']) =>
+          createRenderAttempt({
+            artifacts,
+            owner,
+            prepareRenderSource: (candidate) => candidate as never,
+            reservations,
+          }),
+        createSlotOperation,
+        publisherOrigin: window.location.origin,
+        registerRenderer: vi.fn(),
+        rendererNonces: Object.freeze({}),
+        renderWinner: vi.fn(() => false),
+        reservations,
+      }) as never,
+      slots: slots as never,
+      targeting: targeting as never,
+    });
+
+    expect(protect).toHaveBeenCalledOnce();
+    expect(request).not.toHaveBeenCalled();
+    expect(requestBatch).toHaveBeenCalledOnce();
+    const requestInputs = requestBatch.mock.calls[0]?.[0] as readonly Readonly<{
+      operation: string;
+      registeredSlotId: string;
+    }>[];
+    expect(Object.isFrozen(requestInputs)).toBe(true);
+    expect(
+      requestInputs.map(({ operation, registeredSlotId }) => [registeredSlotId, operation])
+    ).toEqual([
+      ['slot-1', 'display'],
+      ['slot-2', 'display'],
+    ]);
+    await Promise.allSettled([...(protectedLatches ?? [])]);
+    artifacts.dispose();
+    reservations.dispose();
+    runtime.dispose();
+  });
+
+  it('prepares inertly, activates the reversible guard, and starts only after commit', async () => {
+    const config = Object.freeze({ scriptUrl: '/integrations/gpt/script' });
+    const order: string[] = [];
+    const start = vi.fn((received: unknown) => {
+      order.push('start');
+      expect(received).toBe(config);
+    });
+    const release = vi.fn(() => order.push('release'));
+    const activate = vi.fn(() => {
+      order.push('gpt:activate');
+      return release;
+    });
+    let finishPreparation: (() => void) | undefined;
+    const preparationGate = new Promise<void>((resolve) => {
+      finishPreparation = resolve;
+    });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'gate']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt', 'gate']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({ gpt: Object.freeze({ activate, start }) }),
+      }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+    registry.register(
+      registration('gate', async () => {
+        order.push('gate:prepare');
+        await preparationGate;
+        return Object.freeze({ activate: () => order.push('gate:activate') });
+      })
+    );
+    const originalDocumentWrite = document.write;
+
+    const installing = registry.install(callbacks(order));
+    await vi.waitFor(() => expect(order).toEqual(['gate:prepare']));
+
+    expect(isGuardInstalled()).toBe(false);
+    expect(document.write).toBe(originalDocumentWrite);
+    expect(start).not.toHaveBeenCalled();
+
+    finishPreparation?.();
+    const result = await installing;
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(isGuardInstalled()).toBe(true);
+    expect(document.write).not.toBe(originalDocumentWrite);
+    expect(order).toEqual([
+      'gate:prepare',
+      'core',
+      'gpt:activate',
+      'gate:activate',
+      'publish',
+      'start',
+      'drain',
+    ]);
+    expect(activate).toHaveBeenCalledTimes(1);
+    expect(start).toHaveBeenCalledExactlyOnceWith(config);
+
+    if (result.state === 'kernel') {
+      result.dispose();
+      result.dispose();
+    }
+    expect(isGuardInstalled()).toBe(false);
+    expect(document.write).toBe(originalDocumentWrite);
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  it('unwinds the GPT guard before fallback when a later activation fails', async () => {
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'broken']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt', 'broken']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: GPT_CONFIG,
+        interfaces: Object.freeze({
+          gpt: Object.freeze({ activate: () => vi.fn(), start }),
+        }),
+      }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+    registry.register(
+      registration('broken', () => ({
+        activate: () => {
+          expect(isGuardInstalled()).toBe(true);
+          throw new Error('fictional activation failure');
+        },
+      }))
+    );
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+
+    expect(isGuardInstalled()).toBe(false);
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('never installs the guard or starts when reversible GPT activation fails', async () => {
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: GPT_CONFIG,
+        interfaces: Object.freeze({
+          gpt: Object.freeze({
+            activate: () => {
+              expect(isGuardInstalled()).toBe(false);
+              throw new Error('fictional observer activation failure');
+            },
+            start,
+          }),
+        }),
+      }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(isGuardInstalled()).toBe(false);
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('fails preparation without effects when the composition omits the GPT boundary', async () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({ config: GPT_CONFIG, interfaces: Object.freeze({}) }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+
+    expect(isGuardInstalled()).toBe(false);
+  });
+
+  it.each([
+    [
+      'accessor',
+      Object.freeze(
+        Object.defineProperty({}, 'scriptUrl', {
+          enumerable: true,
+          get: () => '/publisher-controlled',
+        })
+      ),
+    ],
+    ['mutable nested data', Object.freeze({ nested: {} })],
+    ['non-plain data', Object.freeze({ value: Object.freeze(new Date(0)) })],
+  ])('rejects %s configuration during inert preparation', async (_caseName, config) => {
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({
+          gpt: Object.freeze({ activate: () => vi.fn(), start }),
+        }),
+      }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(start).not.toHaveBeenCalled();
+    expect(isGuardInstalled()).toBe(false);
+  });
+
+  it('isolates post-commit startup failure and disposes only the GPT module', async () => {
+    const start = vi.fn(() => {
+      throw new Error('fictional GPT startup failure');
+    });
+    const runtimeFailures: unknown[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      startedAtMs: 0,
+      now: () => 0,
+      onRuntimeFailure: (failure) => runtimeFailures.push(failure),
+      getBindings: () => ({
+        config: GPT_CONFIG,
+        interfaces: Object.freeze({
+          gpt: Object.freeze({ activate: () => vi.fn(), start }),
+        }),
+      }),
+    });
+    registry.register(createGptIntegrationRegistration(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'kernel',
+      runtimeFailures: [{ id: 'gpt', phase: 'after_commit' }],
+    });
+
+    expect(start).toHaveBeenCalledTimes(1);
+    expect(runtimeFailures).toEqual([{ id: 'gpt', phase: 'after_commit' }]);
+    expect(isGuardInstalled()).toBe(false);
+  });
+
+  it('starts fallback only after an attributable TS-owned empty cycle settles the primary', async () => {
+    const harness = createAttemptHarness();
+    const slot = deferredSlotOutcome();
+    const order: string[] = [];
+    let fallback: RenderAttempt | undefined;
+    const bridgeInput: unknown[] = [];
+    const bridge = {
+      registerGamAttempt: vi.fn((input: GptSlotOperationInput) => {
+        bridgeInput.push(input);
+        return input.attempt.beginGamClaim();
+      }),
+      recordNonemptyGam: vi.fn(() => true),
+    };
+    const invokeCreateSlotOperation = vi.fn(createSlotOperation);
+    const started = startGptSlotOperation({
+      artifact: harness.artifact,
+      attempt: harness.primary,
+      createSlotOperation: invokeCreateSlotOperation,
+      createFallback: (parentAttemptId) => {
+        expect(harness.primary.snapshot().outcome).toEqual({
+          outcome: 'failed',
+          reason: 'gam_empty',
+        });
+        order.push('fallback:create');
+        fallback = harness.createAttempt(parentAttemptId);
+        return Object.freeze({ ok: true as const, value: fallback });
+      },
+      operation: 'refresh',
+      owner: harness.primaryOwner,
+      pucBridge: bridge,
+      requestClass: 'primary',
+      reservationId: RESERVATION_ID,
+      slots: { request: slot.request },
+    });
+
+    expect(started.ok).toBe(true);
+    expect(invokeCreateSlotOperation).toHaveBeenCalledExactlyOnceWith({
+      primary: harness.primary,
+      createFallback: expect.any(Function),
+    });
+    expect(bridge.registerGamAttempt).toHaveBeenCalledTimes(1);
+    expect(slot.request).toHaveBeenCalledWith({
+      intentId: harness.primary.id,
+      navigationGeneration: harness.primary.navigationGeneration,
+      operation: 'refresh',
+      registeredSlotId: harness.primary.slot,
+      requestClass: 'primary',
+    });
+
+    slot.resolve(Object.freeze({ status: 'empty', responseIdentifier: 'response-one' }));
+    await Promise.resolve();
+
+    expect(order).toEqual(['fallback:create']);
+    expect(harness.primary.snapshot()).toMatchObject({
+      state: 'failed',
+      outcome: { outcome: 'failed', reason: 'gam_empty' },
+    });
+    expect(started.ok && started.value.snapshot()).toEqual({ settled: false });
+    expect(slot.dispose).toHaveBeenCalledTimes(1);
+    expect(bridge.recordNonemptyGam).not.toHaveBeenCalled();
+
+    expect(fallback?.fail('gpt_request_failed')).toBe(true);
+    expect(started.ok && started.value.snapshot()).toMatchObject({
+      settled: true,
+      result: {
+        path: 'fallback',
+        primaryAttemptId: harness.primary.id,
+        primary: { outcome: 'failed', reason: 'gam_empty' },
+        fallbackAttemptId: fallback?.id,
+        fallback: { outcome: 'failed', reason: 'gpt_request_failed' },
+      },
+    });
+    expect(harness.primary.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'gam_empty',
+    });
+    harness.runtime.dispose();
+  });
+
+  it('joins an attributable nonempty cycle to the PUC bridge without settling the operation', async () => {
+    const harness = createAttemptHarness();
+    const slot = deferredSlotOutcome();
+    const registered: unknown[] = [];
+    const nonempty: unknown[] = [];
+    const bridge = {
+      registerGamAttempt: vi.fn((input: GptSlotOperationInput) => {
+        registered.push(input);
+        return input.attempt.beginGamClaim();
+      }),
+      recordNonemptyGam: vi.fn((input: unknown) => {
+        nonempty.push(input);
+        return true;
+      }),
+    };
+    const input = {
+      artifact: harness.artifact,
+      attempt: harness.primary,
+      createSlotOperation,
+      operation: 'display' as const,
+      owner: harness.primaryOwner,
+      pucBridge: bridge,
+      requestClass: 'primary',
+      reservationId: RESERVATION_ID,
+      slots: { request: slot.request },
+    };
+    const started = startGptSlotOperation(input);
+    slot.resolve(Object.freeze({ status: 'rendered', responseIdentifier: 'response-one' }));
+    await Promise.resolve();
+
+    expect(nonempty).toEqual(registered);
+    expect(started.ok && started.value.snapshot()).toEqual({ settled: false });
+    expect(harness.primary.snapshot().state).toBe('waiting_for_gam_and_claim');
+    expect(slot.dispose).not.toHaveBeenCalled();
+
+    harness.primary.cancel('superseded');
+    expect(slot.dispose).toHaveBeenCalledTimes(1);
+    harness.runtime.dispose();
+  });
+
+  it.each([
+    [{ status: 'failed', reason: 'cycle_unattributable' }, 'cycle_unattributable'],
+    [{ status: 'failed', reason: 'slot_quarantined' }, 'slot_quarantined'],
+    [{ status: 'failed', reason: 'gpt_request_timeout' }, 'gpt_request_timeout'],
+    [{ status: 'failed', reason: 'gpt_completion_timeout' }, 'gpt_completion_timeout'],
+    [{ status: 'failed', reason: 'external_queue_full' }, 'external_queue_full'],
+    [{ status: 'failed', reason: 'external_ready_timeout' }, 'external_ready_timeout'],
+    [{ status: 'cancelled', reason: 'navigation_disposed' }, 'navigation_disposed'],
+  ] as const)(
+    'does not start fallback for non-empty terminal cycle outcome %s',
+    async (slotOutcome, reason) => {
+      const harness = createAttemptHarness();
+      const slot = deferredSlotOutcome();
+      const createFallback = vi.fn();
+      const started = startGptSlotOperation({
+        artifact: harness.artifact,
+        attempt: harness.primary,
+        createSlotOperation,
+        createFallback,
+        operation: 'refresh',
+        owner: harness.primaryOwner,
+        pucBridge: {
+          registerGamAttempt: (input) => input.attempt.beginGamClaim(),
+          recordNonemptyGam: () => true,
+        },
+        requestClass: 'primary',
+        reservationId: RESERVATION_ID,
+        slots: { request: slot.request },
+      });
+      slot.resolve(Object.freeze(slotOutcome) as SlotRequestOutcome);
+      await Promise.resolve();
+
+      expect(createFallback).not.toHaveBeenCalled();
+      expect(started.ok && started.value.snapshot()).toMatchObject({
+        settled: true,
+        result: {
+          path: 'primary',
+          outcome: { reason },
+        },
+      });
+      harness.runtime.dispose();
+    }
+  );
+});
+
+describe('ordered GPT winner publication', () => {
+  function preparePublication() {
+    const harness = createAttemptHarness();
+    const source = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<main>trusted</main>',
+      width: 300,
+      height: 250,
+    });
+    const bid = Object.freeze({
+      candidateId: 'AAAAAAAAAAAA',
+      slot: harness.primary.slot,
+      provider: 'trusted',
+      upstreamBidId: 'upstream-one',
+      cpm: 1.25,
+      currency: 'USD' as const,
+      targeting: Object.freeze({ hb_bidder: 'trusted' }),
+      rendererReservationId: RESERVATION_ID,
+      renderSource: source,
+    });
+    const placement = Object.freeze({
+      slot: bid.slot,
+      gamUnitPath: '/123/gpt-slot',
+      divId: 'gpt-slot',
+      formats: Object.freeze([Object.freeze([300, 250] as const)]),
+      targeting: Object.freeze({ hb_bidder: 'publisher', pos: 'top' }),
+    });
+    const projection = Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'gpt-publication',
+        results: Object.freeze([
+          Object.freeze({
+            slot: bid.slot,
+            outcome: 'winner' as const,
+            candidateId: bid.candidateId,
+          }),
+        ]),
+      }),
+      slots: Object.freeze([placement]),
+      bids: Object.freeze([bid]),
+    });
+    expect(harness.navigation.installAuctionProjection(projection)).toBe(true);
+
+    const order: string[] = [];
+    const values = new Map<string, readonly string[]>();
+    const slot = Object.freeze({
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      }),
+      getTargeting: vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])])),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        order.push(`target:${key}`);
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      }),
+    });
+    const facade: GoogletagFacade = Object.freeze({
+      bindingToken: () => Object.freeze({}),
+      clearTargeting: (target: object, key?: string) => (target as typeof slot).clearTargeting(key),
+      enableServices: () => undefined,
+      transactionalDefine: () => Object.freeze({ status: 'discarded' as const }),
+      display: vi.fn(),
+      getTargeting: (target: object, key: string) => (target as typeof slot).getTargeting(key),
+      observeTargeting: () => {
+        order.push('observe');
+        return Object.assign(vi.fn(), { isCurrent: () => true });
+      },
+      refresh: vi.fn(),
+      serviceState: () =>
+        Object.freeze({ apiReady: true, initialLoadDisabled: false, pubadsReady: true }),
+      setTargeting: (target: object, key: string, value: string | readonly string[]) =>
+        (target as typeof slot).setTargeting(key, value),
+      slotElementId: () => undefined,
+      slots: () => Object.freeze([slot]),
+      subscribe: () => vi.fn(),
+      transactionalReplace: () => Object.freeze({ status: 'destroyed' as const }),
+    });
+    const googletag = Object.freeze({
+      ...createNoopGoogletagAdapter(),
+      bindingStatus: () => 'present' as const,
+      run: <Value>(command: (gpt: Readonly<GoogletagFacade>) => Value) => {
+        let result: Promise<Value>;
+        try {
+          result = Promise.resolve(command(facade));
+        } catch (error) {
+          result = Promise.reject(error);
+        }
+        return Object.freeze({ status: 'present' as const, result, dispose: vi.fn() });
+      },
+    });
+    const targeting = createTargetingService();
+    const slotOutcome = deferredSlotOutcome();
+    const slots = {
+      isBoundGptSlot: vi.fn(() => {
+        order.push('slot:validate');
+        return true;
+      }),
+      request: vi.fn((input: unknown) => {
+        order.push('request');
+        expect(input).toMatchObject({
+          registeredSlotId: bid.slot,
+          trustedServerOpportunity: {
+            requestedSlotSizes: [[300, 250]],
+            trustedServerAuctionId: 'gpt-publication',
+          },
+        });
+        const opportunity = (input as { trustedServerOpportunity: object })
+          .trustedServerOpportunity;
+        expect(Object.isFrozen(opportunity)).toBe(true);
+        expect(Object.isFrozen(Reflect.get(opportunity, 'requestedSlotSizes'))).toBe(true);
+        expect(harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+          recognized: true,
+          state: 'renderable',
+        });
+        return slotOutcome.request();
+      }),
+    };
+    let bridgeArtifact: CommittedRenderArtifact | undefined;
+    const pucBridge = {
+      registerGamAttempt: vi.fn((input: GptSlotOperationInput) => {
+        order.push('bridge');
+        bridgeArtifact = input.artifact;
+        return input.attempt.beginGamClaim();
+      }),
+      recordNonemptyGam: vi.fn(() => true),
+    };
+    const reservations = {
+      registerRender: vi.fn((input: Parameters<typeof harness.reservations.registerRender>[0]) => {
+        order.push('reservation');
+        return harness.reservations.registerRender(input);
+      }),
+      tombstone: harness.reservations.tombstone,
+    };
+    const input: GptWinnerPublicationInput = {
+      artifact: harness.artifact,
+      attempt: harness.primary,
+      bid,
+      createSlotOperation,
+      googletag,
+      navigation: harness.navigation,
+      operation: 'refresh',
+      owner: harness.primaryOwner,
+      placement,
+      pucBridge,
+      requestClass: 'primary',
+      reservations,
+      slot,
+      slots,
+      targeting,
+    };
+    return {
+      bid,
+      bridgeArtifact: () => bridgeArtifact,
+      harness,
+      input,
+      order,
+      pucBridge,
+      reservations,
+      slot,
+      slots,
+      targeting,
+      values,
+    };
+  }
+
+  it('publishes reservation, targeting, intent, and request in that exact order', async () => {
+    const publication = preparePublication();
+
+    const result = await publishGptWinner(publication.input);
+
+    expect(result.ok).toBe(true);
+    expect(publication.order).toEqual([
+      'slot:validate',
+      'reservation',
+      'observe',
+      'slot:validate',
+      'target:hb_adid',
+      'target:hb_bidder',
+      'target:pos',
+      'slot:validate',
+      'bridge',
+      'request',
+    ]);
+    expect(publication.values).toEqual(
+      new Map([
+        ['hb_adid', [RESERVATION_ID]],
+        ['hb_bidder', ['trusted']],
+        ['pos', ['top']],
+      ])
+    );
+    publication.bridgeArtifact()?.dispose();
+    expect(publication.values.size).toBe(0);
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(publication.harness.artifact.dispose).toHaveBeenCalledTimes(1);
+    publication.harness.runtime.dispose();
+  });
+
+  it('fails before targeting when exact slot ownership is lost across observation', async () => {
+    const publication = preparePublication();
+    publication.slots.isBoundGptSlot
+      .mockImplementationOnce(() => {
+        publication.order.push('slot:validate');
+        return true;
+      })
+      .mockImplementation(() => {
+        publication.order.push('slot:validate');
+        return false;
+      });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'slot_unresolved',
+    });
+    expect(publication.order).toEqual(['slot:validate', 'reservation', 'observe', 'slot:validate']);
+    expect(publication.values.size).toBe(0);
+    expect(publication.slots.request).not.toHaveBeenCalled();
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(publication.harness.artifact.dispose).toHaveBeenCalledTimes(1);
+    publication.harness.runtime.dispose();
+  });
+
+  it('compare-restores targeting when exact slot ownership is lost during writes', async () => {
+    const publication = preparePublication();
+    publication.slots.isBoundGptSlot
+      .mockImplementationOnce(() => {
+        publication.order.push('slot:validate');
+        return true;
+      })
+      .mockImplementationOnce(() => {
+        publication.order.push('slot:validate');
+        return true;
+      })
+      .mockImplementation(() => {
+        publication.order.push('slot:validate');
+        return false;
+      });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'slot_unresolved',
+    });
+    expect(publication.order).toEqual([
+      'slot:validate',
+      'reservation',
+      'observe',
+      'slot:validate',
+      'target:hb_adid',
+      'target:hb_bidder',
+      'target:pos',
+      'slot:validate',
+    ]);
+    expect(publication.values.size).toBe(0);
+    expect(publication.slots.request).not.toHaveBeenCalled();
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    publication.harness.runtime.dispose();
+  });
+
+  it('rolls back targeting and tombstones when the bridge refuses before request', async () => {
+    const publication = preparePublication();
+    publication.pucBridge.registerGamAttempt.mockImplementation(() => {
+      publication.order.push('bridge');
+      return false;
+    });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'gpt_request_failed',
+    });
+    expect(publication.slots.request).not.toHaveBeenCalled();
+    expect(publication.values.size).toBe(0);
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(publication.harness.artifact.dispose).toHaveBeenCalledTimes(1);
+    publication.harness.runtime.dispose();
+  });
+
+  it('rolls back targeting and tombstones when the slot request throws', async () => {
+    const publication = preparePublication();
+    publication.slots.request.mockImplementation(() => {
+      publication.order.push('request');
+      throw new Error('fictional request failure');
+    });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'gpt_request_failed',
+    });
+    expect(publication.order).toEqual([
+      'slot:validate',
+      'reservation',
+      'observe',
+      'slot:validate',
+      'target:hb_adid',
+      'target:hb_bidder',
+      'target:pos',
+      'slot:validate',
+      'bridge',
+      'request',
+    ]);
+    expect(publication.values.size).toBe(0);
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(publication.harness.artifact.dispose).toHaveBeenCalledTimes(1);
+    publication.harness.runtime.dispose();
+  });
+
+  it('fails before exposure when reservation insertion collides', async () => {
+    const publication = preparePublication();
+    expect(
+      publication.harness.reservations.registerRender({
+        reservationId: RESERVATION_ID,
+        slot: publication.bid.slot,
+        navigation: publication.harness.navigation,
+        attemptId: publication.harness.primary.id,
+        renderSource: publication.bid.renderSource,
+        winnerContext: Object.freeze({ selectedCpm: publication.bid.cpm }),
+      })
+    ).toMatchObject({ ok: true });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'reservation_collision',
+    });
+    expect(publication.order).toEqual(['slot:validate', 'reservation']);
+    expect(publication.values.size).toBe(0);
+    expect(publication.pucBridge.registerGamAttempt).not.toHaveBeenCalled();
+    expect(publication.harness.artifact.dispose).toHaveBeenCalledTimes(1);
+    publication.harness.runtime.dispose();
+  });
+
+  it('compare-restores earlier targeting when a later targeting write throws', async () => {
+    const publication = preparePublication();
+    publication.slot.setTargeting.mockImplementation((key, value) => {
+      publication.order.push(`target:${key}`);
+      if (key === 'hb_bidder') throw new Error('fictional targeting failure');
+      publication.values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+    });
+
+    await expect(publishGptWinner(publication.input)).resolves.toEqual({
+      ok: false,
+      reason: 'gpt_request_failed',
+    });
+    expect(publication.values.size).toBe(0);
+    expect(publication.slots.request).not.toHaveBeenCalled();
+    expect(publication.harness.reservations.recognize(RESERVATION_ID)).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    publication.harness.runtime.dispose();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/schedule_initial_ad_init.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/schedule_initial_ad_init.test.ts
deleted file mode 100644
index 727300aa1..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/schedule_initial_ad_init.test.ts
+++ /dev/null
@@ -1,550 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import type { TsjsApi } from '../../../src/core/types';
-
-type TestWindow = Window & {
-  googletag?: unknown;
-  tsjs?: TsjsApi;
-};
-
-const originalPushState = history.pushState.bind(history);
-const originalReplaceState = history.replaceState.bind(history);
-const BOOTSTRAP_SOURCE = readFileSync(
-  path.resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-  'utf8'
-);
-
-function runBootstrap(): void {
-  new Function(BOOTSTRAP_SOURCE)();
-}
-
-/**
- * Executable lifecycle coverage for `tsjs.scheduleInitialAdInit` — the
- * deferred initial-adInit bootstrap the server's `</body>` bids script hands
- * off to. These tests run the real scheduler (and, where noted, the real
- * `adInit()` and SPA auction hook) instead of string-matching the emitted
- * script, so post-load ordering, two-frame deferral, exactly-once invocation,
- * and stale-navigation cancellation are all exercised, not just spelled.
- */
-describe('scheduleInitialAdInit', () => {
-  let rafQueue: FrameRequestCallback[];
-  let readyState: DocumentReadyState;
-  let fetchStub: ReturnType<typeof vi.fn>;
-  let popstateHandlers: EventListenerOrEventListenerObject[] = [];
-  const realAddEventListener = window.addEventListener.bind(window);
-
-  /** Run every queued animation-frame callback (one frame's worth). */
-  function flushFrame(): void {
-    const queued = [...rafQueue];
-    rafQueue.length = 0;
-    queued.forEach((cb) => cb(0));
-  }
-
-  /** Flush the microtask/timer queue so the SPA hook's awaits settle. */
-  async function flushAsync(): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-
-  async function importGptModule() {
-    return import('../../../src/integrations/gpt/index');
-  }
-
-  beforeEach(() => {
-    vi.resetModules();
-    delete (window as TestWindow).tsjs;
-    delete (window as TestWindow).googletag;
-    // Restore unwrapped history methods so each module import wraps exactly
-    // once — without this, wrappers from prior imports accumulate.
-    history.pushState = originalPushState;
-    history.replaceState = originalReplaceState;
-    fetchStub = vi.fn();
-    vi.stubGlobal('fetch', fetchStub);
-    popstateHandlers = [];
-    vi.spyOn(window, 'addEventListener').mockImplementation((type, listener, options) => {
-      if (type === 'popstate' && listener) popstateHandlers.push(listener);
-      return realAddEventListener(type, listener, options);
-    });
-    // Manual animation-frame queue: the scheduler must be observed frame by
-    // frame, so frames only run when a test flushes them explicitly.
-    rafQueue = [];
-    (
-      window as { requestAnimationFrame: typeof window.requestAnimationFrame }
-    ).requestAnimationFrame = ((cb: FrameRequestCallback) => {
-      rafQueue.push(cb);
-      return rafQueue.length;
-    }) as typeof window.requestAnimationFrame;
-    // Controllable document.readyState (jsdom reports 'complete' by default;
-    // the scheduler branches on it).
-    readyState = 'loading';
-    Object.defineProperty(document, 'readyState', {
-      configurable: true,
-      get: () => readyState,
-    });
-  });
-
-  afterEach(() => {
-    history.pushState = originalPushState;
-    history.replaceState = originalReplaceState;
-    // Reset jsdom location back to root for the next test.
-    originalReplaceState({}, '', '/');
-    document.body.innerHTML = '';
-    popstateHandlers.forEach((handler) => window.removeEventListener('popstate', handler));
-    popstateHandlers = [];
-    // Remove the instance properties so the prototype getters are visible again.
-    delete (document as unknown as Record<string, unknown>).readyState;
-    delete (document as unknown as Record<string, unknown>).hidden;
-    delete (window as unknown as Record<string, unknown>).requestAnimationFrame;
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it('applies the SSR payload and defers adInit until window load plus two animation frames', async () => {
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ atf: { hb_pb: '1.00' } });
-    // On the initial document (generation 0) the SSR bids are adopted
-    // immediately — the deferral applies to the GPT work, not the payload.
-    expect(ts.bids).toEqual({ atf: { hb_pb: '1.00' } });
-    expect(adInit).not.toHaveBeenCalled();
-
-    // load alone must not run it — React commits after the load-time frame.
-    window.dispatchEvent(new Event('load'));
-    expect(adInit).not.toHaveBeenCalled();
-
-    // One frame is not enough: the double rAF exists so the call lands after
-    // React's post-hydration commit, not inside the load-event frame.
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('runs after two frames without a load event when the document is already complete', async () => {
-    readyState = 'complete';
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!();
-    // Still never synchronous — even past load, adInit waits two frames.
-    expect(adInit).not.toHaveBeenCalled();
-
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('invokes adInit exactly once even across duplicate load events and extra frames', async () => {
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!();
-    window.dispatchEvent(new Event('load'));
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    flushFrame();
-
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('accepts only the first schedule call', async () => {
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ first: { hb_pb: '1.00' } });
-    ts.scheduleInitialAdInit!({ second: { hb_pb: '2.00' } });
-    expect(ts.bids).toEqual({ first: { hb_pb: '1.00' } });
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('keeps the first schedule claim across bootstrap-to-bundle handoff', async () => {
-    runBootstrap();
-    const ts = (window as TestWindow).tsjs!;
-    const firstSlot = {
-      id: 'first_slot',
-      gam_unit_path: '/123/first',
-      div_id: 'div-first',
-      formats: [[300, 250]] as Array<[number, number]>,
-    };
-    const secondSlot = {
-      id: 'second_slot',
-      gam_unit_path: '/123/second',
-      div_id: 'div-second',
-      formats: [[728, 90]] as Array<[number, number]>,
-    };
-
-    ts.scheduleInitialAdInit!({ first_slot: { hb_pb: '1.00' } }, [firstSlot]);
-    await importGptModule();
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-    ts.scheduleInitialAdInit!({ second_slot: { hb_pb: '2.00' } }, [secondSlot]);
-
-    expect(ts.bids).toEqual({ first_slot: { hb_pb: '1.00' } });
-    expect(ts.adSlots).toEqual([firstSlot]);
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('still runs after a query-only history change before load', async () => {
-    // The SPA auction hook identifies routes by pathname only, so a query-only
-    // replaceState is not a navigation: it must neither trigger an auction nor
-    // cancel the pending initial adInit. (A URL-equality guard would abort
-    // here and leave the initial ads uninitialized.)
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!();
-    history.replaceState({}, '', '/?utm_source=newsletter');
-    await flushAsync();
-    expect(fetchStub).not.toHaveBeenCalled();
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('cancels the initial run after an /a → /b → /a round trip before load', async () => {
-    // Both navigations commit and return to the original URL, so a URL
-    // comparison would see "unchanged" and run adInit a second time against
-    // the round-tripped route's live state. The navigation generation counts
-    // both commits and stands the initial callback down.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!();
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    history.pushState({}, '', '/');
-    await flushAsync();
-    expect(ts.navGeneration).toBe(2);
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('applies server targeting to a publisher-displayed slot before its refresh', async () => {
-    // A publisher that defined and displayed its GPT slot before window load
-    // still gets the server-side targeting applied before the refresh that
-    // delivers it — the deferred run must order setTargeting ahead of the ad
-    // request it triggers.
-    const div = document.createElement('div');
-    div.id = 'div-atf-sidebar';
-    document.body.appendChild(div);
-    const mockSlot = {
-      addService: vi.fn().mockReturnThis(),
-      setTargeting: vi.fn().mockReturnThis(),
-      clearTargeting: vi.fn().mockReturnThis(),
-      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
-      getTargeting: vi.fn().mockReturnValue([]),
-    };
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([mockSlot]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn(),
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adSlots = [
-      {
-        id: 'atf_sidebar_ad',
-        gam_unit_path: '/123/atf',
-        div_id: 'div-atf-sidebar',
-        formats: [[300, 250]],
-        targeting: { pos: 'atf' },
-      },
-    ];
-    ts.bids = { atf_sidebar_ad: { hb_pb: '1.00', hb_bidder: 'kargo' } };
-
-    ts.scheduleInitialAdInit!();
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('hb_pb', '1.00');
-    expect(mockSlot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-    expect(mockPubads.refresh).toHaveBeenCalledWith([mockSlot]);
-    const targetingOrder = mockSlot.setTargeting.mock.invocationCallOrder[0]!;
-    const refreshOrder = mockPubads.refresh.mock.invocationCallOrder[0]!;
-    expect(targetingOrder).toBeLessThan(refreshOrder);
-  });
-
-  it('drops the SSR payload when a navigation committed before scheduling', async () => {
-    // The SPA hook is installed by the synchronous head bundle, so a
-    // navigation can commit while the document is still streaming — before
-    // the </body> script calls the scheduler. The SSR payload then belongs
-    // to a document the page has already left: it must not overwrite the
-    // live route's bids, and the initial adInit must never fire.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    expect(ts.navGeneration).toBe(1);
-    ts.bids = { live_slot: { hb_pb: '2.50' } };
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } });
-    expect(ts.bids).toEqual({ live_slot: { hb_pb: '2.50' } });
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('preserves a page-bids response applied before scheduling', async () => {
-    // Same race, with the SPA navigation's page-bids response fully applied
-    // (slots + bids + its own adInit) before the scheduler is called: the
-    // stale SSR payload must not corrupt the applied state, and the route's
-    // adInit count must stay at the SPA hook's single call.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 's1', div_id: 'div-s1' }],
-        bids: { s1: { hb_pb: '3.00' } },
-      }),
-    });
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    expect(ts.bids).toEqual({ s1: { hb_pb: '3.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } });
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-
-    expect(ts.bids).toEqual({ s1: { hb_pb: '3.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('applies the SSR slot definitions on the initial document', async () => {
-    // Under a shared-template mode the head script emits no `tsjs.adSlots`, so the
-    // `</body>` seam is the only source of slot definitions. They must arrive, or
-    // `adInit()` iterates an empty list and the page defines no TS slots at all.
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    const ssrSlot = {
-      id: 'ssr_slot',
-      gam_unit_path: '/123/ssr',
-      div_id: 'div-ssr',
-      formats: [[728, 90]] as Array<[number, number]>,
-    };
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } }, [ssrSlot]);
-
-    expect(ts.adSlots).toEqual([ssrSlot]);
-    expect(ts.bids).toEqual({ ssr_slot: { hb_pb: '1.00' } });
-  });
-
-  it('preserves head-injected slots when initialSlots is omitted', async () => {
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    const headSlot = {
-      id: 'head_slot',
-      gam_unit_path: '/123/head',
-      div_id: 'div-head',
-      formats: [[300, 250]] as Array<[number, number]>,
-    };
-    ts.adSlots = [headSlot];
-
-    ts.scheduleInitialAdInit!({ head_slot: { hb_pb: '1.00' } });
-
-    expect(ts.adSlots).toEqual([headSlot]);
-  });
-
-  it('replaces existing slots when initialSlots is explicitly empty', async () => {
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adInit = vi.fn();
-    ts.adSlots = [
-      {
-        id: 'stale_slot',
-        gam_unit_path: '/123/stale',
-        div_id: 'div-stale',
-        formats: [[300, 250]],
-      },
-    ];
-
-    ts.scheduleInitialAdInit!({}, []);
-
-    expect(ts.adSlots).toEqual([]);
-  });
-
-  it('drops the SSR slot definitions when a navigation has already committed', async () => {
-    // The guard covered the bids and the adInit call, but the shared-template seam
-    // assigned `tsjs.adSlots` on the line *before* calling the scheduler — outside the
-    // guard entirely. A navigation that committed while the SSR document was still
-    // streaming therefore kept its own bids and silently lost its slots to the stale
-    // SSR payload, and the next `adInit()` for that route defined the wrong slots.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    expect(ts.navGeneration).toBe(1);
-    const liveSlot = {
-      id: 'live_slot',
-      gam_unit_path: '/123/live',
-      div_id: 'div-live',
-      formats: [[300, 250]] as Array<[number, number]>,
-    };
-    ts.adSlots = [liveSlot];
-
-    ts.scheduleInitialAdInit!({ ssr_slot: { hb_pb: '1.00' } }, [
-      {
-        id: 'ssr_slot',
-        gam_unit_path: '/123/ssr',
-        div_id: 'div-ssr',
-        formats: [[728, 90]],
-      },
-    ]);
-
-    expect(ts.adSlots).toEqual([liveSlot]);
-
-    window.dispatchEvent(new Event('load'));
-    flushFrame();
-    flushFrame();
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('cancels queued GPT work when a navigation commits before the command queue drains', async () => {
-    // adInit() only queues its slot work on googletag.cmd, which drains when
-    // GPT itself loads — possibly long after the generation check that
-    // guarded the adInit() call. A navigation in that gap must cancel the
-    // queued mutation, not let it run against the new route's DOM.
-    const commandQueue: Array<() => void> = [];
-    const mockPubads = {
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([]),
-      addEventListener: vi.fn(),
-      refresh: vi.fn(),
-    };
-    const defineSlot = vi.fn();
-    const destroySlots = vi.fn();
-    (window as TestWindow).googletag = {
-      cmd: commandQueue,
-      defineSlot,
-      destroySlots,
-      pubads: vi.fn().mockReturnValue(mockPubads),
-      enableServices: vi.fn(),
-    };
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    document.body.innerHTML = '<div id="div-atf-sidebar"></div>';
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adSlots = [
-      {
-        id: 'atf_sidebar_ad',
-        gam_unit_path: '/123/atf',
-        div_id: 'div-atf-sidebar',
-        formats: [[300, 250]],
-      },
-    ];
-    ts.bids = { atf_sidebar_ad: { hb_pb: '1.00' } };
-
-    // GPT not loaded yet: the queued work sits in the command array.
-    ts.adInit!();
-    expect(commandQueue.length).toBeGreaterThan(0);
-
-    // A navigation commits before GPT drains the queue.
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    expect(ts.navGeneration).toBe(1);
-
-    // GPT loads and drains the queue: the stale callback must stand down.
-    commandQueue.splice(0).forEach((fn) => fn());
-    expect(defineSlot).not.toHaveBeenCalled();
-    expect(destroySlots).not.toHaveBeenCalled();
-    expect(mockPubads.refresh).not.toHaveBeenCalled();
-    expect(mockPubads.enableSingleRequest).not.toHaveBeenCalled();
-  });
-
-  it('rides animation frames in a hidden document, holding adInit until first view', async () => {
-    // Browsers do not service rAF while the document is hidden, so a
-    // background-tab load queues the frames but does not run them until the
-    // tab is first viewed. This is intended (see installScheduleInitialAdInit):
-    // the initial request spends its impression on a viewed tab. The scheduler
-    // must keep riding rAF — not switch to a timer — while hidden.
-    Object.defineProperty(document, 'hidden', {
-      configurable: true,
-      get: () => true,
-    });
-    await importGptModule();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    ts.scheduleInitialAdInit!({ atf: { hb_pb: '1.00' } });
-    window.dispatchEvent(new Event('load'));
-
-    // Hidden tab: the frame chain is queued but unserviced — adInit waits.
-    expect(rafQueue.length).toBeGreaterThan(0);
-    expect(adInit).not.toHaveBeenCalled();
-
-    // First view: the browser services the pending frames.
-    flushFrame();
-    flushFrame();
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/spa_hook.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/spa_hook.test.ts
deleted file mode 100644
index 979b5b0c7..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/spa_hook.test.ts
+++ /dev/null
@@ -1,866 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import type { TsjsApi } from '../../../src/core/types';
-
-type TestWindow = Window & {
-  googletag?: unknown;
-  tsjs?: TsjsApi;
-};
-
-const originalPushState = history.pushState.bind(history);
-const originalReplaceState = history.replaceState.bind(history);
-
-async function importGptModule() {
-  return import('../../../src/integrations/gpt/index');
-}
-
-/** Flush the microtask/timer queue so onNavigate's awaits settle. */
-async function flushAsync(): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-/** Allow a MutationObserver-scheduled slot check to run. */
-async function flushAnimationFrame(): Promise<void> {
-  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-  await Promise.resolve();
-}
-
-describe('installSpaAuctionHook', () => {
-  let fetchStub: ReturnType<typeof vi.fn>;
-  // popstate listeners registered by each module import. In production the hook
-  // installs once (guarded by `ts.spaHookInstalled`), but tests wipe
-  // `window.tsjs` and re-import per test, so without explicit removal the
-  // listeners accumulate on the shared window and all fire on every dispatch.
-  let popstateHandlers: EventListenerOrEventListenerObject[] = [];
-  const realAddEventListener = window.addEventListener.bind(window);
-
-  beforeEach(() => {
-    vi.resetModules();
-    delete (window as TestWindow).tsjs;
-    // Restore unwrapped history methods so each module import wraps exactly
-    // once — without this, wrappers from prior imports accumulate.
-    history.pushState = originalPushState;
-    history.replaceState = originalReplaceState;
-    fetchStub = vi.fn();
-    vi.stubGlobal('fetch', fetchStub);
-    popstateHandlers = [];
-    vi.spyOn(window, 'addEventListener').mockImplementation((type, listener, options) => {
-      if (type === 'popstate' && listener) popstateHandlers.push(listener);
-      return realAddEventListener(type, listener, options);
-    });
-  });
-
-  afterEach(() => {
-    history.pushState = originalPushState;
-    history.replaceState = originalReplaceState;
-    // Reset jsdom location back to root for the next test.
-    originalReplaceState({}, '', '/');
-    // Drop any ad containers inserted by a test so DOM state does not leak.
-    document.body.innerHTML = '';
-    // Remove this test's popstate listener(s) so they do not fire in later tests.
-    popstateHandlers.forEach((handler) => window.removeEventListener('popstate', handler, true));
-    popstateHandlers = [];
-    vi.restoreAllMocks();
-    vi.unstubAllGlobals();
-  });
-
-  it('increments navGeneration only when a pathname navigation is accepted', async () => {
-    // The deferred initial-adInit bootstrap keys off this counter, so it must
-    // move in lockstep with the hook's own navigation identity: bumped
-    // synchronously for each accepted pathname change, untouched by the
-    // query-only and same-path history calls the hook ignores.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    expect(ts.navGeneration).toBe(0);
-
-    history.pushState({}, '', '/next-page');
-    expect(ts.navGeneration).toBe(1);
-
-    history.replaceState({}, '', '/next-page?utm_source=x');
-    expect(ts.navGeneration).toBe(1);
-
-    history.pushState({}, '', '/next-page');
-    expect(ts.navGeneration).toBe(1);
-    await flushAsync();
-  });
-
-  it.each(['bootstrap', 'bundle'] as const)(
-    'invalidates unclaimed GPT handoffs before an SPA fetch (%s)',
-    async (implementation) => {
-      let resolveFetch: ((response: unknown) => void) | undefined;
-      fetchStub.mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            resolveFetch = resolve;
-          })
-      );
-
-      const routeADiv = document.createElement('div');
-      routeADiv.id = 'div-atf-sidebar';
-      document.body.appendChild(routeADiv);
-      const routeASlot = {
-        getSlotElementId: vi.fn().mockReturnValue(routeADiv.id),
-      };
-      const routeBSlot = {
-        getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar-2'),
-      };
-      const nativeDefineSlot = vi.fn().mockReturnValue(routeBSlot);
-      const nativeDisplay = vi.fn();
-      const pubads = {
-        getSlots: vi.fn().mockReturnValue([routeASlot]),
-        refresh: vi.fn(),
-      };
-      const googletag = {
-        cmd: { push: vi.fn((fn: () => void) => fn()) },
-        defineSlot: nativeDefineSlot,
-        display: nativeDisplay,
-        pubads: vi.fn().mockReturnValue(pubads),
-      };
-      const staleHandoff = {
-        gamUnitPath: '/123/atf',
-        formats: [[300, 250]],
-        divIdPrefix: 'div-atf-sidebar',
-        slotElementId: routeADiv.id,
-        publisherClaimed: false,
-        suppressPublisherDisplay: false,
-        suppressPublisherRefresh: false,
-      };
-      const claimedHandoff = {
-        ...staleHandoff,
-        slotElementId: 'div-claimed',
-        publisherClaimed: true,
-      };
-      (window as TestWindow).googletag = googletag;
-      (window as TestWindow).tsjs = {
-        gptSlotHandoffs: {
-          [staleHandoff.slotElementId]: staleHandoff,
-          'div-atf-sidebar-hydrated': staleHandoff,
-          [claimedHandoff.slotElementId]: claimedHandoff,
-        },
-      };
-
-      if (implementation === 'bootstrap') {
-        const bootstrap = readFileSync(
-          resolve(process.cwd(), '../../trusted-server-core/src/integrations/gpt_bootstrap.js'),
-          'utf8'
-        );
-        window.eval(bootstrap);
-      }
-      await importGptModule();
-
-      routeADiv.remove();
-      const routeBDiv = document.createElement('div');
-      routeBDiv.id = 'div-atf-sidebar-2';
-      document.body.appendChild(routeBDiv);
-      history.pushState({}, '', '/route-b');
-
-      const publisherSlot = (
-        googletag.defineSlot as unknown as (
-          adUnitPath: string,
-          formats: number[][],
-          elementId: string
-        ) => typeof routeBSlot
-      )('/123/atf', [[300, 250]], routeBDiv.id);
-      googletag.display(routeBDiv.id);
-
-      expect(publisherSlot).toBe(routeBSlot);
-      expect(nativeDefineSlot).toHaveBeenCalledWith('/123/atf', [[300, 250]], routeBDiv.id);
-      expect(nativeDisplay).toHaveBeenCalledWith(routeBDiv.id);
-      expect((window as TestWindow).tsjs!.gptSlotHandoffs).toEqual({
-        [claimedHandoff.slotElementId]: claimedHandoff,
-      });
-      expect(resolveFetch).toBeDefined();
-
-      resolveFetch!({ ok: true, json: async () => ({ slots: [], bids: {} }) });
-      await flushAsync();
-    }
-  );
-
-  it('fetches page-bids on pushState and applies slots/bids via adInit', async () => {
-    // The route's ad container already exists, so bids apply immediately.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 's1', div_id: 'div-s1' }],
-        bids: { s1: { hb_pb: '1.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/next-page?edition=fictional#section');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledWith(
-      '/_ts/page-bids?path=%2Fnext-page',
-      expect.objectContaining({
-        credentials: 'include',
-        headers: { 'X-TSJS-Page-Bids': '1' },
-      })
-    );
-    expect(ts.adSlots).toEqual([{ id: 's1', div_id: 'div-s1' }]);
-    expect(ts.bids).toEqual({ s1: { hb_pb: '1.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('skips adInit on an empty page-bids response with no prior TS state', async () => {
-    // A gated page-bids response (template switch, auction gate, or consent
-    // denial) returns no slots. With no prior TS state to sweep, the hook must
-    // not call adInit() so a gated navigation cannot activate publisher GPT.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/gated-route');
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([]);
-    expect(ts.bids).toEqual({});
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('does not defer cleanup to adInit when an empty response has only prior targeting', async () => {
-    // Navigation clears prior targeting synchronously, so an empty response
-    // does not need adInit when TS owns no slots that still require destruction.
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    ts.prevSlotTargetingKeys = { 'div-prev': ['hb_pb'] };
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/cleanup-route');
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([]);
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('clears prior targeting before page-bids resolves without touching new publisher targeting', async () => {
-    let resolveFetch: ((response: Response) => void) | undefined;
-    fetchStub.mockImplementation(
-      () =>
-        new Promise<Response>((resolve) => {
-          resolveFetch = resolve;
-        })
-    );
-    const element = document.createElement('div');
-    element.id = 'div-route-slot';
-    document.body.appendChild(element);
-    const clearTargeting = vi.fn();
-    const gptSlot = {
-      addService: vi.fn().mockReturnThis(),
-      clearTargeting,
-      getSlotElementId: vi.fn().mockReturnValue(element.id),
-      getTargeting: vi.fn().mockReturnValue([]),
-      setTargeting: vi.fn().mockReturnThis(),
-    };
-    const pubads = {
-      addEventListener: vi.fn(),
-      enableSingleRequest: vi.fn(),
-      getSlots: vi.fn().mockReturnValue([gptSlot]),
-      refresh: vi.fn(),
-    };
-    (window as TestWindow).googletag = {
-      cmd: { push: vi.fn((fn: () => void) => fn()) },
-      defineSlot: vi.fn().mockReturnValue(gptSlot),
-      destroySlots: vi.fn(),
-      display: vi.fn(),
-      enableServices: vi.fn(),
-      pubads: vi.fn().mockReturnValue(pubads),
-    };
-
-    const { installSpaAuctionHook, installTsAdInit } = await importGptModule();
-    installTsAdInit();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    ts.prevSlotTargetingKeys = { [element.id]: ['ts_route'] };
-    ts.divToSlotId = { [element.id]: 'route_slot' };
-
-    history.pushState({}, '', '/publisher-route');
-
-    expect(clearTargeting.mock.calls.map(([key]) => key)).toEqual([
-      'hb_pb',
-      'hb_bidder',
-      'hb_adid',
-      'hb_cache_host',
-      'hb_cache_path',
-      'ts_initial',
-      'ts_route',
-    ]);
-    expect(ts.prevSlotTargetingKeys).toEqual({});
-    expect(ts.divToSlotId).toEqual({});
-    const cleanupCallCount = clearTargeting.mock.calls.length;
-
-    ts.firstImpression = {
-      generation: 1,
-      nextToken: 0,
-      fallbackSlots: {},
-      slots: {
-        [element.id]: {
-          generation: 1,
-          slotElementId: element.id,
-          element,
-          owner: 'publisher',
-          phase: 'auctioning',
-          expiresAt: Date.now() + 5000,
-          publisherAuctions: {},
-        },
-      },
-    };
-    gptSlot.setTargeting('hb_adid', 'publisher-current');
-    resolveFetch!(
-      new Response(
-        JSON.stringify({
-          slots: [
-            {
-              id: 'route_slot',
-              gam_unit_path: '/123/route',
-              div_id: element.id,
-              formats: [[300, 250]],
-              targeting: {},
-            },
-          ],
-          bids: {},
-        }),
-        { status: 200, headers: { 'Content-Type': 'application/json' } }
-      )
-    );
-    await flushAsync();
-
-    expect(clearTargeting).toHaveBeenCalledTimes(cleanupCallCount);
-    expect(gptSlot.setTargeting).toHaveBeenCalledWith('hb_adid', 'publisher-current');
-  });
-
-  it('defers applying bids until the route ad container is inserted', async () => {
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 'late', div_id: 'div-late' }],
-        bids: { late: { hb_pb: '2.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    // Navigate before the new route's container has rendered.
-    history.pushState({}, '', '/late-route');
-    await flushAsync();
-    expect(adInit).not.toHaveBeenCalled();
-    expect(ts.adSlots).toBeUndefined();
-
-    // Container commits — the hook should now apply bids exactly once.
-    document.body.innerHTML = '<div id="div-late"></div>';
-    await flushAnimationFrame();
-
-    expect(ts.adSlots).toEqual([{ id: 'late', div_id: 'div-late' }]);
-    expect(ts.bids).toEqual({ late: { hb_pb: '2.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('applies bids immediately when a prefix-configured placement exists but is hidden', async () => {
-    // A breakpoint-hidden placement (mobile-only config while on desktop) has
-    // rendered its div but the tiered resolver returns no element for it. The
-    // slot wait must count it as present — otherwise every navigation to the
-    // route stalls for the full SPA_SLOT_WAIT_MS before applying bids to the
-    // visible slots, and adInit skips the hidden slot anyway.
-    document.body.innerHTML =
-      '<div id="div-visible"></div>' + '<div id="ad-hidden-r1x" style="display:none"></div>';
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [
-          { id: 'visible', div_id: 'div-visible' },
-          { id: 'hidden', div_id: 'ad-hidden-' },
-        ],
-        bids: { visible: { hb_pb: '2.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/mixed-route');
-    await flushAsync();
-
-    // Bids apply without waiting out the slot timeout.
-    expect(ts.adSlots).toEqual([
-      { id: 'visible', div_id: 'div-visible' },
-      { id: 'hidden', div_id: 'ad-hidden-' },
-    ]);
-    expect(ts.bids).toEqual({ visible: { hb_pb: '2.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('checks for route containers directly in a hidden document', async () => {
-    vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
-    vi.stubGlobal('requestAnimationFrame', undefined);
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 'hidden', div_id: 'div-hidden' }],
-        bids: { hidden: { hb_pb: '3.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/hidden-route');
-    await flushAsync();
-    expect(adInit).not.toHaveBeenCalled();
-
-    document.body.innerHTML = '<div id="div-hidden"></div>';
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([{ id: 'hidden', div_id: 'div-hidden' }]);
-    expect(ts.bids).toEqual({ hidden: { hb_pb: '3.00' } });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('cancels a pending visible-tab frame when the document becomes hidden', async () => {
-    let visibility: DocumentVisibilityState = 'visible';
-    vi.spyOn(document, 'visibilityState', 'get').mockImplementation(() => visibility);
-    const requestAnimationFrameMock = vi.fn().mockReturnValue(17);
-    const cancelAnimationFrameMock = vi.fn();
-    vi.stubGlobal('requestAnimationFrame', requestAnimationFrameMock);
-    vi.stubGlobal('cancelAnimationFrame', cancelAnimationFrameMock);
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 'hidden-late', div_id: 'div-hidden-late' }],
-        bids: { 'hidden-late': { hb_pb: '3.50' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/hidden-late-route');
-    await flushAsync();
-
-    // A mutation while visible schedules a frame that never runs.
-    document.body.appendChild(document.createElement('span'));
-    await flushAsync();
-    expect(requestAnimationFrameMock).toHaveBeenCalledTimes(1);
-
-    // The next mutation happens after the document is hidden. It must cancel
-    // the stale frame and perform the presence check immediately.
-    visibility = 'hidden';
-    document.body.innerHTML = '<div id="div-hidden-late"></div>';
-    await flushAsync();
-
-    expect(cancelAnimationFrameMock).toHaveBeenCalledWith(17);
-    expect(adInit).toHaveBeenCalledTimes(1);
-    expect(ts.adSlots).toEqual([{ id: 'hidden-late', div_id: 'div-hidden-late' }]);
-  });
-
-  it('waits for every configured route ad container before applying bids', async () => {
-    document.body.innerHTML = '<div id="div-first"></div>';
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [
-          { id: 'first', div_id: 'div-first' },
-          { id: 'second', div_id: 'div-second' },
-        ],
-        bids: {
-          first: { hb_pb: '1.00' },
-          second: { hb_pb: '2.00' },
-        },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/multi-slot-route');
-    await flushAsync();
-
-    expect(adInit).not.toHaveBeenCalled();
-    expect(ts.adSlots).toBeUndefined();
-
-    const second = document.createElement('div');
-    second.id = 'div-second';
-    document.body.appendChild(second);
-    await flushAnimationFrame();
-
-    expect(ts.adSlots).toEqual([
-      { id: 'first', div_id: 'div-first' },
-      { id: 'second', div_id: 'div-second' },
-    ]);
-    expect(ts.bids).toEqual({
-      first: { hb_pb: '1.00' },
-      second: { hb_pb: '2.00' },
-    });
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not fetch when pushState targets the current path', async () => {
-    await importGptModule();
-
-    history.pushState({}, '', '/');
-    await flushAsync();
-
-    expect(fetchStub).not.toHaveBeenCalled();
-  });
-
-  it('fetches on replaceState navigation', async () => {
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-
-    history.replaceState({}, '', '/replaced');
-    await flushAsync();
-    expect(fetchStub).toHaveBeenCalledWith(
-      '/_ts/page-bids?path=%2Freplaced',
-      expect.objectContaining({ credentials: 'include' })
-    );
-  });
-
-  it('fetches on popstate navigation to a new path', async () => {
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-
-    // Browsers change the URL out-of-band on back/forward, then fire popstate.
-    // Use the unwrapped history method so the patched handler is not invoked.
-    originalReplaceState({}, '', '/popped');
-    window.dispatchEvent(new PopStateEvent('popstate'));
-    await flushAsync();
-    expect(fetchStub).toHaveBeenCalledWith(
-      '/_ts/page-bids?path=%2Fpopped',
-      expect.objectContaining({ credentials: 'include' })
-    );
-  });
-
-  it('does not re-fetch on popstate to the same path', async () => {
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    await importGptModule();
-
-    history.replaceState({}, '', '/replaced');
-    await flushAsync();
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-
-    // popstate on the same path (hash-only change or scroll-restoration
-    // back/forward) must not re-request impressions.
-    window.dispatchEvent(new PopStateEvent('popstate'));
-    await flushAsync();
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-  });
-
-  it('drops a stale response that resolves after a newer navigation started', async () => {
-    let resolveFirst: ((value: unknown) => void) | undefined;
-    fetchStub
-      .mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            resolveFirst = resolve;
-          })
-      )
-      .mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ slots: [{ id: 'newer', div_id: 'div-newer' }], bids: {} }),
-      });
-    // Container for the newer route exists so its bids apply without waiting.
-    document.body.innerHTML = '<div id="div-newer"></div>';
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/first');
-    history.pushState({}, '', '/second');
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([{ id: 'newer', div_id: 'div-newer' }]);
-    expect(adInit).toHaveBeenCalledTimes(1);
-
-    // First navigation's response arrives late — it must not overwrite the
-    // newer route's slots or trigger another adInit.
-    resolveFirst!({
-      ok: true,
-      json: async () => ({ slots: [{ id: 'stale' }], bids: {} }),
-    });
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([{ id: 'newer', div_id: 'div-newer' }]);
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('leaves slots and bids untouched on a non-OK response', async () => {
-    fetchStub.mockResolvedValue({ ok: false, status: 500 });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    ts.adSlots = [{ id: 'existing' } as never];
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/error-page');
-    await flushAsync();
-
-    expect(ts.adSlots).toEqual([{ id: 'existing' }]);
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('retries the same path after a failed page-bids fetch (currentPath rollback)', async () => {
-    // A failed load must roll `currentPath` back so re-navigating to the SAME
-    // path retries instead of being swallowed by the no-op guard at the top of
-    // onNavigate. Without the rollback, currentPath would already equal the
-    // failed path and the second navigation would return early.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub.mockResolvedValueOnce({ ok: false, status: 500 }).mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 's1', div_id: 'div-s1' }],
-        bids: { s1: { hb_pb: '1.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    // First navigation to the path fails; nothing is applied.
-    history.pushState({}, '', '/retry-page');
-    await flushAsync();
-    expect(ts.adSlots).toBeUndefined();
-
-    // Re-navigate to the same path — the retry must re-fetch and apply.
-    history.pushState({}, '', '/retry-page');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledTimes(2);
-    expect(ts.adSlots).toEqual([{ id: 's1', div_id: 'div-s1' }]);
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not strand a path that was aborted mid-flight then failed on the next nav', async () => {
-    // Rapid A→B where A is aborted mid-flight and B then fails must roll
-    // `currentPath` back to the last *applied* path (here the initial route),
-    // not to A. Rolling back to A — which never loaded — would leave it behind
-    // the no-op guard so a later real navigation to A never re-fetches.
-    document.body.innerHTML = '<div id="div-a"></div>';
-    let resolveA: ((value: unknown) => void) | undefined;
-    fetchStub
-      // A: still in flight when B starts (aborted, never settles on its own).
-      .mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            resolveA = resolve;
-          })
-      )
-      // B: fails.
-      .mockResolvedValueOnce({ ok: false, status: 500 })
-      // A retried: succeeds.
-      .mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          slots: [{ id: 'a', div_id: 'div-a' }],
-          bids: { a: { hb_pb: '1.00' } },
-        }),
-      });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    // A starts (left in flight), then B aborts A and fails.
-    history.pushState({}, '', '/a');
-    history.pushState({}, '', '/b');
-    await flushAsync();
-    expect(ts.adSlots).toBeUndefined();
-
-    // Navigate back to /a. With the rollback keyed to the last applied path
-    // (the initial route) instead of B's previous path (/a), this is NOT
-    // swallowed by the no-op guard and re-fetches.
-    history.pushState({}, '', '/a');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledTimes(3);
-    expect(ts.adSlots).toEqual([{ id: 'a', div_id: 'div-a' }]);
-    expect(adInit).toHaveBeenCalledTimes(1);
-
-    // The original aborted A fetch resolving late must not clobber the retry.
-    resolveA?.({ ok: true, json: async () => ({ slots: [{ id: 'stale' }], bids: {} }) });
-    await flushAsync();
-    expect(ts.adSlots).toEqual([{ id: 'a', div_id: 'div-a' }]);
-  });
-
-  it('falls back to the deprecated alias when the canonical path is behind Basic Auth', async () => {
-    // An operator `[[handlers]]` regex broad enough to cover `/_ts` answers the
-    // canonical path with 401 that no anonymous browser fetch can satisfy.
-    // Without the fallback, every SPA navigation on that deployment loses ads.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub.mockResolvedValueOnce({ ok: false, status: 401 }).mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 's1', div_id: 'div-s1' }],
-        bids: { s1: { hb_pb: '1.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/auth-gated');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenNthCalledWith(
-      1,
-      '/_ts/page-bids?path=%2Fauth-gated',
-      expect.anything()
-    );
-    // The fallback marks itself so the server can separate a current bundle
-    // that could not use the canonical path (a deployment to fix) from a
-    // pre-rename bundle (which ages out on its own).
-    expect(fetchStub).toHaveBeenNthCalledWith(
-      2,
-      '/__ts/page-bids?path=%2Fauth-gated',
-      expect.objectContaining({ headers: { 'X-TSJS-Page-Bids': 'fallback' } })
-    );
-    expect(ts.adSlots).toEqual([{ id: 's1', div_id: 'div-s1' }]);
-    expect(adInit).toHaveBeenCalledTimes(1);
-  });
-
-  it('falls back to the deprecated alias when the canonical path returns a non-JSON body', async () => {
-    // A server rolled back to before the rename does not register the canonical
-    // path, so it falls through to the publisher-origin proxy and answers 200
-    // HTML. That is the wrong endpoint, not a transient failure.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub
-      .mockResolvedValueOnce({
-        ok: true,
-        json: async () => {
-          throw new SyntaxError('Unexpected token <');
-        },
-      })
-      .mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({
-          slots: [{ id: 's1', div_id: 'div-s1' }],
-          bids: { s1: { hb_pb: '1.00' } },
-        }),
-      });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-
-    history.pushState({}, '', '/rolled-back');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenNthCalledWith(
-      2,
-      '/__ts/page-bids?path=%2Frolled-back',
-      expect.anything()
-    );
-    expect(ts.adSlots).toEqual([{ id: 's1', div_id: 'div-s1' }]);
-  });
-
-  it('stays on the alias for the rest of the session once the fallback works', async () => {
-    // Re-probing the canonical path on every navigation would double the
-    // request count for the whole session on an affected deployment.
-    document.body.innerHTML = '<div id="div-s1"></div>';
-    fetchStub.mockResolvedValueOnce({ ok: false, status: 401 }).mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        slots: [{ id: 's1', div_id: 'div-s1' }],
-        bids: { s1: { hb_pb: '1.00' } },
-      }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-
-    history.pushState({}, '', '/first');
-    await flushAsync();
-    history.pushState({}, '', '/second');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledTimes(3);
-    expect(fetchStub).toHaveBeenNthCalledWith(
-      3,
-      '/__ts/page-bids?path=%2Fsecond',
-      expect.anything()
-    );
-  });
-
-  it('does not retry the alias when the endpoint denies the request', async () => {
-    // 403 is the cross-site gate, which applies to both registered paths — the
-    // alias would deny it identically, so retrying only burns a request.
-    fetchStub.mockResolvedValue({ ok: false, status: 403 });
-    const { installSpaAuctionHook } = await importGptModule();
-    installSpaAuctionHook();
-    const ts = (window as TestWindow).tsjs!;
-    const adInit = vi.fn();
-    ts.adInit = adInit;
-
-    history.pushState({}, '', '/denied');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-    expect(ts.adSlots).toBeUndefined();
-    expect(adInit).not.toHaveBeenCalled();
-  });
-
-  it('is idempotent — repeated install calls do not double-fetch a navigation', async () => {
-    fetchStub.mockResolvedValue({
-      ok: true,
-      json: async () => ({ slots: [], bids: {} }),
-    });
-    const { installSpaAuctionHook } = await importGptModule();
-    // Module init already installed the hook; both calls must be no-ops.
-    installSpaAuctionHook();
-    installSpaAuctionHook();
-
-    history.pushState({}, '', '/once');
-    await flushAsync();
-
-    expect(fetchStub).toHaveBeenCalledTimes(1);
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt/startup.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt/startup.test.ts
new file mode 100644
index 000000000..cead76a52
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt/startup.test.ts
@@ -0,0 +1,158 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createBrowserGoogletagAdapter,
+  type GoogletagAdapter,
+  type GoogletagPublisherCallObserver,
+} from '../../../src/adapters/googletag';
+import { createGptStartup } from '../../../src/integrations/gpt/startup';
+import { createSlotService, type SlotService } from '../../../src/services/slots';
+
+describe('GPT startup bridge', () => {
+  it('installs one reversible typed observer and delegates all handoff state to slots', () => {
+    const order: string[] = [];
+    let observer: GoogletagPublisherCallObserver | undefined;
+    const release = vi.fn();
+    const observePublisherCalls = vi.fn((candidate: GoogletagPublisherCallObserver) => {
+      observer = candidate;
+      return release;
+    });
+    const adapter = Object.freeze({ observePublisherCalls }) as unknown as GoogletagAdapter;
+    const slot = {};
+    const slots = Object.freeze({
+      claimPublisherGptSlot: vi.fn(() => Object.freeze({ action: 'handoff' as const, slot })),
+      preparePublisherDisplay: vi.fn(() => Object.freeze({ action: 'suppress' as const })),
+      preparePublisherRefresh: vi.fn(() => Object.freeze({ action: 'suppress' as const })),
+      recordPublisherDestruction: vi.fn(() => true),
+      start: vi.fn(() => {
+        order.push('slots:start');
+        return Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(),
+          dispose: vi.fn(),
+        });
+      }),
+    }) satisfies Pick<
+      SlotService,
+      | 'claimPublisherGptSlot'
+      | 'preparePublisherDisplay'
+      | 'preparePublisherRefresh'
+      | 'recordPublisherDestruction'
+      | 'start'
+    >;
+    const start = vi.fn(() => order.push('external:start'));
+    const startup = createGptStartup({ googletag: adapter, slots: () => slots, start });
+
+    expect(startup.activate()).toBe(release);
+    expect(slots.start).not.toHaveBeenCalled();
+    expect(observePublisherCalls).toHaveBeenCalledTimes(1);
+    expect(
+      observer?.defineSlot?.({
+        adUnitPath: '/publisher',
+        elementId: 'slot',
+        initialLoadDisabled: true,
+        sizes: [300, 250],
+      })
+    ).toEqual({ action: 'handoff', slot });
+    expect(observer?.display?.({ initialLoadDisabled: true, target: 'slot' })).toEqual({
+      action: 'suppress',
+    });
+    expect(
+      observer?.refresh?.({
+        requestedSlots: undefined,
+        slots: Object.freeze([slot]),
+        options: undefined,
+      })
+    ).toEqual({ action: 'suppress' });
+    observer?.destroySlots?.({ slots: Object.freeze([slot, {}]) });
+    expect(slots.recordPublisherDestruction).toHaveBeenCalledTimes(2);
+
+    const config = Object.freeze({ disableInitialLoad: true });
+    startup.start(config);
+    expect(slots.start).toHaveBeenCalledOnce();
+    expect(start).toHaveBeenCalledExactlyOnceWith(config);
+    expect(order).toEqual(['slots:start', 'external:start']);
+  });
+
+  it('keeps reversible activation timer-free and begins readiness only from start', () => {
+    vi.useFakeTimers();
+    const adapter = createBrowserGoogletagAdapter({});
+    const slots = createSlotService({ googletag: adapter });
+    const startup = createGptStartup({ googletag: adapter, slots: () => slots });
+
+    const release = startup.activate();
+    slots.activate();
+    expect(vi.getTimerCount()).toBe(0);
+
+    startup.start(Object.freeze({}));
+    expect(vi.getTimerCount()).toBe(1);
+
+    release();
+    slots.dispose();
+    adapter.dispose();
+    expect(vi.getTimerCount()).toBe(0);
+    vi.useRealTimers();
+  });
+
+  it('installs one optional reversible Prebid refresh policy into the sole GPT observer', () => {
+    let observer: GoogletagPublisherCallObserver | undefined;
+    const observePublisherCalls = vi.fn((candidate: GoogletagPublisherCallObserver) => {
+      observer = candidate;
+      return vi.fn();
+    });
+    const adapter = Object.freeze({ observePublisherCalls }) as unknown as GoogletagAdapter;
+    const slot = Object.freeze({ id: 'slot' });
+    const admission = Object.freeze({ commit: vi.fn(), rollback: vi.fn() });
+    const completion = Promise.resolve();
+    const slots = Object.freeze({
+      claimPublisherGptSlot: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      preparePublisherDisplay: vi.fn(() => Object.freeze({ action: 'forward' as const })),
+      preparePublisherRefresh: vi.fn(() =>
+        Object.freeze({ action: 'forward' as const, admission })
+      ),
+      recordPublisherDestruction: vi.fn(),
+      start: vi.fn(),
+    }) as unknown as Pick<
+      SlotService,
+      | 'claimPublisherGptSlot'
+      | 'preparePublisherDisplay'
+      | 'preparePublisherRefresh'
+      | 'recordPublisherDestruction'
+      | 'start'
+    >;
+    const startup = createGptStartup({ googletag: adapter, slots: () => slots });
+    const boundary = startup as typeof startup & {
+      installRefreshPolicy: (
+        policy: Readonly<{ prepare: (call: unknown) => PromiseLike<unknown> | undefined }>
+      ) => (() => void) | undefined;
+    };
+    const prepare = vi.fn(() => completion);
+    const release = boundary.installRefreshPolicy(Object.freeze({ prepare }));
+
+    expect(release).toBeTypeOf('function');
+    expect(
+      boundary.installRefreshPolicy(Object.freeze({ prepare: vi.fn(() => completion) }))
+    ).toBeUndefined();
+    startup.activate();
+    const call = Object.freeze({
+      requestedSlots: Object.freeze([slot]),
+      slots: Object.freeze([slot]),
+      options: Object.freeze({ changeCorrelator: false }),
+    });
+    expect(observer?.refresh?.(call)).toEqual({
+      action: 'defer',
+      admission,
+      completion,
+      slots: [slot],
+    });
+    expect(prepare).toHaveBeenCalledExactlyOnceWith(call);
+
+    release?.();
+    release?.();
+    expect(observer?.refresh?.(call)).toEqual({ action: 'forward', admission });
+    expect(prepare).toHaveBeenCalledOnce();
+    expect(boundary.installRefreshPolicy(Object.freeze({ prepare: vi.fn() }))).toBeTypeOf(
+      'function'
+    );
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/api.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/api.test.ts
index abbdeca69..c7e31c86e 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/api.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/api.test.ts
@@ -1,8 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type { GptDiagnosticsBinding } from '../../../src/core/types';
+import { DiagnosticsSubscriberLimitError } from '../../../src/core/trace';
 import { GptDiagnosticsApiController } from '../../../src/integrations/gpt_diagnostics/api';
-import { GptDiagnosticsStore } from '../../../src/integrations/gpt_diagnostics/store';
+import {
+  GptDiagnosticsStore,
+  type GptDiagnosticsStoreSnapshot,
+} from '../../../src/integrations/gpt_diagnostics/store';
 
 class FakeBindings {
   private readonly listeners = new Set<() => void>();
@@ -63,7 +67,7 @@ function fakeApiStore() {
         evictedRequestCycles: 0,
       },
     })),
-    subscribe: vi.fn(() => () => undefined),
+    subscribeCommits: vi.fn(() => () => undefined),
     recordTrustedServerOpportunity: vi.fn(),
     recordPrebidRefresh: vi.fn(),
     recordTrustedServerCreativeRequest: vi.fn((_auctionSlotId: string) => 41),
@@ -72,6 +76,16 @@ function fakeApiStore() {
   };
 }
 
+function scheduleInto(tasks: Array<() => void>): (callback: () => void) => () => void {
+  return (callback) => {
+    tasks.push(callback);
+    return () => {
+      const index = tasks.indexOf(callback);
+      if (index >= 0) tasks.splice(index, 1);
+    };
+  };
+}
+
 beforeEach(() => {
   vi.restoreAllMocks();
   window.history.replaceState({}, '', '/article?private=value#fragment');
@@ -207,7 +221,7 @@ describe('GptDiagnosticsApiController', () => {
   });
 
   it('detaches nested attribution evidence from the store snapshot', () => {
-    const source = {
+    const source: GptDiagnosticsStoreSnapshot = {
       gptObserved: true,
       slots: [
         {
@@ -274,11 +288,11 @@ describe('GptDiagnosticsApiController', () => {
     );
     expect(cycle?.adManager?.yieldGroupIds).toEqual([10]);
     expect(cycle?.adManager?.yieldGroupIds).not.toBe(
-      source.slots[0]?.requests[0]?.adManager.yieldGroupIds
+      source.slots[0]?.requests[0]?.adManager?.yieldGroupIds
     );
     expect(cycle?.adManager?.companyIds).toEqual([20]);
     expect(cycle?.adManager?.companyIds).not.toBe(
-      source.slots[0]?.requests[0]?.adManager.companyIds
+      source.slots[0]?.requests[0]?.adManager?.companyIds
     );
     expect(snapshot.metadata).not.toBe(source.metadata);
     expect(snapshot.metadata.droppedAttributionIssues).toBe(2);
@@ -385,6 +399,11 @@ describe('GptDiagnosticsApiController', () => {
     const second = controller.api.snapshot();
     expect(second).not.toBe(snapshot);
     expect(second.slots).not.toBe(snapshot.slots);
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(Object.isFrozen(snapshot.page)).toBe(true);
+    expect(Object.isFrozen(snapshot.slots)).toBe(true);
+    expect(Object.isFrozen(snapshot.slots[0]?.requests)).toBe(true);
+    expect(Object.isFrozen(snapshot.slots[0]?.requests[0]?.durations)).toBe(true);
   });
 
   it('coalesces store and binding updates and isolates subscribers', () => {
@@ -400,7 +419,7 @@ describe('GptDiagnosticsApiController', () => {
       { show: vi.fn(), hide: vi.fn() },
       {
         now: () => new Date('2026-07-28T00:00:00.000Z'),
-        schedule: (callback) => scheduled.push(callback),
+        schedule: scheduleInto(scheduled),
       }
     );
     controller.api.subscribe(() => {
@@ -425,98 +444,136 @@ describe('GptDiagnosticsApiController', () => {
     expect(listener).toHaveBeenCalledTimes(1);
   });
 
-  it('gives subscribers isolated copies of one captured snapshot', () => {
+  it('captures subscriber membership per commit and coalesces to the latest snapshot', () => {
     const scheduled: Array<() => void> = [];
-    const sourceListeners = new Set<() => void>();
-    const store = fakeApiStore();
-    store.subscribe.mockImplementation((listener) => {
-      sourceListeners.add(listener);
-      return () => sourceListeners.delete(listener);
-    });
-    store.snapshot.mockReturnValue({
-      gptObserved: true,
-      slots: [
-        {
-          runtimeSlotNumber: 1,
-          slotElementId: 'ad-slot-example',
-          adUnitPath: '/example/site/banner',
-          requests: [
-            {
-              requestNumber: 1,
-              durations: { requestToResponseMs: 10 },
-              incompleteSequence: false,
-              requestedSlotSizes: [
-                [300, 250],
-                [728, 90],
-              ],
-              adManager: { yieldGroupIds: [10], companyIds: [20] },
-              trustedServerCreativeFailures: ['cache_fetch_failed' as const],
-            },
-          ],
-        },
-      ],
-      callbackIssues: [],
-      attributionIssues: [
-        {
-          reason: 'creative_attempt_expired' as const,
-          timestampMs: 30,
-        },
-      ],
-      coverage: emptyCoverage(),
-      metadata: {
-        droppedCallbacks: 0,
-        droppedAttributionIssues: 0,
-        evictedSlots: 0,
-        evictedRequestCycles: 0,
-      },
-    });
+    const store = new GptDiagnosticsStore({ now: () => 1, schedule: (callback) => callback() });
+    const bindings = new FakeBindings();
     const controller = new GptDiagnosticsApiController(
       store,
-      new FakeBindings(),
+      bindings,
       { show: vi.fn(), hide: vi.fn() },
       {
-        now: () => new Date('2026-08-10T00:00:00.000Z'),
-        schedule: (callback) => scheduled.push(callback),
+        now: () => new Date('2026-07-28T00:00:00.000Z'),
+        schedule: scheduleInto(scheduled),
       }
     );
-    let observedSnapshot: ReturnType<typeof controller.api.snapshot> | undefined;
-
-    controller.api.subscribe((snapshot) => {
-      const cycle = snapshot.slots[0]!.requests[0]!;
-      cycle.durations.requestToResponseMs = 999;
-      const requestedSlotSizes = cycle.requestedSlotSizes as unknown as Array<[number, number]>;
-      requestedSlotSizes[0]![0] = 1;
-      requestedSlotSizes.push([970, 250]);
-      cycle.adManager!.yieldGroupIds!.push(99);
-      cycle.trustedServerCreativeFailures!.push('response_post_failed');
-      snapshot.attributionIssues?.push({
-        reason: 'creative_attempt_unknown',
-        timestampMs: 40,
-      });
-      snapshot.coverage.slotRequested.observed = 99;
-      snapshot.metadata.droppedCallbacks = 99;
+    const first = vi.fn();
+    const second = vi.fn();
+    const releaseFirst = controller.api.subscribe(first);
+    const observedSlot = fakeSlot();
+
+    store.recordSlotRequested(observedSlot);
+    controller.api.subscribe(second);
+    releaseFirst();
+    expect(scheduled).toHaveLength(1);
+    scheduled.shift()?.();
+    expect(first).not.toHaveBeenCalled();
+    expect(second).not.toHaveBeenCalled();
+
+    store.recordSlotVisibilityChanged(observedSlot, 10);
+    store.recordSlotVisibilityChanged(observedSlot, 20);
+    expect(scheduled).toHaveLength(1);
+    scheduled.shift()?.();
+    expect(second).toHaveBeenCalledOnce();
+    expect(second.mock.calls[0]?.[0]).toEqual(
+      expect.objectContaining({
+        slots: [expect.objectContaining({ currentVisibilityPercentage: 20 })],
+      })
+    );
+  });
+
+  it('excludes a subscriber registered after the store commit but before source microtasks', () => {
+    const sourceTasks: Array<() => void> = [];
+    const publicTasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({
+      now: () => 1,
+      schedule: (callback) => sourceTasks.push(callback),
     });
-    controller.api.subscribe((snapshot) => {
-      observedSnapshot = snapshot;
+    const controller = new GptDiagnosticsApiController(
+      store,
+      new FakeBindings(),
+      { show: vi.fn(), hide: vi.fn() },
+      { schedule: scheduleInto(publicTasks) }
+    );
+
+    store.recordSlotRequested(fakeSlot());
+    const late = vi.fn();
+    controller.api.subscribe(late);
+    while (sourceTasks.length > 0) sourceTasks.shift()?.();
+    while (publicTasks.length > 0) publicTasks.shift()?.();
+
+    expect(late).not.toHaveBeenCalled();
+  });
+
+  it('includes a subscriber registered before the store commit without calling it inline', () => {
+    const sourceTasks: Array<() => void> = [];
+    const publicTasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({
+      now: () => 1,
+      schedule: (callback) => sourceTasks.push(callback),
     });
+    const controller = new GptDiagnosticsApiController(
+      store,
+      new FakeBindings(),
+      { show: vi.fn(), hide: vi.fn() },
+      { schedule: scheduleInto(publicTasks) }
+    );
+    const listener = vi.fn();
+    controller.api.subscribe(listener);
 
-    for (const listener of sourceListeners) listener();
-    expect(scheduled).toHaveLength(1);
-    scheduled.shift()!();
+    store.recordSlotRequested(fakeSlot());
+    expect(listener).not.toHaveBeenCalled();
+    while (sourceTasks.length > 0) sourceTasks.shift()?.();
+    expect(listener).not.toHaveBeenCalled();
+    while (publicTasks.length > 0) publicTasks.shift()?.();
 
-    expect(store.snapshot).toHaveBeenCalledTimes(1);
-    expect(observedSnapshot?.capturedAt).toBe('2026-08-10T00:00:00.000Z');
-    const observedCycle = observedSnapshot?.slots[0]?.requests[0];
-    expect(observedCycle?.durations.requestToResponseMs).toBe(10);
-    expect(observedCycle?.requestedSlotSizes).toEqual([
-      [300, 250],
-      [728, 90],
-    ]);
-    expect(observedCycle?.adManager?.yieldGroupIds).toEqual([10]);
-    expect(observedCycle?.trustedServerCreativeFailures).toEqual(['cache_fetch_failed']);
-    expect(observedSnapshot?.attributionIssues).toHaveLength(1);
-    expect(observedSnapshot?.coverage.slotRequested.observed).toBe(0);
-    expect(observedSnapshot?.metadata.droppedCallbacks).toBe(0);
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('defers a subscriber registered during dispatch until the next commit', () => {
+    const publicTasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ now: () => 1, schedule: (callback) => callback() });
+    const controller = new GptDiagnosticsApiController(
+      store,
+      new FakeBindings(),
+      { show: vi.fn(), hide: vi.fn() },
+      { schedule: scheduleInto(publicTasks) }
+    );
+    const second = vi.fn();
+    const first = vi.fn(() => controller.api.subscribe(second));
+    controller.api.subscribe(first);
+
+    const observedSlot = fakeSlot();
+    store.recordSlotRequested(observedSlot);
+    expect(first).not.toHaveBeenCalled();
+    publicTasks.shift()?.();
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).not.toHaveBeenCalled();
+
+    store.recordSlotVisibilityChanged(observedSlot, 10);
+    publicTasks.shift()?.();
+    expect(first).toHaveBeenCalledTimes(2);
+    expect(second).toHaveBeenCalledOnce();
+  });
+
+  it('validates callability before enforcing the shared 32-subscriber cap', () => {
+    const controller = new GptDiagnosticsApiController(
+      new GptDiagnosticsStore({ now: () => 1 }),
+      new FakeBindings(),
+      { show: vi.fn(), hide: vi.fn() }
+    );
+    const releases = Array.from({ length: 32 }, () => controller.api.subscribe(() => undefined));
+
+    expect(() => controller.api.subscribe(null as never)).toThrow(TypeError);
+    expect(() => controller.api.subscribe(() => undefined)).toThrow(
+      DiagnosticsSubscriberLimitError
+    );
+    expect(() => controller.api.subscribe(() => undefined)).toThrow(
+      expect.objectContaining({ code: 'subscriber_capacity', surface: 'gpt' })
+    );
+    releases[0]?.();
+    releases[0]?.();
+    expect(controller.api.subscribe(() => undefined)).toEqual(expect.any(Function));
   });
 
   it('delegates show and hide without mutating diagnostics data', () => {
@@ -587,13 +644,17 @@ describe('GptDiagnosticsApiController', () => {
       store,
       bindings,
       { show: vi.fn(), hide: vi.fn() },
-      { schedule: (callback) => scheduled.push(callback) }
+      { schedule: scheduleInto(scheduled) }
     );
     const listener = vi.fn();
     controller.api.subscribe(listener);
 
-    controller.destroy();
     store.recordSlotRequested(fakeSlot());
+    expect(scheduled).toHaveLength(1);
+
+    controller.destroy();
+    while (scheduled.length > 0) scheduled.shift()?.();
+    store.recordSlotVisibilityChanged(fakeSlot(), 10);
     bindings.emit();
 
     expect(scheduled).toEqual([]);
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/badges.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/badges.test.ts
index 329c4d299..17cfbe7a7 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/badges.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/badges.test.ts
@@ -3,8 +3,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { GptDiagnosticsBinding } from '../../../src/core/types';
 import type { GptDiagnosticsBindingView } from '../../../src/integrations/gpt_diagnostics/binding';
 import {
+  formatGptDiagnosticsBadgeText,
   GptDiagnosticsBadgeManager,
-  gptDiagnosticsBadgeTextForTest,
 } from '../../../src/integrations/gpt_diagnostics/badges';
 import { GptDiagnosticsStore } from '../../../src/integrations/gpt_diagnostics/store';
 
@@ -64,6 +64,18 @@ function runFrame(frames: Array<() => void>): void {
   frame();
 }
 
+const gptDiagnosticsBadgeTextForTest = formatGptDiagnosticsBadgeText;
+
+function queueFrame(frames: Array<() => void>): (callback: () => void) => () => void {
+  return (callback) => {
+    frames.push(callback);
+    return () => {
+      const index = frames.indexOf(callback);
+      if (index >= 0) frames.splice(index, 1);
+    };
+  };
+}
+
 beforeEach(() => {
   document.body.replaceChildren();
   Object.defineProperty(window, 'innerWidth', { configurable: true, value: 1024 });
@@ -105,7 +117,7 @@ describe('GptDiagnosticsBadgeManager', () => {
     const layer = document.createElement('div');
     document.body.append(layer);
     const manager = new GptDiagnosticsBadgeManager(store, bindings, {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
     });
     manager.setLayer(layer);
     runFrame(frames);
@@ -245,7 +257,7 @@ describe('GptDiagnosticsBadgeManager', () => {
 
   it('uses only GPT-observed lifecycle facts in badge text', () => {
     expect(
-      gptDiagnosticsBadgeTextForTest({
+      formatGptDiagnosticsBadgeText({
         requestNumber: 1,
         requestedAtMs: 0,
         responseAtMs: 276,
@@ -269,7 +281,7 @@ describe('GptDiagnosticsBadgeManager', () => {
       'Filled · Req 728×90, 970×250 · Fill 728×90 · Box 980×270\nResponse 276 ms · Render 42 ms\nViewable after 1 s'
     );
     expect(
-      gptDiagnosticsBadgeTextForTest({
+      formatGptDiagnosticsBadgeText({
         requestNumber: 1,
         isEmpty: false,
         requestedSlotSizes: [
@@ -291,7 +303,7 @@ describe('GptDiagnosticsBadgeManager', () => {
       })
     ).toBe('Empty');
     expect(
-      gptDiagnosticsBadgeTextForTest({
+      formatGptDiagnosticsBadgeText({
         requestNumber: 1,
         renderAtMs: 5,
         incompleteSequence: false,
@@ -299,42 +311,38 @@ describe('GptDiagnosticsBadgeManager', () => {
       })
     ).toBe('Rendered (fill unknown)');
     expect(
-      gptDiagnosticsBadgeTextForTest({
+      formatGptDiagnosticsBadgeText({
         requestNumber: 1,
         incompleteSequence: false,
         durations: {},
       })
     ).toBe('Pending');
-    expect(
-      gptDiagnosticsBadgeTextForTest({
-        requestNumber: 1,
-        isEmpty: false,
-        renderAtMs: 5,
-        incompleteSequence: true,
-        durations: {},
-      })
-    ).toBe('Filled\nIncomplete sequence');
-    // Assert over rendered text: the delivery vocabulary lives in a helper that
-    // a `toString()` of this function would not include.
-    for (const delivery of [
-      'trusted_server_response_sent',
-      'trusted_server_selected',
-      'candidate_unconfirmed',
-      'no_candidate',
-      'unknown',
-      'pending',
-      'not_applicable',
-    ] as const) {
-      expect(
-        gptDiagnosticsBadgeTextForTest({
-          requestNumber: 1,
-          isEmpty: false,
-          incompleteSequence: false,
-          durations: {},
-          delivery,
-        })
-      ).not.toMatch(/GAM winner|bidder|provenance/i);
-    }
+    expect(formatGptDiagnosticsBadgeText.toString()).not.toMatch(
+      /Trusted Server|GAM winner|Prebid|bidder|provenance/i
+    );
+  });
+
+  it('rejects a counterfeit bound element instead of accepting DOM-shaped data', () => {
+    const frames: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    store.recordSlotRequested(slot('counterfeit'));
+    const bindings = new FakeBindings();
+    const counterfeit = Object.freeze({
+      getBoundingClientRect: () => rectangle(10, 10, 300, 250),
+      isConnected: true,
+    }) as unknown as HTMLElement;
+    bindings.set(1, { status: 'bound' }, counterfeit, true);
+    const layer = document.createElement('div');
+    document.body.append(layer);
+    const manager = new GptDiagnosticsBadgeManager(store, bindings, {
+      scheduleFrame: queueFrame(frames),
+    });
+
+    manager.setLayer(layer);
+    runFrame(frames);
+
+    expect(layer.querySelector('.tsgd-badge')).toBeNull();
+    manager.destroy();
   });
 
   it('positions in the overlay layer and coalesces scroll and resize updates', () => {
@@ -357,7 +365,7 @@ describe('GptDiagnosticsBadgeManager', () => {
     const layer = document.createElement('div');
     document.body.append(layer);
     const manager = new GptDiagnosticsBadgeManager(store, bindings, {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
     });
     manager.setLayer(layer);
     runFrame(frames);
@@ -394,7 +402,7 @@ describe('GptDiagnosticsBadgeManager', () => {
     const layer = document.createElement('div');
     document.body.append(layer);
     const manager = new GptDiagnosticsBadgeManager(store, bindings, {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
     });
     manager.setLayer(layer);
     runFrame(frames);
@@ -433,7 +441,7 @@ describe('GptDiagnosticsBadgeManager', () => {
         MutationObserver: undefined,
         ResizeObserver: undefined,
       }),
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
     });
 
     expect(() => {
@@ -442,4 +450,56 @@ describe('GptDiagnosticsBadgeManager', () => {
     }).not.toThrow();
     manager.destroy();
   });
+
+  it('cancels a pending badge update on destroy and suppresses a hostile late callback', () => {
+    const frames: Array<() => void> = [];
+    const cancel = vi.fn();
+    const layer = document.createElement('div');
+    document.body.append(layer);
+    const manager = new GptDiagnosticsBadgeManager(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: (callback) => {
+        frames.push(callback);
+        return cancel;
+      },
+    });
+    const update = vi.spyOn(manager, 'update');
+    manager.setLayer(layer);
+
+    manager.destroy();
+    frames[0]?.();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it('runs one scheduled badge callback at most once', () => {
+    const frames: Array<() => void> = [];
+    const manager = new GptDiagnosticsBadgeManager(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: (callback) => {
+        frames.push(callback);
+        return vi.fn();
+      },
+    });
+    const update = vi.spyOn(manager, 'update');
+    manager.setLayer(document.createElement('div'));
+
+    frames[0]?.();
+    frames[0]?.();
+
+    expect(update).toHaveBeenCalledOnce();
+    manager.destroy();
+  });
+
+  it('isolates a hostile frame cancellation during destroy', () => {
+    const cancel = vi.fn(() => {
+      throw new Error('cancel failed');
+    });
+    const manager = new GptDiagnosticsBadgeManager(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: () => cancel,
+    });
+    manager.setLayer(document.createElement('div'));
+
+    expect(() => manager.destroy()).not.toThrow();
+    expect(cancel).toHaveBeenCalledOnce();
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/binding.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/binding.test.ts
index 5a1773a59..5cd81c754 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/binding.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/binding.test.ts
@@ -33,13 +33,23 @@ function createStore(): GptDiagnosticsStore {
 
 function createManager(
   store: GptDiagnosticsStore,
-  scheduleFrame?: (callback: () => void) => void
+  scheduleFrame?: (callback: () => void) => () => void
 ): GptDiagnosticsBindingManager {
   const manager = new GptDiagnosticsBindingManager(store, { scheduleFrame });
   managers.push(manager);
   return manager;
 }
 
+function queueFrame(frames: Array<() => void>): (callback: () => void) => () => void {
+  return (callback) => {
+    frames.push(callback);
+    return () => {
+      const index = frames.indexOf(callback);
+      if (index >= 0) frames.splice(index, 1);
+    };
+  };
+}
+
 function setRectangle(
   element: HTMLElement,
   rectangle: { top: number; left: number; width: number; height: number }
@@ -108,6 +118,35 @@ describe('GptDiagnosticsBindingManager', () => {
     });
   });
 
+  it('fails closed when the supplied realm has a hostile HTMLElement constructor', () => {
+    const element = document.createElement('div');
+    element.id = 'hostile-realm-slot';
+    document.body.append(element);
+    const store = createStore();
+    store.recordSlotRequested(fakeSlot(element.id));
+    const hostileWindow = {
+      CSS: window.CSS,
+      MutationObserver: undefined,
+      addEventListener: window.addEventListener.bind(window),
+      get HTMLElement(): never {
+        throw new Error('hostile HTMLElement constructor');
+      },
+      innerHeight: window.innerHeight,
+      innerWidth: window.innerWidth,
+      removeEventListener: window.removeEventListener.bind(window),
+    };
+
+    const manager = new GptDiagnosticsBindingManager(store, {
+      window: hostileWindow as never,
+    });
+    managers.push(manager);
+
+    expect(manager.get(1)).toMatchObject({
+      binding: { status: 'unbound', reason: 'missing_element' },
+      visible: false,
+    });
+  });
+
   it('reports an empty GPT element ID as unbound without a synthetic DOM ID', () => {
     const store = createStore();
     store.recordSlotRequested(fakeSlot());
@@ -118,7 +157,7 @@ describe('GptDiagnosticsBindingManager', () => {
       status: 'unbound',
       reason: 'missing_slot_element_id',
     });
-    expect(store.snapshot().slots[0].slotElementId).toBeUndefined();
+    expect(store.snapshot().slots[0]!.slotElementId).toBeUndefined();
   });
 
   it('treats duplicate DOM IDs as ambiguous', () => {
@@ -258,7 +297,7 @@ describe('GptDiagnosticsBindingManager', () => {
     document.body.append(element);
     const store = createStore();
     store.recordSlotRequested(fakeSlot('observed'));
-    const manager = createManager(store, (callback) => frames.push(callback));
+    const manager = createManager(store, queueFrame(frames));
 
     const unrelated = document.createElement('div');
     unrelated.id = 'unrelated';
@@ -284,7 +323,7 @@ describe('GptDiagnosticsBindingManager', () => {
   it('coalesces store-driven refreshes to one animation frame', () => {
     const scheduled: Array<() => void> = [];
     const store = createStore();
-    const manager = createManager(store, (callback) => scheduled.push(callback));
+    const manager = createManager(store, queueFrame(scheduled));
     const listener = vi.fn();
     manager.subscribe(listener);
     const slot = fakeSlot('scheduled');
@@ -301,4 +340,52 @@ describe('GptDiagnosticsBindingManager', () => {
       reason: 'missing_element',
     });
   });
+
+  it('cancels a pending refresh on destroy and suppresses a hostile late callback', () => {
+    const frames: Array<() => void> = [];
+    const cancel = vi.fn();
+    const store = createStore();
+    const manager = createManager(store, (callback) => {
+      frames.push(callback);
+      return cancel;
+    });
+    const listener = vi.fn();
+    manager.subscribe(listener);
+    store.recordSlotRequested(fakeSlot('pending-destroy'));
+
+    manager.destroy();
+    frames[0]?.();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('runs one scheduled refresh callback at most once', () => {
+    const frames: Array<() => void> = [];
+    const store = createStore();
+    const manager = createManager(store, (callback) => {
+      frames.push(callback);
+      return vi.fn();
+    });
+    const listener = vi.fn();
+    manager.subscribe(listener);
+    store.recordSlotRequested(fakeSlot('once'));
+
+    frames[0]?.();
+    frames[0]?.();
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('isolates a hostile frame cancellation during destroy', () => {
+    const store = createStore();
+    const cancel = vi.fn(() => {
+      throw new Error('cancel failed');
+    });
+    const manager = createManager(store, () => cancel);
+    store.recordSlotRequested(fakeSlot('hostile-cancel'));
+
+    expect(() => manager.destroy()).not.toThrow();
+    expect(cancel).toHaveBeenCalledOnce();
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/data_api.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/data_api.test.ts
new file mode 100644
index 000000000..b4cbc00d9
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/data_api.test.ts
@@ -0,0 +1,347 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  GptDiagnosticsDataApiController,
+  type GptDiagnosticsPresentationControls,
+} from '../../../src/integrations/gpt_diagnostics/data_api';
+import { GptDiagnosticsStore } from '../../../src/integrations/gpt_diagnostics/store';
+
+function controls(overrides: Partial<GptDiagnosticsPresentationControls> = {}) {
+  return Object.freeze({
+    dispose: vi.fn(),
+    download: vi.fn(),
+    exportBinding: vi.fn(() => Object.freeze({ status: 'bound' as const })),
+    hide: vi.fn(),
+    show: vi.fn(),
+    subscribe: vi.fn(() => vi.fn()),
+    ...overrides,
+  });
+}
+
+function controller(store = new GptDiagnosticsStore()) {
+  return new GptDiagnosticsDataApiController(store, {
+    location: { origin: 'https://publisher.example', pathname: '/article' },
+    schedule: (callback) => {
+      callback();
+      return () => undefined;
+    },
+  });
+}
+
+describe('takeover GPT diagnostics data API', () => {
+  it('deeply isolates delivery evidence and exports attribution issues', () => {
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const slot = Object.freeze({
+      getSlotElementId: () => 'delivery-slot',
+      getAdUnitPath: () => '/example/delivery-slot',
+    });
+    store.recordSlotRequested(slot, 1);
+    store.recordSlotRenderEnded(
+      slot,
+      {
+        isEmpty: false,
+        adManager: {
+          yieldGroupIds: [10],
+          companyIds: [20],
+        },
+      },
+      2
+    );
+    store.recordTrustedServerCreativeRequest('unknown-auction-slot');
+    const target = controller(store);
+
+    const snapshot = target.api.snapshot();
+    const cycle = snapshot.slots[0]?.requests[0];
+
+    expect(cycle?.adManager).toEqual({ yieldGroupIds: [10], companyIds: [20] });
+    expect(Object.isFrozen(cycle?.adManager)).toBe(true);
+    expect(Object.isFrozen(cycle?.adManager?.yieldGroupIds)).toBe(true);
+    expect(Object.isFrozen(cycle?.adManager?.companyIds)).toBe(true);
+    expect(snapshot.attributionIssues).toEqual([
+      expect.objectContaining({ reason: 'creative_request_without_slot' }),
+    ]);
+    expect(Object.isFrozen(snapshot.attributionIssues)).toBe(true);
+    expect(Object.isFrozen(snapshot.attributionIssues?.[0])).toBe(true);
+    target.destroy();
+  });
+
+  it('coalesces exactly zero, one, and two committed updates to the latest snapshot', () => {
+    const tasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const target = new GptDiagnosticsDataApiController(store, {
+      location: { origin: 'https://publisher.example', pathname: '/article' },
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => undefined;
+      },
+    });
+    const listener = vi.fn();
+    target.api.subscribe(listener);
+    const slot = Object.freeze({
+      getSlotElementId: () => 'coalesced-slot',
+      getAdUnitPath: () => '/example/coalesced-slot',
+    });
+
+    expect(tasks).toEqual([]);
+    store.recordSlotRequested(slot);
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(listener).toHaveBeenCalledOnce();
+
+    store.recordSlotVisibilityChanged(slot, 10);
+    store.recordSlotVisibilityChanged(slot, 20);
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(listener).toHaveBeenCalledTimes(2);
+    expect(listener.mock.calls[1]?.[0]).toEqual(
+      expect.objectContaining({
+        slots: [expect.objectContaining({ currentVisibilityPercentage: 20 })],
+      })
+    );
+    target.destroy();
+  });
+
+  it('captures subscriber ids at commit and suppresses an id unsubscribed before delivery', () => {
+    const tasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const target = new GptDiagnosticsDataApiController(store, {
+      location: { origin: 'https://publisher.example', pathname: '/article' },
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => undefined;
+      },
+    });
+    const first = vi.fn();
+    const second = vi.fn();
+    const releaseFirst = target.api.subscribe(first);
+    const slot = Object.freeze({ getSlotElementId: () => 'captured-id-slot' });
+
+    store.recordSlotRequested(slot);
+    target.api.subscribe(second);
+    releaseFirst();
+    tasks.shift()?.();
+    expect(first).not.toHaveBeenCalled();
+    expect(second).not.toHaveBeenCalled();
+
+    store.recordSlotVisibilityChanged(slot, 25);
+    tasks.shift()?.();
+    expect(first).not.toHaveBeenCalled();
+    expect(second).toHaveBeenCalledOnce();
+    target.destroy();
+  });
+
+  it('keeps a slow listener and its reentrant commit on separate notifier task stacks', () => {
+    const tasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const target = new GptDiagnosticsDataApiController(store, {
+      location: { origin: 'https://publisher.example', pathname: '/article' },
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => undefined;
+      },
+    });
+    const slot = Object.freeze({ getSlotElementId: () => 'slow-listener-slot' });
+    let listenerDepth = 0;
+    let maximumDepth = 0;
+    const slow = vi.fn(() => {
+      listenerDepth += 1;
+      maximumDepth = Math.max(maximumDepth, listenerDepth);
+      if (slow.mock.calls.length === 1) store.recordSlotVisibilityChanged(slot, 50);
+      listenerDepth -= 1;
+    });
+    const peer = vi.fn();
+    target.api.subscribe(slow);
+    target.api.subscribe(peer);
+
+    store.recordSlotRequested(slot);
+    expect(slow).not.toHaveBeenCalled();
+    expect(peer).not.toHaveBeenCalled();
+    tasks.shift()?.();
+    expect(slow).toHaveBeenCalledOnce();
+    expect(peer).toHaveBeenCalledOnce();
+    expect(tasks).toHaveLength(1);
+    tasks.shift()?.();
+    expect(slow).toHaveBeenCalledTimes(2);
+    expect(peer).toHaveBeenCalledTimes(2);
+    expect(maximumDepth).toBe(1);
+    target.destroy();
+  });
+
+  it('keeps public identity stable and does not spend public subscriber capacity on presentation', () => {
+    const target = controller();
+    const api = target.api;
+    const presentation = controls();
+    const factory = vi.fn((source, attachedApi) => {
+      expect(source).toEqual(
+        expect.objectContaining({
+          bindingInputs: expect.any(Function),
+          snapshot: expect.any(Function),
+          subscribe: expect.any(Function),
+        })
+      );
+      expect(attachedApi).toBe(api);
+      return presentation;
+    });
+
+    const detach = target.attachPresentation(factory);
+    const publicReleases = Array.from({ length: 32 }, () => api.subscribe(vi.fn()));
+
+    expect(() => api.subscribe(vi.fn())).toThrow(
+      expect.objectContaining({ code: 'subscriber_capacity', surface: 'gpt' })
+    );
+    expect(target.api).toBe(api);
+    detach();
+    detach();
+    expect(presentation.subscribe).toHaveBeenCalledOnce();
+    expect(vi.mocked(presentation.subscribe).mock.results[0]?.value).toHaveBeenCalledOnce();
+    expect(presentation.dispose).toHaveBeenCalledOnce();
+    expect(target.api).toBe(api);
+    publicReleases.forEach((release) => release());
+    target.destroy();
+  });
+
+  it('validates callability before state and rejects reentrant attachment without losing the outer owner', () => {
+    const target = controller();
+    const presentation = controls();
+    const nested = vi.fn();
+    const detach = target.attachPresentation(() => {
+      expect(() => target.attachPresentation(nested)).toThrow(
+        'GPT diagnostics presentation is unavailable'
+      );
+      return presentation;
+    });
+
+    expect(nested).not.toHaveBeenCalled();
+    expect(() => target.attachPresentation(null as never)).toThrow(
+      'GPT diagnostics presentation factory must be callable'
+    );
+    expect(() => target.attachPresentation(() => controls())).toThrow(
+      'GPT diagnostics presentation is unavailable'
+    );
+    detach();
+    expect(() => target.attachPresentation(() => controls())).not.toThrow();
+    target.destroy();
+  });
+
+  it.each([
+    [
+      'malformed controls',
+      () => Object.freeze({ dispose: vi.fn() }),
+      'GPT diagnostics presentation controls are malformed',
+    ],
+    [
+      'invalid subscription disposer',
+      () => controls({ subscribe: vi.fn(() => undefined as never) }),
+      'GPT diagnostics presentation disposer is unavailable',
+    ],
+    [
+      'throwing subscription',
+      () =>
+        controls({
+          subscribe: vi.fn(() => {
+            throw new Error('subscription failed');
+          }),
+        }),
+      'subscription failed',
+    ],
+  ])('rolls back %s without publishing presentation ownership', (_name, create, message) => {
+    const target = controller();
+    const presentation = create();
+
+    expect(() => target.attachPresentation(() => presentation as never)).toThrow(message);
+    expect(presentation.dispose).toHaveBeenCalledOnce();
+    expect(() => target.attachPresentation(() => controls())).not.toThrow();
+    target.destroy();
+  });
+
+  it('releases subscription and controls independently during detach and destroy', () => {
+    const detachedDispose = vi.fn();
+    const target = controller();
+    const detach = target.attachPresentation(() =>
+      controls({
+        dispose: detachedDispose,
+        subscribe: vi.fn(() => () => {
+          throw new Error('hostile subscription release');
+        }),
+      })
+    );
+
+    expect(() => detach()).not.toThrow();
+    expect(detachedDispose).toHaveBeenCalledOnce();
+
+    const destroyedDispose = vi.fn();
+    target.attachPresentation(() =>
+      controls({
+        dispose: destroyedDispose,
+        subscribe: vi.fn(() => () => {
+          throw new Error('hostile destroy release');
+        }),
+      })
+    );
+    expect(() => target.destroy()).not.toThrow();
+    expect(destroyedDispose).toHaveBeenCalledOnce();
+  });
+
+  it.each(['throw', 'invalid disposer'] as const)(
+    'contains a notifier scheduler %s and recovers on the next commit',
+    (failure) => {
+      const tasks: Array<() => void> = [];
+      let attempts = 0;
+      const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+      const target = new GptDiagnosticsDataApiController(store, {
+        location: { origin: 'https://publisher.example', pathname: '/article' },
+        schedule: (callback) => {
+          attempts += 1;
+          if (attempts === 1) {
+            if (failure === 'throw') throw new Error('fictional scheduler failure');
+            return undefined as never;
+          }
+          tasks.push(callback);
+          return () => undefined;
+        },
+      });
+      target.api.subscribe(() => {
+        throw new Error('fictional subscriber failure');
+      });
+      const listener = vi.fn();
+      target.api.subscribe(listener);
+      const slot = Object.freeze({
+        getSlotElementId: () => 'notifier-slot',
+        getAdUnitPath: () => '/example/notifier-slot',
+      });
+
+      expect(() => store.recordSlotRequested(slot)).not.toThrow();
+      expect(listener).not.toHaveBeenCalled();
+      expect(() => store.recordSlotVisibilityChanged(slot, 25)).not.toThrow();
+      expect(tasks).toHaveLength(1);
+      expect(() => tasks.shift()?.()).not.toThrow();
+      expect(listener).toHaveBeenCalledOnce();
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          slots: [expect.objectContaining({ currentVisibilityPercentage: 25 })],
+        })
+      );
+      target.destroy();
+    }
+  );
+
+  it('makes a retained scheduled notifier inert after controller destruction', () => {
+    const tasks: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const target = new GptDiagnosticsDataApiController(store, {
+      location: { origin: 'https://publisher.example', pathname: '/article' },
+      schedule: (callback) => {
+        tasks.push(callback);
+        return () => undefined;
+      },
+    });
+    const listener = vi.fn();
+    target.api.subscribe(listener);
+
+    store.recordSlotRequested(Object.freeze({ getSlotElementId: () => 'stale-notifier-slot' }));
+    expect(tasks).toHaveLength(1);
+    target.destroy();
+    expect(() => tasks.shift()?.()).not.toThrow();
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts
index fa50d6366..5971a0380 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts
@@ -1,69 +1,24 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import type { TsjsApi } from '../../../src/core/types';
-import {
-  installGptDiagnosticsRuntime,
-  isGptDiagnosticsActive,
-} from '../../../src/integrations/gpt_diagnostics';
+import type { GoogletagDiagnosticsFact } from '../../../src/adapters/googletag';
+import { createGptDiagnosticsFactBuffer } from '../../../src/integrations/gpt/diagnostics_facts';
+import { createGptDiagnosticsRuntime } from '../../../src/composition/browser_test_gpt_diagnostics';
 import { GPT_DIAGNOSTICS_HOST_ID } from '../../../src/integrations/gpt_diagnostics/overlay';
 
-interface FakeSlot {
-  getSlotElementId(): string;
-  getAdUnitPath(): string;
-}
-
-type Listener = (event: unknown) => void;
-
-type DiagnosticsTestWindow = NonNullable<Parameters<typeof installGptDiagnosticsRuntime>[0]>;
-
-const target = window as unknown as DiagnosticsTestWindow;
-
-function coreApi(): TsjsApi {
-  return {
-    version: 'test',
-    que: [],
-    addAdUnits: vi.fn(),
-    renderAdUnit: vi.fn(),
-    renderAllAdUnits: vi.fn(),
-  };
-}
-
-function installGptStub() {
-  const listeners = new Map<string, Listener[]>();
-  const addEventListener = vi.fn((name: string, listener: Listener) => {
-    const existing = listeners.get(name) ?? [];
-    existing.push(listener);
-    listeners.set(name, existing);
+function slot(id: string): GoogletagDiagnosticsFact['slot'] {
+  return Object.freeze({
+    token: Object.freeze(Object.create(null) as object),
+    elementId: id,
+    adUnitPath: `/example/site/${id}`,
   });
-  const queue = {
-    push: vi.fn((callback: () => void) => {
-      callback();
-      return 1;
-    }),
-  };
-  target.googletag = {
-    cmd: queue,
-    pubads: () => ({ addEventListener }),
-  };
-  return {
-    addEventListener,
-    queue,
-    emit(name: string, event: Record<string, unknown>) {
-      for (const listener of listeners.get(name) ?? []) listener(event);
-    },
-  };
-}
-
-function slot(id: string): FakeSlot {
-  return {
-    getSlotElementId: () => id,
-    getAdUnitPath: () => `/example/site/${id}`,
-  };
 }
 
-async function settle(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
+function fact(
+  kind: GoogletagDiagnosticsFact['kind'],
+  observedSlot: GoogletagDiagnosticsFact['slot'],
+  fields: Partial<GoogletagDiagnosticsFact> = {}
+): Readonly<GoogletagDiagnosticsFact> {
+  return Object.freeze({ kind, observedAtMs: 1, slot: observedSlot, ...fields });
 }
 
 beforeEach(() => {
@@ -77,181 +32,106 @@ beforeEach(() => {
     configurable: true,
     value: { escape: (value: string) => value },
   });
-  target.tsjs = coreApi();
-  delete target.googletag;
-  delete target.__tsjs_gpt_diagnostics_active;
-  delete target.__tsjs_gpt_diagnostics_runtime;
 });
 
 afterEach(() => {
-  target.__tsjs_gpt_diagnostics_runtime?.destroy();
-  delete target.__tsjs_gpt_diagnostics_active;
-  delete target.__tsjs_gpt_diagnostics_runtime;
-  delete target.googletag;
-  delete target.tsjs;
   vi.unstubAllGlobals();
   vi.restoreAllMocks();
   document.body.replaceChildren();
 });
 
-describe('GPT diagnostics integration composition', () => {
-  it('has no inactive side effects', () => {
-    const originalMutationObserver = window.MutationObserver;
+describe('GPT diagnostics runtime', () => {
+  it('is inert until activation and publishes no legacy global or mutable authority', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    const runtime = createGptDiagnosticsRuntime(buffer, { window, document });
+    const legacyTarget = window as unknown as Record<string, unknown>;
 
-    expect(isGptDiagnosticsActive(target)).toBe(false);
-    expect(installGptDiagnosticsRuntime(target)).toBeUndefined();
-
-    expect(target.tsjs?.gptDiagnostics).toBeUndefined();
-    expect(target.tsjs?.gptDiagnosticsRecorder).toBeUndefined();
-    expect(target.googletag).toBeUndefined();
-    expect(target.__tsjs_gpt_diagnostics_runtime).toBeUndefined();
+    expect(runtime.currentApi()).toBeUndefined();
     expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
-    expect(window.MutationObserver).toBe(originalMutationObserver);
-  });
 
-  it('installs one idempotent active runtime and six listeners', () => {
-    target.__tsjs_gpt_diagnostics_active = true;
-    const gpt = installGptStub();
-    const previousApi = target.tsjs;
+    const release = runtime.activate();
+    const api = runtime.currentApi();
 
-    const first = installGptDiagnosticsRuntime(target);
-    const second = installGptDiagnosticsRuntime(target);
-
-    expect(first).toBeDefined();
-    expect(second).toBe(first);
-    expect(target.tsjs).toBe(previousApi);
-    expect(target.tsjs?.gptDiagnostics).toBe(first);
-    // Evidence writers live on their own channel; the operator API stays read-only.
-    expect(Object.keys(first!).sort()).toEqual(['export', 'hide', 'show', 'snapshot', 'subscribe']);
-    expect(Object.keys(target.tsjs!.gptDiagnosticsRecorder!).sort()).toEqual([
-      'recordPrebidRefresh',
-      'recordTrustedServerCreativeFailure',
-      'recordTrustedServerCreativeRequest',
-      'recordTrustedServerCreativeResponse',
-      'recordTrustedServerOpportunity',
-    ]);
-    expect(gpt.queue.push).toHaveBeenCalledTimes(1);
-    expect(gpt.addEventListener).toHaveBeenCalledTimes(6);
-    expect(gpt.addEventListener.mock.calls.map(([name]) => name).sort()).toEqual(
-      [
-        'impressionViewable',
-        'slotOnload',
-        'slotRenderEnded',
-        'slotRequested',
-        'slotResponseReceived',
-        'slotVisibilityChanged',
-      ].sort()
+    expect(api).toBeDefined();
+    expect(Object.isFrozen(api)).toBe(true);
+    expect(Reflect.ownKeys(api ?? {}).sort()).toEqual(
+      ['export', 'hide', 'show', 'snapshot', 'subscribe'].sort()
+    );
+    expect(legacyTarget['__tsjs_gpt_diagnostics_active']).toBeUndefined();
+    expect(legacyTarget['__tsjs_gpt_diagnostics_runtime']).toBeUndefined();
+    expect((legacyTarget['tsjs'] as Record<string, unknown> | undefined)?.['gptDiagnostics']).toBe(
+      undefined
     );
     expect(document.querySelectorAll(`#${GPT_DIAGNOSTICS_HOST_ID}`)).toHaveLength(1);
+
+    expect(() => runtime.activate()).toThrow(/already active/i);
+    release();
+    release();
+    expect(runtime.currentApi()).toBeUndefined();
+    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
   });
 
-  it('keeps capture active while presentation is hidden', async () => {
-    target.__tsjs_gpt_diagnostics_active = true;
-    const gpt = installGptStub();
-    const api = installGptDiagnosticsRuntime(target)!;
+  it('replays buffered facts and keeps capture active while presentation is hidden', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
     const observedSlot = slot('hidden-slot');
+    buffer.publish(fact('slotRequested', observedSlot));
+    buffer.publish(fact('slotResponseReceived', observedSlot));
+    const runtime = createGptDiagnosticsRuntime(buffer, { window, document });
 
+    const release = runtime.activate();
+    const api = runtime.currentApi();
+    if (!api) throw new Error('Expected active diagnostics API');
     api.hide();
-    gpt.emit('slotRequested', { slot: observedSlot });
-    gpt.emit('slotResponseReceived', { slot: observedSlot });
-    gpt.emit('slotRenderEnded', { slot: observedSlot, isEmpty: false, size: [300, 250] });
-    await settle();
+    buffer.publish(
+      fact('slotRenderEnded', observedSlot, {
+        isEmpty: false,
+        size: Object.freeze([300, 250]),
+      })
+    );
 
     expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
-    expect(api.snapshot().slots[0].requests).toHaveLength(1);
-    expect(api.snapshot().slots[0].requests[0].isEmpty).toBe(false);
+    expect(api.snapshot().slots[0]?.requests[0]).toMatchObject({
+      requestNumber: 1,
+      isEmpty: false,
+      size: [300, 250],
+    });
 
     api.show();
     expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).not.toBeNull();
+    release();
   });
 
-  it('keeps lifecycle, overlap issues, bindings, panel, and export snapshot consistent', async () => {
-    target.__tsjs_gpt_diagnostics_active = true;
-    const gpt = installGptStub();
-    const element = document.createElement('div');
-    element.id = 'lifecycle-slot';
-    vi.spyOn(element, 'getBoundingClientRect').mockReturnValue({
-      left: 20,
-      top: 100,
-      right: 320,
-      bottom: 350,
-      width: 300,
-      height: 250,
-      x: 20,
-      y: 100,
-      toJSON: () => ({}),
-    } as DOMRect);
-    document.body.append(element);
-    const api = installGptDiagnosticsRuntime(target)!;
-    const observedSlot = slot('lifecycle-slot');
-
-    gpt.emit('slotRequested', { slot: observedSlot });
-    gpt.emit('slotResponseReceived', { slot: observedSlot });
-    gpt.emit('slotRenderEnded', {
-      slot: observedSlot,
-      isEmpty: false,
-      size: [300, 250],
-      isBackfill: true,
-    });
-    gpt.emit('slotOnload', { slot: observedSlot });
-    gpt.emit('impressionViewable', { slot: observedSlot });
-    gpt.emit('slotVisibilityChanged', { slot: observedSlot, inViewPercentage: 75 });
-    gpt.emit('slotRequested', { slot: observedSlot });
-    gpt.emit('slotResponseReceived', { slot: observedSlot });
-    gpt.emit('slotRenderEnded', { slot: observedSlot, isEmpty: true });
-    gpt.emit('slotRequested', { slot: observedSlot });
-    gpt.emit('slotRequested', { slot: observedSlot });
-    gpt.emit('slotResponseReceived', { slot: observedSlot });
-    await settle();
-
-    const snapshot = api.snapshot();
-    expect(snapshot.slots).toHaveLength(1);
-    expect(snapshot.slots[0]).toMatchObject({
-      slotElementId: 'lifecycle-slot',
-      adUnitPath: '/example/site/lifecycle-slot',
-      binding: { status: 'bound' },
-      currentVisibilityPercentage: 75,
+  it('retains adapter callback timing across delayed fact-buffer replay', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    const observedSlot = slot('timed-slot');
+    buffer.publish(fact('slotRequested', observedSlot, { observedAtMs: 10 }));
+    buffer.publish(fact('slotResponseReceived', observedSlot, { observedAtMs: 25 }));
+    const runtime = createGptDiagnosticsRuntime(buffer, { window, document });
+
+    const release = runtime.activate();
+    buffer.publish(fact('slotRenderEnded', observedSlot, { observedAtMs: 30, isEmpty: false }));
+
+    expect(runtime.currentApi()?.snapshot().slots[0]?.requests[0]).toMatchObject({
+      requestedAtMs: 10,
+      responseAtMs: 25,
+      renderAtMs: 30,
+      durations: { requestToResponseMs: 15, responseToRenderMs: 5, requestToRenderMs: 20 },
     });
-    expect(snapshot.slots[0].requests.map((cycle) => cycle.requestNumber)).toEqual([1, 2, 3, 4]);
-    expect(snapshot.callbackIssues).toContainEqual(
-      expect.objectContaining({
-        kind: 'slotResponseReceived',
-        disposition: 'ambiguous',
-        reason: 'overlapping_request_cycles',
-      })
-    );
-    expect(snapshot.coverage.slotResponseReceived.observed).toBe(
-      snapshot.coverage.slotResponseReceived.matched +
-        snapshot.coverage.slotResponseReceived.unmatched +
-        snapshot.coverage.slotResponseReceived.ambiguous
-    );
-    expect(document.querySelector(`#${GPT_DIAGNOSTICS_HOST_ID}`)).not.toBeNull();
-    expect(document.querySelectorAll(`#${GPT_DIAGNOSTICS_HOST_ID}`)).toHaveLength(1);
-    expect(element.getAttributeNames()).toEqual(['id']);
+    release();
   });
 
-  it('removes both diagnostics channels on teardown', () => {
-    target.__tsjs_gpt_diagnostics_active = true;
-    installGptStub();
-    installGptDiagnosticsRuntime(target);
-
-    expect(target.tsjs?.gptDiagnostics).toBeDefined();
-    expect(target.tsjs?.gptDiagnosticsRecorder).toBeDefined();
+  it('releases its consumer so replacement activation receives intervening buffered facts', () => {
+    const buffer = createGptDiagnosticsFactBuffer();
+    const runtime = createGptDiagnosticsRuntime(buffer, { window, document });
+    const firstRelease = runtime.activate();
+    firstRelease();
+    const observedSlot = slot('replacement-slot');
+    buffer.publish(fact('slotRequested', observedSlot));
 
-    target.__tsjs_gpt_diagnostics_runtime!.destroy();
+    const secondRelease = runtime.activate();
 
-    expect(target.tsjs).toBeDefined();
-    expect(target.tsjs?.gptDiagnostics).toBeUndefined();
-    expect(target.tsjs?.gptDiagnosticsRecorder).toBeUndefined();
-    expect(target.__tsjs_gpt_diagnostics_runtime).toBeUndefined();
-  });
-
-  it('leaves no half-initialized API when the core API is unavailable', () => {
-    target.__tsjs_gpt_diagnostics_active = true;
-    delete target.tsjs;
-
-    expect(installGptDiagnosticsRuntime(target)).toBeUndefined();
-    expect(target.__tsjs_gpt_diagnostics_runtime).toBeUndefined();
-    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
+    expect(runtime.currentApi()?.snapshot().slots[0]?.slotElementId).toBe('replacement-slot');
+    secondRelease();
+    buffer.dispose();
   });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/module.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/module.test.ts
new file mode 100644
index 000000000..b85953f2a
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/module.test.ts
@@ -0,0 +1,195 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createGptDiagnosticsIntegrationRegistration } from '../../../src/integrations/gpt_diagnostics/module';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+function capabilities(
+  subscribe: (listener: (fact: Readonly<Record<string, unknown>>) => void) => () => void = vi.fn(
+    () => vi.fn()
+  ),
+  runtimeDocument: unknown = document
+) {
+  return Object.freeze({
+    'runtime.v1': Object.freeze({ document: runtimeDocument }),
+    'gpt.events.v1': Object.freeze({ subscribe }),
+  });
+}
+
+function prepare(
+  interfaces: Readonly<Record<string, unknown>>,
+  preparationRelease: Array<() => void> = []
+): PreparedIntegration {
+  return createGptDiagnosticsIntegrationRegistration(RELEASE_ID).prepare(
+    Object.freeze({
+      config: Object.freeze({ active: true }),
+      interfaces,
+      signal: new AbortController().signal,
+      onDispose: (callback: () => void) => preparationRelease.push(callback),
+    } satisfies IntegrationPrepareContext)
+  ) as PreparedIntegration;
+}
+
+describe('takeover GPT diagnostics data provider', () => {
+  it('accepts a valid foreign-realm Document at the registration boundary', () => {
+    const frame = document.createElement('iframe');
+    document.body.append(frame);
+    const foreignDocument = frame.contentDocument;
+    const foreignWindow = frame.contentWindow;
+    if (!foreignDocument || !foreignWindow) throw new Error('Expected an iframe document realm');
+    const foreignRealm = foreignWindow as Window & typeof globalThis;
+    expect(foreignDocument).not.toBeInstanceOf(window.Document);
+    expect(foreignDocument).toBeInstanceOf(foreignRealm.Document);
+    const releases: Array<() => void> = [];
+
+    expect(() => prepare(capabilities(undefined, foreignDocument), releases)).not.toThrow();
+
+    releases.reverse().forEach((release) => release());
+    frame.remove();
+  });
+
+  it.each([
+    ['plain record', Object.freeze({})],
+    [
+      'counterfeit realm',
+      Object.freeze({ defaultView: Object.freeze({ Document: class CounterfeitDocument {} }) }),
+    ],
+    [
+      'hostile defaultView',
+      Object.freeze(
+        Object.defineProperty({}, 'defaultView', {
+          get: () => {
+            throw new Error('hostile defaultView');
+          },
+        })
+      ),
+    ],
+  ])('rejects a %s runtime Document candidate at the registration boundary', (_name, candidate) => {
+    expect(() => prepare(capabilities(undefined, candidate))).toThrow(
+      'GPT diagnostics requires runtime.v1'
+    );
+  });
+
+  it('prepares inertly, captures the GPT stream only while active, and exposes no presentation', () => {
+    const preparationRelease: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    let publish: ((fact: Readonly<Record<string, unknown>>) => void) | undefined;
+    const releaseEvents = vi.fn();
+    const subscribe = vi.fn((listener: (fact: Readonly<Record<string, unknown>>) => void) => {
+      publish = listener;
+      return releaseEvents;
+    });
+    const prepared = prepare(capabilities(subscribe), preparationRelease);
+    const data = prepared.interfaces?.['gpt_diag.v1'] as {
+      api: {
+        snapshot: () => { slots: readonly Readonly<Record<string, unknown>>[] };
+      };
+      attachPresentation: (controls: Readonly<Record<string, unknown>>) => () => void;
+    };
+
+    expect(Reflect.ownKeys(prepared.interfaces ?? {})).toEqual(['gpt_diag.v1']);
+    expect(Reflect.ownKeys(data)).toEqual(['api', 'attachPresentation']);
+    expect(Object.isFrozen(data)).toBe(true);
+    expect(subscribe).not.toHaveBeenCalled();
+    expect(data.api.snapshot().slots).toEqual([]);
+    expect(document.querySelector('[id^="trusted-server-gpt-diagnostics"]')).toBeNull();
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    expect(subscribe).toHaveBeenCalledOnce();
+    const fact = Object.freeze({
+      kind: 'slotRequested',
+      observedAtMs: 1,
+      slot: Object.freeze({ token: Object.freeze({}) }),
+    });
+    publish?.(fact);
+    expect(data.api.snapshot().slots[0]).toMatchObject({
+      runtimeSlotNumber: 1,
+      binding: { status: 'unbound', reason: 'missing_element' },
+    });
+    expect(document.querySelector('[id^="trusted-server-gpt-diagnostics"]')).toBeNull();
+
+    activationRelease.reverse().forEach((callback) => callback());
+    expect(releaseEvents).toHaveBeenCalledOnce();
+    preparationRelease.reverse().forEach((callback) => callback());
+  });
+
+  it('consumes only runtime.v1 and gpt.events.v1 without inspecting trace capabilities', () => {
+    const traceRead = vi.fn(() => {
+      throw new Error('trace capability must remain unobserved');
+    });
+    const interfaces = Object.freeze(
+      Object.defineProperty(
+        {
+          'runtime.v1': Object.freeze({ document }),
+          'gpt.events.v1': Object.freeze({ subscribe: vi.fn(() => vi.fn()) }),
+        },
+        'trace.v1',
+        { enumerable: true, get: traceRead }
+      )
+    );
+
+    expect(() => prepare(interfaces)).not.toThrow();
+    expect(traceRead).not.toHaveBeenCalled();
+  });
+
+  it('pre-registers rollback before the GPT subscription can throw', () => {
+    const activationRelease: Array<() => void> = [];
+    const prepared = prepare(
+      capabilities(
+        vi.fn(() => {
+          throw new Error('listener collision');
+        })
+      )
+    );
+
+    expect(() =>
+      prepared.activate(
+        Object.freeze({
+          signal: new AbortController().signal,
+          onDispose: (callback: () => void) => activationRelease.push(callback),
+          afterCommit: vi.fn(),
+        } satisfies IntegrationActivationContext)
+      )
+    ).toThrow('listener collision');
+    activationRelease.reverse().forEach((callback) => callback());
+    const data = prepared.interfaces?.['gpt_diag.v1'] as {
+      api: { snapshot: () => { slots: readonly unknown[] } };
+    };
+    expect(data.api.snapshot().slots).toEqual([]);
+  });
+
+  it.each([
+    ['inactive config', Object.freeze({ active: false }), capabilities()],
+    ['mutable config', { active: true }, capabilities()],
+    [
+      'missing GPT event stream',
+      Object.freeze({ active: true }),
+      Object.freeze({
+        'runtime.v1': Object.freeze({ document }),
+      }),
+    ],
+  ])('rejects %s during inert preparation', (_name, config, interfaces) => {
+    const registration = createGptDiagnosticsIntegrationRegistration(RELEASE_ID);
+    expect(() =>
+      registration.prepare(
+        Object.freeze({
+          config,
+          interfaces,
+          signal: new AbortController().signal,
+          onDispose: vi.fn(),
+        } satisfies IntegrationPrepareContext)
+      )
+    ).toThrow();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/observer.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/observer.test.ts
index 47d82697b..0c25e1ea9 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/observer.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/observer.test.ts
@@ -1,438 +1,158 @@
 import { describe, expect, it, vi } from 'vitest';
 
+import type {
+  GoogletagDiagnosticsFact,
+  GoogletagDiagnosticsSlotSnapshot,
+} from '../../../src/adapters/googletag';
 import {
   GptDiagnosticsObserver,
   type GptDiagnosticsObserverStore,
-  type GptObserverWindow,
 } from '../../../src/integrations/gpt_diagnostics/observer';
-import type { GptDiagnosticsSlotLike } from '../../../src/integrations/gpt_diagnostics/store';
-
-const EVENT_NAMES = [
-  'slotRequested',
-  'slotResponseReceived',
-  'slotRenderEnded',
-  'slotOnload',
-  'impressionViewable',
-  'slotVisibilityChanged',
-] as const;
-
-type EventName = (typeof EVENT_NAMES)[number];
-type EventListener = (event: { slot: GptDiagnosticsSlotLike; [key: string]: unknown }) => void;
+import type { GptDiagnosticsFact } from '../../../src/integrations/gpt/diagnostics_facts';
 
 function fakeStore(): GptDiagnosticsObserverStore {
   return {
     markGptObserved: vi.fn(),
+    recordTrustedServerOpportunity: vi.fn(),
     recordSlotRequested: vi.fn(),
     recordSlotResponseReceived: vi.fn(),
     recordSlotRenderEnded: vi.fn(),
     recordSlotOnload: vi.fn(),
     recordImpressionViewable: vi.fn(),
     recordSlotVisibilityChanged: vi.fn(),
-    recordPublisherRefresh: vi.fn(),
-  };
-}
-
-function fakeSlot(): GptDiagnosticsSlotLike {
-  return {
-    getSlotElementId: () => 'ad-slot-example',
-    getAdUnitPath: () => '/example/site/banner',
   };
 }
 
-function controlledGpt() {
-  const listeners = new Map<EventName, EventListener[]>();
-  const addEventListener = vi.fn((name: EventName, listener: EventListener) => {
-    const current = listeners.get(name) ?? [];
-    current.push(listener);
-    listeners.set(name, current);
+function fakeSlot(): GoogletagDiagnosticsSlotSnapshot {
+  return Object.freeze({
+    token: Object.freeze(Object.create(null) as object),
+    elementId: 'ad-slot-example',
+    adUnitPath: '/example/site/banner',
   });
-  const pubads = {
-    addEventListener,
-    refresh: vi.fn(),
-  };
-  const display = vi.fn();
-  const defineSlot = vi.fn();
-  const cmd: Array<() => void> = [];
-  const googletag = {
-    cmd,
-    pubads: () => pubads,
-    display,
-    defineSlot,
-  };
+}
 
-  return {
-    window: { googletag },
-    googletag,
-    pubads,
-    listeners,
-    emit(name: EventName, event: Parameters<EventListener>[0]) {
-      for (const listener of listeners.get(name) ?? []) listener(event);
-    },
-  };
+function fact(
+  kind: GoogletagDiagnosticsFact['kind'],
+  slot: GoogletagDiagnosticsFact['slot'],
+  fields: Partial<GoogletagDiagnosticsFact> = {}
+): Readonly<GoogletagDiagnosticsFact> {
+  return Object.freeze({ kind, observedAtMs: 1, slot, ...fields });
 }
 
 describe('GptDiagnosticsObserver', () => {
-  it('installs exactly the six documented listeners through googletag.cmd', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-
-    observer.install();
-
-    expect(gpt.googletag.cmd).toHaveLength(1);
-    expect(gpt.pubads.addEventListener).not.toHaveBeenCalled();
-
-    gpt.googletag.cmd[0]();
-
-    expect(gpt.pubads.addEventListener).toHaveBeenCalledTimes(EVENT_NAMES.length);
-    expect(gpt.pubads.addEventListener.mock.calls.map(([name]) => name)).toEqual(EVENT_NAMES);
-    expect(store.markGptObserved).toHaveBeenCalledTimes(1);
-  });
-
-  it('is idempotent before and after command queue execution', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-
-    observer.install();
-    observer.install();
-    expect(gpt.googletag.cmd).toHaveLength(1);
-
-    gpt.googletag.cmd[0]();
-    observer.install();
-    gpt.googletag.cmd[0]();
-
-    expect(gpt.pubads.addEventListener).toHaveBeenCalledTimes(EVENT_NAMES.length);
-    expect(store.markGptObserved).toHaveBeenCalledTimes(1);
-  });
-
-  it('observes publisher refresh slots without changing the delegated call', () => {
+  it('records requested-size evidence without claiming a GPT callback observation', () => {
     const store = fakeStore();
-    const gpt = controlledGpt();
+    const observer = new GptDiagnosticsObserver(store);
     const slot = fakeSlot();
-    const receiver = { refresh: gpt.pubads.refresh };
-    const originalRefresh = vi.fn(function (this: unknown, ...args: unknown[]) {
-      return { receiver: this, args };
-    });
-    gpt.pubads.refresh = originalRefresh;
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    observer.install();
-    gpt.googletag.cmd[0]();
-
-    const result = Reflect.apply(gpt.pubads.refresh, receiver, [
-      [slot],
-      { changeCorrelator: false },
-    ]);
-
-    expect(store.recordPublisherRefresh).toHaveBeenCalledWith([slot]);
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(result).toEqual({ receiver, args: [[slot], { changeCorrelator: false }] });
-  });
-
-  it('preserves bare, explicit-undefined, malformed, throwing, and nested refresh behavior', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const slot = fakeSlot();
-    const secondSlot = fakeSlot();
-    const originalRefresh = vi.fn(function (this: unknown, ...args: unknown[]) {
-      if (args[0] === 'throw') throw new Error('refresh failure');
-      return { receiver: this, args };
-    });
-    const getSlots = vi.fn(() => [slot, null, secondSlot]);
-    gpt.pubads.refresh = originalRefresh;
-    Object.assign(gpt.pubads, { getSlots });
-    const runtime = { tsjs: {} };
-    const observer = new GptDiagnosticsObserver(store, { window: { ...gpt.window, ...runtime } });
-    observer.install();
-    gpt.googletag.cmd[0]();
-    observer.install();
-
-    expect(gpt.pubads.refresh()).toEqual({ receiver: gpt.pubads, args: [] });
-    expect(store.recordPublisherRefresh).toHaveBeenLastCalledWith([slot, secondSlot]);
-
-    // GPT treats an omitted, undefined, or null slot list as "refresh all", and
-    // `refresh(null, opts)` is the documented way to pass options while doing so.
-    expect(gpt.pubads.refresh(undefined)).toEqual({ receiver: gpt.pubads, args: [undefined] });
-    expect(gpt.pubads.refresh(null, { changeCorrelator: false })).toEqual({
-      receiver: gpt.pubads,
-      args: [null, { changeCorrelator: false }],
-    });
-    expect(store.recordPublisherRefresh).toHaveBeenCalledTimes(3);
-    expect(store.recordPublisherRefresh).toHaveBeenLastCalledWith([slot, secondSlot]);
-
-    getSlots.mockImplementationOnce(() => {
-      throw new Error('getSlots failure');
-    });
-    expect(gpt.pubads.refresh()).toEqual({ receiver: gpt.pubads, args: [] });
-    expect(() => gpt.pubads.refresh('throw')).toThrow('refresh failure');
-    expect(
-      store.recordPublisherRefresh,
-      'a failed slot lookup records nothing'
-    ).toHaveBeenCalledTimes(3);
-
-    (
-      observer as unknown as { window: { tsjs: { prebidRefreshDispatchInProgress?: boolean } } }
-    ).window.tsjs.prebidRefreshDispatchInProgress = true;
-    gpt.pubads.refresh([slot]);
-    expect(
-      store.recordPublisherRefresh,
-      'a Prebid-delegated refresh is not publisher intent'
-    ).toHaveBeenCalledTimes(3);
-    expect(originalRefresh).toHaveBeenCalledTimes(6);
-  });
-
-  it('delegates when the shared diagnostics context accessor throws', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const slot = fakeSlot();
-    const originalRefresh = vi.fn(() => 'delegated');
-    gpt.pubads.refresh = originalRefresh;
-    Object.assign(gpt.pubads, { getSlots: () => [slot] });
-    const target = { googletag: gpt.googletag } as unknown as GptObserverWindow;
-    Object.defineProperty(target, 'tsjs', {
-      get: () => {
-        throw new Error('context unavailable');
-      },
-    });
-    const observer = new GptDiagnosticsObserver(store, { window: target });
-    observer.install();
-    gpt.googletag.cmd[0]();
-
-    expect(gpt.pubads.refresh()).toBe('delegated');
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(store.recordPublisherRefresh).not.toHaveBeenCalled();
-  });
-
-  it('creates a command queue and waits when GPT is absent', () => {
-    const store = fakeStore();
-    const delayedWindow: {
-      googletag?: {
-        cmd: Array<() => void>;
-        pubads?: () => { addEventListener: (name: EventName, listener: EventListener) => void };
-      };
-    } = {};
-    const observer = new GptDiagnosticsObserver(store, { window: delayedWindow });
-
-    observer.install();
-
-    expect(delayedWindow.googletag?.cmd).toHaveLength(1);
-    const gpt = controlledGpt();
-    delayedWindow.googletag!.pubads = gpt.googletag.pubads;
-    delayedWindow.googletag!.cmd[0]();
-
-    expect(gpt.pubads.addEventListener).toHaveBeenCalledTimes(EVENT_NAMES.length);
-  });
-
-  it('preserves an already-loaded custom command push contract', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const callbacks: Array<() => void> = [];
-    const customPush = vi.fn((...next: Array<() => void>) => {
-      callbacks.push(...next);
-      for (const callback of next) callback();
-      return callbacks.length;
-    });
-    const observer = new GptDiagnosticsObserver(store, {
-      window: {
-        googletag: {
-          cmd: { push: customPush },
-          pubads: gpt.googletag.pubads,
-        },
-      },
+    const opportunity = Object.freeze({
+      kind: 'trustedServerOpportunity' as const,
+      auctionSlotId: 'fictional-slot',
+      opportunity: 'renderable_candidate' as const,
+      requestedSlotSizes: Object.freeze([Object.freeze([300, 250] as const)]),
+      slot,
+      trustedServerAuctionId: 'fictional-auction',
     });
 
-    observer.install();
+    observer.consume(opportunity as Readonly<GptDiagnosticsFact>);
 
-    expect(customPush).toHaveBeenCalledTimes(1);
-    expect(gpt.pubads.addEventListener).toHaveBeenCalledTimes(EVENT_NAMES.length);
+    expect(store.markGptObserved).not.toHaveBeenCalled();
+    expect(store.recordTrustedServerOpportunity).toHaveBeenCalledWith(
+      slot,
+      'fictional-slot',
+      'renderable_candidate',
+      'fictional-auction',
+      [[300, 250]]
+    );
   });
 
-  it('normalizes allowed callback facts and forwards every event kind', () => {
+  it('does not claim GPT observation merely because the diagnostics module activated', () => {
     const store = fakeStore();
-    const gpt = controlledGpt();
-    const slot = fakeSlot();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    observer.install();
-    gpt.googletag.cmd[0]();
+    const observer = new GptDiagnosticsObserver(store);
 
-    gpt.emit('slotRequested', { slot });
-    gpt.emit('slotResponseReceived', { slot });
-    gpt.emit('slotRenderEnded', {
-      slot,
-      isEmpty: false,
-      size: [300, 250],
-      isBackfill: true,
-      slotContentChanged: false,
-      creativeId: 'must-not-pass-through',
-    });
-    gpt.emit('slotOnload', { slot });
-    gpt.emit('impressionViewable', { slot });
-    gpt.emit('slotVisibilityChanged', { slot, inViewPercentage: 42 });
+    observer.start();
+    observer.start();
 
-    expect(store.recordSlotRequested).toHaveBeenCalledWith(slot);
-    expect(store.recordSlotResponseReceived).toHaveBeenCalledWith(slot);
-    expect(store.recordSlotRenderEnded).toHaveBeenCalledWith(slot, {
-      isEmpty: false,
-      size: [300, 250],
-      isBackfill: true,
-      slotContentChanged: false,
-    });
-    expect(store.recordSlotOnload).toHaveBeenCalledWith(slot);
-    expect(store.recordImpressionViewable).toHaveBeenCalledWith(slot);
-    expect(store.recordSlotVisibilityChanged).toHaveBeenCalledWith(slot, 42);
+    expect(store.markGptObserved).not.toHaveBeenCalled();
   });
 
-  it('forwards the Ad Manager identifiers GPT reports for the delivered ad', () => {
+  it('consumes all six normalized adapter facts', () => {
     const store = fakeStore();
-    const gpt = controlledGpt();
     const slot = fakeSlot();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    observer.install();
-    gpt.googletag.cmd[0]();
-
-    gpt.emit('slotRenderEnded', {
-      slot,
-      isEmpty: false,
-      lineItemId: 6543210987,
-      creativeId: 1234567890,
-      campaignId: 2345678901,
-      advertiserId: 3456789012,
-      sourceAgnosticLineItemId: 6543210987,
-      yieldGroupIds: [11, 12],
-      companyIds: [],
-    });
+    const observer = new GptDiagnosticsObserver(store);
+
+    observer.consume(fact('slotRequested', slot));
+    observer.consume(fact('slotResponseReceived', slot));
+    observer.consume(
+      fact('slotRenderEnded', slot, {
+        isEmpty: false,
+        size: Object.freeze([300, 250]),
+        isBackfill: true,
+        slotContentChanged: false,
+      })
+    );
+    observer.consume(fact('slotOnload', slot));
+    observer.consume(fact('impressionViewable', slot));
+    observer.consume(fact('slotVisibilityChanged', slot, { inViewPercentage: 42 }));
 
+    expect(store.markGptObserved).toHaveBeenCalledOnce();
+    expect(store.recordSlotRequested).toHaveBeenCalledWith(slot, 1);
+    expect(store.recordSlotResponseReceived).toHaveBeenCalledWith(slot, 1);
     expect(store.recordSlotRenderEnded).toHaveBeenCalledWith(
       slot,
-      expect.objectContaining({
-        adManager: {
-          lineItemId: 6543210987,
-          creativeId: 1234567890,
-          campaignId: 2345678901,
-          advertiserId: 3456789012,
-          sourceAgnosticLineItemId: 6543210987,
-          yieldGroupIds: [11, 12],
-        },
-      })
+      {
+        isEmpty: false,
+        size: [300, 250],
+        isBackfill: true,
+        slotContentChanged: false,
+      },
+      1
     );
+    expect(store.recordSlotOnload).toHaveBeenCalledWith(slot, 1);
+    expect(store.recordImpressionViewable).toHaveBeenCalledWith(slot, 1);
+    expect(store.recordSlotVisibilityChanged).toHaveBeenCalledWith(slot, 42, 1);
   });
 
-  it('drops malformed Ad Manager identifiers instead of reporting them', () => {
+  it('passes the immutable adapter callback timestamp through to every store mutation', () => {
     const store = fakeStore();
-    const gpt = controlledGpt();
+    const observer = new GptDiagnosticsObserver(store);
     const slot = fakeSlot();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    observer.install();
-    gpt.googletag.cmd[0]();
-
-    gpt.emit('slotRenderEnded', {
+    const timestamped = Object.freeze({
+      kind: 'slotRequested' as const,
       slot,
-      isEmpty: false,
-      lineItemId: null,
-      creativeId: '1234567890',
-      campaignId: 0,
-      advertiserId: 1.5,
-      yieldGroupIds: 'not-a-list',
+      observedAtMs: 123.5,
     });
 
-    expect(store.recordSlotRenderEnded).toHaveBeenCalledWith(
-      slot,
-      expect.objectContaining({ adManager: undefined })
-    );
+    observer.consume(timestamped as Readonly<GoogletagDiagnosticsFact>);
+
+    expect(store.recordSlotRequested).toHaveBeenCalledWith(slot, 123.5);
   });
 
-  it('drops unsupported or invalid rendered sizes', () => {
+  it('records a malformed visibility fact as unmatched instead of dropping its coverage', () => {
     const store = fakeStore();
-    const gpt = controlledGpt();
-    const slot = fakeSlot();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    observer.install();
-    gpt.googletag.cmd[0]();
+    const observer = new GptDiagnosticsObserver(store);
 
-    gpt.emit('slotRenderEnded', { slot, isEmpty: false, size: 'fluid' });
+    observer.consume(fact('slotVisibilityChanged', fakeSlot()));
 
-    expect(store.recordSlotRenderEnded).toHaveBeenCalledWith(
-      slot,
-      expect.objectContaining({ size: undefined })
-    );
+    expect(store.recordSlotVisibilityChanged).toHaveBeenCalledWith(expect.any(Object), NaN, 1);
   });
 
-  it('contains callback and Slot accessor failures and warns', () => {
+  it('contains store and logger failures without interrupting later facts', () => {
     const store = fakeStore();
     vi.mocked(store.recordSlotRequested).mockImplementation(() => {
       throw new Error('store failed');
     });
-    const logger = { warn: vi.fn() };
-    const gpt = controlledGpt();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window, logger });
-    observer.install();
-    gpt.googletag.cmd[0]();
-    const event = {
-      get slot(): GptDiagnosticsSlotLike {
-        throw new Error('slot accessor failed');
-      },
-    };
-
-    expect(() => gpt.emit('slotRequested', { slot: fakeSlot() })).not.toThrow();
-    expect(() => gpt.emit('slotOnload', event)).not.toThrow();
-    expect(logger.warn).toHaveBeenCalledTimes(2);
-  });
-
-  it('contains command queue and listener installation failures', () => {
-    const store = fakeStore();
-    const logger = { warn: vi.fn() };
-    const queueObserver = new GptDiagnosticsObserver(store, {
-      window: {
-        googletag: {
-          cmd: {
-            push: () => {
-              throw new Error('queue failed');
-            },
-          },
-        },
-      },
-      logger,
-    });
-
-    expect(() => queueObserver.install()).not.toThrow();
-
-    const gpt = controlledGpt();
-    gpt.pubads.addEventListener.mockImplementation(() => {
-      throw new Error('listener failed');
-    });
-    const listenerObserver = new GptDiagnosticsObserver(store, {
-      window: gpt.window,
-      logger,
-    });
-    listenerObserver.install();
-
-    expect(() => gpt.googletag.cmd[0]()).not.toThrow();
-    expect(logger.warn).toHaveBeenCalledTimes(2);
-  });
-
-  it('wraps only PubAds refresh and leaves unrelated GPT and browser methods intact', () => {
-    const store = fakeStore();
-    const gpt = controlledGpt();
-    const observer = new GptDiagnosticsObserver(store, { window: gpt.window });
-    const references = {
-      display: gpt.googletag.display,
-      defineSlot: gpt.googletag.defineSlot,
-      refresh: gpt.pubads.refresh,
-      fetch: window.fetch,
-      XMLHttpRequest: window.XMLHttpRequest,
-      pushState: window.history.pushState,
-      replaceState: window.history.replaceState,
+    const logger = {
+      warn: vi.fn(() => {
+        throw new Error('logger failed');
+      }),
     };
+    const observer = new GptDiagnosticsObserver(store, { logger });
+    const slot = fakeSlot();
 
-    observer.install();
-    gpt.googletag.cmd[0]();
+    expect(() => observer.consume(fact('slotRequested', slot))).not.toThrow();
+    expect(() => observer.consume(fact('slotOnload', slot))).not.toThrow();
 
-    expect(gpt.googletag.display).toBe(references.display);
-    expect(gpt.googletag.defineSlot).toBe(references.defineSlot);
-    expect(gpt.pubads.refresh).not.toBe(references.refresh);
-    expect(window.fetch).toBe(references.fetch);
-    expect(window.XMLHttpRequest).toBe(references.XMLHttpRequest);
-    expect(window.history.pushState).toBe(references.pushState);
-    expect(window.history.replaceState).toBe(references.replaceState);
+    expect(logger.warn).toHaveBeenCalledOnce();
+    expect(store.recordSlotOnload).toHaveBeenCalledWith(slot, 1);
   });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/overlay.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/overlay.test.ts
index 41cad667a..b468308d4 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/overlay.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/overlay.test.ts
@@ -75,6 +75,16 @@ function slotArticle(root: ShadowRoot, slotElementId: string): HTMLElement {
   return article;
 }
 
+function queueFrame(frames: Array<() => void>): (callback: () => void) => () => void {
+  return (callback) => {
+    frames.push(callback);
+    return () => {
+      const index = frames.indexOf(callback);
+      if (index >= 0) frames.splice(index, 1);
+    };
+  };
+}
+
 beforeEach(() => {
   document.body.replaceChildren();
   vi.spyOn(document, 'readyState', 'get').mockReturnValue('complete');
@@ -92,7 +102,7 @@ describe('GptDiagnosticsOverlay', () => {
     store.recordSlotRequested(slot('early-slot'));
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, new FakeBindings(), {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
       },
@@ -235,7 +245,7 @@ describe('GptDiagnosticsOverlay', () => {
 
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, bindings, {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
       },
@@ -375,7 +385,7 @@ describe('GptDiagnosticsOverlay', () => {
 
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, new FakeBindings(), {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
       },
@@ -452,7 +462,7 @@ describe('GptDiagnosticsOverlay', () => {
     const exportSnapshot = vi.fn();
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, bindings, {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onExport: exportSnapshot,
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
@@ -530,7 +540,7 @@ describe('GptDiagnosticsOverlay', () => {
     document.body.append(publisherElement);
     const warn = vi.spyOn(log, 'warn');
     const overlay = new GptDiagnosticsOverlay(new GptDiagnosticsStore(), new FakeBindings(), {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
     });
     runNextFrame(frames);
     runNextFrame(frames);
@@ -559,7 +569,7 @@ describe('GptDiagnosticsOverlay', () => {
     store.recordSlotRequested(diagnosticSlot);
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, new FakeBindings(), {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
       },
@@ -585,7 +595,7 @@ describe('GptDiagnosticsOverlay', () => {
     const store = new GptDiagnosticsStore();
     let root: ShadowRoot | undefined;
     const overlay = new GptDiagnosticsOverlay(store, new FakeBindings(), {
-      scheduleFrame: (callback) => frames.push(callback),
+      scheduleFrame: queueFrame(frames),
       onShadowRoot: (createdRoot) => {
         root = createdRoot;
       },
@@ -619,4 +629,50 @@ describe('GptDiagnosticsOverlay', () => {
     expect(document.querySelectorAll(`#${GPT_DIAGNOSTICS_HOST_ID}`)).toHaveLength(1);
     overlay.destroy();
   });
+
+  it('cancels a pending mount frame on destroy and suppresses a hostile late callback', () => {
+    const frames: Array<() => void> = [];
+    const cancel = vi.fn();
+    const overlay = new GptDiagnosticsOverlay(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: (callback) => {
+        frames.push(callback);
+        return cancel;
+      },
+    });
+
+    overlay.destroy();
+    frames[0]?.();
+
+    expect(cancel).toHaveBeenCalledOnce();
+    expect(frames).toHaveLength(1);
+    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
+  });
+
+  it('runs one scheduled mount callback at most once', () => {
+    const frames: Array<() => void> = [];
+    const overlay = new GptDiagnosticsOverlay(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: (callback) => {
+        frames.push(callback);
+        return vi.fn();
+      },
+    });
+
+    frames[0]?.();
+    frames[0]?.();
+
+    expect(frames).toHaveLength(2);
+    overlay.destroy();
+  });
+
+  it('isolates a hostile frame cancellation during destroy', () => {
+    const cancel = vi.fn(() => {
+      throw new Error('cancel failed');
+    });
+    const overlay = new GptDiagnosticsOverlay(new GptDiagnosticsStore(), new FakeBindings(), {
+      scheduleFrame: () => cancel,
+    });
+
+    expect(() => overlay.destroy()).not.toThrow();
+    expect(cancel).toHaveBeenCalledOnce();
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/presentation.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/presentation.test.ts
new file mode 100644
index 000000000..c1fa38212
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/presentation.test.ts
@@ -0,0 +1,473 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  GptDiagnosticsDataApiController,
+  type GptDiagnosticsPresentationFactory,
+} from '../../../src/integrations/gpt_diagnostics/data_api';
+import { GPT_DIAGNOSTICS_HOST_ID } from '../../../src/integrations/gpt_diagnostics/overlay';
+import {
+  createDiagnosticsPresentationIntegrationRegistration,
+  createRenderTracePresentation,
+} from '../../../src/integrations/gpt_diagnostics/presentation';
+import { GptDiagnosticsStore } from '../../../src/integrations/gpt_diagnostics/store';
+import { createRenderTraceStore } from '../../../src/core/trace';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+let frames: Array<() => void> = [];
+
+beforeEach(() => {
+  document.body.replaceChildren();
+  frames = [];
+  vi.spyOn(document, 'readyState', 'get').mockReturnValue('complete');
+  vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
+    const frame = () => callback(0);
+    frames.push(frame);
+    return frames.length;
+  });
+  vi.stubGlobal('cancelAnimationFrame', vi.fn());
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  document.body.replaceChildren();
+});
+
+function drainFrames(): void {
+  let count = 0;
+  while (frames.length > 0 && count < 16) {
+    frames.shift()?.();
+    count += 1;
+  }
+  if (frames.length > 0) throw new Error('Diagnostics presentation did not quiesce');
+}
+
+function presentationInterfaces(runtimeDocument: unknown) {
+  return Object.freeze({
+    'runtime.v1': Object.freeze({
+      boot: () =>
+        Object.freeze({
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: true,
+            gpt: Object.freeze({ active: false }),
+          }),
+        }),
+      document: runtimeDocument,
+    }),
+    'trace.presentation.v1': Object.freeze({
+      attachPresentation: vi.fn(() => vi.fn()),
+    }),
+  });
+}
+
+function preparePresentation(runtimeDocument: unknown): PreparedIntegration {
+  return createDiagnosticsPresentationIntegrationRegistration(RELEASE_ID).prepare(
+    Object.freeze({
+      config: undefined,
+      interfaces: presentationInterfaces(runtimeDocument),
+      signal: new AbortController().signal,
+      onDispose: vi.fn(),
+    } satisfies IntegrationPrepareContext)
+  ) as PreparedIntegration;
+}
+
+describe('deferred GPT diagnostics presentation integration', () => {
+  it('binds a foreign-realm slot mutation and renders its badge through the registration', async () => {
+    const frame = document.createElement('iframe');
+    document.body.append(frame);
+    const foreignDocument = frame.contentDocument;
+    const foreignWindow = frame.contentWindow;
+    if (!foreignDocument || !foreignWindow) throw new Error('Expected an iframe document realm');
+    const foreignRealm = foreignWindow as Window & typeof globalThis;
+    vi.spyOn(foreignDocument, 'readyState', 'get').mockReturnValue('complete');
+    Object.defineProperty(foreignWindow, 'CSS', {
+      configurable: true,
+      value: Object.freeze({
+        escape: (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, '\\$&'),
+      }),
+    });
+    const replaceChildren = vi.spyOn(foreignRealm.Element.prototype, 'replaceChildren');
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const slotToken = Object.freeze({
+      getAdUnitPath: () => '/foreign/slot',
+      getSlotElementId: () => 'foreign-mutation-slot',
+    });
+    store.recordSlotRequested(slotToken, 1);
+    const controller = new GptDiagnosticsDataApiController(store, {
+      location: foreignWindow.location,
+      schedule: (callback) => {
+        callback();
+        return () => undefined;
+      },
+    });
+    const releases: Array<() => void> = [];
+    const prepared = createDiagnosticsPresentationIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({
+          'runtime.v1': Object.freeze({
+            boot: () =>
+              Object.freeze({
+                diagnostics: Object.freeze({
+                  version: 1,
+                  renderTraceOverlay: false,
+                  gpt: Object.freeze({ active: true }),
+                }),
+              }),
+            document: foreignDocument,
+          }),
+          'trace.presentation.v1': Object.freeze({
+            attachPresentation: vi.fn(() => vi.fn()),
+          }),
+          'gpt_diag.v1': Object.freeze({
+            api: controller.api,
+            attachPresentation: (factory: GptDiagnosticsPresentationFactory) =>
+              controller.attachPresentation(factory),
+          }),
+        }),
+        signal: new AbortController().signal,
+        onDispose: vi.fn(),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (release: () => void) => releases.push(release),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    drainFrames();
+    expect(controller.api.snapshot().slots[0]?.binding).toEqual({
+      status: 'unbound',
+      reason: 'missing_element',
+    });
+
+    const foreignSlot = foreignDocument.createElement('div');
+    foreignSlot.id = 'foreign-mutation-slot';
+    vi.spyOn(foreignSlot, 'getBoundingClientRect').mockReturnValue({
+      bottom: 260,
+      height: 250,
+      left: 10,
+      right: 310,
+      top: 10,
+      width: 300,
+      x: 10,
+      y: 10,
+      toJSON: () => ({}),
+    } as DOMRect);
+    expect(foreignSlot).toBeInstanceOf(foreignRealm.Element);
+    expect(foreignSlot).not.toBeInstanceOf(window.Element);
+    foreignDocument.body.append(foreignSlot);
+
+    await vi.waitFor(() => {
+      drainFrames();
+      expect(controller.api.snapshot().slots[0]?.binding).toEqual({ status: 'bound' });
+    });
+    store.recordSlotRenderEnded(slotToken, { isEmpty: false, size: [300, 250] }, 2);
+    await vi.waitFor(() => {
+      drainFrames();
+      expect(controller.api.snapshot().slots[0]?.requests[0]?.observedSlotSize).toEqual([300, 250]);
+    });
+    const badgeRenderCount = (): number =>
+      replaceChildren.mock.calls.filter((nodes) =>
+        nodes.some(
+          (node) => node instanceof foreignRealm.Element && node.classList.contains('tsgd-badge')
+        )
+      ).length;
+    expect(badgeRenderCount()).toBeGreaterThan(0);
+
+    const renderedBeforeDispose = badgeRenderCount();
+    releases.reverse().forEach((release) => release());
+    expect(replaceChildren.mock.calls[replaceChildren.mock.calls.length - 1]).toEqual([]);
+    foreignSlot.remove();
+    await Promise.resolve();
+    drainFrames();
+    expect(badgeRenderCount()).toBe(renderedBeforeDispose);
+    controller.destroy();
+    frame.remove();
+  });
+
+  it('accepts a valid foreign-realm Document at the registration boundary', () => {
+    const frame = document.createElement('iframe');
+    document.body.append(frame);
+    const foreignDocument = frame.contentDocument;
+    const foreignWindow = frame.contentWindow;
+    if (!foreignDocument || !foreignWindow) throw new Error('Expected an iframe document realm');
+    const foreignRealm = foreignWindow as Window & typeof globalThis;
+    expect(foreignDocument).not.toBeInstanceOf(window.Document);
+    expect(foreignDocument).toBeInstanceOf(foreignRealm.Document);
+
+    expect(() => preparePresentation(foreignDocument)).not.toThrow();
+
+    frame.remove();
+  });
+
+  it.each([
+    ['plain record', Object.freeze({})],
+    [
+      'counterfeit realm',
+      Object.freeze({ defaultView: Object.freeze({ Document: class CounterfeitDocument {} }) }),
+    ],
+    [
+      'hostile defaultView',
+      Object.freeze(
+        Object.defineProperty({}, 'defaultView', {
+          get: () => {
+            throw new Error('hostile defaultView');
+          },
+        })
+      ),
+    ],
+  ])('rejects a %s runtime Document candidate at the registration boundary', (_name, candidate) => {
+    expect(() => preparePresentation(candidate)).toThrow(
+      'diagnostics presentation capability graph is malformed'
+    );
+  });
+
+  it.each(['render trace', 'GPT'] as const)(
+    'throws for an invalid %s presentation disposer so the deferred transaction rolls back',
+    (failedSurface) => {
+      const traceRelease = vi.fn();
+      const gptRelease = vi.fn();
+      const attachTrace = vi.fn(() =>
+        failedSurface === 'render trace' ? (undefined as never) : traceRelease
+      );
+      const attachGpt = vi.fn(() => (failedSurface === 'GPT' ? (undefined as never) : gptRelease));
+      const releases: Array<() => void> = [];
+      const runtime = Object.freeze({
+        boot: () =>
+          Object.freeze({
+            diagnostics: Object.freeze({
+              version: 1,
+              renderTraceOverlay: true,
+              gpt: Object.freeze({ active: true }),
+            }),
+          }),
+        document,
+      });
+      const prepared = createDiagnosticsPresentationIntegrationRegistration(RELEASE_ID).prepare(
+        Object.freeze({
+          config: undefined,
+          interfaces: Object.freeze({
+            'runtime.v1': runtime,
+            'trace.presentation.v1': Object.freeze({
+              attachPresentation: attachTrace,
+            }),
+            'gpt_diag.v1': Object.freeze({
+              api: Object.freeze({}),
+              attachPresentation: attachGpt,
+            }),
+          }),
+          signal: new AbortController().signal,
+          onDispose: vi.fn(),
+        } satisfies IntegrationPrepareContext)
+      ) as PreparedIntegration;
+
+      expect(() =>
+        prepared.activate(
+          Object.freeze({
+            signal: new AbortController().signal,
+            onDispose: (callback: () => void) => releases.push(callback),
+            afterCommit: vi.fn(),
+          } satisfies IntegrationActivationContext)
+        )
+      ).toThrow(
+        failedSurface === 'render trace'
+          ? 'render trace presentation disposer is unavailable'
+          : 'GPT diagnostics presentation disposer is unavailable'
+      );
+      expect(attachTrace).toHaveBeenCalledOnce();
+      expect(attachGpt).toHaveBeenCalledTimes(failedSurface === 'render trace' ? 0 : 1);
+      releases.reverse().forEach((release) => release());
+      expect(traceRelease).toHaveBeenCalledTimes(failedSurface === 'GPT' ? 1 : 0);
+      expect(gptRelease).not.toHaveBeenCalled();
+    }
+  );
+
+  it('uses the target document realm when stamping a render slot', () => {
+    const frame = document.createElement('iframe');
+    document.body.append(frame);
+    const targetDocument = frame.contentDocument;
+    const targetWindow = frame.contentWindow;
+    if (!targetDocument || !targetWindow) throw new Error('Expected an iframe document realm');
+    const targetRealm = targetWindow as Window & typeof globalThis;
+    const slot = targetDocument.createElement('div');
+    slot.id = 'foreign-realm-slot';
+    targetDocument.body.append(slot);
+    expect(slot).toBeInstanceOf(targetRealm.HTMLElement);
+    expect(slot).not.toBeInstanceOf(window.HTMLElement);
+    const renderTrace = createRenderTraceStore();
+    renderTrace.record({
+      slotId: slot.id,
+      elementId: slot.id,
+      path: 'auction',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+
+    const detach = renderTrace.attachPresentation((source) =>
+      createRenderTracePresentation(source, { document: targetDocument })
+    );
+
+    expect(slot.getAttribute('data-ts-rendered')).toBe('true');
+    expect(slot.querySelector('.ts-render-badge')).not.toBeNull();
+    detach();
+    expect(slot.getAttribute('data-ts-rendered')).toBeNull();
+    renderTrace.dispose();
+    frame.remove();
+  });
+
+  it('replays and owns render-trace presentation without GPT diagnostics', () => {
+    const traceTasks: Array<() => void> = [];
+    const renderTrace = createRenderTraceStore({
+      schedule: (callback) => {
+        traceTasks.push(callback);
+        return () => {
+          const index = traceTasks.indexOf(callback);
+          if (index >= 0) traceTasks.splice(index, 1);
+        };
+      },
+    });
+    const diagnostics = renderTrace.diagnostics;
+    const slot = document.createElement('div');
+    slot.id = 'render-overlay-only-slot';
+    document.body.append(slot);
+    renderTrace.record({
+      slotId: slot.id,
+      elementId: slot.id,
+      path: 'ssat',
+      rendered: true,
+      injected: true,
+      visible: true,
+    });
+    const activationRelease: Array<() => void> = [];
+    const runtime = Object.freeze({
+      boot: () =>
+        Object.freeze({
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: true,
+            gpt: Object.freeze({ active: false }),
+          }),
+        }),
+      document,
+    });
+    const trace = Object.freeze({
+      attachPresentation: renderTrace.attachPresentation,
+    });
+    const prepared = createDiagnosticsPresentationIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({
+          'runtime.v1': runtime,
+          'trace.presentation.v1': trace,
+        }),
+        signal: new AbortController().signal,
+        onDispose: vi.fn(),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+
+    expect(traceTasks).toEqual([]);
+    expect(slot.getAttributeNames().filter((name) => name.startsWith('data-ts-'))).toEqual([]);
+    expect(document.getElementById('ts-render-trace-panel')).toBeNull();
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+
+    expect(traceTasks).toEqual([]);
+    expect(slot.getAttribute('data-ts-rendered')).toBe('true');
+    expect(slot.querySelector('.ts-render-badge')).not.toBeNull();
+    expect(document.getElementById('ts-render-trace-panel')?.textContent).toContain(slot.id);
+    expect(renderTrace.diagnostics).toBe(diagnostics);
+
+    renderTrace.enrich(1, { bidder: 'later-bidder' });
+    expect(traceTasks).toHaveLength(1);
+    activationRelease.reverse().forEach((release) => release());
+    expect(traceTasks).toEqual([]);
+    expect(slot.getAttributeNames().filter((name) => name.startsWith('data-ts-'))).toEqual([]);
+    expect(slot.querySelector('.ts-render-badge')).toBeNull();
+    expect(document.getElementById('ts-render-trace-panel')).toBeNull();
+    expect(renderTrace.diagnostics).toBe(diagnostics);
+    renderTrace.dispose();
+  });
+
+  it('owns all DOM presentation after activation and releases it without replacing the API', () => {
+    const store = new GptDiagnosticsStore({ schedule: (callback) => callback() });
+    const renderTrace = createRenderTraceStore();
+    const controller = new GptDiagnosticsDataApiController(store, {
+      location: window.location,
+      schedule: (callback) => {
+        callback();
+        return () => undefined;
+      },
+    });
+    const api = controller.api;
+    const data = Object.freeze({
+      api,
+      attachPresentation: (factory: GptDiagnosticsPresentationFactory) =>
+        controller.attachPresentation(factory),
+    });
+    const preparationRelease: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    const prepared = createDiagnosticsPresentationIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({
+          'runtime.v1': Object.freeze({
+            boot: () =>
+              Object.freeze({
+                diagnostics: Object.freeze({
+                  version: 1,
+                  renderTraceOverlay: false,
+                  gpt: Object.freeze({ active: true }),
+                }),
+              }),
+            document,
+          }),
+          'trace.presentation.v1': Object.freeze({
+            attachPresentation: renderTrace.attachPresentation,
+          }),
+          'gpt_diag.v1': data,
+        }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => preparationRelease.push(callback),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+
+    expect(controller.api).toBe(api);
+    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
+    expect(frames).toEqual([]);
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    drainFrames();
+
+    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).not.toBeNull();
+    expect(controller.api).toBe(api);
+    activationRelease.reverse().forEach((release) => release());
+    expect(document.getElementById(GPT_DIAGNOSTICS_HOST_ID)).toBeNull();
+    expect(controller.api).toBe(api);
+
+    preparationRelease.reverse().forEach((release) => release());
+    controller.destroy();
+    renderTrace.dispose();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/slot_size_observer.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/slot_size_observer.test.ts
index 3709221ab..7b958fbb1 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/slot_size_observer.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/slot_size_observer.test.ts
@@ -74,7 +74,7 @@ describe('GptDiagnosticsSlotSizeObserver', () => {
     const getBoundingClientRect = vi.spyOn(element, 'getBoundingClientRect');
     getBoundingClientRect.mockReturnValue({ width: 728.4, height: 90.5 } as DOMRect);
     const requests = [cycle(1, false)];
-    requests[0].size = [1, 1];
+    requests[0]!.size = [1, 1];
     const store = {
       snapshot: () => snapshot(requests),
       recordObservedSlotSize: vi.fn(),
@@ -91,7 +91,7 @@ describe('GptDiagnosticsSlotSizeObserver', () => {
     });
 
     expect(store.recordObservedSlotSize).toHaveBeenCalledWith(1, 1, [728, 91]);
-    expect(requests[0].size).toEqual([1, 1]);
+    expect(requests[0]!.size).toEqual([1, 1]);
 
     getBoundingClientRect.mockReturnValue({ width: 969.6, height: 250.2 } as DOMRect);
     ResizeObserverMock.instances[ResizeObserverMock.instances.length - 1]!.emit(element);
@@ -248,10 +248,10 @@ describe('GptDiagnosticsSlotSizeObserver', () => {
       } as unknown as SlotSizeTestWindow,
       scheduleFrame: (callback) => frames.push(callback),
     });
-    const firstObserver = ResizeObserverMock.instances[0];
+    const firstObserver = ResizeObserverMock.instances[0]!;
 
     requests.push(cycle(2, false));
-    listeners[0]();
+    listeners[0]!();
     frames.shift()!();
     firstObserver.emit(element);
     while (frames.length > 0) frames.shift()!();
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/store.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/store.test.ts
index 52aef6a7f..992938a55 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/store.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/store.test.ts
@@ -10,7 +10,6 @@ import {
   MAX_REQUESTED_SLOT_SIZES,
   MAX_REQUEST_CYCLES_PER_SLOT,
   MAX_TRUSTED_SERVER_ASSOCIATIONS,
-  REQUEST_PATH_ATTRIBUTION_WINDOW_MS,
   TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS,
   type GptDiagnosticsSlotLike,
 } from '../../../src/integrations/gpt_diagnostics/store';
@@ -30,32 +29,6 @@ function associateSlot(
   store.recordTrustedServerOpportunity(slot, auctionSlotId, 'renderable_candidate');
 }
 
-function recordCompletedAttempts(
-  store: GptDiagnosticsStore,
-  count: number,
-  prefix: string
-): number[] {
-  const attemptIds: number[] = [];
-  let remaining = count;
-
-  for (let slotIndex = 0; remaining > 0; slotIndex += 1) {
-    const slot = fakeSlot(`${prefix}-slot-${slotIndex}`);
-    const auctionSlotId = `${prefix}-auction-${slotIndex}`;
-    associateSlot(store, slot, auctionSlotId);
-    const cycles = Math.min(MAX_REQUEST_CYCLES_PER_SLOT, remaining);
-    for (let cycleIndex = 0; cycleIndex < cycles; cycleIndex += 1) {
-      store.recordSlotRequested(slot);
-      const attemptId = store.recordTrustedServerCreativeRequest(auctionSlotId);
-      expect(attemptId).toEqual(expect.any(Number));
-      attemptIds.push(attemptId!);
-      store.recordTrustedServerCreativeResponse(attemptId!);
-      remaining -= 1;
-    }
-  }
-
-  return attemptIds;
-}
-
 function assertCoverageEquation(store: GptDiagnosticsStore): void {
   for (const counters of Object.values(store.snapshot().coverage)) {
     expect(counters.observed).toBe(counters.matched + counters.unmatched + counters.ambiguous);
@@ -67,6 +40,17 @@ function last<T>(values: readonly T[]): T | undefined {
 }
 
 describe('GptDiagnosticsStore', () => {
+  it('adopts an explicit first-display runtime slot number and advances its high-water value', () => {
+    const store = new GptDiagnosticsStore();
+    const adoptedToken = {};
+
+    store.recordSlotRequested({ token: adoptedToken, runtimeSlotNumber: 5, elementId: 'adopted' });
+    store.recordSlotRequested({ token: {}, elementId: 'fresh' });
+
+    expect(store.snapshot().slots.map(({ runtimeSlotNumber }) => runtimeSlotNumber)).toEqual([
+      5, 6,
+    ]);
+  });
   it('uses the explicit creative-attempt and attribution retention bounds', () => {
     expect(CREATIVE_ATTEMPT_WINDOW_MS).toBe(30_000);
     expect(MAX_CREATIVE_ATTEMPTS).toBe(128);
@@ -98,8 +82,8 @@ describe('GptDiagnosticsStore', () => {
     store.recordSlotVisibilityChanged(slot, 20);
 
     const snapshot = store.snapshot();
-    const recordedSlot = snapshot.slots[0];
-    const cycle = recordedSlot.requests[0];
+    const recordedSlot = snapshot.slots[0]!;
+    const cycle = recordedSlot.requests[0]!;
 
     expect(snapshot.gptObserved).toBe(true);
     expect(recordedSlot).toMatchObject({
@@ -133,51 +117,20 @@ describe('GptDiagnosticsStore', () => {
     assertCoverageEquation(store);
   });
 
-  it('matches the unique response-bearing load that arrives before render', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const slot = fakeSlot('early-load');
+  it('uses adapter callback times even when buffered delivery occurs much later', () => {
+    const store = new GptDiagnosticsStore({ now: () => 9_999 });
+    const slot = fakeSlot('buffered-slot');
 
-    store.recordSlotRequested(slot);
-    now = 2;
-    store.recordSlotResponseReceived(slot);
-    now = 3;
-    store.recordSlotOnload(slot);
-    now = 4;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
+    store.recordSlotRequested(slot, 10);
+    store.recordSlotResponseReceived(slot, 25);
+    store.recordSlotRenderEnded(slot, { isEmpty: false }, 30);
 
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle).toMatchObject({
-      loadAtMs: 3,
-      loadObservedBeforeRender: true,
-      incompleteSequence: false,
+    expect(store.snapshot().slots[0]?.requests[0]).toMatchObject({
+      requestedAtMs: 10,
+      responseAtMs: 25,
+      renderAtMs: 30,
+      durations: { requestToResponseMs: 15, responseToRenderMs: 5, requestToRenderMs: 20 },
     });
-    expect(cycle.durations.renderToLoadMs).toBeUndefined();
-    expect(store.snapshot().callbackIssues).not.toContainEqual(
-      expect.objectContaining({ kind: 'slotOnload', reason: 'invalid_event_order' })
-    );
-  });
-
-  it('keeps no-response loads unmatched and overlapping response-bearing loads ambiguous', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const missingResponse = fakeSlot('missing-load-response');
-    store.recordSlotRequested(missingResponse);
-    store.recordSlotOnload(missingResponse);
-    const overlapping = fakeSlot('overlapping-load-response');
-    now = 2;
-    store.recordSlotRequested(overlapping);
-    now = 3;
-    store.recordSlotResponseReceived(overlapping);
-    now = 4;
-    store.recordSlotRequested(overlapping);
-    now = 5;
-    store.recordSlotResponseReceived(overlapping);
-    now = 6;
-    store.recordSlotOnload(overlapping);
-
-    expect(store.snapshot().coverage.slotOnload).toMatchObject({ unmatched: 1, ambiguous: 1 });
-    assertCoverageEquation(store);
   });
 
   it('matches load and viewability after a render with unknown fill state', () => {
@@ -209,9 +162,9 @@ describe('GptDiagnosticsStore', () => {
       viewableAtMs: 8,
       durations: { renderToLoadMs: 2, renderToViewableMs: 5 },
     });
-    expect(emptyCycle.loadAtMs).toBe(8);
-    expect(emptyCycle.viewableAtMs).toBeUndefined();
-    expect(store.snapshot().coverage.slotOnload).toMatchObject({ matched: 2, unmatched: 0 });
+    expect(emptyCycle!.loadAtMs).toBeUndefined();
+    expect(emptyCycle!.viewableAtMs).toBeUndefined();
+    expect(store.snapshot().coverage.slotOnload).toMatchObject({ matched: 1, unmatched: 1 });
     expect(store.snapshot().coverage.impressionViewable).toMatchObject({
       matched: 1,
       unmatched: 1,
@@ -242,10 +195,10 @@ describe('GptDiagnosticsStore', () => {
       .snapshot()
       .slots.map((slot) => slot.requests[0]);
 
-    expect(requestingCycle.incompleteSequence).toBe(false);
-    expect(requestingCycle.responseAtMs).toBeUndefined();
-    expect(respondedCycle.incompleteSequence).toBe(false);
-    expect(respondedCycle.renderAtMs).toBeUndefined();
+    expect(requestingCycle!.incompleteSequence).toBe(false);
+    expect(requestingCycle!.responseAtMs).toBeUndefined();
+    expect(respondedCycle!.incompleteSequence).toBe(false);
+    expect(respondedCycle!.renderAtMs).toBeUndefined();
     expect(emptyCycle).toMatchObject({ isEmpty: true, incompleteSequence: false });
   });
 
@@ -260,7 +213,7 @@ describe('GptDiagnosticsStore', () => {
       store.recordSlotRenderEnded(slot, { isEmpty: request === 1 });
     }
 
-    expect(store.snapshot().slots[0].requests.map((cycle) => cycle.requestNumber)).toEqual([
+    expect(store.snapshot().slots[0]!.requests.map((cycle) => cycle.requestNumber)).toEqual([
       1, 2, 3,
     ]);
     assertCoverageEquation(store);
@@ -291,8 +244,8 @@ describe('GptDiagnosticsStore', () => {
 
     expect(() => store.recordSlotRequested(slot)).not.toThrow();
     expect(store.snapshot().slots[0]).toMatchObject({ runtimeSlotNumber: 1 });
-    expect(store.snapshot().slots[0].slotElementId).toBeUndefined();
-    expect(store.snapshot().slots[0].adUnitPath).toBeUndefined();
+    expect(store.snapshot().slots[0]!.slotElementId).toBeUndefined();
+    expect(store.snapshot().slots[0]!.adUnitPath).toBeUndefined();
   });
 
   it('records callbacks without a request as unmatched issues', () => {
@@ -305,7 +258,7 @@ describe('GptDiagnosticsStore', () => {
     store.recordImpressionViewable(slot);
 
     const snapshot = store.snapshot();
-    expect(snapshot.slots[0].requests).toEqual([]);
+    expect(snapshot.slots[0]!.requests).toEqual([]);
     expect(snapshot.callbackIssues).toHaveLength(4);
     expect(snapshot.callbackIssues.every((issue) => issue.disposition === 'unmatched')).toBe(true);
     expect(
@@ -325,11 +278,11 @@ describe('GptDiagnosticsStore', () => {
     store.recordSlotRenderEnded(slot, { isEmpty: false });
 
     const snapshot = store.snapshot();
-    expect(snapshot.slots[0].requests).toHaveLength(2);
-    expect(snapshot.slots[0].requests.every((cycle) => cycle.responseAtMs === undefined)).toBe(
+    expect(snapshot.slots[0]!.requests).toHaveLength(2);
+    expect(snapshot.slots[0]!.requests.every((cycle) => cycle.responseAtMs === undefined)).toBe(
       true
     );
-    expect(snapshot.slots[0].requests.every((cycle) => cycle.renderAtMs === undefined)).toBe(true);
+    expect(snapshot.slots[0]!.requests.every((cycle) => cycle.renderAtMs === undefined)).toBe(true);
     expect(snapshot.callbackIssues).toMatchObject([
       {
         kind: 'slotResponseReceived',
@@ -357,7 +310,7 @@ describe('GptDiagnosticsStore', () => {
     store.recordSlotResponseReceived(slot);
 
     const snapshot = store.snapshot();
-    const cycle = snapshot.slots[0].requests[0];
+    const cycle = snapshot.slots[0]!.requests[0]!;
     expect(cycle.incompleteSequence).toBe(true);
     expect(cycle.durations.requestToResponseMs).toBe(20);
     expect(cycle.durations.requestToRenderMs).toBe(10);
@@ -389,10 +342,10 @@ describe('GptDiagnosticsStore', () => {
 
     let snapshot = store.snapshot();
     expect(snapshot.slots).toHaveLength(MAX_DIAGNOSTIC_SLOTS);
-    expect(snapshot.slots[0].runtimeSlotNumber).toBe(2);
+    expect(snapshot.slots[0]!.runtimeSlotNumber).toBe(2);
     expect(snapshot.metadata.evictedSlots).toBe(1);
 
-    store.recordSlotResponseReceived(slots[0]);
+    store.recordSlotResponseReceived(slots[0]!);
     snapshot = store.snapshot();
     expect(snapshot.callbackIssues[snapshot.callbackIssues.length - 1]).toMatchObject({
       runtimeSlotNumber: 1,
@@ -400,14 +353,14 @@ describe('GptDiagnosticsStore', () => {
       reason: 'evicted_slot',
     });
 
-    const retainedSlot = slots[slots.length - 1];
+    const retainedSlot = slots[slots.length - 1]!;
     for (let index = 0; index < MAX_REQUEST_CYCLES_PER_SLOT; index += 1) {
       store.recordSlotRequested(retainedSlot);
     }
     snapshot = store.snapshot();
-    const retainedRecord = snapshot.slots[snapshot.slots.length - 1];
+    const retainedRecord = snapshot.slots[snapshot.slots.length - 1]!;
     expect(retainedRecord.requests).toHaveLength(MAX_REQUEST_CYCLES_PER_SLOT);
-    expect(retainedRecord.requests[0].requestNumber).toBe(2);
+    expect(retainedRecord.requests[0]!.requestNumber).toBe(2);
     expect(snapshot.metadata.evictedRequestCycles).toBe(1);
 
     const issueSlot = fakeSlot('issues');
@@ -430,23 +383,23 @@ describe('GptDiagnosticsStore', () => {
       store.recordSlotRequested(retained);
     }
 
-    store.recordSlotVisibilityChanged(slots[0], 10);
-    store.recordSlotRequested(slots[MAX_DIAGNOSTIC_SLOTS]);
+    store.recordSlotVisibilityChanged(slots[0]!, 10);
+    store.recordSlotRequested(slots[MAX_DIAGNOSTIC_SLOTS]!);
     expect(store.snapshot().slots.some((slot) => slot.runtimeSlotNumber === 1)).toBe(true);
     expect(store.snapshot().slots.some((slot) => slot.runtimeSlotNumber === 2)).toBe(false);
 
-    store.recordSlotResponseReceived(slots[1]);
-    expect(last(store.snapshot().callbackIssues)).toMatchObject({
+    store.recordSlotResponseReceived(slots[1]!);
+    expect(store.snapshot().callbackIssues.slice(-1)[0]).toMatchObject({
       runtimeSlotNumber: 2,
       reason: 'evicted_slot',
     });
 
-    store.recordSlotRequested(slots[1]);
-    store.recordSlotResponseReceived(slots[1]);
+    store.recordSlotRequested(slots[1]!);
+    store.recordSlotResponseReceived(slots[1]!);
     const reentered = store.snapshot().slots.find((slot) => slot.slotElementId === 'lru-1');
     expect(reentered).toMatchObject({ runtimeSlotNumber: 66 });
     expect(reentered?.requests[0]).toMatchObject({ requestNumber: 2 });
-    expect(reentered?.requests[0].responseAtMs).toBeDefined();
+    expect(reentered?.requests[0]!.responseAtMs).toBeDefined();
     expect(store.snapshot().slots).toHaveLength(MAX_DIAGNOSTIC_SLOTS);
     expect(store.snapshot().metadata.evictedSlots).toBe(2);
     assertCoverageEquation(store);
@@ -465,8 +418,8 @@ describe('GptDiagnosticsStore', () => {
       { runtimeSlotNumber: 1, slotElementId: 'first' },
       { runtimeSlotNumber: 2, slotElementId: 'second' },
     ]);
-    inputs[0].slotElementId = 'changed';
-    expect(store.bindingInputs()[0].slotElementId).toBe('first');
+    inputs[0]!.slotElementId = 'changed';
+    expect(store.bindingInputs()[0]!.slotElementId).toBe('first');
   });
 
   it('coalesces notifications and isolates throwing subscribers', () => {
@@ -494,191 +447,186 @@ describe('GptDiagnosticsStore', () => {
     expect(goodListener).toHaveBeenCalledTimes(1);
   });
 
-  it('retains the Ad Manager identifiers GPT reported for the delivered ad', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10 });
-    const slot = fakeSlot('ad-slot-identity');
-
-    store.recordSlotRequested(slot);
-    store.recordSlotResponseReceived(slot);
-    store.recordSlotRenderEnded(slot, {
-      isEmpty: false,
-      adManager: {
-        lineItemId: 6543210987,
-        creativeId: 1234567890,
-        campaignId: 2345678901,
-        advertiserId: 3456789012,
-      },
+  it('announces correctness commits synchronously while coalescing presentation work', () => {
+    const scheduled: Array<() => void> = [];
+    const store = new GptDiagnosticsStore({
+      now: () => 1,
+      schedule: (callback) => scheduled.push(callback),
     });
+    const commitListener = vi.fn();
+    const presentationListener = vi.fn();
+    store.subscribeCommits(commitListener);
+    store.subscribe(presentationListener);
 
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle.adManager, 'should keep every reported identifier').toEqual({
-      lineItemId: 6543210987,
-      creativeId: 1234567890,
-      campaignId: 2345678901,
-      advertiserId: 3456789012,
-    });
-    expect(cycle.responseClass).toBe('reservation');
-  });
+    store.markGptObserved();
+    store.recordSlotRequested(fakeSlot('commit-membership'));
 
-  it('retains an observed outer slot box separately from GPT reported size', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10 });
-    const slot = fakeSlot('ad-slot-outer-box');
+    expect(commitListener).toHaveBeenCalledTimes(2);
+    expect(presentationListener).not.toHaveBeenCalled();
+    expect(scheduled).toHaveLength(1);
+    scheduled.shift()?.();
+    expect(presentationListener).toHaveBeenCalledOnce();
+  });
 
+  it('returns detached snapshot data', () => {
+    const store = new GptDiagnosticsStore({ now: () => 1 });
+    const slot = fakeSlot('detached');
     store.recordSlotRequested(slot);
-    store.recordSlotResponseReceived(slot);
-    store.recordSlotRenderEnded(slot, { isEmpty: false, size: [1, 1] });
-    store.recordObservedSlotSize(1, 1, [728, 90]);
 
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle.size).toEqual([1, 1]);
-    expect(cycle.observedSlotSize).toEqual([728, 90]);
+    const first = store.snapshot();
+    first.slots[0]!.requests[0]!.requestNumber = 999;
+    first.coverage.slotRequested.matched = 999;
+
+    const second = store.snapshot();
+    expect(second.slots[0]!.requests[0]!.requestNumber).toBe(1);
+    expect(second.coverage.slotRequested.matched).toBe(1);
   });
+  it('ignores malformed publisher refresh inputs without recording intent', () => {
+    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
+    const slot = fakeSlot('publisher-refresh-malformed');
 
-  it('rejects a stale prior-cycle outer-box measurement after a refresh', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10 });
-    const slot = fakeSlot('ad-slot-stale-outer-box');
+    expect(() => store.recordPublisherRefresh(null as never)).not.toThrow();
+    expect(() => store.recordPublisherRefresh('slots' as never)).not.toThrow();
+    expect(() => store.recordPublisherRefresh([null, 7, undefined, slot] as never)).not.toThrow();
 
     store.recordSlotRequested(slot);
-    store.recordSlotResponseReceived(slot);
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-    store.recordSlotRequested(slot);
-    store.recordSlotResponseReceived(slot);
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-    store.recordObservedSlotSize(1, 1, [300, 250]);
-    store.recordObservedSlotSize(1, 2, [970, 250]);
-
-    const requests = store.snapshot().slots[0].requests;
-    expect(requests[0].observedSlotSize).toBeUndefined();
-    expect(requests[1].observedSlotSize).toEqual([970, 250]);
+    expect(store.snapshot().slots[0]!.requests[0]!.requestPath).toBe('publisher_refresh');
+    expect(store.snapshot().slots).toHaveLength(1);
   });
 
-  it('separates a fill without Ad Manager identifiers from a reservation', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10 });
-    const slot = fakeSlot('ad-slot-default');
-
-    store.recordSlotRequested(slot);
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
+  it('trims the oldest auction-slot association beyond the retention bound', () => {
+    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
+    const oldest = fakeSlot('association-oldest');
+    associateSlot(store, oldest, 'auction-oldest');
+    for (let index = 0; index < MAX_TRUSTED_SERVER_ASSOCIATIONS; index += 1) {
+      associateSlot(store, fakeSlot(`association-${index}`), `auction-${index}`);
+    }
+    store.recordSlotRequested(oldest);
 
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle.responseClass).toBe('unclassified_non_empty');
-    expect(cycle.adManager).toBeUndefined();
+    expect(store.recordTrustedServerCreativeRequest('auction-oldest')).toBeUndefined();
+    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_request_without_slot');
+    expect(store.recordTrustedServerCreativeRequest('auction-0')).toBeUndefined();
+    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_request_without_cycle');
   });
 
   it.each([
     {
-      name: 'a direct renderable candidate',
-      direct: 'renderable_candidate',
-      prebid: false,
-      publisher: false,
-      expectedPath: 'trusted_server_direct',
-      expectedOpportunity: 'renderable_candidate',
-    },
-    {
-      name: 'a direct unrenderable candidate',
-      direct: 'unrenderable_candidate',
-      prebid: false,
-      publisher: false,
-      expectedPath: 'trusted_server_direct',
-      expectedOpportunity: 'unrenderable_candidate',
-    },
-    {
-      name: 'a direct request without a candidate',
-      direct: 'no_candidate',
-      prebid: false,
-      publisher: false,
-      expectedPath: 'trusted_server_direct',
-      expectedOpportunity: 'no_candidate',
-    },
-    {
-      name: 'a Prebid refresh',
-      direct: undefined,
-      prebid: true,
-      publisher: false,
-      expectedPath: 'prebid_refresh',
-      expectedOpportunity: undefined,
-    },
-    {
-      name: 'competing direct and Prebid evidence',
-      direct: 'renderable_candidate',
-      prebid: true,
-      publisher: false,
-      expectedPath: 'competing',
-      expectedOpportunity: 'renderable_candidate',
-    },
-    {
-      name: 'an unattributed request',
-      direct: undefined,
-      prebid: false,
-      publisher: false,
-      expectedPath: 'unattributed',
-      expectedOpportunity: undefined,
-    },
-    {
-      name: 'a publisher refresh',
-      direct: undefined,
-      prebid: false,
-      publisher: true,
-      expectedPath: 'publisher_refresh',
-      expectedOpportunity: undefined,
+      name: 'a render that precedes its response',
+      kind: 'slotRenderEnded',
+      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
+        store.recordSlotRenderEnded(slot, { isEmpty: false }),
+      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
+        store.recordSlotResponseReceived(slot),
     },
     {
-      name: 'competing Prebid and publisher evidence',
-      direct: undefined,
-      prebid: true,
-      publisher: true,
-      expectedPath: 'competing',
-      expectedOpportunity: undefined,
+      name: 'a load that precedes its render',
+      kind: 'slotOnload',
+      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
+        store.recordSlotOnload(slot),
+      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) => {
+        store.recordSlotResponseReceived(slot);
+        store.recordSlotRenderEnded(slot, { isEmpty: false });
+      },
     },
     {
-      name: 'competing all source evidence',
-      direct: 'renderable_candidate',
-      prebid: true,
-      publisher: true,
-      expectedPath: 'competing',
-      expectedOpportunity: 'renderable_candidate',
+      name: 'a viewable impression that precedes its render',
+      kind: 'impressionViewable',
+      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
+        store.recordImpressionViewable(slot),
+      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) => {
+        store.recordSlotResponseReceived(slot);
+        store.recordSlotRenderEnded(slot, { isEmpty: false });
+      },
     },
-  ] as const)(
-    'attributes $name without inferring demand ownership',
-    ({ direct, prebid, publisher, expectedPath, expectedOpportunity }) => {
+  ])('reports $name as an invalid event order', ({ kind, record, arrange }) => {
+    let now = 100;
+    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
+    const slot = fakeSlot(`out-of-order-${kind}`);
+
+    store.recordSlotRequested(slot);
+    arrange(store, slot);
+    // A backwards clock is the only way GPT can report a later callback with an
+    // earlier timestamp; diagnostics record the contradiction rather than hide it.
+    now = 1;
+    record(store, slot);
+
+    expect(store.snapshot().slots[0]!.requests[0]!.incompleteSequence).toBe(true);
+    expect(store.snapshot().callbackIssues).toContainEqual(
+      expect.objectContaining({ kind, disposition: 'matched', reason: 'invalid_event_order' })
+    );
+    assertCoverageEquation(store);
+  });
+
+  it.each([Number.NaN, Number.POSITIVE_INFINITY])(
+    'rejects the non-finite visibility percentage %s',
+    (percentage) => {
       const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-      const slot = fakeSlot('path-slot');
+      const slot = fakeSlot('visibility-non-finite');
 
-      if (direct !== undefined) {
-        store.recordTrustedServerOpportunity(slot, 'auction-slot', direct);
-      }
-      if (prebid) store.recordPrebidRefresh([slot]);
-      if (publisher) store.recordPublisherRefresh([slot]);
       store.recordSlotRequested(slot);
+      store.recordSlotVisibilityChanged(slot, percentage);
 
-      const cycle = store.snapshot().slots[0].requests[0];
-      expect(cycle.requestPath).toBe(expectedPath);
-      expect(cycle.trustedServerOpportunity).toBe(expectedOpportunity);
+      const snapshot = store.snapshot();
+      expect(snapshot.slots[0]!.currentVisibilityPercentage).toBeUndefined();
+      expect(snapshot.slots[0]!.maximumVisibilityPercentage).toBeUndefined();
+      expect(snapshot.callbackIssues).toContainEqual(
+        expect.objectContaining({
+          kind: 'slotVisibilityChanged',
+          disposition: 'unmatched',
+          reason: 'invalid_visibility_percentage',
+        })
+      );
+      assertCoverageEquation(store);
     }
   );
 
-  it('consumes direct and Prebid markers exactly once', () => {
-    let now = 10;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('one-shot');
-
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate');
-    store.recordPrebidRefresh([slot]);
-    store.recordSlotRequested(slot);
-    now = 11;
+  it('reports an unknown attempt ID for a creative failure without recording one', () => {
+    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
+    const slot = fakeSlot('failure-unknown-attempt');
+    associateSlot(store, slot, 'auction-failure-unknown');
     store.recordSlotRequested(slot);
 
-    const cycles = store.snapshot().slots[0].requests;
-    expect(cycles).toMatchObject([
-      {
-        requestPath: 'competing',
-        trustedServerOpportunity: 'renderable_candidate',
-      },
-      { requestPath: 'unattributed' },
+    store.recordTrustedServerCreativeFailure(4242, 'cache_fetch_failed');
+
+    expect(store.snapshot().slots[0]!.requests[0]!.trustedServerCreativeFailures).toBeUndefined();
+    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_unknown');
+  });
+
+  it('keeps one outstanding delivery-boundary timer across a refresh burst', () => {
+    let now = 0;
+    const deferred: Array<{ callback: () => void; delayMs: number }> = [];
+    const store = new GptDiagnosticsStore({
+      now: () => now,
+      schedule: (callback) => callback(),
+      defer: (callback, delayMs) => deferred.push({ callback, delayMs }),
+    });
+    const slots = Array.from({ length: 8 }, (_, index) => fakeSlot(`burst-${index}`));
+
+    for (const [index, slot] of slots.entries()) {
+      now = index;
+      store.recordTrustedServerOpportunity(slot, `burst-auction-${index}`, 'renderable_candidate');
+      store.recordSlotRequested(slot);
+      store.recordSlotRenderEnded(slot, { isEmpty: false });
+    }
+
+    expect(deferred, 'a burst of candidate renders must share one timer').toMatchObject([
+      { delayMs: TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS },
     ]);
-    expect(cycles[1].trustedServerOpportunity).toBeUndefined();
+
+    // Firing at the earliest deadline re-arms once for the next one, never per render.
+    now = TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
+    deferred.shift()!.callback();
+    expect(deferred).toMatchObject([{ delayMs: 1 }]);
+
+    now = 7 + TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
+    deferred.shift()!.callback();
+    expect(deferred, 'no boundary remains once every candidate crossed it').toHaveLength(0);
+    for (const slot of store.snapshot().slots) {
+      expect(slot.requests[0]!.delivery).toBe('candidate_unconfirmed');
+    }
   });
 
-  it('retains all configured requested slot sizes on only the correlated next request', () => {
+  it('retains a detached requested-size vector on only the correlated next request', () => {
     const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
     const slot = fakeSlot('requested-sizes');
     const formats: Array<[number, number]> = [
@@ -708,7 +656,37 @@ describe('GptDiagnosticsStore', () => {
     expect(cycles[1]?.requestedSlotSizes).toBeUndefined();
   });
 
-  it('bounds and validates configured requested slot sizes before retaining them', () => {
+  it('correlates release-private snapshots through their shared opaque slot token', () => {
+    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
+    const token = Object.freeze(Object.create(null) as object);
+    const opportunitySlot = Object.freeze({
+      token,
+      elementId: 'token-correlated-slot',
+      adUnitPath: '/example/token-correlated-slot',
+    });
+    const callbackSlot = Object.freeze({
+      token,
+      elementId: 'token-correlated-slot',
+      adUnitPath: '/example/token-correlated-slot',
+    });
+
+    store.recordTrustedServerOpportunity(
+      opportunitySlot,
+      'auction-slot',
+      'renderable_candidate',
+      'fictional-auction',
+      [[300, 250]]
+    );
+    store.recordSlotRequested(callbackSlot, 11);
+
+    expect(store.snapshot().slots[0]?.requests[0]).toMatchObject({
+      requestedSlotSizes: [[300, 250]],
+      trustedServerAuctionId: 'fictional-auction',
+      trustedServerOpportunity: 'renderable_candidate',
+    });
+  });
+
+  it('bounds and validates requested sizes before retaining them', () => {
     const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
     const slot = fakeSlot('validated-requested-sizes');
     const formats: Array<[number, number]> = Array.from(
@@ -717,6 +695,8 @@ describe('GptDiagnosticsStore', () => {
     );
     formats[0] = [0, 250];
     formats[1] = [300, Number.NaN];
+    formats[2] = [1.5, 250];
+    formats[3] = [4_097, 250];
 
     store.recordTrustedServerOpportunity(
       slot,
@@ -728,1351 +708,11 @@ describe('GptDiagnosticsStore', () => {
     store.recordSlotRequested(slot);
 
     const requested = store.snapshot().slots[0]!.requests[0]!.requestedSlotSizes;
-    expect(requested).toHaveLength(MAX_REQUESTED_SLOT_SIZES - 2);
+    expect(requested).toHaveLength(MAX_REQUESTED_SLOT_SIZES - 4);
     expect(requested).not.toContainEqual([0, 250]);
     expect(requested).not.toContainEqual([300, Number.NaN]);
+    expect(requested).not.toContainEqual([1.5, 250]);
+    expect(requested).not.toContainEqual([4_097, 250]);
     expect(requested).not.toContainEqual([MAX_REQUESTED_SLOT_SIZES + 1, 250]);
   });
-
-  it('consumes a combined request intent with independent source facts', () => {
-    let now = 10;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const slot = fakeSlot('intent');
-
-    store.recordTrustedServerOpportunity(
-      slot,
-      'auction-slot',
-      'renderable_candidate',
-      ' auction-123 '
-    );
-    now = 20;
-    store.recordPrebidRefresh([slot]);
-    now = 30;
-    store.recordPublisherRefresh([slot]);
-    now = 34;
-    store.recordSlotRequested(slot);
-    now = 35;
-    store.recordSlotRequested(slot);
-
-    const cycles = store.snapshot().slots[0].requests;
-    expect(cycles).toMatchObject([
-      {
-        requestPath: 'competing',
-        requestIntentId: 1,
-        trustedServerOpportunity: 'renderable_candidate',
-        trustedServerAuctionId: 'auction-123',
-        opportunityToRequestMs: 24,
-      },
-      { requestPath: 'unattributed' },
-    ]);
-    expect(cycles[1].requestIntentId).toBeUndefined();
-    expect(deferred, 'source evidence must not schedule deferred work').toHaveLength(0);
-  });
-
-  it('keeps repeated source evidence single-source and increments consumed intent IDs', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const first = fakeSlot('repeat-intent-first');
-    const second = fakeSlot('repeat-intent-second');
-    store.recordPublisherRefresh([first]);
-    now = 2;
-    store.recordPublisherRefresh([first]);
-    store.recordSlotRequested(first);
-    now = 3;
-    store.recordTrustedServerOpportunity(second, 'second-auction', 'no_candidate');
-    store.recordPublisherRefresh([second]);
-    store.recordSlotRequested(second);
-
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      requestPath: 'publisher_refresh',
-      requestIntentId: 1,
-    });
-    expect(store.snapshot().slots[1].requests[0]).toMatchObject({
-      requestPath: 'competing',
-      requestIntentId: 2,
-    });
-  });
-
-  it('expires repeated source evidence lazily without scheduling timer work', () => {
-    let now = 0;
-    const deferred: Array<{ callback: () => void; delayMs: number }> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback, delayMs) => deferred.push({ callback, delayMs }),
-    });
-    const consumed = fakeSlot('lazy-expiry-consumed');
-    const expired = fakeSlot('lazy-expiry-expired');
-
-    for (let observation = 0; observation < 1_000; observation += 1) {
-      now = observation;
-      store.recordPublisherRefresh([consumed, expired]);
-    }
-
-    expect(deferred, 'a refresh burst must not queue deferred work').toHaveLength(0);
-
-    // The window runs from the newest observation, at t = 999.
-    now = 999 + REQUEST_PATH_ATTRIBUTION_WINDOW_MS - 1;
-    store.recordSlotRequested(consumed);
-    now += 1;
-    store.recordSlotRequested(expired);
-
-    expect(store.snapshot().slots[0].requests[0].requestPath).toBe('publisher_refresh');
-    expect(store.snapshot().slots[1].requests[0].requestPath).toBe('unattributed');
-    expect(deferred, 'expiry must stay free of deferred work').toHaveLength(0);
-  });
-
-  it('replaces a fully expired intent instead of reviving its intent ID', () => {
-    let now = 0;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const slot = fakeSlot('expired-intent-replacement');
-
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate', 'stale');
-    now = REQUEST_PATH_ATTRIBUTION_WINDOW_MS;
-    store.recordPublisherRefresh([slot]);
-    store.recordSlotRequested(slot);
-
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle).toMatchObject({ requestPath: 'publisher_refresh', requestIntentId: 2 });
-    expect(
-      cycle.trustedServerOpportunity,
-      'expired direct evidence must not survive'
-    ).toBeUndefined();
-    expect(cycle.trustedServerAuctionId).toBeUndefined();
-    expect(deferred).toHaveLength(0);
-  });
-
-  it('derives a replacement from the most recent earlier filled render', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const slot = fakeSlot('replacement');
-
-    store.recordSlotRequested(slot);
-    now = 2;
-    store.recordSlotResponseReceived(slot);
-    now = 3;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 101 } });
-    now = 20;
-    store.recordSlotRequested(slot);
-    now = 21;
-    store.recordSlotResponseReceived(slot);
-    now = 22;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 202 } });
-
-    expect(store.snapshot().slots[0].requests[1]).toMatchObject({
-      replacedRequestNumber: 1,
-      previousRenderToRequestMs: 17,
-      previousCreativeId: 101,
-      creativeChanged: true,
-    });
-  });
-
-  it('compares primary and source-agnostic GPT creative identities for replacements', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const slot = fakeSlot('replacement-fallback-creative');
-    store.recordSlotRequested(slot);
-    now = 2;
-    store.recordSlotResponseReceived(slot);
-    now = 3;
-    store.recordSlotRenderEnded(slot, {
-      isEmpty: false,
-      adManager: { sourceAgnosticCreativeId: 101 },
-    });
-    now = 4;
-    store.recordSlotRequested(slot);
-    now = 5;
-    store.recordSlotResponseReceived(slot);
-    now = 6;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 101 } });
-
-    expect(store.snapshot().slots[0].requests[1]).toMatchObject({
-      previousCreativeId: 101,
-      creativeChanged: false,
-    });
-  });
-
-  it('uses the latest earlier filled render while ignoring empty renders', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const slot = fakeSlot('replacement-most-recent-filled');
-
-    store.recordSlotRequested(slot);
-    now = 2;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 101 } });
-    now = 3;
-    store.recordSlotRequested(slot);
-    now = 4;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 202 } });
-    now = 5;
-    store.recordSlotRequested(slot);
-    now = 6;
-    store.recordSlotRenderEnded(slot, { isEmpty: true });
-    now = 7;
-    store.recordSlotRequested(slot);
-    now = 8;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 303 } });
-
-    const requests = store.snapshot().slots[0].requests;
-    expect(requests[2].replacedRequestNumber).toBeUndefined();
-    expect(requests[3]).toMatchObject({
-      replacedRequestNumber: 2,
-      previousRenderToRequestMs: 3,
-      previousCreativeId: 202,
-      creativeChanged: true,
-    });
-  });
-
-  it('reports one-sided creative IDs without claiming a creative change', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const previousOnly = fakeSlot('replacement-previous-id-only');
-    const currentOnly = fakeSlot('replacement-current-id-only');
-
-    store.recordSlotRequested(previousOnly);
-    now = 2;
-    store.recordSlotRenderEnded(previousOnly, { isEmpty: false, adManager: { creativeId: 101 } });
-    now = 3;
-    store.recordSlotRequested(previousOnly);
-    now = 4;
-    store.recordSlotRenderEnded(previousOnly, { isEmpty: false });
-
-    store.recordSlotRequested(currentOnly);
-    now = 5;
-    store.recordSlotRenderEnded(currentOnly, { isEmpty: false });
-    now = 6;
-    store.recordSlotRequested(currentOnly);
-    now = 7;
-    store.recordSlotRenderEnded(currentOnly, { isEmpty: false, adManager: { creativeId: 202 } });
-
-    const [previousOnlyCycle] = store.snapshot().slots[0].requests.slice(-1);
-    const [currentOnlyCycle] = store.snapshot().slots[1].requests.slice(-1);
-    expect(previousOnlyCycle).toMatchObject({ replacedRequestNumber: 1, previousCreativeId: 101 });
-    expect(previousOnlyCycle.creativeChanged).toBeUndefined();
-    expect(currentOnlyCycle).toMatchObject({ replacedRequestNumber: 1 });
-    expect(currentOnlyCycle.previousCreativeId).toBeUndefined();
-    expect(currentOnlyCycle.creativeChanged).toBeUndefined();
-  });
-
-  it('does not infer replacements once the earlier filled cycle has been evicted', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now });
-    const slot = fakeSlot('replacement-evicted');
-
-    store.recordSlotRequested(slot);
-    now += 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 101 } });
-    // Complete every filler cycle so the eviction pushes the only filled render
-    // out of retention and the final render still matches exactly one cycle.
-    for (let index = 0; index < MAX_REQUEST_CYCLES_PER_SLOT; index += 1) {
-      now += 1;
-      store.recordSlotRequested(slot);
-      now += 1;
-      store.recordSlotResponseReceived(slot);
-      now += 1;
-      store.recordSlotRenderEnded(slot, { isEmpty: true });
-    }
-    now += 1;
-    store.recordSlotRequested(slot);
-    now += 1;
-    store.recordSlotResponseReceived(slot);
-    now += 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 202 } });
-
-    const requests = store.snapshot().slots[0].requests;
-    expect(
-      requests.some((cycle) => cycle.adManager?.creativeId === 101),
-      'the earlier filled cycle should have been evicted'
-    ).toBe(false);
-    const latestCycle = last(requests)!;
-    expect(latestCycle.renderAtMs, 'the final render must have been matched').toBeDefined();
-    expect(latestCycle.adManager?.creativeId).toBe(202);
-    expect(latestCycle.replacedRequestNumber).toBeUndefined();
-    expect(latestCycle.previousRenderToRequestMs).toBeUndefined();
-    expect(latestCycle.previousCreativeId).toBeUndefined();
-  });
-
-  it('keeps Trusted Server and publisher source evidence separate from replacement facts', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('replacement-source-evidence');
-
-    store.recordSlotRequested(slot);
-    now = 2;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 101 } });
-    now = 3;
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate');
-    store.recordPublisherRefresh([slot]);
-    store.recordSlotRequested(slot);
-    now = 4;
-    store.recordSlotRenderEnded(slot, { isEmpty: false, adManager: { creativeId: 202 } });
-
-    expect(store.snapshot().slots[0].requests[1]).toMatchObject({
-      requestPath: 'competing',
-      replacedRequestNumber: 1,
-      previousCreativeId: 101,
-      creativeChanged: true,
-    });
-  });
-
-  it('expires request-path markers at the five-second boundary without waiting for timers', () => {
-    let now = 0;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const beforeBoundary = fakeSlot('before-boundary');
-    const atBoundary = fakeSlot('at-boundary');
-
-    for (const slot of [beforeBoundary, atBoundary]) {
-      store.recordTrustedServerOpportunity(
-        slot,
-        `auction-${slot.getSlotElementId?.()}`,
-        'no_candidate'
-      );
-      store.recordPrebidRefresh([slot]);
-    }
-
-    now = REQUEST_PATH_ATTRIBUTION_WINDOW_MS - 1;
-    store.recordSlotRequested(beforeBoundary);
-    now = REQUEST_PATH_ATTRIBUTION_WINDOW_MS;
-    store.recordSlotRequested(atBoundary);
-
-    const [before, expired] = store.snapshot().slots.map((slot) => slot.requests[0]);
-    expect(before).toMatchObject({
-      requestPath: 'competing',
-      trustedServerOpportunity: 'no_candidate',
-    });
-    expect(expired).toMatchObject({ requestPath: 'unattributed' });
-    expect(expired.trustedServerOpportunity).toBeUndefined();
-    expect(deferred, 'the boundary must be enforced without marker timers').toHaveLength(0);
-  });
-
-  it('keeps the newest evidence when a source is re-observed inside the window', () => {
-    let now = 0;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const slot = fakeSlot('re-observed-source');
-
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate');
-    store.recordPrebidRefresh([slot]);
-    now = 100;
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'unrenderable_candidate');
-    store.recordPrebidRefresh([slot]);
-    store.recordSlotRequested(slot);
-
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      requestPath: 'competing',
-      requestIntentId: 1,
-      trustedServerOpportunity: 'unrenderable_candidate',
-    });
-    expect(deferred).toHaveLength(0);
-  });
-
-  it('expires sources independently and replaces Trusted Server auction metadata', () => {
-    let now = 0;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const slot = fakeSlot('independent-expiry');
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate', 'old');
-    now = 1;
-    store.recordPrebidRefresh([slot]);
-    now = 2;
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'no_candidate');
-    now = REQUEST_PATH_ATTRIBUTION_WINDOW_MS + 1;
-    store.recordSlotRequested(slot);
-
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      requestPath: 'trusted_server_direct',
-      trustedServerOpportunity: 'no_candidate',
-    });
-    expect(store.snapshot().slots[0].requests[0].trustedServerAuctionId).toBeUndefined();
-  });
-
-  it('uses replacement Trusted Server evidence for latency and removes an unconsumed final source', () => {
-    let now = 0;
-    const deferred: Array<() => void> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      defer: (callback) => deferred.push(callback),
-    });
-    const repeated = fakeSlot('repeated-trusted-server-evidence');
-    const unconsumed = fakeSlot('unconsumed-trusted-server-evidence');
-
-    store.recordTrustedServerOpportunity(repeated, 'auction-slot', 'renderable_candidate');
-    now = 40;
-    store.recordTrustedServerOpportunity(repeated, 'auction-slot', 'no_candidate');
-    now = 50;
-    store.recordSlotRequested(repeated);
-
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      requestPath: 'trusted_server_direct',
-      trustedServerOpportunity: 'no_candidate',
-      opportunityToRequestMs: 10,
-    });
-
-    now = 60;
-    store.recordTrustedServerOpportunity(unconsumed, 'other-auction-slot', 'no_candidate');
-    now += REQUEST_PATH_ATTRIBUTION_WINDOW_MS;
-    store.recordSlotRequested(unconsumed);
-
-    const unconsumedCycle = store.snapshot().slots[1].requests[0];
-    expect(unconsumedCycle.requestPath).toBe('unattributed');
-    expect(unconsumedCycle.requestIntentId).toBeUndefined();
-  });
-
-  it('retains only valid bounded auction IDs without dropping Trusted Server intent', () => {
-    const valid = 'a'.repeat(256);
-    const cases: Array<[unknown, string | undefined]> = [
-      [valid, valid],
-      ['', undefined],
-      ['   ', undefined],
-      [123, undefined],
-      ['é'.repeat(129), undefined],
-    ];
-    for (const [auctionId, expected] of cases) {
-      const store = new GptDiagnosticsStore({ now: () => 1, defer: () => undefined });
-      const slot = fakeSlot(`auction-id-${String(auctionId).length}`);
-      store.recordTrustedServerOpportunity(
-        slot,
-        'auction-slot',
-        'renderable_candidate',
-        auctionId as string
-      );
-      store.recordSlotRequested(slot);
-      const cycle = store.snapshot().slots[0].requests[0];
-      expect(cycle.requestPath).toBe('trusted_server_direct');
-      expect(cycle.trustedServerAuctionId).toBe(expected);
-    }
-  });
-
-  it('does not mutate an open request cycle when a later direct marker arrives', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const slot = fakeSlot('open-cycle');
-
-    store.recordSlotRequested(slot);
-    store.recordTrustedServerOpportunity(slot, 'auction-slot', 'renderable_candidate');
-
-    const openCycle = store.snapshot().slots[0].requests[0];
-    expect(openCycle).toMatchObject({ requestPath: 'unattributed' });
-    expect(openCycle.trustedServerOpportunity).toBeUndefined();
-
-    store.recordSlotRequested(slot);
-    expect(store.snapshot().slots[0].requests[1]).toMatchObject({
-      requestPath: 'trusted_server_direct',
-      trustedServerOpportunity: 'renderable_candidate',
-    });
-  });
-
-  it('ignores malformed diagnostic marker inputs without throwing', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const slot = fakeSlot('valid-marker');
-
-    expect(() =>
-      store.recordTrustedServerOpportunity(null as never, 'auction-slot', 'renderable_candidate')
-    ).not.toThrow();
-    expect(() =>
-      store.recordTrustedServerOpportunity(slot, 'auction-slot', 'invalid' as never)
-    ).not.toThrow();
-    expect(() => store.recordPrebidRefresh(null as never)).not.toThrow();
-    expect(() => store.recordPrebidRefresh([null, 1, slot] as never)).not.toThrow();
-
-    store.recordSlotRequested(slot);
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle).toMatchObject({ requestPath: 'prebid_refresh' });
-    expect(cycle.trustedServerOpportunity).toBeUndefined();
-  });
-
-  it.each(['renderable_candidate', 'unrenderable_candidate'] as const)(
-    'moves an explicit non-empty %s to unconfirmed after one deferred notification',
-    (opportunity) => {
-      let now = 10;
-      const deferred: Array<{ callback: () => void; delayMs: number }> = [];
-      const store = new GptDiagnosticsStore({
-        now: () => now,
-        schedule: (callback) => callback(),
-        defer: (callback, delayMs) => deferred.push({ callback, delayMs }),
-      });
-      const listener = vi.fn();
-      const slot = fakeSlot(`delivery-${opportunity}`);
-      store.subscribe(listener);
-
-      store.recordTrustedServerOpportunity(slot, 'auction-slot', opportunity);
-      store.recordSlotRequested(slot);
-      expect(deferred, 'recording intent must not defer work').toHaveLength(0);
-      listener.mockClear();
-
-      now = 30;
-      store.recordSlotRenderEnded(slot, { isEmpty: false });
-      expect(store.snapshot().slots[0].requests[0].delivery).toBe('pending');
-      expect(deferred).toHaveLength(1);
-      expect(deferred[0].delayMs).toBe(TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS);
-      expect(listener).toHaveBeenCalledTimes(1);
-
-      now = 30 + TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
-      deferred[0].callback();
-      expect(store.snapshot().slots[0].requests[0].delivery).toBe('candidate_unconfirmed');
-      expect(listener).toHaveBeenCalledTimes(2);
-      expect(deferred).toHaveLength(1);
-    }
-  );
-
-  it.each([
-    {
-      name: 'an explicit no-candidate fill',
-      opportunity: 'no_candidate',
-      renderFacts: { isEmpty: false },
-      expected: 'no_candidate',
-    },
-    {
-      name: 'a fill without a direct opportunity',
-      opportunity: undefined,
-      renderFacts: { isEmpty: false },
-      expected: 'unknown',
-    },
-    {
-      name: 'a render with omitted fill state',
-      opportunity: 'renderable_candidate',
-      renderFacts: {},
-      expected: 'unknown',
-    },
-    {
-      name: 'an empty render',
-      opportunity: 'renderable_candidate',
-      renderFacts: { isEmpty: true },
-      expected: 'not_applicable',
-    },
-    {
-      name: 'a pre-render request',
-      opportunity: 'renderable_candidate',
-      renderFacts: undefined,
-      expected: 'not_applicable',
-    },
-  ] as const)(
-    'derives $name from observed evidence only',
-    ({ opportunity, renderFacts, expected }) => {
-      let now = 10;
-      const deferred: Array<() => void> = [];
-      const store = new GptDiagnosticsStore({
-        now: () => now,
-        defer: (callback) => deferred.push(callback),
-      });
-      const slot = fakeSlot('delivery-state');
-
-      if (opportunity === undefined) {
-        store.recordPrebidRefresh([slot]);
-      } else {
-        store.recordTrustedServerOpportunity(slot, 'auction-slot', opportunity);
-      }
-      store.recordSlotRequested(slot);
-      deferred.shift()?.();
-      now = 30;
-      if (renderFacts !== undefined) store.recordSlotRenderEnded(slot, renderFacts);
-
-      expect(store.snapshot().slots[0].requests[0].delivery).toBe(expected);
-      expect(deferred, 'should not schedule an attribution-boundary notification').toHaveLength(0);
-      now = 30 + TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
-      expect(store.snapshot().slots[0].requests[0].delivery).toBe(expected);
-    }
-  );
-
-  it.each([
-    { name: 'omitted fill state', facts: {}, expected: undefined },
-    { name: 'an empty render', facts: { isEmpty: true }, expected: 'empty' },
-    {
-      name: 'an explicit backfill',
-      facts: { isEmpty: false, isBackfill: true },
-      expected: 'backfill',
-    },
-    {
-      name: 'an explicit reservation',
-      facts: { isEmpty: false, adManager: { lineItemId: 123 } },
-      expected: 'reservation',
-    },
-    {
-      name: 'a source-agnostic identity confirmed as non-backfill',
-      facts: {
-        isEmpty: false,
-        isBackfill: false,
-        adManager: { sourceAgnosticLineItemId: 123 },
-      },
-      expected: 'reservation',
-    },
-    {
-      name: 'a source-agnostic identity without a backfill fact',
-      facts: { isEmpty: false, adManager: { sourceAgnosticLineItemId: 123 } },
-      expected: 'unclassified_non_empty',
-    },
-    {
-      name: 'an otherwise unclassified non-empty render',
-      facts: { isEmpty: false },
-      expected: 'unclassified_non_empty',
-    },
-  ] as const)('classifies $name only from explicit render facts', ({ facts, expected }) => {
-    const store = new GptDiagnosticsStore({ now: () => 10 });
-    const slot = fakeSlot('response-class');
-
-    store.recordSlotRequested(slot);
-    store.recordSlotRenderEnded(slot, facts);
-
-    expect(store.snapshot().slots[0].requests[0].responseClass).toBe(expected);
-  });
-
-  it('correlates a creative request and response to the selected request cycle', () => {
-    let now = 10;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('creative-selected');
-    associateSlot(store, slot, 'auction-selected');
-    store.recordSlotRequested(slot);
-
-    now = 20;
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-selected');
-    expect(attemptId).toEqual(expect.any(Number));
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      trustedServerCreativeRequestAtMs: 20,
-      delivery: 'trusted_server_selected',
-    });
-
-    now = 25;
-    store.recordTrustedServerCreativeResponse(attemptId!);
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      trustedServerCreativeRequestAtMs: 20,
-      trustedServerCreativeResponseAtMs: 25,
-      delivery: 'trusted_server_response_sent',
-    });
-  });
-
-  it('accepts late positive creative evidence after the candidate observation timeout', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('late-positive');
-    associateSlot(store, slot, 'auction-late');
-    store.recordSlotRequested(slot);
-    now = 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-
-    now = 1 + TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
-    expect(store.snapshot().slots[0].requests[0].delivery).toBe('candidate_unconfirmed');
-
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-late');
-    expect(attemptId).toEqual(expect.any(Number));
-    expect(store.snapshot().slots[0].requests[0].delivery).toBe('trusted_server_selected');
-    now += 1;
-    store.recordTrustedServerCreativeResponse(attemptId!);
-    expect(store.snapshot().slots[0].requests[0].delivery).toBe('trusted_server_response_sent');
-  });
-
-  it('keeps the first request timestamp and live ID across duplicate creative requests', () => {
-    let now = 1;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('creative-retry');
-    associateSlot(store, slot, 'auction-retry');
-    store.recordSlotRequested(slot);
-
-    now = 5;
-    const firstId = store.recordTrustedServerCreativeRequest('auction-retry');
-    now = 9;
-    const duplicateId = store.recordTrustedServerCreativeRequest('auction-retry');
-
-    expect(duplicateId).toBe(firstId);
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeRequestAtMs).toBe(5);
-  });
-
-  it('records each safe creative failure once in first-observed order and can later succeed', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('creative-failures');
-    associateSlot(store, slot, 'auction-failures');
-    store.recordSlotRequested(slot);
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-failures')!;
-
-    store.recordTrustedServerCreativeFailure(attemptId, 'cache_fetch_failed');
-    store.recordTrustedServerCreativeFailure(attemptId, 'missing_render_source');
-    store.recordTrustedServerCreativeFailure(attemptId, 'cache_fetch_failed');
-    store.recordTrustedServerCreativeFailure(attemptId, 'invalid_cache_payload');
-    store.recordTrustedServerCreativeFailure(attemptId, 'response_post_failed');
-    store.recordTrustedServerCreativeFailure(attemptId, 'unsafe_runtime_value' as never);
-
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeFailures).toEqual([
-      'cache_fetch_failed',
-      'missing_render_source',
-      'invalid_cache_payload',
-      'response_post_failed',
-    ]);
-    expect(store.snapshot().attributionIssues).toEqual([]);
-
-    now = 1;
-    store.recordTrustedServerCreativeResponse(attemptId);
-    expect(store.snapshot().slots[0].requests[0].delivery).toBe('trusted_server_response_sent');
-  });
-
-  it('keeps an asynchronous response on its originating cycle after a newer refresh', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('async-origin');
-    associateSlot(store, slot, 'auction-async');
-    store.recordSlotRequested(slot);
-    const firstId = store.recordTrustedServerCreativeRequest('auction-async')!;
-    now = 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-
-    now = 2;
-    store.recordSlotRequested(slot);
-    now = 3;
-    store.recordTrustedServerCreativeResponse(firstId);
-
-    const [first, second] = store.snapshot().slots[0].requests;
-    expect(first).toMatchObject({
-      trustedServerCreativeResponseAtMs: 3,
-      delivery: 'trusted_server_response_sent',
-    });
-    expect(second.trustedServerCreativeResponseAtMs).toBeUndefined();
-  });
-
-  it('provisionally attaches an initial pre-render creative request', () => {
-    let now = 10;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('provisional');
-    associateSlot(store, slot, 'auction-provisional');
-    store.recordSlotRequested(slot);
-
-    now = 11;
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-provisional');
-    expect(attemptId).toEqual(expect.any(Number));
-    now = 12;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      trustedServerCreativeRequestAtMs: 11,
-      isEmpty: false,
-      delivery: 'trusted_server_selected',
-    });
-    expect(store.snapshot().attributionIssues).toEqual([]);
-  });
-
-  it('rejects an ambiguous pre-render request when an earlier non-empty cycle is retained', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('ambiguous-creative');
-    associateSlot(store, slot, 'auction-ambiguous');
-    store.recordSlotRequested(slot);
-    now = 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-    now = 2;
-    store.recordSlotRequested(slot);
-
-    now = 3;
-    expect(store.recordTrustedServerCreativeRequest('auction-ambiguous')).toBeUndefined();
-    expect(store.snapshot().slots[0].requests[1].trustedServerCreativeRequestAtMs).toBeUndefined();
-    expect(store.snapshot().attributionIssues).toEqual([
-      expect.objectContaining({
-        reason: 'creative_request_ambiguous_cycle',
-        runtimeSlotNumber: 1,
-        slotElementId: 'ambiguous-creative',
-      }),
-    ]);
-  });
-
-  it('accepts positive creative evidence when GPT omitted isEmpty', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('unknown-fill-positive');
-    associateSlot(store, slot, 'auction-unknown-fill');
-    store.recordSlotRequested(slot);
-    now = 1;
-    store.recordSlotRenderEnded(slot, {});
-    now = 2;
-
-    expect(store.recordTrustedServerCreativeRequest('auction-unknown-fill')).toEqual(
-      expect.any(Number)
-    );
-    expect(store.snapshot().slots[0].requests[0].delivery).toBe('trusted_server_selected');
-  });
-
-  it('rejects explicit empty cycles and never falls back to an older compatible cycle', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('empty-current');
-    associateSlot(store, slot, 'auction-empty-current');
-    store.recordSlotRequested(slot);
-    now = 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: false });
-    now = 2;
-    store.recordSlotRequested(slot);
-    now = 3;
-    store.recordSlotRenderEnded(slot, { isEmpty: true });
-
-    expect(store.recordTrustedServerCreativeRequest('auction-empty-current')).toBeUndefined();
-    const [older, current] = store.snapshot().slots[0].requests;
-    expect(older.trustedServerCreativeRequestAtMs).toBeUndefined();
-    expect(current.trustedServerCreativeRequestAtMs).toBeUndefined();
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_request_without_cycle');
-  });
-
-  it('preserves provisional evidence and reports when the cycle later renders empty', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('provisional-empty');
-    associateSlot(store, slot, 'auction-provisional-empty');
-    store.recordSlotRequested(slot);
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-provisional-empty');
-    now = 1;
-    store.recordSlotRenderEnded(slot, { isEmpty: true });
-
-    expect(attemptId).toEqual(expect.any(Number));
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeRequestAtMs).toBe(0);
-    expect(store.snapshot().attributionIssues).toEqual([
-      expect.objectContaining({
-        reason: 'creative_request_on_empty_cycle',
-        runtimeSlotNumber: 1,
-        slotElementId: 'provisional-empty',
-      }),
-    ]);
-
-    // The attempt is dead once its cycle rendered empty, so a late response
-    // cannot claim a Trusted Server delivery against that empty render.
-    store.recordTrustedServerCreativeResponse(attemptId!);
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle.trustedServerCreativeResponseAtMs).toBeUndefined();
-    expect(cycle.delivery, 'an empty cycle must not report a markup response').toBe(
-      'trusted_server_selected'
-    );
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_evicted');
-  });
-
-  it('preserves provisional evidence when the render omits isEmpty', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('provisional-unknown-fill');
-    associateSlot(store, slot, 'auction-provisional-unknown-fill');
-    store.recordSlotRequested(slot);
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-provisional-unknown-fill');
-
-    now = 1;
-    store.recordSlotRenderEnded(slot, {});
-
-    expect(attemptId).toEqual(expect.any(Number));
-    expect(store.snapshot().slots[0].requests[0]).toMatchObject({
-      trustedServerCreativeRequestAtMs: 0,
-      delivery: 'trusted_server_selected',
-    });
-    expect(store.snapshot().attributionIssues).toEqual([]);
-  });
-
-  it('admits a request at the cycle-age boundary and rejects only after it', () => {
-    let boundaryNow = 0;
-    const boundaryStore = new GptDiagnosticsStore({
-      now: () => boundaryNow,
-      defer: () => undefined,
-    });
-    const boundarySlot = fakeSlot('cycle-boundary');
-    associateSlot(boundaryStore, boundarySlot, 'auction-boundary');
-    boundaryStore.recordSlotRequested(boundarySlot);
-    boundaryNow = CREATIVE_ATTEMPT_WINDOW_MS;
-    expect(boundaryStore.recordTrustedServerCreativeRequest('auction-boundary')).toEqual(
-      expect.any(Number)
-    );
-
-    let lateNow = 0;
-    const lateStore = new GptDiagnosticsStore({ now: () => lateNow, defer: () => undefined });
-    const lateSlot = fakeSlot('cycle-too-old');
-    associateSlot(lateStore, lateSlot, 'auction-too-old');
-    lateStore.recordSlotRequested(lateSlot);
-    lateNow = CREATIVE_ATTEMPT_WINDOW_MS + 1;
-    expect(lateStore.recordTrustedServerCreativeRequest('auction-too-old')).toBeUndefined();
-    expect(last(lateStore.snapshot().attributionIssues)?.reason).toBe(
-      'creative_request_without_cycle'
-    );
-  });
-
-  it('distinguishes missing slot associations from known slots without a request cycle', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const associated = fakeSlot('associated-no-cycle');
-    associateSlot(store, associated, 'auction-no-cycle');
-
-    expect(store.recordTrustedServerCreativeRequest('auction-unknown')).toBeUndefined();
-    expect(store.recordTrustedServerCreativeRequest('')).toBeUndefined();
-    expect(store.recordTrustedServerCreativeRequest('auction-no-cycle')).toBeUndefined();
-
-    const issues = store.snapshot().attributionIssues;
-    expect(issues.map((issue) => issue.reason)).toEqual([
-      'creative_request_without_slot',
-      'creative_request_without_slot',
-      'creative_request_without_cycle',
-    ]);
-    expect(issues[0].runtimeSlotNumber).toBeUndefined();
-    expect(issues[0].slotElementId).toBeUndefined();
-    expect(issues[2].slotElementId).toBe('associated-no-cycle');
-  });
-
-  it('expires attempts at 30 seconds without replacement or late mutation', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('attempt-expiry');
-    associateSlot(store, slot, 'auction-expiry');
-    store.recordSlotRequested(slot);
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-expiry')!;
-
-    now = CREATIVE_ATTEMPT_WINDOW_MS - 1;
-    expect(store.recordTrustedServerCreativeRequest('auction-expiry')).toBe(attemptId);
-    now = CREATIVE_ATTEMPT_WINDOW_MS;
-    expect(store.recordTrustedServerCreativeRequest('auction-expiry')).toBeUndefined();
-    store.recordTrustedServerCreativeResponse(attemptId);
-    store.recordTrustedServerCreativeFailure(attemptId, 'cache_fetch_failed');
-
-    const cycle = store.snapshot().slots[0].requests[0];
-    expect(cycle).toMatchObject({ trustedServerCreativeRequestAtMs: 0 });
-    expect(cycle.trustedServerCreativeResponseAtMs).toBeUndefined();
-    expect(cycle.trustedServerCreativeFailures).toBeUndefined();
-    expect(store.snapshot().attributionIssues.map((issue) => issue.reason)).toEqual([
-      'creative_attempt_expired',
-      'creative_attempt_expired',
-      'creative_attempt_expired',
-    ]);
-  });
-
-  it('reuses a live attempt after the cycle ages out and expires from creative-request time', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('delayed-attempt-expiry');
-    associateSlot(store, slot, 'auction-delayed-attempt-expiry');
-    store.recordSlotRequested(slot);
-
-    now = 20_000;
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-delayed-attempt-expiry');
-    expect(attemptId).toEqual(expect.any(Number));
-
-    now = CREATIVE_ATTEMPT_WINDOW_MS + 1;
-    expect(store.recordTrustedServerCreativeRequest('auction-delayed-attempt-expiry')).toBe(
-      attemptId
-    );
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeRequestAtMs).toBe(20_000);
-
-    now = 20_000 + CREATIVE_ATTEMPT_WINDOW_MS - 1;
-    expect(store.recordTrustedServerCreativeRequest('auction-delayed-attempt-expiry')).toBe(
-      attemptId
-    );
-    now = 20_000 + CREATIVE_ATTEMPT_WINDOW_MS;
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-delayed-attempt-expiry')
-    ).toBeUndefined();
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_expired');
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeRequestAtMs).toBe(20_000);
-  });
-
-  it('reports unknown IDs and invalidates live attempts on cycle and slot eviction', () => {
-    const now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    store.recordTrustedServerCreativeResponse(999_999);
-
-    const shiftedSlot = fakeSlot('shifted-attempt');
-    associateSlot(store, shiftedSlot, 'auction-shifted');
-    store.recordSlotRequested(shiftedSlot);
-    const shiftedId = store.recordTrustedServerCreativeRequest('auction-shifted')!;
-    for (let index = 0; index < MAX_REQUEST_CYCLES_PER_SLOT; index += 1) {
-      store.recordSlotRequested(shiftedSlot);
-    }
-    store.recordTrustedServerCreativeResponse(shiftedId);
-
-    const evictedSlot = fakeSlot('lru-attempt');
-    associateSlot(store, evictedSlot, 'auction-lru-attempt');
-    store.recordSlotRequested(evictedSlot);
-    const evictedId = store.recordTrustedServerCreativeRequest('auction-lru-attempt')!;
-    for (let index = 0; index < MAX_DIAGNOSTIC_SLOTS; index += 1) {
-      store.recordSlotRequested(fakeSlot(`attempt-lru-filler-${index}`));
-    }
-    store.recordTrustedServerCreativeFailure(evictedId, 'response_post_failed');
-
-    expect(store.snapshot().attributionIssues.map((issue) => issue.reason)).toEqual([
-      'creative_attempt_unknown',
-      'creative_attempt_evicted',
-      'creative_attempt_evicted',
-    ]);
-  });
-
-  it('treats duplicate writers against a completed attempt as idempotent', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('completed-attempt');
-    associateSlot(store, slot, 'auction-completed');
-    store.recordSlotRequested(slot);
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-completed')!;
-    now = 1;
-    store.recordTrustedServerCreativeResponse(attemptId);
-    const completed = store.snapshot();
-
-    now = 2;
-    expect(store.recordTrustedServerCreativeRequest('auction-completed')).toBeUndefined();
-    store.recordTrustedServerCreativeResponse(attemptId);
-    store.recordTrustedServerCreativeFailure(attemptId, 'cache_fetch_failed');
-
-    expect(store.snapshot().slots[0].requests[0]).toEqual(completed.slots[0].requests[0]);
-    expect(store.snapshot().attributionIssues).toEqual([]);
-  });
-
-  it('does not replace a completed current-cycle attempt after its tombstone is reclaimed', () => {
-    const now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const sentinelSlot = fakeSlot('completed-current-cycle');
-    associateSlot(store, sentinelSlot, 'auction-completed-current-cycle');
-    store.recordSlotRequested(sentinelSlot);
-    const sentinelId = store.recordTrustedServerCreativeRequest('auction-completed-current-cycle')!;
-    store.recordTrustedServerCreativeResponse(sentinelId);
-
-    recordCompletedAttempts(store, MAX_CREATIVE_ATTEMPTS - 1, 'completed-current-cycle-fill');
-    const replacementSlot = fakeSlot('completed-current-cycle-replacement');
-    associateSlot(store, replacementSlot, 'auction-completed-current-cycle-replacement');
-    store.recordSlotRequested(replacementSlot);
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-completed-current-cycle-replacement')
-    ).toEqual(expect.any(Number));
-
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-completed-current-cycle')
-    ).toBeUndefined();
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-completed-current-cycle')
-    ).toBeUndefined();
-    expect(store.snapshot().attributionIssues).toEqual([]);
-    expect(
-      store.snapshot().slots.find((slot) => slot.slotElementId === 'completed-current-cycle')
-        ?.requests[0]
-    ).toMatchObject({
-      trustedServerCreativeRequestAtMs: 0,
-      trustedServerCreativeResponseAtMs: 0,
-    });
-  });
-
-  it('does not replace an expired current-cycle attempt after its tombstone is reclaimed', () => {
-    let now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const sentinelSlot = fakeSlot('expired-current-cycle');
-    associateSlot(store, sentinelSlot, 'auction-expired-current-cycle');
-    store.recordSlotRequested(sentinelSlot);
-    expect(store.recordTrustedServerCreativeRequest('auction-expired-current-cycle')).toEqual(
-      expect.any(Number)
-    );
-
-    now = CREATIVE_ATTEMPT_WINDOW_MS;
-    recordCompletedAttempts(store, MAX_CREATIVE_ATTEMPTS - 1, 'expired-current-cycle-fill');
-    const replacementSlot = fakeSlot('expired-current-cycle-replacement');
-    associateSlot(store, replacementSlot, 'auction-expired-current-cycle-replacement');
-    store.recordSlotRequested(replacementSlot);
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-expired-current-cycle-replacement')
-    ).toEqual(expect.any(Number));
-
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-expired-current-cycle')
-    ).toBeUndefined();
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-expired-current-cycle')
-    ).toBeUndefined();
-    expect(store.snapshot().attributionIssues.map((issue) => issue.reason)).toEqual([
-      'creative_attempt_unknown',
-      'creative_attempt_unknown',
-    ]);
-    expect(
-      store.snapshot().slots.find((slot) => slot.slotElementId === 'expired-current-cycle')
-        ?.requests[0]
-    ).toMatchObject({ trustedServerCreativeRequestAtMs: 0 });
-  });
-
-  it('never evicts a live attempt at capacity and lets an unassigned duplicate retry', () => {
-    let now = 100;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const liveIds: number[] = [];
-    let created = 0;
-
-    for (let slotIndex = 0; created < MAX_CREATIVE_ATTEMPTS; slotIndex += 1) {
-      const slot = fakeSlot(`live-capacity-${slotIndex}`);
-      const auctionSlotId = `auction-live-capacity-${slotIndex}`;
-      associateSlot(store, slot, auctionSlotId);
-      const cycles = Math.min(MAX_REQUEST_CYCLES_PER_SLOT, MAX_CREATIVE_ATTEMPTS - created);
-      for (let cycleIndex = 0; cycleIndex < cycles; cycleIndex += 1) {
-        store.recordSlotRequested(slot);
-        liveIds.push(store.recordTrustedServerCreativeRequest(auctionSlotId)!);
-        created += 1;
-      }
-    }
-
-    const rejectedSlot = fakeSlot('live-capacity-rejected');
-    associateSlot(store, rejectedSlot, 'auction-live-capacity-rejected');
-    store.recordSlotRequested(rejectedSlot);
-    expect(
-      store.recordTrustedServerCreativeRequest('auction-live-capacity-rejected')
-    ).toBeUndefined();
-    expect(last(store.snapshot().slots)?.requests[0].trustedServerCreativeRequestAtMs).toBe(100);
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_capacity');
-
-    now = 250;
-    store.recordTrustedServerCreativeResponse(liveIds[0]);
-    const retriedId = store.recordTrustedServerCreativeRequest('auction-live-capacity-rejected');
-    expect(retriedId).toEqual(expect.any(Number));
-    expect(retriedId).not.toBe(liveIds[0]);
-    expect(last(store.snapshot().slots)?.requests[0].trustedServerCreativeRequestAtMs).toBe(100);
-    store.recordTrustedServerCreativeResponse(liveIds[1]);
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_capacity');
-  });
-
-  it('does not create an already-expired attempt when a capacity retry reaches its boundary', () => {
-    let now = 100;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    let created = 0;
-
-    for (let slotIndex = 0; created < MAX_CREATIVE_ATTEMPTS; slotIndex += 1) {
-      const slot = fakeSlot(`boundary-capacity-${slotIndex}`);
-      const auctionSlotId = `auction-boundary-capacity-${slotIndex}`;
-      associateSlot(store, slot, auctionSlotId);
-      const cycles = Math.min(MAX_REQUEST_CYCLES_PER_SLOT, MAX_CREATIVE_ATTEMPTS - created);
-      for (let cycleIndex = 0; cycleIndex < cycles; cycleIndex += 1) {
-        store.recordSlotRequested(slot);
-        expect(store.recordTrustedServerCreativeRequest(auctionSlotId)).toEqual(expect.any(Number));
-        created += 1;
-      }
-    }
-
-    const rejectedSlot = fakeSlot('boundary-capacity-rejected');
-    const rejectedAuctionSlotId = 'auction-boundary-capacity-rejected';
-    associateSlot(store, rejectedSlot, rejectedAuctionSlotId);
-    store.recordSlotRequested(rejectedSlot);
-    expect(store.recordTrustedServerCreativeRequest(rejectedAuctionSlotId)).toBeUndefined();
-
-    now += CREATIVE_ATTEMPT_WINDOW_MS;
-    expect(store.recordTrustedServerCreativeRequest(rejectedAuctionSlotId)).toBeUndefined();
-    const snapshot = store.snapshot();
-    const rejectedCycle = snapshot.slots.find(
-      (slot) => slot.slotElementId === 'boundary-capacity-rejected'
-    )?.requests[0];
-    expect(rejectedCycle?.trustedServerCreativeRequestAtMs).toBe(100);
-    expect(snapshot.attributionIssues.map((issue) => issue.reason)).toEqual([
-      'creative_attempt_capacity',
-      'creative_attempt_expired',
-    ]);
-  });
-
-  it('bounds attribution issues separately without changing callback coverage', () => {
-    const store = new GptDiagnosticsStore({ now: () => 1, defer: () => undefined });
-    const beforeCoverage = store.snapshot().coverage;
-
-    for (let index = 0; index < MAX_ATTRIBUTION_ISSUES + 1; index += 1) {
-      store.recordTrustedServerCreativeResponse(10_000 + index);
-    }
-
-    const snapshot = store.snapshot();
-    expect(snapshot.attributionIssues).toHaveLength(MAX_ATTRIBUTION_ISSUES);
-    expect(snapshot.metadata.droppedAttributionIssues).toBe(1);
-    expect(snapshot.callbackIssues).toEqual([]);
-    expect(snapshot.metadata.droppedCallbacks).toBe(0);
-    expect(snapshot.coverage).toEqual(beforeCoverage);
-    assertCoverageEquation(store);
-  });
-
-  it('returns detached creative evidence and never exports attempt bookkeeping', () => {
-    const now = 0;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot('detached-creative');
-    associateSlot(store, slot, 'auction-detached-creative');
-    store.recordSlotRequested(slot);
-    store.recordSlotRenderEnded(slot, {
-      isEmpty: false,
-      adManager: { creativeId: 123, yieldGroupIds: [11], companyIds: [22] },
-    });
-    const attemptId = store.recordTrustedServerCreativeRequest('auction-detached-creative')!;
-    store.recordTrustedServerCreativeFailure(attemptId, 'cache_fetch_failed');
-    store.recordTrustedServerCreativeResponse(999_999);
-
-    const first = store.snapshot();
-    first.slots[0].requests[0].trustedServerCreativeFailures!.push('response_post_failed');
-    first.slots[0].requests[0].adManager!.yieldGroupIds!.push(33);
-    first.slots[0].requests[0].adManager!.companyIds!.push(44);
-    first.attributionIssues[0].reason = 'creative_attempt_capacity';
-
-    const second = store.snapshot();
-    expect(second.slots[0].requests[0].trustedServerCreativeFailures).toEqual([
-      'cache_fetch_failed',
-    ]);
-    expect(second.slots[0].requests[0].adManager).toMatchObject({
-      creativeId: 123,
-      yieldGroupIds: [11],
-      companyIds: [22],
-    });
-    expect(second.attributionIssues[0].reason).toBe('creative_attempt_unknown');
-    const serializedCycle = JSON.stringify(second.slots[0].requests[0]);
-    expect(serializedCycle).not.toMatch(
-      /"(?:id|status|expiresAtMs|provisionalBeforeRender|auctionSlotId|attemptId|attemptStatus)"\s*:/
-    );
-  });
-
-  it('returns detached snapshot data', () => {
-    const store = new GptDiagnosticsStore({ now: () => 1 });
-    const slot = fakeSlot('detached');
-    store.recordSlotRequested(slot);
-
-    const first = store.snapshot();
-    first.slots[0].requests[0].requestNumber = 999;
-    first.coverage.slotRequested.matched = 999;
-
-    const second = store.snapshot();
-    expect(second.slots[0].requests[0].requestNumber).toBe(1);
-    expect(second.coverage.slotRequested.matched).toBe(1);
-  });
-  it('ignores malformed publisher refresh inputs without recording intent', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const slot = fakeSlot('publisher-refresh-malformed');
-
-    expect(() => store.recordPublisherRefresh(null as never)).not.toThrow();
-    expect(() => store.recordPublisherRefresh('slots' as never)).not.toThrow();
-    expect(() => store.recordPublisherRefresh([null, 7, undefined, slot] as never)).not.toThrow();
-
-    store.recordSlotRequested(slot);
-    expect(store.snapshot().slots[0].requests[0].requestPath).toBe('publisher_refresh');
-    expect(store.snapshot().slots).toHaveLength(1);
-  });
-
-  it('trims the oldest auction-slot association beyond the retention bound', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const oldest = fakeSlot('association-oldest');
-    associateSlot(store, oldest, 'auction-oldest');
-    for (let index = 0; index < MAX_TRUSTED_SERVER_ASSOCIATIONS; index += 1) {
-      associateSlot(store, fakeSlot(`association-${index}`), `auction-${index}`);
-    }
-    store.recordSlotRequested(oldest);
-
-    expect(store.recordTrustedServerCreativeRequest('auction-oldest')).toBeUndefined();
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_request_without_slot');
-    expect(store.recordTrustedServerCreativeRequest('auction-0')).toBeUndefined();
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_request_without_cycle');
-  });
-
-  it.each([
-    {
-      name: 'a render that precedes its response',
-      kind: 'slotRenderEnded',
-      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
-        store.recordSlotRenderEnded(slot, { isEmpty: false }),
-      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
-        store.recordSlotResponseReceived(slot),
-    },
-    {
-      name: 'a load that precedes its render',
-      kind: 'slotOnload',
-      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
-        store.recordSlotOnload(slot),
-      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) => {
-        store.recordSlotResponseReceived(slot);
-        store.recordSlotRenderEnded(slot, { isEmpty: false });
-      },
-    },
-    {
-      name: 'a viewable impression that precedes its render',
-      kind: 'impressionViewable',
-      record: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) =>
-        store.recordImpressionViewable(slot),
-      arrange: (store: GptDiagnosticsStore, slot: GptDiagnosticsSlotLike) => {
-        store.recordSlotResponseReceived(slot);
-        store.recordSlotRenderEnded(slot, { isEmpty: false });
-      },
-    },
-  ])('reports $name as an invalid event order', ({ kind, record, arrange }) => {
-    let now = 100;
-    const store = new GptDiagnosticsStore({ now: () => now, defer: () => undefined });
-    const slot = fakeSlot(`out-of-order-${kind}`);
-
-    store.recordSlotRequested(slot);
-    arrange(store, slot);
-    // A backwards clock is the only way GPT can report a later callback with an
-    // earlier timestamp; diagnostics record the contradiction rather than hide it.
-    now = 1;
-    record(store, slot);
-
-    expect(store.snapshot().slots[0].requests[0].incompleteSequence).toBe(true);
-    expect(store.snapshot().callbackIssues).toContainEqual(
-      expect.objectContaining({ kind, disposition: 'matched', reason: 'invalid_event_order' })
-    );
-    assertCoverageEquation(store);
-  });
-
-  it.each([Number.NaN, Number.POSITIVE_INFINITY])(
-    'rejects the non-finite visibility percentage %s',
-    (percentage) => {
-      const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-      const slot = fakeSlot('visibility-non-finite');
-
-      store.recordSlotRequested(slot);
-      store.recordSlotVisibilityChanged(slot, percentage);
-
-      const snapshot = store.snapshot();
-      expect(snapshot.slots[0].currentVisibilityPercentage).toBeUndefined();
-      expect(snapshot.slots[0].maximumVisibilityPercentage).toBeUndefined();
-      expect(snapshot.callbackIssues).toContainEqual(
-        expect.objectContaining({
-          kind: 'slotVisibilityChanged',
-          disposition: 'unmatched',
-          reason: 'invalid_visibility_percentage',
-        })
-      );
-      assertCoverageEquation(store);
-    }
-  );
-
-  it('reports an unknown attempt ID for a creative failure without recording one', () => {
-    const store = new GptDiagnosticsStore({ now: () => 10, defer: () => undefined });
-    const slot = fakeSlot('failure-unknown-attempt');
-    associateSlot(store, slot, 'auction-failure-unknown');
-    store.recordSlotRequested(slot);
-
-    store.recordTrustedServerCreativeFailure(4242, 'cache_fetch_failed');
-
-    expect(store.snapshot().slots[0].requests[0].trustedServerCreativeFailures).toBeUndefined();
-    expect(last(store.snapshot().attributionIssues)?.reason).toBe('creative_attempt_unknown');
-  });
-
-  it('keeps one outstanding delivery-boundary timer across a refresh burst', () => {
-    let now = 0;
-    const deferred: Array<{ callback: () => void; delayMs: number }> = [];
-    const store = new GptDiagnosticsStore({
-      now: () => now,
-      schedule: (callback) => callback(),
-      defer: (callback, delayMs) => deferred.push({ callback, delayMs }),
-    });
-    const slots = Array.from({ length: 8 }, (_, index) => fakeSlot(`burst-${index}`));
-
-    for (const [index, slot] of slots.entries()) {
-      now = index;
-      store.recordTrustedServerOpportunity(slot, `burst-auction-${index}`, 'renderable_candidate');
-      store.recordSlotRequested(slot);
-      store.recordSlotRenderEnded(slot, { isEmpty: false });
-    }
-
-    expect(deferred, 'a burst of candidate renders must share one timer').toMatchObject([
-      { delayMs: TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS },
-    ]);
-
-    // Firing at the earliest deadline re-arms once for the next one, never per render.
-    now = TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
-    deferred.shift()!.callback();
-    expect(deferred).toMatchObject([{ delayMs: 1 }]);
-
-    now = 7 + TRUSTED_SERVER_ATTRIBUTION_WINDOW_MS;
-    deferred.shift()!.callback();
-    expect(deferred, 'no boundary remains once every candidate crossed it').toHaveLength(0);
-    for (const slot of store.snapshot().slots) {
-      expect(slot.requests[0].delivery).toBe('candidate_unconfirmed');
-    }
-  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/types.test.ts b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/types.test.ts
index f4f4c7486..2d1d89899 100644
--- a/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/types.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/types.test.ts
@@ -12,7 +12,6 @@ import type {
   GptDiagnosticsResponseClass,
   GptDiagnosticsSlotExport,
   Size,
-  TsjsApi,
 } from '../../../src/core/types';
 
 describe('GPT diagnostics public types', () => {
@@ -49,31 +48,6 @@ describe('GPT diagnostics public types', () => {
     expectTypeOf(readOnlyApi).toEqualTypeOf<GptDiagnosticsApi>();
   });
 
-  it('accepts legacy V1 snapshots without attribution evidence', () => {
-    const legacySnapshot: GptDiagnosticsExportV1 = {
-      version: 1,
-      capturedAt: '2026-08-04T00:00:00.000Z',
-      page: { origin: 'https://example.com', pathname: '/' },
-      slots: [],
-      callbackIssues: [],
-      coverage: {
-        slotRequested: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-        slotResponseReceived: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-        slotRenderEnded: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-        slotOnload: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-        impressionViewable: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-        slotVisibilityChanged: { observed: 0, matched: 0, unmatched: 0, ambiguous: 0 },
-      },
-      metadata: {
-        droppedCallbacks: 0,
-        evictedSlots: 0,
-        evictedRequestCycles: 0,
-      },
-    };
-
-    expect(legacySnapshot.version).toBe(1);
-  });
-
   it('keeps evidence writers off the operator API and on the internal channel', () => {
     expectTypeOf<keyof GptDiagnosticsApi>().toEqualTypeOf<
       'snapshot' | 'export' | 'subscribe' | 'show' | 'hide'
@@ -85,10 +59,6 @@ describe('GPT diagnostics public types', () => {
       | 'recordTrustedServerCreativeResponse'
       | 'recordTrustedServerCreativeFailure'
     >();
-    expectTypeOf<TsjsApi['gptDiagnostics']>().toEqualTypeOf<GptDiagnosticsApi | undefined>();
-    expectTypeOf<TsjsApi['gptDiagnosticsRecorder']>().toEqualTypeOf<
-      GptDiagnosticsRecorder | undefined
-    >();
   });
 
   it('represents the versioned allowlist schema', () => {
@@ -180,11 +150,9 @@ describe('GPT diagnostics public types', () => {
     expectTypeOf(evidenceCycle.requestedSlotSizes).toEqualTypeOf<ReadonlyArray<Size> | undefined>();
     expectTypeOf(evidenceCycle.observedSlotSize).toEqualTypeOf<Size | undefined>();
     expectTypeOf(evidenceSnapshot.attributionIssues).toEqualTypeOf<
-      GptDiagnosticsAttributionIssue[] | undefined
-    >();
-    expectTypeOf(evidenceSnapshot.metadata.droppedAttributionIssues).toEqualTypeOf<
-      number | undefined
+      readonly Readonly<GptDiagnosticsAttributionIssue>[]
     >();
+    expectTypeOf(evidenceSnapshot.metadata.droppedAttributionIssues).toEqualTypeOf<number>();
     expectTypeOf<GptDiagnosticsAttributionIssueReason>().toEqualTypeOf<
       | 'creative_request_without_slot'
       | 'creative_request_without_cycle'
diff --git a/crates/trusted-server-js/lib/test/integrations/lifecycle_modules.test.ts b/crates/trusted-server-js/lib/test/integrations/lifecycle_modules.test.ts
new file mode 100644
index 000000000..40d1fd2fb
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/lifecycle_modules.test.ts
@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createDataDomeIntegrationRegistration } from '../../src/integrations/datadome/module';
+import { createDidomiIntegrationRegistration } from '../../src/integrations/didomi/module';
+import { createGoogleTagManagerIntegrationRegistration } from '../../src/integrations/google_tag_manager/module';
+import { createLockrIntegrationRegistration } from '../../src/integrations/lockr/module';
+import { createOsanoIntegrationRegistration } from '../../src/integrations/osano/module';
+import { createPermutiveIntegrationRegistration } from '../../src/integrations/permutive/module';
+import { createSourcepointIntegrationRegistration } from '../../src/integrations/sourcepoint/module';
+import { createTestlightIntegrationRegistration } from '../../src/integrations/testlight/module';
+import {
+  createIntegrationRegistry,
+  type IntegrationRegistration,
+} from '../../src/kernel/integration_registry';
+import { RELEASE_CATALOG } from '../../src/kernel/release_catalog';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+const registrations: ReadonlyArray<
+  readonly [string, (release: string) => IntegrationRegistration]
+> = Object.freeze([
+  ['datadome', createDataDomeIntegrationRegistration] as const,
+  ['didomi', createDidomiIntegrationRegistration] as const,
+  ['google_tag_manager', createGoogleTagManagerIntegrationRegistration] as const,
+  ['lockr', createLockrIntegrationRegistration] as const,
+  ['osano_consent', createOsanoIntegrationRegistration] as const,
+  ['permutive_context', createPermutiveIntegrationRegistration] as const,
+  ['sourcepoint_consent', createSourcepointIntegrationRegistration] as const,
+  ['testlight', createTestlightIntegrationRegistration] as const,
+]);
+const configFor = (id: string): unknown => {
+  if (id === 'didomi') return Object.freeze({ proxyPath: '/integrations/didomi/sdk' });
+  if (id === 'sourcepoint_consent') return Object.freeze({ rewriteSdk: true });
+  return Object.freeze({});
+};
+
+function catalogFor(ids: readonly string[]) {
+  return Object.freeze(
+    ids.map((id) => {
+      const entry = RELEASE_CATALOG.find((candidate) => candidate.id === id);
+      if (!entry) throw new TypeError(`Missing release catalog row: ${id}`);
+      return Object.freeze({
+        id: entry.id,
+        phase: entry.phase,
+        trigger: entry.trigger,
+        config: entry.config,
+        consumes: Object.freeze([...entry.consumes]),
+        provides: Object.freeze([...entry.provides]),
+      });
+    })
+  );
+}
+
+function runtimeCapability() {
+  return Object.freeze({
+    document,
+    enqueue: (callback: () => void) => {
+      callback();
+      return true;
+    },
+    registerAuctionContext: () => () => undefined,
+  });
+}
+
+describe('remaining integration lifecycle modules', () => {
+  it('activates the provider-owned maximal lifecycle set without foreign runtime authority', async () => {
+    const order: string[] = [];
+    const ids = Object.freeze(registrations.map(([id]) => id));
+    const foreignActivations = new Map<string, ReturnType<typeof vi.fn>>();
+    const foreignStarts = new Map<string, ReturnType<typeof vi.fn>>();
+    const interfaces = Object.freeze(
+      Object.fromEntries(
+        ids.map((id) => {
+          const activate = vi.fn(() => vi.fn());
+          const start = vi.fn();
+          foreignActivations.set(id, activate);
+          foreignStarts.set(id, start);
+          return [id, Object.freeze({ activate, start })];
+        })
+      )
+    );
+    const registry = createIntegrationRegistry({
+      manifest: {
+        version: 1,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: ids.map((id) => ({ id, phase: 'takeover' as const })),
+      },
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: ids,
+      catalog: catalogFor(ids),
+      startedAtMs: 0,
+      now: () => 0,
+      runtimeCapability: runtimeCapability(),
+      getBindings: (id) => ({ config: configFor(id), interfaces }),
+    });
+    for (const [, createRegistration] of registrations) {
+      expect(registry.register(createRegistration(RELEASE_ID))).toBe(true);
+    }
+
+    const result = await registry.install({
+      activateCore: () => order.push('core'),
+      publish: () => order.push('publish'),
+      drainPreload: () => order.push('drain'),
+    });
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual(['core', 'publish', 'drain']);
+    for (const id of ids) {
+      expect(foreignActivations.get(id)).not.toHaveBeenCalled();
+      expect(foreignStarts.get(id)).not.toHaveBeenCalled();
+    }
+    if (result.state === 'kernel') result.dispose();
+  });
+
+  it.each(registrations)(
+    '%s runs alone without cross-integration authority',
+    async (id, create) => {
+      const activate = vi.fn(() => vi.fn());
+      const start = vi.fn();
+      const registry = createIntegrationRegistry({
+        manifest: {
+          version: 1,
+          releaseId: RELEASE_ID,
+          firstDisplay: null,
+          runtimeSrc: RUNTIME_SRC,
+          integrations: [{ id, phase: 'takeover' }],
+        },
+        releaseId: RELEASE_ID,
+        knownIntegrationIds: Object.freeze([id]),
+        catalog: catalogFor([id]),
+        startedAtMs: 0,
+        now: () => 0,
+        runtimeCapability: runtimeCapability(),
+        getBindings: () => ({
+          config: configFor(id),
+          interfaces: Object.freeze({ [id]: Object.freeze({ activate, start }) }),
+        }),
+      });
+      registry.register(create(RELEASE_ID));
+
+      await expect(
+        registry.install({ activateCore: vi.fn(), publish: vi.fn(), drainPreload: vi.fn() })
+      ).resolves.toMatchObject({ state: 'kernel' });
+      expect(activate).not.toHaveBeenCalled();
+      expect(start).not.toHaveBeenCalled();
+      registry.dispose();
+    }
+  );
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/lockr/module.test.ts b/crates/trusted-server-js/lib/test/integrations/lockr/module.test.ts
new file mode 100644
index 000000000..2581fbd7c
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/lockr/module.test.ts
@@ -0,0 +1,122 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createLockrRuntime } from '../../../src/integrations/lockr/module';
+
+describe('transactional Lockr integration module', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('rewrites a later initialized SDK once and compare-restores its host', async () => {
+    vi.useFakeTimers();
+    const state: { sdk?: { host: string } } = {};
+    const resetGuard = vi.fn();
+    const runtime = createLockrRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => state.sdk,
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      resetGuard,
+      setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+    await vi.advanceTimersByTimeAsync(49);
+    const sdk = { host: 'https://identity.loc.kr' };
+    state.sdk = sdk;
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(sdk.host).toBe('https://news.example/integrations/lockr/api');
+    sdk.host = 'https://publisher.example/replacement';
+    release();
+    expect(sdk.host).toBe('https://publisher.example/replacement');
+    expect(resetGuard).toHaveBeenCalledOnce();
+  });
+
+  it('stops after 50 readiness checks and owns no later timer', async () => {
+    vi.useFakeTimers();
+    const timedOut = vi.fn();
+    const setTimeout = vi.fn((callback: () => void, delay: number) =>
+      window.setTimeout(callback, delay)
+    );
+    const runtime = createLockrRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => undefined,
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      resetGuard: vi.fn(),
+      setTimeout,
+      started: vi.fn(),
+      timedOut,
+    });
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+
+    await vi.advanceTimersByTimeAsync(2_500);
+
+    expect(setTimeout).toHaveBeenCalledTimes(49);
+    expect(timedOut).toHaveBeenCalledOnce();
+    expect(vi.getTimerCount()).toBe(0);
+    release();
+  });
+
+  it('cancels readiness work on disposal before the SDK appears', async () => {
+    vi.useFakeTimers();
+    const sdk = { host: 'https://identity.loc.kr' };
+    let available = false;
+    const runtime = createLockrRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => (available ? sdk : undefined),
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      resetGuard: vi.fn(),
+      setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+    release();
+    available = true;
+
+    await vi.runAllTimersAsync();
+
+    expect(sdk.host).toBe('https://identity.loc.kr');
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('isolates a hostile timer release from SDK and guard cleanup', () => {
+    const sdk = { host: 'https://identity.loc.kr' };
+    let sdkAvailable = false;
+    const clearTimeout = vi.fn(() => {
+      throw new Error('publisher clearTimeout failed');
+    });
+    const resetGuard = vi.fn(() => {
+      throw new Error('publisher guard reset failed');
+    });
+    const runtime = createLockrRuntime({
+      clearTimeout,
+      getSdk: () => (sdkAvailable ? sdk : undefined),
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      resetGuard,
+      setTimeout: (callback) => {
+        sdkAvailable = true;
+        callback();
+        return 17;
+      },
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+
+    expect(sdk.host).toBe('https://news.example/integrations/lockr/api');
+    expect(() => release()).not.toThrow();
+    expect(() => release()).not.toThrow();
+
+    expect(clearTimeout).toHaveBeenCalledOnce();
+    expect(sdk.host).toBe('https://identity.loc.kr');
+    expect(resetGuard).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/osano/index.test.ts b/crates/trusted-server-js/lib/test/integrations/osano/index.test.ts
index 891fd5540..d7f2892ae 100644
--- a/crates/trusted-server-js/lib/test/integrations/osano/index.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/osano/index.test.ts
@@ -1,9 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import {
+  disposeOsanoConsentMirror,
   initializeOsanoConsentMirror,
   mirrorOsanoConsent,
-  resetOsanoConsentMirrorForTest,
 } from '../../../src/integrations/osano';
 
 type TestWindow = Window & {
@@ -24,7 +24,7 @@ type UspCallback = (data?: { uspString?: string }, success?: boolean) => void;
 
 function clearAllCookies(): void {
   document.cookie.split(';').forEach((cookie) => {
-    const name = cookie.split('=')[0].trim();
+    const name = cookie.split('=')[0]?.trim() ?? '';
     if (name) document.cookie = `${name}=; path=/; Max-Age=0`;
   });
 }
@@ -80,7 +80,7 @@ function setOsanoStub(): Record<string, (payload?: unknown) => void> {
 
 describe('integrations/osano consent mirror', () => {
   beforeEach(() => {
-    resetOsanoConsentMirrorForTest();
+    disposeOsanoConsentMirror();
     clearAllCookies();
     delete (window as TestWindow).Osano;
     delete (window as TestWindow).__uspapi;
@@ -90,7 +90,7 @@ describe('integrations/osano consent mirror', () => {
 
   afterEach(() => {
     vi.useRealTimers();
-    resetOsanoConsentMirrorForTest();
+    disposeOsanoConsentMirror();
     clearAllCookies();
     delete (window as TestWindow).Osano;
     delete (window as TestWindow).__uspapi;
@@ -436,4 +436,33 @@ describe('integrations/osano consent mirror', () => {
     expect(listeners['osano-cm-consent-saved']).toEqual(expect.any(Function));
     expect(getCookie('us_privacy')).toBe('1YN-');
   });
+
+  it('cancels in-flight API timeouts and makes late callbacks inert on disposal', async () => {
+    vi.useFakeTimers();
+    const callbacks = setControlledUspApi();
+    const pending = mirrorOsanoConsent();
+
+    expect(vi.getTimerCount()).toBe(1);
+    disposeOsanoConsentMirror();
+    expect(vi.getTimerCount()).toBe(0);
+    await expect(pending).resolves.toBe(false);
+
+    callbacks[0]?.({ uspString: 'late-consent' }, true);
+    await Promise.resolve();
+    expect(getCookie('us_privacy')).toBeUndefined();
+    expect(getCookie(MARKER_COOKIE)).toBeUndefined();
+  });
+
+  it('does not retain Osano listeners when the vendor exposes no removal API', async () => {
+    vi.useFakeTimers();
+    const addEventListener = vi.fn();
+    (window as TestWindow).Osano = { cm: { addEventListener } };
+
+    initializeOsanoConsentMirror();
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(addEventListener).not.toHaveBeenCalled();
+    disposeOsanoConsentMirror();
+    expect(vi.getTimerCount()).toBe(0);
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/integrations/osano/module.test.ts b/crates/trusted-server-js/lib/test/integrations/osano/module.test.ts
new file mode 100644
index 000000000..0c1dad220
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/osano/module.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createOsanoRuntime } from '../../../src/integrations/osano/module';
+
+describe('transactional Osano integration module', () => {
+  it('keeps activation reversible and starts the consent mirror once after commit', () => {
+    const initialize = vi.fn();
+    const reset = vi.fn();
+    const runtime = createOsanoRuntime({ initialize, reset });
+
+    const release = runtime.activate(undefined);
+
+    expect(initialize).not.toHaveBeenCalled();
+    runtime.start(undefined);
+    runtime.start(undefined);
+    expect(initialize).toHaveBeenCalledOnce();
+    release();
+    release();
+    expect(reset).toHaveBeenCalledOnce();
+  });
+
+  it('resets partial consent ownership when startup throws', () => {
+    const reset = vi.fn();
+    const runtime = createOsanoRuntime({
+      initialize: () => {
+        throw new Error('listener failed');
+      },
+      reset,
+    });
+    const release = runtime.activate(undefined);
+
+    expect(() => runtime.start(undefined)).toThrow('listener failed');
+    release();
+
+    expect(reset).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/permutive/module.test.ts b/crates/trusted-server-js/lib/test/integrations/permutive/module.test.ts
new file mode 100644
index 000000000..bf89c3e1c
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/permutive/module.test.ts
@@ -0,0 +1,183 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createPermutiveIntegrationRegistration,
+  createPermutiveRuntime,
+} from '../../../src/integrations/permutive/module';
+import type { RuntimeCapabilityV1 } from '../../../src/kernel/runtime';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+describe('transactional Permutive integration module', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('registers one disposable auction-context contributor during activation', () => {
+    const order: string[] = [];
+    let contributor: (() => Readonly<Record<string, unknown>> | undefined) | undefined;
+    const runtime = createPermutiveRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => undefined,
+      getSegments: () => ['11', '22'],
+      installGuard: () => order.push('guard:install'),
+      location: { host: 'news.example', protocol: 'https:' },
+      registerContext: (candidate) => {
+        contributor = candidate;
+        order.push('context:register');
+        return () => order.push('context:release');
+      },
+      resetGuard: () => order.push('guard:reset'),
+      setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+
+    const release = runtime.activate(undefined);
+
+    expect(contributor?.()).toEqual({ permutive_segments: ['11', '22'] });
+    expect(order).toEqual(['guard:install', 'context:register']);
+    release();
+    release();
+    expect(order).toEqual(['guard:install', 'context:register', 'context:release', 'guard:reset']);
+  });
+
+  it('uses the adopted parser-time segments for the first persistent auction', () => {
+    localStorage.removeItem('permutive-app');
+    let contributor: (() => Readonly<Record<string, unknown>> | undefined) | undefined;
+    const runtime = Object.freeze({
+      registerAuctionContext: (_id: string, candidate: typeof contributor) => {
+        contributor = candidate;
+        return vi.fn();
+      },
+    }) as unknown as RuntimeCapabilityV1;
+    const preparationDisposers: Array<() => void> = [];
+    const activationDisposers: Array<() => void> = [];
+    const controller = new AbortController();
+    const registration = createPermutiveIntegrationRegistration(RELEASE_ID);
+    if (registration.phase !== 'takeover') throw new TypeError('Expected takeover registration');
+    const prepared = registration.prepareSync({
+      config: Object.freeze({}),
+      interfaces: Object.freeze({ 'runtime.v1': runtime }),
+      signal: controller.signal,
+      onDispose: (callback: () => void) => preparationDisposers.push(callback),
+    });
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        slices: Object.freeze(['first_display', 'permutive_initial']),
+        parserState: Object.freeze([
+          Object.freeze({
+            sliceId: 'permutive_initial',
+            observations: Object.freeze(['segments']),
+            values: Object.freeze([
+              Object.freeze(['segments', JSON.stringify(['initial-one', 'initial-two'])] as const),
+            ]),
+          }),
+        ]),
+      }),
+      identities: Object.freeze([]),
+    });
+
+    prepared.activate({
+      adoption,
+      afterCommit: vi.fn(),
+      signal: controller.signal,
+      onDispose: (callback: () => void) => activationDisposers.push(callback),
+    });
+
+    expect(contributor?.()).toEqual({
+      permutive_segments: ['initial-one', 'initial-two'],
+    });
+    expect(contributor?.()).toBeUndefined();
+
+    activationDisposers.reverse().forEach((release) => release());
+    preparationDisposers.reverse().forEach((release) => release());
+  });
+
+  it('bounds a context-service segment snapshot even when an injected reader overproduces', () => {
+    let contributor: (() => Readonly<Record<string, unknown>> | undefined) | undefined;
+    const runtime = createPermutiveRuntime({
+      getSegments: () => Array.from({ length: 101 }, (_, index) => `${index}`),
+      installGuard: vi.fn(),
+      registerContext: (candidate) => {
+        contributor = candidate;
+        return vi.fn();
+      },
+      resetGuard: vi.fn(),
+    });
+
+    const release = runtime.activate(undefined);
+    const snapshot = contributor?.() as { readonly permutive_segments?: readonly string[] };
+
+    expect(snapshot.permutive_segments).toHaveLength(100);
+    expect(Object.isFrozen(snapshot.permutive_segments)).toBe(true);
+    release();
+  });
+
+  it('rewrites a later SDK config and compare-restores every owned field', async () => {
+    vi.useFakeTimers();
+    const config = {
+      apiHost: 'api.permutive.com',
+      apiProtocol: 'https',
+      cdnBaseUrl: 'cdn.permutive.com',
+      cdnProtocol: 'https',
+      secureSignalsApiHost: 'signals.permutive.com',
+      segmentSyncApiHost: 'sync.permutive.com',
+    };
+    let available = false;
+    const runtime = createPermutiveRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => (available ? { config } : undefined),
+      getSegments: () => [],
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      registerContext: () => vi.fn(),
+      resetGuard: vi.fn(),
+      setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+    available = true;
+    await vi.advanceTimersByTimeAsync(50);
+
+    expect(config).toEqual({
+      apiHost: 'news.example/integrations/permutive/api',
+      apiProtocol: 'https',
+      cdnBaseUrl: 'news.example/integrations/permutive/cdn',
+      cdnProtocol: 'https',
+      secureSignalsApiHost: 'news.example/integrations/permutive/secure-signal',
+      segmentSyncApiHost: 'news.example/integrations/permutive/sync',
+    });
+    config.apiHost = 'publisher.example/replacement';
+    release();
+    expect(config).toEqual({
+      apiHost: 'publisher.example/replacement',
+      apiProtocol: 'https',
+      cdnBaseUrl: 'cdn.permutive.com',
+      cdnProtocol: 'https',
+      secureSignalsApiHost: 'signals.permutive.com',
+      segmentSyncApiHost: 'sync.permutive.com',
+    });
+  });
+
+  it('rolls back the guard when context registration is refused', () => {
+    const resetGuard = vi.fn();
+    const runtime = createPermutiveRuntime({
+      clearTimeout: (timer) => window.clearTimeout(timer),
+      getSdk: () => undefined,
+      getSegments: () => [],
+      installGuard: vi.fn(),
+      location: { host: 'news.example', protocol: 'https:' },
+      registerContext: () => undefined,
+      resetGuard,
+      setTimeout: (callback, delay) => window.setTimeout(callback, delay),
+      started: vi.fn(),
+      timedOut: vi.fn(),
+    });
+
+    expect(() => runtime.activate(undefined)).toThrowError('Permutive context registration failed');
+    expect(resetGuard).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/phase-slices.test.ts b/crates/trusted-server-js/lib/test/integrations/phase-slices.test.ts
new file mode 100644
index 000000000..6ecdcbfb6
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/phase-slices.test.ts
@@ -0,0 +1,301 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import type { IntegrationRegistration } from '../../src/kernel/integration_registry';
+import {
+  MAX_TAKEOVER_MODULES,
+  MAX_MANIFEST_MODULES,
+  RELEASE_CATALOG,
+  selectReleaseCatalog,
+} from '../../src/kernel/release_catalog';
+
+const RELEASE_ID = 'a'.repeat(64);
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+const EXPECTED_CATALOG = Object.freeze([
+  [
+    'render_runtime',
+    'takeover',
+    'always',
+    ['runtime.v1'],
+    [
+      'slots.v1',
+      'auction.v1',
+      'render.v1',
+      'messages.v1',
+      'trace.v1',
+      'trace.presentation.v1',
+      'direct.v1',
+    ],
+  ],
+  [
+    'aps',
+    'takeover',
+    'integration:aps',
+    ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'trace.v1'],
+    ['aps.v1'],
+  ],
+  ['creative', 'takeover', 'creative_guard', ['runtime.v1'], []],
+  ['datadome', 'takeover', 'integration:datadome', ['runtime.v1'], []],
+  ['didomi', 'takeover', 'integration:didomi', ['runtime.v1'], []],
+  ['google_tag_manager', 'takeover', 'integration:google_tag_manager', ['runtime.v1'], []],
+  [
+    'gpt',
+    'takeover',
+    'integration:gpt',
+    ['runtime.v1', 'slots.v1', 'auction.v1', 'render.v1', 'messages.v1', 'trace.v1', 'aps.v1?aps'],
+    ['gpt.v1', 'gpt.events.v1', 'pbs_cache.baseline.v1'],
+  ],
+  [
+    'gpt_diagnostics',
+    'takeover',
+    'gpt_diagnostics_active',
+    ['runtime.v1', 'gpt.events.v1'],
+    ['gpt_diag.v1'],
+  ],
+  ['lockr', 'takeover', 'integration:lockr', ['runtime.v1'], []],
+  ['osano_consent', 'takeover', 'integration:osano', ['runtime.v1'], ['osano_consent.v1']],
+  [
+    'permutive_context',
+    'takeover',
+    'integration:permutive',
+    ['runtime.v1'],
+    ['permutive_context.v1'],
+  ],
+  [
+    'sourcepoint_consent',
+    'takeover',
+    'integration:sourcepoint',
+    ['runtime.v1'],
+    ['sourcepoint_consent.v1'],
+  ],
+  [
+    'prebid',
+    'takeover',
+    'integration:prebid',
+    ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'aps.v1?aps'],
+    ['prebid.v1'],
+  ],
+  ['testlight', 'takeover', 'integration:testlight', ['runtime.v1'], []],
+  [
+    'diagnostics_presentation',
+    'deferred',
+    'diagnostics_presentation',
+    ['runtime.v1', 'trace.presentation.v1', 'gpt_diag.v1?gpt_diagnostics_active'],
+    [],
+  ],
+  [
+    'gpt_later',
+    'deferred',
+    'integration:gpt',
+    ['runtime.v1', 'slots.v1', 'auction.v1', 'render.v1', 'gpt.v1', 'trace.v1'],
+    [],
+  ],
+  ['osano_lifecycle', 'deferred', 'integration:osano', ['runtime.v1', 'osano_consent.v1'], []],
+  [
+    'permutive_lifecycle',
+    'deferred',
+    'integration:permutive',
+    ['runtime.v1', 'permutive_context.v1'],
+    [],
+  ],
+  [
+    'prebid_later',
+    'deferred',
+    'prebid_and_gpt',
+    ['runtime.v1', 'slots.v1', 'gpt.v1', 'prebid.v1'],
+    [],
+  ],
+  [
+    'sourcepoint_lifecycle',
+    'deferred',
+    'integration:sourcepoint',
+    ['runtime.v1', 'sourcepoint_consent.v1'],
+    [],
+  ],
+] as const);
+
+const DEFERRED_FACTORIES = Object.freeze([
+  [
+    'diagnostics_presentation',
+    '../../src/integrations/gpt_diagnostics/presentation',
+    'createDiagnosticsPresentationIntegrationRegistration',
+  ],
+  ['gpt_later', '../../src/integrations/gpt/later', 'createGptLaterIntegrationRegistration'],
+  [
+    'osano_lifecycle',
+    '../../src/integrations/osano/lifecycle',
+    'createOsanoLifecycleIntegrationRegistration',
+  ],
+  [
+    'permutive_lifecycle',
+    '../../src/integrations/permutive/lifecycle',
+    'createPermutiveLifecycleIntegrationRegistration',
+  ],
+  [
+    'prebid_later',
+    '../../src/integrations/prebid/later',
+    'createPrebidLaterIntegrationRegistration',
+  ],
+  [
+    'sourcepoint_lifecycle',
+    '../../src/integrations/sourcepoint/lifecycle',
+    'createSourcepointLifecycleIntegrationRegistration',
+  ],
+] as const);
+
+function selectedIds(selection: Parameters<typeof selectReleaseCatalog>[0]): readonly string[] {
+  return selectReleaseCatalog(selection).map(({ id }) => id);
+}
+
+function transitiveSources(entry: string): ReadonlySet<string> {
+  const visited = new Set<string>();
+  const visit = (relative: string): void => {
+    const normalized = relative.split('\\').join('/');
+    if (visited.has(normalized)) return;
+    visited.add(normalized);
+    const source = fs.readFileSync(path.join(packageRoot, normalized), 'utf8');
+    const expression = /(?:import|export)\s+(?:type\s+)?(?:[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+    for (const match of source.matchAll(expression)) {
+      const request = match[1];
+      if (!request?.startsWith('.')) continue;
+      const base = path.posix.normalize(path.posix.join(path.posix.dirname(normalized), request));
+      const candidates = [`${base}.ts`, `${base}.tsx`, path.posix.join(base, 'index.ts')];
+      const next = candidates.find((candidate) => fs.existsSync(path.join(packageRoot, candidate)));
+      if (next) visit(next);
+    }
+  };
+  visit(entry);
+  return visited;
+}
+
+describe('canonical takeover and deferred product slices', () => {
+  it('maps every spec catalog row exactly once with exact phase, predicate, and capabilities', () => {
+    expect(RELEASE_CATALOG).toHaveLength(MAX_MANIFEST_MODULES);
+    expect(MAX_MANIFEST_MODULES).toBe(20);
+    expect(MAX_TAKEOVER_MODULES).toBe(14);
+    expect(new Set(RELEASE_CATALOG.map(({ id }) => id))).toHaveLength(20);
+    expect(
+      RELEASE_CATALOG.map(({ id, phase, include, consumes, provides }) => [
+        id,
+        phase,
+        include,
+        [...consumes],
+        [...provides],
+      ])
+    ).toEqual(EXPECTED_CATALOG);
+    expect(RELEASE_CATALOG.every(({ obligation }) => obligation.trim().length > 0)).toBe(true);
+    expect(RELEASE_CATALOG.slice(0, 14).every(({ trigger }) => trigger === null)).toBe(true);
+    expect(
+      RELEASE_CATALOG.slice(14).every(
+        ({ trigger, provides }) => trigger === 'first_display_or_idle' && provides.length === 0
+      )
+    ).toBe(true);
+  });
+
+  it('selects every server-owned inclusion predicate without phase overrides', () => {
+    expect(selectedIds({ integrations: [] })).toEqual(['render_runtime']);
+    expect(
+      selectedIds({
+        integrations: ['aps', 'gpt', 'prebid', 'osano', 'permutive', 'sourcepoint'],
+        creative: { enabled: true, clickGuard: false, renderGuard: true },
+        gptDiagnosticsActive: true,
+      })
+    ).toEqual([
+      'render_runtime',
+      'aps',
+      'creative',
+      'gpt',
+      'gpt_diagnostics',
+      'osano_consent',
+      'permutive_context',
+      'sourcepoint_consent',
+      'prebid',
+      'diagnostics_presentation',
+      'gpt_later',
+      'osano_lifecycle',
+      'permutive_lifecycle',
+      'prebid_later',
+      'sourcepoint_lifecycle',
+    ]);
+    expect(
+      selectedIds({
+        integrations: ['prebid'],
+        creative: { enabled: true, clickGuard: false, renderGuard: false },
+        renderTraceOverlay: true,
+      })
+    ).toEqual(['render_runtime', 'prebid', 'diagnostics_presentation']);
+    expect(() => selectReleaseCatalog({ integrations: ['unknown'] })).toThrow(
+      'Unknown integration: unknown'
+    );
+  });
+
+  it('grants presentation authority to the one deferred presentation slice only', () => {
+    const presentationConsumers = RELEASE_CATALOG.filter(({ consumes }) =>
+      consumes.some((edge) => edge.startsWith('trace.presentation.v1'))
+    );
+    expect(presentationConsumers.map(({ id }) => id)).toEqual(['diagnostics_presentation']);
+    for (const id of ['aps', 'gpt', 'gpt_later']) {
+      expect(RELEASE_CATALOG.find((entry) => entry.id === id)?.consumes).not.toContain(
+        'trace.presentation.v1'
+      );
+    }
+  });
+
+  it.each(DEFERRED_FACTORIES)(
+    '%s exports its real release-bound deferred registration',
+    async (id, request, exportName) => {
+      const module = (await import(request)) as Record<string, unknown>;
+      const factory = module[exportName];
+      expect(factory).toEqual(expect.any(Function));
+      const registration = Reflect.apply(
+        factory as (releaseId: string) => IntegrationRegistration,
+        undefined,
+        [RELEASE_ID]
+      );
+      expect(registration).toMatchObject({ abi: 1, id, phase: 'deferred', releaseId: RELEASE_ID });
+      expect(Reflect.ownKeys(registration).sort()).toEqual([
+        'abi',
+        'id',
+        'phase',
+        'prepare',
+        'releaseId',
+      ]);
+      expect(Object.isFrozen(registration)).toBe(true);
+    }
+  );
+
+  it('keeps production core and deferred entry graphs free of test seams and owner duplication', () => {
+    const coreSources = transitiveSources('src/composition/runtime_transport.ts');
+    expect(
+      [...coreSources].some((source) => /(?:browser_test|\/test\/|ForTest)/.test(source))
+    ).toBe(false);
+    expect(
+      [...coreSources].filter((source) => source.startsWith('src/integrations/')).sort()
+    ).toEqual([
+      'src/integrations/render_runtime/module.ts',
+      'src/integrations/render_runtime/prebid_selection.ts',
+    ]);
+
+    for (const [, request] of DEFERRED_FACTORIES) {
+      const entry = `${request.replace('../../', 'src/').replace(/^src\/src\//, 'src/')}.ts`;
+      const sources = transitiveSources(entry);
+      expect([...sources].some((source) => source.startsWith('src/adapters/'))).toBe(false);
+      expect(
+        [...sources].some((source) => /composition\/browser(?:_test)?\.ts$/.test(source))
+      ).toBe(false);
+      expect([...sources].some((source) => source.endsWith('kernel/runtime.ts'))).toBe(false);
+    }
+  });
+
+  it('keeps the shared parser route owner in bootstrap instead of duplicating it in product slices', () => {
+    const routeOwner = 'src/first_display/leaf/browser_route_owner.ts';
+    expect(transitiveSources('src/core/bootstrap.ts')).toContain(routeOwner);
+    for (const slice of ['datadome', 'google_tag_manager', 'lockr', 'permutive', 'sourcepoint']) {
+      expect(transitiveSources(`src/first_display/slices/${slice}.ts`)).not.toContain(routeOwner);
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts b/crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts
deleted file mode 100644
index e98a7d711..000000000
--- a/crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts
+++ /dev/null
@@ -1,5619 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-function apsRenderer() {
-  const bid = envelope.seatbid[0].bid[0];
-  return {
-    type: 'aps' as const,
-    version: 1 as const,
-    accountId: 'example-account-id',
-    bidId: bid.id,
-    creativeId: 'fictional-creative-id',
-    tagType: 'iframe' as const,
-    creativeUrl: bid.ext.creativeurl,
-    aaxResponse: btoa(JSON.stringify(envelope)),
-    width: bid.w,
-    height: bid.h,
-  };
-}
-
-/**
- * Default external-bundle manifest for tests. Mirrors what the real external
- * Prebid.js bundle stamps on `window.__tsjs_prebid_bundle` (see
- * build-prebid-external.mjs). Individual tests override and restore it.
- */
-const DEFAULT_BUNDLE_MANIFEST = {
-  adapters: ['rubicon', 'openx', 'exampleBrowser', 'appnexus'],
-  bidderCodes: ['rubicon', 'openx', 'exampleBrowser', 'appnexus'],
-  userIdModules: ['sharedIdSystem'],
-};
-
-/** Loose bid shape used by the requestBids shim tests. */
-interface TestBid {
-  bidder: string;
-  params?: Record<string, unknown>;
-}
-
-/** Loose ad unit shape used by the requestBids shim tests. */
-interface TestAdUnit {
-  code?: string;
-  bids?: TestBid[];
-}
-
-/** Window properties the prebid shim reads and writes in these tests. */
-interface InjectedPrebidTestConfig {
-  accountId?: string;
-  timeout?: number;
-  debug?: boolean;
-  serverSideBidders?: string[];
-  clientSideBidders?: string[];
-  excludedGamAdUnitPathSuffixes?: unknown;
-}
-
-interface TestGoogletag {
-  cmd: { push: (fn: () => void) => void };
-  pubads: () => unknown;
-}
-
-interface ApsPrebidTestEntry {
-  adUnitCode: string;
-  markUsed(): void;
-}
-
-interface PrebidTestWindow {
-  pbjs?: unknown;
-  tsjs?: {
-    apsPrebidRenderers?: Record<string, ApsPrebidTestEntry>;
-    [key: string]: unknown;
-  };
-  googletag?: TestGoogletag;
-  __tsjs_prebid?: InjectedPrebidTestConfig;
-  __tsjsPrebidShimInstalled?: boolean;
-  __tsjs_prebid_bundle?: unknown;
-  __tsjs_prebid_diagnostics?: {
-    userIdModules?: {
-      includedModules: string[];
-      configuredUserIdNames: string[];
-      missingConfiguredUserIdNames: string[];
-    };
-  };
-}
-
-const testWindow = window as unknown as PrebidTestWindow;
-
-/** Argument type accepted by the shimmed `pbjs.requestBids`. */
-type RequestBidsArg = Parameters<ReturnType<typeof installPrebidNpm>['requestBids']>[0];
-
-/** The bid adapter spec object registered via `pbjs.registerBidAdapter`. */
-interface TestAdapterSpec {
-  code: string;
-  supportedMediaTypes: string[];
-  isBidRequestValid: (bid: Record<string, unknown>) => boolean;
-  buildRequests: (
-    bidRequests: Array<Record<string, unknown>>,
-    bidderRequest?: Record<string, unknown>
-  ) => {
-    method: string;
-    url: string;
-    data: Record<string, unknown>;
-    options: Record<string, unknown>;
-  };
-  interpretResponse: (
-    response: Record<string, unknown>,
-    request?: Record<string, unknown>
-  ) => Array<Record<string, unknown>>;
-}
-
-// Define mocks using vi.hoisted so they exist before the module under test is
-// imported. The shim reads Prebid.js from the `window.pbjs` global (owned by
-// the external bundle in production), so tests install the mock there instead
-// of mocking module imports.
-const {
-  mockSetConfig,
-  mockProcessQueue,
-  mockRequestBids,
-  mockRegisterBidAdapter,
-  mockGetUserIdsAsEids,
-  mockGetConfig,
-  mockRemoveAdUnit,
-  mockMarkWinningBidAsUsed,
-  mockOnEvent,
-  mockPbjs,
-} = vi.hoisted(() => {
-  const mockSetConfig = vi.fn();
-  const mockProcessQueue = vi.fn();
-  const mockRequestBids = vi.fn();
-  const mockRegisterBidAdapter = vi.fn();
-  const mockMarkWinningBidAsUsed = vi.fn();
-  const mockOnEvent = vi.fn();
-  const mockGetUserIdsAsEids = vi.fn(
-    () => [] as Array<{ source: string; uids?: Array<{ id: string; atype?: number }> }>
-  );
-  const mockGetConfig = vi.fn();
-
-  const mockRemoveAdUnit = vi.fn((adUnitCode?: string | string[]) => {
-    if (!adUnitCode) {
-      mockPbjs.adUnits = [];
-      return;
-    }
-    const codes = new Set(Array.isArray(adUnitCode) ? adUnitCode : [adUnitCode]);
-    mockPbjs.adUnits = mockPbjs.adUnits.filter((unit) => !codes.has(unit.code));
-  });
-  const mockPbjs: {
-    setConfig: typeof mockSetConfig;
-    processQueue: typeof mockProcessQueue;
-    requestBids: typeof mockRequestBids;
-    registerBidAdapter: typeof mockRegisterBidAdapter;
-    getUserIdsAsEids: typeof mockGetUserIdsAsEids;
-    getConfig: typeof mockGetConfig;
-    removeAdUnit: ReturnType<typeof vi.fn>;
-    markWinningBidAsUsed: typeof mockMarkWinningBidAsUsed;
-    adUnits: TestAdUnit[];
-    setTargetingForGPTAsync?: (adUnitCodes?: string[]) => void;
-    [key: string]: unknown;
-  } = {
-    setConfig: mockSetConfig,
-    processQueue: mockProcessQueue,
-    requestBids: mockRequestBids,
-    registerBidAdapter: mockRegisterBidAdapter,
-    getUserIdsAsEids: mockGetUserIdsAsEids,
-    getConfig: mockGetConfig,
-    removeAdUnit: mockRemoveAdUnit,
-    markWinningBidAsUsed: mockMarkWinningBidAsUsed,
-    onEvent: mockOnEvent,
-    adUnits: [] as TestAdUnit[],
-    setTargetingForGPTAsync: undefined as ((adUnitCodes?: string[]) => void) | undefined,
-    que: [] as Array<() => void>,
-    cmd: [] as Array<() => void>,
-  };
-
-  // Install the mock global BEFORE the shim module evaluates — the shim
-  // captures `window.pbjs` at module scope.
-  const w = globalThis.window as unknown as {
-    pbjs?: unknown;
-    __tsjs_prebid_bundle?: unknown;
-  };
-  w.pbjs = mockPbjs;
-  w.__tsjs_prebid_bundle = {
-    adapters: ['rubicon', 'openx', 'exampleBrowser', 'appnexus'],
-    bidderCodes: ['rubicon', 'openx', 'exampleBrowser', 'appnexus'],
-    userIdModules: ['sharedIdSystem'],
-  };
-
-  return {
-    mockSetConfig,
-    mockProcessQueue,
-    mockRequestBids,
-    mockRegisterBidAdapter,
-    mockGetUserIdsAsEids,
-    mockGetConfig,
-    mockRemoveAdUnit,
-    mockMarkWinningBidAsUsed,
-    mockOnEvent,
-    mockPbjs,
-  };
-});
-
-import {
-  collectBidders,
-  getInjectedConfig,
-  auctionBidsToPrebidBids,
-  installPrebidNpm,
-  installRefreshHandler,
-} from '../../../src/integrations/prebid/index';
-import { installTsAdInit } from '../../../src/integrations/gpt/index';
-import type { AuctionBid } from '../../../src/core/auction';
-import {
-  claimFirstImpressionForTrustedServer,
-  consumePublisherFirstImpressionDelivery,
-  firstImpressionClaim,
-  observeFirstImpressionGptLifecycle,
-  registerPublisherFirstImpressionAuctions,
-  releaseTrustedServerFirstImpressionClaim,
-  reservePublisherFirstImpressionFallback,
-} from '../../../src/core/first_impression';
-import { log } from '../../../src/core/log';
-import type { TsjsApi } from '../../../src/core/types';
-import { GptDiagnosticsObserver } from '../../../src/integrations/gpt_diagnostics/observer';
-import { GptDiagnosticsStore } from '../../../src/integrations/gpt_diagnostics/store';
-import envelope from '../../fixtures/aps-renderer-v1.json';
-
-// installPrebidNpm is a per-page no-op once the sentinel is set (the module
-// self-init above already set it), so every test starts from a clean page.
-beforeEach(() => {
-  delete testWindow.__tsjsPrebidShimInstalled;
-});
-
-describe('prebid/collectBidders', () => {
-  it('returns empty array for empty ad units', () => {
-    expect(collectBidders([])).toEqual([]);
-  });
-
-  it('returns empty array for ad units without bids', () => {
-    expect(collectBidders([{}, { bids: [] }])).toEqual([]);
-  });
-
-  it('collects unique bidders from ad units', () => {
-    const adUnits = [
-      { bids: [{ bidder: 'appnexus' }, { bidder: 'rubicon' }] },
-      { bids: [{ bidder: 'appnexus' }, { bidder: 'openx' }] },
-    ];
-    const result = collectBidders(adUnits);
-    expect(result).toHaveLength(3);
-    expect(result).toContain('appnexus');
-    expect(result).toContain('rubicon');
-    expect(result).toContain('openx');
-  });
-
-  it('skips bids without a bidder field', () => {
-    const adUnits = [{ bids: [{ bidder: 'kargo' }, {}] }];
-    expect(collectBidders(adUnits)).toEqual(['kargo']);
-  });
-});
-
-describe('prebid/getInjectedConfig', () => {
-  afterEach(() => {
-    delete testWindow.__tsjs_prebid;
-  });
-
-  it('returns undefined when window.__tsjs_prebid is not set', () => {
-    expect(getInjectedConfig()).toBeUndefined();
-  });
-
-  it('returns the injected config when present', () => {
-    testWindow.__tsjs_prebid = { accountId: 'server-42', timeout: 2000 };
-    expect(getInjectedConfig()).toEqual({ accountId: 'server-42', timeout: 2000 });
-  });
-});
-
-describe('prebid/auctionBidsToPrebidBids', () => {
-  it('maps AuctionBid[] to Prebid bid response objects', () => {
-    const auctionBids: AuctionBid[] = [
-      {
-        impid: 'div-gpt-1',
-        adm: '<div>Ad</div>',
-        price: 3.5,
-        width: 300,
-        height: 250,
-        seat: 'appnexus',
-        creativeId: 'cr-123',
-        adomain: ['example.com'],
-      },
-    ];
-    const bidRequests = [{ adUnitCode: 'div-gpt-1', bidId: 'bid-abc' }];
-
-    const result = auctionBidsToPrebidBids(auctionBids, bidRequests, true);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual({
-      requestId: 'bid-abc',
-      cpm: 3.5,
-      width: 300,
-      height: 250,
-      ad: '<div>Ad</div>',
-      ttl: 300,
-      creativeId: 'cr-123',
-      netRevenue: true,
-      currency: 'USD',
-      bidderCode: 'appnexus',
-      meta: { advertiserDomains: ['example.com'] },
-    });
-  });
-
-  it('preserves an APS renderer without converting it to executable markup', () => {
-    const renderer = apsRenderer();
-    const auctionBids: AuctionBid[] = [
-      {
-        impid: 'div-aps',
-        adm: '<script>must not become Prebid ad markup</script>',
-        renderer,
-        price: 1.23,
-        width: 300,
-        height: 250,
-        seat: 'aps',
-        creativeId: 'fictional-creative-id',
-        adomain: ['advertiser.example'],
-      },
-    ];
-
-    const result = auctionBidsToPrebidBids(
-      auctionBids,
-      [{ adUnitCode: 'div-aps', bidId: 'prebid-request-id' }],
-      true
-    );
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(
-      expect.objectContaining({
-        requestId: 'prebid-request-id',
-        bidderCode: 'aps',
-        ad: '',
-        trustedServerRenderer: renderer,
-        meta: expect.objectContaining({ trustedServerRenderer: renderer }),
-      })
-    );
-  });
-
-  it('drops an APS bid whose renderer fails admission validation', () => {
-    const result = auctionBidsToPrebidBids(
-      [
-        {
-          impid: 'div-aps',
-          adm: '',
-          renderer: { ...apsRenderer(), aaxResponse: 'invalid' },
-          price: 1.23,
-          width: 300,
-          height: 250,
-          seat: 'aps',
-          creativeId: 'fictional-creative-id',
-          adomain: [],
-        },
-      ],
-      [{ adUnitCode: 'div-aps', bidId: 'prebid-request-id' }],
-      true
-    );
-
-    expect(result).toEqual([]);
-  });
-
-  it('falls back to impid when no matching bidRequest found', () => {
-    const auctionBids: AuctionBid[] = [
-      {
-        impid: 'div-gpt-2',
-        adm: '<div>Ad2</div>',
-        price: 2.0,
-        width: 728,
-        height: 90,
-        seat: 'rubicon',
-        creativeId: 'cr-456',
-        adomain: [],
-      },
-    ];
-
-    const result = auctionBidsToPrebidBids(auctionBids, [], true);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].requestId).toBe('div-gpt-2');
-    expect(result[0].cpm).toBe(2.0);
-  });
-
-  it('handles multiple bids across different impids', () => {
-    const auctionBids: AuctionBid[] = [
-      {
-        impid: 'slot-a',
-        adm: '<div>A</div>',
-        price: 1.0,
-        width: 300,
-        height: 250,
-        seat: 'bidderA',
-        creativeId: 'cr-a',
-        adomain: [],
-      },
-      {
-        impid: 'slot-b',
-        adm: '<div>B</div>',
-        price: 2.0,
-        width: 728,
-        height: 90,
-        seat: 'bidderB',
-        creativeId: 'cr-b',
-        adomain: ['b.com'],
-      },
-    ];
-    const bidRequests = [
-      { adUnitCode: 'slot-a', bidId: 'req-a' },
-      { adUnitCode: 'slot-b', bidId: 'req-b' },
-    ];
-
-    const result = auctionBidsToPrebidBids(auctionBids, bidRequests, true);
-
-    expect(result).toHaveLength(2);
-    expect(result[0].requestId).toBe('req-a');
-    expect(result[1].requestId).toBe('req-b');
-  });
-});
-
-describe('prebid/installPrebidNpm', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Reset requestBids to the mock so each test starts fresh
-    mockPbjs.requestBids = mockRequestBids;
-    mockPbjs.adUnits = [];
-    mockGetUserIdsAsEids.mockReset();
-    mockGetUserIdsAsEids.mockReturnValue([]);
-    mockGetConfig.mockReset();
-    document.cookie = 'ts-eids=; Path=/; Max-Age=0';
-    delete testWindow.__tsjs_prebid;
-    delete testWindow.__tsjs_prebid_diagnostics;
-    delete testWindow.tsjs;
-    delete mockPbjs['__tsApsBidResponseListenerInstalled'];
-    delete mockPbjs.bidderSettings;
-  });
-
-  afterEach(() => {
-    delete mockPbjs.bidderSettings;
-    vi.restoreAllMocks();
-  });
-
-  it('registers the trustedServer bid adapter', () => {
-    installPrebidNpm();
-
-    expect(mockRegisterBidAdapter).toHaveBeenCalledTimes(1);
-    expect(mockRegisterBidAdapter).toHaveBeenCalledWith(
-      undefined,
-      'trustedServer',
-      expect.objectContaining({
-        code: 'trustedServer',
-        supportedMediaTypes: ['banner'],
-        isBidRequestValid: expect.any(Function),
-        buildRequests: expect.any(Function),
-        interpretResponse: expect.any(Function),
-      })
-    );
-  });
-
-  it('registers normalized APS descriptors at bidAccepted under Prebid generated ad IDs', () => {
-    installPrebidNpm();
-
-    const bidAcceptedListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidAccepted'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidAcceptedListener).toBeTypeOf('function');
-
-    const renderer = apsRenderer();
-    const normalizedBid: Record<string, unknown> = {
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'prebid-generated-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      meta: { trustedServerRenderer: renderer },
-    };
-    bidAcceptedListener!(normalizedBid);
-
-    const entry = testWindow.tsjs?.apsPrebidRenderers?.['prebid-generated-ad-id'];
-    expect(entry).toEqual(
-      expect.objectContaining({
-        adUnitCode: 'div-aps',
-        renderer,
-        expiresAt: expect.any(Number),
-        markUsed: expect.any(Function),
-      })
-    );
-
-    expect(normalizedBid).not.toHaveProperty('trustedServerRenderer');
-    expect(normalizedBid['meta']).not.toHaveProperty('trustedServerRenderer');
-    entry?.markUsed();
-    expect(mockMarkWinningBidAsUsed).toHaveBeenCalledWith({
-      adId: 'prebid-generated-ad-id',
-      events: true,
-    });
-  });
-
-  it('keeps bidResponse as a top-level renderer compatibility fallback', () => {
-    installPrebidNpm();
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    const renderer = apsRenderer();
-
-    bidResponseListener!({
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'fallback-ad-id',
-      adUnitCode: 'div-aps',
-      trustedServerRenderer: renderer,
-    });
-
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['fallback-ad-id']?.renderer).toEqual(renderer);
-  });
-
-  it('makes failed APS renderer registrations ineligible when zero-CPM bids are allowed', () => {
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    const malformedBid: Record<string, unknown> = {
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'malformed-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      cpm: 1.23,
-      meta: { trustedServerRenderer: { ...apsRenderer(), aaxResponse: 'invalid' } },
-    };
-    bidResponseListener!(malformedBid);
-    bidResponseListener!({
-      adapterCode: 'publisherAdapter',
-      bidderCode: 'aps',
-      adId: 'foreign-ad-id',
-      adUnitCode: 'div-aps',
-      trustedServerRenderer: apsRenderer(),
-    });
-
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['malformed-ad-id']).toBeUndefined();
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['foreign-ad-id']).toBeUndefined();
-    expect(malformedBid).not.toHaveProperty('trustedServerRenderer');
-    expect(malformedBid['meta']).not.toHaveProperty('trustedServerRenderer');
-    // Prebid's allowZeroCpmBids path still requires cpm >= 0.
-    expect(malformedBid['cpm']).toBe(-1);
-    expect(warnSpy).toHaveBeenCalledWith(
-      '[tsjs-prebid] rejected APS renderer capability that failed registration'
-    );
-  });
-
-  it('registers APS renderer via meta when Prebid strips the custom top-level field', () => {
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidResponseListener).toBeTypeOf('function');
-
-    const renderer = apsRenderer();
-    const [built] = auctionBidsToPrebidBids(
-      [
-        {
-          impid: 'div-aps',
-          renderer,
-          price: 1.0,
-          width: 300,
-          height: 250,
-          seat: 'aps',
-          creativeId: 'cr-aps',
-          adomain: [],
-        },
-      ],
-      [{ adUnitCode: 'div-aps', bidId: 'req-strip' }],
-      true
-    );
-
-    // Prebid delivered the bid with the custom top-level field REMOVED — only
-    // first-class fields (requestId, meta) survive normalization.
-    const delivered: Record<string, unknown> = {
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'stripped-field-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      requestId: built.requestId,
-      meta: built.meta,
-    };
-    bidResponseListener!(delivered);
-
-    const entry = testWindow.tsjs?.apsPrebidRenderers?.['stripped-field-ad-id'];
-    expect(entry).toEqual(
-      expect.objectContaining({ adUnitCode: 'div-aps', renderer, markUsed: expect.any(Function) })
-    );
-    // The capability is scrubbed from the delivered bid after registration.
-    expect(delivered.meta).not.toHaveProperty('trustedServerRenderer');
-  });
-
-  it('registers a distinct renderer for each of multiple APS bids on one imp', () => {
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidResponseListener).toBeTypeOf('function');
-
-    // Two APS bids for the same imp share a requestId; each built bid must carry
-    // its own descriptor so neither registration is lost.
-    const firstRenderer = { ...apsRenderer(), creativeId: 'cr-aps-first' };
-    const secondRenderer = { ...apsRenderer(), creativeId: 'cr-aps-second' };
-    const sharedBid = {
-      impid: 'div-aps',
-      price: 1.0,
-      width: 300,
-      height: 250,
-      seat: 'aps',
-      adomain: [],
-    };
-    const built = auctionBidsToPrebidBids(
-      [
-        { ...sharedBid, renderer: firstRenderer, creativeId: 'cr-aps-first' },
-        { ...sharedBid, renderer: secondRenderer, creativeId: 'cr-aps-second' },
-      ],
-      [{ adUnitCode: 'div-aps', bidId: 'req-shared' }],
-      true
-    );
-    expect(built).toHaveLength(2);
-
-    for (const [index, bid] of built.entries()) {
-      bidResponseListener!({
-        adapterCode: 'trustedServer',
-        bidderCode: 'aps',
-        adId: `shared-imp-ad-id-${index}`,
-        adUnitCode: 'div-aps',
-        ttl: 300,
-        requestId: bid.requestId,
-        meta: bid.meta,
-      });
-    }
-
-    const registry = testWindow.tsjs?.apsPrebidRenderers;
-    expect(registry?.['shared-imp-ad-id-0']).toEqual(
-      expect.objectContaining({ renderer: firstRenderer })
-    );
-    expect(registry?.['shared-imp-ad-id-1']).toEqual(
-      expect.objectContaining({ renderer: secondRenderer })
-    );
-  });
-
-  it('does not register anything for a stripped bid that carries no meta descriptor', () => {
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidResponseListener).toBeTypeOf('function');
-
-    // First bid registers through the surviving custom-field path.
-    bidResponseListener!({
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'surviving-field-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      requestId: 'req-reused',
-      trustedServerRenderer: apsRenderer(),
-    });
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['surviving-field-ad-id']).toBeDefined();
-
-    // A later field-stripped bid reusing the same requestId has no descriptor of its
-    // own, so no stale renderer may be registered for it.
-    bidResponseListener!({
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'reused-request-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      requestId: 'req-reused',
-      meta: { advertiserDomains: [] },
-    });
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['reused-request-ad-id']).toBeUndefined();
-  });
-
-  it('registers and scrubs on bidAccepted before later events can observe the descriptor', () => {
-    installPrebidNpm();
-
-    const bidAcceptedListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidAccepted'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidAcceptedListener).toBeTypeOf('function');
-    expect(bidResponseListener).toBeTypeOf('function');
-
-    const renderer = apsRenderer();
-    const [built] = auctionBidsToPrebidBids(
-      [
-        {
-          impid: 'div-aps',
-          renderer,
-          price: 1.0,
-          width: 300,
-          height: 250,
-          seat: 'aps',
-          creativeId: 'cr-aps',
-          adomain: [],
-        },
-      ],
-      [{ adUnitCode: 'div-aps', bidId: 'req-accepted' }],
-      true
-    );
-
-    // Prebid emits bidAccepted and bidResponse with the same in-place-mutated
-    // bid object; the bidAccepted pass must register and scrub both carriers.
-    const accepted: Record<string, unknown> = {
-      ...built,
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'accepted-ad-id',
-      adUnitCode: 'div-aps',
-    };
-    bidAcceptedListener!(accepted);
-
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['accepted-ad-id']).toEqual(
-      expect.objectContaining({ adUnitCode: 'div-aps', renderer })
-    );
-    expect(accepted).not.toHaveProperty('trustedServerRenderer');
-    expect(accepted.meta).not.toHaveProperty('trustedServerRenderer');
-
-    // The later bidResponse pass sees the already-scrubbed object and no-ops.
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-    bidResponseListener!(accepted);
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['accepted-ad-id']).toEqual(
-      expect.objectContaining({ renderer })
-    );
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  it('tolerates a non-object meta value on the bid', () => {
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    expect(bidResponseListener).toBeTypeOf('function');
-
-    // A module overwrote meta with a string and there is no top-level field:
-    // nothing registers and nothing throws.
-    bidResponseListener!({
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'corrupt-meta-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      meta: 'corrupted',
-    });
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['corrupt-meta-ad-id']).toBeUndefined();
-
-    // With a surviving top-level field the corrupt meta must not block registration.
-    bidResponseListener!({
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'corrupt-meta-with-field-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      meta: 'corrupted',
-      trustedServerRenderer: apsRenderer(),
-    });
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['corrupt-meta-with-field-ad-id']).toBeDefined();
-  });
-
-  it('does not register malformed or non-trusted APS renderer capabilities', () => {
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-    installPrebidNpm();
-
-    const bidResponseListener = mockOnEvent.mock.calls.find(
-      ([eventName]) => eventName === 'bidResponse'
-    )?.[1] as ((bid: Record<string, unknown>) => void) | undefined;
-    const malformedBid: Record<string, unknown> = {
-      adapterCode: 'trustedServer',
-      bidderCode: 'aps',
-      adId: 'malformed-ad-id',
-      adUnitCode: 'div-aps',
-      ttl: 300,
-      trustedServerRenderer: { ...apsRenderer(), aaxResponse: 'invalid' },
-    };
-    bidResponseListener!(malformedBid);
-    bidResponseListener!({
-      adapterCode: 'publisherAdapter',
-      bidderCode: 'aps',
-      adId: 'foreign-ad-id',
-      adUnitCode: 'div-aps',
-      trustedServerRenderer: apsRenderer(),
-    });
-
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['malformed-ad-id']).toBeUndefined();
-    expect(testWindow.tsjs?.apsPrebidRenderers?.['foreign-ad-id']).toBeUndefined();
-    expect(malformedBid).not.toHaveProperty('trustedServerRenderer');
-    expect(warnSpy).toHaveBeenCalledWith(
-      '[tsjs-prebid] rejected APS renderer capability that failed registration'
-    );
-  });
-
-  it('calls setConfig with debug=false by default', () => {
-    installPrebidNpm();
-
-    expect(mockSetConfig).toHaveBeenCalledWith(expect.objectContaining({ debug: false }));
-  });
-
-  it('respects custom config values', () => {
-    installPrebidNpm({
-      endpoint: '/custom/auction',
-      timeout: 2000,
-      debug: true,
-    });
-
-    expect(mockSetConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ debug: true, bidderTimeout: 2000 })
-    );
-  });
-
-  it('calls processQueue after configuration', () => {
-    installPrebidNpm();
-    expect(mockProcessQueue).toHaveBeenCalledTimes(1);
-  });
-
-  it('reports the User ID modules selected by the generated bundle', () => {
-    installPrebidNpm();
-
-    expect(testWindow.__tsjs_prebid_diagnostics.userIdModules).toEqual({
-      includedModules: ['sharedIdSystem'],
-      configuredUserIdNames: [],
-      missingConfiguredUserIdNames: [],
-    });
-  });
-
-  it('refreshes late User ID config without repeating missing-module warnings', () => {
-    installPrebidNpm();
-    mockGetConfig.mockImplementation((key?: string) =>
-      key === 'userSync.userIds' ? [{ name: 'sharedId' }, { name: 'pairId' }] : {}
-    );
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-
-    mockPbjs.requestBids({ adUnits: [] });
-    mockPbjs.requestBids({ adUnits: [] });
-
-    expect(testWindow.__tsjs_prebid_diagnostics.userIdModules).toEqual({
-      includedModules: ['sharedIdSystem'],
-      configuredUserIdNames: ['pairId', 'sharedId'],
-      missingConfiguredUserIdNames: ['pairId'],
-    });
-    expect(
-      warnSpy.mock.calls.filter(([message]) => String(message).includes('"pairId"'))
-    ).toHaveLength(1);
-  });
-
-  it('returns the pbjs instance', () => {
-    const result = installPrebidNpm();
-    expect(result).toBe(mockPbjs);
-  });
-
-  it('installs only once per page via the __tsjsPrebidShimInstalled sentinel', () => {
-    const first = installPrebidNpm();
-    const wrappedRequestBids = mockPbjs.requestBids;
-    const second = installPrebidNpm();
-
-    expect(second).toBe(first);
-    expect(mockRegisterBidAdapter).toHaveBeenCalledTimes(1);
-    expect(mockPbjs.requestBids).toBe(wrappedRequestBids);
-    expect(testWindow.__tsjsPrebidShimInstalled).toBe(true);
-  });
-
-  it('warns once about an unstamped User ID manifest instead of once per module', () => {
-    delete testWindow.__tsjs_prebid_bundle;
-    mockGetConfig.mockImplementation((key?: string) =>
-      key === 'userSync.userIds' ? [{ name: 'sharedId' }, { name: 'pairId' }] : {}
-    );
-    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
-
-    installPrebidNpm();
-    mockPbjs.requestBids({ adUnits: [] });
-
-    expect(testWindow.__tsjs_prebid_diagnostics.userIdModules).toEqual({
-      includedModules: [],
-      configuredUserIdNames: ['pairId', 'sharedId'],
-      missingConfiguredUserIdNames: [],
-    });
-    const manifestWarnings = warnSpy.mock.calls.filter(([message]) =>
-      String(message).includes('did not stamp a User ID module manifest')
-    );
-    expect(manifestWarnings).toHaveLength(1);
-    const moduleWarnings = warnSpy.mock.calls.filter(([message]) =>
-      String(message).includes('is not included in the external bundle')
-    );
-    expect(moduleWarnings).toHaveLength(0);
-
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  describe('adapter spec', () => {
-    function getAdapterSpec(): TestAdapterSpec {
-      installPrebidNpm();
-      return mockRegisterBidAdapter.mock.calls[0][2] as TestAdapterSpec;
-    }
-
-    it('isBidRequestValid always returns true', () => {
-      const spec = getAdapterSpec();
-      expect(spec.isBidRequestValid({})).toBe(true);
-    });
-
-    it('buildRequests creates a POST request to /auction', () => {
-      const spec = getAdapterSpec();
-      const bidRequests = [
-        {
-          adUnitCode: 'div-gpt-1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          params: {},
-        },
-      ];
-
-      const result = spec.buildRequests(bidRequests);
-
-      expect(result.method).toBe('POST');
-      expect(result.url).toBe('/auction');
-      expect(result.options).toEqual({ contentType: 'application/json' });
-
-      const payload = JSON.parse(result.data);
-      expect(payload.adUnits).toHaveLength(1);
-      expect(payload.adUnits[0].code).toBe('div-gpt-1');
-      expect(payload.eids).toBeUndefined();
-    });
-
-    it('buildRequests includes current Prebid EIDs in the /auction payload', () => {
-      const spec = getAdapterSpec();
-      mockGetUserIdsAsEids.mockReturnValue([
-        {
-          source: 'id5-sync.com',
-          uids: [{ id: 'ID5_abc', atype: 1 }],
-        },
-        {
-          source: 'sharedid.org',
-          uids: [{ id: 'shared_123' }, { id: 'shared_456', atype: 3 }],
-        },
-        {
-          source: 'google.com',
-          uids: [{ id: 'pair_123', atype: 571187 }],
-        },
-      ]);
-
-      const result = spec.buildRequests([
-        {
-          adUnitCode: 'div-gpt-1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          params: {},
-        },
-      ]);
-
-      const payload = JSON.parse(result.data);
-      expect(payload.eids).toEqual([
-        {
-          source: 'id5-sync.com',
-          uids: [{ id: 'ID5_abc', atype: 1 }],
-        },
-        {
-          source: 'sharedid.org',
-          uids: [{ id: 'shared_123' }, { id: 'shared_456', atype: 3 }],
-        },
-        {
-          source: 'google.com',
-          uids: [{ id: 'pair_123', atype: 571187 }],
-        },
-      ]);
-    });
-
-    it('buildRequests clears stale ts-eids cookie when current Prebid EIDs are absent', () => {
-      const spec = getAdapterSpec();
-      document.cookie = 'ts-eids=stale-value';
-      mockGetUserIdsAsEids.mockReturnValue([]);
-
-      spec.buildRequests([
-        {
-          adUnitCode: 'div-gpt-1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          params: {},
-        },
-      ]);
-
-      expect(document.cookie).toBe('');
-    });
-
-    it('buildRequests preserves uid ext and sanitizes invalid atype values', () => {
-      const spec = getAdapterSpec();
-      mockGetUserIdsAsEids.mockReturnValue([
-        {
-          source: 'adserver.org',
-          uids: [
-            {
-              id: 'uid-with-ext',
-              atype: 1,
-              ext: { provider: 'liveintent.com', rtiPartner: 'TDID' },
-            },
-            {
-              id: 'uid-bad-atype',
-              atype: 2_147_483_648,
-              ext: { keep: true },
-            },
-            {
-              id: 'uid-float-atype',
-              atype: 1.5,
-            },
-          ],
-        },
-      ]);
-
-      const result = spec.buildRequests([
-        {
-          adUnitCode: 'div-gpt-1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          params: {},
-        },
-      ]);
-
-      const payload = JSON.parse(result.data);
-      expect(payload.eids).toEqual([
-        {
-          source: 'adserver.org',
-          uids: [
-            {
-              id: 'uid-with-ext',
-              atype: 1,
-              ext: { provider: 'liveintent.com', rtiPartner: 'TDID' },
-            },
-            {
-              id: 'uid-bad-atype',
-              ext: { keep: true },
-            },
-            {
-              id: 'uid-float-atype',
-            },
-          ],
-        },
-      ]);
-    });
-
-    it('buildRequests uses custom endpoint when configured', () => {
-      mockRegisterBidAdapter.mockClear();
-      installPrebidNpm({ endpoint: '/custom/auction' });
-      const spec = mockRegisterBidAdapter.mock.calls[0][2];
-
-      const result = spec.buildRequests([
-        {
-          adUnitCode: 'slot1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-        },
-      ]);
-
-      expect(result.url).toBe('/custom/auction');
-    });
-
-    it('interpretResponse parses seatbid and returns Prebid bids', () => {
-      const spec = getAdapterSpec();
-
-      const built = spec.buildRequests([
-        {
-          adUnitCode: 'div-gpt-1',
-          bidId: 'bid-1',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-        },
-      ]);
-
-      const serverResponse = {
-        body: {
-          seatbid: [
-            {
-              seat: 'appnexus',
-              bid: [
-                {
-                  impid: 'div-gpt-1',
-                  price: 4.5,
-                  adm: '<div>Creative</div>',
-                  w: 300,
-                  h: 250,
-                  crid: 'cr-789',
-                  adomain: ['advertiser.com'],
-                },
-              ],
-            },
-          ],
-        },
-      };
-
-      const bids = spec.interpretResponse(serverResponse, built);
-
-      expect(bids).toHaveLength(1);
-      expect(bids[0]).toEqual(
-        expect.objectContaining({
-          requestId: 'bid-1',
-          cpm: 4.5,
-          width: 300,
-          height: 250,
-          ad: '<div>Creative</div>',
-          currency: 'USD',
-          netRevenue: true,
-          bidderCode: 'appnexus',
-        })
-      );
-    });
-
-    it('interpretResponse handles empty/missing seatbid', () => {
-      const spec = getAdapterSpec();
-      const built = spec.buildRequests([]);
-
-      expect(spec.interpretResponse({ body: {} }, built)).toEqual([]);
-      expect(spec.interpretResponse({ body: null }, built)).toEqual([]);
-      expect(spec.interpretResponse({}, built)).toEqual([]);
-    });
-
-    it('keeps request mapping isolated across overlapping auctions', () => {
-      const spec = getAdapterSpec();
-
-      const requestA = spec.buildRequests([
-        {
-          adUnitCode: 'slot-a',
-          bidId: 'bid-a',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-        },
-      ]);
-      const requestB = spec.buildRequests([
-        {
-          adUnitCode: 'slot-b',
-          bidId: 'bid-b',
-          bidder: 'trustedServer',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-        },
-      ]);
-
-      const responseA = {
-        body: {
-          seatbid: [
-            {
-              seat: 'appnexus',
-              bid: [{ impid: 'slot-a', price: 1.1, adm: '<div>A</div>', w: 300, h: 250 }],
-            },
-          ],
-        },
-      };
-      const responseB = {
-        body: {
-          seatbid: [
-            {
-              seat: 'rubicon',
-              bid: [{ impid: 'slot-b', price: 2.2, adm: '<div>B</div>', w: 300, h: 250 }],
-            },
-          ],
-        },
-      };
-
-      const bidsA = spec.interpretResponse(responseA, requestA);
-      const bidsB = spec.interpretResponse(responseB, requestB);
-
-      expect(bidsA[0].requestId).toBe('bid-a');
-      expect(bidsB[0].requestId).toBe('bid-b');
-    });
-  });
-
-  describe('requestBids shim', () => {
-    beforeEach(() => {
-      testWindow.__tsjs_prebid = {
-        serverSideBidders: ['appnexus', 'rubicon', 'kargo', 'openx'],
-      };
-    });
-
-    it('limits a global request to opts.adUnitCodes', () => {
-      const selected = document.createElement('div');
-      selected.id = 'selected-global-unit';
-      const unselected = document.createElement('div');
-      unselected.id = 'unselected-global-unit';
-      document.body.append(selected, unselected);
-      const selectedUnit = {
-        code: selected.id,
-        bids: [{ bidder: 'appnexus', params: { placementId: 1 } }],
-      };
-      const unselectedUnit = {
-        code: unselected.id,
-        bids: [{ bidder: 'rubicon', params: { accountId: 2 } }],
-      };
-      mockPbjs.adUnits = [selectedUnit, unselectedUnit];
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({ adUnitCodes: [selected.id] } as unknown as RequestBidsArg);
-
-      expect(selectedUnit.bids.map((bid) => bid.bidder)).toEqual(['trustedServer']);
-      expect(unselectedUnit.bids).toEqual([{ bidder: 'rubicon', params: { accountId: 2 } }]);
-      expect((testWindow.tsjs as TsjsApi).firstImpression?.slots[selected.id]).toBeDefined();
-      expect((testWindow.tsjs as TsjsApi).firstImpression?.slots[unselected.id]).toBeUndefined();
-
-      selected.remove();
-      unselected.remove();
-    });
-
-    it('preserves publisher ts adserverTargeting while adding trustedServer settings', () => {
-      const publisherTargeting = [{ key: 'ts', val: () => 'publisher-value' }];
-      mockPbjs.bidderSettings = {
-        exampleBidder: { adserverTargeting: publisherTargeting },
-      };
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({
-        adUnits: [{ bids: [{ bidder: 'exampleBidder', params: {} }] }],
-      } as unknown as RequestBidsArg);
-
-      const bidderSettings = mockPbjs.bidderSettings as {
-        exampleBidder: { adserverTargeting: typeof publisherTargeting };
-        trustedServer: {
-          allowAlternateBidderCodes: boolean;
-          allowedAlternateBidderCodes: string[];
-        };
-      };
-      expect(bidderSettings.exampleBidder.adserverTargeting).toBe(publisherTargeting);
-      expect(bidderSettings.exampleBidder.adserverTargeting[0].key).toBe('ts');
-      expect(bidderSettings.exampleBidder.adserverTargeting[0].val()).toBe('publisher-value');
-      expect(bidderSettings.trustedServer).toEqual(
-        expect.objectContaining({
-          allowAlternateBidderCodes: true,
-          allowedAlternateBidderCodes: ['*'],
-        })
-      );
-    });
-
-    it('injects trustedServer bidder into every ad unit', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [
-        { bids: [{ bidder: 'appnexus', params: {} }] },
-        { bids: [{ bidder: 'rubicon', params: {} }] },
-      ];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      // Each ad unit should have trustedServer added
-      for (const unit of adUnits) {
-        const hasTsBidder = unit.bids.some((b: TestBid) => b.bidder === 'trustedServer');
-        expect(hasTsBidder).toBe(true);
-      }
-
-      const trustedServerBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer');
-      expect(trustedServerBid.params.bidderParams).toEqual({ appnexus: {} });
-      expect(adUnits[0].bids.map((b: TestBid) => b.bidder)).toEqual(['trustedServer']);
-      expect(adUnits[1].bids.map((b: TestBid) => b.bidder)).toEqual(['trustedServer']);
-
-      // Should call through to original requestBids
-      expect(mockRequestBids).toHaveBeenCalled();
-    });
-
-    it('does not duplicate trustedServer if already present', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [{ bids: [{ bidder: 'trustedServer', params: {} }] }];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const tsCount = adUnits[0].bids.filter((b: TestBid) => b.bidder === 'trustedServer').length;
-      expect(tsCount).toBe(1);
-    });
-
-    it('folds only authoritative routes across mixed client, PBS, APS, and standard demand', () => {
-      testWindow.__tsjs_prebid = {
-        serverSideBidders: ['pbsRoute', 'standardRoute'],
-        clientSideBidders: ['exampleBrowser'],
-      };
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [
-        {
-          bids: [
-            { bidder: 'exampleBrowser', params: { placement: 'browser' } },
-            { bidder: 'pbsRoute', params: { placement: 'pbs' } },
-            { bidder: 'aps', params: { slot: 'aps' } },
-            { bidder: 'standardRoute', params: { placement: 'standard' } },
-            { bidder: 'pbs-provider-id', params: { forbidden: true } },
-          ],
-        },
-      ];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const trustedServerBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer');
-      expect(trustedServerBid?.params?.bidderParams).toEqual({
-        pbsRoute: { placement: 'pbs' },
-        standardRoute: { placement: 'standard' },
-      });
-      expect(adUnits[0].bids.map((b: TestBid) => b.bidder)).toEqual([
-        'exampleBrowser',
-        'aps',
-        'pbs-provider-id',
-        'trustedServer',
-      ]);
-    });
-
-    it('preserves prototype-named server-side bidders as owned JSON properties', () => {
-      testWindow.__tsjs_prebid = { serverSideBidders: ['__proto__'] };
-      const pbjs = installPrebidNpm();
-      const adUnits = [
-        {
-          bids: [{ bidder: '__proto__', params: { placement: 'server-owned' } }],
-        },
-      ];
-
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const trustedServerBid = adUnits[0].bids.find((bid) => bid.bidder === 'trustedServer');
-      const bidderParams = trustedServerBid?.params?.bidderParams as Record<string, unknown>;
-      expect(Object.prototype.hasOwnProperty.call(bidderParams, '__proto__')).toBe(true);
-      expect(bidderParams['__proto__']).toEqual({ placement: 'server-owned' });
-      expect(JSON.parse(JSON.stringify(bidderParams))).toEqual(
-        Object.fromEntries([['__proto__', { placement: 'server-owned' }]])
-      );
-      expect(adUnits[0].bids.map((bid) => bid.bidder)).toEqual(['trustedServer']);
-    });
-
-    it('does not let returned bidder aliases or APS renderer aliases affect folding', () => {
-      testWindow.__tsjs_prebid = { serverSideBidders: ['configuredRoute'] };
-      const pbjs = installPrebidNpm();
-      const adUnits = [
-        {
-          bids: [
-            { bidder: 'configuredRoute', params: { placement: 1 } },
-            { bidder: 'alternateReturnedSeat', params: { placement: 2 } },
-            { bidder: 'apsRendererAlias', params: { placement: 3 } },
-          ],
-        },
-      ];
-
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const trustedServerBid = adUnits[0].bids.find((bid) => bid.bidder === 'trustedServer');
-      expect(trustedServerBid?.params?.bidderParams).toEqual({
-        configuredRoute: { placement: 1 },
-      });
-      expect(adUnits[0].bids.map((bid) => bid.bidder)).toEqual([
-        'alternateReturnedSeat',
-        'apsRendererAlias',
-        'trustedServer',
-      ]);
-    });
-
-    it('preserves captured bidder params when requestBids runs twice on the same ad unit', () => {
-      const pbjs = installPrebidNpm();
-
-      // First auction: inline server-side params supplied by the publisher.
-      const adUnits = [
-        {
-          code: 'div-1',
-          bids: [
-            { bidder: 'appnexus', params: { placementId: 123 } },
-            { bidder: 'rubicon', params: { accountId: 'abc' } },
-          ],
-        },
-      ];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      // Second auction (refresh/re-auction) with the SAME ad unit object: the
-      // server-side bidder entries were already pruned, so the shim must not
-      // overwrite the captured params with an empty object.
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const trustedServerBid = adUnits[0].bids.find(
-        (b: TestBid) => b.bidder === 'trustedServer'
-      ) as TestBid;
-      expect(trustedServerBid.params.bidderParams).toEqual({
-        appnexus: { placementId: 123 },
-        rubicon: { accountId: 'abc' },
-      });
-    });
-
-    it('adds bids array to ad units that have none', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [{ code: 'div-1' }] as TestAdUnit[];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      expect(adUnits[0].bids).toHaveLength(1);
-      expect(adUnits[0].bids[0].bidder).toBe('trustedServer');
-    });
-
-    it('normalizes a truthy non-array bids value without throwing', () => {
-      const pbjs = installPrebidNpm();
-      const adUnits = [
-        { code: 'example-malformed-slot', bids: { malformed: true } },
-      ] as TestAdUnit[];
-
-      expect(() => pbjs.requestBids({ adUnits } as unknown as RequestBidsArg)).not.toThrow();
-
-      expect(adUnits[0].bids).toEqual([{ bidder: 'trustedServer', params: { bidderParams: {} } }]);
-    });
-
-    it('preserves the empty stored-request envelope on initial and repeated requests', () => {
-      const pbjs = installPrebidNpm();
-      const adUnits = [
-        {
-          code: 'stored-slot',
-          bids: [{ bidder: 'trustedServer', params: { bidderParams: {} } }],
-        },
-      ];
-
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      expect(adUnits[0].bids).toEqual([{ bidder: 'trustedServer', params: { bidderParams: {} } }]);
-    });
-
-    it('includes zone from mediaTypes.banner.name in trustedServer params', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [
-        {
-          code: 'ad-header-0',
-          mediaTypes: { banner: { name: 'header', sizes: [[728, 90]] } },
-          bids: [{ bidder: 'kargo', params: { placementId: '_abc' } }],
-        },
-        {
-          code: 'ad-fixed_bottom-0',
-          mediaTypes: { banner: { name: 'fixed_bottom', sizes: [[728, 90]] } },
-          bids: [{ bidder: 'kargo', params: { placementId: '_def' } }],
-        },
-      ];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const tsBid0 = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid0.params.zone).toBe('header');
-
-      const tsBid1 = adUnits[1].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid1.params.zone).toBe('fixed_bottom');
-    });
-
-    it('omits zone when mediaTypes.banner.name is not set', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [
-        {
-          code: 'ad-header-0',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          bids: [{ bidder: 'appnexus', params: {} }],
-        },
-      ];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid.params.zone).toBeUndefined();
-    });
-
-    it('omits zone when ad unit has no mediaTypes', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [{ bids: [{ bidder: 'rubicon', params: {} }] }];
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid.params.zone).toBeUndefined();
-    });
-
-    it('clears stale zone when existing trustedServer bid is reused', () => {
-      const pbjs = installPrebidNpm();
-
-      const adUnits = [
-        {
-          code: 'ad-header-0',
-          mediaTypes: { banner: { name: 'header', sizes: [[300, 250]] } },
-          bids: [
-            { bidder: 'trustedServer', params: { custom: 'keep' } },
-            { bidder: 'kargo', params: { placementId: '_abc' } },
-          ],
-        },
-      ];
-
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      let tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid.params.zone).toBe('header');
-      expect(tsBid.params.custom).toBe('keep');
-
-      delete adUnits[0].mediaTypes.banner.name;
-      pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-      tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-      expect(tsBid.params.zone).toBeUndefined();
-      expect(tsBid.params.custom).toBe('keep');
-    });
-
-    it('falls back to pbjs.adUnits when requestObj has no adUnits', () => {
-      const pbjs = installPrebidNpm();
-
-      mockPbjs.adUnits = [{ bids: [{ bidder: 'openx', params: {} }] }] as TestAdUnit[];
-      pbjs.requestBids({} as RequestBidsArg);
-
-      const hasTsBidder = (mockPbjs.adUnits[0].bids ?? []).some(
-        (b: TestBid) => b.bidder === 'trustedServer'
-      );
-      expect(hasTsBidder).toBe(true);
-    });
-
-    it('syncs a structured ts-eids cookie after bidsBackHandler', () => {
-      mockRequestBids.mockImplementation((opts?: { bidsBackHandler?: () => void }) => {
-        opts?.bidsBackHandler?.();
-      });
-      mockGetUserIdsAsEids.mockReturnValue([
-        {
-          source: 'sharedid.org',
-          uids: [
-            { id: 'shared_123', atype: 3 },
-            { id: 'shared_456', ext: { provider: 'example' } },
-          ],
-        },
-      ]);
-
-      const pbjs = installPrebidNpm();
-      pbjs.requestBids({
-        adUnits: [{ bids: [{ bidder: 'appnexus', params: {} }] }],
-      } as unknown as RequestBidsArg);
-
-      const cookieValue = document.cookie.match(/(?:^|; )ts-eids=([^;]+)/)?.[1];
-      expect(cookieValue).toBeDefined();
-      expect(JSON.parse(atob(cookieValue!))).toEqual([
-        {
-          source: 'sharedid.org',
-          uids: [
-            { id: 'shared_123', atype: 3 },
-            { id: 'shared_456', ext: { provider: 'example' } },
-          ],
-        },
-      ]);
-    });
-
-    it('clears ts-eids cookie after bidsBackHandler when no current EIDs remain', () => {
-      document.cookie = `ts-eids=${btoa(JSON.stringify([{ source: 'sharedid.org', uids: [{ id: 'stale' }] }]))}`;
-      mockRequestBids.mockImplementation((opts?: { bidsBackHandler?: () => void }) => {
-        opts?.bidsBackHandler?.();
-      });
-      mockGetUserIdsAsEids.mockReturnValue([]);
-
-      const pbjs = installPrebidNpm();
-      pbjs.requestBids({
-        adUnits: [{ bids: [{ bidder: 'appnexus', params: {} }] }],
-      } as unknown as RequestBidsArg);
-
-      expect(document.cookie).toBe('');
-    });
-  });
-});
-
-describe('prebid/installPrebidNpm with server-injected config', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockPbjs.requestBids = mockRequestBids;
-    mockPbjs.adUnits = [];
-    mockGetUserIdsAsEids.mockReset();
-    mockGetUserIdsAsEids.mockReturnValue([]);
-    document.cookie = 'ts-eids=; Path=/; Max-Age=0';
-    delete testWindow.__tsjs_prebid;
-  });
-
-  afterEach(() => {
-    delete testWindow.__tsjs_prebid;
-  });
-
-  it('reads timeout and debug from window.__tsjs_prebid', () => {
-    testWindow.__tsjs_prebid = { timeout: 1500, debug: true };
-
-    installPrebidNpm();
-
-    expect(mockSetConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ debug: true, bidderTimeout: 1500 })
-    );
-  });
-
-  it('keeps browser timeout and debug independent from multiple PBS routes', () => {
-    testWindow.__tsjs_prebid = {
-      timeout: 1750,
-      debug: false,
-      serverSideBidders: ['pbsPrimaryRoute', 'pbsSecondaryRoute'],
-    };
-
-    installPrebidNpm();
-
-    expect(mockSetConfig).toHaveBeenCalledWith({ debug: false, bidderTimeout: 1750 });
-  });
-
-  it('explicit config overrides server-injected values', () => {
-    testWindow.__tsjs_prebid = { timeout: 1500, debug: true };
-
-    installPrebidNpm({ timeout: 3000, debug: false });
-
-    expect(mockSetConfig).toHaveBeenCalledWith(
-      expect.objectContaining({ debug: false, bidderTimeout: 3000 })
-    );
-  });
-
-  it('works with no config argument and no injected config', () => {
-    installPrebidNpm();
-
-    expect(mockSetConfig).toHaveBeenCalledWith(expect.objectContaining({ debug: false }));
-    expect(mockProcessQueue).toHaveBeenCalled();
-  });
-});
-
-describe('prebid/installRefreshHandler', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockRequestBids.mockReset();
-    mockPbjs.requestBids = mockRequestBids;
-    mockPbjs.adUnits = [];
-    mockPbjs.setTargetingForGPTAsync = undefined;
-    testWindow.tsjs = undefined;
-    delete testWindow.googletag;
-    testWindow.__tsjs_prebid = {
-      serverSideBidders: ['appnexus', 'rubicon', 'kargo', 'openx', 'exampleServer'],
-    };
-    document.body.replaceChildren();
-  });
-
-  afterEach(() => {
-    testWindow.tsjs = undefined;
-    delete testWindow.googletag;
-    delete testWindow.__tsjs_prebid;
-    document.body.replaceChildren();
-  });
-
-  function attachTestSlot(code: string): void {
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-  }
-
-  it('builds refresh ad units from injected slot metadata', () => {
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [
-            [970, 250],
-            [728, 90],
-          ],
-          targeting: { zone: 'homepage', pos: 'atf' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        timeout: 750,
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-homepage-header',
-            mediaTypes: {
-              banner: {
-                name: 'homepage',
-                sizes: [
-                  [970, 250],
-                  [728, 90],
-                ],
-              },
-            },
-            bids: [{ bidder: 'trustedServer', params: { zone: 'homepage' } }],
-          }),
-        ],
-      })
-    );
-  });
-
-  it('resolves the exact slot when div_ids share a prefix', () => {
-    // Regression: a single find() with a startsWith() clause returned the
-    // first slot whose div_id is a prefix of the element id. With div_ids
-    // "div-ad" and "div-ad-header", refreshing the "div-ad-header" element
-    // must resolve to the header slot, not the shorter prefix slot.
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-header'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'prefix_ad',
-          gam_unit_path: '/123/prefix',
-          div_id: 'div-ad',
-          formats: [[300, 250]],
-          targeting: { zone: 'prefix' },
-        },
-        {
-          id: 'header_ad',
-          gam_unit_path: '/123/header',
-          div_id: 'div-ad-header',
-          formats: [[970, 250]],
-          targeting: { zone: 'header' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-header',
-            mediaTypes: {
-              banner: {
-                name: 'header',
-                sizes: [[970, 250]],
-              },
-            },
-          }),
-        ],
-      })
-    );
-  });
-
-  it('scopes the GPT targeting call to the refreshed slot code', () => {
-    const setTargetingForGPTAsync = vi.fn();
-    mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-    // Run the bidsBackHandler synchronously so the targeting call fires.
-    mockRequestBids.mockImplementation((opts?: { bidsBackHandler?: () => void }) => {
-      opts?.bidsBackHandler?.();
-    });
-    const originalRefresh = vi.fn();
-    // Only the header slot is refreshed; the footer slot must be untouched.
-    const headerSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-header'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn().mockReturnThis(),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [headerSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'header_ad',
-          gam_unit_path: '/123/header',
-          div_id: 'div-ad-header',
-          formats: [[728, 90]],
-          targeting: { zone: 'header' },
-        },
-        {
-          id: 'footer_ad',
-          gam_unit_path: '/123/footer',
-          div_id: 'div-ad-footer',
-          formats: [[728, 90]],
-          targeting: { zone: 'footer' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh([headerSlot]);
-
-    expect(setTargetingForGPTAsync).toHaveBeenCalledTimes(1);
-    expect(setTargetingForGPTAsync).toHaveBeenCalledWith(['div-ad-header']);
-    expect(originalRefresh).toHaveBeenCalledWith([headerSlot], undefined);
-
-    mockPbjs.setTargetingForGPTAsync = undefined;
-  });
-
-  it('includes configured client-side bidders in refresh ad units', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-    // Original publisher ad unit carries a client-side rubicon bid.
-    mockPbjs.adUnits = [
-      {
-        code: 'div-ad-homepage-header',
-        bids: [
-          { bidder: 'trustedServer', params: {} },
-          { bidder: 'rubicon', params: { accountId: 1, siteId: 2, zoneId: 3 } },
-        ],
-      },
-    ];
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [[728, 90]],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-homepage-header',
-            bids: [
-              { bidder: 'trustedServer', params: { zone: 'homepage' } },
-              { bidder: 'rubicon', params: { accountId: 1, siteId: 2, zoneId: 3 } },
-            ],
-          }),
-        ],
-      })
-    );
-
-    delete testWindow.__tsjs_prebid;
-    mockPbjs.adUnits = [];
-  });
-
-  it('preserves raw server-side bidder params in refresh ad units', () => {
-    // Original publisher ad unit carries an inline server-side appnexus bid that
-    // the initial auction has not yet folded into the trustedServer bid.
-    mockPbjs.adUnits = [
-      {
-        code: 'div-ad-homepage-header',
-        bids: [{ bidder: 'appnexus', params: { placementId: 12345 } }],
-      },
-    ];
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [[728, 90]],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-homepage-header',
-            bids: [
-              {
-                bidder: 'trustedServer',
-                params: {
-                  zone: 'homepage',
-                  bidderParams: { appnexus: { placementId: 12345 } },
-                },
-              },
-            ],
-          }),
-        ],
-      })
-    );
-
-    mockPbjs.adUnits = [];
-  });
-
-  it('recovers params and client-side bids for container-backed slots by injected div_id', () => {
-    // A TS-owned GPT slot may be defined on `${div_id}-container`, but the
-    // publisher's Prebid ad unit is keyed by the inner div_id. The synthetic
-    // refresh code stays the GPT element id (so GPT can match it), while params
-    // and client-side bids are recovered from the injected div_id candidate.
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-    mockPbjs.adUnits = [
-      {
-        code: 'div-ad-x',
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 12345 } },
-          { bidder: 'rubicon', params: { accountId: 1 } },
-        ],
-      },
-    ];
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-x-container'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'x_ad',
-          gam_unit_path: '/123/x',
-          div_id: 'div-ad-x',
-          formats: [[728, 90]],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [
-          expect.objectContaining({
-            // Synthetic refresh code stays the GPT element id, not the div_id.
-            code: 'div-ad-x-container',
-            bids: [
-              {
-                bidder: 'trustedServer',
-                params: {
-                  zone: 'homepage',
-                  bidderParams: { appnexus: { placementId: 12345 } },
-                },
-              },
-              { bidder: 'rubicon', params: { accountId: 1 } },
-            ],
-          }),
-        ],
-      })
-    );
-
-    delete testWindow.__tsjs_prebid;
-    mockPbjs.adUnits = [];
-  });
-
-  it('recovers server-side bidder params already folded onto the original trustedServer bid', () => {
-    // After the initial auction, the requestBids shim has folded the publisher's
-    // server-side params into the original ad unit's trustedServer bid. A later
-    // refresh must still recover them by code.
-    mockPbjs.adUnits = [
-      {
-        code: 'div-ad-homepage-header',
-        bids: [
-          {
-            bidder: 'trustedServer',
-            params: { bidderParams: { appnexus: { placementId: 12345 } } },
-          },
-        ],
-      },
-    ];
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [[728, 90]],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-homepage-header',
-            bids: [
-              {
-                bidder: 'trustedServer',
-                params: {
-                  zone: 'homepage',
-                  bidderParams: { appnexus: { placementId: 12345 } },
-                },
-              },
-            ],
-          }),
-        ],
-      })
-    );
-
-    mockPbjs.adUnits = [];
-  });
-
-  it('auctions refreshed TS initial slots and clears stale TS targeting before refresh', () => {
-    const originalRefresh = vi.fn();
-    const slotTargeting = new Map<string, string[]>([
-      ['ts_initial', ['1']],
-      ['zone', ['homepage']],
-    ]);
-    const clearTargeting = vi.fn((key: string) => {
-      slotTargeting.delete(key);
-    });
-    const setTargeting = vi.fn((key: string, value: string | string[]) => {
-      slotTargeting.set(key, Array.isArray(value) ? value : [value]);
-    });
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn((key: string) => slotTargeting.get(key) ?? []),
-      getSizes: vi.fn(() => [
-        { getWidth: () => 970, getHeight: () => 250 },
-        { getWidth: () => 728, getHeight: () => 90 },
-      ]),
-      clearTargeting,
-      setTargeting,
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    const setTargetingForGPTAsync = vi.fn(() => {
-      gptSlot.setTargeting('ts', 'prebid-value');
-    });
-    mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      adSlots: [
-        {
-          id: 'homepage_header_ad',
-          gam_unit_path: '/123/homepage',
-          div_id: 'div-ad-homepage-header',
-          formats: [
-            [970, 250],
-            [728, 90],
-          ],
-          targeting: { zone: 'homepage' },
-        },
-      ],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot]);
-
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        timeout: 750,
-        adUnits: [
-          expect.objectContaining({
-            code: 'div-ad-homepage-header',
-            mediaTypes: {
-              banner: {
-                name: 'homepage',
-                sizes: [
-                  [970, 250],
-                  [728, 90],
-                ],
-              },
-            },
-            bids: [{ bidder: 'trustedServer', params: { zone: 'homepage' } }],
-          }),
-        ],
-      })
-    );
-    expect(clearTargeting).toHaveBeenCalledWith('ts_initial');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_pb');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_bidder');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_host');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_path');
-    expect(clearTargeting).not.toHaveBeenCalledWith('ts');
-    expect(originalRefresh).not.toHaveBeenCalled();
-
-    const bidsBackHandler = mockRequestBids.mock.calls[0][0].bidsBackHandler;
-    bidsBackHandler();
-
-    expect(setTargetingForGPTAsync).toHaveBeenCalled();
-    expect(setTargetingForGPTAsync.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(slotTargeting.get('ts')).toEqual(['prebid-value']);
-    expect(originalRefresh).toHaveBeenCalledWith([gptSlot], undefined);
-  });
-
-  it('passes an explicitly excluded path directly to GPT after clearing stale targeting', () => {
-    const originalRefresh = vi.fn();
-    const clearTargeting = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-tracking'),
-      getAdUnitPath: vi.fn(() => '/123/trackingonly'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting,
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.__tsjs_prebid = {
-      excludedGamAdUnitPathSuffixes: ['/trackingonly'],
-    };
-    const options = { changeCorrelator: false };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot], options);
-
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(clearTargeting).toHaveBeenCalledWith('ts_initial');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_pb');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_bidder');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_host');
-    expect(clearTargeting).toHaveBeenCalledWith('hb_cache_path');
-    expect(originalRefresh).toHaveBeenCalledWith([gptSlot], options);
-  });
-
-  it('passes an all-excluded global refresh directly to GPT', () => {
-    const originalRefresh = vi.fn();
-    const trackingSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-tracking'),
-      getAdUnitPath: vi.fn(() => '/123/trackingonly'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn(),
-    };
-    const measurementSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-measurement'),
-      getAdUnitPath: vi.fn(() => '/123/measurement-only'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn(),
-    };
-    const targetSlots = [trackingSlot, measurementSlot];
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => targetSlots),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.__tsjs_prebid = {
-      excludedGamAdUnitPathSuffixes: ['/trackingonly', '/measurement-only'],
-    };
-    const options = { changeCorrelator: false };
-
-    installRefreshHandler(750);
-    pubads.refresh(undefined, options);
-
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(trackingSlot.clearTargeting).toHaveBeenCalled();
-    expect(measurementSlot.clearTargeting).toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith(undefined, options);
-  });
-
-  it('auctions eligible slots and refreshes every slot in a mixed global refresh', () => {
-    const setTargetingForGPTAsync = vi.fn();
-    mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-    mockRequestBids.mockImplementation((opts?: { bidsBackHandler?: () => void }) => {
-      opts?.bidsBackHandler?.();
-    });
-    const originalRefresh = vi.fn();
-    const displaySlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-display'),
-      getAdUnitPath: vi.fn(() => '/123/content'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn(),
-    };
-    const trackingSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-tracking'),
-      getAdUnitPath: vi.fn(() => '/123/trackingonly'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn(),
-    };
-    const targetSlots = [displaySlot, trackingSlot];
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => targetSlots),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.__tsjs_prebid = {
-      excludedGamAdUnitPathSuffixes: ['/trackingonly'],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh();
-
-    expect(displaySlot.clearTargeting).toHaveBeenCalled();
-    expect(trackingSlot.clearTargeting).toHaveBeenCalled();
-    expect(mockRequestBids).toHaveBeenCalledWith(
-      expect.objectContaining({
-        adUnits: [expect.objectContaining({ code: 'div-ad-display' })],
-      })
-    );
-    expect(setTargetingForGPTAsync).toHaveBeenCalledWith(['div-ad-display']);
-    expect(originalRefresh).toHaveBeenCalledWith(targetSlots, undefined);
-
-    mockPbjs.setTargetingForGPTAsync = undefined;
-  });
-
-  it.each([
-    ['a missing path getter', {}],
-    ['a non-string path', { getAdUnitPath: vi.fn(() => 123) }],
-    [
-      'a throwing path getter',
-      {
-        getAdUnitPath: vi.fn(() => {
-          throw new Error('path unavailable');
-        }),
-      },
-    ],
-  ])('fails open to an auction for %s', (_description, pathBehavior) => {
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-display'),
-      getTargeting: vi.fn(() => []),
-      ...pathBehavior,
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.__tsjs_prebid = {
-      excludedGamAdUnitPathSuffixes: ['/trackingonly'],
-    };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot]);
-
-    expect(mockRequestBids).toHaveBeenCalled();
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ['an empty suffix', ['']],
-    ['a non-array suffix list', {}],
-  ])('ignores %s from injected config and runs the refresh auction', (_description, suffixes) => {
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-display'),
-      getAdUnitPath: vi.fn(() => '/123/content'),
-      getTargeting: vi.fn(() => []),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.__tsjs_prebid = { excludedGamAdUnitPathSuffixes: suffixes };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot]);
-
-    expect(mockRequestBids).toHaveBeenCalled();
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it.each(['/123/TrackingOnly', '/123/trackingonly/'])(
-    'uses literal case-sensitive suffix matching for %s',
-    (adUnitPath) => {
-      const originalRefresh = vi.fn();
-      const gptSlot = {
-        getSlotElementId: vi.fn(() => 'div-ad-display'),
-        getAdUnitPath: vi.fn(() => adUnitPath),
-        getTargeting: vi.fn(() => []),
-      };
-      const pubads = {
-        refresh: originalRefresh,
-        getSlots: vi.fn(() => [gptSlot]),
-      };
-      testWindow.googletag = {
-        cmd: { push: (fn: () => void) => fn() },
-        pubads: () => pubads,
-      };
-      testWindow.__tsjs_prebid = {
-        excludedGamAdUnitPathSuffixes: ['/trackingonly'],
-      };
-
-      installRefreshHandler(750);
-      pubads.refresh([gptSlot]);
-
-      expect(mockRequestBids).toHaveBeenCalled();
-      expect(originalRefresh).not.toHaveBeenCalled();
-    }
-  );
-
-  it('passes the adInit internal refresh straight to GPT without a client-side auction', () => {
-    const originalRefresh = vi.fn();
-    const clearTargeting = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting,
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = { adInitRefreshInProgress: true };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot]);
-
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith([gptSlot], undefined);
-  });
-
-  it('runs a client-side auction for publisher refreshes after adInit completes', () => {
-    const originalRefresh = vi.fn();
-    const gptSlot = {
-      getSlotElementId: vi.fn(() => 'div-ad-homepage-header'),
-      getTargeting: vi.fn(() => []),
-      clearTargeting: vi.fn(),
-    };
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [gptSlot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = { adInitRefreshInProgress: false };
-
-    installRefreshHandler(750);
-    pubads.refresh([gptSlot]);
-
-    expect(mockRequestBids).toHaveBeenCalled();
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('keeps nested Prebid refreshes Prebid-only and restores the diagnostics context', () => {
-    const listeners = new Map<string, (event: { slot: object }) => void>();
-    const store = new GptDiagnosticsStore({ defer: () => undefined });
-    const explicitSlot = {
-      getSlotElementId: () => 'nested-explicit',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const bareSlot = {
-      getSlotElementId: () => 'nested-bare',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    let throwRefresh = false;
-    let getSlots: () => object[] = () => [];
-    const originalRefresh = vi.fn((slots?: unknown[]) => {
-      for (const slot of slots ?? getSlots()) listeners.get('slotRequested')?.({ slot });
-      if (throwRefresh) throw new Error('delegated refresh failed');
-      return 'delegated refresh result';
-    });
-    const pubads = {
-      addEventListener: vi.fn((name: string, listener: (event: { slot: object }) => void) => {
-        listeners.set(name, listener);
-      }),
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [bareSlot]),
-    };
-    getSlots = pubads.getSlots;
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      gptDiagnosticsRecorder: {
-        recordPrebidRefresh: (slots: object[]) => store.recordPrebidRefresh(slots),
-      },
-    };
-
-    new GptDiagnosticsObserver(store).install();
-    installRefreshHandler(750);
-    const pbjs = installPrebidNpm();
-
-    const prepareDelivery = (code: string) => {
-      if (!document.getElementById(code)) attachTestSlot(code);
-      mockRequestBids.mockImplementationOnce((options) => {
-        options.bidsBackHandler?.();
-      });
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: vi.fn(),
-      } as unknown as RequestBidsArg);
-    };
-
-    prepareDelivery('nested-explicit');
-    expect(pubads.refresh([explicitSlot])).toBe('delegated refresh result');
-    expect(store.snapshot().slots[0].requests[0].requestPath).toBe('prebid_refresh');
-    expect(Object.hasOwn(testWindow.tsjs as object, 'prebidRefreshDispatchInProgress')).toBe(false);
-
-    prepareDelivery('nested-bare');
-    expect(pubads.refresh()).toBe('delegated refresh result');
-    expect(store.snapshot().slots[1].requests[0].requestPath).toBe('prebid_refresh');
-    expect(Object.hasOwn(testWindow.tsjs as object, 'prebidRefreshDispatchInProgress')).toBe(false);
-
-    prepareDelivery('nested-explicit');
-    throwRefresh = true;
-    expect(() => pubads.refresh([explicitSlot])).toThrow('delegated refresh failed');
-    expect(Object.hasOwn(testWindow.tsjs as object, 'prebidRefreshDispatchInProgress')).toBe(false);
-
-    testWindow.tsjs = {
-      adInitRefreshInProgress: true,
-      gptDiagnosticsRecorder: {
-        recordPrebidRefresh: (slots: object[]) => store.recordPrebidRefresh(slots),
-      },
-    };
-    throwRefresh = false;
-    expect(pubads.refresh([explicitSlot])).toBe('delegated refresh result');
-    expect(store.snapshot().slots[0].requests[2].requestPath).toBe('unattributed');
-  });
-
-  it.each([
-    { order: 'diagnostics observer first', diagnosticsFirst: true, expectedPath: 'prebid_refresh' },
-    { order: 'Prebid wrapper first', diagnosticsFirst: false, expectedPath: 'competing' },
-  ])(
-    'attributes a Prebid-consumed refresh as $expectedPath when installed with the $order',
-    ({ diagnosticsFirst, expectedPath }) => {
-      const listeners = new Map<string, (event: { slot: object }) => void>();
-      const store = new GptDiagnosticsStore({ defer: () => undefined });
-      const slot = {
-        getSlotElementId: () => 'install-order',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const originalRefresh = vi.fn((slots?: unknown[]) => {
-        for (const refreshed of slots ?? []) listeners.get('slotRequested')?.({ slot: refreshed });
-        return 'delegated refresh result';
-      });
-      const pubads = {
-        addEventListener: vi.fn((name: string, listener: (event: { slot: object }) => void) => {
-          listeners.set(name, listener);
-        }),
-        refresh: originalRefresh as (slots?: unknown[], opts?: unknown) => unknown,
-        getSlots: vi.fn(() => [slot]),
-      };
-      testWindow.googletag = {
-        cmd: { push: (fn: () => void) => fn() },
-        pubads: () => pubads,
-      };
-      testWindow.tsjs = {
-        gptDiagnosticsRecorder: {
-          recordPrebidRefresh: (slots: object[]) => store.recordPrebidRefresh(slots),
-        },
-      };
-
-      // Only the bundle evaluation order enforces this today, so pin both
-      // outcomes: the diagnostics wrapper must sit inside the Prebid one to see
-      // the dispatch context that marks a refresh as Prebid's.
-      if (diagnosticsFirst) {
-        new GptDiagnosticsObserver(store).install();
-        installRefreshHandler(750);
-      } else {
-        installRefreshHandler(750);
-        new GptDiagnosticsObserver(store).install();
-      }
-      const pbjs = installPrebidNpm();
-      attachTestSlot('install-order');
-      mockRequestBids.mockImplementationOnce((options) => options.bidsBackHandler?.());
-      pbjs.requestBids({
-        adUnits: [{ code: 'install-order', bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: vi.fn(),
-      } as unknown as RequestBidsArg);
-
-      pubads.refresh([slot]);
-
-      expect(store.snapshot().slots[0].requests[0].requestPath).toBe(expectedPath);
-    }
-  );
-
-  it('keeps the outer dispatch context set across a nested Prebid refresh', () => {
-    const store = new GptDiagnosticsStore({ defer: () => undefined });
-    const slot = {
-      getSlotElementId: () => 'nested-reentrant',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const contextAfterInner: Array<boolean | undefined> = [];
-    let reentered = false;
-    const originalRefresh = vi.fn(() => {
-      if (!reentered) {
-        reentered = true;
-        pubads.refresh([slot]);
-        contextAfterInner.push(
-          (testWindow.tsjs as { prebidRefreshDispatchInProgress?: boolean })
-            .prebidRefreshDispatchInProgress
-        );
-      }
-      return 'delegated refresh result';
-    });
-    const pubads = {
-      refresh: originalRefresh as (slots?: unknown[], opts?: unknown) => unknown,
-      getSlots: vi.fn(() => [slot]),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    testWindow.tsjs = {
-      gptDiagnosticsRecorder: {
-        recordPrebidRefresh: (slots: object[]) => store.recordPrebidRefresh(slots),
-      },
-    };
-
-    const pbjs = installPrebidNpm();
-    installRefreshHandler(750);
-    attachTestSlot('nested-reentrant');
-    mockRequestBids.mockImplementation((options) => options.bidsBackHandler?.());
-    pbjs.requestBids({
-      adUnits: [{ code: 'nested-reentrant', bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: vi.fn(),
-    } as unknown as RequestBidsArg);
-
-    expect(pubads.refresh([slot])).toBe('delegated refresh result');
-    // The inner dispatch owns the flag while it runs and must hand it back, or
-    // the observer would stop attributing every later publisher refresh.
-    expect(contextAfterInner).toEqual([true]);
-    expect(
-      originalRefresh,
-      'the nested refresh must reach the delegated call'
-    ).toHaveBeenCalledTimes(2);
-    expect(Object.hasOwn(testWindow.tsjs as object, 'prebidRefreshDispatchInProgress')).toBe(false);
-  });
-
-  it('restores diagnostics context when its setter mutates and then throws', () => {
-    const slot = {
-      getSlotElementId: () => 'mutating-context-setter',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const originalRefresh = vi.fn();
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => [slot]),
-    };
-    const contextTarget: Record<string, unknown> = {};
-    let throwAfterMutation = true;
-    testWindow.tsjs = new Proxy(contextTarget, {
-      set(target, property, value) {
-        Reflect.set(target, property, value);
-        if (property === 'prebidRefreshDispatchInProgress' && throwAfterMutation) {
-          throwAfterMutation = false;
-          throw new Error('example mutating context setter failure');
-        }
-        return true;
-      },
-    });
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    mockRequestBids.mockImplementation((options) => options.bidsBackHandler?.());
-
-    installPrebidNpm();
-    installRefreshHandler(750);
-    pubads.refresh([slot]);
-    pubads.refresh([slot]);
-
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-    expect(
-      Object.prototype.hasOwnProperty.call(contextTarget, 'prebidRefreshDispatchInProgress')
-    ).toBe(false);
-  });
-});
-
-describe('prebid publisher snapshots and delivery refreshes', () => {
-  let deliveryAdIds = new WeakMap<object, string>();
-  let installedGptSlots: Array<Record<string, unknown>> = [];
-  let auctionSequence = 0;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    deliveryAdIds = new WeakMap();
-    installedGptSlots = [];
-    auctionSequence = 0;
-    mockRequestBids.mockReset();
-    mockPbjs.requestBids = mockRequestBids;
-    mockPbjs.removeAdUnit = mockRemoveAdUnit;
-    delete (mockPbjs as unknown as Record<string, unknown>).__tsRemoveAdUnitWrapped;
-    mockPbjs.adUnits = [];
-    mockGetUserIdsAsEids.mockReset();
-    mockGetUserIdsAsEids.mockReturnValue([]);
-    // By default the manifest declares all adapters compiled in.
-    (window as unknown as { __tsjs_prebid_bundle?: unknown }).__tsjs_prebid_bundle =
-      DEFAULT_BUNDLE_MANIFEST;
-    mockPbjs.setTargetingForGPTAsync = undefined;
-    testWindow.__tsjs_prebid = {
-      serverSideBidders: ['exampleServer', 'exampleFallback'],
-    };
-    testWindow.tsjs = undefined;
-    delete testWindow.googletag;
-    document.body.replaceChildren();
-  });
-
-  afterEach(() => {
-    delete testWindow.__tsjs_prebid;
-    testWindow.tsjs = undefined;
-    delete testWindow.googletag;
-    document.body.replaceChildren();
-  });
-
-  function installGpt(slots: Array<Record<string, unknown>>) {
-    installedGptSlots = slots;
-    for (const slot of slots) {
-      if (!slot || typeof slot !== 'object') continue;
-      const elementId = slot.getSlotElementId?.();
-      if (typeof elementId === 'string' && elementId && !document.getElementById(elementId)) {
-        const element = document.createElement('div');
-        element.id = elementId;
-        document.body.appendChild(element);
-      }
-      const originalGetTargeting = slot.getTargeting?.bind(slot);
-      slot.getTargeting = (key: string) => {
-        const deliveryAdId = deliveryAdIds.get(slot);
-        if (key === 'hb_adid' && deliveryAdId) return [deliveryAdId];
-        return originalGetTargeting?.(key) ?? [];
-      };
-    }
-
-    const originalRefresh = vi.fn();
-    const pubads = {
-      refresh: originalRefresh,
-      getSlots: vi.fn(() => slots),
-    };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    installRefreshHandler(640);
-    return { originalRefresh, pubads };
-  }
-
-  function refreshAdUnitFromLastRequest():
-    | (Record<string, unknown> & { code?: string; bids?: TestBid[] })
-    | undefined {
-    const lastCall = mockRequestBids.mock.calls[mockRequestBids.mock.calls.length - 1];
-    return lastCall?.[0]?.adUnits?.[0];
-  }
-
-  function completePublisherAuction(
-    opts?: { adUnits?: Array<{ code?: string }>; bidsBackHandler?: (...args: unknown[]) => void },
-    options: { auctionId?: string; applyTargeting?: boolean } = {}
-  ): void {
-    const auctionId = options.auctionId ?? `example-auction-${auctionSequence++}`;
-    const bidResponses: Record<string, { bids: Array<Record<string, unknown>> }> = {};
-
-    for (const unit of opts?.adUnits ?? []) {
-      if (!unit.code) continue;
-      const adId = `${auctionId}-${unit.code}`;
-      bidResponses[unit.code] = {
-        bids: [{ adId, adUnitCode: unit.code, auctionId }],
-      };
-      if (options.applyTargeting !== false) {
-        const slot = installedGptSlots.find((candidate) => {
-          const elementId = candidate?.getSlotElementId?.();
-          return elementId === unit.code || elementId === `${unit.code}-container`;
-        });
-        if (slot) deliveryAdIds.set(slot, adId);
-      }
-    }
-
-    opts?.bidsBackHandler?.(bidResponses, false, auctionId);
-  }
-
-  it('suppresses every publisher auction registered before the first TS delivery', () => {
-    const element = document.createElement('div');
-    element.id = 'overlapping-first-impression';
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, element, 100);
-    const first = registerPublisherFirstImpressionAuctions(ts, [element.id], 101).get(element.id);
-    const second = registerPublisherFirstImpressionAuctions(ts, [element.id], 102).get(element.id);
-
-    expect(consumePublisherFirstImpressionDelivery(ts, first, 103)).toBe(true);
-    expect(consumePublisherFirstImpressionDelivery(ts, second, 104)).toBe(true);
-    expect(registerPublisherFirstImpressionAuctions(ts, [element.id], 105)).toEqual(new Map());
-
-    element.remove();
-  });
-
-  it('suppresses a correlated TS-owned delivery after the five-second lease', () => {
-    const element = document.createElement('div');
-    element.id = 'late-first-impression';
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, element, 100);
-    const token = registerPublisherFirstImpressionAuctions(ts, [element.id], 101).get(element.id);
-
-    expect(consumePublisherFirstImpressionDelivery(ts, token, 5_102)).toBe(true);
-
-    element.remove();
-  });
-
-  it('rejects a connected claim whose element is no longer canonical for its ID', () => {
-    const element = document.createElement('div');
-    element.id = 'replaced-canonical-element';
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, element, 100);
-    const token = registerPublisherFirstImpressionAuctions(ts, [element.id], 101).get(element.id);
-    const replacement = document.createElement('div');
-    replacement.id = element.id;
-    document.body.insertBefore(replacement, element);
-
-    expect(document.getElementById(element.id)).toBe(replacement);
-    expect(consumePublisherFirstImpressionDelivery(ts, token, 102)).toBe(false);
-    expect(ts.firstImpression?.slots[element.id]).toBeUndefined();
-
-    replacement.remove();
-    element.remove();
-  });
-
-  it('prunes a claim stored under a registry key that does not match its slot element ID', () => {
-    const element = document.createElement('div');
-    element.id = 'malformed-registry-key-slot';
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    const claim = claimFirstImpressionForTrustedServer(ts, element, 100)!;
-    delete ts.firstImpression!.slots[element.id];
-    ts.firstImpression!.slots['wrong-registry-key'] = claim;
-
-    expect(firstImpressionClaim(ts, element)).toBeUndefined();
-    expect(ts.firstImpression!.slots['wrong-registry-key']).toBeUndefined();
-
-    element.remove();
-  });
-
-  it('rejects a connected same-ID TS claim from a foreign document', () => {
-    const element = document.createElement('div');
-    element.id = 'foreign-document-claim-slot';
-    document.body.appendChild(element);
-    const foreignDocument = document.implementation.createHTMLDocument('foreign');
-    const foreignElement = foreignDocument.createElement('div');
-    foreignElement.id = element.id;
-    foreignDocument.body.appendChild(foreignElement);
-    const ts = {} as TsjsApi;
-    const claim = claimFirstImpressionForTrustedServer(ts, element, 100)!;
-    const token = registerPublisherFirstImpressionAuctions(ts, [element.id], 101).get(element.id);
-    claim.element = foreignElement;
-
-    expect(foreignElement.isConnected).toBe(true);
-    expect(consumePublisherFirstImpressionDelivery(ts, token, 102)).toBe(false);
-    expect(ts.firstImpression?.slots[element.id]).toBeUndefined();
-    expect(claimFirstImpressionForTrustedServer(ts, element, 103)?.element).toBe(element);
-
-    element.remove();
-  });
-
-  it('prunes an ordinary expired publisher registration without a reserved fallback', () => {
-    const element = document.createElement('div');
-    element.id = 'ordinary-expired-publisher-slot';
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    const token = registerPublisherFirstImpressionAuctions(ts, [element.id], 100).get(element.id);
-
-    expect(consumePublisherFirstImpressionDelivery(ts, token, 5_101)).toBe(false);
-    expect(ts.firstImpression?.slots[element.id]).toBeUndefined();
-
-    element.remove();
-  });
-
-  it('clears a failed fallback reservation before a later ordinary publisher claim expires', () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(100);
-    try {
-      const element = document.createElement('div');
-      element.id = 'failed-fallback-reservation-slot';
-      document.body.appendChild(element);
-      const ts = {} as TsjsApi;
-      const originalToken = registerPublisherFirstImpressionAuctions(ts, [element.id]).get(
-        element.id
-      );
-      expect(originalToken).toBeDefined();
-      expect(reservePublisherFirstImpressionFallback(ts, element)).toBe(true);
-
-      vi.advanceTimersByTime(5_001);
-      const fallbackClaim = claimFirstImpressionForTrustedServer(ts, element)!;
-      expect(fallbackClaim.owner).toBe('trusted_server');
-      expect(fallbackClaim.publisherAuctions[originalToken!]?.suppressDelivery).toBe(true);
-
-      releaseTrustedServerFirstImpressionClaim(ts, element, fallbackClaim);
-      expect(ts.firstImpression?.slots[element.id]).toBeUndefined();
-      expect(ts.firstImpression?.fallbackSlots[element.id]).toBeUndefined();
-
-      const laterToken = registerPublisherFirstImpressionAuctions(ts, [element.id]).get(element.id);
-      expect(laterToken).toBeDefined();
-      vi.advanceTimersByTime(5_001);
-      expect(consumePublisherFirstImpressionDelivery(ts, laterToken)).toBe(false);
-      expect(ts.firstImpression?.slots[element.id]).toBeUndefined();
-
-      const freshClaim = claimFirstImpressionForTrustedServer(ts, element)!;
-      expect(freshClaim.publisherAuctions).toEqual({});
-
-      element.remove();
-    } finally {
-      vi.clearAllTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('reserves first impression while a publisher refresh auction is pending', () => {
-    const code = 'pending-publisher-refresh-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    expect(
-      claimFirstImpressionForTrustedServer(ts, document.getElementById(code)!)
-    ).toBeUndefined();
-    expect(originalRefresh).not.toHaveBeenCalled();
-
-    completeRefresh?.();
-
-    expect(originalRefresh).toHaveBeenCalledOnce();
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('suppresses an original publisher delivery after the lease-boundary TS fallback', () => {
-    vi.useFakeTimers();
-    try {
-      const code = 'lease-boundary-fallback-slot';
-      const slot = {
-        getSlotElementId: () => code,
-        getTargeting: () => [],
-        getSizes: () => [[300, 250]],
-        clearTargeting: vi.fn(),
-        setTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      let originalPublisherAuction: Parameters<typeof completePublisherAuction>[0];
-      mockRequestBids.mockImplementation((options) => {
-        if (!originalPublisherAuction) {
-          originalPublisherAuction = options;
-          return;
-        }
-        completePublisherAuction(options);
-      });
-      const pbjs = installPrebidNpm();
-      const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-      ts.servicesEnabled = true;
-      ts.adSlots = [
-        {
-          id: 'lease-boundary-fallback-ad',
-          gam_unit_path: '/123/lease-boundary',
-          div_id: code,
-          formats: [[300, 250]],
-          targeting: {},
-        },
-      ];
-      ts.bids = {
-        'lease-boundary-fallback-ad': {
-          hb_pb: '1.00',
-          hb_adid: 'trusted-server-fallback-ad',
-        },
-      };
-
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => pubads.refresh([slot]),
-      } as unknown as RequestBidsArg);
-      installTsAdInit();
-      ts.adInit!();
-
-      vi.advanceTimersByTime(5001);
-      observeFirstImpressionGptLifecycle(ts, document.getElementById(code)!, 'requested');
-      expect(originalRefresh).toHaveBeenCalledOnce();
-      expect(ts.firstImpression?.slots[code]?.owner).toBe('trusted_server');
-      expect(ts.firstImpression?.fallbackSlots[code]).toBe(document.getElementById(code));
-      expect(Object.values(ts.firstImpression?.slots[code]?.publisherAuctions ?? {})).toEqual([
-        expect.objectContaining({ suppressDelivery: true }),
-      ]);
-
-      completePublisherAuction(originalPublisherAuction);
-      expect(originalRefresh).toHaveBeenCalledOnce();
-
-      deliveryAdIds.delete(slot);
-      pubads.refresh([slot]);
-      expect(mockRequestBids).toHaveBeenCalledTimes(2);
-      expect(originalRefresh).toHaveBeenCalledTimes(2);
-    } finally {
-      vi.clearAllTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('suppresses a delayed publisher refresh when TS already owns first impression', () => {
-    const code = 'pending-ts-owned-refresh-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, document.getElementById(code)!);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-    expect(originalRefresh).not.toHaveBeenCalled();
-
-    completeRefresh?.();
-
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('filters only the TS-owned slot from a delayed mixed publisher refresh', () => {
-    const tsCode = 'pending-mixed-ts-slot';
-    const publisherCode = 'pending-mixed-publisher-slot';
-    const tsSlot = {
-      getSlotElementId: () => tsCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const publisherSlot = {
-      getSlotElementId: () => publisherCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([tsSlot, publisherSlot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, document.getElementById(tsCode)!);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([tsSlot, publisherSlot]);
-    completeRefresh?.();
-
-    expect(originalRefresh).toHaveBeenCalledOnce();
-    expect(originalRefresh).toHaveBeenCalledWith([publisherSlot], undefined);
-  });
-
-  it('filters a TS-owned excluded slot from a delayed mixed publisher refresh', () => {
-    const eligibleCode = 'pending-mixed-eligible-slot';
-    const excludedCode = 'pending-mixed-excluded-slot';
-    const eligibleSlot = {
-      getSlotElementId: () => eligibleCode,
-      getAdUnitPath: () => '/123/content',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const excludedSlot = {
-      getSlotElementId: () => excludedCode,
-      getAdUnitPath: () => '/123/trackingonly',
-      getTargeting: () => [],
-      getSizes: () => [[1, 1]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([eligibleSlot, excludedSlot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, document.getElementById(excludedCode)!);
-    testWindow.__tsjs_prebid = { excludedGamAdUnitPathSuffixes: ['/trackingonly'] };
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([eligibleSlot, excludedSlot]);
-    completeRefresh?.();
-
-    expect(originalRefresh).toHaveBeenCalledOnce();
-    expect(originalRefresh).toHaveBeenCalledWith([eligibleSlot], undefined);
-  });
-
-  it('drops delayed delivery and auction slots together after SPA navigation', () => {
-    const deliveryCode = 'pending-navigation-delivery-slot';
-    const auctionCode = 'pending-navigation-auction-slot';
-    const deliverySlot = {
-      getSlotElementId: () => deliveryCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const auctionSlot = {
-      getSlotElementId: () => auctionCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([deliverySlot, auctionSlot]);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      if (opts?.adUnits?.[0]?.code === deliveryCode) {
-        completePublisherAuction(opts);
-      } else {
-        completeRefresh = opts.bidsBackHandler;
-      }
-    });
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code: deliveryCode, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh([deliverySlot, auctionSlot]),
-    } as unknown as RequestBidsArg);
-    ((testWindow.tsjs ??= {}) as unknown as TsjsApi).navGeneration = 1;
-    completeRefresh?.();
-
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('drops a delayed publisher refresh after SPA navigation', () => {
-    const code = 'pending-previous-navigation-refresh-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-    ((testWindow.tsjs ??= {}) as unknown as TsjsApi).navGeneration = 1;
-    completeRefresh?.();
-
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('drops a delayed publisher refresh after physical element replacement', () => {
-    const code = 'pending-replaced-refresh-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-    document.getElementById(code)?.remove();
-    const replacement = document.createElement('div');
-    replacement.id = code;
-    document.body.appendChild(replacement);
-    completeRefresh?.();
-
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('keeps a delayed bare refresh scoped to its captured slot list', () => {
-    const firstCode = 'pending-bare-first-slot';
-    const laterCode = 'pending-bare-later-slot';
-    const firstSlot = {
-      getSlotElementId: () => firstCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const laterSlot = {
-      getSlotElementId: () => laterCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const slots = [firstSlot];
-    const { originalRefresh, pubads } = installGpt(slots);
-    let completeRefresh: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      completeRefresh = opts.bidsBackHandler;
-    });
-    installPrebidNpm();
-
-    pubads.refresh();
-    slots.push(laterSlot);
-    completeRefresh?.();
-
-    expect(originalRefresh).toHaveBeenCalledOnce();
-    expect(originalRefresh).toHaveBeenCalledWith([firstSlot], undefined);
-  });
-
-  it('allows publisher refreshes that start after the TS first impression request', () => {
-    const code = 'requested-ts-owned-refresh-slot';
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    const ts = {} as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, element);
-    observeFirstImpressionGptLifecycle(ts, element, 'requested');
-
-    expect(registerPublisherFirstImpressionAuctions(ts, [code])).toEqual(new Map());
-    expect(ts.firstImpression?.slots[code]?.publisherRegistrationClosed).toBe(true);
-  });
-
-  it('clears a stale GPT handoff when delegating a post-request publisher refresh', () => {
-    const code = 'post-request-handoff-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    installedGptSlots = [slot];
-    const nativeRefresh = vi.fn();
-    const ts = (testWindow.tsjs = {} as unknown as PrebidTestWindow['tsjs']) as unknown as TsjsApi;
-    const handoff = {
-      gamUnitPath: '/123/post-request',
-      formats: [[300, 250] as [number, number]],
-      divIdPrefix: code,
-      slotElementId: code,
-      publisherClaimed: true,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: true,
-    };
-    ts.gptSlotHandoffs = { [code]: handoff };
-    const innerRefresh = vi.fn((slots?: (typeof slot)[]) => {
-      if (handoff.suppressPublisherRefresh) {
-        handoff.suppressPublisherRefresh = false;
-        return;
-      }
-      nativeRefresh(slots);
-    });
-    const pubads = { refresh: innerRefresh, getSlots: () => [slot] };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    claimFirstImpressionForTrustedServer(ts, element);
-    observeFirstImpressionGptLifecycle(ts, element, 'requested');
-    installRefreshHandler(640);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(handoff.suppressPublisherRefresh).toBe(false);
-    expect(nativeRefresh).toHaveBeenCalledWith([slot]);
-  });
-
-  it('suppresses an all-excluded refresh while the TS first impression is pending', () => {
-    const code = 'pending-all-excluded-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getAdUnitPath: () => '/123/trackingonly',
-      getTargeting: () => [],
-      getSizes: () => [[1, 1]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, document.getElementById(code)!);
-    testWindow.__tsjs_prebid = { excludedGamAdUnitPathSuffixes: ['/trackingonly'] };
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(originalRefresh).not.toHaveBeenCalled();
-  });
-
-  it('delegates an all-excluded refresh after the TS first impression request', () => {
-    const code = 'requested-all-excluded-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getAdUnitPath: () => '/123/trackingonly',
-      getTargeting: () => [],
-      getSizes: () => [[1, 1]],
-      clearTargeting: vi.fn(),
-    };
-    installedGptSlots = [slot];
-    const nativeRefresh = vi.fn();
-    const ts = (testWindow.tsjs = {} as unknown as PrebidTestWindow['tsjs']) as unknown as TsjsApi;
-    const handoff = {
-      gamUnitPath: '/123/trackingonly',
-      formats: [[1, 1] as [number, number]],
-      divIdPrefix: code,
-      slotElementId: code,
-      publisherClaimed: true,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: true,
-    };
-    ts.gptSlotHandoffs = { [code]: handoff };
-    const innerRefresh = vi.fn((slots?: (typeof slot)[]) => {
-      if (handoff.suppressPublisherRefresh) {
-        handoff.suppressPublisherRefresh = false;
-        return;
-      }
-      nativeRefresh(slots);
-    });
-    const pubads = { refresh: innerRefresh, getSlots: () => [slot] };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    claimFirstImpressionForTrustedServer(ts, element);
-    observeFirstImpressionGptLifecycle(ts, element, 'requested');
-    testWindow.__tsjs_prebid = { excludedGamAdUnitPathSuffixes: ['/trackingonly'] };
-    installRefreshHandler(640);
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(handoff.suppressPublisherRefresh).toBe(false);
-    expect(nativeRefresh).toHaveBeenCalledWith([slot]);
-  });
-
-  it('consumes late-handoff suppression when Prebid suppresses the same delivery', () => {
-    const code = 'composed-suppression-slot';
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    installedGptSlots = [slot];
-    const nativeRefresh = vi.fn();
-    const ts = (testWindow.tsjs = {} as unknown as PrebidTestWindow['tsjs']) as unknown as TsjsApi;
-    const handoff = {
-      gamUnitPath: '/123/composed',
-      formats: [[300, 250] as [number, number]],
-      divIdPrefix: code,
-      slotElementId: code,
-      publisherClaimed: true,
-      suppressPublisherDisplay: false,
-      suppressPublisherRefresh: true,
-    };
-    ts.gptSlotHandoffs = { [code]: handoff };
-    const innerRefresh = vi.fn((slots?: (typeof slot)[]) => {
-      if (handoff.suppressPublisherRefresh) {
-        handoff.suppressPublisherRefresh = false;
-        return;
-      }
-      nativeRefresh(slots);
-    });
-    const pubads = { refresh: innerRefresh, getSlots: () => [slot] };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    claimFirstImpressionForTrustedServer(ts, element);
-    installRefreshHandler(640);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh([slot]),
-    } as unknown as RequestBidsArg);
-
-    expect(handoff.suppressPublisherRefresh).toBe(false);
-    expect(innerRefresh).not.toHaveBeenCalled();
-
-    pubads.refresh([slot]);
-
-    expect(nativeRefresh).toHaveBeenCalledWith([slot]);
-  });
-
-  it('forwards only unsuppressed excluded slots', () => {
-    const suppressedCode = 'mixed-suppressed-slot';
-    const excludedCode = 'mixed-excluded-slot';
-    const suppressedSlot = {
-      getSlotElementId: () => suppressedCode,
-      getAdUnitPath: () => '/123/content',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const excludedSlot = {
-      getSlotElementId: () => excludedCode,
-      getAdUnitPath: () => '/123/trackingonly',
-      getTargeting: () => [],
-      getSizes: () => [[1, 1]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([suppressedSlot, excludedSlot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, document.getElementById(suppressedCode)!);
-    testWindow.__tsjs_prebid = { excludedGamAdUnitPathSuffixes: ['/trackingonly'] };
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code: suppressedCode, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh([suppressedSlot, excludedSlot]),
-    } as unknown as RequestBidsArg);
-
-    expect(originalRefresh).toHaveBeenCalledWith([excludedSlot], undefined);
-  });
-
-  it('rejects pending delivery state from a previous navigation', () => {
-    const code = 'previous-navigation-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    } as unknown as RequestBidsArg);
-    ((testWindow.tsjs ??= {}) as unknown as TsjsApi).navGeneration = 1;
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('rejects pending delivery state after physical element replacement', () => {
-    const code = 'replaced-physical-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    } as unknown as RequestBidsArg);
-    document.getElementById(code)?.remove();
-    const replacement = document.createElement('div');
-    replacement.id = code;
-    document.body.appendChild(replacement);
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  function installPrebidRefreshDiagnostics(
-    implementation?: (slots: Array<Record<string, unknown>>) => void
-  ) {
-    const recordPrebidRefresh = vi.fn(implementation);
-    testWindow.tsjs = { gptDiagnosticsRecorder: { recordPrebidRefresh } };
-    return recordPrebidRefresh;
-  }
-
-  it('suppresses one publisher delivery after TS claims first and allows a later refresh', () => {
-    const code = 'example-ts-first-slot';
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    try {
-      const targeting = new Map<string, string | string[]>([
-        ['ts_initial', '1'],
-        ['hb_adid', 'example-ts-ad-id'],
-        ['hb_pb', '1.25'],
-      ]);
-      const slot = {
-        getSlotElementId: () => code,
-        getTargeting: (key: string) => {
-          const value = targeting.get(key);
-          return value === undefined ? [] : Array.isArray(value) ? value : [value];
-        },
-        setTargeting: vi.fn((key: string, value: string | string[]) => {
-          targeting.set(key, value);
-          return slot;
-        }),
-        clearTargeting: vi.fn((key: string) => {
-          targeting.delete(key);
-          return slot;
-        }),
-        getSizes: () => [[300, 250]],
-      };
-      const ts = (testWindow.tsjs = {} as TsjsApi) as TsjsApi;
-      const claim = claimFirstImpressionForTrustedServer(ts, element)!;
-      claim.targeting = Object.fromEntries(targeting);
-      const { originalRefresh, pubads } = installGpt([slot]);
-      mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => pubads.refresh([slot], { changeCorrelator: false }),
-      } as unknown as RequestBidsArg);
-
-      expect(originalRefresh).not.toHaveBeenCalled();
-      expect(slot.setTargeting).toHaveBeenCalledWith('ts_initial', '1');
-      expect(slot.setTargeting).toHaveBeenCalledWith('hb_adid', 'example-ts-ad-id');
-      expect(ts.firstImpression?.slots[code]?.publisherRegistrationClosed).toBe(true);
-
-      pubads.refresh([slot], { changeCorrelator: false });
-
-      expect(mockRequestBids).toHaveBeenCalledTimes(2);
-      expect(originalRefresh).toHaveBeenCalledOnce();
-      expect(originalRefresh).toHaveBeenCalledWith([slot], { changeCorrelator: false });
-    } finally {
-      element.remove();
-    }
-  });
-
-  it('records a publisher delivery refresh immediately before its GPT request', () => {
-    const slot = {
-      getSlotElementId: () => 'example-delivery-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-delivery-marker', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => pubads.refresh([slot]),
-    } as unknown as RequestBidsArg);
-
-    expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-    expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-    expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('records a completed synthetic refresh immediately before its GPT request', () => {
-    const slot = {
-      getSlotElementId: () => 'example-synthetic-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-    expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-    expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('records every slot in a mixed SRA refresh before its GPT request', () => {
-    const deliverySlot = {
-      getSlotElementId: () => 'example-mixed-delivery-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const independentSlot = {
-      getSlotElementId: () => 'example-mixed-independent-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const targetSlots = [deliverySlot, independentSlot];
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const { originalRefresh, pubads } = installGpt(targetSlots);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code: 'example-mixed-delivery-marker',
-          bids: [{ bidder: 'exampleServer', params: {} }],
-        },
-      ],
-      bidsBackHandler: () => pubads.refresh(targetSlots),
-    } as unknown as RequestBidsArg);
-
-    expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-    expect(recordPrebidRefresh).toHaveBeenCalledWith(targetSlots);
-    expect(recordPrebidRefresh.mock.calls[0][0][0]).toBe(deliverySlot);
-    expect(recordPrebidRefresh.mock.calls[0][0][1]).toBe(independentSlot);
-    expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith(targetSlots, undefined);
-  });
-
-  it('records one synthetic timeout fallback before one GPT request', () => {
-    vi.useFakeTimers();
-    try {
-      const slot = {
-        getSlotElementId: () => 'example-timeout-marker',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-      const { originalRefresh, pubads } = installGpt([slot]);
-      mockRequestBids.mockImplementation(() => undefined);
-      installPrebidNpm();
-
-      pubads.refresh([slot]);
-      expect(recordPrebidRefresh).not.toHaveBeenCalled();
-      expect(originalRefresh).not.toHaveBeenCalled();
-
-      vi.advanceTimersByTime(640);
-
-      expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-      expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-      expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-        originalRefresh.mock.invocationCallOrder[0]
-      );
-      expect(originalRefresh).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('records a caught synthetic auction failure before one GPT fallback request', () => {
-    const slot = {
-      getSlotElementId: () => 'example-failure-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation(() => {
-      throw new Error('example auction failure');
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-    expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-    expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('does not record or refresh again for a late callback after timeout', () => {
-    vi.useFakeTimers();
-    try {
-      const slot = {
-        getSlotElementId: () => 'example-late-marker',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-      const { originalRefresh, pubads } = installGpt([slot]);
-      let bidsBackHandler: (() => void) | undefined;
-      mockRequestBids.mockImplementation((opts) => {
-        bidsBackHandler = opts.bidsBackHandler;
-      });
-      installPrebidNpm();
-
-      pubads.refresh([slot]);
-      vi.advanceTimersByTime(640);
-      bidsBackHandler?.();
-
-      expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-      expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-      expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-        originalRefresh.mock.invocationCallOrder[0]
-      );
-      expect(originalRefresh).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('does not record an adInit refresh bypass', () => {
-    const slot = {
-      getSlotElementId: () => 'example-adinit-marker-bypass',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const recordPrebidRefresh = vi.fn();
-    testWindow.tsjs = {
-      adInitRefreshInProgress: true,
-      gptDiagnosticsRecorder: { recordPrebidRefresh },
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-
-    pubads.refresh([slot]);
-
-    expect(recordPrebidRefresh).not.toHaveBeenCalled();
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('does not record empty or invalid refresh passthroughs', () => {
-    const slot = {
-      getSlotElementId: () => 'example-invalid-marker-bypass',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const invalidSlots = [slot, null];
-
-    pubads.refresh([]);
-    pubads.refresh(invalidSlots);
-
-    expect(recordPrebidRefresh).not.toHaveBeenCalled();
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, invalidSlots, undefined);
-  });
-
-  it('does not record a bare refresh when GPT cannot resolve its slot list', () => {
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-    const originalRefresh = vi.fn();
-    const pubads = { refresh: originalRefresh };
-    testWindow.googletag = {
-      cmd: { push: (fn: () => void) => fn() },
-      pubads: () => pubads,
-    };
-    installRefreshHandler(640);
-
-    pubads.refresh();
-
-    expect(recordPrebidRefresh).not.toHaveBeenCalled();
-    expect(mockRequestBids).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith(undefined, undefined);
-  });
-
-  it('does not record while a synthetic refresh is still waiting for its auction', () => {
-    vi.useFakeTimers();
-    try {
-      const slot = {
-        getSlotElementId: () => 'example-waiting-marker',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const recordPrebidRefresh = installPrebidRefreshDiagnostics();
-      const { originalRefresh, pubads } = installGpt([slot]);
-      let bidsBackHandler: (() => void) | undefined;
-      mockRequestBids.mockImplementation((opts) => {
-        bidsBackHandler = opts.bidsBackHandler;
-      });
-      installPrebidNpm();
-
-      pubads.refresh([slot]);
-
-      expect(recordPrebidRefresh).not.toHaveBeenCalled();
-      expect(originalRefresh).not.toHaveBeenCalled();
-
-      bidsBackHandler?.();
-      expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-      expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-        originalRefresh.mock.invocationCallOrder[0]
-      );
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('still refreshes with unchanged arguments when diagnostics throws', () => {
-    const slot = {
-      getSlotElementId: () => 'example-throwing-marker',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const refreshOptions = { changeCorrelator: false };
-    const recordPrebidRefresh = installPrebidRefreshDiagnostics(() => {
-      throw new Error('example diagnostics failure');
-    });
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    installPrebidNpm();
-
-    pubads.refresh([slot], refreshOptions);
-
-    expect(recordPrebidRefresh).toHaveBeenCalledTimes(1);
-    expect(recordPrebidRefresh).toHaveBeenCalledWith([slot]);
-    expect(recordPrebidRefresh.mock.invocationCallOrder[0]).toBeLessThan(
-      originalRefresh.mock.invocationCallOrder[0]
-    );
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], refreshOptions);
-  });
-
-  it('recovers inline params, ordered client bids, and zone when pbjs.adUnits is empty', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['exampleBrowser'],
-      serverSideBidders: ['exampleServer', 'appnexus'],
-    };
-    const runtimeInstance = 'example-runtime-instance';
-    const code = `example-slot-${runtimeInstance}`;
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [{ getWidth: () => 320, getHeight: () => 100 }],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const pbjs = installPrebidNpm();
-    const firstParams = { placement: 'first' };
-    const effectiveParams = { placement: 'effective' };
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code,
-          mediaTypes: { banner: { name: 'example-zone', sizes: [[320, 100]] } },
-          bids: [
-            { bidder: 'exampleServer', params: firstParams },
-            { bidder: 'exampleBrowser', params: { placement: 'browser-one' } },
-            { bidder: 'exampleServer', params: effectiveParams },
-            { bidder: 'exampleBrowser', params: { placement: 'browser-two' } },
-          ],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-    effectiveParams.placement = 'changed-after-auction';
-
-    pubads.refresh([slot]);
-
-    expect(mockPbjs.adUnits).toEqual([]);
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(refreshAdUnitFromLastRequest()).toEqual({
-      code,
-      mediaTypes: { banner: { name: 'example-zone', sizes: [[320, 100]] } },
-      bids: [
-        {
-          bidder: 'trustedServer',
-          params: {
-            bidderParams: { exampleServer: { placement: 'effective' } },
-            zone: 'example-zone',
-          },
-        },
-        { bidder: 'exampleBrowser', params: { placement: 'browser-one' } },
-        { bidder: 'exampleBrowser', params: { placement: 'browser-two' } },
-      ],
-    });
-  });
-
-  it('isolates nested bidder-param objects and arrays from later publisher mutation', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['exampleBrowser'],
-      serverSideBidders: ['exampleServer', 'appnexus'],
-    };
-    const code = 'example-nested-params-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const pbjs = installPrebidNpm();
-    const serverParams = {
-      placement: {
-        rules: [{ label: 'original-rule' }],
-        sizes: [300, 250],
-      },
-    };
-    const browserParams = {
-      groups: [{ values: ['original-value'] }],
-    };
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code,
-          bids: [
-            { bidder: 'exampleServer', params: serverParams },
-            { bidder: 'exampleBrowser', params: browserParams },
-          ],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-    serverParams.placement.rules[0].label = 'changed-rule';
-    serverParams.placement.sizes.push(999);
-    browserParams.groups[0].values[0] = 'changed-value';
-
-    pubads.refresh([slot]);
-
-    const expectedBids = [
-      {
-        bidder: 'trustedServer',
-        params: {
-          bidderParams: {
-            exampleServer: {
-              placement: {
-                rules: [{ label: 'original-rule' }],
-                sizes: [300, 250],
-              },
-            },
-          },
-        },
-      },
-      {
-        bidder: 'exampleBrowser',
-        params: { groups: [{ values: ['original-value'] }] },
-      },
-    ];
-    const firstRefreshBids = refreshAdUnitFromLastRequest().bids;
-    expect(firstRefreshBids).toEqual(expectedBids);
-
-    firstRefreshBids[0].params.bidderParams.exampleServer.placement.rules[0].label =
-      'changed-refresh-rule';
-    firstRefreshBids[0].params.bidderParams.exampleServer.placement.sizes.push(777);
-    firstRefreshBids[1].params.groups[0].values[0] = 'changed-refresh-value';
-    pubads.refresh([slot]);
-
-    expect(refreshAdUnitFromLastRequest().bids).toEqual(expectedBids);
-  });
-
-  it('keeps snapshots across repeated synthetic refreshes and overwrites newer publisher config', () => {
-    const code = 'example-dynamic-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code,
-          mediaTypes: { banner: { name: 'example-zone-one', sizes: [[300, 250]] } },
-          bids: [{ bidder: 'exampleServer', params: { placement: 'one' } }],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-    pubads.refresh([slot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({
-      bidderParams: { exampleServer: { placement: 'one' } },
-      zone: 'example-zone-one',
-    });
-
-    pubads.refresh([slot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({
-      bidderParams: { exampleServer: { placement: 'one' } },
-      zone: 'example-zone-one',
-    });
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code,
-          mediaTypes: { banner: { name: 'example-zone-two', sizes: [[300, 250]] } },
-          bids: [{ bidder: 'exampleServer', params: { placement: 'two' } }],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-    pubads.refresh([slot]);
-
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({
-      bidderParams: { exampleServer: { placement: 'two' } },
-      zone: 'example-zone-two',
-    });
-  });
-
-  it('does not cross-contaminate dynamic-code snapshots and retains the global fallback', () => {
-    const slotOne = {
-      getSlotElementId: () => 'example-code-one',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const slotTwo = {
-      getSlotElementId: () => 'example-code-two',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const globalSlot = {
-      getSlotElementId: () => 'example-global-code',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slotOne, slotTwo, globalSlot]);
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code: 'example-code-one',
-          bids: [{ bidder: 'exampleServer', params: { placement: 'one' } }],
-        },
-        {
-          code: 'example-code-two',
-          bids: [{ bidder: 'exampleServer', params: { placement: 'two' } }],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-    mockPbjs.adUnits = [
-      {
-        code: 'example-global-code',
-        bids: [{ bidder: 'exampleFallback', params: { placement: 'global' } }],
-      },
-    ];
-
-    pubads.refresh([slotOne]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params.bidderParams).toEqual({
-      exampleServer: { placement: 'one' },
-    });
-    pubads.refresh([slotTwo]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params.bidderParams).toEqual({
-      exampleServer: { placement: 'two' },
-    });
-    pubads.refresh([globalSlot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params.bidderParams).toEqual({
-      exampleFallback: { placement: 'global' },
-    });
-  });
-
-  it('prefers a rich live unit when a fresh same-code request overwrites the snapshot with empty bids', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['exampleBrowser'],
-      serverSideBidders: ['exampleServer', 'appnexus'],
-    };
-    const code = 'example-live-rich-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const liveUnit = {
-      code,
-      bids: [
-        { bidder: 'exampleServer', params: { placement: 'live-server' } },
-        { bidder: 'exampleBrowser', params: { placement: 'live-browser' } },
-      ],
-    };
-    mockPbjs.adUnits = [liveUnit];
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids();
-    pbjs.requestBids({ adUnits: [{ code, bids: [] }] } as unknown as RequestBidsArg);
-    pubads.refresh([slot]);
-
-    expect(refreshAdUnitFromLastRequest().bids).toEqual([
-      {
-        bidder: 'trustedServer',
-        params: { bidderParams: { exampleServer: { placement: 'live-server' } } },
-      },
-      { bidder: 'exampleBrowser', params: { placement: 'live-browser' } },
-    ]);
-  });
-
-  it('filters unowned stored bidder params before snapshot, reuse, and refresh recovery', () => {
-    testWindow.__tsjs_prebid = { serverSideBidders: ['exampleServer'] };
-    const code = 'example-stored-envelope-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const pbjs = installPrebidNpm();
-    const adUnits = [
-      {
-        code,
-        bids: [
-          {
-            bidder: 'trustedServer',
-            params: {
-              bidderParams: {
-                exampleServer: { placement: 'authoritative' },
-                pbsProviderId: { placement: 'provider' },
-                returnedSeatAlias: { placement: 'alias' },
-              },
-            },
-          },
-        ],
-      },
-    ];
-
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-    expect(adUnits[0].bids[0].params?.bidderParams).toEqual({
-      exampleServer: { placement: 'authoritative' },
-    });
-
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-    expect(adUnits[0].bids[0].params?.bidderParams).toEqual({
-      exampleServer: { placement: 'authoritative' },
-    });
-
-    pubads.refresh([slot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params?.bidderParams).toEqual({
-      exampleServer: { placement: 'authoritative' },
-    });
-  });
-
-  it('does not resurrect an older snapshot when the live unit is intentionally empty', () => {
-    const code = 'example-live-empty-slot';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([slot]);
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: { placement: 'snapshot' } }] }],
-    } as unknown as RequestBidsArg);
-    mockPbjs.adUnits = [{ code, bids: [] }];
-    pubads.refresh([slot]);
-
-    expect(refreshAdUnitFromLastRequest().bids).toEqual([
-      { bidder: 'trustedServer', params: { bidderParams: {} } },
-    ]);
-  });
-
-  it('evicts snapshots with the matching removeAdUnit lifecycle', () => {
-    const codes = ['example-remove-one', 'example-remove-two', 'example-remove-all'];
-    const slots = codes.map((code) => ({
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    }));
-    const { pubads } = installGpt(slots);
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: codes.map((code) => ({
-        code,
-        bids: [{ bidder: 'exampleServer', params: { placement: code } }],
-      })),
-    } as unknown as RequestBidsArg);
-    (pbjs as unknown as { removeAdUnit: (adUnitCode?: string | string[]) => void }).removeAdUnit(
-      codes[0]
-    );
-    (pbjs as unknown as { removeAdUnit: (adUnitCode?: string | string[]) => void }).removeAdUnit([
-      codes[1],
-    ]);
-
-    pubads.refresh([slots[0]]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({ bidderParams: {} });
-    pubads.refresh([slots[1]]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({ bidderParams: {} });
-    pubads.refresh([slots[2]]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params.bidderParams).toEqual({
-      exampleServer: { placement: codes[2] },
-    });
-
-    (pbjs as unknown as { removeAdUnit: (adUnitCode?: string | string[]) => void }).removeAdUnit();
-    pubads.refresh([slots[2]]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({ bidderParams: {} });
-  });
-
-  it('bounds snapshots with LRU eviction while retaining a recently refreshed entry', () => {
-    const capacity = 256;
-    const oldestCode = 'example-lru-0';
-    const activeCode = `example-lru-${capacity - 1}`;
-    const oldestSlot = {
-      getSlotElementId: () => oldestCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const activeSlot = {
-      getSlotElementId: () => activeCode,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { pubads } = installGpt([oldestSlot, activeSlot]);
-    const pbjs = installPrebidNpm();
-
-    for (let index = 0; index < capacity; index += 1) {
-      pbjs.requestBids({
-        adUnits: [
-          {
-            code: `example-lru-${index}`,
-            bids: [{ bidder: 'exampleServer', params: { placement: index } }],
-          },
-        ],
-      } as unknown as RequestBidsArg);
-    }
-
-    pubads.refresh([activeSlot]);
-    pbjs.requestBids({
-      adUnits: [
-        {
-          code: `example-lru-${capacity}`,
-          bids: [{ bidder: 'exampleServer', params: { placement: capacity } }],
-        },
-      ],
-    } as unknown as RequestBidsArg);
-
-    pubads.refresh([oldestSlot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params).toEqual({ bidderParams: {} });
-    pubads.refresh([activeSlot]);
-    expect(refreshAdUnitFromLastRequest().bids[0].params.bidderParams).toEqual({
-      exampleServer: { placement: capacity - 1 },
-    });
-  });
-
-  it('bypasses explicit covered subset delivery refreshes without clearing targeting', () => {
-    const slotOne = {
-      getSlotElementId: () => 'example-covered-one',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const slotTwo = {
-      getSlotElementId: () => 'example-covered-two-container',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    testWindow.tsjs = {
-      adSlots: [{ div_id: 'example-covered-two', formats: [[300, 250]], targeting: {} }],
-    };
-    const { originalRefresh, pubads } = installGpt([slotOne, slotTwo]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-covered-one', bids: [{ bidder: 'exampleServer', params: {} }] },
-        { code: 'example-covered-two', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => {
-        pubads.refresh([slotOne]);
-        pubads.refresh([slotTwo]);
-      },
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slotOne.clearTargeting).not.toHaveBeenCalled();
-    expect(slotTwo.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [slotOne], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, [slotTwo], undefined);
-  });
-
-  it('registers delivery state for a publisher auction without a bidsBackHandler', () => {
-    const code = 'example-handlerless-delivery';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    } as unknown as RequestBidsArg);
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('preserves one mixed refresh request and its original options', () => {
-    const deliverySlot = {
-      getSlotElementId: () => 'example-sra-delivery',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const independentSlot = {
-      getSlotElementId: () => 'example-sra-independent',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const refreshOptions = { changeCorrelator: true };
-    const { originalRefresh, pubads } = installGpt([deliverySlot, independentSlot]);
-    let syntheticBidsBackHandler: (() => void) | undefined;
-    mockRequestBids.mockImplementation((opts) => {
-      if (mockRequestBids.mock.calls.length === 1) {
-        completePublisherAuction(opts);
-      } else {
-        syntheticBidsBackHandler = opts.bidsBackHandler;
-      }
-    });
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code: 'example-sra-delivery', bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh([deliverySlot, independentSlot], refreshOptions),
-    } as unknown as RequestBidsArg);
-
-    expect(originalRefresh).not.toHaveBeenCalled();
-    expect(independentSlot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-
-    syntheticBidsBackHandler?.();
-
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([deliverySlot, independentSlot], refreshOptions);
-  });
-
-  it('partitions a bare delivery refresh from an unmatched GPT slot', () => {
-    const coveredSlot = {
-      getSlotElementId: () => 'example-covered',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const gamOnlySlot = {
-      getSlotElementId: () => 'example-gam-only-interstitial',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([coveredSlot, gamOnlySlot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code: 'example-covered', bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh(),
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(coveredSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(gamOnlySlot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([coveredSlot, gamOnlySlot], undefined);
-  });
-
-  it('keeps explicit unrelated lists synthetic and partitions mixed delivery lists', () => {
-    const coveredSlot = {
-      getSlotElementId: () => 'example-covered',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const unrelatedSlot = {
-      getSlotElementId: () => 'example-unrelated',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([coveredSlot, unrelatedSlot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code: 'example-covered', bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => {
-        pubads.refresh([unrelatedSlot]);
-        pubads.refresh([coveredSlot, unrelatedSlot]);
-      },
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(3);
-    expect(
-      mockRequestBids.mock.calls[1][0].adUnits.map((unit: { code?: string }) => unit.code)
-    ).toEqual(['example-unrelated']);
-    expect(
-      mockRequestBids.mock.calls[2][0].adUnits.map((unit: { code?: string }) => unit.code)
-    ).toEqual(['example-unrelated']);
-    expect(coveredSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(unrelatedSlot.clearTargeting).toHaveBeenCalledWith('ts_initial');
-    expect(unrelatedSlot.clearTargeting).toHaveBeenCalledWith('hb_cache_path');
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [unrelatedSlot], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, [coveredSlot, unrelatedSlot], undefined);
-  });
-
-  it('partitions four delivered slots from an unmatched explicit slot', () => {
-    const coveredSlots = Array.from({ length: 4 }, (_, index) => ({
-      getSlotElementId: () => `example-covered-${index}`,
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    }));
-    const gamOnlySlot = {
-      getSlotElementId: () => 'example-gam-only-interstitial',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const refreshSlots = [...coveredSlots, gamOnlySlot];
-    const { originalRefresh, pubads } = installGpt(refreshSlots);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: coveredSlots.map((_, index) => ({
-        code: `example-covered-${index}`,
-        bids: [{ bidder: 'exampleServer', params: { placement: index } }],
-      })),
-      bidsBackHandler: () => pubads.refresh(refreshSlots),
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    coveredSlots.forEach((slot) => expect(slot.clearTargeting).not.toHaveBeenCalled());
-    expect(gamOnlySlot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith(refreshSlots, undefined);
-  });
-
-  it('expires an unconsumed publisher delivery before a later refresh', () => {
-    vi.useFakeTimers();
-    try {
-      const code = 'example-expired-delivery';
-      const slot = {
-        getSlotElementId: () => code,
-        getTargeting: () => [],
-        getSizes: () => [[300, 250]],
-        clearTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      mockRequestBids.mockImplementation((opts) =>
-        completePublisherAuction(opts, { applyTargeting: false })
-      );
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      } as unknown as RequestBidsArg);
-      vi.advanceTimersByTime(5001);
-      pubads.refresh([slot]);
-
-      expect(mockRequestBids).toHaveBeenCalledTimes(2);
-      expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-      expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('expires an unconsumed targeted delivery before a later refresh', () => {
-    vi.useFakeTimers();
-    try {
-      const code = 'example-expired-targeted-delivery';
-      const slot = {
-        getSlotElementId: () => code,
-        getTargeting: () => [],
-        getSizes: () => [[300, 250]],
-        clearTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      } as unknown as RequestBidsArg);
-      vi.advanceTimersByTime(5001);
-      pubads.refresh([slot]);
-
-      expect(mockRequestBids).toHaveBeenCalledTimes(2);
-      expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-      expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('correlates a targeted delivery refresh after more than one second without a timer race', () => {
-    vi.useFakeTimers();
-    try {
-      const code = 'example-delayed-delivery';
-      const auctionId = 'example-delayed-auction';
-      const slot = {
-        getSlotElementId: () => code,
-        getTargeting: () => [],
-        getSizes: () => [[300, 250]],
-        clearTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      mockRequestBids.mockImplementation((opts) =>
-        completePublisherAuction(opts, { auctionId, applyTargeting: false })
-      );
-      const pbjs = installPrebidNpm();
-
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => {
-          setTimeout(() => {
-            deliveryAdIds.set(slot, `${auctionId}-${code}`);
-            pubads.refresh([slot]);
-          }, 1500);
-        },
-      } as unknown as RequestBidsArg);
-
-      vi.advanceTimersByTime(1500);
-
-      expect(mockRequestBids).toHaveBeenCalledTimes(1);
-      expect(slot.clearTargeting).not.toHaveBeenCalled();
-      expect(originalRefresh).toHaveBeenCalledTimes(1);
-      expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-
-      pubads.refresh([slot]);
-      expect(mockRequestBids).toHaveBeenCalledTimes(2);
-      expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-      expect(originalRefresh).toHaveBeenCalledTimes(2);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('correlates null and no-argument targeting with a custom GPT slot match', () => {
-    const code = 'example-custom-matched-code';
-    const slot = {
-      getSlotElementId: () => 'example-different-gpt-slot',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const publisherElement = document.createElement('div');
-    publisherElement.id = code;
-    publisherElement.appendChild(document.getElementById('example-different-gpt-slot')!);
-    document.body.appendChild(publisherElement);
-    let auctionId = 'example-null-auction';
-    const setTargetingForGPTAsync = vi.fn(() => {
-      deliveryAdIds.set(slot, `${auctionId}-${code}`);
-    });
-    mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { auctionId, applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => {
-        (
-          pbjs as unknown as { setTargetingForGPTAsync: (codes?: string[]) => void }
-        ).setTargetingForGPTAsync(null, () => () => true);
-        pubads.refresh([slot]);
-      },
-    } as unknown as RequestBidsArg);
-
-    auctionId = 'example-no-argument-auction';
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => {
-        (
-          pbjs as unknown as { setTargetingForGPTAsync: (codes?: string[]) => void }
-        ).setTargetingForGPTAsync();
-        pubads.refresh([slot]);
-      },
-    } as unknown as RequestBidsArg);
-
-    expect(setTargetingForGPTAsync).toHaveBeenNthCalledWith(1, null, expect.any(Function));
-    expect(setTargetingForGPTAsync).toHaveBeenNthCalledWith(2);
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [slot], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, [slot], undefined);
-    mockPbjs.setTargetingForGPTAsync = undefined;
-  });
-
-  it('correlates requested no-bid slots without manufacturing unrelated bid state', () => {
-    const slot = {
-      getSlotElementId: () => 'example-no-bid-delivery',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation(
-      (opts?: { bidsBackHandler?: (...args: unknown[]) => void }) => {
-        opts?.bidsBackHandler?.({ 'example-no-bid-delivery': { bids: [null, {}] } }, false, 'bad');
-      }
-    );
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-no-bid-delivery', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => pubads.refresh([slot]),
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('bounds code-only delivery correlation to one suppressed independent refresh', () => {
-    const code = 'example-code-only-delivery';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-
-    // Model an initial impression rendered with display() after an auction
-    // that did not apply hb_adid targeting. Its code-only state is unconsumed.
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    } as unknown as RequestBidsArg);
-
-    pubads.refresh([slot]);
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-
-    pubads.refresh([slot]);
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-  });
-
-  it('does not use code fallback when a slot has an unmatched hb_adid', () => {
-    const code = 'example-stale-targeting';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: (key: string) => (key === 'hb_adid' ? ['example-stale-ad-id'] : []),
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => pubads.refresh([slot]),
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('uses an independent auction when a pending hb_adid exceeds the capacity bound', () => {
-    const capacity = 2048;
-    const code = 'example-capacity-delivery';
-    const oldestAdId = 'example-capacity-ad-0';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => {
-      if (mockRequestBids.mock.calls.length === 1) {
-        opts.bidsBackHandler?.({
-          [code]: {
-            bids: Array.from({ length: capacity + 1 }, (_, index) => ({
-              adId: `example-capacity-ad-${index}`,
-              adUnitCode: code,
-            })),
-          },
-        });
-        return;
-      }
-      completePublisherAuction(opts);
-    });
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    } as unknown as RequestBidsArg);
-    deliveryAdIds.set(slot, oldestAdId);
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('bypasses a mixed explicit delivery list spanning nested contexts', () => {
-    const outerSlot = {
-      getSlotElementId: () => 'example-outer-delivery',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const innerSlot = {
-      getSlotElementId: () => 'example-inner-delivery',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const gamOnlySlot = {
-      getSlotElementId: () => 'example-gam-only-interstitial',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const refreshSlots = [innerSlot, outerSlot, gamOnlySlot];
-    const { originalRefresh, pubads } = installGpt(refreshSlots);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-outer-delivery', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => {
-        pbjs.requestBids({
-          adUnits: [
-            { code: 'example-inner-delivery', bids: [{ bidder: 'exampleServer', params: {} }] },
-          ],
-          bidsBackHandler: () => pubads.refresh(refreshSlots),
-        } as unknown as RequestBidsArg);
-      },
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(3);
-    expect(innerSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(outerSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(gamOnlySlot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith(refreshSlots, undefined);
-  });
-
-  it('correlates a microtask refresh by its requested code without targeting', async () => {
-    const slot = {
-      getSlotElementId: () => 'example-deferred-refresh',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-    let deferredRefresh: Promise<void> | undefined;
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-deferred-refresh', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => {
-        deferredRefresh = Promise.resolve().then(() => pubads.refresh([slot]));
-      },
-    } as unknown as RequestBidsArg);
-    await deferredRefresh;
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('correlates targeting and refresh deferred together to a microtask', async () => {
-    const code = 'example-targeted-microtask';
-    const auctionId = 'example-targeted-microtask-auction';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { auctionId, applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-    let deferredRefresh: Promise<void> | undefined;
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () => {
-        deferredRefresh = Promise.resolve().then(() => {
-          deliveryAdIds.set(slot, `${auctionId}-${code}`);
-          pubads.refresh([slot]);
-        });
-      },
-    } as unknown as RequestBidsArg);
-    await deferredRefresh;
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('preserves a sibling registration after consuming an exact overlapping delivery', () => {
-    const code = 'example-overlapping-code';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    for (let index = 0; index < 2; index += 1) {
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => {},
-      } as unknown as RequestBidsArg);
-    }
-
-    deliveryAdIds.set(slot, `example-auction-0-${code}`);
-    pubads.refresh([slot]);
-    deliveryAdIds.set(slot, `example-auction-1-${code}`);
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [slot], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, [slot], undefined);
-  });
-
-  it('does not guess between ordinary overlapping code-only registrations', () => {
-    const code = 'example-ambiguous-code-only';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    for (let index = 0; index < 2; index += 1) {
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => {},
-      } as unknown as RequestBidsArg);
-    }
-
-    deliveryAdIds.delete(slot);
-    pubads.refresh([slot]);
-    expect(mockRequestBids).toHaveBeenCalledTimes(3);
-
-    deliveryAdIds.set(slot, `example-auction-0-${code}`);
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(3);
-    expect(originalRefresh).toHaveBeenCalledTimes(2);
-  });
-
-  it('fails closed without consuming TS-owned ambiguous code-only registrations', () => {
-    const code = 'example-ts-ambiguous-code-only';
-    const element = document.createElement('div');
-    element.id = code;
-    document.body.appendChild(element);
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-      setTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const ts = (testWindow.tsjs ??= {}) as unknown as TsjsApi;
-    claimFirstImpressionForTrustedServer(ts, element);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    for (let index = 0; index < 2; index += 1) {
-      pbjs.requestBids({
-        adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-        bidsBackHandler: () => {},
-      } as unknown as RequestBidsArg);
-    }
-
-    deliveryAdIds.delete(slot);
-    pubads.refresh([slot]);
-    deliveryAdIds.set(slot, `example-auction-0-${code}`);
-    pubads.refresh([slot]);
-    deliveryAdIds.set(slot, `example-auction-1-${code}`);
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).not.toHaveBeenCalled();
-    element.remove();
-  });
-
-  it('filters invalid explicit entries without duplicating or leaking a valid delivery', () => {
-    const code = 'example-valid-delivery';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-      bidsBackHandler: () =>
-        pubads.refresh([slot, undefined, null] as unknown as Array<Record<string, unknown>>),
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledWith([slot, undefined, null], undefined);
-
-    pubads.refresh([slot]);
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(slot.clearTargeting).not.toHaveBeenCalled();
-  });
-
-  it('does not mutate reused publisher request options', () => {
-    const code = 'example-reused-request';
-    const slot = {
-      getSlotElementId: () => code,
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-    const request = {
-      adUnits: [{ code, bids: [{ bidder: 'exampleServer', params: {} }] }],
-    };
-
-    pbjs.requestBids(request as unknown as RequestBidsArg);
-    pbjs.requestBids(request as unknown as RequestBidsArg);
-    pubads.refresh([slot]);
-
-    expect(request).not.toHaveProperty('bidsBackHandler');
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('falls back to one GPT refresh when a synthetic auction throws', () => {
-    const slot = {
-      getSlotElementId: () => 'example-throwing-refresh',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    const setTargetingForGPTAsync = vi.fn();
-    mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-    mockRequestBids.mockImplementation(() => {
-      throw new Error('example synthetic failure');
-    });
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(slot.clearTargeting).toHaveBeenCalledWith('hb_adid');
-    expect(setTargetingForGPTAsync).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('applies targeting before falling back when a synthetic auction never calls back', () => {
-    vi.useFakeTimers();
-    try {
-      const slot = {
-        getSlotElementId: () => 'example-missing-refresh-callback',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      const setTargetingForGPTAsync = vi.fn();
-      mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-      mockRequestBids.mockImplementation(() => undefined);
-      installPrebidNpm();
-
-      pubads.refresh([slot]);
-      expect(originalRefresh).not.toHaveBeenCalled();
-      vi.advanceTimersByTime(640);
-
-      expect(setTargetingForGPTAsync).toHaveBeenCalledWith(['example-missing-refresh-callback']);
-      expect(setTargetingForGPTAsync.mock.invocationCallOrder[0]).toBeLessThan(
-        originalRefresh.mock.invocationCallOrder[0]
-      );
-      expect(originalRefresh).toHaveBeenCalledTimes(1);
-      expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('applies fallback targeting once and ignores a late synthetic callback', () => {
-    vi.useFakeTimers();
-    try {
-      const slot = {
-        getSlotElementId: () => 'example-late-refresh-callback',
-        getTargeting: () => [],
-        clearTargeting: vi.fn(),
-      };
-      const { originalRefresh, pubads } = installGpt([slot]);
-      const setTargetingForGPTAsync = vi.fn();
-      mockPbjs.setTargetingForGPTAsync = setTargetingForGPTAsync;
-      let syntheticBidsBackHandler: (() => void) | undefined;
-      mockRequestBids.mockImplementation((opts) => {
-        syntheticBidsBackHandler = opts.bidsBackHandler;
-      });
-      installPrebidNpm();
-
-      pubads.refresh([slot]);
-      vi.advanceTimersByTime(640);
-      syntheticBidsBackHandler?.();
-
-      expect(setTargetingForGPTAsync).toHaveBeenCalledTimes(1);
-      expect(setTargetingForGPTAsync).toHaveBeenCalledWith(['example-late-refresh-callback']);
-      expect(setTargetingForGPTAsync.mock.invocationCallOrder[0]).toBeLessThan(
-        originalRefresh.mock.invocationCallOrder[0]
-      );
-      expect(originalRefresh).toHaveBeenCalledTimes(1);
-    } finally {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  it('completes a synthetic refresh when targeting throws', () => {
-    const slot = {
-      getSlotElementId: () => 'example-throwing-targeting',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockPbjs.setTargetingForGPTAsync = vi.fn(() => {
-      throw new Error('example targeting failure');
-    });
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-
-  it('does not stack the removeAdUnit lifecycle wrapper across installation', () => {
-    const pbjs = installPrebidNpm();
-    installPrebidNpm();
-
-    (pbjs as unknown as { removeAdUnit: (adUnitCode?: string | string[]) => void }).removeAdUnit(
-      'example-reinstalled-slot'
-    );
-
-    expect(mockRemoveAdUnit).toHaveBeenCalledTimes(1);
-  });
-
-  it('keeps nested publisher delivery contexts isolated during reentrant auctions', () => {
-    const outerSlot = {
-      getSlotElementId: () => 'example-outer-delivery',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const innerSlot = {
-      getSlotElementId: () => 'example-inner-delivery',
-      getTargeting: () => [],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([outerSlot, innerSlot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    const pbjs = installPrebidNpm();
-
-    pbjs.requestBids({
-      adUnits: [
-        { code: 'example-outer-delivery', bids: [{ bidder: 'exampleServer', params: {} }] },
-      ],
-      bidsBackHandler: () => {
-        pbjs.requestBids({
-          adUnits: [
-            { code: 'example-inner-delivery', bids: [{ bidder: 'exampleServer', params: {} }] },
-          ],
-          bidsBackHandler: () => pubads.refresh([innerSlot]),
-        } as unknown as RequestBidsArg);
-        pubads.refresh([outerSlot]);
-      },
-    } as unknown as RequestBidsArg);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(innerSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(outerSlot.clearTargeting).not.toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenNthCalledWith(1, [innerSlot], undefined);
-    expect(originalRefresh).toHaveBeenNthCalledWith(2, [outerSlot], undefined);
-  });
-
-  it('cleans delivery context after a publisher callback throws', () => {
-    const slot = {
-      getSlotElementId: () => 'example-throwing-callback',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) =>
-      completePublisherAuction(opts, { applyTargeting: false })
-    );
-    const pbjs = installPrebidNpm();
-
-    expect(() =>
-      pbjs.requestBids({
-        adUnits: [
-          {
-            code: 'example-throwing-callback',
-            bids: [{ bidder: 'exampleServer', params: {} }],
-          },
-        ],
-        bidsBackHandler: () => {
-          throw new Error('example callback failure');
-        },
-      } as unknown as RequestBidsArg)
-    ).toThrow('example callback failure');
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(2);
-    expect(slot.clearTargeting).toHaveBeenCalled();
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-  });
-
-  it('completes an internal synthetic refresh once without recursion', () => {
-    const slot = {
-      getSlotElementId: () => 'example-independent-refresh',
-      getTargeting: () => [],
-      getSizes: () => [[300, 250]],
-      clearTargeting: vi.fn(),
-    };
-    const { originalRefresh, pubads } = installGpt([slot]);
-    mockRequestBids.mockImplementation((opts) => completePublisherAuction(opts));
-    installPrebidNpm();
-
-    pubads.refresh([slot]);
-
-    expect(mockRequestBids).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledTimes(1);
-    expect(originalRefresh).toHaveBeenCalledWith([slot], undefined);
-  });
-});
-
-describe('prebid/client-side bidders', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockPbjs.requestBids = mockRequestBids;
-    mockPbjs.adUnits = [];
-    mockGetUserIdsAsEids.mockReset();
-    mockGetUserIdsAsEids.mockReturnValue([]);
-    // By default the manifest declares all adapters compiled in.
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-    delete testWindow.__tsjs_prebid;
-  });
-
-  afterEach(() => {
-    delete testWindow.__tsjs_prebid;
-  });
-
-  it('excludes client-side bidders from trustedServer bidderParams', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 123 } },
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-          { bidder: 'kargo', params: { placementId: 'k1' } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-    expect(tsBid).toBeDefined();
-    // rubicon should NOT be in bidderParams — it runs client-side
-    expect(tsBid.params.bidderParams).toEqual({
-      appnexus: { placementId: 123 },
-      kargo: { placementId: 'k1' },
-    });
-  });
-
-  it('preserves client-side bidder bids as standalone entries', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 123 } },
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    // rubicon bid should remain untouched as a standalone entry
-    const rubiconBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'rubicon') as TestBid;
-    expect(rubiconBid).toBeDefined();
-    expect(rubiconBid.params).toEqual({ accountId: 'abc' });
-    expect(adUnits[0].bids.find((b: TestBid) => b.bidder === 'appnexus')).toBeUndefined();
-  });
-
-  it('handles multiple client-side bidders', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon', 'openx'],
-      serverSideBidders: ['appnexus', 'exampleServer'],
-    };
-
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 123 } },
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-          { bidder: 'openx', params: { unit: '456' } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-    // Only appnexus should be in bidderParams
-    expect(tsBid.params.bidderParams).toEqual({
-      appnexus: { placementId: 123 },
-    });
-
-    // Both client-side bidders should remain
-    expect(adUnits[0].bids.find((b: TestBid) => b.bidder === 'rubicon')).toBeDefined();
-    expect(adUnits[0].bids.find((b: TestBid) => b.bidder === 'openx')).toBeDefined();
-    expect(adUnits[0].bids.find((b: TestBid) => b.bidder === 'appnexus')).toBeUndefined();
-  });
-
-  it('leaves all unowned bidders in browser demand when no routes are configured', () => {
-    testWindow.__tsjs_prebid = { serverSideBidders: [] };
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 123 } },
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-    expect(tsBid.params?.bidderParams).toEqual({});
-    expect(adUnits[0].bids.map((bid) => bid.bidder)).toEqual([
-      'appnexus',
-      'rubicon',
-      'trustedServer',
-    ]);
-  });
-
-  it('behaves normally when client-side bidders list is empty', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: [],
-      serverSideBidders: ['appnexus', 'rubicon'],
-    };
-
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'appnexus', params: { placementId: 123 } },
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-    expect(tsBid.params.bidderParams).toEqual({
-      appnexus: { placementId: 123 },
-      rubicon: { accountId: 'abc' },
-    });
-  });
-
-  it('still injects trustedServer when all bidders are client-side', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon', 'appnexus'],
-      serverSideBidders: ['openx', 'exampleServer'],
-    };
-
-    const pbjs = installPrebidNpm();
-
-    const adUnits = [
-      {
-        bids: [
-          { bidder: 'rubicon', params: { accountId: 'abc' } },
-          { bidder: 'appnexus', params: { placementId: 123 } },
-        ],
-      },
-    ];
-    pbjs.requestBids({ adUnits } as unknown as RequestBidsArg);
-
-    // trustedServer should still be present (even with empty bidderParams)
-    const tsBid = adUnits[0].bids.find((b: TestBid) => b.bidder === 'trustedServer') as TestBid;
-    expect(tsBid).toBeDefined();
-    expect(tsBid.params.bidderParams).toEqual({});
-  });
-
-  it('logs error when a client-side bidder has no adapter in the external bundle', () => {
-    // rubicon is compiled into the external bundle, but openx is not
-    testWindow.__tsjs_prebid_bundle = {
-      ...DEFAULT_BUNDLE_MANIFEST,
-      adapters: ['rubicon'],
-      bidderCodes: ['rubicon'],
-    };
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon', 'openx'],
-      serverSideBidders: ['appnexus', 'exampleServer'],
-    };
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    installPrebidNpm();
-
-    // Should log an error for the missing adapter.
-    // log.error() uses styled console output: console.error('%c[tsjs]%c ...:', style, reset, ...args)
-    // so the actual message is the 4th argument.
-    const errorCalls = errorSpy.mock.calls;
-    const hasOpenxError = errorCalls.some((args) =>
-      args.some(
-        (a) =>
-          typeof a === 'string' &&
-          a.includes('client-side bidder "openx" has no adapter in the external Prebid bundle')
-      )
-    );
-    expect(hasOpenxError).toBe(true);
-
-    // The error should point at the operator surface: the CLI config key,
-    // not the internal build script.
-    const pointsAtBundleConfig = errorCalls.some((args) =>
-      args.some((a) => typeof a === 'string' && a.includes('[integrations.prebid.bundle].adapters'))
-    );
-    expect(pointsAtBundleConfig).toBe(true);
-
-    // Should NOT log an error for the compiled-in adapter
-    const hasRubiconError = errorCalls.some((args) =>
-      args.some((a) => typeof a === 'string' && a.includes('client-side bidder "rubicon"'))
-    );
-    expect(hasRubiconError).toBe(false);
-
-    errorSpy.mockRestore();
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  it('accepts alias bidder codes stamped in bidderCodes', () => {
-    // The adf module registers adf plus the adform/adformOpenRTB aliases;
-    // the module-name list alone would flag them as missing.
-    testWindow.__tsjs_prebid_bundle = {
-      ...DEFAULT_BUNDLE_MANIFEST,
-      adapters: ['adf'],
-      bidderCodes: ['adf', 'adform', 'adformOpenRTB'],
-    };
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['adform'],
-      serverSideBidders: ['appnexus', 'exampleServer'],
-    };
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    installPrebidNpm();
-
-    const hasAdapterError = errorSpy.mock.calls.some((args) =>
-      args.some(
-        (a) => typeof a === 'string' && a.includes('has no adapter in the external Prebid bundle')
-      )
-    );
-    expect(hasAdapterError).toBe(false);
-
-    errorSpy.mockRestore();
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  it('rejects a module file stem that is not a registered bidder code', () => {
-    // a1MediaBidAdapter.js registers a1media — configuring the file stem
-    // must be flagged even though the module itself is compiled in.
-    testWindow.__tsjs_prebid_bundle = {
-      ...DEFAULT_BUNDLE_MANIFEST,
-      adapters: ['a1Media'],
-      bidderCodes: ['a1media'],
-    };
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['a1Media'],
-      serverSideBidders: ['appnexus', 'exampleServer'],
-    };
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    installPrebidNpm();
-
-    const hasAdapterError = errorSpy.mock.calls.some((args) =>
-      args.some(
-        (a) =>
-          typeof a === 'string' &&
-          a.includes('client-side bidder "a1Media" has no adapter in the external Prebid bundle')
-      )
-    );
-    expect(hasAdapterError).toBe(true);
-
-    errorSpy.mockRestore();
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  it('treats a malformed manifest as unstamped instead of throwing', () => {
-    // The manifest is a plain window global any page script can overwrite.
-    testWindow.__tsjs_prebid_bundle = { adapters: 'rubicon', userIdModules: 42 };
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    expect(() => installPrebidNpm()).not.toThrow();
-
-    const hasManifestWarn = warnSpy.mock.calls.some((args) =>
-      args.some((a) => typeof a === 'string' && a.includes('did not stamp an adapter manifest'))
-    );
-    expect(hasManifestWarn).toBe(true);
-
-    warnSpy.mockRestore();
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  it('warns when the external bundle stamped no adapter manifest', () => {
-    delete testWindow.__tsjs_prebid_bundle;
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    installPrebidNpm();
-
-    const hasManifestWarn = warnSpy.mock.calls.some((args) =>
-      args.some((a) => typeof a === 'string' && a.includes('did not stamp an adapter manifest'))
-    );
-    expect(hasManifestWarn).toBe(true);
-
-    warnSpy.mockRestore();
-    testWindow.__tsjs_prebid_bundle = DEFAULT_BUNDLE_MANIFEST;
-  });
-
-  it('does not log errors when all client-side bidders have adapters', () => {
-    testWindow.__tsjs_prebid = {
-      clientSideBidders: ['rubicon'],
-      serverSideBidders: ['appnexus', 'exampleServer', 'kargo'],
-    };
-
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    installPrebidNpm();
-
-    const hasAdapterError = errorSpy.mock.calls.some((args) =>
-      args.some(
-        (a) => typeof a === 'string' && a.includes('has no adapter in the external Prebid bundle')
-      )
-    );
-    expect(hasAdapterError).toBe(false);
-
-    errorSpy.mockRestore();
-  });
-});
-
-describe('prebid/self-init without the external bundle', () => {
-  afterEach(() => {
-    // Restore the module registry and the full mock global for later suites.
-    testWindow.pbjs = mockPbjs;
-    delete testWindow.googletag;
-    vi.resetModules();
-  });
-
-  it('keeps basic Prebid enabled when only the APS lifecycle API is unavailable', async () => {
-    vi.resetModules();
-    const registerBidAdapter = vi.fn();
-    const onEvent = vi.fn();
-    const originalRequestBids = vi.fn();
-    const compatiblePbjs = {
-      ...mockPbjs,
-      registerBidAdapter,
-      onEvent,
-      requestBids: originalRequestBids,
-      markWinningBidAsUsed: undefined,
-      que: [] as Array<() => void>,
-      cmd: [] as Array<() => void>,
-    };
-    testWindow.pbjs = compatiblePbjs;
-    const pubads = { refresh: vi.fn() };
-    const cmdPush = vi.fn((callback: () => void) => callback());
-    testWindow.googletag = { cmd: { push: cmdPush }, pubads: () => pubads };
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-
-    await import('../../../src/integrations/prebid/index');
-
-    expect(registerBidAdapter).toHaveBeenCalledTimes(1);
-    expect(compatiblePbjs.requestBids).not.toBe(originalRequestBids);
-
-    const adapter = registerBidAdapter.mock.calls[0][2] as TestAdapterSpec;
-    const convertedBids = adapter.interpretResponse(
-      {
-        body: {
-          seatbid: [
-            {
-              seat: 'appnexus',
-              bid: [
-                {
-                  impid: 'ordinary-slot',
-                  price: 2.5,
-                  adm: '<div>ordinary creative</div>',
-                  w: 300,
-                  h: 250,
-                },
-              ],
-            },
-            {
-              seat: 'aps',
-              bid: [
-                {
-                  impid: 'aps-slot',
-                  price: 3.5,
-                  ext: { trusted_server: { renderer: apsRenderer() } },
-                },
-              ],
-            },
-          ],
-        },
-      },
-      {
-        tsjsBidRequests: [
-          { adUnitCode: 'ordinary-slot', bidId: 'ordinary-request' },
-          { adUnitCode: 'aps-slot', bidId: 'aps-request' },
-        ],
-      }
-    );
-
-    expect(convertedBids).toHaveLength(1);
-    expect(convertedBids[0]).toEqual(
-      expect.objectContaining({
-        requestId: 'ordinary-request',
-        bidderCode: 'appnexus',
-        ad: '<div>ordinary creative</div>',
-      })
-    );
-    expect(convertedBids).not.toEqual(
-      expect.arrayContaining([expect.objectContaining({ bidderCode: 'aps' })])
-    );
-    expect(onEvent).not.toHaveBeenCalledWith('bidResponse', expect.any(Function));
-    expect(
-      warnSpy.mock.calls.some((args) =>
-        args.some(
-          (value) => typeof value === 'string' && value.includes('APS renderer bids disabled')
-        )
-      )
-    ).toBe(true);
-    expect(testWindow.__tsjsPrebidShimInstalled).toBe(true);
-
-    warnSpy.mockRestore();
-  });
-});
-
-describe('prebid self-init user ID module timing', () => {
-  const userSyncCallCount = () =>
-    mockSetConfig.mock.calls.filter(([arg]) => arg && typeof arg === 'object' && 'userSync' in arg)
-      .length;
-
-  const setReadyState = (value: DocumentReadyState) => {
-    Object.defineProperty(document, 'readyState', { value, configurable: true });
-  };
-
-  beforeEach(() => {
-    vi.resetModules();
-    mockSetConfig.mockClear();
-  });
-
-  afterEach(() => {
-    setReadyState('complete');
-  });
-
-  it('installs user ID modules immediately when the bundle loads after window load', async () => {
-    // The GPT slim loader appends this bundle from a window.load handler, so
-    // the document is already complete — a load listener would never fire.
-    setReadyState('complete');
-
-    await import('../../../src/integrations/prebid/index');
-
-    expect(userSyncCallCount()).toBeGreaterThan(0);
-  });
-
-  it('defers user ID modules to window load when the document is still loading', async () => {
-    setReadyState('loading');
-
-    await import('../../../src/integrations/prebid/index');
-
-    expect(userSyncCallCount()).toBe(0);
-
-    window.dispatchEvent(new Event('load'));
-    expect(userSyncCallCount()).toBe(1);
-
-    // { once: true } — a second load event must not reinstall.
-    window.dispatchEvent(new Event('load'));
-    expect(userSyncCallCount()).toBe(1);
-  });
-});
diff --git a/crates/trusted-server-js/lib/test/integrations/prebid/later.test.ts b/crates/trusted-server-js/lib/test/integrations/prebid/later.test.ts
new file mode 100644
index 000000000..9f1ef515c
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/prebid/later.test.ts
@@ -0,0 +1,205 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createPrebidLaterIntegrationRegistration } from '../../../src/integrations/prebid/later';
+import type { PrebidRefreshPolicy } from '../../../src/integrations/prebid/refresh';
+import { createTestNavigationIdentityIssuer } from '../../../src/kernel/identity';
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+import { createRuntimeSession } from '../../../src/kernel/sessions';
+
+const RELEASE_ID = 'a'.repeat(64);
+const CONFIG = Object.freeze({
+  accountId: 'fictional-account',
+  timeout: 1_000,
+  debug: false,
+  bidders: Object.freeze(['server']),
+  clientSideBidders: Object.freeze(['client']),
+  excludedGamAdUnitPathSuffixes: Object.freeze(['/excluded']),
+});
+
+function harness(acceptPolicy = true) {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(4);
+          return target;
+        },
+      }),
+  });
+  const navigationResult = runtime.startInitialNavigation();
+  if (!navigationResult.ok) throw new Error('Expected current navigation');
+  const navigation = navigationResult.value;
+  const physicalSlot = Object.freeze({ id: 'physical-slot' });
+  const directAuctionUnit = Object.freeze({
+    code: 'slot-one',
+    mediaTypes: Object.freeze({
+      banner: Object.freeze({ sizes: Object.freeze([Object.freeze([300, 250])]) }),
+    }),
+    bids: Object.freeze([
+      Object.freeze({
+        bidder: 'trustedServer',
+        params: Object.freeze({
+          bidderParams: Object.freeze({
+            server: Object.freeze({ placement: 'server-owned' }),
+          }),
+        }),
+      }),
+      Object.freeze({ bidder: 'client', params: Object.freeze({ placement: 'publisher-client' }) }),
+    ]),
+  });
+  const clearTargeting = vi.fn();
+  const gptOperationDispose = vi.fn();
+  const googletagRun = vi.fn((command: (facade: object) => unknown) =>
+    Object.freeze({
+      result: Promise.resolve(
+        command(
+          Object.freeze({
+            adUnitPath: () => '/network/eligible',
+            clearTargeting,
+          })
+        )
+      ),
+      dispose: gptOperationDispose,
+    })
+  );
+  const requestBids = vi.fn((request: Readonly<Record<string, unknown>>) => {
+    const callback = request.bidsBackHandler;
+    if (typeof callback === 'function') callback();
+  });
+  const setTargetingForGpt = vi.fn();
+  const prebidOperationDispose = vi.fn();
+  const prebidRun = vi.fn((command: (facade: object) => unknown) =>
+    Object.freeze({
+      result: Promise.resolve(
+        command(
+          Object.freeze({
+            requestBids,
+            setTargetingForGpt,
+          })
+        )
+      ),
+      dispose: prebidOperationDispose,
+    })
+  );
+  let policy: PrebidRefreshPolicy | undefined;
+  const policyRelease = vi.fn();
+  const installRefreshPolicy = vi.fn((candidate: PrebidRefreshPolicy) => {
+    policy = candidate;
+    return acceptPolicy ? policyRelease : undefined;
+  });
+  const directAuctionUnitForSlot = vi.fn((slot: object) =>
+    slot === physicalSlot ? directAuctionUnit : undefined
+  );
+  const activationDisposers: Array<() => void> = [];
+  const registration = createPrebidLaterIntegrationRegistration(RELEASE_ID);
+  const prepared = registration.prepare(
+    Object.freeze({
+      config: CONFIG,
+      interfaces: Object.freeze({
+        'runtime.v1': Object.freeze({}),
+        'slots.v1': Object.freeze({}),
+        'gpt.v1': Object.freeze({
+          adapter: Object.freeze({ run: googletagRun }),
+          directAuctionUnitForSlot,
+          installRefreshPolicy,
+          navigation: () => navigation,
+        }),
+        'prebid.v1': Object.freeze({
+          adapter: Object.freeze({ run: prebidRun }),
+          clientSideBidders: CONFIG.clientSideBidders,
+          excludedGamAdUnitPathSuffixes: CONFIG.excludedGamAdUnitPathSuffixes,
+        }),
+      }),
+      onDispose: () => undefined,
+      signal: new AbortController().signal,
+    } satisfies IntegrationPrepareContext)
+  ) as PreparedIntegration;
+  const activation = Object.freeze({
+    afterCommit: vi.fn(),
+    onDispose: (callback: () => void) => activationDisposers.push(callback),
+    signal: new AbortController().signal,
+  } satisfies IntegrationActivationContext);
+
+  return {
+    activation,
+    activationDisposers,
+    clearTargeting,
+    directAuctionUnitForSlot,
+    googletagRun,
+    installRefreshPolicy,
+    physicalSlot,
+    policy: () => policy,
+    policyRelease,
+    prebidRun,
+    registration,
+    requestBids,
+    runtime,
+    setTargetingForGpt,
+    prepared,
+  };
+}
+
+describe('RCJ-PREBID-04 deferred refresh ownership', () => {
+  it('has no initial-admission effect and runs one detached refresh after activation', async () => {
+    const owner = harness();
+
+    expect(owner.registration).toMatchObject({ id: 'prebid_later', phase: 'deferred' });
+    expect(owner.installRefreshPolicy).not.toHaveBeenCalled();
+    expect(owner.googletagRun).not.toHaveBeenCalled();
+    expect(owner.prebidRun).not.toHaveBeenCalled();
+    expect(owner.directAuctionUnitForSlot).not.toHaveBeenCalled();
+
+    owner.prepared.activate(owner.activation);
+    expect(owner.installRefreshPolicy).toHaveBeenCalledOnce();
+    expect(owner.prebidRun).not.toHaveBeenCalled();
+
+    const completion = owner
+      .policy()
+      ?.prepare(Object.freeze({ slots: Object.freeze([owner.physicalSlot]) }));
+    expect(completion).toBeDefined();
+    await Promise.resolve(completion);
+
+    expect(owner.googletagRun).toHaveBeenCalledOnce();
+    expect(owner.directAuctionUnitForSlot).toHaveBeenCalledExactlyOnceWith(owner.physicalSlot);
+    expect(owner.prebidRun).toHaveBeenCalledOnce();
+    expect(owner.requestBids).toHaveBeenCalledOnce();
+    expect(owner.setTargetingForGpt).toHaveBeenCalledExactlyOnceWith(['slot-one']);
+    expect(owner.requestBids.mock.calls[0]?.[0]).toMatchObject({
+      adUnits: [
+        {
+          code: 'slot-one',
+          bids: [
+            {
+              bidder: 'trustedServer',
+              params: { bidderParams: { server: { placement: 'server-owned' } } },
+            },
+            { bidder: 'client', params: { placement: 'publisher-client' } },
+          ],
+        },
+      ],
+    });
+
+    owner.activationDisposers.reverse().forEach((dispose) => dispose());
+    expect(owner.policyRelease).toHaveBeenCalledOnce();
+    owner.runtime.dispose();
+  });
+
+  it('fails closed when GPT already has a refresh owner without starting another auction', () => {
+    const owner = harness(false);
+
+    expect(() => owner.prepared.activate(owner.activation)).toThrow(
+      'Prebid refresh policy is duplicated'
+    );
+    expect(owner.installRefreshPolicy).toHaveBeenCalledOnce();
+    expect(owner.googletagRun).not.toHaveBeenCalled();
+    expect(owner.prebidRun).not.toHaveBeenCalled();
+
+    owner.activationDisposers.reverse().forEach((dispose) => dispose());
+    expect(owner.policyRelease).not.toHaveBeenCalled();
+    owner.runtime.dispose();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/prebid/module.test.ts b/crates/trusted-server-js/lib/test/integrations/prebid/module.test.ts
new file mode 100644
index 000000000..920e4061f
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/prebid/module.test.ts
@@ -0,0 +1,1972 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { GoogletagAdapter } from '../../../src/adapters/googletag';
+import {
+  PrebidAdmissionContractError,
+  type PrebidAdapter,
+  type PrebidFacade,
+} from '../../../src/adapters/prebid';
+import {
+  createPrebidIntegrationRegistration,
+  type PreparedTrustedBidV1,
+} from '../../../src/integrations/prebid/module';
+import {
+  createPrebidSelectionCoordinator,
+  publishPrebidBid,
+  type PrebidBidPublicationInput,
+} from '../../../src/integrations/render_runtime/prebid_selection';
+import {
+  createPrebidRefreshPolicy,
+  createPrebidSyntheticRefreshRunner,
+  preparePrebidRegisteredRefreshAuction,
+} from '../../../src/integrations/prebid/refresh';
+import { createTestNavigationIdentityIssuer } from '../../../src/kernel/identity';
+import {
+  createIntegrationRegistry,
+  type IntegrationActivationContext,
+  type IntegrationInstallCallbacks,
+  type IntegrationRegistration,
+} from '../../../src/kernel/integration_registry';
+import { createRuntimeSession, type RenderAttemptScope } from '../../../src/kernel/sessions';
+import {
+  createCommittedArtifactStore,
+  createRenderAttempt,
+  type RenderAttempt,
+} from '../../../src/services/render';
+import { createReservationService } from '../../../src/services/reservations';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+function manifest(ids: readonly string[]) {
+  return {
+    version: 1,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) => ({ id, phase: 'takeover' as const })),
+  };
+}
+
+function registration(
+  id: string,
+  prepare: IntegrationRegistration['prepare']
+): IntegrationRegistration {
+  return Object.freeze({
+    abi: 1,
+    id,
+    phase: 'takeover',
+    releaseId: RELEASE_ID,
+    prepareSync: () => Object.freeze({ activate: () => undefined }),
+    prepare,
+  });
+}
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+function recursivelyFrozen(candidate: unknown, seen = new Set<object>()): boolean {
+  if (candidate === null || (typeof candidate !== 'object' && typeof candidate !== 'function')) {
+    return typeof candidate !== 'number' || Number.isFinite(candidate);
+  }
+  if (typeof candidate === 'function' || seen.has(candidate) || !Object.isFrozen(candidate)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(candidate);
+  if (
+    prototype !== Object.prototype &&
+    prototype !== null &&
+    !(Array.isArray(candidate) && prototype === Array.prototype)
+  ) {
+    return false;
+  }
+  seen.add(candidate);
+  return Reflect.ownKeys(candidate).every((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+    return (
+      descriptor !== undefined && 'value' in descriptor && recursivelyFrozen(descriptor.value, seen)
+    );
+  });
+}
+
+function createLegacyPrebidRegistrationForTest(_releaseId: string): IntegrationRegistration {
+  return registration('prebid', ({ config, interfaces }) => {
+    if (!recursivelyFrozen(config)) throw new TypeError('Prebid test config is invalid');
+    const runtime = interfaces['prebid'] as
+      Readonly<{ activate?: () => unknown; start?: (config: unknown) => void }> | undefined;
+    if (
+      !runtime ||
+      !Object.isFrozen(runtime) ||
+      typeof runtime.activate !== 'function' ||
+      typeof runtime.start !== 'function'
+    ) {
+      throw new TypeError('Prebid test runtime is unavailable');
+    }
+    const activate = runtime.activate;
+    const start = runtime.start;
+    return Object.freeze({
+      activate: ({ afterCommit, onDispose }: IntegrationActivationContext) => {
+        const release = activate();
+        if (typeof release !== 'function') {
+          throw new TypeError('Prebid test runtime disposer is unavailable');
+        }
+        onDispose(release as () => void);
+        afterCommit(() => start(config));
+      },
+    });
+  });
+}
+
+type TrustedServerBidder = Readonly<{
+  callBids: (
+    request: Readonly<object>,
+    addBidResponse: (adUnitCode: string, bid: Readonly<Record<string, unknown>>) => void,
+    done: () => void
+  ) => void;
+}>;
+
+function recursivelyFreeze<T>(value: T): T {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) recursivelyFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+function productionPrebidBinding(userIdModules: readonly object[]) {
+  const listeners = new Map<string, Set<(event: unknown) => void>>();
+  const responses = new Map<string, readonly Readonly<Record<string, unknown>>[]>();
+  let bidder: TrustedServerBidder | undefined;
+  let highest: readonly object[] = Object.freeze([]);
+  const responseFor = (adUnitCode: string) => {
+    const response = [...(responses.get(adUnitCode) ?? [])] as object[] & { bids: object[] };
+    response.bids = response;
+    return response;
+  };
+  const pbjs = {
+    addAdUnits: vi.fn(),
+    getBidResponsesForAdUnitCode: vi.fn((adUnitCode: string) => responseFor(adUnitCode)),
+    getHighestCpmBids: vi.fn(() => [...highest]),
+    offEvent: vi.fn((type: string, listener: (event: unknown) => void) => {
+      listeners.get(type)?.delete(listener);
+    }),
+    onEvent: vi.fn((type: string, listener: (event: unknown) => void) => {
+      const current = listeners.get(type) ?? new Set();
+      current.add(listener);
+      listeners.set(type, current);
+    }),
+    processQueue: vi.fn(),
+    registerBidAdapter: vi.fn((factory: () => TrustedServerBidder) => {
+      bidder = factory();
+    }),
+    renderAd: vi.fn(),
+    requestBids: vi.fn(),
+    setTargetingForGPTAsync: vi.fn(),
+    que: Object.freeze({
+      push: (command: () => void) => {
+        command();
+        return 1;
+      },
+    }),
+  };
+  const stamp = recursivelyFreeze({
+    abi: 1,
+    artifactReleaseId: 'b'.repeat(64),
+    prebidVersion: '10.26.0',
+    moduleStems: ['alphaBidAdapter', 'sharedIdSystem'],
+    bidderCodes: ['alpha'],
+    bidderAliases: [],
+    userIdModules: [...userIdModules],
+  });
+  Object.defineProperty(pbjs, '__trustedServerArtifactV1', {
+    configurable: false,
+    enumerable: false,
+    value: stamp,
+    writable: false,
+  });
+  return Object.freeze({
+    addResponse: (adUnitCode: string, bid: Readonly<Record<string, unknown>>): void => {
+      responses.set(adUnitCode, Object.freeze([bid]));
+      for (const listener of listeners.get('bidResponse') ?? []) listener(bid);
+    },
+    bidder: () => bidder,
+    emit: (type: string, event: unknown): void => {
+      for (const listener of listeners.get(type) ?? []) listener(event);
+    },
+    pbjs,
+    select: (bids: readonly object[]): void => {
+      highest = Object.freeze([...bids]);
+    },
+  });
+}
+
+function projectedPrebidConfig() {
+  return Object.freeze({
+    accountId: 'publisher',
+    timeout: 1_000,
+    debug: false,
+    bidders: Object.freeze(['alpha']),
+    clientSideBidders: Object.freeze(['alpha']),
+    excludedGamAdUnitPathSuffixes: Object.freeze(['/excluded']),
+  });
+}
+
+function initialProductionPrebidHarness(userIdModules: readonly object[]) {
+  const binding = productionPrebidBinding(userIdModules);
+  (window as unknown as { pbjs?: unknown }).pbjs = binding.pbjs;
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(9);
+          return target;
+        },
+      }),
+  });
+  const navigationResult = runtime.startInitialNavigation();
+  if (!navigationResult.ok) throw new Error('Expected initial navigation');
+  const navigation = navigationResult.value;
+  const renderSource = Object.freeze({
+    type: 'adm' as const,
+    version: 1 as const,
+    adm: '<main>production-prebid</main>',
+    width: 300,
+    height: 250,
+  });
+  const bid = Object.freeze({
+    candidateId: 'AAAAAAAAAAAA',
+    slot: 'slot-one',
+    provider: 'aps',
+    upstreamBidId: 'upstream-one',
+    cpm: 1.25,
+    currency: 'USD' as const,
+    targeting: Object.freeze({ hb_bidder: 'trustedServer' }),
+    rendererReservationId: `r1_${'p'.repeat(22)}`,
+    renderSource,
+  });
+  const projection = Object.freeze({
+    version: 1,
+    auction: Object.freeze({
+      version: 1,
+      auctionId: 'auction-one',
+      results: Object.freeze([
+        Object.freeze({
+          slot: bid.slot,
+          outcome: 'winner' as const,
+          candidateId: bid.candidateId,
+        }),
+      ]),
+    }),
+    bids: Object.freeze([bid]),
+  });
+  if (!navigation.installAuctionProjection(projection)) throw new Error('Expected projection');
+  const reservations = createReservationService({
+    prepareRenderSource: (candidate) =>
+      typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+        ? (candidate as typeof renderSource)
+        : undefined,
+  });
+  const artifacts = createCommittedArtifactStore();
+  const registerPucGamAttempt = vi.fn((_input: unknown) => true);
+  const createAttempt = (owner: RenderAttemptScope) =>
+    createRenderAttempt({
+      artifacts,
+      owner,
+      prepareRenderSource: (candidate) =>
+        typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+          ? (candidate as typeof renderSource)
+          : undefined,
+      reservations,
+    });
+  const renderCapability = Object.freeze({
+    createPrebidSelectionCoordinator: () =>
+      createPrebidSelectionCoordinator({
+        activateAttempt: ({ attempt, owner, preparedBid }) =>
+          registerPucGamAttempt(
+            Object.freeze({
+              artifact: Object.freeze({
+                kind: 'puc' as const,
+                attemptId: attempt.id,
+                slot: attempt.slot,
+                navigationGeneration: attempt.navigationGeneration,
+                dispose: () => undefined,
+              }),
+              attempt,
+              owner,
+              reservationId: preparedBid.bid.adId,
+            })
+          ),
+        createAttempt,
+        reservations,
+      }),
+    navigation,
+    projection,
+    publishPrebidBid: (input: Omit<PrebidBidPublicationInput, 'navigation' | 'reservations'>) =>
+      publishPrebidBid({ ...input, navigation, reservations }),
+  });
+  const preparationDisposers: Array<() => void> = [];
+  const activationDisposers: Array<() => void> = [];
+  const afterCommit: Array<() => void> = [];
+  const controller = new AbortController();
+  return Object.freeze({
+    activationContext: Object.freeze({
+      afterCommit: (callback: () => void) => afterCommit.push(callback),
+      onDispose: (callback: () => void) => activationDisposers.push(callback),
+      signal: controller.signal,
+    }),
+    afterCommit,
+    bid,
+    binding,
+    config: projectedPrebidConfig(),
+    dispose: () => {
+      for (let index = activationDisposers.length - 1; index >= 0; index -= 1) {
+        activationDisposers[index]?.();
+      }
+      for (let index = preparationDisposers.length - 1; index >= 0; index -= 1) {
+        preparationDisposers[index]?.();
+      }
+      reservations.dispose();
+      artifacts.dispose();
+      runtime.dispose();
+      delete (window as unknown as { pbjs?: unknown }).pbjs;
+    },
+    interfaces: Object.freeze({
+      'runtime.v1': Object.freeze({ document }),
+      'slots.v1': Object.freeze({}),
+      'render.v1': renderCapability,
+      'messages.v1': Object.freeze({}),
+      'aps.v1': Object.freeze({}),
+    }),
+    navigation,
+    prepareContext: Object.freeze({
+      config: projectedPrebidConfig(),
+      interfaces: Object.freeze({
+        'runtime.v1': Object.freeze({ document }),
+        'slots.v1': Object.freeze({}),
+        'render.v1': renderCapability,
+        'messages.v1': Object.freeze({}),
+        'aps.v1': Object.freeze({}),
+      }),
+      onDispose: (callback: () => void) => preparationDisposers.push(callback),
+      signal: controller.signal,
+    }),
+    registerPucGamAttempt,
+    reservations,
+  });
+}
+
+describe('production Prebid takeover registration', () => {
+  afterEach(() => {
+    delete (window as unknown as { pbjs?: unknown }).pbjs;
+  });
+
+  it('accepts only the exact server-projected Prebid browser configuration', async () => {
+    const harness = initialProductionPrebidHarness([]);
+    try {
+      const prepared = await createPrebidIntegrationRegistration(RELEASE_ID).prepare(
+        harness.prepareContext
+      );
+      const capability = prepared.interfaces?.['prebid.v1'] as
+        Readonly<{ adapter?: PrebidAdapter }> | undefined;
+      expect(capability?.adapter?.bindingStatus()).toBe('present');
+    } finally {
+      harness.dispose();
+    }
+  });
+
+  it('rejects legacy or publisher-only Prebid config fields during preparation', async () => {
+    const harness = initialProductionPrebidHarness([]);
+    try {
+      const config = Object.freeze({
+        ...projectedPrebidConfig(),
+        requiredUserIdModules: Object.freeze([]),
+      });
+      expect(() =>
+        createPrebidIntegrationRegistration(RELEASE_ID).prepare(
+          Object.freeze({ ...harness.prepareContext, config })
+        )
+      ).toThrow('Prebid integration config is invalid');
+    } finally {
+      harness.dispose();
+    }
+  });
+
+  it('adopts the sealed initial Prebid slice without replaying an initial bid publication', async () => {
+    const harness = initialProductionPrebidHarness([
+      Object.freeze({
+        moduleName: 'sharedIdSystem',
+        configNames: Object.freeze(['sharedId']),
+        eidSources: Object.freeze(['sharedid.org']),
+      }),
+    ]);
+    try {
+      const prepared = await createPrebidIntegrationRegistration(RELEASE_ID).prepare(
+        harness.prepareContext
+      );
+      const adoption = Object.freeze({
+        version: 1 as const,
+        adoptInitialDisplay: true as const,
+        handoff: Object.freeze({
+          slices: Object.freeze(['first_display', 'prebid_initial']),
+          parserState: Object.freeze([
+            Object.freeze({
+              sliceId: 'prebid_initial',
+              observations: Object.freeze(['protocol_version']),
+              values: Object.freeze([Object.freeze(['protocol_version', 1] as const)]),
+            }),
+          ]),
+        }),
+        identities: Object.freeze([]),
+      });
+
+      prepared.activate(Object.freeze({ ...harness.activationContext, adoption }));
+      for (const callback of harness.afterCommit) callback();
+
+      expect(harness.binding.bidder()).toEqual(expect.any(Object));
+      expect(harness.registerPucGamAttempt).not.toHaveBeenCalled();
+    } finally {
+      harness.dispose();
+    }
+  });
+
+  it('rejects a takeover that omits the selected initial Prebid state', async () => {
+    const harness = initialProductionPrebidHarness([]);
+    try {
+      const prepared = await createPrebidIntegrationRegistration(RELEASE_ID).prepare(
+        harness.prepareContext
+      );
+      const adoption = Object.freeze({
+        version: 1 as const,
+        adoptInitialDisplay: true as const,
+        handoff: Object.freeze({
+          slices: Object.freeze(['first_display', 'prebid_initial']),
+          parserState: Object.freeze([]),
+        }),
+        identities: Object.freeze([]),
+      });
+
+      expect(() =>
+        prepared.activate(Object.freeze({ ...harness.activationContext, adoption }))
+      ).toThrow('Prebid first-display adoption is invalid');
+    } finally {
+      harness.dispose();
+    }
+  });
+
+  it('publishes the initial TS winner and promotes its exact selection through render.v1', async () => {
+    const harness = initialProductionPrebidHarness([
+      Object.freeze({
+        moduleName: 'sharedIdSystem',
+        configNames: Object.freeze(['sharedId']),
+        eidSources: Object.freeze(['sharedid.org']),
+      }),
+    ]);
+    try {
+      const prepared = await createPrebidIntegrationRegistration(RELEASE_ID).prepare(
+        harness.prepareContext
+      );
+      prepared.activate(harness.activationContext);
+      for (const callback of harness.afterCommit) callback();
+      const bidder = harness.binding.bidder();
+      if (!bidder) throw new Error('Expected trustedServer bidder registration');
+      const done = vi.fn();
+      let admitted: Readonly<Record<string, unknown>> | undefined;
+      bidder.callBids(
+        Object.freeze({
+          auctionId: 'auction-one',
+          bids: Object.freeze([
+            Object.freeze({
+              adUnitCode: 'slot-one',
+              adUnitId: 'unit-one',
+              auctionId: 'auction-one',
+              bidId: 'request-one',
+              src: 'client',
+              transactionId: 'transaction-one',
+            }),
+          ]),
+        }),
+        (adUnitCode, response) => {
+          const enriched = Object.freeze({ ...response, adUnitCode });
+          admitted = enriched;
+          harness.binding.addResponse(adUnitCode, enriched);
+        },
+        done
+      );
+      expect(done).toHaveBeenCalledOnce();
+      expect(admitted).toMatchObject({
+        adId: harness.bid.rendererReservationId,
+        bidderCode: 'trustedServer',
+        requestId: 'request-one',
+      });
+      const selected = admitted;
+      if (!selected) throw new Error('Expected admitted TS bid');
+      harness.binding.select([
+        Object.freeze({
+          ...selected,
+          adUnitCode: 'slot-one',
+          auctionId: 'auction-one',
+        }),
+      ]);
+      expect(harness.reservations.recognize(harness.bid.rendererReservationId)).toMatchObject({
+        state: 'awaiting_prebid_selection',
+      });
+      harness.binding.emit('auctionEnd', Object.freeze({ auctionId: 'auction-one' }));
+      expect(harness.binding.pbjs.getHighestCpmBids).toHaveBeenCalledOnce();
+      expect(harness.registerPucGamAttempt).toHaveBeenCalledOnce();
+      expect(harness.reservations.recognize(harness.bid.rendererReservationId)).toMatchObject({
+        state: 'renderable',
+      });
+    } finally {
+      harness.dispose();
+    }
+  });
+});
+
+describe('transactional test-composition Prebid boundary', () => {
+  it('prepares inertly, activates reversible listeners, and starts only after commit', async () => {
+    const config = Object.freeze({ clientSideBidders: Object.freeze(['rubicon']) });
+    const order: string[] = [];
+    const start = vi.fn((received: unknown) => {
+      order.push('start');
+      expect(received).toBe(config);
+    });
+    const release = vi.fn(() => order.push('release'));
+    const activate = vi.fn(() => {
+      order.push('prebid:activate');
+      return release;
+    });
+    let finishPreparation: (() => void) | undefined;
+    const preparationGate = new Promise<void>((resolve) => {
+      finishPreparation = resolve;
+    });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid', 'gate']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid', 'gate']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({ prebid: Object.freeze({ activate, start }) }),
+      }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+    registry.register(
+      registration('gate', async () => {
+        order.push('gate:prepare');
+        await preparationGate;
+        return Object.freeze({ activate: () => order.push('gate:activate') });
+      })
+    );
+
+    const installing = registry.install(callbacks(order));
+    await vi.waitFor(() => expect(order).toEqual(['gate:prepare']));
+    expect(start).not.toHaveBeenCalled();
+
+    finishPreparation?.();
+    const result = await installing;
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'gate:prepare',
+      'core',
+      'prebid:activate',
+      'gate:activate',
+      'publish',
+      'start',
+      'drain',
+    ]);
+    expect(activate).toHaveBeenCalledTimes(1);
+    expect(start).toHaveBeenCalledExactlyOnceWith(config);
+    if (result.state === 'kernel') {
+      result.dispose();
+      result.dispose();
+    }
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  it('unwinds Prebid activation before fallback when a later module fails', async () => {
+    const release = vi.fn();
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid', 'broken']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid', 'broken']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({
+          prebid: Object.freeze({ activate: () => release, start }),
+        }),
+      }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+    registry.register(
+      registration('broken', () => ({
+        activate: () => {
+          throw new Error('fictional activation failure');
+        },
+      }))
+    );
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(release).toHaveBeenCalledTimes(1);
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('does not start when reversible Prebid activation fails', async () => {
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({
+          prebid: Object.freeze({
+            activate: () => {
+              throw new Error('fictional listener activation failure');
+            },
+            start,
+          }),
+        }),
+      }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('fails preparation without effects when the composition omits the Prebid boundary', async () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({ config: Object.freeze({}), interfaces: Object.freeze({}) }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+  });
+
+  it.each([
+    [
+      'accessor',
+      Object.freeze(
+        Object.defineProperty({}, 'externalBundleUrl', {
+          enumerable: true,
+          get: () => '/publisher-controlled',
+        })
+      ),
+    ],
+    ['mutable nested data', Object.freeze({ nested: {} })],
+    ['non-plain data', Object.freeze({ value: Object.freeze(new Date(0)) })],
+  ])('rejects %s configuration during inert preparation', async (_caseName, config) => {
+    const start = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid']),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({
+          prebid: Object.freeze({ activate: () => vi.fn(), start }),
+        }),
+      }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(start).not.toHaveBeenCalled();
+  });
+
+  it('isolates post-commit startup failure to the Prebid module', async () => {
+    const start = vi.fn(() => {
+      throw new Error('fictional Prebid startup failure');
+    });
+    const runtimeFailures: unknown[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['prebid']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['prebid']),
+      startedAtMs: 0,
+      now: () => 0,
+      onRuntimeFailure: (failure) => runtimeFailures.push(failure),
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({
+          prebid: Object.freeze({ activate: () => vi.fn(), start }),
+        }),
+      }),
+    });
+    registry.register(createLegacyPrebidRegistrationForTest(RELEASE_ID));
+
+    await expect(registry.install(callbacks([]))).resolves.toMatchObject({
+      state: 'kernel',
+      runtimeFailures: [{ id: 'prebid', phase: 'after_commit' }],
+    });
+    expect(start).toHaveBeenCalledTimes(1);
+    expect(runtimeFailures).toEqual([{ id: 'prebid', phase: 'after_commit' }]);
+  });
+});
+
+describe('RCJ-PREBID-04 refresh policy', () => {
+  function refreshHarness(
+    excludedGamAdUnitPathSuffixes: readonly string[] | (() => readonly string[])
+  ) {
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(3);
+            return target;
+          },
+        }),
+    });
+    const navigationResult = runtime.startInitialNavigation();
+    if (!navigationResult.ok) throw new Error('Expected navigation');
+    const navigation = navigationResult.value;
+    const clearCalls: Array<readonly [object, string]> = [];
+    const operationDisposals: Array<ReturnType<typeof vi.fn>> = [];
+    const googletag = {
+      run: vi.fn((command: (gpt: object) => unknown) => {
+        const dispose = vi.fn();
+        operationDisposals.push(dispose);
+        const facade = Object.freeze({
+          adUnitPath: (slot: object) => {
+            const getter = Reflect.get(slot, 'getAdUnitPath');
+            if (typeof getter !== 'function') return undefined;
+            return Reflect.apply(getter, slot, []);
+          },
+          clearTargeting: (slot: object, key: string) => {
+            clearCalls.push([slot, key]);
+            const clear = Reflect.get(slot, 'clearTargeting');
+            if (typeof clear === 'function') return Reflect.apply(clear, slot, [key]);
+            return undefined;
+          },
+        });
+        return Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(command(facade)),
+          dispose,
+        });
+      }),
+    };
+    const auctionDisposals: Array<ReturnType<typeof vi.fn>> = [];
+    const runSyntheticAuction = vi.fn((_slots: readonly object[]) => {
+      const dispose = vi.fn();
+      auctionDisposals.push(dispose);
+      return Object.freeze({ completion: Promise.resolve(), dispose });
+    });
+    const policy = createPrebidRefreshPolicy({
+      currentNavigation: () => navigation,
+      excludedGamAdUnitPathSuffixes,
+      googletag: googletag as unknown as Pick<GoogletagAdapter, 'run'>,
+      runSyntheticAuction,
+    });
+    return {
+      auctionDisposals,
+      clearCalls,
+      navigation,
+      operationDisposals,
+      policy,
+      runSyntheticAuction,
+      runtime,
+    };
+  }
+
+  it('clears every target then filters only literal case-sensitive suffix matches', async () => {
+    const harness = refreshHarness(['/tracking']);
+    const excluded = {
+      clearTargeting: vi.fn(),
+      getAdUnitPath: vi.fn(() => '/network/tracking'),
+    };
+    const caseMismatch = {
+      clearTargeting: vi.fn(),
+      getAdUnitPath: vi.fn(() => '/network/Tracking'),
+    };
+    const trailingSlash = {
+      clearTargeting: vi.fn(),
+      getAdUnitPath: vi.fn(() => '/network/tracking/'),
+    };
+    const missing = { clearTargeting: vi.fn() };
+    const nonString = {
+      clearTargeting: vi.fn(),
+      getAdUnitPath: vi.fn(() => 42),
+    };
+    const throwing = {
+      clearTargeting: vi.fn(),
+      getAdUnitPath: vi.fn(() => {
+        throw new Error('path unavailable');
+      }),
+    };
+    const clearFailure = {
+      clearTargeting: vi.fn((key: string) => {
+        if (key === 'hb_adid') throw new Error('clear unavailable');
+      }),
+      getAdUnitPath: vi.fn(() => '/network/tracking'),
+    };
+    const slots = Object.freeze([
+      excluded,
+      caseMismatch,
+      trailingSlash,
+      missing,
+      nonString,
+      throwing,
+      clearFailure,
+    ]);
+
+    await harness.policy.prepare(
+      Object.freeze({ requestedSlots: slots, slots, options: Object.freeze({ exact: true }) })
+    );
+
+    const expectedKeys = [
+      'ts_initial',
+      'hb_pb',
+      'hb_bidder',
+      'hb_adid',
+      'hb_cache_host',
+      'hb_cache_path',
+    ];
+    for (const slot of slots) {
+      expect(
+        harness.clearCalls.filter(([target]) => target === slot).map(([, key]) => key)
+      ).toEqual(expectedKeys);
+    }
+    expect(harness.runSyntheticAuction).toHaveBeenCalledExactlyOnceWith(
+      [caseMismatch, trailingSlash, missing, nonString, throwing, clearFailure],
+      harness.navigation
+    );
+    harness.policy.dispose();
+    harness.runtime.dispose();
+  });
+
+  it('skips the synthetic auction when all targets are excluded', async () => {
+    const harness = refreshHarness(['/skip']);
+    const slots = Object.freeze([
+      { getAdUnitPath: () => '/one/skip' },
+      { getAdUnitPath: () => '/two/skip' },
+    ]);
+
+    await harness.policy.prepare(
+      Object.freeze({ requestedSlots: undefined, slots, options: undefined })
+    );
+
+    expect(harness.runSyntheticAuction).not.toHaveBeenCalled();
+    expect(harness.clearCalls).toHaveLength(slots.length * 6);
+    harness.policy.dispose();
+    harness.runtime.dispose();
+  });
+
+  it('reads the configured exclusion snapshot only when the activated policy prepares', async () => {
+    let configuredSuffixes: readonly string[] = Object.freeze([]);
+    const harness = refreshHarness(() => configuredSuffixes);
+    configuredSuffixes = Object.freeze(['/configured-after-activation']);
+    const slot = Object.freeze({ getAdUnitPath: () => '/network/configured-after-activation' });
+
+    await harness.policy.prepare(
+      Object.freeze({ requestedSlots: Object.freeze([slot]), slots: Object.freeze([slot]) })
+    );
+
+    expect(harness.runSyntheticAuction).not.toHaveBeenCalled();
+    expect(harness.clearCalls).toHaveLength(6);
+    harness.policy.dispose();
+    harness.runtime.dispose();
+  });
+
+  it('settles pending work on navigation abort and ignores a late auction completion', async () => {
+    const harness = refreshHarness([]);
+    let finishAuction!: () => void;
+    const auction = new Promise<void>((resolve) => {
+      finishAuction = resolve;
+    });
+    const auctionDispose = vi.fn();
+    harness.runSyntheticAuction.mockReturnValue(
+      Object.freeze({ completion: auction, dispose: auctionDispose })
+    );
+    const slot = Object.freeze({ getAdUnitPath: () => '/eligible' });
+    const completion = harness.policy.prepare(
+      Object.freeze({
+        requestedSlots: Object.freeze([slot]),
+        slots: Object.freeze([slot]),
+        options: undefined,
+      })
+    );
+    await vi.waitFor(() => expect(harness.runSyntheticAuction).toHaveBeenCalledOnce());
+
+    harness.runtime.replaceNavigation();
+    await expect(completion).resolves.toBeUndefined();
+    expect(harness.operationDisposals[0]).toHaveBeenCalledOnce();
+    expect(auctionDispose).toHaveBeenCalledOnce();
+    finishAuction();
+    await auction;
+    await Promise.resolve();
+    expect(harness.runSyntheticAuction).toHaveBeenCalledOnce();
+    harness.policy.dispose();
+  });
+
+  it('settles pending work when the refresh policy is disposed', async () => {
+    const harness = refreshHarness([]);
+    let finishAuction!: () => void;
+    const auction = new Promise<void>((resolve) => {
+      finishAuction = resolve;
+    });
+    const auctionDispose = vi.fn();
+    harness.runSyntheticAuction.mockReturnValue(
+      Object.freeze({ completion: auction, dispose: auctionDispose })
+    );
+    const slot = Object.freeze({ getAdUnitPath: () => '/eligible' });
+    const completion = harness.policy.prepare(
+      Object.freeze({ requestedSlots: Object.freeze([slot]), slots: Object.freeze([slot]) })
+    );
+    await vi.waitFor(() => expect(harness.runSyntheticAuction).toHaveBeenCalledOnce());
+
+    harness.policy.dispose();
+    harness.policy.dispose();
+    await expect(completion).resolves.toBeUndefined();
+    expect(harness.operationDisposals[0]).toHaveBeenCalledOnce();
+    expect(auctionDispose).toHaveBeenCalledOnce();
+    finishAuction();
+    await auction;
+    harness.runtime.dispose();
+  });
+});
+
+describe('RCJ-PREBID-04 adapter-backed synthetic refresh runner', () => {
+  it('routes detached server and client bids without consulting publisher Prebid state', () => {
+    const slot = Object.freeze({ id: 'slot-a' });
+    const serverParams = Object.freeze({ placement: 'current' });
+    const unit = Object.freeze({
+      code: 'slot-a',
+      mediaTypes: Object.freeze({
+        banner: Object.freeze({ sizes: Object.freeze([Object.freeze([300, 250])]) }),
+      }),
+      bids: Object.freeze([
+        Object.freeze({
+          bidder: 'trustedServer',
+          params: Object.freeze({
+            bidderParams: Object.freeze({
+              client: Object.freeze({ stale: true }),
+              preserved: Object.freeze({ placement: 'folded' }),
+              server: Object.freeze({ placement: 'stale' }),
+            }),
+            zone: 'news',
+          }),
+        }),
+        Object.freeze({ bidder: 'server', params: serverParams }),
+        Object.freeze({ bidder: 'client', params: Object.freeze({ placement: 'browser' }) }),
+      ]),
+    });
+
+    const prepared = preparePrebidRegisteredRefreshAuction({
+      clientSideBidders: Object.freeze(['client']),
+      resolveAdUnit: (candidate) => (candidate === slot ? unit : undefined),
+      slots: Object.freeze([slot]),
+    });
+
+    expect(prepared).toEqual({
+      adUnitCodes: ['slot-a'],
+      adUnits: [
+        {
+          code: 'slot-a',
+          mediaTypes: { banner: { sizes: [[300, 250]] } },
+          bids: [
+            {
+              bidder: 'trustedServer',
+              params: {
+                bidderParams: {
+                  preserved: { placement: 'folded' },
+                  server: { placement: 'current' },
+                },
+                zone: 'news',
+              },
+            },
+            { bidder: 'client', params: { placement: 'browser' } },
+          ],
+        },
+      ],
+    });
+    expect(Object.isFrozen(prepared?.adUnits)).toBe(true);
+    expect(Object.isFrozen(prepared?.adUnits[0])).toBe(true);
+  });
+
+  it('preserves legacy last-write precedence when folded params follow direct bids', () => {
+    const slot = Object.freeze({ id: 'slot-order' });
+    const unit = Object.freeze({
+      code: 'slot-order',
+      mediaTypes: Object.freeze({ banner: Object.freeze({ sizes: Object.freeze([]) }) }),
+      bids: Object.freeze([
+        Object.freeze({
+          bidder: 'server',
+          params: Object.freeze({ placement: 'direct-first' }),
+        }),
+        Object.freeze({
+          bidder: 'trustedServer',
+          params: Object.freeze({
+            bidderParams: Object.freeze({
+              preserved: Object.freeze({ placement: 'folded-only' }),
+              server: Object.freeze({ placement: 'folded-last' }),
+            }),
+          }),
+        }),
+      ]),
+    });
+
+    const prepared = preparePrebidRegisteredRefreshAuction({
+      clientSideBidders: Object.freeze([]),
+      resolveAdUnit: () => unit,
+      slots: Object.freeze([slot]),
+    });
+
+    expect(prepared?.adUnits).toEqual([
+      {
+        code: 'slot-order',
+        mediaTypes: { banner: { sizes: [] } },
+        bids: [
+          {
+            bidder: 'trustedServer',
+            params: {
+              bidderParams: {
+                server: { placement: 'folded-last' },
+                preserved: { placement: 'folded-only' },
+              },
+            },
+          },
+        ],
+      },
+    ]);
+    const bidderParams = (
+      prepared?.adUnits[0] as {
+        bids: readonly [{ params: { bidderParams: Readonly<Record<string, unknown>> } }];
+      }
+    ).bids[0].params.bidderParams;
+    expect(Object.keys(bidderParams)).toEqual(['server', 'preserved']);
+  });
+
+  it('fails closed when detached registrations contain duplicate trustedServer bids', () => {
+    const slot = Object.freeze({ id: 'slot-duplicate-trusted' });
+    const trustedBid = Object.freeze({
+      bidder: 'trustedServer',
+      params: Object.freeze({ bidderParams: Object.freeze({}) }),
+    });
+    const unit = Object.freeze({
+      code: 'slot-duplicate-trusted',
+      mediaTypes: Object.freeze({ banner: Object.freeze({ sizes: Object.freeze([]) }) }),
+      bids: Object.freeze([trustedBid, trustedBid]),
+    });
+
+    expect(
+      preparePrebidRegisteredRefreshAuction({
+        clientSideBidders: Object.freeze([]),
+        resolveAdUnit: () => unit,
+        slots: Object.freeze([slot]),
+      })
+    ).toBeUndefined();
+  });
+
+  it('keeps deterministic order while resolving duplicate direct and client bids', () => {
+    const slot = Object.freeze({ id: 'slot-duplicates' });
+    const unit = Object.freeze({
+      code: 'slot-duplicates',
+      mediaTypes: Object.freeze({ banner: Object.freeze({ sizes: Object.freeze([]) }) }),
+      bids: Object.freeze([
+        Object.freeze({ bidder: 'alpha', params: Object.freeze({ sequence: 1 }) }),
+        Object.freeze({ bidder: 'client', params: Object.freeze({ sequence: 1 }) }),
+        Object.freeze({ bidder: 'beta', params: Object.freeze({ sequence: 1 }) }),
+        Object.freeze({ bidder: 'alpha', params: Object.freeze({ sequence: 2 }) }),
+        Object.freeze({ bidder: 'client', params: Object.freeze({ sequence: 2 }) }),
+      ]),
+    });
+
+    const prepared = preparePrebidRegisteredRefreshAuction({
+      clientSideBidders: Object.freeze(['client']),
+      resolveAdUnit: () => unit,
+      slots: Object.freeze([slot]),
+    });
+
+    expect(prepared?.adUnits).toEqual([
+      {
+        code: 'slot-duplicates',
+        mediaTypes: { banner: { sizes: [] } },
+        bids: [
+          {
+            bidder: 'trustedServer',
+            params: { bidderParams: { alpha: { sequence: 2 }, beta: { sequence: 1 } } },
+          },
+          { bidder: 'client', params: { sequence: 1 } },
+          { bidder: 'client', params: { sequence: 2 } },
+        ],
+      },
+    ]);
+    const bidderParams = (
+      prepared?.adUnits[0] as {
+        bids: readonly [{ params: { bidderParams: Readonly<Record<string, unknown>> } }];
+      }
+    ).bids[0].params.bidderParams;
+    expect(Object.keys(bidderParams)).toEqual(['alpha', 'beta']);
+  });
+
+  it('returns a recursively frozen synthetic refresh preparation', () => {
+    const slot = Object.freeze({ id: 'slot-frozen' });
+    const unit = Object.freeze({
+      code: 'slot-frozen',
+      mediaTypes: Object.freeze({
+        banner: Object.freeze({ sizes: Object.freeze([Object.freeze([300, 250])]) }),
+      }),
+      bids: Object.freeze([
+        Object.freeze({
+          bidder: 'server',
+          params: Object.freeze({
+            placement: Object.freeze({
+              rules: Object.freeze([Object.freeze({ label: 'frozen' })]),
+            }),
+          }),
+        }),
+      ]),
+    });
+    const prepared = preparePrebidRegisteredRefreshAuction({
+      clientSideBidders: Object.freeze([]),
+      resolveAdUnit: () => unit,
+      slots: Object.freeze([slot]),
+    });
+    const seen = new Set<object>();
+    const expectRecursivelyFrozen = (value: unknown): void => {
+      if (value === null || typeof value !== 'object' || seen.has(value)) return;
+      seen.add(value);
+      expect(Object.isFrozen(value)).toBe(true);
+      for (const child of Object.values(value)) expectRecursivelyFrozen(child);
+    };
+
+    expect(prepared).toBeDefined();
+    expectRecursivelyFrozen(prepared);
+  });
+
+  it('fails closed when a physical slot has no detached registered ad unit', () => {
+    const slot = Object.freeze({ id: 'unregistered' });
+
+    expect(
+      preparePrebidRegisteredRefreshAuction({
+        clientSideBidders: Object.freeze([]),
+        resolveAdUnit: () => undefined,
+        slots: Object.freeze([slot]),
+      })
+    ).toBeUndefined();
+  });
+
+  function runnerHarness(options: Readonly<{ requestThrows?: boolean }> = {}) {
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(4);
+            return target;
+          },
+        }),
+    });
+    const navigationResult = runtime.startInitialNavigation();
+    if (!navigationResult.ok) throw new Error('Expected navigation');
+    const navigation = navigationResult.value;
+    const order: string[] = [];
+    let requestOptions:
+      | Readonly<{
+          adUnits: readonly object[];
+          bidsBackHandler: () => void;
+          timeout: number;
+        }>
+      | undefined;
+    const facade = Object.freeze({
+      requestBids: vi.fn((received: unknown) => {
+        order.push('request');
+        if (options.requestThrows) throw new Error('request unavailable');
+        requestOptions = received as typeof requestOptions;
+      }),
+      setTargetingForGpt: vi.fn((codes: readonly string[]) => {
+        order.push(`target:${codes.join(',')}`);
+      }),
+    }) as unknown as Readonly<PrebidFacade>;
+    const adapterDispose = vi.fn();
+    const prebid = Object.freeze({
+      run: vi.fn((command: (prebid: Readonly<PrebidFacade>) => unknown) =>
+        Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(command(facade)),
+          dispose: adapterDispose,
+        })
+      ),
+    }) as unknown as Pick<PrebidAdapter, 'run'>;
+    let deadline: (() => void) | undefined;
+    const timerHandle = Object.freeze({});
+    const clear = vi.fn();
+    const slot = Object.freeze({ id: 'slot-a' });
+    const adUnit = Object.freeze({ code: 'slot-a', bids: Object.freeze([]) });
+    const prepareAuction = vi.fn(() =>
+      Object.freeze({
+        adUnitCodes: Object.freeze(['slot-a']),
+        adUnits: Object.freeze([adUnit]),
+      })
+    );
+    const runner = createPrebidSyntheticRefreshRunner({
+      prebid,
+      prepareAuction,
+      scheduler: Object.freeze({
+        clear,
+        set: (callback: () => void, milliseconds: number) => {
+          expect(milliseconds).toBe(1_500);
+          deadline = callback;
+          return timerHandle;
+        },
+      }),
+    });
+    return {
+      adapterDispose,
+      clear,
+      deadline: () => deadline,
+      facade,
+      navigation,
+      order,
+      prepareAuction,
+      requestOptions: () => requestOptions,
+      runner,
+      runtime,
+      slot,
+      timerHandle,
+    };
+  }
+
+  it('requests eligible ad units then applies only their scoped targeting before completion', async () => {
+    const harness = runnerHarness();
+    const operation = harness.runner(Object.freeze([harness.slot]), harness.navigation);
+
+    expect(harness.order).toEqual(['request']);
+    expect(harness.prepareAuction).toHaveBeenCalledExactlyOnceWith(
+      [harness.slot],
+      harness.navigation
+    );
+    expect(harness.requestOptions()).toMatchObject({
+      adUnits: [{ code: 'slot-a', bids: [] }],
+      timeout: 1_500,
+    });
+    harness.requestOptions()?.bidsBackHandler();
+    await expect(operation.completion).resolves.toBeUndefined();
+
+    expect(harness.order).toEqual(['request', 'target:slot-a']);
+    expect(harness.clear).toHaveBeenCalledExactlyOnceWith(harness.timerHandle);
+    expect(harness.adapterDispose).toHaveBeenCalledOnce();
+    harness.runtime.dispose();
+  });
+
+  it('uses one targeting/settlement latch for timeout, disposal, and late callbacks', async () => {
+    const timedOut = runnerHarness();
+    const timedOutOperation = timedOut.runner(Object.freeze([timedOut.slot]), timedOut.navigation);
+    const lateTimeoutCallback = timedOut.requestOptions()?.bidsBackHandler;
+    timedOut.deadline()?.();
+    await expect(timedOutOperation.completion).resolves.toBeUndefined();
+    lateTimeoutCallback?.();
+    expect(timedOut.order).toEqual(['request', 'target:slot-a']);
+    expect(timedOut.adapterDispose).toHaveBeenCalledOnce();
+    timedOut.runtime.dispose();
+
+    const disposed = runnerHarness();
+    const disposedOperation = disposed.runner(Object.freeze([disposed.slot]), disposed.navigation);
+    const lateDisposedCallback = disposed.requestOptions()?.bidsBackHandler;
+    disposedOperation.dispose();
+    disposedOperation.dispose();
+    await expect(disposedOperation.completion).resolves.toBeUndefined();
+    lateDisposedCallback?.();
+    disposed.deadline()?.();
+    expect(disposed.order).toEqual(['request']);
+    expect(disposed.adapterDispose).toHaveBeenCalledOnce();
+    disposed.runtime.dispose();
+  });
+
+  it('forwards completion without targeting when requestBids throws', async () => {
+    const harness = runnerHarness({ requestThrows: true });
+    const operation = harness.runner(Object.freeze([harness.slot]), harness.navigation);
+
+    await expect(operation.completion).resolves.toBeUndefined();
+    expect(harness.order).toEqual(['request']);
+    expect(harness.facade.setTargetingForGpt).not.toHaveBeenCalled();
+    expect(harness.adapterDispose).toHaveBeenCalledOnce();
+    expect(harness.deadline()).toBeUndefined();
+    harness.runtime.dispose();
+  });
+});
+
+describe('ordered Prebid bid publication', () => {
+  function preparePublication() {
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(1);
+            return target;
+          },
+        }),
+    });
+    const navigationResult = runtime.startInitialNavigation();
+    if (!navigationResult.ok) throw new Error('Expected navigation');
+    const navigation = navigationResult.value;
+    const reservationId = `r1_${'a'.repeat(22)}`;
+    const renderSource = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '<main>private creative</main>',
+      width: 300,
+      height: 250,
+    });
+    const bid = Object.freeze({
+      candidateId: 'AAAAAAAAAAAA',
+      slot: 'slot-one',
+      provider: 'aps',
+      upstreamBidId: 'upstream-one',
+      cpm: 1.25,
+      currency: 'USD' as const,
+      targeting: Object.freeze({ hb_bidder: 'trustedServer' }),
+      rendererReservationId: reservationId,
+      renderSource,
+    });
+    const projection = Object.freeze({
+      version: 1,
+      auction: Object.freeze({
+        version: 1,
+        auctionId: 'auction-one',
+        results: Object.freeze([
+          Object.freeze({
+            slot: bid.slot,
+            outcome: 'winner' as const,
+            candidateId: bid.candidateId,
+          }),
+        ]),
+      }),
+      bids: Object.freeze([bid]),
+    });
+    expect(navigation.installAuctionProjection(projection)).toBe(true);
+    const reservations = createReservationService({
+      prepareRenderSource: (candidate) =>
+        typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+          ? (candidate as typeof renderSource)
+          : undefined,
+    });
+    const generatedBid = Object.freeze({
+      requestId: 'prebid-request-one',
+      adId: 'prebid-generated-id',
+      cpm: bid.cpm,
+      width: 300,
+      height: 250,
+    });
+    const order: string[] = [];
+    const admitTrustedBid = vi.fn((_preparedBid: Readonly<PreparedTrustedBidV1>) => {
+      order.push('admit');
+      expect(reservations.recognize(reservationId)).toMatchObject({
+        recognized: true,
+        state: 'awaiting_prebid_selection',
+      });
+      return 'admitted' as const;
+    });
+    const trackAdmittedBid = vi.fn(() => {
+      order.push('track');
+      return true;
+    });
+    const input: PrebidBidPublicationInput = {
+      admitTrustedBid,
+      auctionId: 'auction-one',
+      adUnitCode: bid.slot,
+      bid,
+      generatedBid,
+      navigation,
+      reservations: {
+        registerPrebidLease: (registrationInput) => {
+          order.push('reservation');
+          return reservations.registerPrebidLease(registrationInput);
+        },
+        tombstonePrebidLease: reservations.tombstonePrebidLease,
+      },
+      trackAdmittedBid,
+    };
+    return {
+      admitTrustedBid,
+      bid,
+      generatedBid,
+      input,
+      navigation,
+      order,
+      reservationId,
+      reservations,
+      runtime,
+      trackAdmittedBid,
+    };
+  }
+
+  it('registers the lease before exposing one capability-free frozen bid', () => {
+    const publication = preparePublication();
+
+    const result = publishPrebidBid(publication.input);
+
+    expect(result.ok).toBe(true);
+    expect(publication.order).toEqual(['reservation', 'admit', 'track']);
+    expect(publication.admitTrustedBid).toHaveBeenCalledTimes(1);
+    const prepared = publication.admitTrustedBid.mock.calls[0]?.[0];
+    if (!prepared) throw new Error('Expected prepared bid');
+    expect(prepared).toMatchObject({
+      auctionId: 'auction-one',
+      adUnitCode: 'slot-one',
+      bid: {
+        requestId: 'prebid-request-one',
+        adId: publication.reservationId,
+        cpm: 1.25,
+        width: 300,
+        height: 250,
+        ad: '',
+        ttl: 300,
+        creativeId: 'upstream-one',
+        netRevenue: true,
+        currency: 'USD',
+        bidderCode: 'trustedServer',
+        meta: {
+          advertiserDomains: [],
+          tsAuctionId: 'auction-one',
+          tsBidId: 'upstream-one',
+        },
+      },
+    });
+    expect(Object.isFrozen(prepared)).toBe(true);
+    expect(Object.isFrozen(prepared.bid)).toBe(true);
+    expect(Object.isFrozen(prepared.bid.meta)).toBe(true);
+    expect(JSON.stringify(prepared)).not.toContain('private creative');
+    expect(publication.generatedBid.adId).toBe('prebid-generated-id');
+    publication.runtime.dispose();
+  });
+
+  it('suppresses a partially published bid or failed selection tracking as a contract violation', () => {
+    const partial = preparePublication();
+    expect(
+      publishPrebidBid({
+        ...partial.input,
+        admitTrustedBid: () => {
+          throw new PrebidAdmissionContractError();
+        },
+      })
+    ).toEqual({ ok: false, reason: 'prebid_contract_violation' });
+    expect(partial.reservations.recognize(partial.reservationId)).toMatchObject({
+      state: 'prebid_contract_violation',
+    });
+    partial.runtime.dispose();
+
+    const untracked = preparePublication();
+    expect(publishPrebidBid({ ...untracked.input, trackAdmittedBid: () => false })).toEqual({
+      ok: false,
+      reason: 'prebid_contract_violation',
+    });
+    expect(untracked.reservations.recognize(untracked.reservationId)).toMatchObject({
+      state: 'prebid_contract_violation',
+    });
+    untracked.runtime.dispose();
+  });
+
+  it.each([
+    ['not admitted', () => 'not_admitted' as const, 'prebid_admission_failed'],
+    [
+      'throw',
+      () => {
+        throw new Error('fictional Prebid failure');
+      },
+      'prebid_admission_failed',
+    ],
+    ['partial publication', () => 'partially_admitted', 'prebid_contract_violation'],
+  ])('tombstones an admission that reports %s', (_caseName, admission, reason) => {
+    const publication = preparePublication();
+
+    expect(publishPrebidBid({ ...publication.input, admitTrustedBid: admission })).toEqual({
+      ok: false,
+      reason,
+    });
+    expect(publication.reservations.recognize(publication.reservationId)).toMatchObject({
+      recognized: true,
+      state: reason,
+    });
+    publication.runtime.dispose();
+  });
+
+  it('fails before exposure on collision and leaves the generated identity untouched', () => {
+    const publication = preparePublication();
+    expect(
+      publication.reservations.registerPrebidLease({
+        reservationId: publication.reservationId,
+        slot: publication.bid.slot,
+        navigation: publication.navigation,
+        auctionId: 'auction-one',
+        adUnitCode: publication.bid.slot,
+        renderSource: publication.bid.renderSource,
+        winnerContext: Object.freeze({ selectedCpm: publication.bid.cpm }),
+        prebidBid: Object.freeze({ cpm: publication.bid.cpm }),
+      })
+    ).toMatchObject({ ok: true });
+
+    expect(publishPrebidBid(publication.input)).toEqual({
+      ok: false,
+      reason: 'reservation_collision',
+    });
+    expect(publication.admitTrustedBid).not.toHaveBeenCalled();
+    expect(publication.generatedBid.adId).toBe('prebid-generated-id');
+    publication.runtime.dispose();
+  });
+
+  it('rejects a stale projected bid and malformed generated response before registration', () => {
+    const stale = preparePublication();
+    expect(publishPrebidBid({ ...stale.input, auctionId: 'other-auction' })).toEqual({
+      ok: false,
+      reason: 'winner_not_renderable',
+    });
+    expect(stale.order).toEqual([]);
+    stale.runtime.dispose();
+
+    const malformed = preparePublication();
+    expect(publishPrebidBid({ ...malformed.input, generatedBid: { cpm: 1.25 } })).toEqual({
+      ok: false,
+      reason: 'descriptor_invalid',
+    });
+    expect(malformed.order).toEqual([]);
+    malformed.runtime.dispose();
+  });
+});
+
+describe('Prebid selection coordination', () => {
+  function prepareSelection(
+    options: Readonly<{
+      activateResult?: boolean;
+      synchronousTimer?: boolean;
+      throwCreateAttempt?: boolean;
+      throwFail?: boolean;
+      throwPromotion?: boolean;
+    }> = {}
+  ) {
+    let now = 0;
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(7);
+            return target;
+          },
+        }),
+    });
+    const navigationResult = runtime.startInitialNavigation();
+    if (!navigationResult.ok) throw new Error('Expected navigation');
+    const navigation = navigationResult.value;
+    const reservations = createReservationService({
+      now: () => now,
+      prepareRenderSource: (candidate) =>
+        typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+          ? (candidate as Readonly<{ type: 'aps' | 'adm'; version: 1 }>)
+          : undefined,
+    });
+    const artifacts = createCommittedArtifactStore();
+    const attempts: RenderAttempt[] = [];
+    const promotions: Array<ReturnType<typeof reservations.promotePrebidSelection>> = [];
+    const attemptOwners: RenderAttemptScope[] = [];
+    const timers = new Map<object, () => void>();
+    const cleared: object[] = [];
+    const activateAttempt = vi.fn(() => options.activateResult ?? true);
+    const coordinator = createPrebidSelectionCoordinator({
+      activateAttempt,
+      createAttempt: (owner) => {
+        if (options.throwCreateAttempt) throw new Error('attempt factory failed');
+        attemptOwners.push(owner);
+        const result = createRenderAttempt({
+          artifacts,
+          owner,
+          prepareRenderSource: (candidate) =>
+            typeof candidate === 'object' && candidate !== null && Object.isFrozen(candidate)
+              ? (candidate as Readonly<{ type: 'aps' | 'adm'; version: 1 }>)
+              : undefined,
+          reservations,
+        });
+        if (result.ok) {
+          attempts.push(result.value);
+          if (options.throwFail) {
+            return Object.freeze({
+              ok: true as const,
+              value: Object.freeze({
+                ...result.value,
+                fail: () => {
+                  throw new Error('attempt failure settlement failed');
+                },
+              }),
+            });
+          }
+        }
+        return result;
+      },
+      reservations: {
+        promotePrebidSelection: (input) => {
+          if (options.throwPromotion) throw new Error('promotion failed');
+          const result = reservations.promotePrebidSelection(input);
+          promotions.push(result);
+          return result;
+        },
+        tombstone: reservations.tombstone,
+        tombstonePrebidGroup: reservations.tombstonePrebidGroup,
+      },
+      scheduler: {
+        clear: (handle) => {
+          cleared.push(handle as object);
+          timers.delete(handle as object);
+        },
+        set: (callback, milliseconds) => {
+          expect(milliseconds).toBe(10_000);
+          const handle = Object.freeze({});
+          timers.set(handle, callback);
+          if (options.synchronousTimer) callback();
+          return handle;
+        },
+      },
+    });
+    const admitted = (idCharacter: string, adUnitCode = 'slot-one') => {
+      const reservationId = `r1_${idCharacter.repeat(22)}`;
+      const bid = Object.freeze({
+        requestId: `request-${idCharacter}`,
+        adId: reservationId,
+        cpm: 1.25,
+        width: 300,
+        height: 250,
+        ad: '' as const,
+        ttl: 300 as const,
+        creativeId: `creative-${idCharacter}`,
+        netRevenue: true as const,
+        currency: 'USD' as const,
+        bidderCode: 'trustedServer' as const,
+        meta: Object.freeze({
+          advertiserDomains: Object.freeze([] as string[]),
+          tsAuctionId: 'auction-one',
+          tsBidId: `bid-${idCharacter}`,
+        }),
+      });
+      const prepared = Object.freeze({ auctionId: 'auction-one', adUnitCode, bid });
+      const renderSource = Object.freeze({
+        type: 'adm' as const,
+        version: 1 as const,
+        adm: `<main>${idCharacter}</main>`,
+        width: 300,
+        height: 250,
+      });
+      expect(
+        reservations.registerPrebidLease({
+          reservationId,
+          slot: adUnitCode,
+          navigation,
+          auctionId: prepared.auctionId,
+          adUnitCode,
+          renderSource,
+          winnerContext: Object.freeze({ selectedCpm: bid.cpm }),
+          prebidBid: bid,
+        })
+      ).toMatchObject({ ok: true });
+      expect(coordinator.track(prepared, navigation)).toBe(!options.synchronousTimer);
+      return prepared;
+    };
+    return {
+      admitted,
+      activateAttempt,
+      attempts,
+      attemptOwners,
+      cleared,
+      coordinator,
+      navigation,
+      promotions,
+      reservations,
+      runtime,
+      setNow: (value: number) => {
+        now = value;
+      },
+      timers,
+    };
+  }
+
+  it('contains a hostile publication failure settlement and releases its ephemeral owner', () => {
+    const harness = prepareSelection({ throwFail: true });
+
+    expect(
+      harness.coordinator.settlePublicationFailure(
+        harness.navigation,
+        'auction-one',
+        'slot-one',
+        'prebid_admission_failed'
+      )
+    ).toBe(false);
+    expect(harness.attempts[0]?.snapshot().outcome).toEqual({
+      outcome: 'cancelled',
+      reason: 'navigation_disposed',
+    });
+    expect(harness.navigation.snapshotInventoryForTest()).toMatchObject({
+      attempts: 0,
+      batches: 0,
+    });
+    harness.runtime.dispose();
+  });
+
+  it('promotes only the exact selected TS id and suppresses its group losers', () => {
+    const harness = prepareSelection();
+    const selected = harness.admitted('a');
+    const losing = harness.admitted('b');
+
+    harness.coordinator.auctionEnded(
+      Object.freeze({ auctionId: 'auction-one' }),
+      Object.freeze({
+        highestBids: () =>
+          Object.freeze([
+            Object.freeze({
+              ...selected.bid,
+              adUnitCode: selected.adUnitCode,
+              auctionId: selected.auctionId,
+            }),
+          ]),
+      })
+    );
+
+    expect(harness.attempts).toHaveLength(1);
+    expect(harness.promotions).toEqual([expect.objectContaining({ ok: true })]);
+    expect(harness.reservations.recognize(selected.bid.adId)).toMatchObject({
+      state: 'renderable',
+    });
+    expect(harness.reservations.recognize(losing.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.attemptOwners[0]?.winnerContext).toEqual({ selectedCpm: 1.25 });
+    expect(harness.attempts[0]?.winnerContext).toBeUndefined();
+    expect(harness.activateAttempt).toHaveBeenCalledTimes(1);
+    expect(harness.timers).toHaveLength(0);
+    harness.runtime.dispose();
+  });
+
+  it('tombstones a selected reservation when its PUC attempt cannot activate', () => {
+    const harness = prepareSelection({ activateResult: false });
+    const selected = harness.admitted('f');
+
+    harness.coordinator.auctionEnded(
+      Object.freeze({ auctionId: 'auction-one' }),
+      Object.freeze({
+        highestBids: () =>
+          Object.freeze([
+            Object.freeze({
+              ...selected.bid,
+              adUnitCode: selected.adUnitCode,
+              auctionId: selected.auctionId,
+            }),
+          ]),
+      })
+    );
+
+    expect(harness.reservations.recognize(selected.bid.adId)).toMatchObject({ state: 'stale' });
+    expect(harness.attempts[0]?.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'prebid_contract_violation',
+    });
+    harness.runtime.dispose();
+  });
+
+  it('marks the whole TS group unselected when native Prebid wins', () => {
+    const harness = prepareSelection();
+    const losing = harness.admitted('c');
+
+    harness.coordinator.auctionEnded(
+      Object.freeze({ auctionId: 'auction-one' }),
+      Object.freeze({
+        highestBids: () =>
+          Object.freeze([
+            Object.freeze({
+              adId: 'native-prebid-id',
+              adUnitCode: 'slot-one',
+              auctionId: 'auction-one',
+              cpm: 9,
+            }),
+          ]),
+      })
+    );
+
+    expect(harness.reservations.recognize(losing.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.attempts).toEqual([]);
+    expect(harness.timers).toHaveLength(0);
+    harness.runtime.dispose();
+  });
+
+  it('fails closed when the pinned single-unit winner query is ambiguous', () => {
+    const harness = prepareSelection();
+    const selected = harness.admitted('i');
+
+    harness.coordinator.auctionEnded(
+      Object.freeze({ auctionId: 'auction-one' }),
+      Object.freeze({
+        highestBids: () =>
+          Object.freeze([
+            Object.freeze({
+              ...selected.bid,
+              adUnitCode: selected.adUnitCode,
+              auctionId: selected.auctionId,
+            }),
+            Object.freeze({
+              adId: 'native-prebid-id',
+              adUnitCode: selected.adUnitCode,
+              auctionId: selected.auctionId,
+              cpm: selected.bid.cpm,
+            }),
+          ]),
+      })
+    );
+
+    expect(harness.reservations.recognize(selected.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.attempts).toEqual([]);
+    expect(harness.timers).toHaveLength(0);
+    harness.runtime.dispose();
+  });
+
+  it('times out a missing auctionEnd and cancels the watchdog on navigation disposal', () => {
+    const timedOut = prepareSelection();
+    const bid = timedOut.admitted('d');
+    timedOut.setNow(9_999);
+    expect(timedOut.timers.size).toBe(1);
+    [...timedOut.timers.values()][0]?.();
+    expect(timedOut.reservations.recognize(bid.bid.adId)).toMatchObject({
+      state: 'prebid_selection_timeout',
+    });
+    timedOut.runtime.dispose();
+
+    const disposed = prepareSelection();
+    const disposedBid = disposed.admitted('e');
+    disposed.runtime.replaceNavigation();
+    expect(disposed.reservations.recognize(disposedBid.bid.adId)).toMatchObject({
+      state: 'aborted',
+    });
+    expect(disposed.timers).toHaveLength(0);
+  });
+
+  it('aborts every ad unit in one exact auction and releases each short lease at expiry', () => {
+    const harness = prepareSelection();
+    const first = harness.admitted('j', 'slot-one');
+    const second = harness.admitted('k', 'slot-two');
+
+    harness.coordinator.abort(harness.navigation, 'auction-one');
+
+    expect(harness.reservations.recognize(first.bid.adId)).toMatchObject({ state: 'aborted' });
+    expect(harness.reservations.recognize(second.bid.adId)).toMatchObject({ state: 'aborted' });
+    expect(harness.timers).toHaveLength(0);
+    expect(harness.navigation.snapshotInventoryForTest().batches).toBe(0);
+
+    harness.setNow(10_000);
+    expect(harness.reservations.recognize(first.bid.adId)).toEqual({ recognized: false });
+    expect(harness.reservations.recognize(second.bid.adId)).toEqual({ recognized: false });
+    expect(harness.reservations.snapshotInventoryForTest().size).toBe(0);
+    harness.runtime.dispose();
+  });
+
+  it('selects independently across multiple ad units without promoting either group loser', () => {
+    const harness = prepareSelection();
+    const first = harness.admitted('l', 'slot-one');
+    const firstLoser = harness.admitted('m', 'slot-one');
+    const second = harness.admitted('n', 'slot-two');
+    const secondLoser = harness.admitted('o', 'slot-two');
+
+    harness.coordinator.auctionEnded(
+      Object.freeze({ auctionId: 'auction-one' }),
+      Object.freeze({
+        highestBids: (adUnitCode?: string) => {
+          const selected = adUnitCode === 'slot-one' ? first : second;
+          return Object.freeze([
+            Object.freeze({
+              ...selected.bid,
+              adUnitCode: selected.adUnitCode,
+              auctionId: selected.auctionId,
+            }),
+          ]);
+        },
+      })
+    );
+
+    expect(harness.reservations.recognize(first.bid.adId)).toMatchObject({ state: 'renderable' });
+    expect(harness.reservations.recognize(second.bid.adId)).toMatchObject({ state: 'renderable' });
+    expect(harness.reservations.recognize(firstLoser.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.reservations.recognize(secondLoser.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.attempts).toHaveLength(2);
+    expect(harness.timers).toHaveLength(0);
+    harness.runtime.dispose();
+  });
+
+  it('rolls back a scheduler that invokes the deadline before timer publication returns', () => {
+    const harness = prepareSelection({ synchronousTimer: true });
+    const bid = harness.admitted('g');
+
+    expect(harness.reservations.recognize(bid.bid.adId)).toMatchObject({
+      state: 'prebid_selection_timeout',
+    });
+    expect(harness.timers).toHaveLength(0);
+    expect(harness.navigation.snapshotInventoryForTest().batches).toBe(0);
+    harness.runtime.dispose();
+  });
+
+  it.each([
+    { failure: 'attempt creation', options: { throwCreateAttempt: true } },
+    { failure: 'reservation promotion', options: { throwPromotion: true } },
+  ])('fails closed when $failure throws during selection', ({ options }) => {
+    const harness = prepareSelection(options);
+    const selected = harness.admitted('h');
+
+    expect(() =>
+      harness.coordinator.auctionEnded(
+        Object.freeze({ auctionId: 'auction-one' }),
+        Object.freeze({
+          highestBids: () =>
+            Object.freeze([
+              Object.freeze({
+                ...selected.bid,
+                adUnitCode: selected.adUnitCode,
+                auctionId: selected.auctionId,
+              }),
+            ]),
+        })
+      )
+    ).not.toThrow();
+
+    expect(harness.reservations.recognize(selected.bid.adId)).toMatchObject({
+      state: 'unselected',
+    });
+    expect(harness.attempts[0]?.snapshot().outcome).toEqual(
+      options.throwPromotion
+        ? { outcome: 'failed', reason: 'prebid_contract_violation' }
+        : undefined
+    );
+    expect(harness.timers).toHaveLength(0);
+    expect(harness.navigation.snapshotInventoryForTest().batches).toBe(0);
+    harness.runtime.dispose();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/prebid/startup.test.ts b/crates/trusted-server-js/lib/test/integrations/prebid/startup.test.ts
new file mode 100644
index 000000000..aaae60d1f
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/prebid/startup.test.ts
@@ -0,0 +1,259 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type {
+  PrebidAdapter,
+  PrebidEventFacade,
+  PrebidFacade,
+  PrebidTrustedServerAuctionV1,
+} from '../../../src/adapters/prebid';
+import { createPrebidStartup } from '../../../src/integrations/prebid/startup';
+import type { GptRefreshPolicy } from '../../../src/integrations/gpt/startup';
+
+describe('Prebid startup bridge', () => {
+  it('installs one reversible bidder/event operation before starting the external boundary', async () => {
+    let bidderListener: ((auction: Readonly<PrebidTrustedServerAuctionV1>) => void) | undefined;
+    let auctionEndListener:
+      ((event: unknown, prebid: Readonly<PrebidEventFacade>) => void) | undefined;
+    const operationDispose = vi.fn();
+    const releaseBidder = vi.fn();
+    const releaseAuctionEnd = vi.fn();
+    const order: string[] = [];
+    const eventFacade = Object.freeze({ highestBids: vi.fn(() => Object.freeze([])) });
+    const facade = Object.freeze({
+      registerTrustedServerBidder: vi.fn(
+        (listener: (auction: Readonly<PrebidTrustedServerAuctionV1>) => void) => {
+          order.push('register-bidder');
+          bidderListener = listener;
+          return () => {
+            order.push('release-bidder');
+            releaseBidder();
+          };
+        }
+      ),
+      subscribe: vi.fn(
+        (
+          eventType: string,
+          listener: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void
+        ) => {
+          expect(eventType).toBe('auctionEnd');
+          order.push('subscribe-auction-end');
+          auctionEndListener = listener;
+          return () => {
+            order.push('release-auction-end');
+            releaseAuctionEnd();
+          };
+        }
+      ),
+    }) as unknown as Readonly<PrebidFacade>;
+    const run = vi.fn((command: (prebid: Readonly<PrebidFacade>) => unknown) =>
+      Object.freeze({
+        status: 'present' as const,
+        result: Promise.resolve(command(facade)),
+        dispose: operationDispose,
+      })
+    );
+    const notifyReady = vi.fn();
+    const adapter = Object.freeze({ run, notifyReady }) as unknown as PrebidAdapter;
+    const onAuction = vi.fn();
+    const onAuctionEnd = vi.fn();
+    const dispose = vi.fn();
+    const start = vi.fn();
+    const startup = createPrebidStartup({
+      dispose,
+      onAuction,
+      onAuctionEnd,
+      prebid: adapter,
+      start,
+    });
+
+    const release = startup.activate();
+    await Promise.resolve();
+
+    expect(run).toHaveBeenCalledTimes(1);
+    expect(order).toEqual(['subscribe-auction-end']);
+    expect(facade.registerTrustedServerBidder).not.toHaveBeenCalled();
+    expect(facade.subscribe).toHaveBeenCalledTimes(1);
+    const event = Object.freeze({ auctionId: 'auction-one' });
+    auctionEndListener?.(event, eventFacade);
+    expect(onAuctionEnd).toHaveBeenCalledExactlyOnceWith(event, eventFacade);
+
+    const config = Object.freeze({ externalBundleUrl: '/prebid.js' });
+    startup.start(config);
+    await Promise.resolve();
+    expect(start).toHaveBeenCalledExactlyOnceWith(config);
+    expect(notifyReady).toHaveBeenCalledTimes(1);
+    expect(run).toHaveBeenCalledTimes(2);
+    expect(facade.registerTrustedServerBidder).toHaveBeenCalledTimes(1);
+    expect(order).toEqual(['subscribe-auction-end', 'register-bidder']);
+    const auction = Object.freeze({
+      auctionId: 'auction-one',
+      bids: Object.freeze([]),
+      complete: vi.fn(),
+    });
+    bidderListener?.(auction);
+    expect(onAuction).toHaveBeenCalledExactlyOnceWith(auction);
+
+    release();
+    release();
+    expect(operationDispose).toHaveBeenCalledTimes(2);
+    expect(releaseAuctionEnd).toHaveBeenCalledTimes(1);
+    expect(releaseBidder).toHaveBeenCalledTimes(1);
+    expect(order).toEqual([
+      'subscribe-auction-end',
+      'register-bidder',
+      'release-bidder',
+      'release-auction-end',
+    ]);
+    expect(dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it('releases effects that settle after the runtime owner is already disposed', async () => {
+    let resolveOperation!: (release: () => void) => void;
+    const result = new Promise<() => void>((resolve) => {
+      resolveOperation = resolve;
+    });
+    const operationDispose = vi.fn();
+    const run = vi.fn(() =>
+      Object.freeze({ status: 'present' as const, result, dispose: operationDispose })
+    );
+    const dispose = vi.fn();
+    const startup = createPrebidStartup({
+      dispose,
+      onAuction: vi.fn(),
+      onAuctionEnd: vi.fn(),
+      prebid: Object.freeze({ run, notifyReady: vi.fn() }) as unknown as PrebidAdapter,
+    });
+    const releaseEffects = vi.fn();
+
+    const release = startup.activate();
+    release();
+    resolveOperation(releaseEffects);
+    await Promise.resolve();
+
+    expect(operationDispose).toHaveBeenCalledTimes(1);
+    expect(releaseEffects).toHaveBeenCalledTimes(1);
+    expect(dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it('installs the TS auctionEnd listener before startup can add a publisher callback', async () => {
+    const listeners: Array<(event: unknown, prebid: Readonly<PrebidEventFacade>) => void> = [];
+    const order: string[] = [];
+    const eventFacade = Object.freeze({ highestBids: vi.fn(() => Object.freeze([])) });
+    const facade = Object.freeze({
+      registerTrustedServerBidder: vi.fn(() => vi.fn()),
+      subscribe: vi.fn(
+        (
+          eventType: string,
+          listener: (event: unknown, prebid: Readonly<PrebidEventFacade>) => void
+        ) => {
+          expect(eventType).toBe('auctionEnd');
+          listeners.push(listener);
+          return vi.fn();
+        }
+      ),
+    }) as unknown as Readonly<PrebidFacade>;
+    const run = vi.fn((command: (prebid: Readonly<PrebidFacade>) => unknown) =>
+      Object.freeze({
+        status: 'present' as const,
+        result: Promise.resolve(command(facade)),
+        dispose: vi.fn(),
+      })
+    );
+    const startup = createPrebidStartup({
+      dispose: vi.fn(),
+      onAuction: vi.fn(),
+      onAuctionEnd: () => order.push('trusted-server'),
+      prebid: Object.freeze({ run, notifyReady: vi.fn() }) as unknown as PrebidAdapter,
+      start: () => {
+        listeners.push(() => order.push('publisher'));
+      },
+    });
+
+    startup.activate();
+    await Promise.resolve();
+    startup.start(Object.freeze({}));
+    await Promise.resolve();
+    const event = Object.freeze({ auctionId: 'auction-one' });
+    for (const listener of listeners) listener(event, eventFacade);
+
+    expect(order).toEqual(['trusted-server', 'publisher']);
+  });
+
+  it('installs, configures, and releases one runtime-owned GPT refresh policy', async () => {
+    const order: string[] = [];
+    const operationDispose = vi.fn();
+    const facade = Object.freeze({
+      registerTrustedServerBidder: vi.fn(() => vi.fn()),
+      subscribe: vi.fn(() => vi.fn()),
+    }) as unknown as Readonly<PrebidFacade>;
+    const prebid = Object.freeze({
+      notifyReady: vi.fn(),
+      run: vi.fn((command: (prebid: Readonly<PrebidFacade>) => unknown) =>
+        Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(command(facade)),
+          dispose: operationDispose,
+        })
+      ),
+    }) as unknown as Pick<PrebidAdapter, 'notifyReady' | 'run'>;
+    const policy = Object.freeze({ prepare: vi.fn(), dispose: vi.fn() });
+    const releasePolicy = vi.fn(() => order.push('release-policy'));
+    const install = vi.fn((_policy: GptRefreshPolicy) => {
+      order.push('install-policy');
+      return releasePolicy;
+    });
+    const configure = vi.fn((_config: unknown) => order.push('configure-policy'));
+    const start = vi.fn(() => order.push('start-prebid'));
+    const startup = createPrebidStartup({
+      dispose: vi.fn(),
+      onAuction: vi.fn(),
+      onAuctionEnd: vi.fn(),
+      prebid,
+      refresh: Object.freeze({ configure, install, policy }),
+      start,
+    });
+
+    const release = startup.activate();
+    expect(install).toHaveBeenCalledExactlyOnceWith(policy);
+    const config = Object.freeze({ excludedGamAdUnitPathSuffixes: Object.freeze(['/skip']) });
+    startup.start(config);
+    expect(configure).toHaveBeenCalledExactlyOnceWith(config);
+    expect(order).toEqual(['install-policy', 'configure-policy', 'start-prebid']);
+
+    release();
+    release();
+    expect(policy.dispose).toHaveBeenCalledOnce();
+    expect(releasePolicy).toHaveBeenCalledOnce();
+  });
+
+  it('unwinds the adapter and policy when GPT refuses a second refresh owner', () => {
+    const operationDispose = vi.fn();
+    const prebid = Object.freeze({
+      notifyReady: vi.fn(),
+      run: vi.fn(() =>
+        Object.freeze({
+          status: 'present' as const,
+          result: Promise.resolve(vi.fn()),
+          dispose: operationDispose,
+        })
+      ),
+    }) as unknown as Pick<PrebidAdapter, 'notifyReady' | 'run'>;
+    const policy = Object.freeze({ prepare: vi.fn(), dispose: vi.fn() });
+    const dispose = vi.fn();
+    const startup = createPrebidStartup({
+      dispose,
+      onAuction: vi.fn(),
+      onAuctionEnd: vi.fn(),
+      prebid,
+      refresh: Object.freeze({
+        install: vi.fn(() => undefined),
+        policy,
+      }),
+    });
+
+    expect(() => startup.activate()).toThrow('Prebid refresh policy is unavailable');
+    expect(operationDispose).toHaveBeenCalledOnce();
+    expect(policy.dispose).toHaveBeenCalledOnce();
+    expect(dispose).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/render_runtime/module.test.ts b/crates/trusted-server-js/lib/test/integrations/render_runtime/module.test.ts
new file mode 100644
index 000000000..8991f11a4
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/render_runtime/module.test.ts
@@ -0,0 +1,1051 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type {
+  IntegrationActivationContext,
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../../src/kernel/integration_registry';
+import type {
+  RuntimeAuctionContextService,
+  RuntimeCapabilityV1,
+} from '../../../src/kernel/runtime';
+import {
+  adoptInitialRenderArtifactsFromHandoff,
+  adoptInitialRenderStateFromHandoff,
+  createRenderRuntimeIntegrationRegistration,
+} from '../../../src/integrations/render_runtime/module';
+import { log } from '../../../src/core/log';
+import {
+  createArtifactHostPositionLeaseRegistry,
+  createCommittedArtifactStore,
+  type CommittedRenderArtifact,
+  type RenderAttempt,
+} from '../../../src/services/render';
+import type { NavigationSession } from '../../../src/kernel/sessions';
+
+const RELEASE_ID = 'a'.repeat(64);
+
+afterEach(() => {
+  document.body.replaceChildren();
+});
+
+describe('render_runtime provider', () => {
+  it('adopts first-display replay tombstones and trace high-water state', () => {
+    const adoptFirstDisplayIdentityState = vi.fn(() => true);
+    const adoptTombstones = vi.fn(() => true);
+    const adoptTrace = vi.fn(() => true);
+    const navigationGeneration = {};
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        highWater: Object.freeze({
+          nextAttemptOrdinal: 7,
+          nextNavigationAttemptOrdinal: 6,
+          navigationAttemptPrefix: 'CAcGBQQDAgE',
+          reservationClockEpochMs: 50,
+        }),
+        tombstones: Object.freeze([
+          Object.freeze({
+            expiresAtMs: 250,
+            kind: 'reservation',
+            ordinal: 4,
+            value: `r1_${'a'.repeat(22)}`,
+          }),
+          Object.freeze({ expiresAtMs: 90, kind: 'ticket', ordinal: 2, value: 'ticket' }),
+        ]),
+        slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+        cycles: Object.freeze([
+          Object.freeze({
+            records: Object.freeze([Object.freeze({ ordinal: 1, state: 'completed' as const })]),
+            slotId: 'slot-1',
+            token: 'gt1_1',
+          }),
+        ]),
+        trace: Object.freeze({
+          nextSequence: 9,
+          slots: Object.freeze([
+            Object.freeze({
+              bindings: Object.freeze([
+                Object.freeze({
+                  atMs: 4,
+                  cycleOrdinal: 1,
+                  historySequence: 8,
+                  state: 'completed' as const,
+                  token: 'gt1_1',
+                }),
+              ]),
+              impressions: 3,
+              slotId: 'slot-1',
+            }),
+          ]),
+        }),
+      }),
+      identities: Object.freeze([]),
+    });
+
+    expect(
+      adoptInitialRenderStateFromHandoff(
+        adoption,
+        { adoptFirstDisplayIdentityState, generation: navigationGeneration },
+        { adoptFirstDisplayTombstones: adoptTombstones },
+        { adoptFirstDisplay: adoptTrace }
+      )
+    ).toBe(adoption);
+    expect(adoptFirstDisplayIdentityState).toHaveBeenCalledExactlyOnceWith('CAcGBQQDAgE', 7);
+    expect(adoptTrace).toHaveBeenCalledWith({
+      navigationGeneration,
+      nextSequence: 9,
+      slots: [
+        {
+          bindings: [
+            {
+              cycleOrdinal: 1,
+              historySequence: 8,
+              state: 'completed',
+              token: 'gt1_1',
+            },
+          ],
+          impressions: 3,
+          records: [
+            {
+              at: 4,
+              count: 3,
+              elementId: 'div-1',
+              injected: true,
+              path: 'ssat',
+              rendered: true,
+              seq: 8,
+              servedFrom: 'inline',
+              slotId: 'slot-1',
+            },
+          ],
+          slotId: 'slot-1',
+        },
+      ],
+    });
+    expect(adoptTombstones).toHaveBeenCalledWith({
+      clockEpochMs: 50,
+      tombstones: [{ expiresAtMs: 250, reservationId: `r1_${'a'.repeat(22)}` }],
+    });
+  });
+
+  it('adopts transferred DOM artifacts without removing them on rollback, then arms commit ownership', () => {
+    const host = document.createElement('div');
+    host.id = 'div-1';
+    const frame = document.createElement('iframe');
+    frame.srcdoc = '<!doctype html><title>Fictional creative</title>';
+    host.append(frame);
+    document.body.append(host);
+    const physicalSlot = Object.freeze({});
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        artifacts: Object.freeze([
+          Object.freeze({
+            hostPosition: null,
+            hostPositionPriority: null,
+            kind: 'gpt_adm' as const,
+            owner: 'trusted_server' as const,
+            slotId: 'slot-1',
+            token: `r1_${'a'.repeat(22)}`,
+          }),
+        ]),
+      }),
+      identities: Object.freeze([physicalSlot, frame]),
+    });
+    const navigationGeneration = {};
+    const batch = Object.freeze({
+      createRenderAttempt: vi.fn(() =>
+        Object.freeze({
+          ok: true as const,
+          value: Object.freeze({
+            id: `a1_${'A'.repeat(22)}`,
+            navigationGeneration,
+          }),
+        })
+      ),
+      dispose: vi.fn(),
+    });
+    const navigation = Object.freeze({
+      generation: navigationGeneration,
+      createAuctionBatch: vi.fn(() => batch),
+      isCurrent: () => true,
+    }) as unknown as NavigationSession;
+
+    const rollbackStore = createCommittedArtifactStore();
+    expect(
+      adoptInitialRenderArtifactsFromHandoff(
+        adoption,
+        navigation,
+        rollbackStore,
+        createArtifactHostPositionLeaseRegistry(),
+        document
+      )
+    ).toBeDefined();
+    rollbackStore.dispose();
+    expect(frame.isConnected).toBe(true);
+
+    const committedStore = createCommittedArtifactStore();
+    const committed = adoptInitialRenderArtifactsFromHandoff(
+      adoption,
+      navigation,
+      committedStore,
+      createArtifactHostPositionLeaseRegistry(),
+      document
+    );
+    expect(committed?.adoption).toBe(adoption);
+    committed?.arm();
+    committedStore.dispose();
+    expect(frame.isConnected).toBe(false);
+    expect(batch.dispose).toHaveBeenCalledTimes(2);
+  });
+
+  it('adopts a publisher-owned PUC shell without claiming its DOM lifetime', () => {
+    const host = document.createElement('div');
+    host.id = 'div-1';
+    const publisherWrapper = document.createElement('div');
+    const frame = document.createElement('iframe');
+    frame.src = 'https://publisher.example/universal-creative';
+    publisherWrapper.append(frame);
+    document.body.append(host, publisherWrapper);
+    const navigationGeneration = {};
+    const batch = Object.freeze({
+      createRenderAttempt: vi.fn(() =>
+        Object.freeze({
+          ok: true as const,
+          value: Object.freeze({ id: `a1_${'A'.repeat(22)}`, navigationGeneration }),
+        })
+      ),
+      dispose: vi.fn(),
+    });
+    const navigation = Object.freeze({
+      generation: navigationGeneration,
+      createAuctionBatch: vi.fn(() => batch),
+      isCurrent: () => true,
+    }) as unknown as NavigationSession;
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        artifacts: Object.freeze([
+          Object.freeze({
+            hostPosition: null,
+            hostPositionPriority: null,
+            kind: 'gpt_adm' as const,
+            owner: 'publisher' as const,
+            slotId: 'slot-1',
+            token: `r1_${'a'.repeat(22)}`,
+          }),
+        ]),
+      }),
+      identities: Object.freeze([Object.freeze({}), frame]),
+    });
+    const store = createCommittedArtifactStore();
+    const committed = adoptInitialRenderArtifactsFromHandoff(
+      adoption,
+      navigation,
+      store,
+      createArtifactHostPositionLeaseRegistry(),
+      document
+    );
+
+    expect(committed).toBeDefined();
+    committed?.arm();
+    frame.style.setProperty('visibility', 'hidden');
+    expect(store.sweep()).toBe(1);
+    expect(frame.isConnected).toBe(true);
+    expect(batch.dispose).toHaveBeenCalledOnce();
+  });
+
+  it.each(['reparented', 'frame_style'] as const)(
+    'retires an adopted APS mount on %s loss and compare-restores only owned style',
+    (mutation) => {
+      const host = document.createElement('div');
+      host.id = 'div-1';
+      host.style.setProperty('position', 'relative');
+      const frame = document.createElement('iframe');
+      frame.setAttribute('sandbox', 'allow-scripts');
+      frame.src = 'https://example.com/renderer';
+      host.append(frame);
+      document.body.append(host);
+      const physicalSlot = Object.freeze({});
+      const navigationGeneration = {};
+      const batch = Object.freeze({
+        createRenderAttempt: vi.fn(() =>
+          Object.freeze({
+            ok: true as const,
+            value: Object.freeze({ id: `a1_${'A'.repeat(22)}`, navigationGeneration }),
+          })
+        ),
+        dispose: vi.fn(),
+      });
+      const navigation = Object.freeze({
+        generation: navigationGeneration,
+        createAuctionBatch: vi.fn(() => batch),
+        isCurrent: () => true,
+      }) as unknown as NavigationSession;
+      const adoption = Object.freeze({
+        version: 1 as const,
+        adoptInitialDisplay: true as const,
+        handoff: Object.freeze({
+          slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+          cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+          artifacts: Object.freeze([
+            Object.freeze({
+              hostPosition: '',
+              hostPositionPriority: '',
+              kind: 'aps' as const,
+              owner: 'trusted_server' as const,
+              slotId: 'slot-1',
+              token: `r1_${'a'.repeat(22)}`,
+            }),
+          ]),
+        }),
+        identities: Object.freeze([physicalSlot, frame]),
+      });
+      const store = createCommittedArtifactStore();
+      const committed = adoptInitialRenderArtifactsFromHandoff(
+        adoption,
+        navigation,
+        store,
+        createArtifactHostPositionLeaseRegistry(),
+        document
+      );
+      expect(committed).toBeDefined();
+      committed?.arm();
+
+      if (mutation === 'reparented') {
+        const publisherContainer = document.createElement('div');
+        document.body.append(publisherContainer);
+        publisherContainer.append(frame);
+      } else {
+        frame.style.setProperty('visibility', 'hidden');
+      }
+
+      expect(store.sweep()).toBe(1);
+      expect(frame.isConnected).toBe(false);
+      expect(host.style.getPropertyValue('position')).toBe('');
+      expect(store.sweep()).toBe(0);
+    }
+  );
+
+  it('transfers an adopted APS host-position lease through persistent replacement', () => {
+    const host = document.createElement('div');
+    host.id = 'div-1';
+    host.style.setProperty('position', 'relative');
+    const frame = document.createElement('iframe');
+    frame.src = 'https://example.com/renderer';
+    host.append(frame);
+    document.body.append(host);
+    const physicalSlot = Object.freeze({});
+    const navigationGeneration = {};
+    const batch = Object.freeze({
+      createRenderAttempt: vi.fn(() =>
+        Object.freeze({
+          ok: true as const,
+          value: Object.freeze({ id: `a1_${'A'.repeat(22)}`, navigationGeneration }),
+        })
+      ),
+      dispose: vi.fn(),
+    });
+    const navigation = Object.freeze({
+      generation: navigationGeneration,
+      createAuctionBatch: vi.fn(() => batch),
+      isCurrent: () => true,
+    }) as unknown as NavigationSession;
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        artifacts: Object.freeze([
+          Object.freeze({
+            hostPosition: '',
+            hostPositionPriority: '',
+            kind: 'aps' as const,
+            owner: 'trusted_server' as const,
+            slotId: 'slot-1',
+            token: `r1_${'a'.repeat(22)}`,
+          }),
+        ]),
+      }),
+      identities: Object.freeze([physicalSlot, frame]),
+    });
+    const store = createCommittedArtifactStore();
+    const positions = createArtifactHostPositionLeaseRegistry();
+    const committed = adoptInitialRenderArtifactsFromHandoff(
+      adoption,
+      navigation,
+      store,
+      positions,
+      document
+    );
+    expect(committed).toBeDefined();
+    committed?.arm();
+    const predecessor = store.current('slot-1');
+    if (!predecessor) throw new Error('should adopt the first-display APS artifact');
+    let replacementDisposed = false;
+    const replacement: CommittedRenderArtifact = Object.freeze({
+      attemptId: `a1_${'B'.repeat(22)}`,
+      kind: 'aps_mount' as const,
+      navigationGeneration,
+      slot: 'slot-1',
+      dispose: () => {
+        if (replacementDisposed) return;
+        replacementDisposed = true;
+        positions.release(replacement);
+      },
+    });
+
+    expect(positions.inherit(replacement, predecessor, host)).toBe(true);
+    expect(positions.claim(replacement)).toBe(true);
+    expect(store.promote(replacement)).toBe(true);
+    expect(frame.isConnected).toBe(false);
+    expect(host.style.getPropertyValue('position')).toBe('relative');
+
+    expect(store.release(replacement)).toBe(true);
+    expect(host.style.getPropertyValue('position')).toBe('');
+  });
+
+  it('does not restore an adopted APS host style after a publisher replaces it', () => {
+    const host = document.createElement('div');
+    host.id = 'div-1';
+    host.style.setProperty('position', 'relative');
+    const frame = document.createElement('iframe');
+    host.append(frame);
+    document.body.append(host);
+    const navigationGeneration = {};
+    const batch = Object.freeze({
+      createRenderAttempt: () =>
+        Object.freeze({
+          ok: true as const,
+          value: Object.freeze({ id: `a1_${'A'.repeat(22)}`, navigationGeneration }),
+        }),
+      dispose: vi.fn(),
+    });
+    const navigation = Object.freeze({
+      generation: navigationGeneration,
+      createAuctionBatch: () => batch,
+      isCurrent: () => true,
+    }) as unknown as NavigationSession;
+    const adoption = Object.freeze({
+      version: 1 as const,
+      adoptInitialDisplay: true as const,
+      handoff: Object.freeze({
+        slots: Object.freeze([Object.freeze({ id: 'slot-1', domId: 'div-1' })]),
+        cycles: Object.freeze([Object.freeze({ slotId: 'slot-1' })]),
+        artifacts: Object.freeze([
+          Object.freeze({
+            hostPosition: '',
+            hostPositionPriority: '',
+            kind: 'aps' as const,
+            owner: 'trusted_server' as const,
+            slotId: 'slot-1',
+            token: `r1_${'a'.repeat(22)}`,
+          }),
+        ]),
+      }),
+      identities: Object.freeze([Object.freeze({}), frame]),
+    });
+    const store = createCommittedArtifactStore();
+    const committed = adoptInitialRenderArtifactsFromHandoff(
+      adoption,
+      navigation,
+      store,
+      createArtifactHostPositionLeaseRegistry(),
+      document
+    );
+    expect(committed).toBeDefined();
+    committed?.arm();
+
+    host.style.setProperty('position', 'absolute', 'important');
+    expect(store.sweep()).toBe(1);
+    expect(frame.isConnected).toBe(false);
+    expect(host.style.getPropertyValue('position')).toBe('absolute');
+    expect(host.style.getPropertyPriority('position')).toBe('important');
+  });
+
+  it('rolls back prepared resources without unbound disposer failures', () => {
+    const release: Array<() => void> = [];
+    const warn = vi.spyOn(log, 'warn').mockImplementation(() => undefined);
+    const runtime = Object.freeze({
+      attachAuctionContextService: () => () => undefined,
+      boot: () =>
+        Object.freeze({
+          auctionProjection: Object.freeze({
+            version: 1,
+            auction: Object.freeze({
+              version: 1,
+              auctionId: 'initial',
+              results: Object.freeze([]),
+            }),
+            slots: Object.freeze([]),
+            bids: Object.freeze([]),
+          }),
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: false,
+            gpt: Object.freeze({ active: false }),
+          }),
+          manifest: Object.freeze({
+            version: 1,
+            releaseId: RELEASE_ID,
+            firstDisplay: null,
+            runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'b'.repeat(64)}`,
+            integrations: Object.freeze([
+              Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+            ]),
+          }),
+        }),
+      document,
+      enqueue: () => true,
+      generation: Object.freeze({}),
+      protectFirstDisplayAttemptBatch: vi.fn(() => true),
+      registerAuctionContext: () => () => undefined,
+    } satisfies RuntimeCapabilityV1);
+
+    createRenderRuntimeIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({ 'runtime.v1': runtime }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => release.push(callback),
+      } satisfies IntegrationPrepareContext)
+    );
+    release.reverse().forEach((callback) => callback());
+
+    expect(warn).not.toHaveBeenCalledWith('render_runtime disposal failed', expect.anything());
+    warn.mockRestore();
+  });
+
+  it('stages the seven real capabilities inertly and activates direct registration once', async () => {
+    const release: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    const protect = vi.fn(() => true);
+    let contextService: RuntimeAuctionContextService | undefined;
+    const runtime = Object.freeze({
+      attachAuctionContextService: (service: RuntimeAuctionContextService) => {
+        if (contextService) return undefined;
+        contextService = service;
+        return () => {
+          if (contextService === service) contextService = undefined;
+        };
+      },
+      boot: () =>
+        Object.freeze({
+          auctionProjection: Object.freeze({
+            version: 1,
+            auction: Object.freeze({
+              version: 1,
+              auctionId: 'initial',
+              results: Object.freeze([]),
+            }),
+            slots: Object.freeze([]),
+            bids: Object.freeze([]),
+          }),
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: false,
+            gpt: Object.freeze({ active: false }),
+          }),
+          manifest: Object.freeze({
+            version: 1,
+            releaseId: RELEASE_ID,
+            firstDisplay: null,
+            runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'b'.repeat(64)}`,
+            integrations: Object.freeze([
+              Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+              Object.freeze({ id: 'permutive_context', phase: 'takeover' as const }),
+            ]),
+          }),
+        }),
+      document,
+      enqueue: () => true,
+      generation: Object.freeze({}),
+      protectFirstDisplayAttemptBatch: protect,
+      registerAuctionContext: (
+        integrationId: string,
+        contributor: () => Readonly<Record<string, unknown>> | undefined
+      ) => contextService?.register(integrationId, contributor),
+    } satisfies RuntimeCapabilityV1);
+    const registration = createRenderRuntimeIntegrationRegistration(RELEASE_ID);
+    const prepared = registration.prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({ 'runtime.v1': runtime }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => release.push(callback),
+      } satisfies IntegrationPrepareContext)
+    );
+    if ('then' in Object(prepared)) throw new Error('render_runtime preparation must be sync');
+    const exactPrepared = prepared as PreparedIntegration;
+    const interfaces = exactPrepared.interfaces;
+    expect(Reflect.ownKeys(interfaces ?? {})).toEqual([
+      'slots.v1',
+      'auction.v1',
+      'render.v1',
+      'messages.v1',
+      'trace.v1',
+      'trace.presentation.v1',
+      'direct.v1',
+    ]);
+    const direct = interfaces?.['direct.v1'] as {
+      addAdUnits: (candidate: unknown) => unknown;
+      requestAds: (candidate?: unknown) => Promise<unknown>;
+    };
+    const slotCapability = interfaces?.['slots.v1'] as {
+      attachPhysicalService: (service: object) => () => void;
+      snapshot: () => readonly Readonly<{ registeredSlotId: string }>[];
+    };
+    expect(() =>
+      direct.addAdUnits({
+        code: 'programmatic',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [{ bidder: 'fictional', params: {} }],
+      })
+    ).toThrow();
+
+    exactPrepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    expect(
+      direct.addAdUnits({
+        code: 'programmatic',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [{ bidder: 'fictional', params: {} }],
+      })
+    ).toEqual({ registered: ['programmatic'] });
+    const physicalRecords: Array<Readonly<Record<string, unknown>>> = [];
+    const physicalService = Object.freeze({
+      register: vi.fn(
+        (_owner: object, registrations: readonly Readonly<Record<string, unknown>>[]) => {
+          physicalRecords.push(
+            ...registrations.map((registration) =>
+              Object.freeze({
+                ...registration,
+                navigationGeneration: Object.freeze({}),
+                domAliases: registration['domAliases'] ?? Object.freeze([]),
+              })
+            )
+          );
+          return Object.freeze({ ok: true as const, records: Object.freeze([...physicalRecords]) });
+        }
+      ),
+      snapshotRegisteredSlots: vi.fn(() => Object.freeze([...physicalRecords])),
+    });
+    const releasePhysical = slotCapability.attachPhysicalService(physicalService);
+    expect(physicalService.register).toHaveBeenCalledOnce();
+    expect(slotCapability.snapshot().map(({ registeredSlotId }) => registeredSlotId)).toEqual([
+      'programmatic',
+    ]);
+    releasePhysical();
+    expect(slotCapability.snapshot().map(({ registeredSlotId }) => registeredSlotId)).toEqual([
+      'programmatic',
+    ]);
+    const releaseContext = runtime.registerAuctionContext('permutive_context', () =>
+      Object.freeze({ permutive_segments: Object.freeze(['segment-one']) })
+    );
+    expect(releaseContext).toBeTypeOf('function');
+    const fetcher = vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () =>
+        Object.freeze({
+          id: 'auction-one',
+          cur: 'USD',
+          seatbid: Object.freeze([]),
+          ext: Object.freeze({
+            trusted_server: Object.freeze({
+              slot_results: Object.freeze({
+                version: 1,
+                auctionId: 'auction-one',
+                results: Object.freeze([
+                  Object.freeze({ slot: 'programmatic', outcome: 'no_bid' as const }),
+                ]),
+              }),
+            }),
+          }),
+        }),
+    } as Response);
+    await expect(direct.requestAds({ slots: ['programmatic'] })).resolves.toEqual({
+      slots: [{ slot: 'programmatic', path: 'primary', outcome: 'no_bid' }],
+    });
+    expect(JSON.parse(String(fetcher.mock.calls[0]?.[1]?.body))).toMatchObject({
+      config: { permutive_segments: ['segment-one'] },
+    });
+    fetcher.mockRestore();
+    releaseContext?.();
+
+    activationRelease.reverse().forEach((callback) => callback());
+    release.reverse().forEach((callback) => callback());
+    expect(() =>
+      direct.addAdUnits({
+        code: 'late',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      })
+    ).toThrow();
+  });
+
+  it('rejects renderer and APS-message registration until activation and removes exact registrations', () => {
+    const release: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    const runtime = Object.freeze({
+      attachAuctionContextService: () => () => undefined,
+      boot: () =>
+        Object.freeze({
+          auctionProjection: Object.freeze({
+            version: 1,
+            auction: Object.freeze({
+              version: 1,
+              auctionId: 'initial',
+              results: Object.freeze([]),
+            }),
+            slots: Object.freeze([]),
+            bids: Object.freeze([]),
+          }),
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: false,
+            gpt: Object.freeze({ active: false }),
+          }),
+          manifest: Object.freeze({
+            version: 1,
+            releaseId: RELEASE_ID,
+            firstDisplay: null,
+            runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'b'.repeat(64)}`,
+            integrations: Object.freeze([
+              Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+            ]),
+          }),
+        }),
+      document,
+      enqueue: () => true,
+      generation: Object.freeze({}),
+      protectFirstDisplayAttemptBatch: vi.fn(() => true),
+      registerAuctionContext: () => () => undefined,
+    } satisfies RuntimeCapabilityV1);
+    const prepared = createRenderRuntimeIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({ 'runtime.v1': runtime }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => release.push(callback),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+    const render = prepared.interfaces?.['render.v1'] as {
+      attachPucGamAttemptRegistrar: (registrar: (input: unknown) => boolean) => () => void;
+      createAttempt: (
+        owner: Readonly<Record<string, unknown>>
+      ) => Readonly<{ ok: boolean; value?: RenderAttempt }>;
+      createSlotOperation: (
+        input: Readonly<{ primary: RenderAttempt }>
+      ) => Readonly<{ ok: true; value: object }> | Readonly<{ ok: false; reason: string }>;
+      navigation: {
+        createAuctionBatch: (auctionId: string) =>
+          | {
+              createRenderAttempt: (
+                slot: string
+              ) => Readonly<{ ok: boolean; value?: Readonly<Record<string, unknown>> }>;
+            }
+          | undefined;
+      };
+      registerPucGamAttempt: (input: unknown) => boolean;
+      registerRenderer: (
+        type: 'aps',
+        renderer: (attempt: RenderAttempt, container: HTMLElement) => boolean
+      ) => () => void;
+    };
+    const messages = prepared.interfaces?.['messages.v1'] as {
+      messaging: {
+        parseProtocolMessage: (kind: 'apsEnvelope', candidate: unknown) => object | undefined;
+      };
+      registerApsValidation: (validation: Readonly<Record<string, unknown>>) => () => void;
+    };
+    const renderer = vi.fn(() => true);
+    const origin = window.location.origin;
+    const rendererUrl = new URL('/integrations/aps/renderer/v2', origin).href;
+    const validation = Object.freeze({
+      expectedPublisherOrigin: origin,
+      expectedRendererUrl: rendererUrl,
+      validateApsRenderer: vi.fn(() => true),
+    });
+    const envelope = Object.freeze({
+      version: 1,
+      nonce: `n1_${'a'.repeat(22)}`,
+      publisherOrigin: origin,
+      renderer: Object.freeze({
+        type: 'aps',
+        version: 1,
+        accountId: 'account',
+        bidId: 'bid',
+        tagType: 'iframe',
+        creativeUrl: 'https://example.test/creative',
+        width: 300,
+        height: 250,
+        aaxResponse: 'response',
+      }),
+    });
+
+    expect(() => render.registerRenderer('aps', renderer)).toThrow('inactive');
+    expect(() => render.attachPucGamAttemptRegistrar(() => true)).toThrow('unavailable');
+    expect(render.registerPucGamAttempt(Object.freeze({}))).toBe(false);
+    expect(() => messages.registerApsValidation(validation)).toThrow('inactive');
+    expect(messages.messaging.parseProtocolMessage('apsEnvelope', envelope)).toBeUndefined();
+
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    const batch = render.navigation.createAuctionBatch('cross-bundle-render-capability');
+    const owner = batch?.createRenderAttempt('slot-one');
+    expect(owner?.ok).toBe(true);
+    const attempt = render.createAttempt(owner?.value ?? Object.freeze({}));
+    expect(attempt.ok).toBe(true);
+    expect(render.createSlotOperation({ primary: attempt.value as RenderAttempt })).toMatchObject({
+      ok: true,
+    });
+    const hostileCause = new Error('publisher-owned validation trap');
+    const hostileValidation = new Proxy(Object.freeze({}), {
+      getPrototypeOf: () => {
+        throw hostileCause;
+      },
+    });
+    let validationError: unknown;
+    try {
+      messages.registerApsValidation(hostileValidation);
+    } catch (error) {
+      validationError = error;
+    }
+    expect(validationError).toBeInstanceOf(TypeError);
+    expect(validationError).toMatchObject({
+      message: 'APS message validation is malformed',
+      cause: hostileCause,
+    });
+    expect(Object.keys(validationError as object)).not.toContain('cause');
+    const pucAttempt = Object.freeze({ marker: 'exact-attempt' });
+    const pucRegistrar = vi.fn(() => true);
+    const releasePucRegistrar = render.attachPucGamAttemptRegistrar(pucRegistrar);
+    expect(render.registerPucGamAttempt(pucAttempt)).toBe(true);
+    expect(pucRegistrar).toHaveBeenCalledExactlyOnceWith(pucAttempt);
+    expect(() => render.attachPucGamAttemptRegistrar(() => true)).toThrow('duplicated');
+    releasePucRegistrar();
+    expect(render.registerPucGamAttempt(pucAttempt)).toBe(false);
+    const releaseThrowingPucRegistrar = render.attachPucGamAttemptRegistrar(() => {
+      throw new Error('contained GPT owner failure');
+    });
+    expect(render.registerPucGamAttempt(pucAttempt)).toBe(false);
+    const releaseRenderer = render.registerRenderer('aps', renderer);
+    const releaseValidation = messages.registerApsValidation(validation);
+    expect(messages.messaging.parseProtocolMessage('apsEnvelope', envelope)).toEqual(envelope);
+    expect(() => render.registerRenderer('aps', vi.fn())).toThrow('duplicated');
+    expect(() => messages.registerApsValidation(validation)).toThrow('duplicated');
+
+    releaseRenderer();
+    releaseValidation();
+    const replacementRenderer = vi.fn(() => false);
+    const releaseReplacement = render.registerRenderer('aps', replacementRenderer);
+    const releaseReplacementValidation = messages.registerApsValidation(validation);
+    releaseRenderer();
+    releaseValidation();
+    expect(() => render.registerRenderer('aps', vi.fn())).toThrow('duplicated');
+    expect(() => messages.registerApsValidation(validation)).toThrow('duplicated');
+
+    activationRelease.reverse().forEach((callback) => callback());
+    releaseThrowingPucRegistrar();
+    expect(render.registerPucGamAttempt(pucAttempt)).toBe(false);
+    expect(() => render.registerRenderer('aps', vi.fn())).toThrow('inactive');
+    expect(() => messages.registerApsValidation(validation)).toThrow('inactive');
+    expect(messages.messaging.parseProtocolMessage('apsEnvelope', envelope)).toBeUndefined();
+    releaseReplacement();
+    releaseReplacementValidation();
+    release.reverse().forEach((callback) => callback());
+  });
+
+  it('publishes the data-only render trace through the private capability and public diagnostics', () => {
+    const release: Array<() => void> = [];
+    const activationRelease: Array<() => void> = [];
+    const runtime = Object.freeze({
+      attachAuctionContextService: () => () => undefined,
+      boot: () =>
+        Object.freeze({
+          auctionProjection: Object.freeze({
+            version: 1,
+            auction: Object.freeze({
+              version: 1,
+              auctionId: 'initial',
+              results: Object.freeze([
+                Object.freeze({ slot: 'slot-one', outcome: 'no_bid' as const }),
+              ]),
+            }),
+            slots: Object.freeze([
+              Object.freeze({
+                slot: 'slot-one',
+                gamUnitPath: '/123/slot-one',
+                divId: 'slot-one',
+                formats: Object.freeze([Object.freeze([300, 250])]),
+                targeting: Object.freeze({}),
+              }),
+            ]),
+            bids: Object.freeze([]),
+          }),
+          diagnostics: Object.freeze({
+            version: 1,
+            renderTraceOverlay: true,
+            gpt: Object.freeze({ active: false }),
+          }),
+          manifest: Object.freeze({
+            version: 1,
+            releaseId: RELEASE_ID,
+            firstDisplay: null,
+            runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'b'.repeat(64)}`,
+            integrations: Object.freeze([
+              Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+            ]),
+          }),
+        }),
+      document,
+      enqueue: () => true,
+      generation: Object.freeze({}),
+      protectFirstDisplayAttemptBatch: vi.fn(() => true),
+      registerAuctionContext: () => () => undefined,
+    } satisfies RuntimeCapabilityV1);
+    const prepared = createRenderRuntimeIntegrationRegistration(RELEASE_ID).prepare(
+      Object.freeze({
+        config: undefined,
+        interfaces: Object.freeze({ 'runtime.v1': runtime }),
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => release.push(callback),
+      } satisfies IntegrationPrepareContext)
+    ) as PreparedIntegration;
+    const trace = prepared.interfaces?.['trace.v1'] as {
+      diagnostics: {
+        current: () => Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+      };
+      observations: { publish: (observation: Readonly<Record<string, unknown>>) => boolean };
+      record: (record: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>;
+    };
+    const tracePresentation = prepared.interfaces?.['trace.presentation.v1'] as {
+      attachPresentation: (factory: (source: object) => object) => () => void;
+    };
+    const direct = prepared.interfaces?.['direct.v1'] as {
+      diagnostics: { renderTrace: object };
+    };
+    const slots = prepared.interfaces?.['slots.v1'] as {
+      attachPhysicalService: (service: object) => () => void;
+    };
+    prepared.activate(
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: (callback: () => void) => activationRelease.push(callback),
+        afterCommit: vi.fn(),
+      } satisfies IntegrationActivationContext)
+    );
+    let physicalRecords: readonly Readonly<Record<string, unknown>>[] = Object.freeze([]);
+    const physicalService = Object.freeze({
+      register: (
+        owner: { generation: object },
+        registrations: readonly Readonly<Record<string, unknown>>[]
+      ) => {
+        physicalRecords = Object.freeze(
+          registrations.map((registration) =>
+            Object.freeze({
+              ...registration,
+              domAliases: registration['domAliases'] ?? Object.freeze([]),
+              navigationGeneration: owner.generation,
+              traceToken: 'gt1_1',
+            })
+          )
+        );
+        return Object.freeze({ ok: true as const, records: physicalRecords });
+      },
+      resolveDomAlias: (alias: string) =>
+        physicalRecords.find((record) =>
+          (record['domAliases'] as readonly string[]).includes(alias)
+        ),
+      resolveRegisteredSlot: (slotId: string) =>
+        physicalRecords.find((record) => record['registeredSlotId'] === slotId),
+      snapshotRegisteredSlots: () => physicalRecords,
+    });
+    const releasePhysicalService = slots.attachPhysicalService(physicalService);
+
+    expect(Reflect.ownKeys(trace)).toEqual([
+      'record',
+      'enrich',
+      'prune',
+      'diagnostics',
+      'observations',
+    ]);
+    expect(Object.isFrozen(trace)).toBe(true);
+    expect(Reflect.ownKeys(trace.observations)).toEqual(['publish']);
+    expect('attachPresentation' in trace).toBe(false);
+    expect(Reflect.ownKeys(tracePresentation)).toEqual(['attachPresentation']);
+    expect(Object.isFrozen(tracePresentation)).toBe(true);
+    expect(tracePresentation.attachPresentation).toBeTypeOf('function');
+    expect(direct.diagnostics.renderTrace).toBe(trace.diagnostics);
+    expect(document.getElementById('ts-render-trace-panel')).toBeNull();
+    expect(
+      trace.observations.publish(
+        Object.freeze({
+          kind: 'render_attempt',
+          attemptId: 'attempt-one',
+          slotId: 'slot-one',
+          path: 'auction',
+          rendered: true,
+          injected: true,
+          servedFrom: 'inline',
+          state: 'accepted',
+          outcome: Object.freeze({ outcome: 'accepted' }),
+        })
+      )
+    ).toBe(true);
+    expect(trace.diagnostics.current()['slot-one']).toMatchObject({
+      slotId: 'slot-one',
+      path: 'auction',
+      rendered: true,
+      injected: true,
+      servedFrom: 'inline',
+    });
+    expect(
+      trace.observations.publish(
+        Object.freeze({
+          kind: 'slotRequested',
+          slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'slot-one' }),
+        })
+      )
+    ).toBe(true);
+    expect(
+      trace.observations.publish(
+        Object.freeze({
+          kind: 'slotRenderEnded',
+          slot: Object.freeze({ token: 'gt1_1', cycleOrdinal: 1, elementId: 'slot-one' }),
+          isEmpty: false,
+        })
+      )
+    ).toBe(true);
+    expect(trace.diagnostics.current()['slot-one']).toMatchObject({
+      count: 2,
+      path: 'gam-refresh',
+      rendered: true,
+      servedFrom: 'gam',
+    });
+    expect(document.getElementById('ts-render-trace-panel')).toBeNull();
+
+    activationRelease.reverse().forEach((callback) => callback());
+    releasePhysicalService();
+    release.reverse().forEach((callback) => callback());
+    expect(trace.diagnostics.current()).toEqual({});
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/sourcepoint/index.test.ts b/crates/trusted-server-js/lib/test/integrations/sourcepoint/index.test.ts
index fc29e14c2..e640024d5 100644
--- a/crates/trusted-server-js/lib/test/integrations/sourcepoint/index.test.ts
+++ b/crates/trusted-server-js/lib/test/integrations/sourcepoint/index.test.ts
@@ -1,21 +1,14 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { mirrorSourcepointConsent } from '../../../src/integrations/sourcepoint';
-
-type SourcepointWindow = Window & {
-  __tsjs_sourcepoint?: {
-    rewriteSdk?: boolean;
-  };
-  __tsjs_installSourcepointGuard?: unknown;
-};
+import {
+  disposeSourcepointConsentMirror,
+  initializeSourcepointConsentMirror,
+  mirrorSourcepointConsent,
+} from '../../../src/integrations/sourcepoint/consent_mirror';
+import { createSourcepointRuntime } from '../../../src/integrations/sourcepoint/module';
 
 describe('Sourcepoint integration initialization', () => {
-  let win: SourcepointWindow;
-
   beforeEach(async () => {
-    win = window as SourcepointWindow;
-    delete win.__tsjs_sourcepoint;
-
     const guard = await import('../../../src/integrations/sourcepoint/script_guard');
     guard.resetGuardState();
   });
@@ -23,37 +16,22 @@ describe('Sourcepoint integration initialization', () => {
   afterEach(async () => {
     const guard = await import('../../../src/integrations/sourcepoint/script_guard');
     guard.resetGuardState();
-    delete win.__tsjs_sourcepoint;
-    delete win.__tsjs_installSourcepointGuard;
   });
 
   it('installs the guard when rewriteSdk is enabled', async () => {
-    vi.resetModules();
-    win.__tsjs_sourcepoint = { rewriteSdk: true };
-
     const guard = await import('../../../src/integrations/sourcepoint/script_guard');
-    await import('../../../src/integrations/sourcepoint/index');
+    const release = createSourcepointRuntime().activate(Object.freeze({ rewriteSdk: true }));
 
     expect(guard.isGuardInstalled()).toBe(true);
+    release();
   });
 
   it('skips the guard when rewriteSdk is disabled', async () => {
-    vi.resetModules();
-    win.__tsjs_sourcepoint = { rewriteSdk: false };
-
     const guard = await import('../../../src/integrations/sourcepoint/script_guard');
-    await import('../../../src/integrations/sourcepoint/index');
+    const release = createSourcepointRuntime().activate(Object.freeze({ rewriteSdk: false }));
 
     expect(guard.isGuardInstalled()).toBe(false);
-  });
-
-  it('defaults to installing the guard when rewriteSdk is missing for backward compatibility', async () => {
-    vi.resetModules();
-
-    const guard = await import('../../../src/integrations/sourcepoint/script_guard');
-    await import('../../../src/integrations/sourcepoint/index');
-
-    expect(guard.isGuardInstalled()).toBe(true);
+    release();
   });
 });
 
@@ -71,7 +49,7 @@ function sourcepointPayload(gppString = 'DBABLA~BVQqAAAAAgA.QA', applicableSecti
 describe('integrations/sourcepoint', () => {
   function clearAllCookies(): void {
     document.cookie.split(';').forEach((c) => {
-      const name = c.split('=')[0].trim();
+      const name = c.split('=')[0]?.trim() ?? '';
       if (name) document.cookie = `${name}=; path=/; Max-Age=0`;
     });
   }
@@ -83,11 +61,13 @@ describe('integrations/sourcepoint', () => {
 
   beforeEach(() => {
     // Clear cookies and localStorage before each test.
+    disposeSourcepointConsentMirror();
     clearAllCookies();
     localStorage.clear();
   });
 
   afterEach(() => {
+    disposeSourcepointConsentMirror();
     vi.useRealTimers();
     Object.defineProperty(document, 'readyState', { value: 'complete', configurable: true });
     clearAllCookies();
@@ -277,7 +257,7 @@ describe('integrations/sourcepoint', () => {
       JSON.stringify(sourcepointPayload('initial-gpp', [7]))
     );
 
-    mirrorSourcepointConsent();
+    initializeSourcepointConsentMirror();
     localStorage.setItem(
       '_sp_user_consent_12345',
       JSON.stringify(sourcepointPayload('updated-gpp', [8]))
@@ -294,7 +274,7 @@ describe('integrations/sourcepoint', () => {
       JSON.stringify(sourcepointPayload('initial-gpp', [7]))
     );
 
-    mirrorSourcepointConsent();
+    initializeSourcepointConsentMirror();
     localStorage.removeItem('_sp_user_consent_12345');
     window.dispatchEvent(new Event('focus'));
 
@@ -309,7 +289,7 @@ describe('integrations/sourcepoint', () => {
     localStorage.clear();
     clearAllCookies();
 
-    await import('../../../src/integrations/sourcepoint');
+    initializeSourcepointConsentMirror();
 
     localStorage.setItem(
       '_sp_user_consent_12345',
@@ -328,13 +308,13 @@ describe('integrations/sourcepoint', () => {
     clearAllCookies();
     Object.defineProperty(document, 'readyState', { value: 'loading', configurable: true });
 
-    const sourcepoint = await import('../../../src/integrations/sourcepoint');
+    initializeSourcepointConsentMirror();
 
     localStorage.setItem(
       '_sp_user_consent_12345',
       JSON.stringify(sourcepointPayload('manual-gpp', [7]))
     );
-    expect(sourcepoint.mirrorSourcepointConsent()).toBe(true);
+    expect(mirrorSourcepointConsent()).toBe(true);
 
     localStorage.setItem(
       '_sp_user_consent_12345',
@@ -354,7 +334,7 @@ describe('integrations/sourcepoint', () => {
     clearAllCookies();
     Object.defineProperty(document, 'readyState', { value: 'loading', configurable: true });
 
-    await import('../../../src/integrations/sourcepoint');
+    initializeSourcepointConsentMirror();
 
     localStorage.setItem(
       '_sp_user_consent_12345',
diff --git a/crates/trusted-server-js/lib/test/integrations/sourcepoint/module.test.ts b/crates/trusted-server-js/lib/test/integrations/sourcepoint/module.test.ts
new file mode 100644
index 000000000..0a582b508
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/sourcepoint/module.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createSourcepointIntegrationRegistration,
+  createSourcepointRuntime,
+} from '../../../src/integrations/sourcepoint/module';
+import { createIntegrationRegistry } from '../../../src/kernel/integration_registry';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+const SOURCEPOINT_INTEGRATION_ID = 'sourcepoint_consent';
+
+describe('transactional Sourcepoint integration module', () => {
+  it.each([true, false])(
+    'owns the optional SDK guard and consent mirror when rewriteSdk=%s',
+    (rewriteSdk) => {
+      const order: string[] = [];
+      const runtime = createSourcepointRuntime({
+        initializeConsentMirror: () => order.push('start:consent'),
+        installGuard: () => order.push('activate:guard'),
+        resetConsentMirror: () => order.push('dispose:consent'),
+        resetGuard: () => order.push('dispose:guard'),
+      });
+      const config = Object.freeze({ rewriteSdk });
+
+      const release = runtime.activate(config);
+      runtime.start(config);
+      release();
+      release();
+
+      expect(order).toEqual(
+        rewriteSdk
+          ? ['activate:guard', 'start:consent', 'dispose:consent', 'dispose:guard']
+          : ['start:consent', 'dispose:consent']
+      );
+    }
+  );
+
+  it.each([
+    ['missing', undefined],
+    ['mutable', { rewriteSdk: true }],
+    ['wrong type', Object.freeze({ rewriteSdk: 'yes' })],
+    ['extra', Object.freeze({ rewriteSdk: true, legacy: true })],
+  ])('rejects %s boot config before activation', async (_name, config) => {
+    const activate = vi.fn(() => vi.fn());
+    const registry = createIntegrationRegistry({
+      manifest: {
+        version: 1,
+        releaseId: RELEASE_ID,
+        firstDisplay: null,
+        runtimeSrc: RUNTIME_SRC,
+        integrations: [{ id: SOURCEPOINT_INTEGRATION_ID, phase: 'takeover' }],
+      },
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze([SOURCEPOINT_INTEGRATION_ID]),
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config,
+        interfaces: Object.freeze({
+          [SOURCEPOINT_INTEGRATION_ID]: Object.freeze({ activate, start: vi.fn() }),
+        }),
+      }),
+    });
+    registry.register(createSourcepointIntegrationRegistration(RELEASE_ID));
+
+    await expect(
+      registry.install({ activateCore: vi.fn(), publish: vi.fn(), drainPreload: vi.fn() })
+    ).resolves.toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(activate).not.toHaveBeenCalled();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/integrations/testlight/module.test.ts b/crates/trusted-server-js/lib/test/integrations/testlight/module.test.ts
new file mode 100644
index 000000000..136f2b60f
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/integrations/testlight/module.test.ts
@@ -0,0 +1,123 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createTestlightRuntime } from '../../../src/integrations/testlight/module';
+
+describe('transactional Testlight integration module', () => {
+  it('bridges preexisting and later callbacks once while isolating invalid and throwing work', () => {
+    const calls: string[] = [];
+    const first = () => calls.push('first');
+    const throwing = () => {
+      calls.push('throwing');
+      throw new Error('publisher callback failed');
+    };
+    const second = () => calls.push('second');
+    const beforeCommit = () => calls.push('before-commit');
+    const afterCommit = () => calls.push('after-commit');
+    const original = [first, 'invalid', throwing, second];
+    const target = { testlight: { publisher: true, que: original } };
+    const enqueue = vi.fn((callback: () => void) => callback());
+    const runtime = createTestlightRuntime({ enqueue, started: vi.fn(), target });
+
+    const release = runtime.activate(undefined);
+    target.testlight.que.push(beforeCommit);
+    expect(calls).toEqual([]);
+
+    runtime.start(undefined);
+    target.testlight.que.push(afterCommit);
+
+    expect(calls).toEqual(['first', 'throwing', 'second', 'before-commit', 'after-commit']);
+    expect(enqueue).toHaveBeenCalledTimes(5);
+    release();
+    release();
+    expect(target.testlight).toEqual({ publisher: true, que: original });
+  });
+
+  it('returns callbacks added during activation to the publisher queue on rollback', () => {
+    const original = [vi.fn()];
+    const later = vi.fn();
+    const target = { testlight: { que: original } };
+    const runtime = createTestlightRuntime({
+      enqueue: vi.fn(),
+      started: vi.fn(),
+      target,
+    });
+
+    const release = runtime.activate(undefined);
+    target.testlight.que.push(later);
+    release();
+
+    expect(target.testlight.que).toBe(original);
+    expect(original).toEqual([expect.any(Function), later]);
+  });
+
+  it('returns the captured native push result after forwarding a later callback', () => {
+    const callback = vi.fn();
+    const target = { testlight: { que: [] as unknown[] } };
+    const runtime = createTestlightRuntime({
+      enqueue: (candidate) => candidate(),
+      started: vi.fn(),
+      target,
+    });
+
+    const release = runtime.activate(undefined);
+    runtime.start(undefined);
+
+    expect(target.testlight.que.push(callback)).toBe(1);
+    expect(callback).toHaveBeenCalledOnce();
+    expect(target.testlight.que).toHaveLength(0);
+
+    release();
+  });
+
+  it('does not overwrite a publisher queue replacement during disposal', () => {
+    const target = { testlight: { que: [] as unknown[] } };
+    const runtime = createTestlightRuntime({
+      enqueue: vi.fn(),
+      started: vi.fn(),
+      target,
+    });
+    const release = runtime.activate(undefined);
+    const replacement: unknown[] = [];
+    target.testlight.que = replacement;
+
+    release();
+
+    expect(target.testlight.que).toBe(replacement);
+  });
+
+  it('preserves publisher fields added to a runtime-created global', () => {
+    const target: { testlight?: { publisher?: boolean; que?: unknown[] } } = {};
+    const runtime = createTestlightRuntime({
+      enqueue: vi.fn(),
+      started: vi.fn(),
+      target,
+    });
+    const release = runtime.activate(undefined);
+    if (!target.testlight) throw new Error('should create the Testlight global');
+    target.testlight.publisher = true;
+
+    release();
+
+    expect(target.testlight).toEqual({ publisher: true });
+  });
+
+  it('snapshots queue data without invoking a publisher iterator', () => {
+    const callback = vi.fn();
+    const original = [callback];
+    Object.defineProperty(original, Symbol.iterator, {
+      configurable: true,
+      value: () => {
+        throw new Error('publisher iterator must remain inert');
+      },
+    });
+    const target = { testlight: { que: original } };
+    const enqueue = vi.fn((candidate: () => void) => candidate());
+    const runtime = createTestlightRuntime({ enqueue, started: vi.fn(), target });
+
+    const release = runtime.activate(undefined);
+    expect(() => runtime.start(undefined)).not.toThrow();
+
+    expect(callback).toHaveBeenCalledOnce();
+    release();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/diagnostics.test.ts b/crates/trusted-server-js/lib/test/kernel/diagnostics.test.ts
new file mode 100644
index 000000000..6702a1d1d
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/diagnostics.test.ts
@@ -0,0 +1,234 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createDiagnosticsIngress,
+  type DiagnosticsObservation,
+} from '../../src/kernel/diagnostics';
+
+function scalarRecord(valueCount: number): Record<string, unknown> {
+  return Object.fromEntries(
+    Array.from({ length: valueCount }, (_, index) => [`value${index}`, index])
+  );
+}
+
+function nestedRecord(depth: number): Record<string, unknown> {
+  const root: Record<string, unknown> = {};
+  let cursor = root;
+  for (let index = 0; index < depth; index += 1) {
+    const child: Record<string, unknown> = {};
+    cursor['child'] = child;
+    cursor = child;
+  }
+  return root;
+}
+
+function primitiveLeafRecord(depth: number, value: unknown): Record<string, unknown> {
+  const root: Record<string, unknown> = {};
+  let cursor = root;
+  for (let currentDepth = 1; currentDepth < depth; currentDepth += 1) {
+    const child: Record<string, unknown> = {};
+    cursor['child'] = child;
+    cursor = child;
+  }
+  cursor['leaf'] = value;
+  return root;
+}
+
+describe('kernel diagnostics ingress', () => {
+  it('exposes only the exact frozen core-owned facade', () => {
+    const ingress = createDiagnosticsIngress({ reduce: vi.fn() });
+
+    expect(Object.isFrozen(ingress)).toBe(true);
+    expect(Reflect.ownKeys(ingress).sort()).toEqual(['dispose', 'publish']);
+    expect('subscribe' in ingress).toBe(false);
+    expect('consumerIds' in ingress).toBe(false);
+    expect('capacity' in ingress).toBe(false);
+    expect('queue' in ingress).toBe(false);
+    expect('scheduler' in ingress).toBe(false);
+    expect('timer' in ingress).toBe(false);
+    expect('overflow' in ingress).toBe(false);
+  });
+
+  it('copies ordinary and null-prototype data trees into fresh deeply frozen values', () => {
+    const reduced: DiagnosticsObservation[] = [];
+    const ingress = createDiagnosticsIngress({
+      reduce: (observation) => reduced.push(observation),
+    });
+    const nested = Object.assign(Object.create(null) as Record<string, unknown>, {
+      label: '診断✓',
+    });
+    const array = [nested, null, true, 3.25];
+    const candidate = { array, name: 'publisher-value' };
+
+    expect(ingress.publish(candidate)).toBe(true);
+    expect(reduced).toHaveLength(1);
+    const accepted = reduced[0]!;
+    expect(accepted).not.toBe(candidate);
+    expect(Object.getPrototypeOf(accepted)).toBeNull();
+    expect(Object.isFrozen(accepted)).toBe(true);
+    expect(accepted['array']).not.toBe(array);
+    expect(Object.isFrozen(accepted['array'])).toBe(true);
+    const acceptedArray = accepted['array'] as readonly unknown[];
+    expect(acceptedArray[0]).not.toBe(nested);
+    expect(Object.getPrototypeOf(acceptedArray[0])).toBeNull();
+    expect(Object.isFrozen(acceptedArray[0])).toBe(true);
+    expect(acceptedArray).toEqual([{ label: '診断✓' }, null, true, 3.25]);
+  });
+
+  it('accepts exactly 512 nodes and rejects 513 before reducer entry', () => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+
+    expect(ingress.publish(scalarRecord(510))).toBe(true);
+    expect(ingress.publish(scalarRecord(511))).toBe(true);
+    expect(ingress.publish(scalarRecord(512))).toBe(false);
+    expect(reduce).toHaveBeenCalledTimes(2);
+  });
+
+  it('accepts depth sixteen and rejects depth seventeen before reducer entry', () => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+
+    expect(ingress.publish(nestedRecord(15))).toBe(true);
+    expect(ingress.publish(nestedRecord(16))).toBe(true);
+    expect(ingress.publish(nestedRecord(17))).toBe(false);
+    expect(reduce).toHaveBeenCalledTimes(2);
+  });
+
+  it.each([
+    [15, null, true],
+    [16, false, true],
+    [16, 42.25, true],
+    [16, '診断✓', true],
+    [17, null, false],
+    [17, false, false],
+    [17, 42.25, false],
+    [17, '診断✓', false],
+  ])('enforces the depth boundary for primitive leaf depth %i', (depth, value, accepted) => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+
+    expect(ingress.publish(primitiveLeafRecord(depth, value))).toBe(accepted);
+    expect(reduce).toHaveBeenCalledTimes(accepted ? 1 : 0);
+  });
+
+  it('enforces UTF-8 property-name and string byte limits including multibyte input', () => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+    const property127 = 'a'.repeat(127);
+    const property128 = 'é'.repeat(64);
+    const property129 = `${'é'.repeat(64)}a`;
+    const string4095 = 'a'.repeat(4095);
+    const string4096 = 'é'.repeat(2048);
+    const string4097 = `${'é'.repeat(2048)}a`;
+
+    expect(ingress.publish({ [property127]: string4095 })).toBe(true);
+    expect(ingress.publish({ [property128]: string4096 })).toBe(true);
+    expect(ingress.publish({ [property129]: 'value' })).toBe(false);
+    expect(ingress.publish({ value: string4097 })).toBe(false);
+    expect(reduce).toHaveBeenCalledTimes(2);
+  });
+
+  it.each([
+    ['sparse array', Object.assign(new Array(2), { 0: 'first' })],
+    ['array extra property', Object.assign(['first'], { extra: true })],
+    ['undefined', { value: undefined }],
+    // @ts-expect-error The runtime supports this hostile input even though the build target does not.
+    ['bigint', { value: 1n }],
+    ['function', { value: () => undefined }],
+    ['symbol value', { value: Symbol('fictional') }],
+    ['nonfinite number', { value: Number.POSITIVE_INFINITY }],
+    ['custom prototype', Object.freeze(new (class FictionalValue {})())],
+  ])('rejects %s values before reducer entry', (_label, candidate) => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+
+    expect(ingress.publish(candidate as Record<string, unknown>)).toBe(false);
+    expect(reduce).not.toHaveBeenCalled();
+  });
+
+  it('rejects aliases, cycles, accessors, symbols, and non-enumerable record fields', () => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+    const shared = { value: true };
+    const cycle: Record<string, unknown> = {};
+    cycle['self'] = cycle;
+    const accessor = Object.defineProperty({}, 'value', {
+      enumerable: true,
+      get: vi.fn(() => true),
+    });
+    const symbol = Object.defineProperty({}, Symbol('fictional'), {
+      enumerable: true,
+      value: true,
+    });
+    const hidden = Object.defineProperty({}, 'hidden', {
+      enumerable: false,
+      value: true,
+    });
+
+    expect(ingress.publish({ first: shared, second: shared })).toBe(false);
+    expect(ingress.publish(cycle)).toBe(false);
+    expect(ingress.publish(accessor)).toBe(false);
+    expect(ingress.publish(symbol)).toBe(false);
+    expect(ingress.publish(hidden)).toBe(false);
+    expect(reduce).not.toHaveBeenCalled();
+  });
+
+  it('fails closed on hostile reflection and injected copy or freeze failures', () => {
+    const reduce = vi.fn();
+    const reportError = vi.fn(() => {
+      throw new Error('fictional reporter failure');
+    });
+    const ingress = createDiagnosticsIngress({ reduce, reportError });
+    const hostile = new Proxy(
+      {},
+      {
+        getPrototypeOf: () => {
+          throw new Error('fictional prototype trap');
+        },
+      }
+    );
+
+    expect(() => ingress.publish(hostile)).not.toThrow();
+    expect(ingress.publish(hostile)).toBe(false);
+    const defineProperty = vi.spyOn(Object, 'defineProperty').mockImplementationOnce(() => {
+      throw new Error('fictional copy failure');
+    });
+    expect(ingress.publish({ acceptedShape: true })).toBe(false);
+    defineProperty.mockRestore();
+    const freeze = vi.spyOn(Object, 'freeze').mockImplementationOnce(() => {
+      throw new Error('fictional freeze failure');
+    });
+    expect(ingress.publish({ acceptedShape: true })).toBe(false);
+    freeze.mockRestore();
+    expect(reduce).not.toHaveBeenCalled();
+  });
+
+  it('returns true after acceptance even when reducer and reporter throw', () => {
+    const reportError = vi.fn(() => {
+      throw new Error('fictional reporter failure');
+    });
+    const ingress = createDiagnosticsIngress({
+      reduce: () => {
+        throw new Error('fictional reducer failure');
+      },
+      reportError,
+    });
+
+    expect(() => ingress.publish({ accepted: true })).not.toThrow();
+    expect(ingress.publish({ accepted: true })).toBe(true);
+    expect(reportError).toHaveBeenCalledTimes(2);
+  });
+
+  it('disposes idempotently and makes retained runtime publishers inert', () => {
+    const reduce = vi.fn();
+    const ingress = createDiagnosticsIngress({ reduce });
+    const retainedPublish = ingress.publish;
+
+    expect(retainedPublish({ sequence: 1 })).toBe(true);
+    ingress.dispose();
+    ingress.dispose();
+    expect(retainedPublish({ sequence: 2 })).toBe(false);
+    expect(reduce).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/disposable.test.ts b/crates/trusted-server-js/lib/test/kernel/disposable.test.ts
new file mode 100644
index 000000000..bfb60dd66
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/disposable.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { DisposableStack, TerminalLatch } from '../../src/kernel/disposable';
+
+describe('DisposableStack', () => {
+  it('aborts and disposes in reverse order exactly once while isolating failures', () => {
+    const calls: string[] = [];
+    const errors: unknown[] = [];
+    const stack = new DisposableStack((error) => errors.push(error));
+
+    stack.onDispose(() => calls.push('first'));
+    stack.onDispose(() => {
+      calls.push('second');
+      throw new Error('fictional disposer failure');
+    });
+    stack.onDispose(() => calls.push('third'));
+    stack.signal.addEventListener('abort', () => calls.push('abort'));
+
+    stack.dispose();
+    stack.dispose();
+
+    expect(stack.disposed).toBe(true);
+    expect(stack.signal.aborted).toBe(true);
+    expect(calls).toEqual(['abort', 'third', 'second', 'first']);
+    expect(errors).toHaveLength(1);
+  });
+
+  it('runs a disposer registered after disposal immediately and isolates its failure', () => {
+    const calls: string[] = [];
+    const onError = vi.fn();
+    const stack = new DisposableStack(onError);
+    stack.dispose();
+
+    stack.onDispose(() => calls.push('late'));
+    stack.onDispose(() => {
+      throw new Error('late fictional failure');
+    });
+
+    expect(calls).toEqual(['late']);
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+
+  it('observes a rejecting async disposer without delaying terminal disposal', async () => {
+    const onError = vi.fn();
+    const stack = new DisposableStack(onError);
+    stack.onDispose(async () => {
+      throw new Error('fictional async disposer failure');
+    });
+
+    stack.dispose();
+
+    expect(stack.disposed).toBe(true);
+    expect(stack.signal.aborted).toBe(true);
+    await vi.waitFor(() => expect(onError).toHaveBeenCalledTimes(1));
+  });
+});
+
+describe('TerminalLatch', () => {
+  it('lets only the first terminal result win and disposes before completion', async () => {
+    const events: string[] = [];
+    const latch = new TerminalLatch<{ outcome: string }>();
+    latch.onDispose(() => events.push('disposed'));
+    latch.completion.then(() => events.push('completed'));
+
+    expect(latch.trySettle({ outcome: 'accepted' })).toBe(true);
+    expect(latch.trySettle({ outcome: 'failed' })).toBe(false);
+    expect(latch.terminal).toBe(true);
+    expect(latch.value).toEqual({ outcome: 'accepted' });
+    await expect(latch.completion).resolves.toEqual({ outcome: 'accepted' });
+    expect(events).toEqual(['disposed', 'completed']);
+  });
+
+  it('supports undefined as a terminal value without reopening the latch', async () => {
+    const latch = new TerminalLatch<undefined>();
+
+    expect(latch.trySettle(undefined)).toBe(true);
+    expect(latch.terminal).toBe(true);
+    expect(latch.trySettle(undefined)).toBe(false);
+    await expect(latch.completion).resolves.toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/fallback.test.ts b/crates/trusted-server-js/lib/test/kernel/fallback.test.ts
new file mode 100644
index 000000000..a899198d9
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/fallback.test.ts
@@ -0,0 +1,332 @@
+import { describe, expect, it } from 'vitest';
+
+import { snapshotTsjsBootV1 } from '../../src/core/contracts/boot';
+import {
+  buildFallbackBoot,
+  buildKernelBoot,
+  trustedArtifactOrigin,
+} from '../../src/kernel/fallback';
+
+const RELEASE_ID = 'a'.repeat(64);
+const TRUSTED_RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'d'.repeat(64)}`;
+
+function opaqueDocument(stamp: PropertyDescriptor | undefined): Document {
+  const view = { location: { origin: 'null' } } as Record<string, unknown>;
+  if (stamp) Object.defineProperty(view, '__tsCreativeOrigin', stamp);
+  return { defaultView: view } as unknown as Document;
+}
+
+describe('takeover artifact origin', () => {
+  it('accepts only the immutable own-data creative stamp for an opaque document', () => {
+    expect(
+      trustedArtifactOrigin(
+        opaqueDocument({
+          configurable: false,
+          enumerable: false,
+          value: 'https://publisher.example',
+          writable: false,
+        })
+      )
+    ).toBe('https://publisher.example');
+  });
+
+  it.each([
+    undefined,
+    { configurable: true, enumerable: false, value: 'https://publisher.example', writable: false },
+    { configurable: false, enumerable: false, value: 'https://publisher.example', writable: true },
+    { configurable: false, enumerable: true, value: 'https://publisher.example', writable: false },
+    { configurable: false, enumerable: false, get: () => 'https://publisher.example' },
+    {
+      configurable: false,
+      enumerable: false,
+      value: 'https://attacker.example/path',
+      writable: false,
+    },
+  ])('rejects an absent, mutable, accessor-backed, or non-origin creative stamp', (stamp) => {
+    expect(trustedArtifactOrigin(opaqueDocument(stamp))).toBeUndefined();
+  });
+});
+
+function manifest(ids: readonly string[]) {
+  return {
+    version: 1 as const,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) =>
+      id === 'diagnostics_presentation'
+        ? {
+            id,
+            phase: 'deferred' as const,
+            trigger: 'first_display_or_idle' as const,
+            src: `/static/tsjs=tsjs-${id}.min.js?v=${'d'.repeat(64)}`,
+          }
+        : { id, phase: 'takeover' as const }
+    ),
+  };
+}
+
+function boot(
+  creative: unknown,
+  diagnostics: Readonly<{
+    renderTraceOverlay: boolean;
+    gptActive: boolean;
+  }> = { renderTraceOverlay: false, gptActive: false }
+) {
+  return {
+    auctionProjection: {
+      version: 1,
+      auction: { version: 1, auctionId: 'initial', results: [] },
+      slots: [],
+      bids: [],
+    },
+    integrations: { version: 1, entries: [] },
+    creative,
+    diagnostics: {
+      version: 1,
+      renderTraceOverlay: diagnostics.renderTraceOverlay,
+      gpt: { active: diagnostics.gptActive },
+    },
+  };
+}
+
+function completeBoot(
+  ids: readonly string[],
+  creative: unknown,
+  diagnostics?: Readonly<{ renderTraceOverlay: boolean; gptActive: boolean }>
+) {
+  return snapshotTsjsBootV1(
+    {
+      abi: 1,
+      releaseId: RELEASE_ID,
+      manifest: manifest(ids),
+      ...boot(creative, diagnostics),
+    },
+    RELEASE_ID
+  );
+}
+
+describe('kernel boot creative ABI', () => {
+  it.each([
+    { version: 1, enabled: false, clickGuard: true, renderGuard: false },
+    { version: 1, enabled: false, clickGuard: false, renderGuard: true },
+  ])('rejects disabled creative with an enabled guard bit', (creative) => {
+    expect(completeBoot([], creative)).toBeUndefined();
+  });
+
+  it('rejects a null-prototype creative record', () => {
+    const creative = Object.assign(Object.create(null) as object, {
+      version: 1,
+      enabled: false,
+      clickGuard: false,
+      renderGuard: false,
+    });
+
+    expect(completeBoot([], creative)).toBeUndefined();
+  });
+
+  it.each([
+    ['enabled no-guard creative with a manifest member', true, ['creative']],
+    ['enabled creative with duplicate manifest members', true, ['creative', 'creative']],
+    ['disabled creative with a manifest member', false, ['creative']],
+  ] as const)('rejects %s', (_caseName, enabled, ids) => {
+    expect(
+      completeBoot(ids, { version: 1, enabled, clickGuard: false, renderGuard: false })
+    ).toBeUndefined();
+  });
+
+  it('accepts enabled creative with both guards false without a manifest member', () => {
+    const snapshot = completeBoot([], {
+      version: 1,
+      enabled: true,
+      clickGuard: false,
+      renderGuard: false,
+    });
+    const accepted = snapshot
+      ? buildKernelBoot(RELEASE_ID, snapshot.manifest, snapshot)
+      : undefined;
+
+    expect(accepted?.creative).toEqual({
+      version: 1,
+      enabled: true,
+      clickGuard: false,
+      renderGuard: false,
+    });
+    expect(Object.isFrozen(accepted?.creative)).toBe(true);
+  });
+});
+
+describe('terminal fallback boot manifest', () => {
+  it('constructs the exact safe manifest from the independently trusted takeover source', () => {
+    const fallback = buildFallbackBoot(RELEASE_ID, TRUSTED_RUNTIME_SRC) as {
+      readonly manifest: unknown;
+    };
+
+    expect(fallback.manifest).toEqual({
+      version: 1,
+      releaseId: RELEASE_ID,
+      firstDisplay: null,
+      runtimeSrc: TRUSTED_RUNTIME_SRC,
+      integrations: [],
+    });
+  });
+
+  it('refuses to construct a fallback boot without an independently trusted takeover source', () => {
+    expect(buildFallbackBoot(RELEASE_ID, undefined as never)).toBeUndefined();
+  });
+
+  it('publishes the exact phase-aware fallback manifest with the accepted takeover source', () => {
+    const acceptedManifest = manifest(['render_runtime', 'diagnostics_presentation']);
+    const fallback = buildFallbackBoot(RELEASE_ID, acceptedManifest.runtimeSrc) as {
+      readonly manifest: unknown;
+    };
+
+    expect(fallback.manifest).toEqual({
+      version: 1,
+      releaseId: RELEASE_ID,
+      firstDisplay: null,
+      runtimeSrc: acceptedManifest.runtimeSrc,
+      integrations: [],
+    });
+    expect(Reflect.ownKeys(fallback.manifest as object).sort()).toEqual([
+      'firstDisplay',
+      'integrations',
+      'releaseId',
+      'runtimeSrc',
+      'version',
+    ]);
+    expect(Object.isFrozen(fallback.manifest)).toBe(true);
+  });
+});
+
+describe('kernel boot diagnostics presentation membership', () => {
+  const disabledCreative = Object.freeze({
+    version: 1,
+    enabled: false,
+    clickGuard: false,
+    renderGuard: false,
+  });
+
+  it.each([
+    { renderTraceOverlay: false, gptActive: false, presentation: false },
+    { renderTraceOverlay: true, gptActive: false, presentation: true },
+    { renderTraceOverlay: false, gptActive: true, presentation: true },
+    { renderTraceOverlay: true, gptActive: true, presentation: true },
+  ])(
+    'accepts diagnostics_presentation iff overlay=$renderTraceOverlay or GPT=$gptActive',
+    ({ renderTraceOverlay, gptActive, presentation }) => {
+      const ids = [
+        ...(gptActive ? ['gpt_diagnostics'] : []),
+        ...(presentation ? ['diagnostics_presentation'] : []),
+      ];
+
+      const snapshot = completeBoot(ids, disabledCreative, { renderTraceOverlay, gptActive });
+      expect(snapshot).toBeDefined();
+      expect(
+        snapshot ? buildKernelBoot(RELEASE_ID, snapshot.manifest, snapshot) : undefined
+      ).toBeDefined();
+    }
+  );
+
+  it.each([
+    { renderTraceOverlay: false, gptActive: false, presentation: true },
+    { renderTraceOverlay: true, gptActive: false, presentation: false },
+    { renderTraceOverlay: false, gptActive: true, presentation: false },
+    { renderTraceOverlay: true, gptActive: true, presentation: false },
+  ])(
+    'rejects the inverse diagnostics_presentation membership for overlay=$renderTraceOverlay and GPT=$gptActive',
+    ({ renderTraceOverlay, gptActive, presentation }) => {
+      const ids = [
+        ...(gptActive ? ['gpt_diagnostics'] : []),
+        ...(presentation ? ['diagnostics_presentation'] : []),
+      ];
+
+      expect(
+        completeBoot(ids, disabledCreative, { renderTraceOverlay, gptActive })
+      ).toBeUndefined();
+    }
+  );
+
+  it('accepts the complete server-shaped phase-aware boot manifest', () => {
+    const expectedManifest = manifest(['render_runtime']);
+    const candidate = snapshotTsjsBootV1(
+      {
+        abi: 1,
+        releaseId: RELEASE_ID,
+        manifest: expectedManifest,
+        ...boot(disabledCreative),
+      },
+      RELEASE_ID
+    );
+
+    expect(candidate).toBeDefined();
+    expect(buildKernelBoot(RELEASE_ID, candidate!.manifest, candidate)).toBeDefined();
+  });
+
+  it.each([
+    [19, true],
+    [20, true],
+    [21, false],
+  ] as const)('accepts at most %i complete server manifest integrations', (count, accepted) => {
+    const expectedManifest = manifest(
+      Array.from({ length: count }, (_, index) => `integration_${index + 1}`)
+    );
+    const candidate = snapshotTsjsBootV1(
+      {
+        abi: 1,
+        releaseId: RELEASE_ID,
+        manifest: expectedManifest,
+        ...boot(disabledCreative),
+      },
+      RELEASE_ID
+    );
+
+    expect(
+      candidate ? buildKernelBoot(RELEASE_ID, candidate.manifest, candidate) !== undefined : false
+    ).toBe(accepted);
+  });
+
+  it('rejects a complete boot whose phase-aware manifest differs from the accepted manifest', () => {
+    const expectedManifest = manifest(['render_runtime']);
+    const candidateManifest = {
+      ...expectedManifest,
+      runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'e'.repeat(64)}`,
+    };
+
+    expect(
+      buildKernelBoot(RELEASE_ID, expectedManifest, {
+        abi: 1,
+        releaseId: RELEASE_ID,
+        manifest: candidateManifest,
+        ...boot(disabledCreative),
+      })
+    ).toBeUndefined();
+  });
+
+  it.each(['diagnostics root', 'diagnostics GPT child'] as const)(
+    'rejects a null-prototype %s',
+    (target) => {
+      const candidate = boot(disabledCreative);
+      const diagnostics =
+        target === 'diagnostics root'
+          ? Object.assign(Object.create(null) as object, candidate.diagnostics)
+          : {
+              ...candidate.diagnostics,
+              gpt: Object.assign(Object.create(null) as object, candidate.diagnostics.gpt),
+            };
+
+      expect(
+        snapshotTsjsBootV1(
+          {
+            abi: 1,
+            releaseId: RELEASE_ID,
+            manifest: manifest([]),
+            ...candidate,
+            diagnostics,
+          },
+          RELEASE_ID
+        )
+      ).toBeUndefined();
+    }
+  );
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/identity.test.ts b/crates/trusted-server-js/lib/test/kernel/identity.test.ts
new file mode 100644
index 000000000..82876fb83
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/identity.test.ts
@@ -0,0 +1,330 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createBrowserNavigationIdentityIssuer,
+  createFirstDisplayNavigationIdentityIssuerFromSource,
+  createTestNavigationIdentityIssuer,
+  mintTestBootstrapNonce,
+  mintTestLifecycleTicket,
+  mintTestRendererNonce,
+  type RandomValuesSource,
+} from '../../src/kernel/identity';
+
+function decodeIdentity(value: string): Buffer {
+  return Buffer.from(value.slice(3), 'base64url');
+}
+
+function deterministicSource(bytes: readonly number[]): {
+  readonly source: RandomValuesSource;
+  readonly calls: ReturnType<typeof vi.fn>;
+} {
+  let offset = 0;
+  const calls = vi.fn((target: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer> => {
+    for (let index = 0; index < target.length; index += 1) {
+      target[index] = bytes[offset % bytes.length] ?? 0;
+      offset += 1;
+    }
+    return target;
+  });
+  return { source: calls, calls };
+}
+
+describe('navigation identity issuer', () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it('draws one eight-byte prefix and increments a big-endian u64 ordinal once per attempt', () => {
+    const { source, calls } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createTestNavigationIdentityIssuer({ getRandomValues: source });
+
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+
+    const first = created.value.mintAttemptId();
+    const second = created.value.mintAttemptId();
+
+    expect(first).toEqual({ ok: true, value: 'a1_AAECAwQFBgcAAAAAAAAAAQ' });
+    expect(second).toEqual({ ok: true, value: 'a1_AAECAwQFBgcAAAAAAAAAAg' });
+    expect(first.ok && decodeIdentity(first.value)).toEqual(
+      Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 1])
+    );
+    expect(second.ok && decodeIdentity(second.value)).toEqual(
+      Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 2])
+    );
+    expect(first.ok && first.value).toHaveLength(25);
+    expect(second.ok && second.value).toHaveLength(25);
+    expect(calls).toHaveBeenCalledOnce();
+    expect(calls.mock.calls[0]?.[0]).toHaveLength(8);
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0, 2]);
+  });
+
+  it('uses the compact initial-display issuer for the same bounded wire identities', () => {
+    const { source, calls } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createFirstDisplayNavigationIdentityIssuerFromSource(source);
+
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an initial-display identity issuer');
+
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+    });
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_AAECAwQFBgcAAAAAAAAAAg',
+    });
+    expect(created.value.snapshotPrefix()).toBe('AAECAwQFBgc');
+    expect(calls).toHaveBeenCalledOnce();
+    expect(calls.mock.calls[0]?.[0]).toHaveLength(8);
+  });
+
+  it('adopts the next first-display ordinal once before minting', () => {
+    const { source } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createTestNavigationIdentityIssuer({ getRandomValues: source });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+
+    expect(created.value.adoptNextAttemptOrdinal(9)).toBe(true);
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_AAECAwQFBgcAAAAAAAAACQ',
+    });
+    expect(created.value.adoptNextAttemptOrdinal(10)).toBe(false);
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0, 9]);
+  });
+
+  it('adopts the exact first-display prefix and next ordinal as one state transition', () => {
+    const { source } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createTestNavigationIdentityIssuer({ getRandomValues: source });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+
+    expect(created.value.adoptFirstDisplayState('CAcGBQQDAgE', 9)).toBe(true);
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_CAcGBQQDAgEAAAAAAAAACQ',
+    });
+    expect(created.value.adoptFirstDisplayState('AAECAwQFBgc', 10)).toBe(false);
+  });
+
+  it('owns an immutable copy of the source-filled navigation prefix', () => {
+    let sourceBuffer: Uint8Array<ArrayBuffer> | undefined;
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: (target) => {
+        target.set([0, 1, 2, 3, 4, 5, 6, 7]);
+        sourceBuffer = target;
+        return target;
+      },
+    });
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+
+    sourceBuffer?.fill(255);
+
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+    });
+  });
+
+  it('survives detachment of the source-filled navigation prefix buffer', () => {
+    let sourceBuffer: Uint8Array<ArrayBuffer> | undefined;
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: (target) => {
+        target.set([0, 1, 2, 3, 4, 5, 6, 7]);
+        sourceBuffer = target;
+        return target;
+      },
+    });
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+    if (!sourceBuffer) throw new Error('Expected the source buffer');
+
+    structuredClone(sourceBuffer.buffer, { transfer: [sourceBuffer.buffer] });
+
+    expect(sourceBuffer.byteLength).toBe(0);
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: true,
+      value: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+    });
+  });
+
+  it('contains mint buffer and view failures behind the typed identity failure', () => {
+    const failure = vi.fn();
+    const { source } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: source,
+      onFailure: failure,
+    });
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+    vi.stubGlobal(
+      'DataView',
+      class {
+        public constructor() {
+          throw new Error('sensitive detached view failure');
+        }
+      }
+    );
+
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(failure.mock.calls).toEqual([['identity_generation_failed']]);
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0, 0]);
+  });
+
+  it('fails closed when a mint view silently leaves ordinal bytes unwritten', () => {
+    const failure = vi.fn();
+    const { source } = deterministicSource([0, 1, 2, 3, 4, 5, 6, 7]);
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: source,
+      onFailure: failure,
+    });
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+    vi.stubGlobal(
+      'DataView',
+      class {
+        public setUint32(): void {}
+      }
+    );
+
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(failure.mock.calls).toEqual([['identity_generation_failed']]);
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0, 0]);
+  });
+
+  it('issues the final ordinal once and then fails forever without wrapping', () => {
+    const { source } = deterministicSource([8, 7, 6, 5, 4, 3, 2, 1]);
+    const failure = vi.fn();
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: source,
+      initialOrdinal: [0xffff_ffff, 0xffff_fffe],
+      onFailure: failure,
+    });
+
+    expect(created).toMatchObject({ ok: true });
+    if (!created.ok) throw new Error('Expected an identity issuer');
+
+    expect(created.value.mintAttemptId()).toMatchObject({ ok: true });
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0xffff_ffff, 0xffff_ffff]);
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(created.value.mintAttemptId()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(created.value.snapshotOrdinalForTest()).toEqual([0xffff_ffff, 0xffff_ffff]);
+    expect(failure).toHaveBeenCalledTimes(2);
+    expect(failure.mock.calls).toEqual([
+      ['identity_generation_failed'],
+      ['identity_generation_failed'],
+    ]);
+  });
+
+  it('fails before creating an issuer when browser crypto is missing or throws', () => {
+    vi.stubGlobal('crypto', undefined);
+    expect(createBrowserNavigationIdentityIssuer()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+
+    vi.stubGlobal('crypto', {
+      getRandomValues: () => {
+        throw new Error('unavailable');
+      },
+    });
+    expect(createBrowserNavigationIdentityIssuer()).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+  });
+
+  it('reports prefix failures without exposing raw bytes or identities', () => {
+    const failure = vi.fn();
+    const created = createTestNavigationIdentityIssuer({
+      getRandomValues: () => {
+        throw new Error('sensitive source failure');
+      },
+      onFailure: failure,
+    });
+
+    expect(created).toEqual({ ok: false, reason: 'identity_generation_failed' });
+    expect(failure.mock.calls).toEqual([['identity_generation_failed']]);
+  });
+});
+
+describe('fresh capability identities', () => {
+  it('encodes each lifecycle ticket from sixteen fresh CSPRNG bytes', () => {
+    const { source, calls } = deterministicSource([
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    ]);
+
+    const first = mintTestLifecycleTicket(source);
+    const second = mintTestLifecycleTicket(source);
+
+    expect(first).toEqual({ ok: true, value: 't1_AAECAwQFBgcICQoLDA0ODw' });
+    expect(second).toEqual({ ok: true, value: 't1_AAECAwQFBgcICQoLDA0ODw' });
+    expect(first.ok && first.value).toHaveLength(25);
+    expect(first.ok && decodeIdentity(first.value)).toHaveLength(16);
+    expect(calls).toHaveBeenCalledTimes(2);
+    expect(calls.mock.calls[0]?.[0]).not.toBe(calls.mock.calls[1]?.[0]);
+  });
+
+  it('encodes each renderer nonce from sixteen fresh CSPRNG bytes', () => {
+    const { source, calls } = deterministicSource([
+      15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
+    ]);
+
+    const result = mintTestRendererNonce(source);
+
+    expect(result).toEqual({ ok: true, value: 'n1_Dw4NDAsKCQgHBgUEAwIBAA' });
+    expect(result.ok && result.value).toHaveLength(25);
+    expect(result.ok && decodeIdentity(result.value)).toHaveLength(16);
+    expect(calls).toHaveBeenCalledOnce();
+    expect(calls.mock.calls[0]?.[0]).toHaveLength(16);
+  });
+
+  it('keeps bootstrap and renderer nonce roles cryptographically distinct', () => {
+    const { source, calls } = deterministicSource([
+      15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
+    ]);
+
+    const bootstrap = mintTestBootstrapNonce(source);
+    const renderer = mintTestRendererNonce(source);
+
+    expect(bootstrap).toEqual({ ok: true, value: 'b1_Dw4NDAsKCQgHBgUEAwIBAA' });
+    expect(renderer).toEqual({ ok: true, value: 'n1_Dw4NDAsKCQgHBgUEAwIBAA' });
+    expect(bootstrap.ok && bootstrap.value).not.toBe(renderer.ok && renderer.value);
+    expect(calls).toHaveBeenCalledTimes(2);
+  });
+
+  it('maps ticket and nonce source failures without leaking source values', () => {
+    const failure = vi.fn();
+    const source = () => {
+      throw new Error('sensitive source failure');
+    };
+
+    expect(mintTestLifecycleTicket(source, failure)).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(mintTestBootstrapNonce(source, failure)).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(mintTestRendererNonce(source, failure)).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(failure.mock.calls).toEqual([
+      ['identity_generation_failed'],
+      ['identity_generation_failed'],
+      ['identity_generation_failed'],
+    ]);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/integration_registry.test.ts b/crates/trusted-server-js/lib/test/kernel/integration_registry.test.ts
new file mode 100644
index 000000000..ddcbba5e6
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/integration_registry.test.ts
@@ -0,0 +1,1948 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { BootManifestV1 } from '../../src/core/types';
+import { EMBEDDED_MAX_MANIFEST_MODULES } from '../../src/kernel/contracts/release_capacity';
+import {
+  createIntegrationRegistry as createIntegrationRegistryOwner,
+  snapshotIntegrationRegistration,
+  type IntegrationPrepareContext,
+  type IntegrationRegistryOptions,
+  type TakeoverIntegrationRegistration,
+} from '../../src/kernel/integration_registry';
+import { snapshotPersistentFirstDisplayAdoptionV1 } from '../../src/shared/takeover';
+import { failedFirstDisplayTakeover } from '../first_display/helpers/compact_takeover';
+
+const RELEASE_ID = 'a'.repeat(64);
+const OTHER_RELEASE_ID = 'b'.repeat(64);
+
+type TestRegistryOptions = Omit<IntegrationRegistryOptions, 'knownIntegrationIds'> & {
+  readonly knownIntegrationIds?: readonly string[];
+};
+
+function manifestIds(candidate: unknown): readonly string[] {
+  if (typeof candidate !== 'object' || candidate === null) return Object.freeze([]);
+  const integrations = (candidate as { integrations?: unknown }).integrations;
+  if (!Array.isArray(integrations)) return Object.freeze([]);
+
+  const ids: string[] = [];
+  for (let index = 0; index < integrations.length; index += 1) {
+    const entry = integrations[index] as { id?: unknown } | undefined;
+    if (typeof entry?.id === 'string') ids.push(entry.id);
+  }
+  return Object.freeze([...new Set(ids)]);
+}
+
+function createIntegrationRegistry(options: TestRegistryOptions) {
+  const knownIntegrationIds = options.knownIntegrationIds ?? manifestIds(options.manifest);
+  return createIntegrationRegistryOwner({
+    ...options,
+    knownIntegrationIds,
+    catalog: Object.freeze(
+      knownIntegrationIds.map((id) =>
+        Object.freeze({
+          id,
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze([]),
+        })
+      )
+    ),
+  });
+}
+
+function manifest(ids: readonly string[]): BootManifestV1 {
+  return {
+    version: 1,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) => ({ id, phase: 'takeover' as const })),
+  };
+}
+
+function registration(
+  id: string,
+  hooks: Partial<TakeoverIntegrationRegistration> = {}
+): TakeoverIntegrationRegistration {
+  const prepare = hooks.prepare ?? (() => Object.freeze({ activate: () => undefined }));
+  return {
+    abi: 1,
+    id,
+    phase: 'takeover',
+    releaseId: RELEASE_ID,
+    prepareSync: hooks.prepareSync ?? (() => Object.freeze({ activate: () => undefined })),
+    prepare,
+    ...hooks,
+  };
+}
+
+async function install(
+  registry: ReturnType<typeof createIntegrationRegistry>,
+  order: string[] = []
+) {
+  return registry.install({
+    activateCore: () => undefined,
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  });
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  document.head.replaceChildren();
+  Object.defineProperty(document, 'currentScript', { configurable: true, value: null });
+});
+
+describe('integration manifest and registration admission', () => {
+  it('offers one synchronous activation/commit barrier after every preparation completes', async () => {
+    const order: string[] = [];
+    let adoption: unknown;
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepareSync: () => {
+          throw new Error('agent takeover must not use prepareSync');
+        },
+        prepare: () => {
+          order.push('module:prepare');
+          return {
+            activate: ({ adoption: received, afterCommit }) => {
+              expect(received).toBe(adoption);
+              order.push('module:activate');
+              afterCommit(() => order.push('after-commit'));
+            },
+          };
+        },
+      })
+    );
+
+    const result = await registry.install({
+      prepareCore: () => order.push('core:prepare'),
+      activateCore: () => order.push('core:activate'),
+      publish: () => order.push('publish'),
+      drainPreload: () => order.push('drain'),
+      coordinateTakeover: (prepared) => {
+        expect(Object.isFrozen(prepared)).toBe(true);
+        expect(order).toEqual(['core:prepare', 'module:prepare']);
+        const candidate = failedFirstDisplayTakeover(RELEASE_ID);
+        const handoff = prepared.validateHandoff(
+          candidate.capture || {
+            version: 1,
+            releaseId: RELEASE_ID,
+            generation: 1,
+            projectionDigest: 'b'.repeat(64),
+            integrationConfigDigest: 'c'.repeat(64),
+            slices: ['first_display'],
+            slots: [
+              {
+                id: 'slot-1',
+                aliases: [],
+                domId: 'div-1',
+                gamPath: '/123/slot-1',
+                formats: [[300, 250]],
+                owner: 'trusted_server',
+                outcome: 'failed',
+                targeting: [],
+                targetingOwnership: [],
+                committedArtifact: 'none',
+                gptToken: null,
+              },
+            ],
+            attempts: [
+              {
+                id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+                slotId: 'slot-1',
+                ordinal: 1,
+                state: 'failed',
+                reason: 'internal_error',
+              },
+            ],
+            tombstones: [],
+            artifacts: [],
+            parserState: [],
+            gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+            timing: {
+              bidsScriptMs: 0,
+              firstDisplayMs: null,
+              terminalMs: 0,
+              paintMs: 0,
+            },
+            highWater: {
+              navigationAttemptPrefix: 'AAECAwQFBgc',
+              nextNavigationAttemptOrdinal: 2,
+              nextAttemptOrdinal: 2,
+              nextSlotRegistrationOrdinal: 2,
+              reservationClockEpochMs: 0,
+              nextReservationOrdinal: 1,
+              nextTicketOrdinal: 1,
+            },
+            cycles: [],
+            trace: {
+              nextSequence: 1,
+              nextGlobalSlotOrdinal: 2,
+              slots: [{ slotId: 'slot-1', impressions: 0, bindings: [] }],
+            },
+            mutationRevision: 0,
+          },
+          {
+            version: 1,
+            releaseId: RELEASE_ID,
+            generation: 1,
+            projectionDigest: 'b'.repeat(64),
+            integrationConfigDigest: 'c'.repeat(64),
+            slices: ['first_display'],
+            slotCount: 1,
+            outcomeCount: 1,
+            capabilities: [],
+            objectKinds: [],
+          },
+          candidate.boot
+        );
+        expect(handoff).toBeDefined();
+        adoption = Object.freeze({
+          version: 1 as const,
+          adoptInitialDisplay: true as const,
+          handoff: handoff!,
+          identities: Object.freeze([]),
+        });
+        expect(snapshotPersistentFirstDisplayAdoptionV1(adoption)).toBe(adoption);
+        prepared.activate(adoption);
+        expect(() => prepared.activate()).toThrow();
+        expect(order).toEqual([
+          'core:prepare',
+          'module:prepare',
+          'core:activate',
+          'module:activate',
+        ]);
+        prepared.commit();
+      },
+    });
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'core:prepare',
+      'module:prepare',
+      'core:activate',
+      'module:activate',
+      'publish',
+      'after-commit',
+      'drain',
+    ]);
+  });
+
+  it('prepares, activates, and commits a no-agent runtime without yielding', async () => {
+    const order: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    for (const id of ['gpt', 'prebid']) {
+      expect(
+        registry.register(
+          registration(id, {
+            prepareSync: () => {
+              order.push(`prepareSync:${id}`);
+              return Object.freeze({
+                activate: () => order.push(`activate:${id}`),
+              });
+            },
+            prepare: () => {
+              throw new Error('no-agent runtime must not use prepare');
+            },
+          })
+        )
+      ).toBe(true);
+    }
+    queueMicrotask(() => order.push('microtask'));
+
+    const result = registry.installSync({
+      activateCore: () => order.push('activate:core'),
+      publish: () => order.push('publish'),
+      drainPreload: () => order.push('drain'),
+    });
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'prepareSync:gpt',
+      'prepareSync:prebid',
+      'activate:core',
+      'activate:gpt',
+      'activate:prebid',
+      'publish',
+      'drain',
+    ]);
+    await Promise.resolve();
+    expect(order[order.length - 1]).toBe('microtask');
+  });
+
+  it('rejects a thenable returned by no-agent prepareSync before activation', () => {
+    const activate = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepareSync: () => Promise.resolve(Object.freeze({ activate })) as never,
+      })
+    );
+
+    expect(
+      registry.installSync({
+        activateCore: activate,
+        publish: vi.fn(),
+        drainPreload: vi.fn(),
+      })
+    ).toEqual({ state: 'fallback', reason: 'bundle_partial' });
+    expect(activate).not.toHaveBeenCalled();
+  });
+
+  it('fails closed when a takeover coordinator returns without committing', async () => {
+    const activate = vi.fn();
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({ activate }),
+      })
+    );
+
+    await expect(
+      registry.install({
+        activateCore: () => undefined,
+        publish,
+        drainPreload: () => undefined,
+        coordinateTakeover: () => undefined,
+      })
+    ).resolves.toEqual({ state: 'fallback', reason: 'bundle_partial' });
+    expect(activate).not.toHaveBeenCalled();
+    expect(publish).not.toHaveBeenCalled();
+  });
+
+  it('accepts only the exact six-field takeover registrar ABI', () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    const exact = registration('gpt');
+
+    expect(Reflect.ownKeys(exact)).toEqual([
+      'abi',
+      'id',
+      'phase',
+      'releaseId',
+      'prepareSync',
+      'prepare',
+    ]);
+    expect(registry.register(exact)).toBe(true);
+  });
+
+  it('admits the exact five-field deferred shape and rejects prepareSync on deferred code', () => {
+    const deferred = Object.freeze({
+      abi: 1 as const,
+      id: 'gpt_later',
+      phase: 'deferred' as const,
+      releaseId: RELEASE_ID,
+      prepare: () => Object.freeze({ activate: () => undefined }),
+    });
+
+    expect(snapshotIntegrationRegistration(deferred)).toMatchObject({
+      id: 'gpt_later',
+      phase: 'deferred',
+    });
+    expect(
+      snapshotIntegrationRegistration({ ...deferred, prepareSync: deferred.prepare })
+    ).toBeUndefined();
+  });
+
+  it.each([
+    ['old three-field ABI', { id: 'gpt', release: RELEASE_ID, prepare: vi.fn() }],
+    ['missing abi', { id: 'gpt', phase: 'takeover', releaseId: RELEASE_ID, prepare: vi.fn() }],
+    ['missing prepareSync', { ...registration('gpt'), prepareSync: undefined }],
+    ['unknown field', { ...registration('gpt'), unexpected: true }],
+    ['wrong phase', { ...registration('gpt'), phase: 'deferred' }],
+    ['custom prototype', Object.assign(Object.create({ inherited: true }), registration('gpt'))],
+    ['null prototype', Object.assign(Object.create(null), registration('gpt'))],
+  ])('rejects %s without invoking module code', async (_name, candidate) => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(candidate)).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    const prepare = (candidate as { prepare?: unknown }).prepare;
+    if (vi.isMockFunction(prepare)) expect(prepare).not.toHaveBeenCalled();
+  });
+
+  it('authenticates every takeover registration to the captured connected core script', () => {
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = `${window.location.origin}/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+    document.head.append(runtimeScript);
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: runtimeScript,
+    });
+    const registry = createIntegrationRegistryOwner({
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'gpt',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      takeoverScript: runtimeScript,
+      document,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('gpt'))).toBe(true);
+  });
+
+  it.each(['different current script', 'disconnected script', 'wrong exact source'])(
+    'rejects a takeover registration from a %s',
+    (failure) => {
+      const runtimeScript = document.createElement('script');
+      runtimeScript.id = 'trustedserver-js';
+      runtimeScript.src = `${window.location.origin}/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+      document.head.append(runtimeScript);
+      Object.defineProperty(document, 'currentScript', {
+        configurable: true,
+        value: runtimeScript,
+      });
+      const registry = createIntegrationRegistryOwner({
+        catalog: Object.freeze([
+          Object.freeze({
+            id: 'gpt',
+            phase: 'takeover' as const,
+            trigger: null,
+            consumes: Object.freeze([]),
+            provides: Object.freeze([]),
+          }),
+        ]),
+        takeoverScript: runtimeScript,
+        document,
+        knownIntegrationIds: Object.freeze(['gpt']),
+        manifest: manifest(['gpt']),
+        releaseId: RELEASE_ID,
+        startedAtMs: 0,
+        now: () => 0,
+      });
+      if (failure === 'different current script') {
+        Object.defineProperty(document, 'currentScript', {
+          configurable: true,
+          value: document.createElement('script'),
+        });
+      } else if (failure === 'disconnected script') {
+        runtimeScript.remove();
+      } else {
+        runtimeScript.src = `${window.location.origin}/static/tsjs=tsjs-unified.min.js?v=${'d'.repeat(64)}`;
+      }
+
+      expect(registry.register(registration('gpt'))).toBe(false);
+      expect(registry.state).toBe('failed');
+    }
+  );
+
+  it('exposes only a frozen facade while mutable registry state stays in a closure', () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest([]),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(Object.isFrozen(registry)).toBe(true);
+    expect(Reflect.ownKeys(registry).sort()).toEqual([
+      'dispose',
+      'install',
+      'installSync',
+      'manifest',
+      'prepareDeferred',
+      'register',
+      'state',
+    ]);
+    expect('registrations' in registry).toBe(false);
+    expect('prepared' in registry).toBe(false);
+    registry.dispose();
+  });
+
+  it('rejects an integration array with executable iteration without invoking it', async () => {
+    const iterator = vi.fn(function* () {
+      for (let index = 0; index < 21; index += 1) {
+        yield { id: `module_${index}`, phase: 'takeover' };
+      }
+    });
+    const integrations: unknown[] = [];
+    Object.defineProperty(integrations, Symbol.iterator, { value: iterator });
+    const registry = createIntegrationRegistry({
+      manifest: { version: 1, releaseId: RELEASE_ID, integrations },
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(iterator).not.toHaveBeenCalled();
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it.each([
+    ['non-object', null],
+    ['wrong version', { ...manifest([]), version: 2 }],
+    ['extra manifest field', { ...manifest([]), unexpected: true }],
+    ['wrong release grammar', { ...manifest([]), releaseId: 'ABC' }],
+    ['malformed id', { ...manifest([]), integrations: [{ id: 'Uppercase', required: true }] }],
+    [
+      'unknown integration field',
+      { ...manifest([]), integrations: [{ id: 'gpt', required: true, optional: false }] },
+    ],
+    ['non-required entry', { ...manifest([]), integrations: [{ id: 'gpt', required: false }] }],
+    [
+      'duplicate id',
+      {
+        ...manifest([]),
+        integrations: [
+          { id: 'gpt', required: true },
+          { id: 'gpt', required: true },
+        ],
+      },
+    ],
+    [
+      'over generated capacity',
+      manifest(
+        Array.from({ length: EMBEDDED_MAX_MANIFEST_MODULES + 1 }, (_, index) => `module_${index}`)
+      ),
+    ],
+  ])('rejects a malformed manifest: %s', async (_name, candidate) => {
+    const registry = createIntegrationRegistry({
+      manifest: candidate,
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('gpt'))).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it('requires the embedded release, manifest release, and bundle release to match', async () => {
+    const registry = createIntegrationRegistry({
+      manifest: { ...manifest(['gpt']), releaseId: OTHER_RELEASE_ID },
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('gpt'))).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it('rejects a syntactically valid manifest id outside the frozen core bundle inventory', async () => {
+    const prepare = vi.fn(() => ({ activate: () => undefined }));
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['evil']),
+      releaseId: RELEASE_ID,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('evil', { prepare }))).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect(prepare).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['unknown id', registration('unknown')],
+    ['wrong bundle release', registration('gpt', { releaseId: OTHER_RELEASE_ID })],
+  ])('quarantines %s before prepare is called', async (_name, candidate) => {
+    const prepare = vi.fn(candidate.prepare);
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register({ ...candidate, prepare })).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect(prepare).not.toHaveBeenCalled();
+  });
+
+  it('rejects registration accessors without invoking bundle code during collection', async () => {
+    const prepareGetter = vi.fn(() => () => ({ activate: () => undefined }));
+    const candidate = Object.defineProperties(
+      {},
+      {
+        id: { value: 'gpt', enumerable: true },
+        release: { value: RELEASE_ID, enumerable: true },
+        prepare: { get: prepareGetter, enumerable: true },
+      }
+    );
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(candidate)).toBe(false);
+    expect(prepareGetter).not.toHaveBeenCalled();
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it('rejects duplicate registration without invoking either module', async () => {
+    const firstPrepare = vi.fn(() => ({ activate: () => undefined }));
+    const secondPrepare = vi.fn(() => ({ activate: () => undefined }));
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('gpt', { prepare: firstPrepare }))).toBe(true);
+    expect(registry.register(registration('gpt', { prepare: secondPrepare }))).toBe(false);
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect(firstPrepare).not.toHaveBeenCalled();
+    expect(secondPrepare).not.toHaveBeenCalled();
+  });
+
+  it('rejects a takeover registration that skips the next manifest entry', async () => {
+    const prepare = vi.fn(() => ({ activate: () => undefined }));
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(registration('prebid', { prepare }))).toBe(false);
+    expect(registry.state).toBe('failed');
+    expect(prepare).not.toHaveBeenCalled();
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it('snapshots accepted registration code so retained objects cannot swap it later', async () => {
+    const acceptedPrepare = vi.fn(() => ({ activate: () => undefined }));
+    const swappedPrepare = vi.fn(() => ({
+      activate: () => {
+        throw new Error('must never execute');
+      },
+    }));
+    const candidate = {
+      abi: 1 as const,
+      id: 'gpt',
+      phase: 'takeover' as const,
+      releaseId: RELEASE_ID,
+      prepareSync: acceptedPrepare,
+      prepare: acceptedPrepare,
+    };
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    expect(registry.register(candidate)).toBe(true);
+    candidate.id = 'unknown';
+    candidate.releaseId = OTHER_RELEASE_ID;
+    candidate.prepareSync = swappedPrepare;
+    candidate.prepare = swappedPrepare;
+
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+    expect(acceptedPrepare).toHaveBeenCalledTimes(1);
+    expect(swappedPrepare).not.toHaveBeenCalled();
+  });
+
+  it('waits for required modules registered after install starts without early execution', async () => {
+    const order: string[] = [];
+    const gptPrepare = vi.fn(() => {
+      order.push('prepare:gpt');
+      return { activate: () => order.push('activate:gpt') };
+    });
+    const prebidPrepare = vi.fn(() => {
+      order.push('prepare:prebid');
+      return { activate: () => order.push('activate:prebid') };
+    });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(registration('gpt', { prepare: gptPrepare }));
+
+    const installed = install(registry, order);
+    await Promise.resolve();
+    expect(registry.state).toBe('collecting');
+    expect(order).toEqual([]);
+    expect(registry.register(registration('prebid', { prepare: prebidPrepare }))).toBe(true);
+
+    await expect(installed).resolves.toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'prepare:gpt',
+      'prepare:prebid',
+      'activate:gpt',
+      'activate:prebid',
+      'publish',
+      'drain',
+    ]);
+  });
+
+  it('fails missing required modules only at the shared boot deadline', async () => {
+    vi.useFakeTimers();
+    let now = 0;
+    const prepare = vi.fn(() => ({ activate: () => undefined }));
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => now,
+    });
+    registry.register(registration('gpt', { prepare }));
+
+    const installed = install(registry);
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(registry.state).toBe('collecting');
+    expect(prepare).not.toHaveBeenCalled();
+    now = 10_000;
+    await vi.advanceTimersByTimeAsync(1);
+
+    await expect(installed).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(prepare).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('accepts exactly 14 takeover modules in manifest order', async () => {
+    const ids = Array.from({ length: 14 }, (_, index) => `module_${index}`);
+    const order: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(ids),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    for (const id of ids) {
+      expect(
+        registry.register(
+          registration(id, {
+            prepare: () => {
+              order.push(`prepare:${id}`);
+              return { activate: () => order.push(`activate:${id}`) };
+            },
+          })
+        )
+      ).toBe(true);
+    }
+
+    await expect(install(registry, order)).resolves.toMatchObject({ state: 'kernel' });
+    expect(order.slice(0, 14)).toEqual(ids.map((id) => `prepare:${id}`));
+    expect(order.slice(14, 28)).toEqual(ids.map((id) => `activate:${id}`));
+    expect(order.slice(28)).toEqual(['publish', 'drain']);
+  });
+});
+
+describe('integration preparation and activation transaction', () => {
+  it('stages only declared provider capabilities for later takeover consumers', async () => {
+    const gpt = Object.freeze({ kind: 'gpt' });
+    let consumerInterfaces: Readonly<Record<string, unknown>> | undefined;
+    const registry = createIntegrationRegistryOwner({
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'gpt',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze(['gpt.v1']),
+        }),
+        Object.freeze({
+          id: 'prebid',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['gpt.v1']),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      knownIntegrationIds: Object.freeze(['gpt', 'prebid']),
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      runtimeCapability: Object.freeze({ kind: 'runtime' }),
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: ({ interfaces }) => {
+          expect(Reflect.ownKeys(interfaces)).toEqual(['runtime.v1']);
+          return { activate: () => undefined, interfaces: Object.freeze({ 'gpt.v1': gpt }) };
+        },
+      })
+    );
+    registry.register(
+      registration('prebid', {
+        prepare: ({ interfaces }) => {
+          consumerInterfaces = interfaces;
+          return { activate: () => undefined, interfaces: Object.freeze({}) };
+        },
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+    expect(consumerInterfaces).toEqual(Object.freeze({ 'gpt.v1': gpt }));
+    expect(Object.isFrozen(consumerInterfaces)).toBe(true);
+    expect(Reflect.ownKeys(consumerInterfaces ?? {})).toEqual(['gpt.v1']);
+  });
+
+  it('prepares a deferred consumer from committed takeover capabilities only', async () => {
+    const gpt = Object.freeze({ kind: 'gpt' });
+    const registry = createIntegrationRegistryOwner({
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'gpt',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze(['gpt.v1']),
+        }),
+        Object.freeze({
+          id: 'gpt_later',
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          consumes: Object.freeze(['gpt.v1']),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      knownIntegrationIds: Object.freeze(['gpt', 'gpt_later']),
+      manifest: {
+        ...manifest(['gpt']),
+        integrations: Object.freeze([
+          Object.freeze({ id: 'gpt', phase: 'takeover' as const }),
+          Object.freeze({
+            id: 'gpt_later',
+            phase: 'deferred' as const,
+            trigger: 'first_display_or_idle' as const,
+            src: `/static/tsjs=tsjs-gpt_later.min.js?v=${'d'.repeat(64)}`,
+          }),
+        ]),
+      },
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: () => undefined,
+          interfaces: Object.freeze({ 'gpt.v1': gpt }),
+        }),
+      })
+    );
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+
+    const prepare = vi.fn(({ interfaces }: IntegrationPrepareContext) => {
+      expect(interfaces).toEqual(Object.freeze({ 'gpt.v1': gpt }));
+      return { activate: () => undefined };
+    });
+    const prepared = registry.prepareDeferred(
+      { ...registration('gpt_later', { prepare }), phase: 'deferred' },
+      Object.freeze({
+        signal: new AbortController().signal,
+        onDispose: vi.fn(),
+      })
+    );
+
+    expect(prepare).toHaveBeenCalledTimes(1);
+    expect(prepared).toMatchObject({ activate: expect.any(Function) });
+  });
+
+  it.each([
+    ['missing declared key', Object.freeze({})],
+    ['unknown key', Object.freeze({ 'gpt.v1': Object.freeze({}), 'other.v1': Object.freeze({}) })],
+    ['mutable facade', Object.freeze({ 'gpt.v1': {} })],
+    [
+      'custom facade prototype',
+      Object.freeze({ 'gpt.v1': Object.freeze(Object.create({ inherited: true })) }),
+    ],
+  ])('rejects provider interfaces with a %s', async (_name, interfaces) => {
+    const prepareConsumer = vi.fn(() => ({
+      activate: () => undefined,
+      interfaces: Object.freeze({}),
+    }));
+    const registry = createIntegrationRegistryOwner({
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'gpt',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze(['gpt.v1']),
+        }),
+        Object.freeze({
+          id: 'prebid',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['gpt.v1']),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      knownIntegrationIds: Object.freeze(['gpt', 'prebid']),
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({ activate: () => undefined, interfaces }),
+      })
+    );
+    registry.register(registration('prebid', { prepare: prepareConsumer }));
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(prepareConsumer).not.toHaveBeenCalled();
+  });
+
+  it('prepares core-owned bindings before module preparation and activates afterward', async () => {
+    const order: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => {
+        order.push('bindings');
+        return { config: Object.freeze({}), interfaces: Object.freeze({}) };
+      },
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => {
+          order.push('module:prepare');
+          return { activate: () => order.push('module:activate') };
+        },
+      })
+    );
+
+    const result = await registry.install({
+      prepareCore: () => order.push('core:prepare'),
+      activateCore: () => order.push('core:activate'),
+      publish: () => order.push('publish'),
+      drainPreload: () => order.push('drain'),
+    });
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'core:prepare',
+      'bindings',
+      'module:prepare',
+      'core:activate',
+      'module:activate',
+      'publish',
+      'drain',
+    ]);
+  });
+
+  it('unwinds core-prepared resources when later module preparation fails', async () => {
+    const release = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => {
+          throw new Error('fictional preparation failure');
+        },
+      })
+    );
+
+    const result = await registry.install({
+      prepareCore: ({ onDispose }) => onDispose(release),
+      activateCore: vi.fn(),
+      publish: vi.fn(),
+      drainPreload: vi.fn(),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  it('collects without execution, prepares sequentially, and commits in exact order', async () => {
+    const order: string[] = [];
+    const contexts: IntegrationPrepareContext[] = [];
+    let finishGpt: (() => void) | undefined;
+    const gptPrepared = new Promise<void>((resolve) => {
+      finishGpt = resolve;
+    });
+    const frozenConfig = Object.freeze({ enabled: true });
+    const frozenInterfaces = Object.freeze({ adapter: Object.freeze({ kind: 'fake' }) });
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: (id) => ({
+        config: id === 'gpt' ? frozenConfig : Object.freeze({ enabled: false }),
+        interfaces: frozenInterfaces,
+      }),
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: async (context) => {
+          contexts.push(context);
+          order.push('prepare:gpt:start');
+          await gptPrepared;
+          order.push('prepare:gpt:end');
+          return {
+            activate: (activation) => {
+              order.push('activate:gpt');
+              activation.afterCommit(() => order.push('after:gpt'));
+            },
+          };
+        },
+      })
+    );
+    registry.register(
+      registration('prebid', {
+        prepare: (context) => {
+          contexts.push(context);
+          order.push('prepare:prebid');
+          return {
+            activate: (activation) => {
+              order.push('activate:prebid');
+              activation.afterCommit(() => order.push('after:prebid'));
+            },
+          };
+        },
+      })
+    );
+
+    expect(order).toEqual([]);
+    const installed = install(registry, order);
+    await vi.waitFor(() => expect(order).toEqual(['prepare:gpt:start']));
+    expect(order).not.toContain('prepare:prebid');
+    finishGpt?.();
+
+    await expect(installed).resolves.toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'prepare:gpt:start',
+      'prepare:gpt:end',
+      'prepare:prebid',
+      'activate:gpt',
+      'activate:prebid',
+      'publish',
+      'after:gpt',
+      'after:prebid',
+      'drain',
+    ]);
+    expect(contexts).toHaveLength(2);
+    expect(Object.isFrozen(contexts[0])).toBe(true);
+    expect(contexts[0]?.config).toBe(frozenConfig);
+    expect(contexts[0]?.interfaces).toBe(frozenInterfaces);
+  });
+
+  it('closes a synchronous preparation context before detached microtasks can use it', async () => {
+    const lateDisposer = vi.fn();
+    let lateError: unknown;
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: (context) => {
+          queueMicrotask(() => {
+            try {
+              context.onDispose(lateDisposer);
+            } catch (error) {
+              lateError = error;
+            }
+          });
+          return { activate: () => undefined };
+        },
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+    await Promise.resolve();
+    expect(lateError).toBeInstanceOf(Error);
+    expect(lateDisposer).not.toHaveBeenCalled();
+  });
+
+  it('rejects a prepared activation accessor without invoking it or publishing', async () => {
+    const owner = new AbortController();
+    const activateGetter = vi.fn(() => {
+      owner.abort();
+      return () => undefined;
+    });
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      signal: owner.signal,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () =>
+          Object.defineProperty({}, 'activate', {
+            get: activateGetter,
+            enumerable: true,
+          }) as { activate: () => void },
+      })
+    );
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish,
+      drainPreload: vi.fn(),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(activateGetter).not.toHaveBeenCalled();
+    expect(publish).not.toHaveBeenCalled();
+  });
+
+  it('rejects a frozen interface container that exposes a mutable adapter facade', async () => {
+    const prepare = vi.fn(() => ({ activate: () => undefined }));
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      getBindings: () => ({
+        config: Object.freeze({}),
+        interfaces: Object.freeze({ adapter: { mutable: true } }),
+      }),
+    });
+    registry.register(registration('gpt', { prepare }));
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(prepare).not.toHaveBeenCalled();
+  });
+
+  it('snapshots each prepared activation before preparing a later module', async () => {
+    const acceptedActivate = vi.fn();
+    const swappedActivate = vi.fn(() => {
+      throw new Error('must never execute');
+    });
+    const prepared = { activate: acceptedActivate };
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(registration('gpt', { prepare: () => prepared }));
+    registry.register(
+      registration('prebid', {
+        prepare: () => {
+          prepared.activate = swappedActivate;
+          return { activate: () => undefined };
+        },
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+    expect(acceptedActivate).toHaveBeenCalledTimes(1);
+    expect(swappedActivate).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    [
+      'synchronous throw',
+      () => {
+        throw new Error('fictional prepare throw');
+      },
+    ],
+    ['asynchronous rejection', () => Promise.reject(new Error('fictional prepare rejection'))],
+  ])('unwinds a preparation %s as bundle_partial', async (_name, prepare) => {
+    const disposed: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: (context) => {
+          context.onDispose(() => disposed.push('prepared'));
+          return prepare();
+        },
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(disposed).toEqual(['prepared']);
+  });
+
+  it('aborts a pending preparation at the shared deadline and ignores its late continuation', async () => {
+    vi.useFakeTimers();
+    let now = 0;
+    let finishPrepare: ((value: { activate: () => void }) => void) | undefined;
+    let context: IntegrationPrepareContext | undefined;
+    const activate = vi.fn();
+    const lateDispose = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => now,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: (receivedContext) => {
+          context = receivedContext;
+          return new Promise((resolve) => {
+            finishPrepare = resolve;
+          });
+        },
+      })
+    );
+
+    const installed = install(registry);
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(registry.state).toBe('preparing');
+    now = 10_000;
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(installed).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(context?.signal.aborted).toBe(true);
+    context?.onDispose(lateDispose);
+    expect(lateDispose).toHaveBeenCalledTimes(1);
+
+    finishPrepare?.({ activate });
+    await Promise.resolve();
+    expect(activate).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('aborts preparation through the caller signal and leaves no late activation', async () => {
+    const owner = new AbortController();
+    const activate = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      signal: owner.signal,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: ({ signal }) =>
+          new Promise((resolve) => {
+            signal.addEventListener('abort', () => resolve({ activate }));
+          }),
+      })
+    );
+
+    const installed = install(registry);
+    owner.abort();
+    await expect(installed).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activate).not.toHaveBeenCalled();
+  });
+
+  it('observes a rejected preparation promise returned after synchronous abort', async () => {
+    const owner = new AbortController();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      signal: owner.signal,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => {
+          owner.abort();
+          return Promise.reject(new Error('fictional late preparation rejection'));
+        },
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    await Promise.resolve();
+  });
+
+  it('turns a registration attempt during preparation into abi_mismatch', async () => {
+    let finishPrepare: ((value: { activate: () => void }) => void) | undefined;
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () =>
+          new Promise((resolve) => {
+            finishPrepare = resolve;
+          }),
+      })
+    );
+
+    const installed = install(registry);
+    await vi.waitFor(() => expect(registry.state).toBe('preparing'));
+    expect(registry.register(registration('unknown'))).toBe(false);
+    finishPrepare?.({ activate: () => undefined });
+
+    await expect(installed).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+  });
+
+  it('unwinds activated and prepared resources in reverse order on activation failure', async () => {
+    const order: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    for (const id of ['gpt', 'prebid']) {
+      registry.register(
+        registration(id, {
+          prepare: (preparation) => {
+            preparation.onDispose(() => order.push(`dispose:prepare:${id}`));
+            return {
+              activate: (activation) => {
+                activation.onDispose(() => order.push(`dispose:activate:${id}`));
+                order.push(`activate:${id}`);
+                if (id === 'prebid') throw new Error('fictional activation failure');
+              },
+            };
+          },
+        })
+      );
+    }
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(order).toEqual([
+      'activate:gpt',
+      'activate:prebid',
+      'dispose:activate:prebid',
+      'dispose:prepare:prebid',
+      'dispose:activate:gpt',
+      'dispose:prepare:gpt',
+    ]);
+  });
+
+  it('activates reversible core effects first and unwinds them after every module', async () => {
+    const order: string[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    for (const id of ['gpt', 'prebid']) {
+      registry.register(
+        registration(id, {
+          prepare: () => ({
+            activate: ({ onDispose }) => {
+              onDispose(() => order.push(`dispose:${id}`));
+              order.push(`activate:${id}`);
+              if (id === 'prebid') throw new Error('fictional later activation failure');
+            },
+          }),
+        })
+      );
+    }
+
+    const result = await registry.install({
+      activateCore: ({ onDispose }) => {
+        onDispose(() => order.push('dispose:core'));
+        order.push('activate:core');
+      },
+      publish: () => order.push('publish'),
+      drainPreload: () => order.push('drain'),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(order).toEqual([
+      'activate:core',
+      'activate:gpt',
+      'activate:prebid',
+      'dispose:prebid',
+      'dispose:gpt',
+      'dispose:core',
+    ]);
+  });
+
+  it.each([
+    ['deadline crossing', ({ setNow }: { setNow: (value: number) => void }) => setNow(10_000)],
+    ['async rejection', () => Promise.reject(new Error('fictional core rejection'))],
+  ])('rejects a core activation %s before module activation', async (_name, activate) => {
+    let now = 0;
+    const moduleActivate = vi.fn();
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => now,
+    });
+    registry.register(registration('gpt', { prepare: () => ({ activate: moduleActivate }) }));
+
+    const result = await registry.install({
+      activateCore: () => activate({ setNow: (value) => (now = value) }),
+      publish,
+      drainPreload: vi.fn(),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(moduleActivate).not.toHaveBeenCalled();
+    expect(publish).not.toHaveBeenCalled();
+  });
+
+  it('cannot commit after activation synchronously aborts the owner', async () => {
+    const owner = new AbortController();
+    const live = { wrapper: 'publisher' };
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      signal: owner.signal,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: ({ onDispose }) => {
+            const previous = live.wrapper;
+            onDispose(() => {
+              if (live.wrapper === 'tsjs') live.wrapper = previous;
+            });
+            live.wrapper = 'tsjs';
+            owner.abort();
+            live.wrapper = 'tsjs';
+          },
+        }),
+      })
+    );
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish,
+      drainPreload: vi.fn(),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(publish).not.toHaveBeenCalled();
+    expect(live.wrapper).toBe('publisher');
+  });
+
+  it('cannot commit after an activation attempts late bundle registration', async () => {
+    const live = { wrapper: 'publisher' };
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: ({ onDispose }) => {
+            const previous = live.wrapper;
+            onDispose(() => {
+              if (live.wrapper === 'tsjs') live.wrapper = previous;
+            });
+            live.wrapper = 'tsjs';
+            expect(registry.register(registration('unknown'))).toBe(false);
+            live.wrapper = 'tsjs';
+          },
+        }),
+      })
+    );
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish,
+      drainPreload: vi.fn(),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'abi_mismatch' });
+    expect(publish).not.toHaveBeenCalled();
+    expect(live.wrapper).toBe('publisher');
+  });
+
+  it('restores reversible effects before fallback publication', async () => {
+    const live = { wrapper: 'publisher' };
+    const observations: string[] = [];
+    const irreversibleWork = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => {
+          observations.push(`prepare:${live.wrapper}`);
+          return {
+            activate: ({ onDispose }) => {
+              const previous = live.wrapper;
+              onDispose(() => {
+                if (live.wrapper === 'tsjs') live.wrapper = previous;
+              });
+              live.wrapper = 'tsjs';
+            },
+          };
+        },
+      })
+    );
+    registry.register(
+      registration('prebid', {
+        prepare: () => ({
+          activate: ({ afterCommit }) => {
+            afterCommit(irreversibleWork);
+            throw new Error('later fictional failure');
+          },
+        }),
+      })
+    );
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish: () => observations.push(`publish:${live.wrapper}`),
+      drainPreload: () => observations.push('drain'),
+    });
+
+    expect(result).toMatchObject({ state: 'fallback' });
+    expect(live.wrapper).toBe('publisher');
+    expect(observations).toEqual(['prepare:publisher']);
+    expect(irreversibleWork).not.toHaveBeenCalled();
+  });
+
+  it('rejects asynchronous kernel publication and observes its rejection', async () => {
+    const drainPreload = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest([]),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish: async () => {
+        throw new Error('fictional asynchronous publication rejection');
+      },
+      drainPreload,
+    });
+
+    expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+    expect(drainPreload).not.toHaveBeenCalled();
+    await Promise.resolve();
+  });
+
+  it.each([9_999, 10_000, 10_001])(
+    'checks the monotonic deadline after activation at %i ms',
+    async (activationReturnMs) => {
+      let now = 0;
+      const order: string[] = [];
+      const registry = createIntegrationRegistry({
+        manifest: manifest(['gpt']),
+        releaseId: RELEASE_ID,
+        startedAtMs: 0,
+        now: () => now,
+      });
+      const prepare = () => ({
+        activate: () => {
+          order.push('activate');
+          now = activationReturnMs;
+        },
+      });
+      registry.register(
+        registration('gpt', {
+          prepareSync: prepare,
+          prepare,
+        })
+      );
+
+      const result = registry.installSync({
+        activateCore: () => undefined,
+        publish: () => order.push('publish'),
+        drainPreload: () => order.push('drain'),
+      });
+      if (activationReturnMs < 10_000) {
+        expect(result).toMatchObject({ state: 'kernel' });
+        expect(order).toEqual(['activate', 'publish', 'drain']);
+      } else {
+        expect(result).toMatchObject({ state: 'fallback', reason: 'bundle_partial' });
+        expect(order).toEqual(['activate']);
+      }
+    }
+  );
+
+  it('checks the deadline again immediately before handoff', async () => {
+    let checks = 0;
+    const activateCore = vi.fn();
+    const publish = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest([]),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => (checks++ < 5 ? 9_999 : 10_000),
+    });
+
+    expect(
+      registry.installSync({
+        activateCore,
+        publish,
+        drainPreload: vi.fn(),
+      })
+    ).toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activateCore).toHaveBeenCalledOnce();
+    expect(publish).not.toHaveBeenCalled();
+    expect(checks).toBe(6);
+  });
+
+  it('treats an asynchronous activation as a synchronous barrier violation', async () => {
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: async () => {
+            throw new Error('fictional async activation rejection');
+          },
+        }),
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+  });
+
+  it('turns a second afterCommit registration into bundle_partial', async () => {
+    const staged = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: ({ afterCommit }) => {
+            afterCommit(staged);
+            afterCommit(staged);
+          },
+        }),
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(staged).not.toHaveBeenCalled();
+  });
+
+  it('latches duplicate afterCommit as bundle_partial even when module code catches the throw', async () => {
+    const first = vi.fn();
+    const second = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: ({ afterCommit }) => {
+            try {
+              afterCommit(first);
+              afterCommit(second);
+            } catch {
+              // A bundle cannot swallow a registry contract violation and commit.
+            }
+          },
+        }),
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(first).not.toHaveBeenCalled();
+    expect(second).not.toHaveBeenCalled();
+  });
+
+  it('isolates afterCommit failure to its module and keeps the committed kernel', async () => {
+    const order: string[] = [];
+    const runtimeFailures: unknown[] = [];
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt', 'prebid']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      onRuntimeFailure: (failure) => runtimeFailures.push(failure),
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: ({ onDispose }) => {
+          onDispose(() => order.push('dispose:gpt'));
+          return {
+            activate: ({ afterCommit }) =>
+              afterCommit(() => {
+                order.push('after:gpt');
+                throw new Error('fictional post-commit failure');
+              }),
+          };
+        },
+      })
+    );
+    registry.register(
+      registration('prebid', {
+        prepare: () => ({
+          activate: ({ afterCommit }) => afterCommit(() => order.push('after:prebid')),
+        }),
+      })
+    );
+
+    const result = await install(registry, order);
+
+    expect(result).toMatchObject({
+      state: 'kernel',
+      runtimeFailures: [{ id: 'gpt', phase: 'after_commit' }],
+    });
+    expect(runtimeFailures).toEqual([{ id: 'gpt', phase: 'after_commit' }]);
+    expect(Object.isFrozen(runtimeFailures[0])).toBe(true);
+    expect(order).toEqual(['publish', 'after:gpt', 'dispose:gpt', 'after:prebid', 'drain']);
+    expect(registry.state).toBe('committed');
+  });
+
+  it('observes a rejecting asynchronous preload drain without undoing commit', async () => {
+    const onDisposalError = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest([]),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+      onDisposalError,
+    });
+
+    const result = await registry.install({
+      activateCore: () => undefined,
+      publish: () => undefined,
+      drainPreload: async () => {
+        throw new Error('fictional asynchronous preload rejection');
+      },
+    });
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(registry.state).toBe('committed');
+    await vi.waitFor(() => expect(onDisposalError).toHaveBeenCalledTimes(1));
+    expect(registry.state).toBe('committed');
+  });
+
+  it('refuses late registration after fallback or commit without invoking module code', async () => {
+    const fallbackRegistry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 10_000,
+    });
+    await install(fallbackRegistry);
+    const fallbackPrepare = vi.fn();
+    expect(fallbackRegistry.register(registration('gpt', { prepare: fallbackPrepare }))).toBe(
+      false
+    );
+
+    const committedRegistry = createIntegrationRegistry({
+      manifest: manifest([]),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    await install(committedRegistry);
+    const committedPrepare = vi.fn();
+    expect(committedRegistry.register(registration('gpt', { prepare: committedPrepare }))).toBe(
+      false
+    );
+
+    expect(fallbackPrepare).not.toHaveBeenCalled();
+    expect(committedPrepare).not.toHaveBeenCalled();
+  });
+
+  it('documents the same-thread limitation by completing only after activate returns', async () => {
+    let returned = false;
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    registry.register(
+      registration('gpt', {
+        prepare: () => ({
+          activate: () => {
+            expect(registry.state).toBe('activating');
+            returned = true;
+          },
+        }),
+      })
+    );
+
+    await expect(install(registry)).resolves.toMatchObject({ state: 'kernel' });
+    expect(returned).toBe(true);
+  });
+
+  it('memoizes installation before any synchronous callback can reenter it', async () => {
+    const phases: string[] = [];
+    const reentrantPromises: Promise<unknown>[] = [];
+    const ignoredPublish = vi.fn();
+    const ignoredDrain = vi.fn();
+    const registry = createIntegrationRegistry({
+      manifest: manifest(['gpt']),
+      releaseId: RELEASE_ID,
+      startedAtMs: 0,
+      now: () => 0,
+    });
+    const reenter = () => {
+      reentrantPromises.push(
+        registry.install({
+          activateCore: vi.fn(),
+          publish: ignoredPublish,
+          drainPreload: ignoredDrain,
+        })
+      );
+    };
+    registry.register(
+      registration('gpt', {
+        prepare: () => {
+          phases.push('prepare');
+          reenter();
+          return {
+            activate: () => {
+              phases.push('activate');
+              reenter();
+            },
+          };
+        },
+      })
+    );
+
+    const installed = registry.install({
+      activateCore: () => {
+        phases.push('core');
+        reenter();
+      },
+      publish: () => {
+        phases.push('publish');
+        reenter();
+      },
+      drainPreload: () => phases.push('drain'),
+    });
+
+    await expect(installed).resolves.toMatchObject({ state: 'kernel' });
+    expect(reentrantPromises).toHaveLength(4);
+    for (const promise of reentrantPromises) expect(promise).toBe(installed);
+    expect(phases).toEqual(['prepare', 'core', 'activate', 'publish', 'drain']);
+    expect(ignoredPublish).not.toHaveBeenCalled();
+    expect(ignoredDrain).not.toHaveBeenCalled();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/lifecycle_module.test.ts b/crates/trusted-server-js/lib/test/kernel/lifecycle_module.test.ts
new file mode 100644
index 000000000..0192b0eae
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/lifecycle_module.test.ts
@@ -0,0 +1,265 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createIntegrationRegistry,
+  type IntegrationInstallCallbacks,
+} from '../../src/kernel/integration_registry';
+import { createLifecycleIntegrationRegistration } from '../../src/kernel/lifecycle_module';
+
+const RELEASE_ID = 'a'.repeat(64);
+const RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+const TEST_INTEGRATION_ID = 'datadome';
+
+function callbacks(order: string[]): IntegrationInstallCallbacks {
+  return {
+    activateCore: () => order.push('core'),
+    publish: () => order.push('publish'),
+    drainPreload: () => order.push('drain'),
+  };
+}
+
+function registry(config: unknown, runtime: unknown) {
+  return createIntegrationRegistry({
+    manifest: {
+      version: 1,
+      releaseId: RELEASE_ID,
+      firstDisplay: null,
+      runtimeSrc: RUNTIME_SRC,
+      integrations: [{ id: TEST_INTEGRATION_ID, phase: 'takeover' }],
+    },
+    releaseId: RELEASE_ID,
+    knownIntegrationIds: Object.freeze([TEST_INTEGRATION_ID]),
+    startedAtMs: 0,
+    now: () => 0,
+    getBindings: () => ({
+      config,
+      interfaces: Object.freeze({ [TEST_INTEGRATION_ID]: runtime }),
+    }),
+  });
+}
+
+describe('shared integration lifecycle module', () => {
+  it('prepares inertly, activates reversibly, and starts only after publication', async () => {
+    const order: string[] = [];
+    const config = Object.freeze({ nested: Object.freeze({ enabled: true }) });
+    const release = vi.fn(() => order.push('release'));
+    const activate = vi.fn((received: unknown) => {
+      expect(received).toBe(config);
+      order.push('activate');
+      return release;
+    });
+    const start = vi.fn((received: unknown) => {
+      expect(received).toBe(config);
+      order.push('start');
+    });
+    const runtime = Object.freeze({ activate, start });
+    const owner = registry(config, runtime);
+    owner.register(createLifecycleIntegrationRegistration(TEST_INTEGRATION_ID, RELEASE_ID));
+
+    const result = await owner.install(callbacks(order));
+
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual(['core', 'activate', 'publish', 'start', 'drain']);
+    if (result.state === 'kernel') result.dispose();
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it.each([
+    ['mutable root', { enabled: true }],
+    ['mutable nested value', Object.freeze({ nested: { enabled: true } })],
+    ['accessor', Object.freeze(Object.defineProperty({}, 'enabled', { get: () => true }))],
+    ['function', Object.freeze(() => undefined)],
+  ])('rejects %s configuration before activation', async (_name, config) => {
+    const activate = vi.fn(() => vi.fn());
+    const owner = registry(config, Object.freeze({ activate, start: vi.fn() }));
+    owner.register(createLifecycleIntegrationRegistration(TEST_INTEGRATION_ID, RELEASE_ID));
+
+    await expect(owner.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activate).not.toHaveBeenCalled();
+  });
+
+  it('rejects extra runtime authority and unwinds activation when startup peers fail', async () => {
+    const activate = vi.fn(() => vi.fn());
+    const owner = registry(
+      Object.freeze({}),
+      Object.freeze({ activate, start: vi.fn(), publish: vi.fn() })
+    );
+    owner.register(createLifecycleIntegrationRegistration(TEST_INTEGRATION_ID, RELEASE_ID));
+
+    await expect(owner.install(callbacks([]))).resolves.toMatchObject({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activate).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    { selected: true, state: true, expected: 'kernel' },
+    { selected: true, state: false, expected: 'fallback' },
+    { selected: false, state: false, expected: 'kernel' },
+  ] as const)(
+    'validates selected first-display parser state before lifecycle activation ($selected, $state)',
+    async ({ selected, state, expected }) => {
+      const activate = vi.fn(() => vi.fn());
+      const owner = registry(Object.freeze({}), Object.freeze({ activate, start: vi.fn() }));
+      owner.register(
+        createLifecycleIntegrationRegistration(TEST_INTEGRATION_ID, RELEASE_ID, {
+          firstDisplaySliceId: 'datadome_initial',
+          validateFirstDisplayState: (candidate) =>
+            candidate.values.find(([key]) => key === 'route_guard')?.[1] === 'datadome',
+        })
+      );
+      const adoption = Object.freeze({
+        version: 1 as const,
+        adoptInitialDisplay: true as const,
+        handoff: {
+          version: 1,
+          releaseId: RELEASE_ID,
+          generation: 1,
+          projectionDigest: 'b'.repeat(64),
+          integrationConfigDigest: 'c'.repeat(64),
+          slices: Object.freeze(
+            selected ? ['first_display', 'datadome_initial'] : ['first_display']
+          ),
+          slots: [
+            {
+              id: 'slot-1',
+              aliases: [],
+              domId: 'slot-1',
+              gamPath: '/123/slot-1',
+              formats: [[300, 250]],
+              owner: 'trusted_server',
+              outcome: 'failed',
+              targeting: [],
+              targetingOwnership: [],
+              committedArtifact: 'none',
+              gptToken: null,
+            },
+          ],
+          attempts: [
+            {
+              id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+              slotId: 'slot-1',
+              ordinal: 1,
+              state: 'failed',
+              reason: 'internal_error',
+            },
+          ],
+          tombstones: [],
+          artifacts: [],
+          parserState: Object.freeze(
+            state
+              ? [
+                  Object.freeze({
+                    sliceId: 'datadome_initial',
+                    observations: Object.freeze(['route_guard']),
+                    values: Object.freeze([Object.freeze(['route_guard', 'datadome'] as const)]),
+                  }),
+                ]
+              : []
+          ),
+          gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+          timing: { bidsScriptMs: 1, firstDisplayMs: null, terminalMs: 2, paintMs: 3 },
+          highWater: {
+            navigationAttemptPrefix: 'AAECAwQFBgc',
+            nextNavigationAttemptOrdinal: 2,
+            nextAttemptOrdinal: 2,
+            nextSlotRegistrationOrdinal: 2,
+            reservationClockEpochMs: 0,
+            nextReservationOrdinal: 1,
+            nextTicketOrdinal: 1,
+          },
+          cycles: [],
+          trace: {
+            nextSequence: 1,
+            nextGlobalSlotOrdinal: 1,
+            slots: [{ slotId: 'slot-1', impressions: 0, bindings: [] }],
+          },
+          mutationRevision: 0,
+        },
+        identities: Object.freeze([]),
+      });
+      const slices = selected ? ['first_display', 'datadome_initial'] : ['first_display'];
+      const compactCapture = {
+        captureVersion: 1,
+        releaseId: RELEASE_ID,
+        generation: 1,
+        data: [
+          'b'.repeat(64),
+          'c'.repeat(64),
+          slices,
+          [['failed', 'internal_error', null, null]],
+          [],
+          [],
+          [],
+          state ? [['datadome_initial', [['route_guard', 'datadome']]]] : [],
+          [[], 0, 0],
+          [1, null, 2, 3],
+          [2, 0, 1, 1],
+          [],
+          1,
+          1,
+        ],
+        mutationRevision: 0,
+        identityCount: 0,
+      };
+      const boot = {
+        abi: 1,
+        releaseId: RELEASE_ID,
+        manifest: {},
+        auctionProjection: {
+          version: 1,
+          auction: {
+            version: 1,
+            auctionId: 'initial',
+            results: [{ slot: 'slot-1', outcome: 'failed', reason: 'internal_error' }],
+          },
+          slots: [
+            {
+              slot: 'slot-1',
+              gamUnitPath: '/123/slot-1',
+              divId: 'slot-1',
+              formats: [[300, 250]],
+              targeting: {},
+            },
+          ],
+          bids: [],
+        },
+        integrations: {},
+        creative: {},
+        diagnostics: {},
+      };
+
+      const result = await owner.install({
+        ...callbacks([]),
+        coordinateTakeover: (prepared) => {
+          const handoff = prepared.validateHandoff(
+            compactCapture,
+            {
+              version: 1,
+              releaseId: RELEASE_ID,
+              generation: 1,
+              projectionDigest: 'b'.repeat(64),
+              integrationConfigDigest: 'c'.repeat(64),
+              slices,
+              slotCount: 1,
+              outcomeCount: 1,
+              capabilities: [],
+              objectKinds: [],
+            },
+            boot
+          );
+          if (!handoff) throw new Error('should validate lifecycle handoff');
+          prepared.activate(Object.freeze({ ...adoption, handoff }));
+          prepared.commit();
+        },
+      });
+
+      expect(result.state).toBe(expected);
+      expect(activate).toHaveBeenCalledTimes(expected === 'kernel' ? 1 : 0);
+    }
+  );
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/phase_loader.test.ts b/crates/trusted-server-js/lib/test/kernel/phase_loader.test.ts
new file mode 100644
index 000000000..a0fa52fd8
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/phase_loader.test.ts
@@ -0,0 +1,616 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { BootManifestV1 } from '../../src/core/types';
+import {
+  createDeferredPhaseLoader,
+  createProtectedFirstDisplayGate,
+  type DeferredPhaseLoaderOptions,
+  type PhaseScheduler,
+} from '../../src/kernel/phase_loader';
+
+const RELEASE_ID = 'a'.repeat(64);
+const HASH = 'b'.repeat(64);
+
+function scheduler(options: { idle?: boolean } = {}): {
+  readonly frames: FrameRequestCallback[];
+  readonly idle: Array<() => void>;
+  readonly value: PhaseScheduler;
+} {
+  const frames: FrameRequestCallback[] = [];
+  const idle: Array<() => void> = [];
+  return {
+    frames,
+    idle,
+    value: {
+      cancelAnimationFrame: vi.fn(),
+      clearTimeout,
+      requestAnimationFrame: (callback) => {
+        frames.push(callback);
+        return frames.length;
+      },
+      ...(options.idle
+        ? {
+            cancelIdleCallback: vi.fn(),
+            requestIdleCallback: (callback: () => void) => {
+              idle.push(callback);
+              return idle.length;
+            },
+          }
+        : {}),
+      setTimeout,
+    },
+  };
+}
+
+function deferredManifest(ids: readonly string[]): BootManifestV1 {
+  return Object.freeze({
+    version: 1,
+    releaseId: RELEASE_ID,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${HASH}`,
+    integrations: Object.freeze([
+      Object.freeze({ id: 'render_runtime', phase: 'takeover' as const }),
+      ...ids.map((id) =>
+        Object.freeze({
+          id,
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          src: `/static/tsjs=tsjs-${id}.min.js?v=${HASH}`,
+        })
+      ),
+    ]),
+  });
+}
+
+function deferredRegistration(
+  id: string,
+  prepare = vi.fn(() => Object.freeze({ activate: () => undefined }))
+): object {
+  return Object.freeze({
+    abi: 1,
+    id,
+    phase: 'deferred',
+    releaseId: RELEASE_ID,
+    prepare,
+  });
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  document.head.replaceChildren();
+  vi.restoreAllMocks();
+});
+
+describe('protected first-display paint gate', () => {
+  it('adopts an agent-owned protected paint and proceeds directly to idle', async () => {
+    const platform = scheduler({ idle: true });
+    const markPaint = vi.fn();
+    const gate = createProtectedFirstDisplayGate({
+      document,
+      markPaint,
+      paintAlreadyRecorded: true,
+      scheduler: platform.value,
+    });
+
+    gate.commit();
+
+    expect(platform.frames).toEqual([]);
+    expect(platform.idle).toHaveLength(1);
+    expect(markPaint).not.toHaveBeenCalled();
+    expect(gate.protectAttemptBatch([Promise.resolve()])).toBe(false);
+    platform.idle.shift()?.();
+    await expect(gate.ready).resolves.toBe(true);
+  });
+
+  it('releases a no-attempt page only at 10 seconds, after two frames and idle', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler({ idle: true });
+    const marks: string[] = [];
+    const gate = createProtectedFirstDisplayGate({
+      document,
+      markPaint: () => marks.push('paint'),
+      scheduler: platform.value,
+    });
+    let released = false;
+    void gate.ready.then(() => (released = true));
+
+    gate.commit();
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(released).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(platform.frames).toHaveLength(1);
+    platform.frames.shift()?.(10_000);
+    expect(platform.frames).toHaveLength(1);
+    expect(marks).toEqual([]);
+    platform.frames.shift()?.(10_016);
+    expect(marks).toEqual(['paint']);
+    expect(released).toBe(false);
+    expect(platform.idle).toHaveLength(1);
+    platform.idle.shift()?.();
+    await Promise.resolve();
+    expect(released).toBe(true);
+  });
+
+  it('protects the first batch created at 9,999 ms until every terminal latch settles', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler({ idle: true });
+    let settle: (() => void) | undefined;
+    const terminal = new Promise<void>((resolve) => (settle = resolve));
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+
+    gate.commit();
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(gate.protectAttemptBatch(Object.freeze([terminal]))).toBe(true);
+    await vi.advanceTimersByTimeAsync(10_001);
+    expect(platform.frames).toEqual([]);
+    settle?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(platform.frames).toHaveLength(1);
+    platform.frames.shift()?.(20_000);
+    platform.frames.shift()?.(20_016);
+    platform.idle.shift()?.();
+    await expect(gate.ready).resolves.toBe(true);
+  });
+
+  it('uses a post-paint 50 ms fallback only when requestIdleCallback is unavailable', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler();
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+    let released = false;
+    void gate.ready.then(() => (released = true));
+
+    gate.commit();
+    await vi.advanceTimersByTimeAsync(10_000);
+    platform.frames.shift()?.(10_000);
+    platform.frames.shift()?.(10_016);
+    await vi.advanceTimersByTimeAsync(49);
+    expect(released).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(released).toBe(true);
+  });
+
+  it.each([10_000, 10_001])(
+    'does not protect a first attempt created at %i ms after the no-attempt release',
+    async (createdAtMs) => {
+      vi.useFakeTimers();
+      const platform = scheduler({ idle: true });
+      const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+      gate.commit();
+
+      await vi.advanceTimersByTimeAsync(createdAtMs);
+      expect(gate.protectAttemptBatch([Promise.resolve()])).toBe(false);
+    }
+  );
+
+  it('freezes the first protected batch and waits for every one of its members', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler({ idle: true });
+    let settleFirst: (() => void) | undefined;
+    let settleSecond: (() => void) | undefined;
+    const first = new Promise<void>((resolve) => (settleFirst = resolve));
+    const second = new Promise<void>((resolve) => (settleSecond = resolve));
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+    gate.commit();
+
+    expect(gate.protectAttemptBatch([first, second])).toBe(true);
+    expect(gate.protectAttemptBatch([Promise.resolve()])).toBe(false);
+    settleFirst?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(platform.frames).toEqual([]);
+    settleSecond?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(platform.frames).toHaveLength(1);
+  });
+
+  it('waits for visibility and two frames when a hidden page becomes visible first', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler({ idle: true });
+    Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' });
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+    gate.commit();
+    await vi.advanceTimersByTimeAsync(10_000);
+    await vi.advanceTimersByTimeAsync(1_999);
+    expect(platform.frames).toEqual([]);
+
+    Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'visible' });
+    document.dispatchEvent(new Event('visibilitychange'));
+    expect(platform.frames).toHaveLength(1);
+    platform.frames.shift()?.(12_000);
+    platform.frames.shift()?.(12_016);
+    platform.idle.shift()?.();
+    await expect(gate.ready).resolves.toBe(true);
+  });
+
+  it('uses the two-second hidden timeout without requesting a frame', async () => {
+    vi.useFakeTimers();
+    const platform = scheduler({ idle: true });
+    Object.defineProperty(document, 'visibilityState', { configurable: true, value: 'hidden' });
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: platform.value });
+    gate.commit();
+    await vi.advanceTimersByTimeAsync(11_999);
+    expect(platform.idle).toEqual([]);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(platform.frames).toEqual([]);
+    expect(platform.idle).toHaveLength(1);
+    platform.idle.shift()?.();
+    await expect(gate.ready).resolves.toBe(true);
+  });
+});
+
+describe('authenticated deferred module loading', () => {
+  it('starts every module in manifest order without awaiting a sibling', async () => {
+    const prepare = vi.fn();
+    const takeover = document.createElement('script');
+    takeover.nonce = 'response-nonce';
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: takeover,
+      document,
+      prepare,
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later', 'prebid_later']),
+      releaseId: RELEASE_ID,
+    });
+
+    await Promise.resolve();
+    const scripts = [...document.head.querySelectorAll('script')];
+    expect(scripts.map((script) => new URL(script.src).pathname)).toEqual([
+      '/static/tsjs=tsjs-gpt_later.min.js',
+      '/static/tsjs=tsjs-prebid_later.min.js',
+    ]);
+    expect(scripts.every((script) => script.async && script.nonce === 'response-nonce')).toBe(true);
+    expect(loader.state('gpt_later')).toBe('loading');
+    expect(loader.state('prebid_later')).toBe('loading');
+  });
+
+  it('requires one exact registration from the exact connected current script', async () => {
+    const prepare = vi.fn<DeferredPhaseLoaderOptions['prepare']>((registration, owner) =>
+      registration.prepare(
+        Object.freeze({
+          config: Object.freeze({}),
+          interfaces: Object.freeze({}),
+          signal: owner.signal,
+          onDispose: owner.onDispose,
+        })
+      )
+    );
+    const takeover = document.createElement('script');
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: takeover,
+      document,
+      prepare,
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const script = document.head.querySelector('script');
+    expect(script).not.toBeNull();
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+
+    const registration = deferredRegistration('gpt_later');
+    expect(loader.register(registration)).toBe(true);
+    script?.dispatchEvent(new Event('load'));
+    await vi.waitFor(() => expect(prepare).toHaveBeenCalledOnce());
+    expect(loader.state('gpt_later')).toBe('ready');
+    expect(loader.register(registration)).toBe(false);
+  });
+
+  it('ignores a publisher currentScript shadow and still admits the genuine deferred artifact', async () => {
+    const prepare = vi.fn<DeferredPhaseLoaderOptions['prepare']>(() =>
+      Object.freeze({ activate: () => undefined })
+    );
+    let trustedCurrentScript: HTMLScriptElement | null = null;
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      currentScript: () => trustedCurrentScript,
+      document,
+      prepare,
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const expected = document.head.querySelector('script');
+    expect(expected).not.toBeNull();
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: expected,
+    });
+    const publisherPrepare = vi.fn(() => Object.freeze({ activate: () => undefined }));
+
+    expect(loader.register(deferredRegistration('gpt_later', publisherPrepare))).toBe(false);
+    expect(loader.state('gpt_later')).toBe('loading');
+    expect(loader.reason('gpt_later')).toBeUndefined();
+    expect(publisherPrepare).not.toHaveBeenCalled();
+
+    trustedCurrentScript = expected;
+    expect(loader.register(deferredRegistration('gpt_later'))).toBe(true);
+    expected?.dispatchEvent(new Event('load'));
+    await vi.waitFor(() => expect(loader.state('gpt_later')).toBe('ready'));
+    expect(prepare).toHaveBeenCalledOnce();
+  });
+
+  it('isolates a failed module while a sibling reaches ready', async () => {
+    const prepare = vi.fn(async (registration: { readonly id: string }) => {
+      if (registration.id === 'gpt_later') throw new Error('fictional module failure');
+      return Object.freeze({ activate: () => undefined });
+    });
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare,
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later', 'prebid_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const scripts = [...document.head.querySelectorAll('script')];
+    for (const [index, id] of ['gpt_later', 'prebid_later'].entries()) {
+      Object.defineProperty(document, 'currentScript', {
+        configurable: true,
+        value: scripts[index],
+      });
+      expect(loader.register(deferredRegistration(id))).toBe(true);
+      scripts[index]?.dispatchEvent(new Event('load'));
+    }
+
+    await vi.waitFor(() => expect(loader.state('prebid_later')).toBe('ready'));
+    expect(loader.state('gpt_later')).toBe('unavailable');
+    expect(loader.reason('gpt_later')).toBe('prepare_failed');
+  });
+
+  it('classifies exact URL mutation before insertion as policy_blocked', async () => {
+    const takeover = document.createElement('script');
+    const originalCreate = document.createElement.bind(document);
+    vi.spyOn(document, 'createElement').mockImplementation(((name: string) => {
+      const element = originalCreate(name);
+      if (name === 'script') {
+        Object.defineProperty(element, 'src', {
+          configurable: true,
+          get: () => 'https://publisher.example/mutated.js',
+          set: () => undefined,
+        });
+      }
+      return element;
+    }) as typeof document.createElement);
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: takeover,
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+
+    await vi.waitFor(() => expect(loader.state('gpt_later')).toBe('unavailable'));
+    expect(loader.reason('gpt_later')).toBe('policy_blocked');
+    expect(document.head.querySelector('script')).toBeNull();
+  });
+
+  it.each([
+    ['error', 'load_error'],
+    ['load', 'load_without_registration'],
+  ] as const)('classifies a script %s without accepted registration', async (event, reason) => {
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    document.head.querySelector('script')?.dispatchEvent(new Event(event));
+
+    await vi.waitFor(() => expect(loader.state('gpt_later')).toBe('unavailable'));
+    expect(loader.reason('gpt_later')).toBe(reason);
+  });
+
+  it('rejects registration after the expected node is removed or replaced', async () => {
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const expected = document.head.querySelector('script');
+    const replacement = document.createElement('script');
+    expected?.replaceWith(replacement);
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: expected });
+
+    expect(loader.register(deferredRegistration('gpt_later'))).toBe(false);
+    expect(loader.reason('gpt_later')).toBe('registration_rejected');
+  });
+
+  it.each([
+    [
+      'activation',
+      () =>
+        Object.freeze({
+          activate: () => {
+            throw new Error('activation');
+          },
+        }),
+      'activation_failed',
+    ],
+    [
+      'after commit',
+      () =>
+        Object.freeze({
+          activate: ({ afterCommit }: { afterCommit: (callback: () => void) => void }) =>
+            afterCommit(() => {
+              throw new Error('after commit');
+            }),
+        }),
+      'after_commit_failed',
+    ],
+  ] as const)('classifies an %s failure at its exact stage', async (_name, prepared, reason) => {
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: () => prepared(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const script = document.head.querySelector('script');
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+    expect(loader.register(deferredRegistration('gpt_later'))).toBe(true);
+    script?.dispatchEvent(new Event('load'));
+
+    await vi.waitFor(() => expect(loader.state('gpt_later')).toBe('unavailable'));
+    expect(loader.reason('gpt_later')).toBe(reason);
+  });
+
+  it('keeps the shared module alive after one caller deadline expires', async () => {
+    vi.useFakeTimers();
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: () => Object.freeze({ activate: () => undefined }),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    const caller = loader.waitFor('gpt_later', 100);
+    await vi.advanceTimersByTimeAsync(100);
+    await expect(caller).resolves.toBe('caller_timeout');
+    expect(loader.state('gpt_later')).toBe('loading');
+
+    const script = document.head.querySelector('script');
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+    expect(loader.register(deferredRegistration('gpt_later'))).toBe(true);
+    script?.dispatchEvent(new Event('load'));
+    await expect(loader.waitFor('gpt_later', 100)).resolves.toBe('ready');
+  });
+
+  it('retires a hung shared module at its independent ten-second deadline', async () => {
+    vi.useFakeTimers();
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(9_999);
+    expect(loader.state('gpt_later')).toBe('loading');
+    await vi.advanceTimersByTimeAsync(1);
+    expect(loader.state('gpt_later')).toBe('unavailable');
+    expect(loader.reason('gpt_later')).toBe('module_timeout');
+  });
+
+  it('does not start after the owning gate is disposed', async () => {
+    const gate = createProtectedFirstDisplayGate({ document, scheduler: scheduler().value });
+    const loader = createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: gate.ready,
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+
+    gate.dispose();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(document.head.querySelector('script')).toBeNull();
+    expect(loader.reason('gpt_later')).toBe('disposed');
+  });
+
+  it('uses window origin rather than a hostile document base URL', async () => {
+    const base = document.createElement('base');
+    base.href = 'https://attacker.example/subtree/';
+    document.head.append(base);
+    createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+
+    expect(document.head.querySelector('script')?.src).toBe(
+      `${window.location.origin}/static/tsjs=tsjs-gpt_later.min.js?v=${HASH}`
+    );
+  });
+
+  it('creates the fixed Trusted Types policy once and admits only canonical absolute URLs', async () => {
+    const createPolicy = vi.fn((_name: string, rules: { createScriptURL(value: string): string }) =>
+      Object.freeze({ createScriptURL: rules.createScriptURL })
+    );
+    Object.defineProperty(window, 'trustedTypes', {
+      configurable: true,
+      value: Object.freeze({ createPolicy }),
+    });
+    createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later', 'prebid_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+
+    expect(createPolicy).toHaveBeenCalledOnce();
+    expect(createPolicy).toHaveBeenCalledWith(
+      'trusted-server#tsjs-v1',
+      expect.objectContaining({ createScriptURL: expect.any(Function) })
+    );
+    const rules = createPolicy.mock.calls[0]?.[1];
+    expect(() => rules?.createScriptURL('https://attacker.example/x.js')).toThrow();
+  });
+
+  it('reuses the bootstrap Trusted Types capability without creating the fixed policy twice', async () => {
+    const runtimeScript = document.createElement('script');
+    const createScriptURL = vi.fn((value: string) => value);
+    const createPolicy = vi.fn(() => {
+      throw new TypeError('duplicate policy');
+    });
+    Object.defineProperty(window, 'trustedTypes', {
+      configurable: true,
+      value: Object.freeze({ createPolicy }),
+    });
+    createDeferredPhaseLoader({
+      runtimeScript,
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+      trustedScriptUrl: createScriptURL,
+    });
+    await Promise.resolve();
+
+    expect(createPolicy).not.toHaveBeenCalled();
+    expect(createScriptURL).toHaveBeenCalledWith(
+      `${window.location.origin}/static/tsjs=tsjs-gpt_later.min.js?v=${HASH}`
+    );
+  });
+
+  it('copies no nonce when the takeover script has no nonempty nonce', async () => {
+    createDeferredPhaseLoader({
+      runtimeScript: document.createElement('script'),
+      document,
+      prepare: vi.fn(),
+      gate: Promise.resolve(),
+      manifest: deferredManifest(['gpt_later']),
+      releaseId: RELEASE_ID,
+    });
+    await Promise.resolve();
+    expect(document.head.querySelector('script')?.nonce).toBe('');
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/release_catalog.test.ts b/crates/trusted-server-js/lib/test/kernel/release_catalog.test.ts
new file mode 100644
index 000000000..e86d35516
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/release_catalog.test.ts
@@ -0,0 +1,345 @@
+import { describe, expect, it } from 'vitest';
+
+import { FIRST_DISPLAY_CONTRACT_IDS } from '../../src/shared/first_display_contracts';
+import * as releaseCatalog from '../../src/kernel/release_catalog';
+import {
+  FIRST_DISPLAY_CATALOG,
+  MAX_FIRST_DISPLAY_SLICES,
+  MAX_TAKEOVER_MODULES,
+  MAX_MANIFEST_MODULES,
+  MINIMAL_TAKEOVER_IDS,
+  REFERENCE_TAKEOVER_IDS,
+  RELEASE_CATALOG,
+  selectFirstDisplayCatalog,
+  selectReleaseCatalog,
+  validateReleaseCatalog,
+  type ReleaseCatalogEntry,
+} from '../../src/kernel/release_catalog';
+
+const EXPECTED = [
+  ['render_runtime', 'runtime', 'takeover', null, 'always', null],
+  ['aps', 'APS', 'takeover', null, 'integration:aps', 'aps'],
+  ['creative', 'creative', 'takeover', null, 'creative_guard', 'creative'],
+  ['datadome', 'DataDome', 'takeover', null, 'integration:datadome', 'datadome'],
+  ['didomi', 'Didomi', 'takeover', null, 'integration:didomi', 'didomi'],
+  [
+    'google_tag_manager',
+    'GTM/GA',
+    'takeover',
+    null,
+    'integration:google_tag_manager',
+    'google_tag_manager',
+  ],
+  ['gpt', 'GPT', 'takeover', null, 'integration:gpt', 'gpt'],
+  ['gpt_diagnostics', 'diagnostics', 'takeover', null, 'gpt_diagnostics_active', 'diagnostics'],
+  ['lockr', 'Lockr', 'takeover', null, 'integration:lockr', 'lockr'],
+  ['osano_consent', 'Osano', 'takeover', null, 'integration:osano', 'osano'],
+  ['permutive_context', 'Permutive', 'takeover', null, 'integration:permutive', 'permutive'],
+  [
+    'sourcepoint_consent',
+    'Sourcepoint',
+    'takeover',
+    null,
+    'integration:sourcepoint',
+    'sourcepoint',
+  ],
+  ['prebid', 'Prebid', 'takeover', null, 'integration:prebid', 'prebid'],
+  ['testlight', 'Testlight', 'takeover', null, 'integration:testlight', 'testlight'],
+  [
+    'diagnostics_presentation',
+    'diagnostics',
+    'deferred',
+    'first_display_or_idle',
+    'diagnostics_presentation',
+    null,
+  ],
+  ['gpt_later', 'GPT', 'deferred', 'first_display_or_idle', 'integration:gpt', 'gpt'],
+  ['osano_lifecycle', 'Osano', 'deferred', 'first_display_or_idle', 'integration:osano', 'osano'],
+  [
+    'permutive_lifecycle',
+    'Permutive',
+    'deferred',
+    'first_display_or_idle',
+    'integration:permutive',
+    'permutive',
+  ],
+  ['prebid_later', 'Prebid', 'deferred', 'first_display_or_idle', 'prebid_and_gpt', 'prebid'],
+  [
+    'sourcepoint_lifecycle',
+    'Sourcepoint',
+    'deferred',
+    'first_display_or_idle',
+    'integration:sourcepoint',
+    'sourcepoint',
+  ],
+] as const;
+
+describe('canonical release catalog', () => {
+  it('pins the exact fourteen first-display rows and closed server-owned selection', () => {
+    expect(FIRST_DISPLAY_CONTRACT_IDS).toEqual(FIRST_DISPLAY_CATALOG.map(({ id }) => id));
+    expect(FIRST_DISPLAY_CATALOG.map(({ order, id }) => [order, id])).toEqual([
+      [1, 'first_display'],
+      [2, 'render_owner_initial'],
+      [3, 'aps_initial'],
+      [4, 'creative_initial'],
+      [5, 'datadome_initial'],
+      [6, 'didomi_initial'],
+      [7, 'google_tag_manager_initial'],
+      [8, 'gpt_initial'],
+      [9, 'lockr_initial'],
+      [10, 'osano_initial'],
+      [11, 'permutive_initial'],
+      [12, 'sourcepoint_initial'],
+      [13, 'prebid_initial'],
+      [14, 'testlight_initial'],
+    ]);
+    expect(MAX_FIRST_DISPLAY_SLICES).toBe(14);
+    expect(
+      selectFirstDisplayCatalog({
+        eligibleBatch: true,
+        integrations: ['aps', 'gpt', 'prebid'],
+        apsParticipates: true,
+        renderOwnerParticipates: true,
+        prebidParticipates: true,
+      }).map(({ id }) => id)
+    ).toEqual([
+      'first_display',
+      'render_owner_initial',
+      'aps_initial',
+      'gpt_initial',
+      'prebid_initial',
+    ]);
+    expect(
+      selectFirstDisplayCatalog({
+        eligibleBatch: true,
+        integrations: ['gpt'],
+        renderOwnerParticipates: true,
+      }).map(({ id }) => id)
+    ).toEqual(['first_display', 'render_owner_initial', 'gpt_initial']);
+    expect(
+      selectFirstDisplayCatalog({
+        eligibleBatch: true,
+        integrations: ['gpt'],
+        renderOwnerParticipates: false,
+      }).map(({ id }) => id)
+    ).toEqual(['first_display', 'gpt_initial']);
+    expect(
+      selectFirstDisplayCatalog({
+        eligibleBatch: true,
+        integrations: ['gpt'],
+        apsParticipates: true,
+      }).map(({ id }) => id)
+    ).toEqual(['first_display', 'gpt_initial']);
+    expect(selectFirstDisplayCatalog({ eligibleBatch: false, integrations: [] })).toEqual([]);
+    expect(() =>
+      selectFirstDisplayCatalog({ eligibleBatch: true, integrations: ['unknown'] })
+    ).toThrow(/unknown/i);
+    expect(
+      FIRST_DISPLAY_CATALOG.every(
+        ({ allowedImports, inputs, outputs, obligation }) =>
+          allowedImports.length > 0 &&
+          inputs.length > 0 &&
+          outputs.length > 0 &&
+          obligation.length > 0
+      )
+    ).toBe(true);
+  });
+  it('pins the exact twenty rows, phases, triggers, products, predicates, and order', () => {
+    expect(
+      RELEASE_CATALOG.map(({ id, product, phase, trigger, include, config }) => [
+        id,
+        product,
+        phase,
+        trigger,
+        include,
+        config,
+      ])
+    ).toEqual(EXPECTED);
+    expect(RELEASE_CATALOG.map(({ order }) => order)).toEqual(
+      Array.from({ length: 20 }, (_, index) => index + 1)
+    );
+  });
+
+  it('pins the exact capability graph and named scopes', () => {
+    expect(RELEASE_CATALOG.map(({ id, provides, consumes }) => [id, provides, consumes])).toEqual([
+      [
+        'render_runtime',
+        [
+          'slots.v1',
+          'auction.v1',
+          'render.v1',
+          'messages.v1',
+          'trace.v1',
+          'trace.presentation.v1',
+          'direct.v1',
+        ],
+        ['runtime.v1'],
+      ],
+      ['aps', ['aps.v1'], ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'trace.v1']],
+      ['creative', [], ['runtime.v1']],
+      ['datadome', [], ['runtime.v1']],
+      ['didomi', [], ['runtime.v1']],
+      ['google_tag_manager', [], ['runtime.v1']],
+      [
+        'gpt',
+        ['gpt.v1', 'gpt.events.v1', 'pbs_cache.baseline.v1'],
+        [
+          'runtime.v1',
+          'slots.v1',
+          'auction.v1',
+          'render.v1',
+          'messages.v1',
+          'trace.v1',
+          'aps.v1?aps',
+        ],
+      ],
+      ['gpt_diagnostics', ['gpt_diag.v1'], ['runtime.v1', 'gpt.events.v1']],
+      ['lockr', [], ['runtime.v1']],
+      ['osano_consent', ['osano_consent.v1'], ['runtime.v1']],
+      ['permutive_context', ['permutive_context.v1'], ['runtime.v1']],
+      ['sourcepoint_consent', ['sourcepoint_consent.v1'], ['runtime.v1']],
+      [
+        'prebid',
+        ['prebid.v1'],
+        ['runtime.v1', 'slots.v1', 'render.v1', 'messages.v1', 'aps.v1?aps'],
+      ],
+      ['testlight', [], ['runtime.v1']],
+      [
+        'diagnostics_presentation',
+        [],
+        ['runtime.v1', 'trace.presentation.v1', 'gpt_diag.v1?gpt_diagnostics_active'],
+      ],
+      [
+        'gpt_later',
+        [],
+        ['runtime.v1', 'slots.v1', 'auction.v1', 'render.v1', 'gpt.v1', 'trace.v1'],
+      ],
+      ['osano_lifecycle', [], ['runtime.v1', 'osano_consent.v1']],
+      ['permutive_lifecycle', [], ['runtime.v1', 'permutive_context.v1']],
+      ['prebid_later', [], ['runtime.v1', 'slots.v1', 'gpt.v1', 'prebid.v1']],
+      ['sourcepoint_lifecycle', [], ['runtime.v1', 'sourcepoint_consent.v1']],
+    ]);
+    expect(RELEASE_CATALOG.every(({ obligation }) => obligation.length > 0)).toBe(true);
+  });
+
+  it('derives capacity and budget vectors without an internal diagnostics subscriber cap', () => {
+    expect(MAX_TAKEOVER_MODULES).toBe(14);
+    expect(MAX_MANIFEST_MODULES).toBe(20);
+    expect('MAX_INTERNAL_DIAGNOSTICS_SUBSCRIPTIONS' in releaseCatalog).toBe(false);
+    expect(MINIMAL_TAKEOVER_IDS).toEqual(['core', 'render_runtime']);
+    expect(REFERENCE_TAKEOVER_IDS).toEqual([
+      'core',
+      'render_runtime',
+      'creative',
+      'gpt',
+      'prebid',
+      'datadome',
+    ]);
+    expect(() => validateReleaseCatalog(RELEASE_CATALOG.slice(0, 13))).not.toThrow();
+    expect(() => validateReleaseCatalog(RELEASE_CATALOG.slice(0, 14))).not.toThrow();
+    expect(() => validateReleaseCatalog(RELEASE_CATALOG.slice(0, 15))).not.toThrow();
+    expect(() => validateReleaseCatalog(RELEASE_CATALOG.slice(0, 19))).not.toThrow();
+    expect(() => validateReleaseCatalog(RELEASE_CATALOG.slice(0, 20))).not.toThrow();
+    const fifteenTakeover = [
+      ...RELEASE_CATALOG.slice(0, 14),
+      {
+        ...RELEASE_CATALOG[14]!,
+        phase: 'takeover' as const,
+        trigger: null,
+      },
+    ];
+    expect(() => validateReleaseCatalog(fifteenTakeover)).toThrow(
+      /takeover capacity|phase override/i
+    );
+    expect(() => validateReleaseCatalog([...RELEASE_CATALOG, RELEASE_CATALOG[0]!])).toThrow();
+  });
+
+  it('selects rows only through deny-unknown server-owned predicates', () => {
+    expect(selectReleaseCatalog({ integrations: [] }).map(({ id }) => id)).toEqual([
+      'render_runtime',
+    ]);
+    expect(
+      selectReleaseCatalog({
+        integrations: ['aps', 'gpt', 'prebid'],
+        creative: { enabled: true, clickGuard: false, renderGuard: true },
+        gptDiagnosticsActive: true,
+        renderTraceOverlay: true,
+      }).map(({ id }) => id)
+    ).toEqual([
+      'render_runtime',
+      'aps',
+      'creative',
+      'gpt',
+      'gpt_diagnostics',
+      'prebid',
+      'diagnostics_presentation',
+      'gpt_later',
+      'prebid_later',
+    ]);
+    expect(
+      selectReleaseCatalog({
+        integrations: [],
+        gptDiagnosticsActive: true,
+        renderTraceOverlay: false,
+      }).map(({ id }) => id)
+    ).toEqual(['render_runtime', 'gpt_diagnostics', 'diagnostics_presentation']);
+    expect(
+      selectReleaseCatalog({
+        integrations: [],
+        gptDiagnosticsActive: false,
+        renderTraceOverlay: true,
+      }).map(({ id }) => id)
+    ).toEqual(['render_runtime', 'diagnostics_presentation']);
+    expect(
+      selectReleaseCatalog({
+        integrations: [],
+        gptDiagnosticsActive: false,
+        renderTraceOverlay: false,
+      }).map(({ id }) => id)
+    ).toEqual(['render_runtime']);
+    expect(() => selectReleaseCatalog({ integrations: ['unknown'] })).toThrow(/unknown/i);
+  });
+
+  it('rejects duplicate providers, undeclared edges, cycles, deferred providers, and bad order', () => {
+    const clone = (): ReleaseCatalogEntry[] => RELEASE_CATALOG.map((entry) => ({ ...entry }));
+
+    const duplicateProvider = clone();
+    duplicateProvider[2] = { ...duplicateProvider[2]!, provides: ['aps.v1'] };
+    expect(() => validateReleaseCatalog(duplicateProvider)).toThrow(/provider/i);
+
+    const unknownEdge = clone();
+    unknownEdge[2] = { ...unknownEdge[2]!, consumes: ['missing.v1'] };
+    expect(() => validateReleaseCatalog(unknownEdge)).toThrow(/capability/i);
+
+    const deferredProvider = clone();
+    deferredProvider[14] = { ...deferredProvider[14]!, provides: ['later.v1'] };
+    expect(() => validateReleaseCatalog(deferredProvider)).toThrow(/deferred provider/i);
+
+    const cycle = clone();
+    cycle[0] = { ...cycle[0]!, consumes: ['aps.v1'] };
+    expect(() => validateReleaseCatalog(cycle)).toThrow(/order|cycle/i);
+
+    const wrongOrder = clone();
+    [wrongOrder[0], wrongOrder[1]] = [wrongOrder[1]!, wrongOrder[0]!];
+    expect(() => validateReleaseCatalog(wrongOrder)).toThrow(/order/i);
+
+    const phaseOverride = clone();
+    phaseOverride[13] = {
+      ...phaseOverride[13]!,
+      phase: 'deferred',
+      trigger: 'first_display_or_idle',
+    };
+    expect(() => validateReleaseCatalog(phaseOverride)).toThrow(/phase override/i);
+
+    const configOverride = clone();
+    configOverride[15] = { ...configOverride[15]!, config: 'prebid' };
+    expect(() => validateReleaseCatalog(configOverride)).toThrow(/config|catalog/i);
+
+    const invalidConditionalEdge = clone();
+    invalidConditionalEdge[12] = {
+      ...invalidConditionalEdge[12]!,
+      consumes: ['runtime.v1', 'aps.v1?publisher_choice'],
+    };
+    expect(() => validateReleaseCatalog(invalidConditionalEdge)).toThrow(/conditional/i);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/runtime.test.ts b/crates/trusted-server-js/lib/test/kernel/runtime.test.ts
new file mode 100644
index 000000000..37704329b
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/runtime.test.ts
@@ -0,0 +1,2865 @@
+import { afterEach, describe, expect, expectTypeOf, it, vi } from 'vitest';
+
+import {
+  AdUnitRegistrationError,
+  RequestAdsInputError,
+  TsjsUnavailableError,
+  type AdUnitRegistrationErrorCode,
+} from '../../src/kernel/fallback';
+import { createRuntime as createRuntimeOwner, type RuntimeOptions } from '../../src/kernel/runtime';
+import { snapshotTsjsBootV1 } from '../../src/core/contracts/boot';
+import { createDiagnosticsPresentationIntegrationRegistration } from '../../src/integrations/gpt_diagnostics/presentation';
+import type {
+  IntegrationPrepareContext,
+  PreparedIntegration,
+} from '../../src/kernel/integration_registry';
+import { createLifecycleIntegrationRegistration } from '../../src/kernel/lifecycle_module';
+import { failedFirstDisplayTakeover } from '../first_display/helpers/compact_takeover';
+
+const RELEASE = 'a'.repeat(64);
+const TRUSTED_RUNTIME_SRC = `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`;
+
+function takeoverRegistration(
+  candidate: Readonly<{
+    abi: 1;
+    id: string;
+    phase: 'takeover';
+    releaseId: string;
+    prepare: (
+      context: IntegrationPrepareContext
+    ) => PreparedIntegration | PromiseLike<PreparedIntegration>;
+  }>
+) {
+  return Object.freeze({
+    abi: candidate.abi,
+    id: candidate.id,
+    phase: candidate.phase,
+    releaseId: candidate.releaseId,
+    prepareSync: (context: IntegrationPrepareContext) =>
+      candidate.prepare(context) as PreparedIntegration,
+    prepare: candidate.prepare,
+  });
+}
+
+function installTestRuntimeScript(runtimeDocument: Document, takeover = false): void {
+  if (runtimeDocument.currentScript) return;
+  const script = runtimeDocument.createElement('script');
+  script.id = takeover ? 'trustedserver-js-runtime' : 'trustedserver-js';
+  script.src = new URL(TRUSTED_RUNTIME_SRC, runtimeDocument.location.origin).href;
+  runtimeDocument.head.insertBefore(script, null);
+  Object.defineProperty(runtimeDocument, 'currentScript', {
+    configurable: true,
+    value: script,
+  });
+}
+
+function createRuntime(options: RuntimeOptions) {
+  installTestRuntimeScript(options.document ?? document, options.coordinateTakeover !== undefined);
+  let acceptedOptions = options;
+  try {
+    if (
+      typeof options.boot === 'object' &&
+      options.boot !== null &&
+      !Array.isArray(options.boot) &&
+      Object.getPrototypeOf(options.boot) === Object.prototype
+    ) {
+      const descriptors = Object.getOwnPropertyDescriptors(options.boot);
+      if (Object.values(descriptors).every((descriptor) => 'value' in descriptor)) {
+        const fields = Object.fromEntries(
+          Object.entries(descriptors).map(([key, descriptor]) => [key, descriptor.value])
+        );
+        const carrier = Object.prototype.hasOwnProperty.call(fields, 'integrations')
+          ? fields['integrations']
+          : defaultIntegrationConfigs(options.manifest);
+        const candidate = Object.prototype.hasOwnProperty.call(fields, 'abi')
+          ? options.boot
+          : {
+              abi: 1,
+              releaseId: RELEASE,
+              manifest: options.manifest,
+              auctionProjection: fields['auctionProjection'],
+              integrations: carrier,
+              creative: fields['creative'],
+              diagnostics: fields['diagnostics'],
+            };
+        const snapshot = snapshotTsjsBootV1(candidate, RELEASE);
+        if (snapshot) {
+          const retained =
+            Object.prototype.hasOwnProperty.call(fields, 'abi') && Object.isFrozen(options.boot);
+          const acceptedBoot = retained ? options.boot : snapshot;
+          acceptedOptions = {
+            ...options,
+            manifest: retained ? fields['manifest'] : snapshot.manifest,
+            boot: acceptedBoot,
+          };
+        }
+      }
+    }
+  } catch {
+    // Hostile values remain untouched so production boundary tests can reject them.
+  }
+  return createRuntimeOwner(acceptedOptions);
+}
+
+const CONFIG_ORDER = Object.freeze([
+  'aps',
+  'datadome',
+  'didomi',
+  'google_tag_manager',
+  'gpt',
+  'lockr',
+  'osano',
+  'permutive',
+  'prebid',
+  'sourcepoint',
+  'testlight',
+]);
+
+function configProduct(id: string): string | undefined {
+  if (id === 'gpt' || id === 'gpt_later') return 'gpt';
+  if (id === 'osano_consent' || id === 'osano_lifecycle') return 'osano';
+  if (id === 'permutive_context' || id === 'permutive_lifecycle') return 'permutive';
+  if (id === 'prebid' || id === 'prebid_later') return 'prebid';
+  if (id === 'sourcepoint_consent' || id === 'sourcepoint_lifecycle') return 'sourcepoint';
+  return CONFIG_ORDER.includes(id) ? id : undefined;
+}
+
+function defaultConfig(id: string): Readonly<Record<string, unknown>> {
+  if (id === 'didomi') return { proxyPath: '/integrations/didomi/sdk.js' };
+  if (id === 'gpt') return { gamAttributionEnabled: false, pageBidsEnabled: true };
+  if (id === 'prebid') {
+    return { accountId: 'test', timeout: 1_000, debug: false, bidders: [] };
+  }
+  if (id === 'sourcepoint') return { rewriteSdk: false };
+  return {};
+}
+
+function defaultIntegrationConfigs(candidateManifest: unknown): Readonly<Record<string, unknown>> {
+  const entries =
+    typeof candidateManifest === 'object' &&
+    candidateManifest !== null &&
+    Array.isArray((candidateManifest as { integrations?: unknown }).integrations)
+      ? (candidateManifest as { integrations: Array<{ id?: unknown }> }).integrations
+      : [];
+  const selected = new Set(
+    entries.flatMap(({ id }) => (typeof id === 'string' ? [configProduct(id)] : []))
+  );
+  return {
+    version: 1,
+    entries: CONFIG_ORDER.filter((id) => selected.has(id)).map((id) => ({
+      id,
+      config: defaultConfig(id),
+    })),
+  };
+}
+
+function boot(results: readonly object[] = []) {
+  return {
+    auctionProjection: {
+      version: 1,
+      auction: { version: 1, auctionId: 'boot', results },
+      slots: results.map((result) => {
+        const slot = (result as { readonly slot?: unknown }).slot;
+        return {
+          slot,
+          gamUnitPath: `/123/${String(slot)}`,
+          divId: String(slot),
+          formats: [[300, 250]],
+          targeting: {},
+        };
+      }),
+      bids: [],
+    },
+    creative: { version: 1, enabled: false, clickGuard: false, renderGuard: false },
+    diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: false } },
+  };
+}
+
+function takeoverHandoff() {
+  const projectionDigest = 'b'.repeat(64);
+  const compact = failedFirstDisplayTakeover(RELEASE);
+  return {
+    capture: compact.capture,
+    boot: compact.boot,
+    handoff: {
+      version: 1,
+      releaseId: RELEASE,
+      generation: 1,
+      projectionDigest,
+      integrationConfigDigest: 'c'.repeat(64),
+      slices: ['first_display'],
+      slots: [
+        {
+          id: 'slot-1',
+          aliases: [],
+          domId: 'div-1',
+          gamPath: '/123/slot-1',
+          formats: [[300, 250]],
+          owner: 'trusted_server',
+          outcome: 'failed',
+          targeting: [],
+          targetingOwnership: [],
+          committedArtifact: 'none',
+          gptToken: null,
+        },
+      ],
+      attempts: [
+        {
+          id: 'a1_AAECAwQFBgcAAAAAAAAAAQ',
+          slotId: 'slot-1',
+          ordinal: 1,
+          state: 'failed',
+          reason: 'internal_error',
+        },
+      ],
+      tombstones: [],
+      artifacts: [],
+      parserState: [],
+      gptDiagnostics: { facts: [], overflowCount: 0, dropCount: 0 },
+      timing: { bidsScriptMs: 0, firstDisplayMs: null, terminalMs: 0, paintMs: 0 },
+      highWater: {
+        navigationAttemptPrefix: 'AAECAwQFBgc',
+        nextNavigationAttemptOrdinal: 2,
+        nextAttemptOrdinal: 2,
+        nextSlotRegistrationOrdinal: 2,
+        reservationClockEpochMs: 0,
+        nextReservationOrdinal: 1,
+        nextTicketOrdinal: 1,
+      },
+      cycles: [],
+      trace: {
+        nextSequence: 1,
+        nextGlobalSlotOrdinal: 2,
+        slots: [{ slotId: 'slot-1', impressions: 0, bindings: [] }],
+      },
+      mutationRevision: 0,
+    },
+    outline: {
+      version: 1,
+      releaseId: RELEASE,
+      generation: 1,
+      projectionDigest,
+      integrationConfigDigest: 'c'.repeat(64),
+      slices: ['first_display'],
+      slotCount: 1,
+      outcomeCount: 1,
+      capabilities: [],
+      objectKinds: [],
+    },
+  } as const;
+}
+
+function manifest(ids: readonly string[]) {
+  const deferredIds = new Set([
+    'diagnostics_presentation',
+    'gpt_later',
+    'osano_lifecycle',
+    'permutive_lifecycle',
+    'prebid_later',
+    'sourcepoint_lifecycle',
+  ]);
+  return {
+    version: 1,
+    releaseId: RELEASE,
+    firstDisplay: null,
+    runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${'c'.repeat(64)}`,
+    integrations: ids.map((id) =>
+      deferredIds.has(id)
+        ? {
+            id,
+            phase: 'deferred' as const,
+            trigger: 'first_display_or_idle' as const,
+            src: `/static/tsjs=tsjs-${id}.min.js?v=${'d'.repeat(64)}`,
+          }
+        : { id, phase: 'takeover' as const }
+    ),
+  };
+}
+
+type ReflectionTrap = 'getPrototypeOf' | 'ownKeys' | 'getOwnPropertyDescriptor';
+
+function hostileRecord(trap: ReflectionTrap, target: object = {}): object {
+  const fail = () => {
+    throw new Error(`hostile ${trap}`);
+  };
+  const handler: ProxyHandler<object> = {};
+  if (trap === 'getPrototypeOf') handler.getPrototypeOf = fail;
+  if (trap === 'ownKeys') handler.ownKeys = fail;
+  if (trap === 'getOwnPropertyDescriptor') handler.getOwnPropertyDescriptor = fail;
+  return new Proxy(target, handler);
+}
+
+function thrownBy(callback: () => unknown): unknown {
+  try {
+    callback();
+  } catch (error) {
+    return error;
+  }
+  throw new Error('Expected callback to throw');
+}
+
+describe('Runtime bootstrap owner', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    document.head.replaceChildren();
+    Object.defineProperty(document, 'currentScript', { configurable: true, value: null });
+  });
+
+  it('exports the exact programmatic registration error taxonomy', () => {
+    type ExpectedCode =
+      | 'invalid_units'
+      | 'invalid_unit'
+      | 'invalid_code'
+      | 'duplicate_code'
+      | 'slot_collision'
+      | 'invalid_media_types'
+      | 'invalid_dimensions'
+      | 'dimensions_out_of_range'
+      | 'invalid_bids'
+      | 'invalid_bidder'
+      | 'invalid_params'
+      | 'request_body_too_large'
+      | 'registry_capacity';
+
+    expectTypeOf<AdUnitRegistrationErrorCode>().toEqualTypeOf<ExpectedCode>();
+    expectTypeOf<AdUnitRegistrationError['code']>().toEqualTypeOf<ExpectedCode>();
+  });
+
+  it.each([
+    {
+      boundary: 'no document',
+      arrange: () => {
+        vi.stubGlobal('document', undefined);
+        return undefined;
+      },
+    },
+    {
+      boundary: 'no takeover tag',
+      arrange: () => document,
+    },
+    {
+      boundary: 'wrong realm and owner document',
+      arrange: () => {
+        const frame = document.createElement('iframe');
+        document.body.append(frame);
+        const foreignDocument = frame.contentDocument;
+        if (!foreignDocument) throw new Error('should expose an iframe document');
+        const script = foreignDocument.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = new URL(TRUSTED_RUNTIME_SRC, window.location.origin).href;
+        foreignDocument.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'wrong id',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'publisher-script';
+        script.src = new URL(TRUSTED_RUNTIME_SRC, window.location.origin).href;
+        document.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'disconnected tag',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = new URL(TRUSTED_RUNTIME_SRC, window.location.origin).href;
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'duplicate tag',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = new URL(TRUSTED_RUNTIME_SRC, window.location.origin).href;
+        const duplicate = script.cloneNode() as HTMLScriptElement;
+        document.head.append(script, duplicate);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'cross-origin source',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = `https://attacker.example${TRUSTED_RUNTIME_SRC}`;
+        document.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'fragment source',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = `${new URL(TRUSTED_RUNTIME_SRC, window.location.origin).href}#publisher`;
+        document.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'wrong route',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = new URL(
+          `/static/tsjs=tsjs-publisher.min.js?v=${'c'.repeat(64)}`,
+          window.location.origin
+        ).href;
+        document.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+    {
+      boundary: 'malformed artifact hash',
+      arrange: () => {
+        const script = document.createElement('script');
+        script.id = 'trustedserver-js';
+        script.src = new URL(
+          `/static/tsjs=tsjs-unified.min.js?v=${'C'.repeat(64)}`,
+          window.location.origin
+        ).href;
+        document.head.append(script);
+        Object.defineProperty(document, 'currentScript', { configurable: true, value: script });
+        return document;
+      },
+    },
+  ])('rejects caller-supplied takeover source at the $boundary boundary', ({ arrange }) => {
+    const runtimeDocument = arrange();
+    const queued = vi.fn();
+    const target = { boot: boot(), que: [queued] };
+    const bootDescriptor = Object.getOwnPropertyDescriptor(target, 'boot');
+    const queueDescriptor = Object.getOwnPropertyDescriptor(target, 'que');
+    const options: RuntimeOptions & Record<string, unknown> = {
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: target.boot,
+      ...(runtimeDocument ? { document: runtimeDocument } : {}),
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    };
+    options['trustedRuntimeSrc'] = TRUSTED_RUNTIME_SRC;
+    const runtime = createRuntimeOwner(options);
+
+    expect(runtime.start()).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(Object.getOwnPropertyDescriptor(target, 'boot')).toEqual(bootDescriptor);
+    expect(Object.getOwnPropertyDescriptor(target, 'que')).toEqual(queueDescriptor);
+    expect(target).not.toHaveProperty('_registerIntegration');
+    expect(target).not.toHaveProperty('_internal');
+    expect(queued).not.toHaveBeenCalled();
+  });
+
+  it('commits one kernel after core/integration activation and afterCommit before queue drain', async () => {
+    const order: string[] = [];
+    const target = { que: [() => order.push('queued')], config: { publisher: true } };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      activateCore: () => order.push('core'),
+      kernel: {
+        addAdUnits: () => ({ registered: [] }),
+        diagnostics: Object.freeze({}),
+        requestAds: async () => ({ slots: [] }),
+      },
+    });
+
+    expect(runtime.state).toBe('unclaimed');
+    expect(runtime.start()).toBe(true);
+    expect(runtime.state).toBe('installing');
+    expect(target.config).toEqual({ publisher: true });
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () => ({
+            activate: ({ afterCommit }: { afterCommit(callback: () => void): void }) => {
+              order.push('integration');
+              afterCommit(() => order.push('after-commit'));
+            },
+          }),
+        })
+      )
+    ).toBe(true);
+
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(runtime.state).toBe('kernel');
+    expect(order).toEqual(['core', 'integration', 'after-commit', 'queued']);
+    expect(target).toMatchObject({ version: '1.0.0', releaseId: RELEASE });
+    expect(Object.isFrozen(target.que)).toBe(true);
+    expect(Object.getOwnPropertyDescriptor(target, '_internal')).toMatchObject({
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+    expect(
+      (target as { _registerIntegration?: (value: unknown) => boolean })._registerIntegration?.({
+        id: 'late',
+      })
+    ).toBe(false);
+  });
+
+  it('publishes the exact closure-supplied immutable boot snapshot without rereading the target', async () => {
+    const target: Record<string, unknown> = {};
+    const acceptedBoot = snapshotTsjsBootV1(
+      {
+        abi: 1,
+        releaseId: RELEASE,
+        manifest: manifest(['test_module']),
+        ...boot(),
+        integrations: { version: 1, entries: [] },
+      },
+      RELEASE
+    );
+    expect(acceptedBoot).toBeDefined();
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: acceptedBoot!.manifest,
+      knownIntegrationIds: Object.freeze(['test_module']),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'test_module',
+          phase: 'takeover' as const,
+          trigger: null,
+          config: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      boot: acceptedBoot,
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+
+    expect(runtime.start()).toBe(true);
+    target.boot = Object.freeze({ publisherReplacement: true });
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'test_module',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: ({ config }: { config: unknown }) => {
+            expect(config).toBeUndefined();
+            return Object.freeze({ activate: () => undefined });
+          },
+        })
+      )
+    ).toBe(true);
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(target.boot).toBe(acceptedBoot);
+  });
+
+  it('publishes direct.v1 through stable public closures only after provider activation', async () => {
+    const target: Record<string, unknown> = {};
+    const addAdUnits = vi.fn((candidate: unknown) => Object.freeze({ candidate }));
+    const requestAds = vi.fn(async (_candidate?: unknown) =>
+      Object.freeze({ slots: Object.freeze([]) })
+    );
+    let active = false;
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['render_runtime']),
+      knownIntegrationIds: Object.freeze(['render_runtime']),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'render_runtime',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze(['direct.v1']),
+        }),
+      ]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'render_runtime',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: ({ interfaces }: { interfaces: Readonly<Record<string, unknown>> }) => {
+            expect(Reflect.ownKeys(interfaces)).toEqual(['runtime.v1']);
+            return Object.freeze({
+              activate: ({ onDispose }: { onDispose(callback: () => void): void }) => {
+                active = true;
+                onDispose(() => {
+                  active = false;
+                });
+              },
+              interfaces: Object.freeze({
+                'direct.v1': Object.freeze({
+                  addAdUnits: (candidate: unknown) => {
+                    if (!active) throw new Error('inactive');
+                    return addAdUnits(candidate);
+                  },
+                  requestAds: async (candidate?: unknown) => {
+                    if (!active) throw new Error('inactive');
+                    return requestAds(candidate);
+                  },
+                  diagnostics: Object.freeze({ owner: 'render_runtime' }),
+                }),
+              }),
+            });
+          },
+        })
+      )
+    ).toBe(true);
+
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    const api = target as {
+      addAdUnits: (candidate: unknown) => unknown;
+      requestAds: (candidate?: unknown) => Promise<unknown>;
+      diagnostics: unknown;
+    };
+    expect(api.addAdUnits('unit')).toEqual({ candidate: 'unit' });
+    await expect(api.requestAds()).resolves.toEqual({ slots: [] });
+    expect(api.diagnostics).toEqual({ owner: 'render_runtime' });
+    runtime.dispose();
+    expect(() => api.addAdUnits('late')).toThrow('inactive');
+  });
+
+  it('publishes the staged takeover GPT diagnostics API without waiting for presentation', async () => {
+    const target: Record<string, unknown> = {};
+    const renderTrace = Object.freeze({ current: vi.fn(), history: vi.fn(), subscribe: vi.fn() });
+    const gpt = Object.freeze({
+      snapshot: vi.fn(() => Object.freeze({ slots: Object.freeze([]) })),
+      export: vi.fn(),
+      subscribe: vi.fn(() => vi.fn()),
+      show: vi.fn(),
+      hide: vi.fn(),
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['render_runtime', 'gpt_diagnostics', 'diagnostics_presentation']),
+      knownIntegrationIds: Object.freeze([
+        'render_runtime',
+        'gpt_diagnostics',
+        'diagnostics_presentation',
+      ]),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'render_runtime',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze(['direct.v1']),
+        }),
+        Object.freeze({
+          id: 'gpt_diagnostics',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze(['gpt_diag.v1']),
+        }),
+        Object.freeze({
+          id: 'diagnostics_presentation',
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          consumes: Object.freeze(['runtime.v1', 'gpt_diag.v1']),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      boot: {
+        ...boot(),
+        diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+      },
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'render_runtime',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () =>
+            Object.freeze({
+              activate: () => undefined,
+              interfaces: Object.freeze({
+                'direct.v1': Object.freeze({
+                  addAdUnits: vi.fn(),
+                  requestAds: vi.fn(),
+                  diagnostics: Object.freeze({ renderTrace }),
+                }),
+              }),
+            }),
+        })
+      )
+    ).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt_diagnostics',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () =>
+            Object.freeze({
+              activate: () => undefined,
+              interfaces: Object.freeze({
+                'gpt_diag.v1': Object.freeze({ api: gpt, attachPresentation: vi.fn() }),
+              }),
+            }),
+        })
+      )
+    ).toBe(true);
+
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    const diagnostics = target['diagnostics'] as Readonly<Record<string, unknown>>;
+    expect(Object.isFrozen(diagnostics)).toBe(true);
+    expect(Reflect.ownKeys(diagnostics)).toEqual(['renderTrace', 'gpt']);
+    expect(diagnostics['renderTrace']).toBe(renderTrace);
+    expect(diagnostics['gpt']).toBe(gpt);
+  });
+
+  it('binds creative and GPT diagnostics from the private validated boot snapshot', async () => {
+    const target: Record<string, unknown> = {};
+    const prepared = new Map<string, unknown>();
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['creative', 'gpt_diagnostics', 'diagnostics_presentation']),
+      knownIntegrationIds: Object.freeze([
+        'creative',
+        'gpt_diagnostics',
+        'diagnostics_presentation',
+      ]),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'creative',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze([]),
+        }),
+        Object.freeze({
+          id: 'gpt_diagnostics',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze(['runtime.v1']),
+          provides: Object.freeze(['gpt_diag.v1']),
+        }),
+        Object.freeze({
+          id: 'diagnostics_presentation',
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          consumes: Object.freeze(['runtime.v1', 'gpt_diag.v1']),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      boot: {
+        ...boot(),
+        creative: { version: 1, enabled: true, clickGuard: true, renderGuard: false },
+        diagnostics: { version: 1, renderTraceOverlay: false, gpt: { active: true } },
+      },
+      getBindings: () =>
+        Object.freeze({
+          config: Object.freeze({ publisherControlled: true }),
+          interfaces: Object.freeze({}),
+        }),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+    for (const id of ['creative', 'gpt_diagnostics']) {
+      expect(
+        runtime.registerIntegration(
+          takeoverRegistration({
+            abi: 1,
+            id,
+            phase: 'takeover',
+            releaseId: RELEASE,
+            prepare: ({ config }: { config: unknown }) => {
+              prepared.set(id, config);
+              return id === 'gpt_diagnostics'
+                ? Object.freeze({
+                    activate: () => undefined,
+                    interfaces: Object.freeze({
+                      'gpt_diag.v1': Object.freeze({
+                        api: Object.freeze({
+                          snapshot: vi.fn(),
+                          export: vi.fn(),
+                          subscribe: vi.fn(),
+                          show: vi.fn(),
+                          hide: vi.fn(),
+                        }),
+                        attachPresentation: vi.fn(),
+                      }),
+                    }),
+                  })
+                : Object.freeze({ activate: () => undefined });
+            },
+          })
+        )
+      ).toBe(true);
+    }
+
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(prepared.get('creative')).toEqual({
+      version: 1,
+      enabled: true,
+      clickGuard: true,
+      renderGuard: false,
+    });
+    expect(prepared.get('gpt_diagnostics')).toEqual({ active: true });
+    expect(Object.isFrozen(prepared.get('creative'))).toBe(true);
+    expect(Object.isFrozen(prepared.get('gpt_diagnostics'))).toBe(true);
+  });
+
+  it('keeps the authenticated registrar live and starts deferred loading only after the gate', async () => {
+    vi.useFakeTimers();
+    const frames: FrameRequestCallback[] = [];
+    const idle: Array<() => void> = [];
+    const runtimeHash = 'c'.repeat(64);
+    const deferredHash = 'd'.repeat(64);
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = `${window.location.origin}/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`;
+    document.head.insertBefore(runtimeScript, null);
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: runtimeScript,
+    });
+    const target: Record<string, unknown> = {};
+    const deferredPrepare = vi.fn(() => Object.freeze({ activate: () => undefined }));
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      document,
+      manifest: {
+        version: 1,
+        releaseId: RELEASE,
+        firstDisplay: null,
+        runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`,
+        integrations: [
+          { id: 'render_runtime', phase: 'takeover' },
+          {
+            id: 'gpt_later',
+            phase: 'deferred',
+            trigger: 'first_display_or_idle',
+            src: `/static/tsjs=tsjs-gpt_later.min.js?v=${deferredHash}`,
+          },
+        ],
+      },
+      knownIntegrationIds: Object.freeze(['render_runtime', 'gpt_later']),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'render_runtime',
+          phase: 'takeover' as const,
+          trigger: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze([]),
+        }),
+        Object.freeze({
+          id: 'gpt_later',
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          consumes: Object.freeze([]),
+          provides: Object.freeze([]),
+        }),
+      ]),
+      boot: boot(),
+      getBindings: () => Object.freeze({ config: undefined, interfaces: Object.freeze({}) }),
+      phaseScheduler: {
+        cancelAnimationFrame: vi.fn(),
+        cancelIdleCallback: vi.fn(),
+        clearTimeout,
+        requestAnimationFrame: (callback) => {
+          frames.push(callback);
+          return frames.length;
+        },
+        requestIdleCallback: (callback) => {
+          idle.push(callback);
+          return idle.length;
+        },
+        setTimeout,
+      },
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'render_runtime',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () => Object.freeze({ activate: () => undefined }),
+        })
+      )
+    ).toBe(true);
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(Object.getOwnPropertyDescriptor(target, '_registerIntegration')).toMatchObject({
+      configurable: false,
+      enumerable: true,
+      writable: false,
+    });
+    expect(document.head.querySelectorAll('script')).toHaveLength(1);
+
+    expect(runtime.protectFirstDisplayAttemptBatch([Promise.resolve()])).toBe(true);
+    await Promise.resolve();
+    await Promise.resolve();
+    frames.shift()?.(1);
+    frames.shift()?.(2);
+    idle.shift()?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    const deferredScript = [...document.head.querySelectorAll('script')].find(
+      (script) => script !== runtimeScript
+    );
+    expect(deferredScript?.src).toContain('tsjs-gpt_later.min.js');
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: deferredScript,
+    });
+    const register = target['_registerIntegration'];
+    expect(typeof register).toBe('function');
+    expect(
+      Reflect.apply(register as (...args: unknown[]) => unknown, target, [
+        {
+          abi: 1,
+          id: 'gpt_later',
+          phase: 'deferred',
+          releaseId: RELEASE,
+          prepare: deferredPrepare,
+        },
+      ])
+    ).toBe(true);
+    deferredScript?.dispatchEvent(new Event('load'));
+    await vi.waitFor(() => expect(deferredPrepare).toHaveBeenCalledOnce());
+  });
+
+  it('loads overlay-only presentation, GPT later, and Prebid later as separate authenticated artifacts', async () => {
+    vi.useFakeTimers();
+    const runtimeHash = 'c'.repeat(64);
+    const deferredHash = 'd'.repeat(64);
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = `${window.location.origin}/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`;
+    document.head.insertBefore(runtimeScript, null);
+    let executingScript: HTMLScriptElement | null = runtimeScript;
+    vi.spyOn(document, 'currentScript', 'get').mockImplementation(() => executingScript);
+    const frames: FrameRequestCallback[] = [];
+    const idle: Array<() => void> = [];
+    const target: Record<string, unknown> = {};
+    const traceAttach = vi.fn(() => vi.fn());
+    const traceDiagnostics = Object.freeze({
+      current: vi.fn(() => Object.freeze({})),
+      history: vi.fn(() => Object.freeze([])),
+      subscribe: vi.fn(() => vi.fn()),
+    });
+    const traceDataCapability = Object.freeze({ diagnostics: traceDiagnostics });
+    const tracePresentationCapability = Object.freeze({ attachPresentation: traceAttach });
+    const gptLaterRelease = vi.fn();
+    const prebidLaterRelease = vi.fn();
+    const gptConfig = { gamAttributionEnabled: true, pageBidsEnabled: true };
+    const prebidConfig = { accountId: 'publisher' };
+    const gptLater = Object.freeze({
+      activate: vi.fn(() => gptLaterRelease),
+      start: vi.fn(),
+    });
+    const prebidLater = Object.freeze({
+      activate: vi.fn(() => prebidLaterRelease),
+      start: vi.fn(),
+    });
+    const deferredIds = Object.freeze(['diagnostics_presentation', 'gpt_later', 'prebid_later']);
+    const manifestEntries = deferredIds.map((id) =>
+      Object.freeze({
+        id,
+        phase: 'deferred' as const,
+        trigger: 'first_display_or_idle' as const,
+        src: `/static/tsjs=tsjs-${id}.min.js?v=${deferredHash}`,
+      })
+    );
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      document,
+      manifest: {
+        version: 1,
+        releaseId: RELEASE,
+        firstDisplay: null,
+        runtimeSrc: `/static/tsjs=tsjs-unified.min.js?v=${runtimeHash}`,
+        integrations: [{ id: 'trace_provider', phase: 'takeover' }, ...manifestEntries],
+      },
+      knownIntegrationIds: Object.freeze([
+        'trace_provider',
+        'optional_gpt_diag_provider',
+        ...deferredIds,
+      ]),
+      catalog: Object.freeze([
+        Object.freeze({
+          id: 'trace_provider',
+          phase: 'takeover' as const,
+          trigger: null,
+          config: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze(['trace.v1', 'trace.presentation.v1']),
+        }),
+        Object.freeze({
+          id: 'optional_gpt_diag_provider',
+          phase: 'takeover' as const,
+          trigger: null,
+          config: null,
+          consumes: Object.freeze([]),
+          provides: Object.freeze(['gpt_diag.v1']),
+        }),
+        Object.freeze({
+          id: 'diagnostics_presentation',
+          phase: 'deferred' as const,
+          trigger: 'first_display_or_idle' as const,
+          config: null,
+          consumes: Object.freeze([
+            'runtime.v1',
+            'trace.presentation.v1',
+            'gpt_diag.v1?gpt_diagnostics_active',
+          ]),
+          provides: Object.freeze([]),
+        }),
+        ...deferredIds.slice(1).map((id) =>
+          Object.freeze({
+            id,
+            phase: 'deferred' as const,
+            trigger: 'first_display_or_idle' as const,
+            config: id === 'gpt_later' ? ('gpt' as const) : ('prebid' as const),
+            consumes: Object.freeze([]),
+            provides: Object.freeze([]),
+          })
+        ),
+      ]),
+      boot: {
+        ...boot(),
+        integrations: {
+          version: 1,
+          entries: [
+            { id: 'gpt', config: gptConfig },
+            { id: 'prebid', config: prebidConfig },
+          ],
+        },
+        diagnostics: { version: 1, renderTraceOverlay: true, gpt: { active: false } },
+      },
+      getBindings: (id) =>
+        Object.freeze({
+          config: id === 'gpt_later' || id === 'prebid_later' ? Object.freeze({}) : undefined,
+          interfaces: Object.freeze(
+            id === 'gpt_later'
+              ? { gpt_later: gptLater }
+              : id === 'prebid_later'
+                ? { prebid_later: prebidLater }
+                : {}
+          ),
+        }),
+      phaseScheduler: {
+        cancelAnimationFrame: vi.fn(),
+        cancelIdleCallback: vi.fn(),
+        clearTimeout,
+        requestAnimationFrame: (callback) => {
+          frames.push(callback);
+          return frames.length;
+        },
+        requestIdleCallback: (callback) => {
+          idle.push(callback);
+          return idle.length;
+        },
+        setTimeout,
+      },
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'trace_provider',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () =>
+            Object.freeze({
+              activate: () => undefined,
+              interfaces: Object.freeze({
+                'trace.v1': traceDataCapability,
+                'trace.presentation.v1': tracePresentationCapability,
+              }),
+            }),
+        })
+      )
+    ).toBe(true);
+    expect(Reflect.ownKeys(traceDataCapability)).toEqual(['diagnostics']);
+    expect(traceDataCapability).not.toHaveProperty('attachPresentation');
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(document.head.querySelectorAll('script')).toHaveLength(1);
+    expect(traceAttach).not.toHaveBeenCalled();
+    expect(gptLater.activate).not.toHaveBeenCalled();
+    expect(prebidLater.activate).not.toHaveBeenCalled();
+
+    const loadedSources: string[] = [];
+    const originalHeadAppend = document.head.append.bind(document.head);
+    vi.spyOn(document.head, 'append').mockImplementation((...nodes) => {
+      originalHeadAppend(...nodes);
+      for (const node of nodes) {
+        if (!(node instanceof HTMLScriptElement) || node === runtimeScript) continue;
+        const entry = manifestEntries.find(({ src }) => node.src.endsWith(src));
+        if (!entry) throw new Error('Unexpected deferred artifact source');
+        executingScript = node;
+        loadedSources.push(node.src);
+        const registration =
+          entry.id === 'diagnostics_presentation'
+            ? createDiagnosticsPresentationIntegrationRegistration(RELEASE)
+            : createLifecycleIntegrationRegistration(entry.id, RELEASE);
+        expect(runtime.registerIntegration(registration)).toBe(true);
+        node.onload?.(new Event('load'));
+        executingScript = runtimeScript;
+      }
+    });
+
+    expect(runtime.protectFirstDisplayAttemptBatch([Promise.resolve()])).toBe(true);
+    await Promise.resolve();
+    await Promise.resolve();
+    frames.shift()?.(1);
+    frames.shift()?.(2);
+    idle.shift()?.();
+    await vi.waitFor(() => {
+      expect(traceAttach).toHaveBeenCalledOnce();
+      expect(gptLater.start).toHaveBeenCalledOnce();
+      expect(prebidLater.start).toHaveBeenCalledOnce();
+    });
+    expect(loadedSources).toEqual(
+      manifestEntries.map(({ src }) => new URL(src, window.location.origin).href)
+    );
+    expect(new Set(loadedSources)).toHaveLength(3);
+    expect(loadedSources.every((source) => !source.includes('tsjs-unified'))).toBe(true);
+    expect(gptLater.activate).toHaveBeenCalledOnce();
+    expect(prebidLater.activate).toHaveBeenCalledOnce();
+    const acceptedCarrier = (
+      target['boot'] as {
+        integrations: { entries: readonly { id: string; config: unknown }[] };
+      }
+    ).integrations;
+    const acceptedGpt = acceptedCarrier.entries.find(({ id }) => id === 'gpt')?.config;
+    const acceptedPrebid = acceptedCarrier.entries.find(({ id }) => id === 'prebid')?.config;
+    expect(gptLater.activate).toHaveBeenCalledWith(acceptedGpt);
+    expect(gptLater.start).toHaveBeenCalledWith(acceptedGpt);
+    expect(prebidLater.activate).toHaveBeenCalledWith(acceptedPrebid);
+    expect(prebidLater.start).toHaveBeenCalledWith(acceptedPrebid);
+    expect(acceptedGpt).not.toBe(gptConfig);
+    expect(acceptedPrebid).not.toBe(prebidConfig);
+
+    runtime.dispose();
+    expect(gptLaterRelease).toHaveBeenCalledOnce();
+    expect(prebidLaterRelease).toHaveBeenCalledOnce();
+  });
+
+  it('resolves the frozen diagnostics namespace only after core and module activation', async () => {
+    const target: Record<string, unknown> = {};
+    const diagnostics = Object.freeze({ renderTrace: Object.freeze({}) });
+    let activated = false;
+    const getDiagnosticsForPublish = vi.fn(() => {
+      expect(activated).toBe(true);
+      return diagnostics;
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      activateCore: () => {
+        activated = true;
+      },
+      getDiagnosticsForPublish,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({ premature: true }),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+    expect(getDiagnosticsForPublish).toHaveBeenCalledOnce();
+    expect(target['diagnostics']).toBe(diagnostics);
+  });
+
+  it('prepares inert owner interfaces before module preparation and activates afterward', async () => {
+    const order: string[] = [];
+    let prepared = false;
+    const runtime = createRuntime({
+      target: { que: [() => order.push('drain')] },
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      prepareOwner: ({ boot: acceptedBoot, onDispose }) => {
+        expect(Object.isFrozen(acceptedBoot)).toBe(true);
+        prepared = true;
+        order.push('owner:prepare');
+        onDispose(() => order.push('owner:dispose'));
+      },
+      getBindings: () => {
+        expect(prepared).toBe(true);
+        order.push('bindings');
+        return { config: Object.freeze({}), interfaces: Object.freeze({}) };
+      },
+      activateOwner: () => order.push('owner:activate'),
+      activateCore: () => order.push('core:activate'),
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: ({ onDispose }: { onDispose(callback: () => void): void }) => {
+            order.push('module:prepare');
+            onDispose(() => order.push('module:dispose'));
+            return {
+              activate: ({ afterCommit }: { afterCommit(callback: () => void): void }) => {
+                order.push('module:activate');
+                afterCommit(() => order.push('after-commit'));
+              },
+            };
+          },
+        })
+      )
+    ).toBe(true);
+
+    const result = await runtime.install();
+    expect(result).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'owner:prepare',
+      'bindings',
+      'module:prepare',
+      'owner:activate',
+      'core:activate',
+      'module:activate',
+      'after-commit',
+      'drain',
+    ]);
+
+    if (result.state === 'kernel') result.dispose();
+    expect(order.slice(-2)).toEqual(['module:dispose', 'owner:dispose']);
+  });
+
+  it('keeps persistent activation and publication inside the supplied takeover call stack', async () => {
+    const order: string[] = [];
+    const runtime = createRuntime({
+      target: { que: [() => order.push('drain')] },
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      prepareOwner: () => order.push('prepare'),
+      activateOwner: () => order.push('activate'),
+      coordinateTakeover: (prepared) => {
+        order.push('takeover:begin');
+        const candidate = takeoverHandoff();
+        const handoff = prepared.validateHandoff(
+          candidate.capture,
+          candidate.outline,
+          candidate.boot
+        );
+        expect(handoff).toBeDefined();
+        prepared.activate(
+          Object.freeze({
+            version: 1 as const,
+            adoptInitialDisplay: true as const,
+            handoff: handoff!,
+            identities: Object.freeze([]),
+          })
+        );
+        order.push('takeover:activated');
+        prepared.commit();
+        order.push('takeover:committed');
+      },
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    const result = await runtime.install();
+    expect(result, JSON.stringify(order)).toMatchObject({ state: 'kernel' });
+    expect(order).toEqual([
+      'prepare',
+      'takeover:begin',
+      'activate',
+      'takeover:activated',
+      'drain',
+      'takeover:committed',
+    ]);
+  });
+
+  it.each(['prepare', 'activate'] as const)(
+    'returns a takeover %s failure to bootstrap without publishing a second fallback owner',
+    async (checkpoint) => {
+      const target = { que: [] as unknown[] };
+      const onInstallComplete = vi.fn();
+      const coordinateTakeover = vi.fn((prepared) => {
+        const candidate = takeoverHandoff();
+        const handoff = prepared.validateHandoff(
+          candidate.capture,
+          candidate.outline,
+          candidate.boot
+        );
+        expect(handoff).toBeDefined();
+        prepared.activate(
+          Object.freeze({
+            version: 1 as const,
+            adoptInitialDisplay: true as const,
+            handoff: handoff!,
+            identities: Object.freeze([]),
+          })
+        );
+        prepared.commit();
+      });
+      const fail = () => {
+        throw new Error(checkpoint);
+      };
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: manifest([]),
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(),
+        ...(checkpoint === 'prepare' ? { prepareOwner: fail } : { activateOwner: fail }),
+        coordinateTakeover,
+        onInstallComplete,
+        kernel: {
+          addAdUnits: vi.fn(),
+          diagnostics: Object.freeze({}),
+          requestAds: vi.fn(),
+        },
+      });
+
+      expect(runtime.start()).toBe(true);
+      await expect(runtime.install()).resolves.toEqual({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+
+      expect(runtime.state).toBe('failed');
+      expect(onInstallComplete).toHaveBeenCalledOnce();
+      expect(onInstallComplete).toHaveBeenCalledWith({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+      expect(target).not.toHaveProperty('version');
+      expect(target).not.toHaveProperty('_internal');
+      expect(target).not.toHaveProperty('requestAds');
+      if (checkpoint === 'prepare') expect(coordinateTakeover).not.toHaveBeenCalled();
+      else expect(coordinateTakeover).toHaveBeenCalledOnce();
+    }
+  );
+
+  it('stops activation when owner activation disposes the installing runtime', async () => {
+    const activateCore = vi.fn();
+    const activateModule = vi.fn();
+    const disposeOwner = vi.fn();
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      activateOwner: ({ onDispose }) => {
+        onDispose(disposeOwner);
+        runtime.dispose();
+      },
+      activateCore,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () => ({ activate: activateModule }),
+        })
+      )
+    ).toBe(true);
+
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+    expect(activateCore).not.toHaveBeenCalled();
+    expect(activateModule).not.toHaveBeenCalled();
+    expect(disposeOwner).toHaveBeenCalledOnce();
+    expect(runtime.state).toBe('fallback');
+    expect(target).toMatchObject({
+      _internal: { state: 'fallback', releaseId: RELEASE, reason: 'bundle_partial' },
+    });
+  });
+
+  it('runs queued work at the exact activation, commit, afterCommit, and FIFO drain boundaries', async () => {
+    const order: string[] = [];
+    let commitPushInstalled = false;
+    const backing: { que?: unknown[]; version?: string } = {
+      que: [
+        function (this: unknown) {
+          expect(this).toBe(target);
+          order.push('preload-start');
+          target.que?.push(() => order.push('preload-nested'));
+          order.push('preload-end');
+        },
+      ],
+    };
+    const target = new Proxy(backing, {
+      defineProperty(object, key, descriptor) {
+        if (key === 'version' && !commitPushInstalled) {
+          commitPushInstalled = true;
+          object.que?.push(() => order.push('commit-enqueued'));
+        }
+        return Reflect.defineProperty(object, key, descriptor);
+      },
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      activateCore: () => {
+        order.push('core-activation');
+        target.que?.push(() => order.push('core-enqueued'));
+      },
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    expect(
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () => ({
+            activate: ({ afterCommit }: { afterCommit(callback: () => void): void }) => {
+              order.push('module-activation');
+              target.que?.push(() => order.push('module-enqueued'));
+              afterCommit(() => {
+                order.push('after-commit-start');
+                target.que?.push(() => order.push('after-commit-enqueued'));
+                order.push('after-commit-end');
+              });
+            },
+          }),
+        })
+      )
+    ).toBe(true);
+
+    await expect(runtime.install()).resolves.toMatchObject({ state: 'kernel' });
+
+    expect(order).toEqual([
+      'core-activation',
+      'module-activation',
+      'commit-enqueued',
+      'after-commit-start',
+      'after-commit-enqueued',
+      'after-commit-end',
+      'preload-start',
+      'preload-nested',
+      'preload-end',
+      'core-enqueued',
+      'module-enqueued',
+    ]);
+  });
+
+  it.each([
+    ['invalid manifest', { version: 2 }, 'abi_mismatch'],
+    ['missing bundle', manifest(['gpt']), 'bundle_partial'],
+  ] as const)('commits terminal fallback for %s', async (_name, candidateManifest, reason) => {
+    vi.useFakeTimers();
+    const queued = vi.fn();
+    const activateCore = vi.fn();
+    const target = { que: [queued], boot: boot() };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: candidateManifest,
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: target.boot,
+      activateCore,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    runtime.start();
+    const installed = runtime.install();
+    if (reason === 'bundle_partial') await vi.advanceTimersByTimeAsync(10_000);
+    await expect(installed).resolves.toEqual({ state: 'fallback', reason });
+
+    expect(runtime.state).toBe('fallback');
+    expect(activateCore).not.toHaveBeenCalled();
+    expect(queued).toHaveBeenCalledOnce();
+    expect(target).toMatchObject({ version: '1.0.0', releaseId: RELEASE });
+    expect((target as { _internal?: unknown })._internal).toEqual({
+      state: 'fallback',
+      releaseId: RELEASE,
+      reason,
+      initialDisplayCommitted: false,
+    });
+    await expect(
+      (target as unknown as { requestAds(options?: unknown): Promise<unknown> }).requestAds()
+    ).resolves.toEqual({ slots: [] });
+    expect(
+      (target as unknown as { _registerIntegration(value: unknown): boolean })._registerIntegration(
+        {
+          id: 'gpt',
+          releaseId: RELEASE,
+          prepare: vi.fn(),
+        }
+      )
+    ).toBe(false);
+  });
+
+  it('publishes the captured exact takeover source when the manifest field is missing', async () => {
+    const runtimeSrc = `/static/tsjs=tsjs-unified.min.js?v=${'d'.repeat(64)}`;
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = new URL(runtimeSrc, window.location.origin).href;
+    document.head.insertBefore(runtimeScript, null);
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: runtimeScript,
+    });
+    const candidateManifest = {
+      version: 1,
+      releaseId: RELEASE,
+      integrations: [],
+    };
+    const target = {
+      boot: {
+        ...boot(),
+        manifest: candidateManifest,
+      },
+    };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      document,
+      manifest: candidateManifest,
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: target.boot,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect((target as { boot: { manifest: unknown } }).boot.manifest).toEqual({
+      version: 1,
+      releaseId: RELEASE,
+      firstDisplay: null,
+      runtimeSrc,
+      integrations: [],
+    });
+  });
+
+  it('publishes the captured exact takeover source when the manifest field is malformed', async () => {
+    const runtimeSrc = `/static/tsjs=tsjs-unified.min.js?v=${'d'.repeat(64)}`;
+    const runtimeScript = document.createElement('script');
+    runtimeScript.id = 'trustedserver-js';
+    runtimeScript.src = new URL(runtimeSrc, window.location.origin).href;
+    document.head.insertBefore(runtimeScript, null);
+    Object.defineProperty(document, 'currentScript', {
+      configurable: true,
+      value: runtimeScript,
+    });
+    const candidateManifest = {
+      version: 1,
+      releaseId: RELEASE,
+      firstDisplay: null,
+      runtimeSrc: `${runtimeSrc}&publisher=1`,
+      integrations: [],
+    };
+    const target = {
+      boot: {
+        ...boot(),
+        manifest: candidateManifest,
+      },
+    };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      document,
+      manifest: candidateManifest,
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: target.boot,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(true);
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect((target as { boot: { manifest: unknown } }).boot.manifest).toEqual({
+      version: 1,
+      releaseId: RELEASE,
+      firstDisplay: null,
+      runtimeSrc,
+      integrations: [],
+    });
+  });
+
+  it('leaves the namespace unclaimed when no trusted takeover source exists', () => {
+    const target = {
+      boot: boot(),
+      que: [vi.fn()],
+    };
+    const bootDescriptor = Object.getOwnPropertyDescriptor(target, 'boot');
+    const queueDescriptor = Object.getOwnPropertyDescriptor(target, 'que');
+    const runtime = createRuntimeOwner({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 1, releaseId: RELEASE, integrations: [] },
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: target.boot,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(runtime.start()).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(Object.getOwnPropertyDescriptor(target, 'boot')).toEqual(bootDescriptor);
+    expect(Object.getOwnPropertyDescriptor(target, 'que')).toEqual(queueDescriptor);
+    expect(target).not.toHaveProperty('_registerIntegration');
+    expect(target).not.toHaveProperty('_internal');
+  });
+
+  it('publishes an exact terminal namespace with no publisher-owned fields', async () => {
+    const target = {
+      que: [] as unknown[],
+      diagnostics: { legacy: true },
+      adInit: vi.fn(),
+      renderAdUnit: vi.fn(),
+      setConfig: vi.fn(),
+      publisher: { retained: true },
+    };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+
+    expect(runtime.start()).toBe(true);
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+
+    expect(Object.prototype.hasOwnProperty.call(target, 'diagnostics')).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(target, 'adInit')).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(target, 'renderAdUnit')).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(target, 'setConfig')).toBe(false);
+    expect(target).not.toHaveProperty('publisher');
+  });
+
+  it('allows exactly one bootstrap owner for a namespace', () => {
+    const target = {};
+    const options = {
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: boot(),
+      kernel: {
+        addAdUnits: () => ({ registered: [] }),
+        diagnostics: Object.freeze({}),
+        requestAds: async () => ({ slots: [] }),
+      },
+    };
+    const first = createRuntime(options);
+    const second = createRuntime(options);
+
+    expect(first.start()).toBe(true);
+    expect(second.start()).toBe(false);
+    expect(first.generation).not.toBe(second.generation);
+  });
+
+  it('rejects a detached async no-agent preparation before activation', async () => {
+    const target = {};
+    const staleCoreActivation = vi.fn();
+    const staleModuleActivation = vi.fn();
+    const staleDisposal = vi.fn();
+    let resolveStalePreparation: (() => void) | undefined;
+    const stalePreparation = new Promise<void>((resolve) => {
+      resolveStalePreparation = resolve;
+    });
+    const first = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      activateCore: staleCoreActivation,
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+    const second = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+
+    expect(first.start()).toBe(true);
+    expect(
+      first.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: ({ onDispose }: { onDispose(callback: () => void): void }) => {
+            onDispose(staleDisposal);
+            return stalePreparation.then(() => ({ activate: staleModuleActivation }));
+          },
+        })
+      )
+    ).toBe(true);
+    const staleInstall = first.install();
+    expect(first.state).toBe('fallback');
+    expect(Reflect.deleteProperty(target, '_registerIntegration')).toBe(false);
+    expect(second.start()).toBe(false);
+    resolveStalePreparation?.();
+    await expect(staleInstall).resolves.toEqual({ state: 'fallback', reason: 'bundle_partial' });
+
+    expect(staleCoreActivation).not.toHaveBeenCalled();
+    expect(staleModuleActivation).not.toHaveBeenCalled();
+    expect(staleDisposal).toHaveBeenCalledOnce();
+    expect(first.state).toBe('fallback');
+    expect(second.state).toBe('unclaimed');
+    expect((target as { _internal?: unknown })._internal).toEqual({
+      state: 'fallback',
+      releaseId: RELEASE,
+      reason: 'bundle_partial',
+      initialDisplayCommitted: false,
+    });
+  });
+
+  it('rejects registration when candidate reflection replaces the owner handshake', async () => {
+    const target = {};
+    const staleCoreActivation = vi.fn();
+    const staleModuleActivation = vi.fn();
+    const options = {
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    };
+    const first = createRuntime({ ...options, activateCore: staleCoreActivation });
+    const second = createRuntime(options);
+
+    expect(first.start()).toBe(true);
+    const registration = new Proxy(
+      {
+        abi: 1,
+        id: 'gpt',
+        phase: 'takeover',
+        releaseId: RELEASE,
+        prepareSync: () => ({ activate: staleModuleActivation }),
+        prepare: () => ({ activate: staleModuleActivation }),
+      },
+      {
+        ownKeys(candidate) {
+          expect(Reflect.deleteProperty(target, '_registerIntegration')).toBe(true);
+          return Reflect.ownKeys(candidate);
+        },
+      }
+    );
+
+    expect(first.registerIntegration(registration)).toBe(false);
+    expect(second.start()).toBe(true);
+    expect(
+      second.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare: () => ({ activate: vi.fn() }),
+        })
+      )
+    ).toBe(true);
+    await expect(second.install()).resolves.toMatchObject({ state: 'kernel' });
+    await expect(first.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+
+    expect(staleCoreActivation).not.toHaveBeenCalled();
+    expect(staleModuleActivation).not.toHaveBeenCalled();
+    expect(first.state).toBe('failed');
+    expect(second.state).toBe('kernel');
+  });
+
+  it('allows exactly one bootstrap owner across independently evaluated core modules', async () => {
+    const target = {};
+    const options = {
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: boot(),
+      kernel: {
+        addAdUnits: () => ({ registered: [] }),
+        diagnostics: Object.freeze({}),
+        requestAds: async () => ({ slots: [] }),
+      },
+    };
+    const firstModule = await import('../../src/kernel/runtime');
+    vi.resetModules();
+    const secondModule = await import('../../src/kernel/runtime');
+    installTestRuntimeScript(document);
+    const first = firstModule.createRuntime(options);
+    const second = secondModule.createRuntime(options);
+
+    expect(first.start()).toBe(true);
+    expect(second.start()).toBe(false);
+    expect(first.generation).not.toBe(second.generation);
+  });
+
+  it('refuses a conflicting terminal namespace before constructing an installing generation', () => {
+    const target: { que: unknown[]; version?: string } = { que: [] };
+    Object.defineProperty(target, 'version', {
+      configurable: false,
+      enumerable: true,
+      value: 'publisher',
+      writable: false,
+    });
+    const queueDescriptor = Object.getOwnPropertyDescriptor(target, 'que');
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([] as string[]),
+      boot: boot(),
+      kernel: {
+        addAdUnits: () => ({ registered: [] }),
+        diagnostics: Object.freeze({}),
+        requestAds: async () => ({ slots: [] }),
+      },
+    });
+
+    expect(runtime.start()).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(Object.getOwnPropertyDescriptor(target, 'que')).toEqual(queueDescriptor);
+    expect(Reflect.ownKeys(target)).toEqual(['que', 'version']);
+  });
+
+  it.each([
+    [
+      'wrong release',
+      {
+        abi: 1,
+        id: 'gpt',
+        phase: 'takeover',
+        releaseId: 'b'.repeat(64),
+        prepareSync: vi.fn(),
+        prepare: vi.fn(),
+      },
+    ],
+    [
+      'unknown id',
+      {
+        abi: 1,
+        id: 'aps',
+        phase: 'takeover',
+        releaseId: RELEASE,
+        prepareSync: vi.fn(),
+        prepare: vi.fn(),
+      },
+    ],
+  ])(
+    'classifies %s registration as abi_mismatch without invoking module code',
+    async (_name, registration) => {
+      const runtime = createRuntime({
+        target: {},
+        releaseId: RELEASE,
+        manifest: manifest(['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: boot(),
+        kernel: {
+          addAdUnits: vi.fn(),
+          diagnostics: Object.freeze({}),
+          requestAds: vi.fn(),
+        },
+      });
+      runtime.start();
+
+      expect(runtime.registerIntegration(registration)).toBe(false);
+      await expect(runtime.install()).resolves.toEqual({
+        state: 'fallback',
+        reason: 'abi_mismatch',
+      });
+      expect(registration.prepare).not.toHaveBeenCalled();
+    }
+  );
+
+  it('classifies duplicate registration as abi_mismatch', async () => {
+    const prepare = vi.fn(() => ({ activate: vi.fn() }));
+    const registration = takeoverRegistration({
+      abi: 1,
+      id: 'gpt',
+      phase: 'takeover',
+      releaseId: RELEASE,
+      prepare,
+    });
+    const runtime = createRuntime({
+      target: {},
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      kernel: {
+        addAdUnits: vi.fn(),
+        diagnostics: Object.freeze({}),
+        requestAds: vi.fn(),
+      },
+    });
+    runtime.start();
+    expect(runtime.registerIntegration(registration)).toBe(true);
+    expect(runtime.registerIntegration(registration)).toBe(false);
+
+    await expect(runtime.install()).resolves.toEqual({ state: 'fallback', reason: 'abi_mismatch' });
+    expect(prepare).not.toHaveBeenCalled();
+  });
+
+  it.each(['prepare_throw', 'prepare_reject', 'activate_throw'] as const)(
+    'unwinds %s as bundle_partial',
+    async (checkpoint) => {
+      const disposed = vi.fn();
+      const prepare =
+        checkpoint === 'prepare_throw'
+          ? () => {
+              throw new Error('prepare');
+            }
+          : checkpoint === 'prepare_reject'
+            ? async ({ onDispose }: { onDispose(callback: () => void): void }) => {
+                onDispose(disposed);
+                throw new Error('prepare');
+              }
+            : ({ onDispose }: { onDispose(callback: () => void): void }) => {
+                onDispose(disposed);
+                return {
+                  activate: () => {
+                    throw new Error('activate');
+                  },
+                };
+              };
+      const runtime = createRuntime({
+        target: {},
+        releaseId: RELEASE,
+        manifest: manifest(['gpt']),
+        knownIntegrationIds: Object.freeze(['gpt']),
+        boot: boot(),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      runtime.start();
+      runtime.registerIntegration(
+        takeoverRegistration({
+          abi: 1,
+          id: 'gpt',
+          phase: 'takeover',
+          releaseId: RELEASE,
+          prepare,
+        })
+      );
+
+      await expect(runtime.install()).resolves.toEqual({
+        state: 'fallback',
+        reason: 'bundle_partial',
+      });
+      if (checkpoint !== 'prepare_throw') expect(disposed).toHaveBeenCalledOnce();
+    }
+  );
+
+  it('shares the ten-second watchdog with a hung preparation and ignores its late continuation', async () => {
+    vi.useFakeTimers();
+    let finish: ((value: { activate(): void }) => void) | undefined;
+    const lateActivate = vi.fn();
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    runtime.registerIntegration(
+      takeoverRegistration({
+        abi: 1,
+        id: 'gpt',
+        phase: 'takeover',
+        releaseId: RELEASE,
+        prepare: () =>
+          new Promise<{ activate(): void }>((resolve) => {
+            finish = resolve;
+          }),
+      })
+    );
+    const installed = runtime.install();
+
+    await vi.advanceTimersByTimeAsync(10_000);
+    await expect(installed).resolves.toEqual({ state: 'fallback', reason: 'bundle_partial' });
+    finish?.({ activate: lateActivate });
+    await Promise.resolve();
+    expect(lateActivate).not.toHaveBeenCalled();
+    expect(runtime.state).toBe('fallback');
+  });
+
+  it('isolates afterCommit failure after kernel publication', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest(['gpt']),
+      knownIntegrationIds: Object.freeze(['gpt']),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    runtime.registerIntegration(
+      takeoverRegistration({
+        abi: 1,
+        id: 'gpt',
+        phase: 'takeover',
+        releaseId: RELEASE,
+        prepare: () => ({
+          activate: ({ afterCommit }: { afterCommit(callback: () => void): void }) =>
+            afterCommit(() => {
+              throw new Error('post commit');
+            }),
+        }),
+      })
+    );
+
+    await expect(runtime.install()).resolves.toMatchObject({
+      state: 'kernel',
+      runtimeFailures: [{ id: 'gpt', phase: 'after_commit' }],
+    });
+    expect(runtime.state).toBe('kernel');
+  });
+
+  it('validates fallback calls against the exact empty safe projection', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot([{ slot: 'known', outcome: 'no_bid' }]),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const api = target as unknown as {
+      addAdUnits(units: unknown): unknown;
+      requestAds(options?: unknown): Promise<unknown>;
+      boot: unknown;
+    };
+
+    await expect(api.requestAds()).resolves.toEqual({ slots: [] });
+    await expect(api.requestAds({ slots: ['known', 'unknown'] })).resolves.toEqual({
+      slots: [
+        { slot: 'known', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+        { slot: 'unknown', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+      ],
+    });
+    const controller = new AbortController();
+    controller.abort();
+    await expect(api.requestAds({ slots: ['known'], signal: controller.signal })).resolves.toEqual({
+      slots: [{ slot: 'known', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' }],
+    });
+    await expect(api.requestAds({ slots: [] })).rejects.toBeInstanceOf(RequestAdsInputError);
+    expect(() => api.addAdUnits({ code: '', mediaTypes: {} })).toThrow(AdUnitRegistrationError);
+    expect(() =>
+      api.addAdUnits({
+        code: 'programmatic',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      })
+    ).toThrow(TsjsUnavailableError);
+    expect(Object.isFrozen(api.boot)).toBe(true);
+  });
+
+  it('substitutes the exact safe auction projection when boot data is hostile', async () => {
+    const getter = vi.fn(() => ({ version: 1 }));
+    const hostile = {};
+    Object.defineProperty(hostile, 'auctionProjection', { enumerable: true, get: getter });
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: hostile,
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+
+    expect(getter).not.toHaveBeenCalled();
+    expect(
+      (target as unknown as { boot: { auctionProjection: unknown } }).boot.auctionProjection
+    ).toEqual({
+      version: 1,
+      auction: { version: 1, auctionId: 'fallback', results: [] },
+      slots: [],
+      bids: [],
+    });
+  });
+
+  it('never retains projected slot membership in fallback boot', async () => {
+    const target = { boot: boot([{ slot: 'initial', outcome: 'no_bid' }]) };
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: target.boot,
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+    target.boot = boot([{ slot: 'mutated', outcome: 'no_bid' }]);
+
+    await runtime.install();
+    const api = target as unknown as {
+      boot: { auctionProjection: { auction: { results: readonly { slot: string }[] } } };
+      requestAds(options: unknown): Promise<unknown>;
+    };
+    expect(api.boot.auctionProjection.auction.results).toEqual([]);
+    await expect(api.requestAds({ slots: ['initial', 'mutated'] })).resolves.toEqual({
+      slots: [
+        { slot: 'initial', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+        { slot: 'mutated', path: 'primary', outcome: 'failed', reason: 'slot_unresolved' },
+      ],
+    });
+  });
+
+  it.each(['getPrototypeOf', 'ownKeys', 'getOwnPropertyDescriptor'] as const)(
+    'maps a hostile request options %s trap to invalid_options',
+    async (trap) => {
+      const target = {};
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: { version: 2 },
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      runtime.start();
+      await runtime.install();
+      const requestAds = (target as unknown as { requestAds(value: unknown): Promise<unknown> })
+        .requestAds;
+      const optionsTarget = trap === 'getOwnPropertyDescriptor' ? { slots: ['known'] } : {};
+
+      await expect(requestAds(hostileRecord(trap, optionsTarget))).rejects.toMatchObject({
+        code: 'invalid_options',
+      });
+    }
+  );
+
+  it.each(['getPrototypeOf', 'ownKeys', 'getOwnPropertyDescriptor'] as const)(
+    'maps a hostile addAdUnits unit %s trap to invalid_unit',
+    async (trap) => {
+      const target = {};
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: { version: 2 },
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      runtime.start();
+      await runtime.install();
+      const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+      const unit = hostileRecord(trap, {
+        code: 'hostile',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+      });
+
+      expect(() => addAdUnits(unit)).toThrow(
+        expect.objectContaining({ code: 'invalid_unit', unitIndex: 0 })
+      );
+    }
+  );
+
+  it('maps hostile outer addAdUnits Array reflection to invalid_units', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+    const units = new Proxy([], {
+      ownKeys() {
+        throw new Error('hostile outer Array');
+      },
+    });
+
+    const error = thrownBy(() => addAdUnits(units));
+    expect(error).toMatchObject({ code: 'invalid_units' });
+    expect(Object.prototype.hasOwnProperty.call(error, 'unitIndex')).toBe(false);
+  });
+
+  it('maps a revoked outer addAdUnits Array proxy to invalid_units', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const { proxy, revoke } = Proxy.revocable([], {});
+    revoke();
+
+    const error = thrownBy(() =>
+      (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits(proxy)
+    );
+    expect(error).toMatchObject({ code: 'invalid_units' });
+    expect(Object.prototype.hasOwnProperty.call(error, 'unitIndex')).toBe(false);
+  });
+
+  it.each(['getPrototypeOf', 'ownKeys', 'getOwnPropertyDescriptor'] as const)(
+    'substitutes exact safe boot for a hostile boot %s trap',
+    async (trap) => {
+      const target = {};
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: { version: 2 },
+        knownIntegrationIds: Object.freeze([]),
+        boot: hostileRecord(trap, trap === 'getOwnPropertyDescriptor' ? boot() : {}),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      expect(runtime.start()).toBe(true);
+
+      await expect(runtime.install()).resolves.toEqual({
+        state: 'fallback',
+        reason: 'abi_mismatch',
+      });
+      expect(
+        (target as unknown as { boot: { auctionProjection: unknown } }).boot.auctionProjection
+      ).toEqual({
+        version: 1,
+        auction: { version: 1, auctionId: 'fallback', results: [] },
+        slots: [],
+        bids: [],
+      });
+    }
+  );
+
+  it('substitutes exact safe boot when nested boot contract proxies throw', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: {
+        cachePolicy: hostileRecord('ownKeys'),
+        auctionProjection: hostileRecord('getPrototypeOf'),
+      },
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'abi_mismatch',
+    });
+    expect(
+      (target as unknown as { boot: { auctionProjection: unknown } }).boot.auctionProjection
+    ).toEqual({
+      version: 1,
+      auction: { version: 1, auctionId: 'fallback', results: [] },
+      slots: [],
+      bids: [],
+    });
+  });
+
+  it('rejects a full boot whose server manifest disagrees with the accepted bundle manifest', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: { abi: 1, releaseId: RELEASE, manifest: manifest(['gpt']), ...boot() },
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+
+    await expect(runtime.install()).resolves.toEqual({ state: 'fallback', reason: 'abi_mismatch' });
+  });
+
+  it('binds validation and fallback publication to the embedded bundle release', async () => {
+    const serverRelease = 'b'.repeat(64);
+    const serverManifest = { version: 1, releaseId: serverRelease, integrations: [] };
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: serverRelease,
+      manifest: serverManifest,
+      knownIntegrationIds: Object.freeze([]),
+      boot: {
+        abi: 1,
+        releaseId: serverRelease,
+        manifest: serverManifest,
+        ...boot(),
+      },
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+
+    await expect(runtime.install()).resolves.toEqual({ state: 'fallback', reason: 'abi_mismatch' });
+    expect(target).toMatchObject({
+      releaseId: RELEASE,
+      boot: { releaseId: RELEASE, manifest: { releaseId: RELEASE } },
+      _internal: { state: 'fallback', releaseId: RELEASE, reason: 'abi_mismatch' },
+    });
+  });
+
+  it('does not invoke hostile Array iterators at fallback input boundaries', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot([{ slot: 'known', outcome: 'no_bid' }]),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const iterator = vi.fn();
+    const slots = ['known'];
+    Object.defineProperty(slots, Symbol.iterator, { value: iterator });
+
+    await expect(
+      (target as unknown as { requestAds(value: unknown): Promise<unknown> }).requestAds({ slots })
+    ).rejects.toMatchObject({ code: 'invalid_slots' });
+    expect(iterator).not.toHaveBeenCalled();
+  });
+
+  it('uses exact addAdUnits dimension and bidder validation before refusing valid input', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+
+    expect(() =>
+      addAdUnits({ code: 'zero', mediaTypes: { banner: { sizes: [[0, 250]] } } })
+    ).toThrow(expect.objectContaining({ code: 'invalid_dimensions' }));
+    expect(() =>
+      addAdUnits({ code: 'large', mediaTypes: { banner: { sizes: [[4097, 250]] } } })
+    ).toThrow(expect.objectContaining({ code: 'dimensions_out_of_range' }));
+    expect(() =>
+      addAdUnits({
+        code: 'bad-bidder',
+        mediaTypes: { banner: { sizes: [[1, 1]] } },
+        bids: [{ bidder: 'x'.repeat(65) }],
+      })
+    ).toThrow(expect.objectContaining({ code: 'invalid_bidder' }));
+    expect(() =>
+      addAdUnits({
+        code: 'valid',
+        mediaTypes: { banner: { sizes: [[1, 4096]] } },
+        bids: [{ bidder: 'aps', params: { placement: 'one' } }],
+      })
+    ).toThrow(TsjsUnavailableError);
+  });
+
+  it.each([
+    ['high', '\ud800'],
+    ['low', '\udc00'],
+  ] as const)(
+    'rejects a lone %s UTF-16 surrogate in a programmatic slot code',
+    async (_kind, code) => {
+      const target = {};
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: { version: 2 },
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      runtime.start();
+      await runtime.install();
+      const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+
+      expect(() => addAdUnits({ code, mediaTypes: { banner: { sizes: [[300, 250]] } } })).toThrow(
+        expect.objectContaining({ code: 'invalid_code', unitIndex: 0 })
+      );
+    }
+  );
+
+  it('does not retain server slot collisions or capacity in fallback validation', async () => {
+    const makeFallback = async (slots: readonly string[]) => {
+      const target = {};
+      const runtime = createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: { version: 2 },
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(slots.map((slot) => ({ slot, outcome: 'no_bid' }))),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      });
+      runtime.start();
+      await runtime.install();
+      return (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+    };
+    const collision = await makeFallback(['server']);
+    expect(() =>
+      collision({ code: 'server', mediaTypes: { banner: { sizes: [[300, 250]] } } })
+    ).toThrow(TsjsUnavailableError);
+
+    const full = await makeFallback(Array.from({ length: 256 }, (_, index) => `slot-${index}`));
+    expect(() =>
+      full({ code: 'overflow', mediaTypes: { banner: { sizes: [[300, 250]] } } })
+    ).toThrow(TsjsUnavailableError);
+  });
+
+  it('reports aggregate request overflow before combined registry capacity', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(
+        Array.from({ length: 256 }, (_, index) => ({
+          slot: `server-${index}`,
+          outcome: 'no_bid',
+        }))
+      ),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+
+    expect(() =>
+      addAdUnits({
+        code: 'programmatic-overflow',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [{ bidder: 'aps', params: { payload: 'x'.repeat(256 * 1024) } }],
+      })
+    ).toThrow(expect.objectContaining({ code: 'request_body_too_large' }));
+  });
+
+  it('accepts contract-valid large collections and deep params before refusing availability', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+    const sizes = Array.from({ length: 257 }, () => [1, 1]);
+    const bids = Array.from({ length: 257 }, () => ({ bidder: 'aps' }));
+    const paramsArray = Array.from({ length: 4097 }, () => 0);
+    let deepParams: object = { leaf: true };
+    for (let depth = 0; depth < 128; depth += 1) deepParams = { child: deepParams };
+
+    for (const unit of [
+      { code: 'many-sizes', mediaTypes: { banner: { sizes } } },
+      { code: 'many-bids', mediaTypes: { banner: { sizes: [[1, 1]] } }, bids },
+      {
+        code: 'large-params-array',
+        mediaTypes: { banner: { sizes: [[1, 1]] } },
+        bids: [{ bidder: 'aps', params: { values: paramsArray } }],
+      },
+      {
+        code: 'deep-params',
+        mediaTypes: { banner: { sizes: [[1, 1]] } },
+        bids: [{ bidder: 'aps', params: deepParams }],
+      },
+    ]) {
+      expect(() => addAdUnits(unit)).toThrow(TsjsUnavailableError);
+    }
+  });
+
+  it('classifies an empty banner size list as invalid_media_types', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+
+    expect(() =>
+      (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits({
+        code: 'empty-sizes',
+        mediaTypes: { banner: { sizes: [] } },
+      })
+    ).toThrow(expect.objectContaining({ code: 'invalid_media_types', unitIndex: 0 }));
+  });
+
+  it('bounds an exponentially expanded shared params DAG without revisiting nodes', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const addAdUnits = (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits;
+    const descriptorReads: number[] = [];
+    let shared: object = { value: 'leaf' };
+    for (let depth = 0; depth < 24; depth += 1) {
+      const node = { left: shared, right: shared };
+      const nodeIndex = descriptorReads.length;
+      descriptorReads.push(0);
+      shared = new Proxy(node, {
+        getOwnPropertyDescriptor(object, key) {
+          descriptorReads[nodeIndex] = (descriptorReads[nodeIndex] ?? 0) + 1;
+          if ((descriptorReads[nodeIndex] ?? 0) > Reflect.ownKeys(object).length) {
+            throw new Error('shared DAG node was expanded more than once');
+          }
+          return Reflect.getOwnPropertyDescriptor(object, key);
+        },
+      });
+    }
+
+    expect(() =>
+      addAdUnits({
+        code: 'shared-dag',
+        mediaTypes: { banner: { sizes: [[300, 250]] } },
+        bids: [{ bidder: 'aps', params: shared }],
+      })
+    ).toThrow(expect.objectContaining({ code: 'request_body_too_large' }));
+    expect(descriptorReads.every((reads) => reads <= 2)).toBe(true);
+  });
+
+  it('measures addAdUnits input without invoking inherited toJSON hooks', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const hook = vi.fn(() => {
+      throw new Error('publisher toJSON');
+    });
+    Object.defineProperty(Object.prototype, 'toJSON', { configurable: true, value: hook });
+    Object.defineProperty(Array.prototype, 'toJSON', { configurable: true, value: hook });
+    try {
+      expect(() =>
+        (target as unknown as { addAdUnits(value: unknown): unknown }).addAdUnits({
+          code: 'valid',
+          mediaTypes: { banner: { sizes: [[300, 250]] } },
+          bids: [{ bidder: 'aps', params: { placement: 'one' } }],
+        })
+      ).toThrow(TsjsUnavailableError);
+      expect(hook).not.toHaveBeenCalled();
+    } finally {
+      Reflect.deleteProperty(Object.prototype, 'toJSON');
+      Reflect.deleteProperty(Array.prototype, 'toJSON');
+    }
+  });
+
+  it('publishes an immutable exact logger facade', async () => {
+    const target = {};
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: { version: 2 },
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    runtime.start();
+    await runtime.install();
+    const publicLog = (target as unknown as { log: object }).log;
+
+    expect(Object.isFrozen(publicLog)).toBe(true);
+    expect(Object.keys(publicLog)).toEqual([
+      'setLevel',
+      'getLevel',
+      'error',
+      'warn',
+      'info',
+      'debug',
+    ]);
+    expect(Reflect.set(publicLog, 'warn', vi.fn())).toBe(false);
+  });
+
+  it('returns false when queue descriptor reflection becomes hostile after preflight', () => {
+    let queueDescriptorReads = 0;
+    const backing = {};
+    const target = new Proxy(backing, {
+      getOwnPropertyDescriptor(object, key) {
+        if (key === 'que') {
+          queueDescriptorReads += 1;
+          if (queueDescriptorReads === 2) throw new Error('hostile second queue reflection');
+        }
+        return Reflect.getOwnPropertyDescriptor(object, key);
+      },
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    let started: boolean | undefined;
+
+    expect(() => {
+      started = runtime.start();
+    }).not.toThrow();
+    expect(started).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(queueDescriptorReads).toBe(2);
+    expect(Object.prototype.hasOwnProperty.call(backing, '_registerIntegration')).toBe(false);
+  });
+
+  it('returns false when a claim mutation and its rollback restoration both throw', () => {
+    const ingress: unknown[] = [];
+    const backing = { que: ingress, boot: boot() };
+    let queueDefinitionCalls = 0;
+    const target = new Proxy(backing, {
+      defineProperty(object, key, descriptor) {
+        if (key === 'que') {
+          queueDefinitionCalls += 1;
+          if (queueDefinitionCalls === 1) {
+            Reflect.defineProperty(object, key, descriptor);
+            throw new Error('hostile claim definition');
+          }
+          if (queueDefinitionCalls === 2) throw new Error('hostile rollback definition');
+        }
+        return Reflect.defineProperty(object, key, descriptor);
+      },
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: backing.boot,
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    let started: boolean | undefined;
+
+    expect(() => {
+      started = runtime.start();
+    }).not.toThrow();
+    expect(started).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(queueDefinitionCalls).toBe(2);
+    expect(Object.prototype.hasOwnProperty.call(backing, '_registerIntegration')).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(backing, 'version')).toBe(false);
+    expect(Object.getOwnPropertyDescriptor(backing, 'que')).toMatchObject({
+      configurable: true,
+      enumerable: true,
+      value: ingress,
+      writable: false,
+    });
+  });
+
+  it('rolls back a failed start claim without leaving a partial owner', () => {
+    let fail = true;
+    const backing = {};
+    const target = new Proxy(backing, {
+      defineProperty(object, key, descriptor) {
+        if (fail) {
+          fail = false;
+          throw new Error('transient define failure');
+        }
+        return Reflect.defineProperty(object, key, descriptor);
+      },
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+
+    expect(runtime.start()).toBe(false);
+    expect(runtime.state).toBe('unclaimed');
+    expect(Object.prototype.hasOwnProperty.call(target, '_registerIntegration')).toBe(false);
+    expect(
+      createRuntime({
+        target,
+        releaseId: RELEASE,
+        manifest: manifest([]),
+        knownIntegrationIds: Object.freeze([]),
+        boot: boot(),
+        kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+      }).start()
+    ).toBe(true);
+  });
+
+  it('captures the monotonic start before queue normalization work', async () => {
+    let time = 0;
+    const backing = {};
+    const target = new Proxy(backing, {
+      defineProperty(object, key, descriptor) {
+        time = 10_000;
+        return Reflect.defineProperty(object, key, descriptor);
+      },
+    });
+    const runtime = createRuntime({
+      target,
+      releaseId: RELEASE,
+      manifest: manifest([]),
+      knownIntegrationIds: Object.freeze([]),
+      boot: boot(),
+      now: () => time,
+      kernel: { addAdUnits: vi.fn(), diagnostics: Object.freeze({}), requestAds: vi.fn() },
+    });
+    expect(runtime.start()).toBe(true);
+
+    await expect(runtime.install()).resolves.toEqual({
+      state: 'fallback',
+      reason: 'bundle_partial',
+    });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/kernel/sessions.test.ts b/crates/trusted-server-js/lib/test/kernel/sessions.test.ts
new file mode 100644
index 000000000..5f305a647
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/kernel/sessions.test.ts
@@ -0,0 +1,442 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import {
+  createRuntimeSession,
+  type NavigationIdentityIssuerFactory,
+} from '../../src/kernel/sessions';
+
+function identityFactory(seed = 1): NavigationIdentityIssuerFactory {
+  let navigation = seed;
+  return () => {
+    const value = navigation;
+    navigation += 1;
+    return createTestNavigationIdentityIssuer({
+      getRandomValues: (target) => {
+        target.fill(value);
+        return target;
+      },
+    });
+  };
+}
+
+function frozenProjection(id: string): Readonly<object> {
+  return Object.freeze({
+    version: 1,
+    auction: Object.freeze({ version: 1, auctionId: id, results: Object.freeze([]) }),
+    bids: Object.freeze([]),
+  });
+}
+
+describe('runtime and navigation sessions', () => {
+  it('reports every navigation generation exactly once at its disposal boundary', () => {
+    const onNavigationDispose = vi.fn();
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: identityFactory(),
+      onNavigationDispose,
+    });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+
+    const replacement = runtime.replaceNavigation();
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+    expect(onNavigationDispose).toHaveBeenCalledExactlyOnceWith(initial.value.generation);
+
+    runtime.dispose();
+    runtime.dispose();
+    expect(onNavigationDispose).toHaveBeenCalledTimes(2);
+    expect(onNavigationDispose).toHaveBeenLastCalledWith(replacement.value.generation);
+  });
+
+  it('owns one current navigation and replaces it atomically before reverse disposal', () => {
+    const order: string[] = [];
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+
+    expect(initial.ok).toBe(true);
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    expect(runtime.currentNavigation).toBe(initial.value);
+    initial.value.onDispose('first', () => order.push('first'));
+    initial.value.onDispose('second', () => {
+      expect(runtime.currentNavigation).not.toBe(initial.value);
+      order.push('second');
+    });
+
+    const replacement = runtime.replaceNavigation();
+
+    expect(replacement.ok).toBe(true);
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+    expect(runtime.currentNavigation).toBe(replacement.value);
+    expect(initial.value.disposed).toBe(true);
+    expect(replacement.value.currentAuctionProjection).toBeUndefined();
+    expect(order).toEqual(['second', 'first']);
+    expect(runtime.snapshotInventoryForTest()).toMatchObject({
+      currentNavigationGeneration: replacement.value.generation,
+      disposedNavigations: 1,
+      navigationCount: 1,
+    });
+  });
+
+  it('makes late old-generation callbacks inert and allows the same DOM alias on a new route', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    const mutation = vi.fn();
+    const oldCallback = initial.value.capture(mutation);
+
+    expect(initial.value.claimAlias('shared-dom-id')).toBe(true);
+    expect(oldCallback('before')).toBe(true);
+    const replacement = runtime.replaceNavigation();
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+
+    expect(replacement.value.claimAlias('shared-dom-id')).toBe(true);
+    expect(oldCallback('late')).toBe(false);
+    expect(mutation).toHaveBeenCalledExactlyOnceWith('before');
+    expect(initial.value.snapshotInventoryForTest().aliases).toBe(0);
+    expect(replacement.value.snapshotInventoryForTest().aliases).toBe(1);
+  });
+
+  it('does not publish the replacement while old-navigation disposers are running', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    let disposerSawCurrent = true;
+    let aliasMutation: boolean | undefined;
+    initial.value.onDispose('reentrant-alias', () => {
+      disposerSawCurrent = runtime.currentNavigation !== undefined;
+      aliasMutation = runtime.currentNavigation?.claimAlias('must-not-cross-generation');
+    });
+
+    const replacement = runtime.replaceNavigation();
+
+    expect(replacement).toMatchObject({ ok: true });
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+    expect(disposerSawCurrent).toBe(false);
+    expect(aliasMutation).toBeUndefined();
+    expect(runtime.currentNavigation).toBe(replacement.value);
+    expect(replacement.value.disposed).toBe(false);
+    expect(replacement.value.snapshotInventoryForTest().aliases).toBe(0);
+  });
+
+  it('blocks nested replacement from an old-navigation disposer', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    let nestedReplacement: ReturnType<typeof runtime.replaceNavigation> | undefined;
+    initial.value.onDispose('nested-replacement', () => {
+      nestedReplacement = runtime.replaceNavigation();
+    });
+
+    const replacement = runtime.replaceNavigation();
+
+    expect(nestedReplacement).toEqual({
+      ok: false,
+      reason: 'navigation_transition_in_progress',
+    });
+    expect(replacement).toMatchObject({ ok: true });
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+    expect(runtime.currentNavigation).toBe(replacement.value);
+    expect(replacement.value.disposed).toBe(false);
+
+    const successive = runtime.replaceNavigation();
+    expect(successive).toMatchObject({ ok: true });
+    if (!successive.ok) throw new Error('Expected successive replacement');
+    expect(runtime.currentNavigation).toBe(successive.value);
+    expect(successive.value.disposed).toBe(false);
+  });
+
+  it('publishes no replacement if runtime disposal occurs during old-navigation unwind', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    initial.value.onDispose('runtime', () => runtime.dispose());
+
+    expect(runtime.replaceNavigation()).toEqual({
+      ok: false,
+      reason: 'runtime_disposed',
+    });
+    expect(runtime.currentNavigation).toBeUndefined();
+    expect(runtime.disposed).toBe(true);
+  });
+
+  it('publishes no initial navigation if identity setup disposes the runtime', () => {
+    const issueIdentity = identityFactory();
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () => {
+        runtime.dispose();
+        return issueIdentity();
+      },
+    });
+
+    expect(runtime.startInitialNavigation(frozenProjection('initial'))).toEqual({
+      ok: false,
+      reason: 'runtime_disposed',
+    });
+    expect(runtime.currentNavigation).toBeUndefined();
+    expect(runtime.disposed).toBe(true);
+  });
+
+  it('blocks nested initial-navigation creation from identity setup', () => {
+    const issueIdentity = identityFactory();
+    let nested: ReturnType<ReturnType<typeof createRuntimeSession>['startInitialNavigation']>;
+    let firstCall = true;
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () => {
+        if (firstCall) {
+          firstCall = false;
+          nested = runtime.startInitialNavigation(frozenProjection('nested'));
+        }
+        return issueIdentity();
+      },
+    });
+
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+
+    expect(nested!).toEqual({
+      ok: false,
+      reason: 'navigation_transition_in_progress',
+    });
+    expect(initial).toMatchObject({ ok: true });
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    expect(runtime.currentNavigation).toBe(initial.value);
+    expect(initial.value.disposed).toBe(false);
+  });
+
+  it('cleans timers, listeners, and ports exactly once across double disposal', () => {
+    const cleanup = {
+      timer: vi.fn(),
+      listener: vi.fn(),
+      port: vi.fn(),
+    };
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const navigation = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!navigation.ok) throw new Error('Expected initial navigation');
+
+    navigation.value.onDispose('timer', cleanup.timer);
+    navigation.value.onDispose('listener', cleanup.listener);
+    navigation.value.onDispose('port', cleanup.port);
+    navigation.value.dispose();
+    navigation.value.dispose();
+
+    expect(cleanup.port).toHaveBeenCalledOnce();
+    expect(cleanup.listener).toHaveBeenCalledOnce();
+    expect(cleanup.timer).toHaveBeenCalledOnce();
+    expect(navigation.value.snapshotInventoryForTest()).toMatchObject({
+      disposed: true,
+      activeDisposers: 0,
+      disposedByKind: { listener: 1, port: 1, timer: 1 },
+    });
+  });
+
+  it('clears an exactly current navigation after direct child disposal', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+
+    initial.value.dispose();
+
+    expect(runtime.currentNavigation).toBeUndefined();
+    expect(runtime.snapshotInventoryForTest()).toMatchObject({
+      currentNavigationGeneration: undefined,
+      disposedNavigations: 1,
+      navigationCount: 0,
+    });
+    const replacement = runtime.replaceNavigation();
+    expect(replacement).toMatchObject({ ok: true });
+    if (!replacement.ok) throw new Error('Expected replacement navigation');
+    expect(runtime.currentNavigation).toBe(replacement.value);
+    expect(replacement.value.disposed).toBe(false);
+  });
+
+  it('blocks replacement before remaining direct-disposal callbacks can mutate a new route', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    let replacement: ReturnType<typeof runtime.replaceNavigation> | undefined;
+    let disposerSawCurrent = true;
+    let aliasMutation: boolean | undefined;
+    initial.value.onDispose('old-mutator', () => {
+      disposerSawCurrent = runtime.currentNavigation !== undefined;
+      aliasMutation = runtime.currentNavigation?.claimAlias('must-not-cross-generation');
+    });
+    initial.value.onDispose('replacement', () => {
+      replacement = runtime.replaceNavigation();
+    });
+
+    initial.value.dispose();
+
+    expect(replacement).toEqual({
+      ok: false,
+      reason: 'navigation_transition_in_progress',
+    });
+    expect(disposerSawCurrent).toBe(false);
+    expect(aliasMutation).toBeUndefined();
+    expect(runtime.currentNavigation).toBeUndefined();
+    expect(runtime.snapshotInventoryForTest()).toMatchObject({
+      currentNavigationGeneration: undefined,
+      disposedNavigations: 1,
+      navigationCount: 0,
+    });
+
+    const successive = runtime.replaceNavigation();
+    expect(successive).toMatchObject({ ok: true });
+    if (!successive.ok) throw new Error('Expected successive navigation');
+    expect(runtime.currentNavigation).toBe(successive.value);
+    expect(successive.value.snapshotInventoryForTest().aliases).toBe(0);
+  });
+
+  it('owns auction batches and render attempts in nested child scopes', () => {
+    const order: string[] = [];
+    const staleMutation = vi.fn();
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory(7) });
+    const navigation = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!navigation.ok) throw new Error('Expected initial navigation');
+    const batch = navigation.value.createAuctionBatch('batch-one');
+    const overlappingBatch = navigation.value.createAuctionBatch('batch-two');
+
+    expect(batch).toBeDefined();
+    if (!batch) throw new Error('Expected auction batch');
+    if (!overlappingBatch) throw new Error('Expected overlapping auction batch');
+    const attempt = batch.createRenderAttempt('slot-one');
+    const secondAttempt = batch.createRenderAttempt('slot-two');
+    expect(attempt).toMatchObject({ ok: true });
+    if (!attempt.ok) throw new Error('Expected render attempt');
+    expect(secondAttempt).toMatchObject({ ok: true });
+    if (!secondAttempt.ok) throw new Error('Expected second render attempt');
+    expect(overlappingBatch.createRenderAttempt('slot-one')).toEqual({
+      ok: false,
+      reason: 'attempt_exists',
+    });
+    expect(attempt.value.id).toMatch(/^a1_[A-Za-z0-9_-]{22}$/);
+    expect(attempt.value.navigationGeneration).toBe(navigation.value.generation);
+    expect(attempt.value.navigationGeneration).not.toBe(attempt.value.generation);
+    batch.onDispose('batch', () => order.push('batch'));
+    batch.onDispose('late-callback', navigation.value.capture(staleMutation));
+    attempt.value.onDispose('attempt-first', () => order.push('attempt-first'));
+    attempt.value.onDispose('attempt-second', () => order.push('attempt-second'));
+    expect(navigation.value.snapshotInventoryForTest()).toMatchObject({
+      attempts: 2,
+      batches: 2,
+      retainedAttemptScopes: 2,
+      retainedBatchScopes: 2,
+    });
+
+    secondAttempt.value.dispose();
+    overlappingBatch.dispose();
+    expect(navigation.value.snapshotInventoryForTest()).toMatchObject({
+      attempts: 1,
+      batches: 1,
+      retainedAttemptScopes: 1,
+      retainedBatchScopes: 1,
+    });
+
+    navigation.value.dispose();
+
+    expect(staleMutation).not.toHaveBeenCalled();
+    expect(order).toEqual(['attempt-second', 'attempt-first', 'batch']);
+    expect(batch.disposed).toBe(true);
+    expect(attempt.value.disposed).toBe(true);
+    expect(navigation.value.snapshotInventoryForTest()).toMatchObject({
+      attempts: 0,
+      batches: 0,
+    });
+  });
+
+  it('prepares, commits, and rolls back one immutable winner-context admission', () => {
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const navigation = runtime.startInitialNavigation();
+    if (!navigation.ok) throw new Error('Expected navigation');
+    const batch = navigation.value.createAuctionBatch('winner-context');
+    if (!batch) throw new Error('Expected auction batch');
+    const attempt = batch.createRenderAttempt('fictional-slot');
+    if (!attempt.ok) throw new Error('Expected render attempt');
+    const accepted = Object.freeze({ selectedCpm: 1.25 });
+
+    expect(attempt.value.winnerContext).toBeUndefined();
+    const first = attempt.value.prepareWinnerContext(accepted);
+    expect(first).toBeDefined();
+    expect(attempt.value.winnerContext).toBeUndefined();
+    expect(first?.commit()).toBe(true);
+    expect(attempt.value.winnerContext).toBe(accepted);
+    expect(first?.rollback()).toBe(true);
+    expect(attempt.value.winnerContext).toBeUndefined();
+
+    const committed = attempt.value.prepareWinnerContext(accepted);
+    expect(committed?.commit()).toBe(true);
+    expect(attempt.value.winnerContext).toBe(accepted);
+    expect(attempt.value.prepareWinnerContext(accepted)?.commit()).toBe(true);
+    expect(
+      attempt.value.prepareWinnerContext(Object.freeze({ selectedCpm: 1.25 }))
+    ).toBeUndefined();
+
+    attempt.value.dispose();
+    expect(attempt.value.prepareWinnerContext(Object.freeze({ selectedCpm: 2 }))).toBeUndefined();
+    expect(attempt.value.winnerContext).toBe(accepted);
+  });
+
+  it('refuses identity failure before replacing or creating route work', () => {
+    const firstIssuer = identityFactory();
+    const createIdentityIssuer = vi
+      .fn<NavigationIdentityIssuerFactory>()
+      .mockImplementationOnce(firstIssuer)
+      .mockReturnValue({ ok: false, reason: 'identity_generation_failed' });
+    const runtime = createRuntimeSession({ createIdentityIssuer });
+    const initial = runtime.startInitialNavigation(frozenProjection('initial'));
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    const disposer = vi.fn();
+    initial.value.onDispose('route', disposer);
+
+    const replacement = runtime.replaceNavigation();
+
+    expect(replacement).toEqual({ ok: false, reason: 'identity_generation_failed' });
+    expect(runtime.currentNavigation).toBe(initial.value);
+    expect(initial.value.disposed).toBe(false);
+    expect(disposer).not.toHaveBeenCalled();
+    expect(runtime.snapshotInventoryForTest()).toMatchObject({
+      disposedNavigations: 0,
+      navigationCount: 1,
+    });
+  });
+
+  it('owns aliases, intents, targeting, batches, attempts, and one immutable projection', () => {
+    const projection = frozenProjection('initial');
+    const runtime = createRuntimeSession({ createIdentityIssuer: identityFactory() });
+    const navigation = runtime.startInitialNavigation(projection);
+    if (!navigation.ok) throw new Error('Expected initial navigation');
+
+    expect(navigation.value.claimAlias('slot-alias')).toBe(true);
+    expect(navigation.value.claimAlias('slot-alias')).toBe(false);
+    expect(navigation.value.claimIntent('slot-one')).toBe(true);
+    expect(navigation.value.claimTargeting('slot-one')).toBe(true);
+    expect(navigation.value.currentAuctionProjection).toBe(projection);
+    expect(Object.isFrozen(navigation.value.currentAuctionProjection)).toBe(true);
+    expect(navigation.value.snapshotInventoryForTest()).toMatchObject({
+      aliases: 1,
+      attempts: 0,
+      batches: 0,
+      intents: 1,
+      targetingOwners: 1,
+    });
+  });
+
+  it('owns injected interfaces and runtime disposers without exposing mutable inventory', () => {
+    const order: string[] = [];
+    const interfaces = Object.freeze({ messaging: Object.freeze({ active: true }) });
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: identityFactory(),
+      interfaces,
+    });
+    runtime.onDispose('adapter', () => order.push('adapter'));
+    runtime.onDispose('service', () => order.push('service'));
+
+    expect(runtime.interfaces).toBe(interfaces);
+    expect(Object.isFrozen(runtime.interfaces)).toBe(true);
+    runtime.dispose();
+    runtime.dispose();
+
+    expect(order).toEqual(['service', 'adapter']);
+    const inventory = runtime.snapshotInventoryForTest();
+    expect(Object.isFrozen(inventory)).toBe(true);
+    expect(inventory).toMatchObject({ disposed: true, activeDisposers: 0 });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs b/crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs
index 6f4be0caa..27e9353e8 100644
--- a/crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs
+++ b/crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs
@@ -18,6 +18,7 @@ import { JSDOM } from 'jsdom';
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
 
 import { main } from '../build-prebid-external.mjs';
+import { createBrowserPrebidAdapter } from '../src/adapters/prebid';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const libDir = path.resolve(__dirname, '..');
@@ -26,6 +27,19 @@ let outputDirectory;
 let bundleCode;
 let shimCode;
 let prebidVersion;
+let artifactManifest;
+
+function cloneAndDeepFreezeInWindow(pageWindow, value) {
+  const cloned = pageWindow.JSON.parse(JSON.stringify(value));
+  const freeze = (entry) => {
+    if (entry && typeof entry === 'object') {
+      for (const key of pageWindow.Object.getOwnPropertyNames(entry)) freeze(entry[key]);
+      pageWindow.Object.freeze(entry);
+    }
+    return entry;
+  };
+  return freeze(cloned);
+}
 
 beforeAll(async () => {
   outputDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'trusted-server-prebid-artifacts-'));
@@ -38,9 +52,11 @@ beforeAll(async () => {
     '--out',
     outputDirectory,
   ]);
-  const manifest = JSON.parse(fs.readFileSync(path.join(outputDirectory, 'manifest.json'), 'utf8'));
-  bundleCode = fs.readFileSync(path.join(outputDirectory, manifest.filename), 'utf8');
-  prebidVersion = manifest.prebidVersion;
+  artifactManifest = JSON.parse(
+    fs.readFileSync(path.join(outputDirectory, 'manifest.json'), 'utf8')
+  );
+  bundleCode = fs.readFileSync(path.join(outputDirectory, artifactManifest.filename), 'utf8');
+  prebidVersion = artifactManifest.prebidVersion;
 
   const { build } = await import('vite');
   await build({
@@ -58,7 +74,6 @@ beforeAll(async () => {
           format: 'iife',
           dir: outputDirectory,
           entryFileNames: 'tsjs-prebid.js',
-          inlineDynamicImports: true,
           extend: false,
           name: 'tsjs_prebid',
         },
@@ -86,142 +101,371 @@ describe('tsjs-prebid shim artifact', () => {
     // A value-import of Prebid or a private rendering helper would multiply
     // the shim size; retain a margin above the normal compact shim output.
     expect(bundleCode.length).toBeGreaterThan(200_000);
-    expect(shimCode.length).toBeLessThan(32_000);
-    expect(shimCode).toContain('markWinningBidAsUsed');
+    expect(shimCode.length).toBeLessThan(30_000);
+    expect(shimCode).toContain('registerTrustedServerBidder');
   });
 });
 
 describe('external bundle + served shim evaluated together', () => {
-  it('populates the public API, installs the shim exactly once, and routes an /auction request', async () => {
+  it('reuses an exact artifact without replaying factories and keeps one watchdog per wrapper', () => {
     const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>', {
       url: 'https://pub.example.com/article',
       runScripts: 'outside-only',
-      pretendToBeVisual: true,
     });
     const pageWindow = dom.window;
-
-    // Stub the network before any artifact runs: Prebid's ajax module
-    // captures window.fetch at evaluation time and builds Request objects.
-    // jsdom ships none of the fetch API, so lend it Node's — with relative
-    // URLs resolved against the page, as a browser Request would.
-    const fetchSpy = vi.fn(
-      async () =>
-        new Response('{}', {
-          status: 200,
-          headers: { 'Content-Type': 'application/json' },
-        })
-    );
-    pageWindow.fetch = fetchSpy;
-    pageWindow.Request = class PageRequest extends Request {
-      constructor(resource, init) {
-        super(
-          typeof resource === 'string'
-            ? new URL(resource, 'https://pub.example.com').href
-            : resource,
-          init
-        );
+    const watchdogs = [];
+    const originalSetTimeout = pageWindow.setTimeout.bind(pageWindow);
+    pageWindow.setTimeout = (callback, delay, ...arguments_) => {
+      if (delay === 5_000 && String(callback).includes('__tsWatchdogFired')) {
+        watchdogs.push(callback);
+        return 1;
       }
+      return originalSetTimeout(callback, delay, ...arguments_);
     };
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
     pageWindow.Headers = Headers;
     pageWindow.Response = Response;
     pageWindow.AbortController = AbortController;
-    if (!('isSecureContext' in pageWindow)) {
-      pageWindow.isSecureContext = true;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
+    pageWindow.eval('window.pbjs = { que: [], cmd: [] };');
+
+    pageWindow.eval(bundleCode);
+    const firstBinding = pageWindow.pbjs;
+    const firstRequestBids = firstBinding.requestBids;
+    const firstStamp = firstBinding.__trustedServerArtifactV1;
+    pageWindow.eval(bundleCode);
+
+    expect(pageWindow.pbjs).toBe(firstBinding);
+    expect(pageWindow.pbjs.requestBids).toBe(firstRequestBids);
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(firstStamp);
+    expect(watchdogs).toHaveLength(2);
+
+    const processQueue = vi.fn(firstBinding.processQueue.bind(firstBinding));
+    firstBinding.processQueue = processQueue;
+    for (const watchdog of watchdogs) {
+      watchdog();
+      watchdog();
     }
+    expect(processQueue).toHaveBeenCalledTimes(2);
+    dom.window.close();
+  });
 
-    // Mirror the server's head-injected state, which always precedes the
-    // bundle script in document order.
+  it('reuses separately constructed identical artifacts without reporting a conflict', () => {
+    const dom = new JSDOM('<!doctype html><html><head></head><body></body></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    const watchdogs = [];
+    const originalSetTimeout = pageWindow.setTimeout.bind(pageWindow);
+    pageWindow.setTimeout = (callback, delay, ...arguments_) => {
+      if (delay === 5_000 && String(callback).includes('__tsWatchdogFired')) {
+        watchdogs.push(callback);
+        return 1;
+      }
+      return originalSetTimeout(callback, delay, ...arguments_);
+    };
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
+    pageWindow.Headers = Headers;
+    pageWindow.Response = Response;
+    pageWindow.AbortController = AbortController;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
     pageWindow.eval('window.pbjs = { que: [], cmd: [] };');
-    pageWindow.__tsjs_prebid = {
-      clientSideBidders: [],
-      serverSideBidders: ['appnexus'],
+    const warn = vi.fn();
+    pageWindow.console.warn = warn;
+    const firstBytes = Buffer.from(bundleCode, 'utf8');
+    const duplicateBytes = Buffer.from(bundleCode, 'utf8');
+    expect(firstBytes).not.toBe(duplicateBytes);
+    expect(firstBytes.equals(duplicateBytes)).toBe(true);
+
+    pageWindow.eval(firstBytes.toString('utf8'));
+    const firstBinding = pageWindow.pbjs;
+    const firstRequestBids = firstBinding.requestBids;
+    const firstRegisterBidAdapter = firstBinding.registerBidAdapter;
+    const firstStamp = firstBinding.__trustedServerArtifactV1;
+    pageWindow.eval(duplicateBytes.toString('utf8'));
+
+    expect(pageWindow.pbjs).toBe(firstBinding);
+    expect(pageWindow.pbjs.requestBids).toBe(firstRequestBids);
+    expect(pageWindow.pbjs.registerBidAdapter).toBe(firstRegisterBidAdapter);
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(firstStamp);
+    expect(warn).not.toHaveBeenCalled();
+    expect(watchdogs).toHaveLength(2);
+
+    const processQueue = vi.fn(firstBinding.processQueue.bind(firstBinding));
+    firstBinding.processQueue = processQueue;
+    for (const watchdog of watchdogs) {
+      watchdog();
+      watchdog();
+    }
+    expect(processQueue).toHaveBeenCalledTimes(2);
+    dom.window.close();
+  });
+
+  it('refuses a different valid artifact without disturbing the working binding', () => {
+    const dom = new JSDOM('<!doctype html><html></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    const conflictingStamp = {
+      abi: artifactManifest.abi,
+      artifactReleaseId: 'f'.repeat(64),
+      prebidVersion: artifactManifest.prebidVersion,
+      moduleStems: artifactManifest.moduleStems,
+      bidderCodes: artifactManifest.bidderCodes,
+      bidderAliases: artifactManifest.bidderAliases,
+      userIdModules: artifactManifest.userIdModules,
     };
+    pageWindow.eval(
+      `window.__conflictingRequestBids=function conflictingRequestBids(){};window.pbjs={que:[],cmd:[]};["addAdUnits","getBidResponsesForAdUnitCode","getHighestCpmBids","offEvent","onEvent","processQueue","registerBidAdapter","renderAd","requestBids","setTargetingForGPTAsync"].forEach(function(name){window.pbjs[name]=name==="requestBids"?window.__conflictingRequestBids:function(){};});`
+    );
+    pageWindow.__conflictingStamp = cloneAndDeepFreezeInWindow(pageWindow, conflictingStamp);
+    pageWindow.Object.defineProperty(pageWindow.pbjs, '__trustedServerArtifactV1', {
+      value: pageWindow.__conflictingStamp,
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+    const binding = pageWindow.pbjs;
+    const warn = vi.fn();
+    pageWindow.console.warn = warn;
 
-    pageWindow.eval(bundleCode);
+    expect(() => pageWindow.eval(bundleCode)).not.toThrow();
+    expect(pageWindow.pbjs).toBe(binding);
+    expect(pageWindow.pbjs.requestBids).toBe(pageWindow.__conflictingRequestBids);
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(pageWindow.__conflictingStamp);
+    expect(warn).toHaveBeenCalledTimes(1);
+    dom.window.close();
+  });
 
+  it('does not mistake an exact stamp on a Prebid stub for an initialized duplicate', () => {
+    const dom = new JSDOM('<!doctype html><html></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
+    pageWindow.Headers = Headers;
+    pageWindow.Response = Response;
+    pageWindow.AbortController = AbortController;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
+    pageWindow.eval('window.pbjs = { que: [], cmd: [] };');
+    pageWindow.__exactStamp = cloneAndDeepFreezeInWindow(pageWindow, {
+      abi: artifactManifest.abi,
+      artifactReleaseId: artifactManifest.artifactReleaseId,
+      prebidVersion: artifactManifest.prebidVersion,
+      moduleStems: artifactManifest.moduleStems,
+      bidderCodes: artifactManifest.bidderCodes,
+      bidderAliases: artifactManifest.bidderAliases,
+      userIdModules: artifactManifest.userIdModules,
+    });
+    pageWindow.Object.defineProperty(pageWindow.pbjs, '__trustedServerArtifactV1', {
+      value: pageWindow.__exactStamp,
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
+
+    expect(() => pageWindow.eval(bundleCode)).not.toThrow();
     expect(typeof pageWindow.pbjs.requestBids).toBe('function');
-    expect(typeof pageWindow.pbjs.registerBidAdapter).toBe('function');
-    expect(pageWindow.__tsjs_prebid_bundle.adapters).toEqual(['adf']);
-    expect([...pageWindow.__tsjs_prebid_bundle.bidderCodes]).toEqual([
-      'adf',
-      'adform',
-      'adformOpenRTB',
-    ]);
-    expect([...pageWindow.__tsjs_prebid_bundle.userIdModules]).toEqual(['sharedIdSystem']);
-
-    // Count trustedServer registrations across repeated shim evaluations.
-    const originalRegisterBidAdapter = pageWindow.pbjs.registerBidAdapter.bind(pageWindow.pbjs);
-    const registerSpy = vi.fn(originalRegisterBidAdapter);
-    pageWindow.pbjs.registerBidAdapter = registerSpy;
-
-    pageWindow.eval(shimCode);
-    const wrappedRequestBids = pageWindow.pbjs.requestBids;
-
-    // A second evaluation (double script inclusion, or a legacy bundle that
-    // still carries a baked-in shim running after this one) must be a no-op.
-    pageWindow.eval(shimCode);
-
-    const trustedServerRegistrations = registerSpy.mock.calls.filter(
-      ([, bidderCode]) => bidderCode === 'trustedServer'
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(pageWindow.__exactStamp);
+    dom.window.close();
+  });
+
+  it('accepts an exact 128-byte non-ASCII artifact name on a real stamped binding', () => {
+    const dom = new JSDOM('<!doctype html><html></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    const boundaryName = 'é'.repeat(64);
+    const boundaryStamp = {
+      abi: artifactManifest.abi,
+      artifactReleaseId: 'e'.repeat(64),
+      prebidVersion: artifactManifest.prebidVersion,
+      moduleStems: [...artifactManifest.moduleStems, boundaryName].sort(),
+      bidderCodes: artifactManifest.bidderCodes,
+      bidderAliases: artifactManifest.bidderAliases,
+      userIdModules: artifactManifest.userIdModules,
+    };
+    pageWindow.eval(
+      `window.__fakeRequestBids=function fakeRequestBids(){};window.pbjs={que:[],cmd:[]};["addAdUnits","getBidResponsesForAdUnitCode","getHighestCpmBids","offEvent","onEvent","processQueue","registerBidAdapter","renderAd","requestBids","setTargetingForGPTAsync"].forEach(function(name){window.pbjs[name]=name==="requestBids"?window.__fakeRequestBids:function(){};});`
     );
-    expect(trustedServerRegistrations).toHaveLength(1);
-    expect(pageWindow.pbjs.requestBids).toBe(wrappedRequestBids);
-    expect(pageWindow.__tsjsPrebidShimInstalled).toBe(true);
-
-    // Drive one real auction through the wrapped requestBids and assert the
-    // transformed request reaches /auction.
-    const slot = pageWindow.document.createElement('div');
-    slot.id = 'ad-slot-1';
-    pageWindow.document.body.appendChild(slot);
-
-    pageWindow.pbjs.requestBids({
-      adUnits: [
-        {
-          code: 'ad-slot-1',
-          mediaTypes: { banner: { sizes: [[300, 250]] } },
-          bids: [
-            {
-              bidder: 'trustedServer',
-              params: {
-                bidderParams: {
-                  appnexus: { placementId: 1 },
-                  pbsProviderId: { placementId: 2 },
-                  returnedSeatAlias: { placementId: 3 },
-                },
-              },
-            },
-          ],
-        },
-      ],
-      timeout: 1000,
+    pageWindow.__boundaryStamp = cloneAndDeepFreezeInWindow(pageWindow, boundaryStamp);
+    pageWindow.Object.defineProperty(pageWindow.pbjs, '__trustedServerArtifactV1', {
+      value: pageWindow.__boundaryStamp,
+      enumerable: false,
+      writable: false,
+      configurable: false,
     });
 
-    const requestUrl = (resource) =>
-      typeof resource === 'string' ? resource : String(resource?.url ?? resource);
+    expect(() => pageWindow.eval(bundleCode)).not.toThrow();
+    expect(pageWindow.pbjs.requestBids).toBe(pageWindow.__fakeRequestBids);
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(pageWindow.__boundaryStamp);
+    dom.window.close();
+  });
 
-    await vi.waitFor(
-      () => {
-        expect(
-          fetchSpy.mock.calls.some(([resource]) => requestUrl(resource).includes('/auction'))
-        ).toBe(true);
-      },
-      { timeout: 10_000 }
+  it('does not accept a UTF-8-overlong artifact name on a real stamped binding', () => {
+    const dom = new JSDOM('<!doctype html><html></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
+    pageWindow.Headers = Headers;
+    pageWindow.Response = Response;
+    pageWindow.AbortController = AbortController;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
+    const overlongName = `${'é'.repeat(64)}a`;
+    const malformedStamp = {
+      abi: artifactManifest.abi,
+      artifactReleaseId: 'f'.repeat(64),
+      prebidVersion: artifactManifest.prebidVersion,
+      moduleStems: [...artifactManifest.moduleStems, overlongName].sort(),
+      bidderCodes: artifactManifest.bidderCodes,
+      bidderAliases: artifactManifest.bidderAliases,
+      userIdModules: artifactManifest.userIdModules,
+    };
+    pageWindow.eval(
+      `window.__fakeRequestBids=function fakeRequestBids(){};window.pbjs={que:[],cmd:[]};["addAdUnits","getBidResponsesForAdUnitCode","getHighestCpmBids","offEvent","onEvent","processQueue","registerBidAdapter","renderAd","requestBids","setTargetingForGPTAsync"].forEach(function(name){window.pbjs[name]=name==="requestBids"?window.__fakeRequestBids:function(){};});`
     );
+    pageWindow.__malformedStamp = cloneAndDeepFreezeInWindow(pageWindow, malformedStamp);
+    pageWindow.Object.defineProperty(pageWindow.pbjs, '__trustedServerArtifactV1', {
+      value: pageWindow.__malformedStamp,
+      enumerable: false,
+      writable: false,
+      configurable: false,
+    });
 
-    const [resource, init] = fetchSpy.mock.calls.find(([target]) =>
-      requestUrl(target).includes('/auction')
-    );
-    const body = init?.body ?? (typeof resource === 'object' ? await resource.text() : undefined);
-    const method = init?.method ?? resource?.method;
-    expect(method).toBe('POST');
-    const payload = JSON.parse(body);
-    const adUnit = payload.adUnits[0];
-    expect(adUnit.code).toBe('ad-slot-1');
-    // Stored trustedServer params retain only authoritative server-side route
-    // codes; provider IDs and returned aliases cannot reach /auction.
-    const trustedServerBid = adUnit.bids.find((bid) => bid.bidder === 'trustedServer');
-    expect(trustedServerBid.params.bidderParams).toEqual({ appnexus: { placementId: 1 } });
+    expect(() => pageWindow.eval(bundleCode)).not.toThrow();
+    expect(typeof pageWindow.pbjs.requestBids).toBe('function');
+    expect(pageWindow.pbjs.requestBids).not.toBe(pageWindow.__fakeRequestBids);
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(pageWindow.__malformedStamp);
+    dom.window.close();
+  });
 
+  it('keeps publisher Prebid usable when a hostile stamp cannot be replaced', () => {
+    const dom = new JSDOM('<!doctype html><html></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+    });
+    const pageWindow = dom.window;
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
+    pageWindow.Headers = Headers;
+    pageWindow.Response = Response;
+    pageWindow.AbortController = AbortController;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
+    pageWindow.eval('window.pbjs = { que: [], cmd: [] };');
+    const hostileStamp = Object.freeze({ abi: 99 });
+    pageWindow.Object.defineProperty(pageWindow.pbjs, '__trustedServerArtifactV1', {
+      value: hostileStamp,
+      enumerable: true,
+      writable: false,
+      configurable: false,
+    });
+    const warn = vi.fn();
+    pageWindow.console.warn = warn;
+
+    expect(() => pageWindow.eval(bundleCode)).not.toThrow();
+    expect(typeof pageWindow.pbjs.requestBids).toBe('function');
+    expect(pageWindow.pbjs.__trustedServerArtifactV1).toBe(hostileStamp);
+    expect(warn).toHaveBeenCalledTimes(1);
+    dom.window.close();
+  });
+
+  it('admits one exact TS bid through the real 10.26.0 response callback', async () => {
+    const dom = new JSDOM('<!doctype html><html><body></body></html>', {
+      url: 'https://pub.example.com/article',
+      runScripts: 'outside-only',
+      pretendToBeVisual: true,
+    });
+    const pageWindow = dom.window;
+    pageWindow.fetch = vi.fn(async () => new Response('{}'));
+    pageWindow.Request = Request;
+    pageWindow.Headers = Headers;
+    pageWindow.Response = Response;
+    pageWindow.AbortController = AbortController;
+    if (!('isSecureContext' in pageWindow)) pageWindow.isSecureContext = true;
+    pageWindow.eval('window.pbjs = { que: [], cmd: [] };');
+    pageWindow.eval(bundleCode);
+
+    const adapter = createBrowserPrebidAdapter(pageWindow);
+    let resolveAuction;
+    const auctionReady = new Promise((resolve) => {
+      resolveAuction = resolve;
+    });
+    let resolveBidsBack;
+    const bidsBack = new Promise((resolve) => {
+      resolveBidsBack = resolve;
+    });
+    const operation = adapter.run((prebid) => {
+      prebid.registerTrustedServerBidder(resolveAuction);
+      return prebid.requestBids({
+        adUnits: [
+          {
+            code: 'slot-one',
+            mediaTypes: { banner: { sizes: [[300, 250]] } },
+            bids: [{ bidder: 'trustedServer', params: {} }],
+          },
+        ],
+        timeout: 1_000,
+        bidsBackHandler: resolveBidsBack,
+      });
+    });
+    await operation.result;
+    const auction = await auctionReady;
+    expect(Object.isFrozen(auction)).toBe(true);
+    expect(auction.bids).toHaveLength(1);
+
+    const request = auction.bids[0];
+    const reservationId = `r1_${'z'.repeat(22)}`;
+    const prepared = Object.freeze({
+      auctionId: auction.auctionId,
+      adUnitCode: request.adUnitCode,
+      bid: Object.freeze({
+        requestId: request.requestId,
+        adId: reservationId,
+        cpm: 1.25,
+        width: 300,
+        height: 250,
+        ad: '',
+        ttl: 300,
+        creativeId: 'creative-one',
+        netRevenue: true,
+        currency: 'USD',
+        bidderCode: 'trustedServer',
+        meta: Object.freeze({
+          advertiserDomains: Object.freeze([]),
+          tsAuctionId: auction.auctionId,
+          tsBidId: 'server-bid-one',
+        }),
+      }),
+    });
+
+    const beforeAdmission = pageWindow.pbjs.getBidResponsesForAdUnitCode('slot-one');
+    expect(Array.isArray(beforeAdmission)).toBe(true);
+    expect(Array.isArray(beforeAdmission.bids)).toBe(true);
+    expect(beforeAdmission.bids).toHaveLength(0);
+    expect(adapter.admitTrustedBid(prepared)).toBe('admitted');
+    const stored = pageWindow.pbjs.getBidResponsesForAdUnitCode('slot-one').bids;
+    const admitted = stored.filter((bid) => bid.adId === reservationId);
+    expect(admitted).toHaveLength(1);
+    expect(admitted[0]).toMatchObject({
+      adId: reservationId,
+      adUnitCode: 'slot-one',
+      auctionId: auction.auctionId,
+      requestId: request.requestId,
+      adserverTargeting: { hb_adid: reservationId },
+    });
+    auction.complete();
+    await bidsBack;
+    adapter.dispose();
     dom.window.close();
   }, 60_000);
 });
diff --git a/crates/trusted-server-js/lib/test/services/auction_batch.test.ts b/crates/trusted-server-js/lib/test/services/auction_batch.test.ts
new file mode 100644
index 000000000..768faffde
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/auction_batch.test.ts
@@ -0,0 +1,660 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { parseTrustedServerAuctionResponseV1 } from '../../src/core/auction';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import {
+  createRuntimeSession,
+  type NavigationSession,
+  type RenderAttemptScope,
+} from '../../src/kernel/sessions';
+import {
+  createAuctionBatchService,
+  type AuctionBatchFetcher,
+  type AuctionBatchServiceOptions,
+} from '../../src/services/auction_batch';
+import type {
+  RenderAttempt,
+  RenderCancellationReason,
+  RenderFailureReason,
+  RenderOutcome,
+} from '../../src/services/render';
+
+function navigation(): NavigationSession {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(7);
+          return target;
+        },
+      }),
+  });
+  const result = runtime.startInitialNavigation();
+  if (!result.ok) throw new Error(result.reason);
+  return result.value;
+}
+
+interface AttemptHarness {
+  readonly attempt: RenderAttempt;
+  readonly outcomes: readonly RenderOutcome[];
+}
+
+function attemptHarness(owner: RenderAttemptScope): AttemptHarness {
+  const outcomes: RenderOutcome[] = [];
+  const observers: Array<(outcome: RenderOutcome) => void> = [];
+  let outcome: RenderOutcome | undefined;
+  const settle = (next: RenderOutcome): boolean => {
+    if (outcome) return false;
+    outcome = Object.freeze(next);
+    outcomes.push(outcome);
+    owner.dispose();
+    observers.splice(0).forEach((observer) => observer(outcome!));
+    return true;
+  };
+  owner.onDispose('test-render-lifecycle', () => {
+    if (!outcome) settle({ outcome: 'cancelled', reason: 'navigation_disposed' });
+  });
+  const attempt = {
+    id: owner.id,
+    slot: owner.slot,
+    generation: owner.generation,
+    navigationGeneration: owner.navigationGeneration,
+    parentAttemptId: undefined,
+    renderSource: undefined,
+    winnerContext: undefined,
+    admitDirectWinner: vi.fn(() => true),
+    admitClaimedWinner: vi.fn(() => false),
+    beginGamClaim: vi.fn(() => false),
+    ownerClaimed: vi.fn(() => false),
+    ownerRegistered: vi.fn(() => false),
+    beginDirect: vi.fn(() => false),
+    beginApsDocument: vi.fn(() => false),
+    beginAdm: vi.fn(() => false),
+    apsDocumentAccepted: vi.fn(() => false),
+    accept: () => settle({ outcome: 'accepted' }),
+    noBid: () => settle({ outcome: 'no_bid' }),
+    fail: (reason: RenderFailureReason) => settle({ outcome: 'failed', reason }),
+    cancel: (reason: RenderCancellationReason) => settle({ outcome: 'cancelled', reason }),
+    onSettled: (observer: (terminal: RenderOutcome) => void) => {
+      if (outcome) observer(outcome);
+      else observers.push(observer);
+      return true;
+    },
+    snapshot: () => ({
+      history: Object.freeze(outcome ? ['created', outcome.outcome] : ['created']),
+      outcome,
+      state: outcome?.outcome ?? ('created' as const),
+    }),
+  } as RenderAttempt;
+  return { attempt, outcomes };
+}
+
+function candidateId(index: number): string {
+  return index.toString(36).padStart(12, 'A');
+}
+
+function reservationId(index: number): string {
+  return `r1_${index.toString(36).padStart(22, 'A')}`;
+}
+
+type Decision =
+  | { slot: string; outcome: 'winner'; candidateId: string }
+  | { slot: string; outcome: 'no_bid' }
+  | { slot: string; outcome: 'failed'; reason: 'provider_timeout' };
+
+function response(decisions: readonly Decision[]): unknown {
+  const winners = decisions.filter(
+    (decision): decision is Extract<Decision, { outcome: 'winner' }> =>
+      decision.outcome === 'winner'
+  );
+  return {
+    id: 'auction-1',
+    cur: 'USD',
+    seatbid:
+      winners.length === 0
+        ? []
+        : [
+            {
+              seat: 'prebid',
+              bid: winners.map((winner, index) => {
+                const source = {
+                  type: 'adm',
+                  version: 1,
+                  adm: `<div>${winner.slot}</div>`,
+                  width: 300,
+                  height: 250,
+                };
+                return {
+                  id: reservationId(index),
+                  impid: winner.slot,
+                  price: index + 1,
+                  adm: source.adm,
+                  w: source.width,
+                  h: source.height,
+                  ext: {
+                    trusted_server: {
+                      candidate_id: winner.candidateId,
+                      slot_id: winner.slot,
+                      render_source: source,
+                    },
+                  },
+                };
+              }),
+            },
+          ],
+    ext: {
+      trusted_server: {
+        slot_results: { version: 1, auctionId: 'auction-1', results: decisions },
+      },
+    },
+  };
+}
+
+function successfulFetcher(body: unknown): AuctionBatchFetcher {
+  return vi.fn(async () => ({ ok: true, json: async () => body }));
+}
+
+function createService(options: Omit<AuctionBatchServiceOptions, 'parseResponse'>) {
+  return createAuctionBatchService({
+    ...options,
+    parseResponse: parseTrustedServerAuctionResponseV1,
+  });
+}
+
+function abortablePendingFetcher(): {
+  readonly fetcher: AuctionBatchFetcher;
+  readonly signals: AbortSignal[];
+} {
+  const signals: AbortSignal[] = [];
+  const fetcher: AuctionBatchFetcher = vi.fn(
+    (_input, init) =>
+      new Promise((_resolve, reject) => {
+        const signal = init.signal;
+        if (!signal) throw new Error('Expected a fetch signal');
+        signals.push(signal);
+        signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')), {
+          once: true,
+        });
+      })
+  );
+  return { fetcher, signals };
+}
+
+describe('auction batch service', () => {
+  it('rejects a response whose decisions reverse immutable request order', async () => {
+    const attempts = new Map<string, AttemptHarness>();
+    const fetcher = successfulFetcher(
+      response([
+        { slot: 'slot-a', outcome: 'no_bid' },
+        { slot: 'slot-b', outcome: 'winner', candidateId: candidateId(0) },
+      ])
+    );
+    const service = createService({
+      createAttempt: (owner) => {
+        const harness = attemptHarness(owner);
+        attempts.set(owner.slot, harness);
+        return { ok: true, value: harness.attempt };
+      },
+      fetcher,
+      renderWinner: (attempt) => attempt.accept(),
+    });
+
+    const batch = service.create({
+      navigation: navigation(),
+      requestBody: '{"adUnits":[]}',
+      slots: Object.freeze(['slot-b', 'slot-a']),
+      timeoutMs: 10_000,
+    });
+
+    await expect(batch.result).resolves.toEqual({
+      slots: [
+        { slot: 'slot-b', path: 'primary', outcome: 'failed', reason: 'invalid_response' },
+        { slot: 'slot-a', path: 'primary', outcome: 'failed', reason: 'invalid_response' },
+      ],
+    });
+    expect(fetcher).toHaveBeenCalledOnce();
+    expect(fetcher).toHaveBeenCalledWith(
+      '/auction',
+      expect.objectContaining({
+        method: 'POST',
+        body: '{"adUnits":[]}',
+        signal: expect.any(AbortSignal),
+      })
+    );
+    expect(attempts.size).toBe(2);
+    expect(attempts.get('slot-b')?.attempt.admitDirectWinner).not.toHaveBeenCalled();
+    expect(Object.isFrozen(await batch.result)).toBe(true);
+    expect(Object.isFrozen((await batch.result).slots)).toBe(true);
+  });
+
+  it('fails only live children on the shared response deadline and aborts the fetch', async () => {
+    vi.useFakeTimers();
+    try {
+      const pending = abortablePendingFetcher();
+      const service = createService({
+        createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+        fetcher: pending.fetcher,
+        renderWinner: () => false,
+      });
+      const batch = service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        slots: Object.freeze(['slot-a', 'slot-b']),
+        timeoutMs: 100,
+      });
+
+      await vi.advanceTimersByTimeAsync(99);
+      expect(pending.signals[0]?.aborted).toBe(false);
+      await vi.advanceTimersByTimeAsync(1);
+
+      await expect(batch.result).resolves.toEqual({
+        slots: [
+          { slot: 'slot-a', path: 'primary', outcome: 'failed', reason: 'auction_timeout' },
+          { slot: 'slot-b', path: 'primary', outcome: 'failed', reason: 'auction_timeout' },
+        ],
+      });
+      expect(pending.signals[0]?.aborted).toBe(true);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('cancels issued children without fetching for an already-aborted caller', async () => {
+    const fetcher = successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }]));
+    const createAttempt = vi.fn((owner: RenderAttemptScope) => ({
+      ok: true as const,
+      value: attemptHarness(owner).attempt,
+    }));
+    const service = createService({
+      createAttempt,
+      fetcher,
+      renderWinner: () => false,
+    });
+    const caller = new AbortController();
+    caller.abort();
+
+    await expect(
+      service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        signal: caller.signal,
+        slots: Object.freeze(['slot-a']),
+        timeoutMs: 10_000,
+      }).result
+    ).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' }],
+    });
+    expect(createAttempt).toHaveBeenCalledOnce();
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it('supersedes only overlapping children and retains the old fetch until all old children settle', async () => {
+    const firstFetch = abortablePendingFetcher();
+    const secondFetch = successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }]));
+    const fetchers = [firstFetch.fetcher, secondFetch] as const;
+    let fetchIndex = 0;
+    const service = createService({
+      createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+      fetcher: (input, init) => fetchers[fetchIndex++]!(input, init),
+      renderWinner: () => false,
+    });
+    const firstAbort = new AbortController();
+    const owner = navigation();
+    const first = service.create({
+      navigation: owner,
+      requestBody: '{}',
+      signal: firstAbort.signal,
+      slots: Object.freeze(['slot-a', 'slot-b']),
+      timeoutMs: 10_000,
+    });
+    const second = service.create({
+      navigation: owner,
+      requestBody: '{}',
+      slots: Object.freeze(['slot-a']),
+      timeoutMs: 10_000,
+    });
+
+    expect(firstFetch.signals[0]?.aborted).toBe(false);
+    await expect(second.result).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'no_bid' }],
+    });
+    firstAbort.abort();
+    await expect(first.result).resolves.toEqual({
+      slots: [
+        { slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'superseded' },
+        { slot: 'slot-b', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' },
+      ],
+    });
+    expect(firstFetch.signals[0]?.aborted).toBe(true);
+  });
+
+  it.each([
+    {
+      name: 'network rejection',
+      fetcher: vi.fn(async () => Promise.reject(new Error('offline'))),
+      reason: 'network_error',
+    },
+    {
+      name: 'non-success response',
+      fetcher: vi.fn(async () => ({ ok: false, json: async () => ({}) })),
+      reason: 'http_error',
+    },
+    {
+      name: 'invalid JSON body',
+      fetcher: vi.fn(async () => ({
+        ok: true,
+        json: async () => Promise.reject(new SyntaxError('invalid JSON')),
+      })),
+      reason: 'invalid_response',
+    },
+    {
+      name: 'missing slot decision',
+      fetcher: successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }])),
+      reason: 'invalid_response',
+    },
+    {
+      name: 'extra slot decision',
+      fetcher: successfulFetcher(
+        response([
+          { slot: 'slot-a', outcome: 'no_bid' },
+          { slot: 'slot-b', outcome: 'no_bid' },
+          { slot: 'slot-extra', outcome: 'no_bid' },
+        ])
+      ),
+      reason: 'invalid_response',
+    },
+  ] as const)('preserves $name as $reason for every live child', async ({ fetcher, reason }) => {
+    const service = createService({
+      createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+      fetcher,
+      renderWinner: () => false,
+    });
+
+    await expect(
+      service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        slots: Object.freeze(['slot-a', 'slot-b']),
+        timeoutMs: 10_000,
+      }).result
+    ).resolves.toEqual({
+      slots: [
+        { slot: 'slot-a', path: 'primary', outcome: 'failed', reason },
+        { slot: 'slot-b', path: 'primary', outcome: 'failed', reason },
+      ],
+    });
+  });
+
+  it('passes through an exact server failure without inferring no-bid', async () => {
+    const service = createService({
+      createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+      fetcher: successfulFetcher(
+        response([{ slot: 'slot-a', outcome: 'failed', reason: 'provider_timeout' }])
+      ),
+      renderWinner: () => false,
+    });
+
+    await expect(
+      service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        slots: Object.freeze(['slot-a']),
+        timeoutMs: 10_000,
+      }).result
+    ).resolves.toEqual({
+      slots: [
+        {
+          slot: 'slot-a',
+          path: 'primary',
+          outcome: 'failed',
+          reason: 'provider_timeout',
+        },
+      ],
+    });
+  });
+
+  it('ends the shared deadline after parse while retaining caller cancellation during render', async () => {
+    vi.useFakeTimers();
+    try {
+      let fetchSignal: AbortSignal | undefined;
+      const settled = vi.fn();
+      const service = createService({
+        createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+        fetcher: vi.fn(async (_input, init) => {
+          fetchSignal = init.signal;
+          return {
+            ok: true,
+            json: async () =>
+              response([{ slot: 'slot-a', outcome: 'winner', candidateId: candidateId(0) }]),
+          };
+        }),
+        renderWinner: () => true,
+      });
+      const caller = new AbortController();
+      const batch = service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        signal: caller.signal,
+        slots: Object.freeze(['slot-a']),
+        timeoutMs: 100,
+      });
+      void batch.result.then(settled);
+
+      await vi.advanceTimersByTimeAsync(1_000);
+      expect(settled).not.toHaveBeenCalled();
+      expect(fetchSignal?.aborted).toBe(false);
+
+      caller.abort();
+      await expect(batch.result).resolves.toEqual({
+        slots: [
+          { slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' },
+        ],
+      });
+      expect(fetchSignal?.aborted).toBe(false);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('cancels every child and the shared fetch when navigation disposes', async () => {
+    const pending = abortablePendingFetcher();
+    const owner = navigation();
+    const service = createService({
+      createAttempt: (attemptOwner) => ({
+        ok: true,
+        value: attemptHarness(attemptOwner).attempt,
+      }),
+      fetcher: pending.fetcher,
+      renderWinner: () => false,
+    });
+    const batch = service.create({
+      navigation: owner,
+      requestBody: '{}',
+      slots: Object.freeze(['slot-a', 'slot-b']),
+      timeoutMs: 10_000,
+    });
+
+    owner.dispose();
+
+    await expect(batch.result).resolves.toEqual({
+      slots: [
+        {
+          slot: 'slot-a',
+          path: 'primary',
+          outcome: 'cancelled',
+          reason: 'navigation_disposed',
+        },
+        {
+          slot: 'slot-b',
+          path: 'primary',
+          outcome: 'cancelled',
+          reason: 'navigation_disposed',
+        },
+      ],
+    });
+    expect(pending.signals[0]?.aborted).toBe(true);
+  });
+
+  it('aborts the old shared fetch when its only child is superseded', async () => {
+    const firstFetch = abortablePendingFetcher();
+    const owner = navigation();
+    const fetchers = [
+      firstFetch.fetcher,
+      successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }])),
+    ] as const;
+    let fetchIndex = 0;
+    const service = createService({
+      createAttempt: (attemptOwner) => ({
+        ok: true,
+        value: attemptHarness(attemptOwner).attempt,
+      }),
+      fetcher: (input, init) => fetchers[fetchIndex++]!(input, init),
+      renderWinner: () => false,
+    });
+    const first = service.create({
+      navigation: owner,
+      requestBody: '{}',
+      slots: Object.freeze(['slot-a']),
+      timeoutMs: 10_000,
+    });
+    const second = service.create({
+      navigation: owner,
+      requestBody: '{}',
+      slots: Object.freeze(['slot-a']),
+      timeoutMs: 10_000,
+    });
+
+    await expect(first.result).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'superseded' }],
+    });
+    expect(firstFetch.signals[0]?.aborted).toBe(true);
+    await expect(second.result).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'no_bid' }],
+    });
+  });
+
+  it('fails closed without fetching when deadline setup settles reentrantly', async () => {
+    const fetcher = successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }]));
+    const clear = vi.fn();
+    const service = createService({
+      createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+      fetcher,
+      renderWinner: () => false,
+      scheduler: {
+        clear,
+        set: (callback) => {
+          callback();
+          return Object.freeze({ handle: true });
+        },
+      },
+    });
+
+    await expect(
+      service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        slots: Object.freeze(['slot-a']),
+        timeoutMs: 100,
+      }).result
+    ).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'failed', reason: 'auction_timeout' }],
+    });
+    expect(fetcher).not.toHaveBeenCalled();
+    expect(clear).toHaveBeenCalled();
+  });
+
+  it('settles and skips transport when an attempt refuses settlement observation', async () => {
+    const fetcher = successfulFetcher(response([{ slot: 'slot-a', outcome: 'no_bid' }]));
+    const service = createService({
+      createAttempt: (owner) => {
+        const attempt = attemptHarness(owner).attempt;
+        return {
+          ok: true,
+          value: {
+            ...attempt,
+            fail: vi.fn(() => false),
+            onSettled: vi.fn(() => false),
+          } as RenderAttempt,
+        };
+      },
+      fetcher,
+      renderWinner: () => false,
+    });
+
+    await expect(
+      service.create({
+        navigation: navigation(),
+        requestBody: '{}',
+        slots: Object.freeze(['slot-a']),
+        timeoutMs: 100,
+      }).result
+    ).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'failed', reason: 'internal_error' }],
+    });
+    expect(fetcher).not.toHaveBeenCalled();
+  });
+
+  it('contains an attempt that claims cancellation without notifying its observer', async () => {
+    const pending = abortablePendingFetcher();
+    const service = createService({
+      createAttempt: (owner) => {
+        const attempt = attemptHarness(owner).attempt;
+        return {
+          ok: true,
+          value: {
+            ...attempt,
+            cancel: vi.fn(() => true),
+          } as RenderAttempt,
+        };
+      },
+      fetcher: pending.fetcher,
+      renderWinner: () => false,
+    });
+    const batch = service.create({
+      navigation: navigation(),
+      requestBody: '{}',
+      slots: Object.freeze(['slot-a']),
+      timeoutMs: 10_000,
+    });
+
+    batch.cancel();
+
+    await expect(batch.result).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' }],
+    });
+    expect(pending.signals[0]?.aborted).toBe(true);
+  });
+
+  it('observes a branded caller signal without consulting shadowed instance hooks', async () => {
+    const pending = abortablePendingFetcher();
+    const service = createService({
+      createAttempt: (owner) => ({ ok: true, value: attemptHarness(owner).attempt }),
+      fetcher: pending.fetcher,
+      renderWinner: () => false,
+    });
+    const caller = new AbortController();
+    const publisherHook = vi.fn(() => {
+      throw new Error('publisher signal hook');
+    });
+    Object.defineProperties(caller.signal, {
+      aborted: { configurable: true, get: publisherHook },
+      addEventListener: { configurable: true, get: publisherHook },
+      removeEventListener: { configurable: true, get: publisherHook },
+    });
+
+    const batch = service.create({
+      navigation: navigation(),
+      requestBody: '{}',
+      signal: caller.signal,
+      slots: Object.freeze(['slot-a']),
+      timeoutMs: 10_000,
+    });
+    caller.abort();
+
+    await expect(batch.result).resolves.toEqual({
+      slots: [{ slot: 'slot-a', path: 'primary', outcome: 'cancelled', reason: 'caller_aborted' }],
+    });
+    expect(publisherHook).not.toHaveBeenCalled();
+    expect(pending.signals[0]?.aborted).toBe(true);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/context.test.ts b/crates/trusted-server-js/lib/test/services/context.test.ts
new file mode 100644
index 000000000..c2a4725dd
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/context.test.ts
@@ -0,0 +1,892 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  createAuctionContextRegistry,
+  type ContextContributorOwner,
+} from '../../src/services/context';
+
+const MAX_CONTEXT_JSON_BYTES = 256 * 1024;
+const MAX_CONTEXT_ENCODED_KEY_BYTES = MAX_CONTEXT_JSON_BYTES - 7;
+const MAX_CONTEXT_STRUCTURE_ENTRIES = Math.floor((MAX_CONTEXT_JSON_BYTES - 1) / 2);
+
+function owner(): ContextContributorOwner & { readonly dispose: () => void } {
+  const generation = Object.freeze({});
+  const disposers: (() => void)[] = [];
+  let current = true;
+  return Object.freeze({
+    generation,
+    isCurrent: () => current,
+    onDispose: (_kind: string, callback: () => void) => {
+      if (!current) callback();
+      else disposers.push(callback);
+    },
+    dispose: () => {
+      if (!current) return;
+      current = false;
+      for (let index = disposers.length - 1; index >= 0; index -= 1) {
+        disposers[index]?.();
+      }
+      disposers.length = 0;
+    },
+  });
+}
+
+describe('AuctionContextRegistry', () => {
+  it('snapshots in manifest order with later-key precedence and recursive freezing', () => {
+    const runtimeOwner = owner();
+    const firstOwner = owner();
+    const secondOwner = owner();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['first', 'second']),
+      runtimeOwner,
+    });
+
+    expect(
+      registry.register('second', () => ({ shared: 'second', nested: { value: 2 } }), secondOwner)
+    ).toBe(true);
+    expect(registry.register('first', () => ({ first: true, shared: 'first' }), firstOwner)).toBe(
+      true
+    );
+
+    const snapshot = registry.snapshot();
+
+    expect(snapshot).toEqual({ first: true, shared: 'second', nested: { value: 2 } });
+    expect(Object.keys(snapshot)).toEqual(['first', 'shared', 'nested']);
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(Object.isFrozen(snapshot.nested)).toBe(true);
+  });
+
+  it('isolates a throwing contributor and does not retain any of its partial values', () => {
+    const runtimeOwner = owner();
+    const failure = vi.fn();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['good-first', 'hostile', 'good-last']),
+      runtimeOwner,
+      onContributorFailure: failure,
+    });
+    const partial = { leaked: 'must-not-escape' };
+    Object.defineProperty(partial, 'throwing', {
+      enumerable: true,
+      get() {
+        throw new Error('hostile getter');
+      },
+    });
+    registry.register('good-first', () => ({ retained: 'first' }), owner());
+    registry.register('hostile', () => partial, owner());
+    registry.register('good-last', () => ({ retained: 'last' }), owner());
+
+    const snapshot = registry.snapshot();
+
+    expect(snapshot).toEqual({ retained: 'last' });
+    expect(snapshot).not.toHaveProperty('leaked');
+    expect(failure.mock.calls).toEqual([
+      [{ integrationId: 'hostile', reason: 'contributor_failed' }],
+    ]);
+    expect(Object.isFrozen(failure.mock.calls[0]?.[0])).toBe(true);
+  });
+
+  it('removes an owner-scoped contributor before the next batch snapshot', () => {
+    const runtimeOwner = owner();
+    const contributorOwner = owner();
+    const contributor = vi.fn(() => ({ active: true }));
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+    });
+    expect(registry.register('integration', contributor, contributorOwner)).toBe(true);
+    expect(registry.snapshot()).toEqual({ active: true });
+
+    contributorOwner.dispose();
+
+    expect(registry.snapshot()).toEqual({});
+    expect(contributor).toHaveBeenCalledOnce();
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: [],
+    });
+  });
+
+  it('rejects unknown, duplicate, and stale-owner registrations', () => {
+    const runtimeOwner = owner();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['known']),
+      runtimeOwner,
+    });
+    const active = owner();
+    const stale = owner();
+    stale.dispose();
+
+    expect(registry.register('unknown', () => ({}), active)).toBe(false);
+    expect(registry.register('known', () => ({ first: true }), active)).toBe(true);
+    expect(registry.register('known', () => ({ duplicate: true }), owner())).toBe(false);
+    active.dispose();
+    expect(registry.register('known', () => ({ stale: true }), stale)).toBe(false);
+  });
+
+  it('fails closed when the runtime-owner generation getter throws during construction', () => {
+    const hostileRuntimeOwner = new Proxy(owner(), {
+      get(target, key, receiver) {
+        if (key === 'generation') throw new Error('hostile generation getter');
+        return Reflect.get(target, key, receiver);
+      },
+    });
+    let registry: ReturnType<typeof createAuctionContextRegistry> | undefined;
+
+    expect(() => {
+      registry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(['integration']),
+        runtimeOwner: hostileRuntimeOwner,
+      });
+    }).not.toThrow();
+
+    const snapshot = registry?.snapshot();
+    expect(snapshot).toEqual({});
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(registry?.register('integration', () => ({ leaked: true }), owner())).toBe(false);
+    expect(registry?.snapshotInventoryForTest()).toEqual({
+      disposed: true,
+      registrations: [],
+    });
+  });
+
+  it('fails closed when the runtime-owner generation getter throws during a later snapshot', () => {
+    const runtimeOwner = owner();
+    let throwOnGenerationRead = false;
+    const hostileRuntimeOwner = new Proxy(runtimeOwner, {
+      get(target, key, receiver) {
+        if (key === 'generation' && throwOnGenerationRead) {
+          throw new Error('hostile generation getter');
+        }
+        return Reflect.get(target, key, receiver);
+      },
+    });
+    const contributor = vi.fn(() => ({ leaked: true }));
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: hostileRuntimeOwner,
+    });
+    expect(registry.register('integration', contributor, owner())).toBe(true);
+
+    throwOnGenerationRead = true;
+    let snapshot: Readonly<Record<string, unknown>> | undefined;
+    expect(() => {
+      snapshot = registry.snapshot();
+    }).not.toThrow();
+
+    expect(snapshot).toEqual({});
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(contributor).not.toHaveBeenCalled();
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: true,
+      registrations: [],
+    });
+  });
+
+  it('contains a throwing contributor-owner generation getter without retention', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const hostileOwner = new Proxy(owner(), {
+      get(target, key, receiver) {
+        if (key === 'generation') throw new Error('hostile generation getter');
+        return Reflect.get(target, key, receiver);
+      },
+    });
+
+    expect(() =>
+      registry.register('integration', () => ({ leaked: true }), hostileOwner)
+    ).not.toThrow();
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: [],
+    });
+    expect(registry.snapshot()).toEqual({});
+  });
+
+  it('reads contributor-owner generation once at each registration checkpoint', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const generation = Object.freeze({});
+    const readGeneration = vi.fn(() => generation);
+    const contributorOwner = {
+      get generation() {
+        return readGeneration();
+      },
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+
+    expect(registry.register('integration', () => ({ retained: true }), contributorOwner)).toBe(
+      true
+    );
+    expect(readGeneration).toHaveBeenCalledTimes(2);
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: ['integration'],
+    });
+  });
+
+  it.each([
+    ['finalization', false],
+    ['throw rollback', true],
+  ] as const)(
+    'does not delete a reentrant replacement record during outer %s',
+    (_name, throwAfterReplacement) => {
+      const registry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(['integration']),
+        runtimeOwner: owner(),
+      });
+      const replacementOwner = owner();
+      let replacementRegistered: boolean | undefined;
+      const outerOwner: ContextContributorOwner = {
+        generation: Object.freeze({}),
+        isCurrent: () => true,
+        onDispose: (_kind, cleanup) => {
+          cleanup();
+          replacementRegistered = registry.register(
+            'integration',
+            () => ({ replacement: true }),
+            replacementOwner
+          );
+          if (throwAfterReplacement) throw new Error('outer onDispose failed');
+        },
+      };
+
+      expect(registry.register('integration', () => ({ outer: true }), outerOwner)).toBe(false);
+      expect(replacementRegistered).toBe(true);
+      expect(registry.snapshotInventoryForTest()).toEqual({
+        disposed: false,
+        registrations: ['integration'],
+      });
+      expect(registry.snapshot()).toEqual({ replacement: true });
+    }
+  );
+
+  it('reports a registration as displaced when final owner reflection installs a replacement', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const generation = Object.freeze({});
+    const replacementOwner = owner();
+    let generationReads = 0;
+    let cleanup: (() => void) | undefined;
+    let replacementRegistered: boolean | undefined;
+    const reentrantOwner: ContextContributorOwner = {
+      get generation() {
+        generationReads += 1;
+        if (generationReads === 2) {
+          cleanup?.();
+          replacementRegistered = registry.register(
+            'integration',
+            () => ({ replacement: true }),
+            replacementOwner
+          );
+        }
+        return generation;
+      },
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        cleanup = callback;
+      },
+    };
+
+    expect(registry.register('integration', () => ({ displaced: true }), reentrantOwner)).toBe(
+      false
+    );
+    expect(replacementRegistered).toBe(true);
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: ['integration'],
+    });
+    expect(registry.snapshot()).toEqual({ replacement: true });
+  });
+
+  it('rolls back a registration whose owner generation changes during onDispose', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const firstGeneration = Object.freeze({});
+    const secondGeneration = Object.freeze({});
+    let generation = firstGeneration;
+    let rotateGeneration = true;
+    const readGeneration = vi.fn(() => generation);
+    const changingOwner: ContextContributorOwner = {
+      get generation() {
+        return readGeneration();
+      },
+      isCurrent: () => true,
+      onDispose: () => {
+        if (!rotateGeneration) return;
+        rotateGeneration = false;
+        generation = secondGeneration;
+      },
+    };
+
+    expect(registry.register('integration', () => ({ stale: true }), changingOwner)).toBe(false);
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: [],
+    });
+    expect(registry.register('integration', () => ({ current: true }), changingOwner)).toBe(true);
+    expect(readGeneration).toHaveBeenCalledTimes(4);
+    expect(registry.snapshot()).toEqual({ current: true });
+  });
+
+  it('rejects a reflected contributor-owner generation that is not an object', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const invalidOwner = {
+      generation: null as unknown as object,
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+
+    expect(registry.register('integration', () => ({ leaked: true }), invalidOwner)).toBe(false);
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: [],
+    });
+  });
+
+  it.each(['isCurrent', 'onDispose'] as const)(
+    'contains a throwing contributor-owner %s trap without retention',
+    (method) => {
+      const registry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(['integration']),
+        runtimeOwner: owner(),
+      });
+      const contributorOwner = owner();
+      const hostileOwner = new Proxy(contributorOwner, {
+        get(target, key, receiver) {
+          if (key === method) throw new Error(`hostile ${method} trap`);
+          return Reflect.get(target, key, receiver);
+        },
+      });
+
+      expect(() =>
+        registry.register('integration', () => ({ leaked: true }), hostileOwner)
+      ).not.toThrow();
+      expect(registry.snapshotInventoryForTest()).toEqual({
+        disposed: false,
+        registrations: [],
+      });
+    }
+  );
+
+  it('takes one fresh contributor snapshot per batch call without retaining prior values', () => {
+    const runtimeOwner = owner();
+    const mutable = { value: 1 };
+    const contributor = vi.fn(() => ({ nested: mutable }));
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+    });
+    registry.register('integration', contributor, owner());
+
+    const first = registry.snapshot();
+    mutable.value = 2;
+    const second = registry.snapshot();
+
+    expect(first).toEqual({ nested: { value: 1 } });
+    expect(second).toEqual({ nested: { value: 2 } });
+    expect(first).not.toBe(second);
+    expect(first.nested).not.toBe(second.nested);
+    expect(contributor).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not invoke a record displaced during its owner-currentness reflection', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const generation = Object.freeze({});
+    const replacementOwner = owner();
+    const displacedContributor = vi.fn(() => ({ displaced: true }));
+    const replacementContributor = vi.fn(() => ({ replacement: true }));
+    let generationReads = 0;
+    let cleanup: (() => void) | undefined;
+    let replacementRegistered: boolean | undefined;
+    const reentrantOwner: ContextContributorOwner = {
+      get generation() {
+        generationReads += 1;
+        if (generationReads === 3) {
+          cleanup?.();
+          replacementRegistered = registry.register(
+            'integration',
+            replacementContributor,
+            replacementOwner
+          );
+        }
+        return generation;
+      },
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        cleanup = callback;
+      },
+    };
+    expect(registry.register('integration', displacedContributor, reentrantOwner)).toBe(true);
+
+    expect(registry.snapshot()).toEqual({});
+    expect(replacementRegistered).toBe(true);
+    expect(displacedContributor).not.toHaveBeenCalled();
+    expect(replacementContributor).not.toHaveBeenCalled();
+    expect(registry.snapshot()).toEqual({ replacement: true });
+    expect(replacementContributor).toHaveBeenCalledOnce();
+  });
+
+  it('does not merge a record displaced during contributor execution', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    const generation = Object.freeze({});
+    const replacementOwner = owner();
+    const replacementContributor = vi.fn(() => ({ replacement: true }));
+    let cleanup: (() => void) | undefined;
+    let replacementRegistered: boolean | undefined;
+    const reentrantOwner: ContextContributorOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        cleanup = callback;
+      },
+    };
+    const displacedContributor = vi.fn(() => {
+      cleanup?.();
+      replacementRegistered = registry.register(
+        'integration',
+        replacementContributor,
+        replacementOwner
+      );
+      return { displaced: true };
+    });
+    expect(registry.register('integration', displacedContributor, reentrantOwner)).toBe(true);
+
+    expect(registry.snapshot()).toEqual({});
+    expect(replacementRegistered).toBe(true);
+    expect(displacedContributor).toHaveBeenCalledOnce();
+    expect(replacementContributor).not.toHaveBeenCalled();
+    expect(registry.snapshot()).toEqual({ replacement: true });
+    expect(replacementContributor).toHaveBeenCalledOnce();
+  });
+
+  it('does not merge a record displaced during runtime-currentness reflection', () => {
+    const runtimeGeneration = Object.freeze({});
+    let replaceOnRuntimeReflection = false;
+    let contributorCleanup: (() => void) | undefined;
+    let replacementRegistered: boolean | undefined;
+    const replacementOwner = owner();
+    const replacementContributor = vi.fn(() => ({ replacement: true }));
+    const runtimeOwner: ContextContributorOwner = {
+      get generation() {
+        if (replaceOnRuntimeReflection) {
+          replaceOnRuntimeReflection = false;
+          contributorCleanup?.();
+          replacementRegistered = registry.register(
+            'integration',
+            replacementContributor,
+            replacementOwner
+          );
+        }
+        return runtimeGeneration;
+      },
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+    });
+    const displacedContributor = vi.fn(() => {
+      replaceOnRuntimeReflection = true;
+      return { displaced: true };
+    });
+    expect(
+      registry.register('integration', displacedContributor, {
+        generation: Object.freeze({}),
+        isCurrent: () => true,
+        onDispose: (_kind, callback) => {
+          contributorCleanup = callback;
+        },
+      })
+    ).toBe(true);
+
+    expect(registry.snapshot()).toEqual({});
+    expect(replacementRegistered).toBe(true);
+    expect(displacedContributor).toHaveBeenCalledOnce();
+    expect(replacementContributor).not.toHaveBeenCalled();
+    expect(registry.snapshot()).toEqual({ replacement: true });
+    expect(replacementContributor).toHaveBeenCalledOnce();
+  });
+
+  it('fails closed when final runtime reflection displaces an already accepted record', () => {
+    const runtimeGeneration = Object.freeze({});
+    const contributorGeneration = Object.freeze({});
+    const replacementOwner = owner();
+    const staleContributor = vi.fn(() => ({ stale: true }));
+    const replacementContributor = vi.fn(() => ({ replacement: true }));
+    let contributorGenerationReads = 0;
+    let contributorCleanup: (() => void) | undefined;
+    let reflectReplacement = false;
+    let replacementRegistered: boolean | undefined;
+    const runtimeOwner: ContextContributorOwner = {
+      get generation() {
+        if (reflectReplacement) {
+          reflectReplacement = false;
+          contributorCleanup?.();
+          replacementRegistered = registry.register(
+            'integration',
+            replacementContributor,
+            replacementOwner
+          );
+        }
+        return runtimeGeneration;
+      },
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+    });
+    expect(
+      registry.register('integration', staleContributor, {
+        get generation() {
+          contributorGenerationReads += 1;
+          if (contributorGenerationReads === 4) reflectReplacement = true;
+          return contributorGeneration;
+        },
+        isCurrent: () => true,
+        onDispose: (_kind, callback) => {
+          contributorCleanup = callback;
+        },
+      })
+    ).toBe(true);
+
+    const firstSnapshot = registry.snapshot();
+    expect(firstSnapshot).toEqual({});
+    expect(Object.isFrozen(firstSnapshot)).toBe(true);
+    expect(replacementRegistered).toBe(true);
+    expect(staleContributor).toHaveBeenCalledOnce();
+    expect(replacementContributor).not.toHaveBeenCalled();
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: false,
+      registrations: ['integration'],
+    });
+    expect(registry.snapshot()).toEqual({ replacement: true });
+    expect(replacementContributor).toHaveBeenCalledOnce();
+  });
+
+  it('fails closed when final runtime reflection disposes the registry after acceptance', () => {
+    const runtimeGeneration = Object.freeze({});
+    const contributorGeneration = Object.freeze({});
+    let contributorGenerationReads = 0;
+    let reflectDisposal = false;
+    const runtimeOwner: ContextContributorOwner = {
+      get generation() {
+        if (reflectDisposal) {
+          reflectDisposal = false;
+          registry.dispose();
+        }
+        return runtimeGeneration;
+      },
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+    });
+    expect(
+      registry.register('integration', () => ({ stale: true }), {
+        get generation() {
+          contributorGenerationReads += 1;
+          if (contributorGenerationReads === 4) reflectDisposal = true;
+          return contributorGeneration;
+        },
+        isCurrent: () => true,
+        onDispose: vi.fn(),
+      })
+    ).toBe(true);
+
+    const snapshot = registry.snapshot();
+    expect(snapshot).toEqual({});
+    expect(Object.isFrozen(snapshot)).toBe(true);
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: true,
+      registrations: [],
+    });
+  });
+
+  it('does not classify primitive clone records through Object.prototype pollution', () => {
+    const priorDescriptor = Object.getOwnPropertyDescriptor(Object.prototype, 'source');
+    try {
+      Object.defineProperty(Object.prototype, 'source', {
+        configurable: true,
+        enumerable: false,
+        value: 'polluted',
+        writable: true,
+      });
+      const registry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(['integration']),
+        runtimeOwner: owner(),
+      });
+      registry.register(
+        'integration',
+        () => ({ string: 'value', number: 7, boolean: true, nullable: null }),
+        owner()
+      );
+
+      expect(registry.snapshot()).toEqual({
+        string: 'value',
+        number: 7,
+        boolean: true,
+        nullable: null,
+      });
+    } finally {
+      if (priorDescriptor) Object.defineProperty(Object.prototype, 'source', priorDescriptor);
+      else Reflect.deleteProperty(Object.prototype, 'source');
+    }
+  });
+
+  it('makes stale callbacks and logger failures inert after runtime disposal', () => {
+    const runtimeOwner = owner();
+    const contributor = vi.fn(() => {
+      throw new Error('contributor failed');
+    });
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner,
+      onContributorFailure: () => {
+        throw new Error('logger failed');
+      },
+    });
+    registry.register('integration', contributor, owner());
+
+    expect(() => registry.snapshot()).not.toThrow();
+    runtimeOwner.dispose();
+    expect(registry.snapshot()).toEqual({});
+    expect(contributor).toHaveBeenCalledOnce();
+    expect(registry.snapshotInventoryForTest()).toEqual({
+      disposed: true,
+      registrations: [],
+    });
+  });
+
+  it('discards the whole batch snapshot if a contributor disposes the runtime', () => {
+    const runtimeOwner = owner();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['first', 'disposing']),
+      runtimeOwner,
+    });
+    registry.register('first', () => ({ stale: 'must-not-escape' }), owner());
+    registry.register(
+      'disposing',
+      () => {
+        runtimeOwner.dispose();
+        return { late: 'must-not-escape' };
+      },
+      owner()
+    );
+
+    expect(registry.snapshot()).toEqual({});
+  });
+
+  it.each([
+    ['just below', MAX_CONTEXT_JSON_BYTES - 1, true],
+    ['at', MAX_CONTEXT_JSON_BYTES, true],
+    ['above', MAX_CONTEXT_JSON_BYTES + 1, false],
+  ] as const)(
+    'applies the shared JSON byte budget %s the body ceiling',
+    (_name, bytes, accepted) => {
+      const failure = vi.fn();
+      const registry = createAuctionContextRegistry({
+        manifestIntegrationIds: Object.freeze(['integration']),
+        runtimeOwner: owner(),
+        onContributorFailure: failure,
+      });
+      const payload = 'x'.repeat(bytes - 14);
+      registry.register('integration', () => ({ payload }), owner());
+
+      const snapshot = registry.snapshot();
+
+      if (accepted) {
+        expect(new TextEncoder().encode(JSON.stringify(snapshot)).byteLength).toBe(bytes);
+        expect(snapshot).toEqual({ payload });
+        expect(failure).not.toHaveBeenCalled();
+      } else {
+        expect(snapshot).toEqual({});
+        expect(failure.mock.calls).toEqual([
+          [{ integrationId: 'integration', reason: 'contributor_failed' }],
+        ]);
+      }
+    }
+  );
+
+  it('accounts for multibyte and escaped JSON strings at the exact byte ceiling', () => {
+    const payloadBytes = MAX_CONTEXT_JSON_BYTES - 14;
+    const emojiCount = Math.floor((payloadBytes - 4) / 4);
+    const payload = `${'😀'.repeat(emojiCount)}xx"\n`;
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['integration']),
+      runtimeOwner: owner(),
+    });
+    registry.register('integration', () => ({ payload }), owner());
+
+    const snapshot = registry.snapshot();
+
+    expect(new TextEncoder().encode(JSON.stringify(snapshot)).byteLength).toBe(
+      MAX_CONTEXT_JSON_BYTES
+    );
+    expect(snapshot).toEqual({ payload });
+  });
+
+  it('shares the byte budget across contributors and rejects an overflowing merge atomically', () => {
+    const failure = vi.fn();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['first', 'overflowing']),
+      runtimeOwner: owner(),
+      onContributorFailure: failure,
+    });
+    const payload = 'x'.repeat(MAX_CONTEXT_JSON_BYTES - 14);
+    registry.register('first', () => ({ payload }), owner());
+    registry.register('overflowing', () => ({ late: true }), owner());
+
+    const snapshot = registry.snapshot();
+
+    expect(new TextEncoder().encode(JSON.stringify(snapshot)).byteLength).toBe(
+      MAX_CONTEXT_JSON_BYTES
+    );
+    expect(snapshot).toEqual({ payload });
+    expect(failure.mock.calls).toEqual([
+      [{ integrationId: 'overflowing', reason: 'contributor_failed' }],
+    ]);
+  });
+
+  it('subtracts replaced predecessor bytes before admitting a later contributor', () => {
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['first', 'replacement']),
+      runtimeOwner: owner(),
+    });
+    registry.register(
+      'first',
+      () => ({ shared: 'x'.repeat(MAX_CONTEXT_JSON_BYTES - 13) }),
+      owner()
+    );
+    registry.register('replacement', () => ({ shared: 'small', later: true }), owner());
+
+    expect(registry.snapshot()).toEqual({ shared: 'small', later: true });
+  });
+
+  it('retains no replacement values when one prospective contributor exceeds the budget', () => {
+    const failure = vi.fn();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['first', 'overflowing']),
+      runtimeOwner: owner(),
+      onContributorFailure: failure,
+    });
+    registry.register('first', () => ({ shared: 'original' }), owner());
+    registry.register(
+      'overflowing',
+      () => ({ shared: 'must-not-replace', excess: 'x'.repeat(MAX_CONTEXT_JSON_BYTES) }),
+      owner()
+    );
+
+    expect(registry.snapshot()).toEqual({ shared: 'original' });
+    expect(failure.mock.calls).toEqual([
+      [{ integrationId: 'overflowing', reason: 'contributor_failed' }],
+    ]);
+  });
+
+  it('clones and freezes a deeply nested contribution without a recursion cap', () => {
+    const depth = 12_000;
+    let deep: Record<string, unknown> = { terminal: true };
+    for (let index = 0; index < depth; index += 1) deep = { next: deep };
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['deep']),
+      runtimeOwner: owner(),
+    });
+    registry.register('deep', () => ({ deep }), owner());
+
+    const snapshot = registry.snapshot();
+
+    let cursor = snapshot.deep;
+    for (let index = 0; index < depth; index += 1) {
+      expect(Object.isFrozen(cursor)).toBe(true);
+      cursor = (cursor as { readonly next: unknown }).next;
+    }
+    expect(cursor).toEqual({ terminal: true });
+  });
+
+  it('rejects an oversized encoded key before retaining contributor values', () => {
+    const failure = vi.fn();
+    const hugeKey = 'k'.repeat(MAX_CONTEXT_ENCODED_KEY_BYTES + 1);
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['huge-key']),
+      runtimeOwner: owner(),
+      onContributorFailure: failure,
+    });
+    registry.register('huge-key', () => ({ [hugeKey]: 'must-not-escape' }), owner());
+
+    expect(registry.snapshot()).toEqual({});
+    expect(failure.mock.calls).toEqual([
+      [{ integrationId: 'huge-key', reason: 'contributor_failed' }],
+    ]);
+  });
+
+  it('rejects a huge iterative structure and continues with the next contributor', () => {
+    let huge: unknown[] = [];
+    const depth = Math.ceil(MAX_CONTEXT_STRUCTURE_ENTRIES / 2) + 1;
+    for (let index = 0; index < depth; index += 1) huge = [huge];
+    const failure = vi.fn();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['huge', 'later']),
+      runtimeOwner: owner(),
+      onContributorFailure: failure,
+    });
+    registry.register('huge', () => ({ huge }), owner());
+    registry.register('later', () => ({ retained: true }), owner());
+
+    expect(registry.snapshot()).toEqual({ retained: true });
+    expect(failure.mock.calls).toEqual([[{ integrationId: 'huge', reason: 'contributor_failed' }]]);
+  });
+
+  it('rejects a cyclic graph atomically and continues in manifest order', () => {
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+    const failure = vi.fn();
+    const registry = createAuctionContextRegistry({
+      manifestIntegrationIds: Object.freeze(['cyclic', 'later']),
+      runtimeOwner: owner(),
+      onContributorFailure: failure,
+    });
+    registry.register('cyclic', () => ({ leaked: true, cyclic }), owner());
+    registry.register('later', () => ({ retained: true }), owner());
+
+    expect(registry.snapshot()).toEqual({ retained: true });
+    expect(failure.mock.calls).toEqual([
+      [{ integrationId: 'cyclic', reason: 'contributor_failed' }],
+    ]);
+  });
+
+  it.each([
+    ['just below', 19, true],
+    ['at', 20, true],
+    ['above', 21, false],
+  ] as const)('%s the canonical manifest capacity accepts=%s', (_name, count, accepted) => {
+    const ids = Object.freeze(Array.from({ length: count }, (_, index) => `integration-${index}`));
+    const construct = (): void => {
+      createAuctionContextRegistry({ manifestIntegrationIds: ids, runtimeOwner: owner() });
+    };
+
+    if (accepted) expect(construct).not.toThrow();
+    else expect(construct).toThrow(TypeError);
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/projections.test.ts b/crates/trusted-server-js/lib/test/services/projections.test.ts
new file mode 100644
index 000000000..601e52ffc
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/projections.test.ts
@@ -0,0 +1,323 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { parseBrowserAuctionProjectionV1 } from '../../src/core/contracts/auction_projection';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import { createRuntimeSession, type NavigationSession } from '../../src/kernel/sessions';
+import {
+  createPageBidsController,
+  prepareInitialAuctionProjection,
+  type PreparedProjectionSlots,
+  type ProjectionSlotRegistration,
+  type ProjectionSlotRegistry,
+} from '../../src/services/projections';
+
+function runtimeSession() {
+  let prefix = 0;
+  return createRuntimeSession({
+    createIdentityIssuer: () => {
+      prefix += 1;
+      return createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(prefix);
+          return target;
+        },
+      });
+    },
+  });
+}
+
+function projection(slots: readonly string[], auctionId = 'page-bids') {
+  return {
+    version: 1,
+    auction: {
+      version: 1,
+      auctionId,
+      results: slots.map((slot) => ({ slot, outcome: 'no_bid' as const })),
+    },
+    slots: slots.map((slot) => ({
+      slot,
+      gamUnitPath: `/123/${slot}`,
+      divId: `div-${slot}`,
+      formats: [[300, 250]],
+      targeting: {},
+    })),
+    bids: [],
+  };
+}
+
+class SlotLedger implements ProjectionSlotRegistry {
+  public readonly slots = new Set<string>();
+  public prepareCalls = 0;
+  public commitHook: (() => void) | undefined;
+
+  public constructor(programmaticCount = 0) {
+    for (let index = 0; index < programmaticCount; index += 1) {
+      this.slots.add(`programmatic-${index}`);
+    }
+  }
+
+  public prepareProjectionSlots(
+    ownerGeneration: object,
+    slots: readonly ProjectionSlotRegistration[],
+    maximumActiveSlots: number
+  ): PreparedProjectionSlots | undefined {
+    this.prepareCalls += 1;
+    if (
+      this.slots.size + slots.length > maximumActiveSlots ||
+      slots.some((slot) => this.slots.has(slot.registeredSlotId))
+    ) {
+      return undefined;
+    }
+    let committed = false;
+    return Object.freeze({
+      ownerGeneration,
+      commit: () => {
+        this.commitHook?.();
+        for (const slot of slots) this.slots.add(slot.registeredSlotId);
+        committed = true;
+        return true;
+      },
+      rollback: () => {
+        if (!committed) return;
+        for (const slot of slots) this.slots.delete(slot.registeredSlotId);
+        committed = false;
+      },
+    });
+  }
+}
+
+function controller(navigation: NavigationSession, registry: ProjectionSlotRegistry) {
+  return createPageBidsController({
+    navigation,
+    parseProjection: parseBrowserAuctionProjectionV1,
+    slotRegistry: registry,
+  });
+}
+
+describe('initial auction projection', () => {
+  it('deep-copies and recursively freezes boot input without mutating it', () => {
+    const bootProjection = projection(['server-slot'], 'initial');
+
+    const prepared = prepareInitialAuctionProjection(
+      bootProjection,
+      parseBrowserAuctionProjectionV1
+    );
+
+    expect(prepared).toEqual(bootProjection);
+    expect(prepared).not.toBe(bootProjection);
+    expect(Object.isFrozen(prepared)).toBe(true);
+    expect(Object.isFrozen((prepared as typeof bootProjection).auction)).toBe(true);
+    expect(Object.isFrozen((prepared as typeof bootProjection).auction.results)).toBe(true);
+    expect(Object.isFrozen(bootProjection)).toBe(false);
+    bootProjection.auction.auctionId = 'publisher-mutated';
+    expect((prepared as typeof bootProjection).auction.auctionId).toBe('initial');
+  });
+});
+
+describe('SPA page-bids projection controller', () => {
+  it('prepares exact placement aliases in the same transaction as projected slot ids', () => {
+    const runtime = runtimeSession();
+    const initial = runtime.startInitialNavigation(
+      prepareInitialAuctionProjection(projection([], 'initial'), parseBrowserAuctionProjectionV1)
+    );
+    if (!initial.ok) throw new Error(initial.reason);
+    const replacement = runtime.replaceNavigation();
+    if (!replacement.ok) throw new Error(replacement.reason);
+    const prepareProjectionSlots = vi.fn(() => ({
+      ownerGeneration: replacement.value.generation,
+      commit: () => true,
+      rollback: vi.fn(),
+    }));
+
+    expect(
+      controller(replacement.value, { prepareProjectionSlots }).commit(projection(['server-slot']))
+    ).toEqual({ status: 'committed' });
+    expect(prepareProjectionSlots).toHaveBeenCalledExactlyOnceWith(
+      replacement.value.generation,
+      [
+        {
+          registeredSlotId: 'server-slot',
+          domAliases: ['div-server-slot'],
+        },
+      ],
+      256
+    );
+    runtime.dispose();
+  });
+
+  it('atomically reserves slots and commits one immutable current-generation projection', () => {
+    const runtime = runtimeSession();
+    const navigation = runtime.startInitialNavigation(
+      prepareInitialAuctionProjection(projection([], 'initial'), parseBrowserAuctionProjectionV1)
+    );
+    if (!navigation.ok) throw new Error('Expected initial navigation');
+    const spa = runtime.replaceNavigation();
+    if (!spa.ok) throw new Error('Expected SPA navigation');
+    const registry = new SlotLedger(254);
+    const input = projection(['server-one', 'server-two']);
+
+    expect(controller(spa.value, registry).commit(input)).toEqual({ status: 'committed' });
+    expect([...registry.slots].slice(-2)).toEqual(['server-one', 'server-two']);
+    expect(spa.value.currentAuctionProjection).toEqual(input);
+    expect(spa.value.currentAuctionProjection).not.toBe(input);
+    expect(Object.isFrozen(spa.value.currentAuctionProjection)).toBe(true);
+    expect(
+      Object.isFrozen((spa.value.currentAuctionProjection as typeof input).auction.results[0])
+    ).toBe(true);
+    input.auction.auctionId = 'publisher-mutated';
+    expect((spa.value.currentAuctionProjection as typeof input).auction.auctionId).toBe(
+      'page-bids'
+    );
+  });
+
+  it('rejects a duplicate response without preparing or changing committed state', () => {
+    const runtime = runtimeSession();
+    const spa = runtime.startInitialNavigation();
+    if (!spa.ok) throw new Error('Expected navigation');
+    const registry = new SlotLedger();
+    const pageBids = controller(spa.value, registry);
+
+    expect(pageBids.commit(projection(['first']))).toEqual({ status: 'committed' });
+    expect(pageBids.commit(projection(['second']))).toEqual({
+      status: 'rejected',
+      reason: 'duplicate',
+    });
+    expect(registry.prepareCalls).toBe(1);
+    expect([...registry.slots]).toEqual(['first']);
+    expect(
+      (spa.value.currentAuctionProjection as ReturnType<typeof projection>).auction.results
+    ).toEqual([{ slot: 'first', outcome: 'no_bid' }]);
+  });
+
+  it('makes a late old-generation response inert after navigation replacement', () => {
+    const runtime = runtimeSession();
+    const initial = runtime.startInitialNavigation();
+    if (!initial.ok) throw new Error('Expected navigation');
+    const registry = new SlotLedger();
+    const pageBids = controller(initial.value, registry);
+    const replacement = runtime.replaceNavigation();
+    if (!replacement.ok) throw new Error('Expected replacement');
+
+    expect(pageBids.commit(projection(['stale']))).toEqual({
+      status: 'rejected',
+      reason: 'stale',
+    });
+    expect(registry.prepareCalls).toBe(0);
+    expect(registry.slots.size).toBe(0);
+    expect(replacement.value.currentAuctionProjection).toBeUndefined();
+  });
+
+  it('rejects malformed input without retaining or reserving it', () => {
+    const runtime = runtimeSession();
+    const navigation = runtime.startInitialNavigation();
+    if (!navigation.ok) throw new Error('Expected navigation');
+    const registry = new SlotLedger();
+    const malformed = { ...projection(['slot']), extra: true };
+
+    expect(controller(navigation.value, registry).commit(malformed)).toEqual({
+      status: 'rejected',
+      reason: 'malformed',
+    });
+    expect(registry.prepareCalls).toBe(0);
+    expect(registry.slots.size).toBe(0);
+    expect(navigation.value.currentAuctionProjection).toBeUndefined();
+  });
+
+  it.each([
+    [255, 1, 'committed'],
+    [255, 2, 'capacity'],
+    [256, 1, 'capacity'],
+  ] as const)(
+    'enforces the shared 256 cap with %i programmatic plus %i projected slots',
+    (programmatic, projected, expected) => {
+      const runtime = runtimeSession();
+      const navigation = runtime.startInitialNavigation();
+      if (!navigation.ok) throw new Error('Expected navigation');
+      const registry = new SlotLedger(programmatic);
+      const slots = Array.from({ length: projected }, (_, index) => `server-${index}`);
+
+      const result = controller(navigation.value, registry).commit(projection(slots));
+
+      expect(result).toEqual(
+        expected === 'committed'
+          ? { status: 'committed' }
+          : { status: 'rejected', reason: 'capacity' }
+      );
+      expect(registry.slots.size).toBe(expected === 'committed' ? 256 : programmatic);
+      expect(navigation.value.currentAuctionProjection === undefined).toBe(
+        expected !== 'committed'
+      );
+    }
+  );
+
+  it('rolls back prepared slots if ownership changes during the synchronous commit', () => {
+    const runtime = runtimeSession();
+    const navigation = runtime.startInitialNavigation();
+    if (!navigation.ok) throw new Error('Expected navigation');
+    const registry = new SlotLedger();
+    registry.commitHook = () => {
+      runtime.replaceNavigation();
+    };
+
+    expect(controller(navigation.value, registry).commit(projection(['raced']))).toEqual({
+      status: 'rejected',
+      reason: 'stale',
+    });
+    expect(registry.slots.size).toBe(0);
+    expect(runtime.currentNavigation?.currentAuctionProjection).toBeUndefined();
+  });
+
+  it('does not retain prior-navigation projection after a malformed SPA response', () => {
+    const runtime = runtimeSession();
+    const initialProjection = prepareInitialAuctionProjection(
+      projection(['old-slot'], 'initial'),
+      parseBrowserAuctionProjectionV1
+    );
+    const initial = runtime.startInitialNavigation(initialProjection);
+    if (!initial.ok) throw new Error('Expected initial navigation');
+    const spa = runtime.replaceNavigation();
+    if (!spa.ok) throw new Error('Expected SPA navigation');
+
+    expect(controller(spa.value, new SlotLedger()).commit({ invalid: true })).toEqual({
+      status: 'rejected',
+      reason: 'malformed',
+    });
+    expect(initial.value.currentAuctionProjection).toBeUndefined();
+    expect(spa.value.currentAuctionProjection).toBeUndefined();
+  });
+
+  it('isolates a throwing parser and a throwing reservation commit', () => {
+    const runtime = runtimeSession();
+    const first = runtime.startInitialNavigation();
+    if (!first.ok) throw new Error('Expected navigation');
+    const parser = vi.fn(() => {
+      throw new Error('hostile parser');
+    });
+    expect(
+      createPageBidsController({
+        navigation: first.value,
+        parseProjection: parser,
+        slotRegistry: new SlotLedger(),
+      }).commit(projection(['slot']))
+    ).toEqual({ status: 'rejected', reason: 'malformed' });
+
+    const second = runtime.replaceNavigation();
+    if (!second.ok) throw new Error('Expected replacement');
+    const rollback = vi.fn();
+    const throwingRegistry: ProjectionSlotRegistry = {
+      prepareProjectionSlots: () => ({
+        ownerGeneration: second.value.generation,
+        commit: () => {
+          throw new Error('commit failed');
+        },
+        rollback,
+      }),
+    };
+    expect(controller(second.value, throwingRegistry).commit(projection(['slot']))).toEqual({
+      status: 'rejected',
+      reason: 'capacity',
+    });
+    expect(rollback).toHaveBeenCalledOnce();
+    expect(second.value.currentAuctionProjection).toBeUndefined();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/puc_bridge.test.ts b/crates/trusted-server-js/lib/test/services/puc_bridge.test.ts
new file mode 100644
index 000000000..03669b80b
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/puc_bridge.test.ts
@@ -0,0 +1,3186 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import apsEnvelope from '../fixtures/aps-renderer-v1.json';
+import { createBrowserMessagingAdapter } from '../../src/adapters/messaging';
+import { renderPucApsAttempt } from '../../src/integrations/aps/render';
+import {
+  createPucBridge,
+  PUC_DYNAMIC_OWNER,
+  type PucBridgeOptions,
+} from '../../src/services/puc_bridge';
+import {
+  bindCommittedArtifactGuard,
+  createArtifactHostPositionLeaseRegistry,
+  type RenderFailureReason,
+  type RenderOutcome,
+} from '../../src/services/render';
+import type {
+  ReservationClaimResult,
+  ReservationRecognition,
+  ReservationRenderSource,
+} from '../../src/services/reservations';
+
+const RESERVATION_ID = 'r1_abcdefghijklmnopqrstuv';
+const LIFECYCLE_TICKET = 't1_abcdefghijklmnopqrstuv';
+
+function createPort() {
+  return {
+    addEventListener: vi.fn(),
+    close: vi.fn(),
+    postMessage: vi.fn(),
+    removeEventListener: vi.fn(),
+    start: vi.fn(),
+  };
+}
+
+function exactRequest(adId = RESERVATION_ID): string {
+  return JSON.stringify({
+    message: 'Prebid Request',
+    adId,
+    adServerDomain: 'ads.example.com',
+  });
+}
+
+function exactOwnerRegistration(adId: string, lifecycleTicket = LIFECYCLE_TICKET): string {
+  return JSON.stringify({
+    message: 'TS Render Owner Register',
+    adId,
+    version: 1,
+    lifecycleTicket,
+  });
+}
+
+interface HarnessOptions {
+  readonly claim?: PucBridgeOptions['reservations']['claim'];
+  readonly messageChannel?: new () => { readonly port1: unknown; readonly port2: unknown };
+  readonly mintLifecycleTicket?: PucBridgeOptions['mintLifecycleTicket'];
+  readonly now?: PucBridgeOptions['now'];
+  readonly publisherOrigin?: string;
+  readonly resizeCollapsedShell?: PucBridgeOptions['resizeCollapsedShell'];
+  readonly mountAps?: PucBridgeOptions['mountAps'];
+  readonly scheduler?: PucBridgeOptions['scheduler'];
+  readonly slots?: PucBridgeOptions['slots'];
+}
+
+function createHarness(
+  recognize: (reservationId: unknown) => ReservationRecognition,
+  options: HarnessOptions = {}
+) {
+  const listeners: Array<(event: MessageEvent) => void> = [];
+  const target = {
+    addEventListener: vi.fn(
+      (_type: 'message', next: (event: MessageEvent) => void, _capture: true) => {
+        listeners.push(next);
+      }
+    ),
+    removeEventListener: vi.fn(
+      (_type: 'message', removed: (event: MessageEvent) => void, _capture: true) => {
+        const index = listeners.indexOf(removed);
+        if (index >= 0) listeners.splice(index, 1);
+      }
+    ),
+    ...(options.messageChannel ? { MessageChannel: options.messageChannel } : {}),
+  };
+  const bridgeOptions: PucBridgeOptions = {
+    messaging: createBrowserMessagingAdapter(target, {
+      ...(options.publisherOrigin ? { expectedPublisherOrigin: options.publisherOrigin } : {}),
+      validateApsRenderer: () => true,
+    }),
+    mintLifecycleTicket:
+      options.mintLifecycleTicket ??
+      (() => Object.freeze({ ok: true as const, value: LIFECYCLE_TICKET })),
+    reservations: {
+      claim: options.claim ?? (() => ({ recognized: false }) satisfies ReservationClaimResult),
+      recognize,
+    },
+    ...(options.now ? { now: options.now } : {}),
+    ...(options.resizeCollapsedShell ? { resizeCollapsedShell: options.resizeCollapsedShell } : {}),
+    ...(options.mountAps ? { mountAps: options.mountAps } : {}),
+    ...(options.scheduler ? { scheduler: options.scheduler } : {}),
+    ...(options.slots ? { slots: options.slots } : {}),
+  };
+  const bridge = createPucBridge(bridgeOptions);
+  const dispatch = (event: Record<string, unknown>): void => {
+    if (listeners.length === 0) {
+      throw new Error('Expected the capture listener to be installed synchronously');
+    }
+    for (const listener of [...listeners]) listener(event as unknown as MessageEvent);
+  };
+  return { bridge, dispatch, listeners, target };
+}
+
+function createGamAttempt(kind: 'aps' | 'adm' = 'aps', index = 0) {
+  const suffix = index.toString(36).padStart(22, '0').slice(-22);
+  const id = `a1_${suffix}`;
+  const reservationId = `r1_${suffix}`;
+  const navigationGeneration = Object.freeze({ navigation: index });
+  const generation = Object.freeze({ attempt: index });
+  const winnerContext = Object.freeze({ selectedCpm: 1.25 });
+  let state = 'created';
+  let outcome: RenderOutcome | undefined;
+  let renderSource: ReservationRenderSource | undefined;
+  const settlementObservers: Array<(outcome: RenderOutcome) => void> = [];
+  const apsBid = apsEnvelope.seatbid[0]!.bid[0]!;
+  const owner = Object.freeze({
+    id,
+    slot: `slot-${index}`,
+    navigationGeneration,
+    generation,
+    winnerContext,
+    isCurrent: vi.fn(() => outcome === undefined),
+    prepareWinnerContext: vi.fn(),
+  });
+  const artifact = Object.freeze({
+    kind: 'puc' as const,
+    attemptId: id,
+    slot: owner.slot,
+    navigationGeneration,
+    dispose: vi.fn(),
+  });
+  const attempt = Object.freeze({
+    id,
+    slot: owner.slot,
+    generation,
+    navigationGeneration,
+    get renderSource() {
+      return renderSource;
+    },
+    beginGamClaim: vi.fn(() => {
+      if (state !== 'created' || outcome !== undefined) return false;
+      state = 'waiting_for_gam_and_claim';
+      return true;
+    }),
+    admitClaimedWinner: vi.fn(() => {
+      if (state !== 'waiting_for_gam_and_claim' || outcome !== undefined) return false;
+      renderSource = Object.freeze(
+        kind === 'aps'
+          ? {
+              type: 'aps',
+              version: 1,
+              accountId: 'publisher-account',
+              bidId: apsBid.id,
+              tagType: apsBid.ext.tagtype,
+              creativeUrl: apsBid.ext.creativeurl,
+              width: apsBid.w,
+              height: apsBid.h,
+              aaxResponse: btoa(JSON.stringify(apsEnvelope)),
+            }
+          : {
+              type: 'adm',
+              version: 1,
+              adm: '<main>fictional creative</main>',
+              width: 300,
+              height: 250,
+            }
+      ) as ReservationRenderSource;
+      return true;
+    }),
+    ownerClaimed: vi.fn(() => {
+      if (!renderSource || state !== 'waiting_for_gam_and_claim' || outcome !== undefined) {
+        return false;
+      }
+      state = 'waiting_for_owner';
+      return true;
+    }),
+    ownerRegistered: vi.fn(() => {
+      if (state !== 'waiting_for_owner' || outcome !== undefined) return false;
+      state = 'waiting_for_insertion';
+      return true;
+    }),
+    beginApsDocument: vi.fn(() => {
+      if (state !== 'waiting_for_insertion' || outcome !== undefined) return false;
+      state = 'waiting_for_document';
+      return true;
+    }),
+    beginAdm: vi.fn(() => {
+      if (state !== 'waiting_for_insertion' || outcome !== undefined) return false;
+      state = 'waiting_for_adm';
+      return true;
+    }),
+    apsDocumentAccepted: vi.fn(() => {
+      if (state !== 'waiting_for_document' || outcome !== undefined) return false;
+      state = 'waiting_for_aps_completion';
+      return true;
+    }),
+    accept: vi.fn(() => {
+      if (
+        (state !== 'waiting_for_aps_completion' && state !== 'waiting_for_adm') ||
+        outcome !== undefined
+      ) {
+        return false;
+      }
+      outcome = Object.freeze({ outcome: 'accepted' });
+      state = 'accepted';
+      for (const observer of settlementObservers) observer(outcome);
+      return true;
+    }),
+    cancel: vi.fn((reason: 'caller_aborted' | 'superseded' | 'navigation_disposed') => {
+      if (outcome !== undefined) return false;
+      outcome = Object.freeze({ outcome: 'cancelled' as const, reason });
+      state = 'cancelled';
+      for (const observer of settlementObservers) observer(outcome);
+      return true;
+    }),
+    fail: vi.fn((reason: RenderFailureReason) => {
+      if (outcome !== undefined) return false;
+      outcome = Object.freeze({ outcome: 'failed', reason });
+      state = 'failed';
+      for (const observer of settlementObservers) observer(outcome);
+      return true;
+    }),
+    onSettled: vi.fn((callback: (terminal: RenderOutcome) => void) => {
+      if (outcome !== undefined) return false;
+      settlementObservers.push(callback);
+      return true;
+    }),
+    snapshot: vi.fn(() => Object.freeze({ state, outcome, history: Object.freeze([state]) })),
+  });
+  return { artifact, attempt, owner, reservationId };
+}
+
+function dispatchPortMessage(
+  port: ReturnType<typeof createPort>,
+  data: unknown,
+  ports: readonly unknown[] = []
+): void {
+  const listener = port.addEventListener.mock.calls.find((call) => call[0] === 'message')?.[1] as
+    ((event: { data: unknown; ports: readonly unknown[] }) => void) | undefined;
+  if (!listener) throw new Error('Expected the retained port listener to be installed');
+  listener({ data, ports });
+}
+
+function createClock() {
+  let now = 0;
+  let nextHandle = 0;
+  const tasks = new Map<number, { callback: () => void; deadline: number }>();
+  const scheduler = {
+    set: vi.fn((callback: () => void, milliseconds: number): number => {
+      nextHandle += 1;
+      tasks.set(nextHandle, { callback, deadline: now + milliseconds });
+      return nextHandle;
+    }),
+    clear: vi.fn((handle: unknown): void => {
+      if (typeof handle === 'number') tasks.delete(handle);
+    }),
+  };
+  const advance = (milliseconds: number): void => {
+    now += milliseconds;
+    for (const [handle, task] of [...tasks]) {
+      if (task.deadline <= now) {
+        tasks.delete(handle);
+        task.callback();
+      }
+    }
+  };
+  return { advance, now: () => now, scheduler };
+}
+
+function issueReadyTicket(
+  harness: ReturnType<typeof createHarness>,
+  gam: ReturnType<typeof createGamAttempt>,
+  source: object
+): void {
+  expect(
+    harness.bridge.registerGamAttempt({
+      artifact: gam.artifact,
+      attempt: gam.attempt,
+      owner: gam.owner,
+      reservationId: gam.reservationId,
+    })
+  ).toBe(true);
+  harness.dispatch({
+    data: exactRequest(gam.reservationId),
+    ports: [createPort()],
+    source,
+    stopImmediatePropagation: vi.fn(),
+  });
+  expect(
+    harness.bridge.recordNonemptyGam({
+      artifact: gam.artifact,
+      attempt: gam.attempt,
+      owner: gam.owner,
+      reservationId: gam.reservationId,
+    })
+  ).toBe(true);
+  expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+}
+
+describe('Universal Creative bridge dispatcher', () => {
+  it('adopts first-display lifecycle-ticket tombstones and expires them in the local epoch', () => {
+    let now = 100;
+    const tasks: Array<() => void> = [];
+    const harness = createHarness(() => ({ recognized: false }), {
+      now: () => now,
+      scheduler: {
+        set: (callback) => {
+          tasks.push(callback);
+          return callback;
+        },
+        clear: (handle) => {
+          const index = tasks.indexOf(handle as () => void);
+          if (index >= 0) tasks.splice(index, 1);
+        },
+      },
+    });
+
+    expect(
+      harness.bridge.adoptFirstDisplayTickets({
+        clockEpochMs: 40,
+        nextTicketOrdinal: 4,
+        tombstones: [{ expiresAtMs: 140, ticket: LIFECYCLE_TICKET }],
+      })
+    ).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(1);
+    const responsePort = createPort();
+    const stopImmediatePropagation = vi.fn();
+    harness.dispatch({
+      data: exactOwnerRegistration(RESERVATION_ID),
+      ports: [responsePort],
+      source: Object.freeze({}),
+      stopImmediatePropagation,
+    });
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(responsePort.postMessage).toHaveBeenCalledOnce();
+    expect(responsePort.close).toHaveBeenCalledOnce();
+
+    now = 200;
+    tasks.shift()?.();
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(0);
+    expect(
+      harness.bridge.adoptFirstDisplayTickets({
+        clockEpochMs: 200,
+        nextTicketOrdinal: 5,
+        tombstones: [],
+      })
+    ).toBe(false);
+  });
+
+  it('keeps APS out of the PUC realm while preserving ADM iframe ordering', () => {
+    const admStart = PUC_DYNAMIC_OWNER.indexOf('const insertAdm');
+    const controlStart = PUC_DYNAMIC_OWNER.indexOf('const receiveControl');
+    const admOwner = PUC_DYNAMIC_OWNER.slice(admStart, controlStart);
+
+    expect(new TextEncoder().encode(PUC_DYNAMIC_OWNER).byteLength).toBeLessThanOrEqual(64 * 1_024);
+    expect(admStart).toBeGreaterThanOrEqual(0);
+    expect(controlStart).toBeGreaterThan(admStart);
+    expect(admOwner.indexOf('next.onload =')).toBeLessThan(
+      admOwner.indexOf('next.srcdoc = intendedSource;')
+    );
+    expect(admOwner.indexOf('next.onerror =')).toBeLessThan(
+      admOwner.indexOf('next.srcdoc = intendedSource;')
+    );
+    expect(PUC_DYNAMIC_OWNER).not.toContain('const insertAps');
+    expect(PUC_DYNAMIC_OWNER).not.toContain('TS APS Start');
+    expect(PUC_DYNAMIC_OWNER).not.toContain('rendererUrl');
+    expect(PUC_DYNAMIC_OWNER).not.toContain('aaxResponse');
+    expect(PUC_DYNAMIC_OWNER).toContain('TS APS Top Mount Started');
+    expect(PUC_DYNAMIC_OWNER).not.toMatch(
+      /\b(?:fetch|XMLHttpRequest|WebSocket|EventSource|Worker|SharedWorker|Blob)\b/
+    );
+    expect(PUC_DYNAMIC_OWNER).not.toContain('import(');
+    expect(PUC_DYNAMIC_OWNER).not.toContain('createObjectURL');
+    expect(PUC_DYNAMIC_OWNER).not.toMatch(/createElement\(["'](?:script|link)["']\)/);
+  });
+
+  it('binds ADM load and final acceptance to the exact inserted navigation', () => {
+    const admStart = PUC_DYNAMIC_OWNER.indexOf('const insertAdm');
+    const controlStart = PUC_DYNAMIC_OWNER.indexOf('const receiveControl');
+    const admOwner = PUC_DYNAMIC_OWNER.slice(admStart, controlStart);
+
+    expect(admOwner).toContain('next.parentNode === creativeWindow.document.body');
+    expect(admOwner).toContain('next.srcdoc === intendedSource');
+    expect(admOwner).toContain('next.getAttribute("src") === null');
+    expect(PUC_DYNAMIC_OWNER).toContain('ownerFrameCurrent?.() === true');
+  });
+
+  it.each([
+    'duplicate registration key',
+    'accessor-backed registration port',
+    'accessor-backed registration ports collection',
+    'usable registration port before an accessor',
+  ])('rejects a %s without binding its owner channel', async (caseName) => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(_listener: ((event: unknown) => void) | null) {},
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    let portAccessorCalls = 0;
+    let rendered: Promise<void> | undefined;
+    let observedRejection: Promise<unknown> | undefined;
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      observedRejection = rendered.then(
+        () => undefined,
+        (error: unknown) => error
+      );
+      const ports: unknown[] = [controlPort];
+      if (caseName === 'accessor-backed registration port') {
+        Object.defineProperty(ports, '0', {
+          configurable: true,
+          enumerable: true,
+          get: () => {
+            portAccessorCalls += 1;
+            return controlPort;
+          },
+        });
+      }
+      if (caseName === 'usable registration port before an accessor') {
+        ports[1] = undefined;
+        Object.defineProperty(ports, '1', {
+          configurable: true,
+          enumerable: true,
+          get: () => {
+            portAccessorCalls += 1;
+            return createPort();
+          },
+        });
+      }
+      const registrationEvent: Record<string, unknown> = {
+        data:
+          caseName === 'duplicate registration key'
+            ? `{"message":"TS Render Owner Registered","adId":"${RESERVATION_ID}","version":1,"lifecycleTicket":"${LIFECYCLE_TICKET}","lifecycleTicket":"${LIFECYCLE_TICKET}"}`
+            : JSON.stringify({
+                message: 'TS Render Owner Registered',
+                adId: RESERVATION_ID,
+                version: 1,
+                lifecycleTicket: LIFECYCLE_TICKET,
+              }),
+        ports,
+      };
+      if (caseName === 'accessor-backed registration ports collection') {
+        Object.defineProperty(registrationEvent, 'ports', {
+          configurable: true,
+          enumerable: true,
+          get: () => {
+            portAccessorCalls += 1;
+            return ports;
+          },
+        });
+      }
+      registrationCallback?.(registrationEvent);
+
+      expect(controlPort.start).not.toHaveBeenCalled();
+      expect(portAccessorCalls).toBe(0);
+      if (
+        caseName === 'duplicate registration key' ||
+        caseName === 'usable registration port before an accessor'
+      ) {
+        expect(controlPort.close).toHaveBeenCalledOnce();
+      }
+      await expect(observedRejection).resolves.toEqual(
+        expect.objectContaining({ message: 'TS render owner registration refused' })
+      );
+    } finally {
+      await vi.runAllTimersAsync();
+      await observedRejection;
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('closes usable control-message ports without reading a later accessor', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    const usable = createPort();
+    let accessorCalls = 0;
+    let observedRejection: Promise<unknown> | undefined;
+
+    try {
+      const rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      observedRejection = rendered.then(
+        () => undefined,
+        (error: unknown) => error
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      const ports: unknown[] = [usable, undefined];
+      Object.defineProperty(ports, '1', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          accessorCalls += 1;
+          return createPort();
+        },
+      });
+
+      controlListener?.({
+        data: {
+          message: 'TS ADM Start',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          source: {
+            type: 'adm',
+            version: 1,
+            adm: '<main>must not render</main>',
+            width: 300,
+            height: 250,
+          },
+        },
+        ports,
+      });
+
+      expect(accessorCalls).toBe(0);
+      expect(usable.close).toHaveBeenCalledOnce();
+      expect(controlPort.close).toHaveBeenCalledOnce();
+      expect(document.body.querySelector('iframe')).toBeNull();
+      await expect(observedRejection).resolves.toEqual(
+        expect.objectContaining({ message: 'TS render owner control refused' })
+      );
+    } finally {
+      await vi.runAllTimersAsync();
+      await observedRejection;
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('runs the checked-in PUC owner through helper registration and final ADM settlement', async () => {
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    const stopListening = vi.fn();
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        type: string,
+        payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return stopListening;
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+
+    try {
+      const ownerData = window.JSON.parse(
+        JSON.stringify({
+          adId: RESERVATION_ID,
+          message: 'Prebid Response',
+          renderer: PUC_DYNAMIC_OWNER,
+          rendererVersion: '4',
+          tsOwner: {
+            version: 1,
+            status: 'ready',
+            kind: 'adm',
+            lifecycleTicket: LIFECYCLE_TICKET,
+          },
+        })
+      ) as Readonly<Record<string, unknown>>;
+      const rendered = dynamicWindow.render!(ownerData, { sendMessage }, window);
+      expect(sendMessage).toHaveBeenCalledWith(
+        'TS Render Owner Register',
+        { version: 1, lifecycleTicket: LIFECYCLE_TICKET },
+        expect.any(Function)
+      );
+      registrationCallback?.(
+        new MessageEvent('message', {
+          data: JSON.stringify({
+            message: 'TS Render Owner Registered',
+            adId: RESERVATION_ID,
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+          }),
+          ports: [controlPort as unknown as MessagePort],
+        })
+      );
+      expect(stopListening).toHaveBeenCalledOnce();
+      expect(controlPort.start).toHaveBeenCalledOnce();
+
+      controlListener?.(
+        new MessageEvent('message', {
+          data: {
+            message: 'TS ADM Start',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+            source: {
+              type: 'adm',
+              version: 1,
+              adm: '<main>remote creative</main>',
+              width: 300,
+              height: 250,
+            },
+          },
+          ports: [],
+        })
+      );
+      const frame = document.body.querySelector<HTMLIFrameElement>('iframe');
+      expect(frame).not.toBeNull();
+      expect(frame?.srcdoc).toContain('<main>remote creative</main>');
+      expect(frame?.getAttribute('sandbox')).toBe(
+        'allow-forms allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation'
+      );
+      expect(controlPort.postMessage).toHaveBeenCalledWith({
+        message: 'TS Owner Inserted',
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+      });
+
+      frame?.dispatchEvent(new Event('load'));
+      expect(controlPort.postMessage).toHaveBeenCalledWith({
+        message: 'TS ADM Loaded',
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+      });
+      controlListener?.(
+        new MessageEvent('message', {
+          data: {
+            message: 'TS Owner Settled',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+            outcome: 'accepted',
+          },
+          ports: [],
+        })
+      );
+
+      await expect(rendered).resolves.toBeUndefined();
+      expect(frame?.isConnected).toBe(true);
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('contains synchronous helper registration and control-port settlement reentrancy', async () => {
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    const stopListening = vi.fn();
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+      start: vi.fn(() => {
+        controlListener?.({
+          data: {
+            message: 'TS APS Top Mount Started',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+          },
+          ports: [],
+        });
+        controlListener?.({
+          data: {
+            message: 'TS Owner Settled',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+            outcome: 'accepted',
+          },
+          ports: [],
+        });
+      }),
+    };
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        callback({
+          data: JSON.stringify({
+            message: 'TS Render Owner Registered',
+            adId: RESERVATION_ID,
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+          }),
+          ports: [controlPort],
+        });
+        return stopListening;
+      }
+    );
+
+    try {
+      const rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'aps',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+
+      await expect(rendered).resolves.toBeUndefined();
+      expect(controlPort.start).toHaveBeenCalledOnce();
+      expect(controlPort.close).toHaveBeenCalledOnce();
+      expect(stopListening).toHaveBeenCalledOnce();
+    } finally {
+      delete dynamicWindow.render;
+    }
+  });
+
+  it('rejects accepted ADM settlement after the owner iframe navigation changes', async () => {
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+
+    try {
+      const rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      registrationCallback?.(
+        new MessageEvent('message', {
+          data: JSON.stringify({
+            message: 'TS Render Owner Registered',
+            adId: RESERVATION_ID,
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+          }),
+          ports: [controlPort as unknown as MessagePort],
+        })
+      );
+      controlListener?.(
+        new MessageEvent('message', {
+          data: {
+            message: 'TS ADM Start',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+            source: {
+              type: 'adm',
+              version: 1,
+              adm: '<main>intended creative</main>',
+              width: 300,
+              height: 250,
+            },
+          },
+          ports: [],
+        })
+      );
+      const frame = document.body.querySelector<HTMLIFrameElement>('iframe');
+      expect(frame).not.toBeNull();
+      if (!frame) throw new Error('Expected owner iframe');
+      frame.srcdoc = '<main>replaced creative</main>';
+      frame.dispatchEvent(new Event('load'));
+      expect(controlPort.postMessage).not.toHaveBeenCalledWith(
+        expect.objectContaining({ message: 'TS ADM Loaded' })
+      );
+
+      controlListener?.(
+        new MessageEvent('message', {
+          data: {
+            message: 'TS Owner Settled',
+            version: 1,
+            lifecycleTicket: LIFECYCLE_TICKET,
+            outcome: 'accepted',
+          },
+          ports: [],
+        })
+      );
+
+      await expect(rendered).rejects.toThrow('TS render owner control refused');
+      expect(frame.isConnected).toBe(false);
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('settles and closes the owner channel when every terminal DOM cleanup hook throws', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    const hostileOwnerWindow = Object.create(window) as Window;
+    const clearTimeout = vi.fn(() => {
+      throw new Error('clear timeout failed');
+    });
+    Object.defineProperties(hostileOwnerWindow, {
+      clearTimeout: { configurable: true, value: clearTimeout },
+      document: { configurable: true, value: document },
+      setTimeout: { configurable: true, value: window.setTimeout.bind(window) },
+    });
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const stopListening = vi.fn();
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return stopListening;
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    let throwOnHandlerClear = false;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        if (listener === null && throwOnHandlerClear) throw new Error('message clear failed');
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(listener: ((event: unknown) => void) | null) {
+        if (listener === null && throwOnHandlerClear) {
+          throw new Error('messageerror clear failed');
+        }
+      },
+    };
+
+    try {
+      const rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        hostileOwnerWindow
+      );
+      const observed = rendered.then(
+        () => 'resolved',
+        () => 'rejected'
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      controlListener?.({
+        data: {
+          message: 'TS ADM Start',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          source: {
+            type: 'adm',
+            version: 1,
+            adm: '<main>cleanup test</main>',
+            width: 300,
+            height: 250,
+          },
+        },
+        ports: [],
+      });
+      const frame = document.body.querySelector<HTMLIFrameElement>('iframe');
+      if (!frame) throw new Error('Expected the owner frame');
+      const loadHandler = frame.onload;
+      const errorHandler = frame.onerror;
+      Object.defineProperties(frame, {
+        onerror: {
+          configurable: true,
+          get: () => errorHandler,
+          set: (value: unknown) => {
+            if (value === null) throw new Error('frame error-handler clear failed');
+          },
+        },
+        onload: {
+          configurable: true,
+          get: () => loadHandler,
+          set: (value: unknown) => {
+            if (value === null) throw new Error('frame load-handler clear failed');
+          },
+        },
+        remove: {
+          configurable: true,
+          value: vi.fn(() => {
+            throw new Error('frame removal failed');
+          }),
+        },
+      });
+      throwOnHandlerClear = true;
+
+      controlListener?.({
+        data: {
+          message: 'TS Owner Settled',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          outcome: 'failed',
+        },
+        ports: [],
+      });
+
+      await Promise.resolve();
+      expect(await Promise.race([observed, Promise.resolve('pending')])).toBe('rejected');
+      expect(clearTimeout).toHaveBeenCalled();
+      expect(stopListening).toHaveBeenCalledOnce();
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      vi.clearAllTimers();
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('keeps APS DOM ownership out of the PUC frame after a data-free top-mount signal', async () => {
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    try {
+      const rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'aps',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      controlListener?.({
+        data: {
+          message: 'TS APS Top Mount Started',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        },
+        ports: [],
+      });
+
+      expect(document.body.querySelector('iframe')).toBeNull();
+      controlListener?.({
+        data: {
+          message: 'TS Owner Settled',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          outcome: 'accepted',
+        },
+        ports: [],
+      });
+      await expect(rendered).resolves.toBeUndefined();
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('refuses the removed data-bearing APS start and closes every transferred port', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    const documentPort = createPort();
+    let rendered: Promise<void> | undefined;
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'aps',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      controlListener?.({
+        data: {
+          message: 'TS APS Start',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          rendererUrl: 'https://publisher.example/integrations/aps/renderer/v2',
+          envelope: {
+            version: 1,
+            nonce: 'n1_abcdefghijklmnopqrstuv',
+            publisherOrigin: 'https://publisher.example',
+            renderer: {
+              type: 'aps',
+              version: 1,
+              accountId: 'publisher-account',
+              bidId: 'bid-1',
+              tagType: 'iframe',
+              creativeUrl: 'https://creative.example/render',
+              width: 300,
+              height: 250,
+              aaxResponse: 'renderer-envelope',
+            },
+          },
+        },
+        ports: [documentPort],
+      });
+
+      await expect(rendered).rejects.toThrow('TS render owner control refused');
+      expect(documentPort.close).toHaveBeenCalledOnce();
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      await vi.runAllTimersAsync();
+      await rendered?.catch(() => undefined);
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('fails closed immediately when the PUC helper does not return its disposer', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let rendered: Promise<void> | undefined;
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage: vi.fn(() => undefined) },
+        window
+      );
+      const immediate = rendered.then(
+        () => 'resolved',
+        () => 'rejected'
+      );
+
+      await Promise.resolve();
+      expect(await Promise.race([immediate, Promise.resolve('pending')])).toBe('rejected');
+    } finally {
+      await vi.runAllTimersAsync();
+      await rendered?.catch(() => undefined);
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('rejects registration at exactly three seconds, disposes the helper, and closes a late port', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    const stopListening = vi.fn();
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return stopListening;
+      }
+    );
+    let rendered: Promise<void> | undefined;
+    let settlement = 'pending';
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      void rendered.then(
+        () => {
+          settlement = 'resolved';
+        },
+        () => {
+          settlement = 'rejected';
+        }
+      );
+
+      await vi.advanceTimersByTimeAsync(2_999);
+      expect(settlement).toBe('pending');
+      expect(stopListening).not.toHaveBeenCalled();
+      await vi.advanceTimersByTimeAsync(1);
+      expect(settlement).toBe('rejected');
+      expect(stopListening).toHaveBeenCalledOnce();
+
+      const latePort = createPort();
+      registrationCallback?.({ data: '{}', ports: [latePort] });
+      expect(latePort.close).toHaveBeenCalledOnce();
+      expect(stopListening).toHaveBeenCalledOnce();
+    } finally {
+      await rendered?.catch(() => undefined);
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('removes uncommitted owner DOM at the exact twenty-second watchdog boundary', async () => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    let rendered: Promise<void> | undefined;
+    let settlement = 'pending';
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'adm',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      void rendered.then(
+        () => {
+          settlement = 'resolved';
+        },
+        () => {
+          settlement = 'rejected';
+        }
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      controlListener?.({
+        data: {
+          message: 'TS ADM Start',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          source: {
+            type: 'adm',
+            version: 1,
+            adm: '<main>uncommitted creative</main>',
+            width: 300,
+            height: 250,
+          },
+        },
+        ports: [],
+      });
+      const frame = document.body.querySelector<HTMLIFrameElement>('iframe');
+      expect(frame?.isConnected).toBe(true);
+
+      await vi.advanceTimersByTimeAsync(19_999);
+      expect(settlement).toBe('pending');
+      expect(frame?.isConnected).toBe(true);
+      expect(controlPort.close).not.toHaveBeenCalled();
+      await vi.advanceTimersByTimeAsync(1);
+      expect(settlement).toBe('rejected');
+      expect(frame?.isConnected).toBe(false);
+      expect(controlPort.close).toHaveBeenCalledOnce();
+      await vi.advanceTimersByTimeAsync(1);
+      expect(controlPort.close).toHaveBeenCalledOnce();
+    } finally {
+      await rendered?.catch(() => undefined);
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it.each([
+    { caseName: 'unexpected field', message: { unexpected: true }, ports: [] },
+    { caseName: 'transferred port', message: {}, ports: [createPort()] },
+    { caseName: 'wrong message', message: { message: 'TS APS Start' }, ports: [] },
+  ])('refuses a malformed top-mount signal with an $caseName', async ({ message, ports }) => {
+    vi.useFakeTimers();
+    const dynamicWindow = window as unknown as {
+      render?: (
+        data: Readonly<Record<string, unknown>>,
+        helper: Readonly<Record<string, unknown>>,
+        ownerWindow: Window
+      ) => Promise<void>;
+    };
+    window.eval(PUC_DYNAMIC_OWNER);
+    let registrationCallback: ((event: unknown) => void) | undefined;
+    const sendMessage = vi.fn(
+      (
+        _type: string,
+        _payload: Readonly<Record<string, unknown>>,
+        callback: (event: unknown) => void
+      ) => {
+        registrationCallback = callback;
+        return vi.fn();
+      }
+    );
+    let controlListener: ((event: unknown) => void) | undefined;
+    const controlPort = {
+      close: vi.fn(),
+      postMessage: vi.fn(),
+      start: vi.fn(),
+      set onmessage(listener: ((event: unknown) => void) | null) {
+        controlListener = listener ?? undefined;
+      },
+      set onmessageerror(_listener: ((event: unknown) => void) | null) {},
+    };
+    let rendered: Promise<void> | undefined;
+
+    try {
+      rendered = dynamicWindow.render!(
+        window.JSON.parse(
+          JSON.stringify({
+            adId: RESERVATION_ID,
+            message: 'Prebid Response',
+            renderer: PUC_DYNAMIC_OWNER,
+            rendererVersion: '4',
+            tsOwner: {
+              version: 1,
+              status: 'ready',
+              kind: 'aps',
+              lifecycleTicket: LIFECYCLE_TICKET,
+            },
+          })
+        ) as Readonly<Record<string, unknown>>,
+        { sendMessage },
+        window
+      );
+      registrationCallback?.({
+        data: JSON.stringify({
+          message: 'TS Render Owner Registered',
+          adId: RESERVATION_ID,
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        }),
+        ports: [controlPort],
+      });
+      controlListener?.({
+        data: {
+          message: 'TS APS Top Mount Started',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          ...message,
+        },
+        ports,
+      });
+      await expect(rendered).rejects.toThrow('TS render owner control refused');
+      expect(document.body.querySelector('iframe')).toBeNull();
+      for (const port of ports) expect(port.close).toHaveBeenCalledOnce();
+    } finally {
+      await vi.runAllTimersAsync();
+      await rendered?.catch(() => undefined);
+      vi.useRealTimers();
+      delete dynamicWindow.render;
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('installs one capture listener synchronously and removes only that listener on disposal', () => {
+    const harness = createHarness(() => ({ recognized: false }));
+
+    expect(harness.target.addEventListener).toHaveBeenCalledOnce();
+    expect(harness.target.addEventListener.mock.calls[0]?.[0]).toBe('message');
+    expect(harness.target.addEventListener.mock.calls[0]?.[2]).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest()).toEqual({
+      attempts: 0,
+      disposed: false,
+      liveTickets: 0,
+      pendingClaims: 0,
+      ticketTombstones: 0,
+    });
+
+    harness.bridge.dispose();
+    harness.bridge.dispose();
+    expect(harness.target.removeEventListener).toHaveBeenCalledOnce();
+    expect(harness.target.removeEventListener.mock.calls[0]?.[0]).toBe('message');
+    expect(harness.target.removeEventListener.mock.calls[0]?.[2]).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest()).toEqual({
+      attempts: 0,
+      disposed: true,
+      liveTickets: 0,
+      pendingClaims: 0,
+      ticketTombstones: 0,
+    });
+  });
+
+  it('leaves native Prebid identifiers untouched before port or source inspection', () => {
+    const recognize = vi.fn((): ReservationRecognition => ({ recognized: false }));
+    const harness = createHarness(recognize);
+    const stopImmediatePropagation = vi.fn();
+    const ports = vi.fn(() => {
+      throw new Error('native ports must not be read');
+    });
+    const source = vi.fn(() => {
+      throw new Error('native source must not be read');
+    });
+
+    harness.dispatch({
+      data: exactRequest('native-prebid-id'),
+      stopImmediatePropagation,
+      get ports() {
+        return ports();
+      },
+      get source() {
+        return source();
+      },
+    });
+
+    expect(recognize).toHaveBeenCalledWith('native-prebid-id');
+    expect(stopImmediatePropagation).not.toHaveBeenCalled();
+    expect(ports).not.toHaveBeenCalled();
+    expect(source).not.toHaveBeenCalled();
+    expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(0);
+  });
+
+  it.each([
+    ['extended object', { message: 'Prebid Request', adId: RESERVATION_ID, extra: true }],
+    [
+      'extended JSON',
+      JSON.stringify({ message: 'Prebid Request', adId: RESERVATION_ID, extra: true }),
+    ],
+  ])('suppresses and generically refuses a recognized %s before exact parsing', (_label, data) => {
+    const order: string[] = [];
+    const harness = createHarness((reservationId) => {
+      order.push(`lookup:${String(reservationId)}`);
+      return { recognized: true, state: 'renderable', expiresAt: 1_000 };
+    });
+    const port = createPort();
+
+    harness.dispatch({
+      data,
+      ports: [port],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(() => order.push('stop')),
+    });
+
+    expect(order).toEqual([`lookup:${RESERVATION_ID}`, 'stop']);
+    expect(port.postMessage).toHaveBeenCalledOnce();
+    expect(String(port.postMessage.mock.calls[0]?.[0])).toBe(
+      JSON.stringify({
+        message: 'Prebid Response',
+        adId: RESERVATION_ID,
+        rendererVersion: '4',
+        tsOwner: { version: 1, status: 'refused' },
+      })
+    );
+    expect(JSON.parse(String(port.postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'Prebid Response',
+      adId: RESERVATION_ID,
+      rendererVersion: '4',
+      tsOwner: { version: 1, status: 'refused' },
+    });
+    expect(port.postMessage.mock.calls[0]?.[1]).toEqual([]);
+    expect(port.close).toHaveBeenCalledOnce();
+  });
+
+  it('suppresses recognized requests with the wrong port count, refuses on the first, and closes every port', () => {
+    const harness = createHarness(() => ({
+      recognized: true,
+      state: 'renderable',
+      expiresAt: 1_000,
+    }));
+    const first = createPort();
+    const second = createPort();
+    const third = createPort();
+    const stopImmediatePropagation = vi.fn();
+
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [first, second, third],
+      source: Object.freeze({}),
+      stopImmediatePropagation,
+    });
+
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(first.postMessage).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(first.postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'Prebid Response',
+      adId: RESERVATION_ID,
+      rendererVersion: '4',
+      tsOwner: { version: 1, status: 'refused' },
+    });
+    expect(first.postMessage.mock.calls[0]?.[1]).toEqual([]);
+    expect(second.postMessage).not.toHaveBeenCalled();
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(second.close).toHaveBeenCalledOnce();
+    expect(third.close).toHaveBeenCalledOnce();
+
+    const malformed = { close: vi.fn() };
+    const laterUsable = createPort();
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [malformed, laterUsable],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(malformed.close).toHaveBeenCalledOnce();
+    expect(laterUsable.postMessage).toHaveBeenCalledOnce();
+    expect(laterUsable.close).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(0);
+  });
+
+  it('buffers only the first exact live claim and generically refuses a duplicate', () => {
+    const gam = createGamAttempt('aps');
+    const harness = createHarness(() => ({
+      recognized: true,
+      state: 'renderable',
+      expiresAt: 1_000,
+    }));
+    const first = createPort();
+    const duplicate = createPort();
+    const source = Object.freeze({ frame: 'authoritative' });
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [first],
+      source,
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(first.postMessage).not.toHaveBeenCalled();
+    expect(first.close).not.toHaveBeenCalled();
+    expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(1);
+
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [duplicate],
+      source: Object.freeze({ frame: 'duplicate' }),
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(duplicate.postMessage).toHaveBeenCalledOnce();
+    expect(duplicate.close).toHaveBeenCalledOnce();
+    expect(first.postMessage).not.toHaveBeenCalled();
+    expect(first.close).not.toHaveBeenCalled();
+    expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(1);
+
+    harness.bridge.dispose();
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(0);
+  });
+
+  it.each(['caller_aborted', 'superseded', 'navigation_disposed'] as const)(
+    'contains a claim-first attempt cancelled as %s',
+    (reason) => {
+      const gam = createGamAttempt('aps');
+      const harness = createHarness(() => ({
+        recognized: true,
+        state: 'renderable',
+        expiresAt: 10_000,
+      }));
+      const port = createPort();
+      expect(
+        harness.bridge.registerGamAttempt({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      harness.dispatch({
+        data: exactRequest(gam.reservationId),
+        ports: [port],
+        source: Object.freeze({ frame: 'authoritative' }),
+        stopImmediatePropagation: vi.fn(),
+      });
+
+      expect(gam.attempt.cancel(reason)).toBe(true);
+
+      expect(port.postMessage).not.toHaveBeenCalled();
+      expect(port.close).toHaveBeenCalledOnce();
+      expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+      expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+        attempts: 0,
+        liveTickets: 0,
+        pendingClaims: 0,
+      });
+    }
+  );
+
+  it.each(['gam_empty', 'gpt_request_timeout', 'gpt_completion_timeout'] as const)(
+    'contains a GAM-first attempt failed as %s and clears its claim deadline',
+    (reason) => {
+      const clock = createClock();
+      const gam = createGamAttempt('aps');
+      const harness = createHarness(
+        () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+        { now: clock.now, scheduler: clock.scheduler }
+      );
+      expect(
+        harness.bridge.registerGamAttempt({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      expect(
+        harness.bridge.recordNonemptyGam({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+
+      expect(gam.attempt.fail(reason)).toBe(true);
+
+      expect(clock.scheduler.clear).toHaveBeenCalledOnce();
+      expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+      expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+        attempts: 0,
+        liveTickets: 0,
+        pendingClaims: 0,
+      });
+    }
+  );
+
+  it('tombstones a ready ticket when the owning attempt settles before registration', () => {
+    const clock = createClock();
+    const gam = createGamAttempt('adm');
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: clock.now,
+        scheduler: clock.scheduler,
+      }
+    );
+    issueReadyTicket(harness, gam, Object.freeze({ frame: 'authoritative' }));
+
+    expect(gam.attempt.cancel('superseded')).toBe(true);
+
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 0,
+      liveTickets: 0,
+      ticketTombstones: 1,
+    });
+  });
+
+  it.each(['consumed', 'disposed', 'awaiting_prebid_selection'] as const)(
+    'suppresses and refuses a recognized non-renderable %s reservation',
+    (state) => {
+      const harness = createHarness(() => ({ recognized: true, state, expiresAt: 1_000 }));
+      const port = createPort();
+
+      harness.dispatch({
+        data: exactRequest(),
+        ports: [port],
+        source: Object.freeze({}),
+        stopImmediatePropagation: vi.fn(),
+      });
+
+      expect(port.postMessage).toHaveBeenCalledOnce();
+      expect(port.close).toHaveBeenCalledOnce();
+      expect(harness.bridge.snapshotInventoryForTest().pendingClaims).toBe(0);
+    }
+  );
+
+  it('joins an early claim with nonempty GAM and exposes only owner kind and ticket', () => {
+    const gam = createGamAttempt('aps');
+    const source = Object.freeze({ frame: 'authoritative' });
+    const claim = vi.fn(({ pucSource }: { pucSource: unknown }): ReservationClaimResult => ({
+      recognized: true,
+      claimed: true,
+      pucSource: pucSource as object,
+      expiresAt: 10_000,
+    }));
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim,
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    const port = createPort();
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [port],
+      source,
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(claim).not.toHaveBeenCalled();
+    expect(port.postMessage).not.toHaveBeenCalled();
+
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+
+    expect(claim).toHaveBeenCalledWith({
+      attempt: gam.owner,
+      navigationGeneration: gam.owner.navigationGeneration,
+      pucSource: source,
+      reservationId: RESERVATION_ID,
+      slot: gam.owner.slot,
+    });
+    expect(gam.attempt.admitClaimedWinner).toHaveBeenCalledOnce();
+    expect(gam.attempt.ownerClaimed).toHaveBeenCalledOnce();
+    expect(port.postMessage).toHaveBeenCalledOnce();
+    const rawResponse = String(port.postMessage.mock.calls[0]?.[0]);
+    const response = JSON.parse(rawResponse);
+    expect(
+      new TextEncoder().encode(String(port.postMessage.mock.calls[0]?.[0])).byteLength
+    ).toBeLessThanOrEqual(72 * 1_024);
+    expect(response).toEqual({
+      message: 'Prebid Response',
+      adId: RESERVATION_ID,
+      renderer: PUC_DYNAMIC_OWNER,
+      rendererVersion: '4',
+      tsOwner: {
+        version: 1,
+        status: 'ready',
+        kind: 'aps',
+        lifecycleTicket: LIFECYCLE_TICKET,
+      },
+    });
+    expect(rawResponse).toBe(
+      JSON.stringify({
+        message: 'Prebid Response',
+        adId: RESERVATION_ID,
+        renderer: PUC_DYNAMIC_OWNER,
+        rendererVersion: '4',
+        tsOwner: {
+          version: 1,
+          status: 'ready',
+          kind: 'aps',
+          lifecycleTicket: LIFECYCLE_TICKET,
+        },
+      })
+    );
+    expect(response).not.toHaveProperty('source');
+    expect(response).not.toHaveProperty('renderSource');
+    expect(response).not.toHaveProperty('winnerContext');
+    expect(port.postMessage.mock.calls[0]?.[1]).toEqual([]);
+    expect(port.close).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest()).toEqual({
+      attempts: 1,
+      disposed: false,
+      liveTickets: 1,
+      pendingClaims: 0,
+      ticketTombstones: 0,
+    });
+
+    expect(gam.attempt.fail('internal_error')).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest()).toEqual({
+      attempts: 0,
+      disposed: false,
+      liveTickets: 0,
+      pendingClaims: 0,
+      ticketTombstones: 1,
+    });
+  });
+
+  it('requests one guarded shell resize only after the current ready response posts', () => {
+    const gam = createGamAttempt('aps', 81);
+    const source = Object.freeze({ frame: 'authoritative' });
+    const resizeCollapsedShell = vi.fn(() => true);
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        resizeCollapsedShell,
+      }
+    );
+    const port = createPort();
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(gam.reservationId),
+      ports: [port],
+      source,
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+
+    expect(resizeCollapsedShell).toHaveBeenCalledExactlyOnceWith({
+      source,
+      width: 300,
+      height: 250,
+    });
+    expect(port.postMessage.mock.invocationCallOrder[0]).toBeLessThan(
+      resizeCollapsedShell.mock.invocationCallOrder[0]!
+    );
+  });
+
+  it('does not resize after a failed post or a navigation cancellation during the post', () => {
+    const resizeCollapsedShell = vi.fn(() => true);
+    for (const cancelDuringPost of [false, true]) {
+      const gam = createGamAttempt('adm', cancelDuringPost ? 83 : 82);
+      const harness = createHarness(
+        () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+        {
+          claim: ({ pucSource }) => ({
+            recognized: true,
+            claimed: true,
+            pucSource: pucSource as object,
+            expiresAt: 10_000,
+          }),
+          mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+          resizeCollapsedShell,
+        }
+      );
+      const port = createPort();
+      port.postMessage.mockImplementation(() => {
+        if (cancelDuringPost) gam.attempt.cancel('navigation_disposed');
+        else throw new Error('post failed');
+      });
+      expect(
+        harness.bridge.registerGamAttempt({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      harness.dispatch({
+        data: exactRequest(gam.reservationId),
+        ports: [port],
+        source: Object.freeze({ frame: cancelDuringPost ? 'cancelled' : 'failed' }),
+        stopImmediatePropagation: vi.fn(),
+      });
+      expect(
+        harness.bridge.recordNonemptyGam({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+    }
+
+    expect(resizeCollapsedShell).not.toHaveBeenCalled();
+  });
+
+  it('starts the exact three-second claim deadline only after nonempty GAM', () => {
+    const clock = createClock();
+    const gam = createGamAttempt('adm');
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      { now: clock.now, scheduler: clock.scheduler }
+    );
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+
+    expect(clock.scheduler.set).toHaveBeenCalledWith(expect.any(Function), 3_000);
+    clock.advance(2_999);
+    expect(gam.attempt.fail).not.toHaveBeenCalled();
+    clock.advance(1);
+    expect(gam.attempt.fail).toHaveBeenCalledWith('bridge_claim_timeout');
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest().attempts).toBe(0);
+  });
+
+  it('clears a GAM-first claim deadline when the exact request completes the join', () => {
+    const clock = createClock();
+    const gam = createGamAttempt('adm');
+    const claim = vi.fn(({ pucSource }: { pucSource: unknown }): ReservationClaimResult => ({
+      recognized: true,
+      claimed: true,
+      pucSource: pucSource as object,
+      expiresAt: 10_000,
+    }));
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim,
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: clock.now,
+        scheduler: clock.scheduler,
+      }
+    );
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: RESERVATION_ID,
+      })
+    ).toBe(true);
+    const staleClaimDeadline = clock.scheduler.set.mock.calls[0]?.[0];
+    if (typeof staleClaimDeadline !== 'function') {
+      throw new Error('Expected the GAM-first claim deadline callback');
+    }
+    const port = createPort();
+    harness.dispatch({
+      data: exactRequest(),
+      ports: [port],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(port.postMessage).toHaveBeenCalledOnce();
+    expect(gam.attempt.renderSource).toMatchObject({ type: 'adm', version: 1 });
+    expect(JSON.parse(String(port.postMessage.mock.calls[0]?.[0])).tsOwner.kind).toBe('adm');
+    expect(clock.scheduler.clear).toHaveBeenCalledOnce();
+    staleClaimDeadline();
+    expect(gam.attempt.fail).not.toHaveBeenCalledWith('bridge_claim_timeout');
+    clock.advance(2_999);
+    expect(gam.attempt.fail).not.toHaveBeenCalled();
+    clock.advance(1);
+    expect(gam.attempt.fail).toHaveBeenCalledWith('owner_registration_timeout');
+    expect(gam.attempt.fail).not.toHaveBeenCalledWith('bridge_claim_timeout');
+  });
+
+  it('checks all eight ticket draws against live and tombstoned entries', () => {
+    const first = createGamAttempt('aps', 1);
+    const second = createGamAttempt('aps', 2);
+    let draws = 0;
+    const claim = vi.fn(({ pucSource }: { pucSource: unknown }): ReservationClaimResult => ({
+      recognized: true,
+      claimed: true,
+      pucSource: pucSource as object,
+      expiresAt: 10_000,
+    }));
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim,
+        mintLifecycleTicket: () => {
+          draws += 1;
+          return Object.freeze({ ok: true as const, value: LIFECYCLE_TICKET });
+        },
+      }
+    );
+    for (const gam of [first, second]) {
+      expect(
+        harness.bridge.registerGamAttempt({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      const port = createPort();
+      harness.dispatch({
+        data: exactRequest(gam.reservationId),
+        ports: [port],
+        source: Object.freeze({ index: draws }),
+        stopImmediatePropagation: vi.fn(),
+      });
+      expect(
+        harness.bridge.recordNonemptyGam({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      if (gam === first) {
+        expect(JSON.parse(String(port.postMessage.mock.calls[0]?.[0])).tsOwner.status).toBe(
+          'ready'
+        );
+        expect(gam.attempt.fail('internal_error')).toBe(true);
+      } else {
+        expect(JSON.parse(String(port.postMessage.mock.calls[0]?.[0])).tsOwner.status).toBe(
+          'refused'
+        );
+        expect(gam.attempt.fail).toHaveBeenCalledWith('identity_generation_failed');
+      }
+    }
+    expect(draws).toBe(9);
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(1);
+  });
+
+  it('retains ticket tombstones through 2,999 ms and prunes them at 3,000 ms', () => {
+    const clock = createClock();
+    const gam = createGamAttempt('aps', 7);
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: clock.now,
+        scheduler: clock.scheduler,
+      }
+    );
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(gam.reservationId),
+      ports: [createPort()],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    expect(gam.attempt.fail('internal_error')).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(1);
+
+    clock.advance(2_999);
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(1);
+    clock.advance(1);
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(0);
+  });
+
+  it('starts the fixed ticket TTL only after posting the ready outer response', () => {
+    const clock = createClock();
+    const gam = createGamAttempt('aps', 71);
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: clock.now,
+        scheduler: clock.scheduler,
+      }
+    );
+    const port = createPort();
+    port.postMessage.mockImplementation(() => clock.advance(1_000));
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(gam.reservationId),
+      ports: [port],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+
+    clock.advance(2_000);
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+    expect(gam.attempt.fail).not.toHaveBeenCalled();
+    clock.advance(999);
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+    clock.advance(1);
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(0);
+    expect(gam.attempt.fail).toHaveBeenCalledWith('owner_registration_timeout');
+  });
+
+  it('keeps a reused ticket live when a cleared expiry callback from its prior issue arrives late', () => {
+    let now = 0;
+    const callbacks: Array<() => void> = [];
+    const scheduler = {
+      set: vi.fn((callback: () => void): number => {
+        callbacks[callbacks.length] = callback;
+        return callbacks.length;
+      }),
+      clear: vi.fn(),
+    };
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: () => now,
+        scheduler,
+      }
+    );
+    const first = createGamAttempt('aps', 72);
+    issueReadyTicket(harness, first, Object.freeze({ frame: 'first' }));
+    const firstExpiry = callbacks[0];
+    if (!firstExpiry) throw new Error('Expected the first ticket expiry callback');
+
+    now = 3_000;
+    firstExpiry();
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(0);
+
+    const second = createGamAttempt('aps', 73);
+    issueReadyTicket(harness, second, Object.freeze({ frame: 'second' }));
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+
+    now = 6_000;
+    firstExpiry();
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(1);
+    expect(second.attempt.fail).not.toHaveBeenCalled();
+
+    const secondExpiry = callbacks[1];
+    if (!secondExpiry) throw new Error('Expected the reused ticket expiry callback');
+    secondExpiry();
+    expect(harness.bridge.snapshotInventoryForTest().liveTickets).toBe(0);
+    expect(second.attempt.fail).toHaveBeenCalledWith('owner_registration_timeout');
+  });
+
+  it('fails and tombstones a ticket when the ready outer response cannot be posted', () => {
+    const gam = createGamAttempt('adm', 8);
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    const port = createPort();
+    port.postMessage.mockImplementation(() => {
+      throw new Error('outer response transport failed');
+    });
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(gam.reservationId),
+      ports: [port],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+
+    expect(gam.attempt.fail).toHaveBeenCalledWith('internal_error');
+    expect(port.close).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 0,
+      liveTickets: 0,
+      pendingClaims: 0,
+      ticketTombstones: 1,
+    });
+  });
+
+  it('shares ticket capacity 320 across live entries without eviction', () => {
+    const clock = createClock();
+    let draw = 0;
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => {
+          const suffix = draw.toString(36).padStart(22, '0').slice(-22);
+          draw += 1;
+          return Object.freeze({ ok: true as const, value: `t1_${suffix}` });
+        },
+        now: clock.now,
+        scheduler: clock.scheduler,
+      }
+    );
+
+    for (let index = 0; index < 320; index += 1) {
+      const gam = createGamAttempt('aps', 100 + index);
+      expect(
+        harness.bridge.registerGamAttempt({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      const port = createPort();
+      harness.dispatch({
+        data: exactRequest(gam.reservationId),
+        ports: [port],
+        source: Object.freeze({ index }),
+        stopImmediatePropagation: vi.fn(),
+      });
+      expect(
+        harness.bridge.recordNonemptyGam({
+          artifact: gam.artifact,
+          attempt: gam.attempt,
+          owner: gam.owner,
+          reservationId: gam.reservationId,
+        })
+      ).toBe(true);
+      expect(JSON.parse(String(port.postMessage.mock.calls[0]?.[0])).tsOwner.status).toBe('ready');
+    }
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 320,
+      liveTickets: 320,
+      ticketTombstones: 0,
+    });
+
+    const overflow = createGamAttempt('aps', 999);
+    const overflowPort = createPort();
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: overflow.artifact,
+        attempt: overflow.attempt,
+        owner: overflow.owner,
+        reservationId: overflow.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(overflow.reservationId),
+      ports: [overflowPort],
+      source: Object.freeze({ overflow: true }),
+      stopImmediatePropagation: vi.fn(),
+    });
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: overflow.artifact,
+        attempt: overflow.attempt,
+        owner: overflow.owner,
+        reservationId: overflow.reservationId,
+      })
+    ).toBe(true);
+    expect(overflow.attempt.fail).toHaveBeenCalledWith('capability_registry_full');
+    expect(JSON.parse(String(overflowPort.postMessage.mock.calls[0]?.[0])).tsOwner.status).toBe(
+      'refused'
+    );
+    expect(draw).toBe(320);
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 320,
+      liveTickets: 320,
+      ticketTombstones: 0,
+    });
+    harness.bridge.dispose();
+  });
+
+  it('ignores an unknown owner ticket before suppression, source, or port inspection', () => {
+    const harness = createHarness(() => ({ recognized: false }));
+    const stopImmediatePropagation = vi.fn();
+    const ports = vi.fn(() => {
+      throw new Error('unknown ticket ports must not be read');
+    });
+    const source = vi.fn(() => {
+      throw new Error('unknown ticket source must not be read');
+    });
+
+    harness.dispatch({
+      data: exactOwnerRegistration(RESERVATION_ID, 't1_0000000000000000000000'),
+      stopImmediatePropagation,
+      get ports() {
+        return ports();
+      },
+      get source() {
+        return source();
+      },
+    });
+
+    expect(stopImmediatePropagation).not.toHaveBeenCalled();
+    expect(ports).not.toHaveBeenCalled();
+    expect(source).not.toHaveBeenCalled();
+  });
+
+  it('suppresses a known owner ticket before failing closed on a regressed clock', () => {
+    let now = 100;
+    const gam = createGamAttempt('adm', 1_009);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: () => now,
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    now = 99;
+    const responsePort = createPort();
+    const stopImmediatePropagation = vi.fn();
+
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [responsePort],
+      source: pucSource,
+      stopImmediatePropagation,
+    });
+
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(responsePort.postMessage.mock.calls[0]?.[0]))).toMatchObject({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+    });
+    expect(responsePort.close).toHaveBeenCalledOnce();
+    expect(gam.attempt.fail).toHaveBeenCalledWith('internal_error');
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+  });
+
+  it('consumes one exact owner registration and retains only the kernel control endpoint', () => {
+    const gam = createGamAttempt('adm', 1_001);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const retained = createPort();
+    const transferred = createPort();
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          readonly port1 = retained;
+          readonly port2 = transferred;
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    const responsePort = createPort();
+    const stopImmediatePropagation = vi.fn();
+
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [responsePort],
+      source: pucSource,
+      stopImmediatePropagation,
+    });
+
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(gam.attempt.ownerRegistered).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(responsePort.postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'TS Render Owner Registered',
+      adId: gam.reservationId,
+      version: 1,
+      lifecycleTicket: LIFECYCLE_TICKET,
+    });
+    expect(responsePort.postMessage.mock.calls[0]?.[1]).toEqual([transferred]);
+    expect(responsePort.close).toHaveBeenCalledOnce();
+    expect(transferred.close).not.toHaveBeenCalled();
+    expect(retained.close).not.toHaveBeenCalled();
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 1,
+      liveTickets: 0,
+      ticketTombstones: 1,
+    });
+
+    expect(gam.attempt.fail('internal_error')).toBe(true);
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+    expect(retained.close).toHaveBeenCalledOnce();
+    expect(transferred.close).not.toHaveBeenCalled();
+  });
+
+  it('closes both channel endpoints when owner-channel construction settles reentrantly', () => {
+    const gam = createGamAttempt('adm', 1_010);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const retained = createPort();
+    const transferred = createPort();
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          readonly port1 = retained;
+          readonly port2 = transferred;
+
+          constructor() {
+            gam.attempt.fail('internal_error');
+          }
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    const responsePort = createPort();
+
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [responsePort],
+      source: pucSource,
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(retained.close).toHaveBeenCalledOnce();
+    expect(transferred.close).toHaveBeenCalledOnce();
+    expect(responsePort.close).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(responsePort.postMessage.mock.calls[0]?.[0]))).toMatchObject({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+    });
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+    expect(harness.bridge.snapshotInventoryForTest().attempts).toBe(0);
+  });
+
+  it('sends exact ADM start and settles only after owner insertion and intended load', () => {
+    const gam = createGamAttempt('adm', 1_011);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const controlRetained = createPort();
+    const controlTransferred = createPort();
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          readonly port1 = controlRetained;
+          readonly port2 = controlTransferred;
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    const responsePort = createPort();
+
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [responsePort],
+      source: pucSource,
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(controlRetained.postMessage).toHaveBeenCalledOnce();
+    expect(controlRetained.postMessage.mock.calls[0]).toEqual([
+      {
+        message: 'TS ADM Start',
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+        source: {
+          type: 'adm',
+          version: 1,
+          adm: '<main>fictional creative</main>',
+          width: 300,
+          height: 250,
+        },
+      },
+      [],
+    ]);
+    expect(gam.attempt.accept).not.toHaveBeenCalled();
+
+    dispatchPortMessage(controlRetained, {
+      message: 'TS Owner Inserted',
+      version: 1,
+      lifecycleTicket: LIFECYCLE_TICKET,
+    });
+    expect(gam.attempt.beginAdm).toHaveBeenCalledWith(gam.artifact);
+    expect(gam.artifact.dispose).not.toHaveBeenCalled();
+    expect(gam.attempt.accept).not.toHaveBeenCalled();
+
+    dispatchPortMessage(controlRetained, {
+      message: 'TS ADM Loaded',
+      version: 1,
+      lifecycleTicket: LIFECYCLE_TICKET,
+    });
+    expect(gam.attempt.accept).toHaveBeenCalledOnce();
+    expect(gam.artifact.dispose).not.toHaveBeenCalled();
+    expect(controlRetained.postMessage).toHaveBeenCalledTimes(2);
+    expect(controlRetained.postMessage.mock.calls[1]).toEqual([
+      {
+        message: 'TS Owner Settled',
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+        outcome: 'accepted',
+      },
+      [],
+    ]);
+    expect(controlRetained.close).toHaveBeenCalledOnce();
+  });
+
+  it('fails closed and contains every port when an owner control message transfers one', () => {
+    const gam = createGamAttempt('adm', 1_014);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const controlRetained = createPort();
+    const controlTransferred = createPort();
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          readonly port1 = controlRetained;
+          readonly port2 = controlTransferred;
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [createPort()],
+      source: pucSource,
+      stopImmediatePropagation: vi.fn(),
+    });
+    const unexpected = createPort();
+
+    dispatchPortMessage(
+      controlRetained,
+      {
+        message: 'TS Owner Inserted',
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+      },
+      [unexpected]
+    );
+
+    expect(unexpected.close).toHaveBeenCalledOnce();
+    expect(gam.attempt.beginAdm).not.toHaveBeenCalled();
+    expect(gam.attempt.fail).toHaveBeenCalledWith('internal_error');
+    expect(controlRetained.close).toHaveBeenCalledOnce();
+    expect(gam.artifact.dispose).toHaveBeenCalledOnce();
+  });
+
+  it('mounts APS in the exact top-page slot and sends only the data-free owner signal', () => {
+    document.body.innerHTML =
+      '<div id="publisher-child"></div><div id="top-slot"><span>gam</span></div>';
+    const gam = createGamAttempt('aps', 1_012);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const controlRetained = createPort();
+    const controlTransferred = createPort();
+    const bootstrapNonce = `b1_${'b'.repeat(22)}`;
+    const rendererNonce = `n1_${'n'.repeat(22)}`;
+    const nonceRegistry = (nonce: string) =>
+      Object.freeze({
+        bindSource: vi.fn(() => true),
+        consume: vi.fn(() => true),
+        dispose: vi.fn(),
+        issue: vi.fn(() => Object.freeze({ ok: true as const, nonce })),
+        snapshotForTest: vi.fn(() =>
+          Object.freeze({ bindings: 1, disposed: false, liveNonces: 1 })
+        ),
+      });
+    const bootstraps = nonceRegistry(bootstrapNonce);
+    const renderers = nonceRegistry(rendererNonce);
+    const topSlot = document.getElementById('top-slot')!;
+    const isCurrent = vi.fn(() => true);
+    const resolveApsMountBinding = vi.fn(() =>
+      Object.freeze({
+        bindArtifact: () =>
+          Object.freeze({
+            commit: () => true,
+            finalize: () => undefined,
+            isCurrent: () => true,
+            previousArtifact: undefined,
+            release: () => undefined,
+            rollback: () => undefined,
+          }),
+        bindingEpoch: Object.freeze({ binding: 1 }),
+        cycle: Object.freeze({ isRetired: () => false }),
+        element: topSlot,
+        physicalSlot: Object.freeze({ slot: 'physical' }),
+        isCurrent,
+      })
+    );
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          readonly port1 = controlRetained;
+          readonly port2 = controlTransferred;
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        mountAps: (input) =>
+          renderPucApsAttempt({
+            ...input,
+            bindArtifactGuard: bindCommittedArtifactGuard,
+            bootstrapNonces: bootstraps,
+            hostPositions: createArtifactHostPositionLeaseRegistry(),
+            nonces: renderers,
+            publisherOrigin: window.location.origin,
+          }),
+        slots: { resolveApsMountBinding },
+      }
+    );
+
+    try {
+      issueReadyTicket(harness, gam, pucSource);
+      harness.dispatch({
+        data: exactOwnerRegistration(gam.reservationId),
+        ports: [createPort()],
+        source: pucSource,
+        stopImmediatePropagation: vi.fn(),
+      });
+
+      expect(resolveApsMountBinding).toHaveBeenCalledWith(
+        gam.owner.navigationGeneration,
+        gam.owner.slot,
+        gam.attempt.id
+      );
+      expect(gam.attempt.fail.mock.calls).toEqual([]);
+      expect(bootstraps.issue).toHaveBeenCalledOnce();
+      expect(renderers.issue).toHaveBeenCalledOnce();
+      expect(gam.attempt.beginApsDocument).toHaveBeenCalledOnce();
+      expect(gam.artifact.dispose).not.toHaveBeenCalled();
+      expect(document.body.querySelector('#publisher-child iframe')).toBeNull();
+      expect(document.body.querySelectorAll('#top-slot iframe')).toHaveLength(1);
+      const frame = topSlot.querySelector<HTMLIFrameElement>('iframe')!;
+      expect(frame.style.position).toBe('absolute');
+      expect(frame.style.visibility).toBe('hidden');
+      expect(topSlot.querySelector('span')?.textContent).toBe('gam');
+      expect(controlRetained.postMessage).toHaveBeenCalledExactlyOnceWith(
+        {
+          message: 'TS APS Top Mount Started',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+        },
+        []
+      );
+
+      const source = frame.contentWindow!;
+      harness.dispatch({
+        data: JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce,
+        }),
+        origin: 'null',
+        ports: [],
+        source,
+      });
+      const rendererPort = createPort();
+      harness.dispatch({
+        data: JSON.stringify({
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce,
+          rendererNonce,
+        }),
+        origin: 'null',
+        ports: [rendererPort],
+        source,
+      });
+      dispatchPortMessage(rendererPort, {
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      dispatchPortMessage(rendererPort, {
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: rendererNonce,
+      });
+
+      expect(frame.style.visibility).toBe('visible');
+      expect(gam.attempt.accept).toHaveBeenCalledOnce();
+      expect(controlRetained.postMessage.mock.calls[1]).toEqual([
+        {
+          message: 'TS Owner Settled',
+          version: 1,
+          lifecycleTicket: LIFECYCLE_TICKET,
+          outcome: 'accepted',
+        },
+        [],
+      ]);
+      expect(controlRetained.close).toHaveBeenCalledOnce();
+    } finally {
+      bootstraps.dispose();
+      renderers.dispose();
+      harness.bridge.dispose();
+      document.body.innerHTML = '';
+    }
+  });
+  it('suppresses, refuses, and invalidates a live ticket used from the wrong source', () => {
+    const gam = createGamAttempt('adm', 1_002);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    let channels = 0;
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        messageChannel: class {
+          constructor() {
+            channels += 1;
+          }
+
+          readonly port1 = createPort();
+          readonly port2 = createPort();
+        },
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    const wrongSourcePort = createPort();
+
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [wrongSourcePort],
+      source: Object.freeze({ frame: 'wrong' }),
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(JSON.parse(String(wrongSourcePort.postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+      version: 1,
+    });
+    expect(wrongSourcePort.close).toHaveBeenCalledOnce();
+    expect(channels).toBe(0);
+    expect(gam.attempt.fail).toHaveBeenCalledWith('bridge_id_mismatch');
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      attempts: 0,
+      liveTickets: 0,
+      ticketTombstones: 1,
+    });
+
+    const replayPort = createPort();
+    const stopReplay = vi.fn();
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId),
+      ports: [replayPort],
+      source: pucSource,
+      stopImmediatePropagation: stopReplay,
+    });
+    expect(stopReplay).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(replayPort.postMessage.mock.calls[0]?.[0]))).toMatchObject({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+    });
+    expect(replayPort.close).toHaveBeenCalledOnce();
+    expect(channels).toBe(0);
+  });
+
+  it('invalidates a live owner ticket on an extended shape or wrong port count', () => {
+    const gam = createGamAttempt('aps', 1_003);
+    const pucSource = Object.freeze({ frame: 'authoritative' });
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource: claimedSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: claimedSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+      }
+    );
+    issueReadyTicket(harness, gam, pucSource);
+    const first = createPort();
+    const second = createPort();
+    const stopImmediatePropagation = vi.fn();
+
+    harness.dispatch({
+      data: JSON.stringify({
+        message: 'TS Render Owner Register',
+        adId: gam.reservationId,
+        version: 1,
+        lifecycleTicket: LIFECYCLE_TICKET,
+        extra: true,
+      }),
+      ports: [first, second],
+      source: pucSource,
+      stopImmediatePropagation,
+    });
+
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(first.postMessage.mock.calls[0]?.[0]))).toEqual({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+      version: 1,
+    });
+    expect(first.postMessage.mock.calls[0]?.[1]).toEqual([]);
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(second.close).toHaveBeenCalledOnce();
+    expect(gam.attempt.fail).toHaveBeenCalledWith('bridge_id_mismatch');
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(1);
+  });
+
+  it('tombstones a posted ticket when its expiry scheduler cannot arm', () => {
+    let now = 0;
+    const gam = createGamAttempt('aps', 81);
+    const harness = createHarness(
+      () => ({ recognized: true, state: 'renderable', expiresAt: 10_000 }),
+      {
+        claim: ({ pucSource }) => ({
+          recognized: true,
+          claimed: true,
+          pucSource: pucSource as object,
+          expiresAt: 10_000,
+        }),
+        mintLifecycleTicket: () => Object.freeze({ ok: true, value: LIFECYCLE_TICKET }),
+        now: () => now,
+        scheduler: {
+          clear: vi.fn(),
+          set: vi.fn(() => undefined),
+        },
+      }
+    );
+    const port = createPort();
+    expect(
+      harness.bridge.registerGamAttempt({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    harness.dispatch({
+      data: exactRequest(gam.reservationId),
+      ports: [port],
+      source: Object.freeze({}),
+      stopImmediatePropagation: vi.fn(),
+    });
+
+    expect(
+      harness.bridge.recordNonemptyGam({
+        artifact: gam.artifact,
+        attempt: gam.attempt,
+        owner: gam.owner,
+        reservationId: gam.reservationId,
+      })
+    ).toBe(true);
+    expect(port.postMessage).toHaveBeenCalledOnce();
+    expect(gam.attempt.fail).toHaveBeenCalledWith('internal_error');
+    expect(harness.bridge.snapshotInventoryForTest()).toMatchObject({
+      liveTickets: 0,
+      ticketTombstones: 1,
+    });
+
+    now = 3_000;
+    const latePort = createPort();
+    const stopImmediatePropagation = vi.fn();
+    harness.dispatch({
+      data: exactOwnerRegistration(gam.reservationId, LIFECYCLE_TICKET),
+      ports: [latePort],
+      source: Object.freeze({}),
+      stopImmediatePropagation,
+    });
+    expect(harness.bridge.snapshotInventoryForTest().ticketTombstones).toBe(0);
+    expect(stopImmediatePropagation).toHaveBeenCalledOnce();
+    expect(JSON.parse(String(latePort.postMessage.mock.calls[0]?.[0]))).toMatchObject({
+      message: 'TS Render Owner Refused',
+      adId: gam.reservationId,
+    });
+    expect(latePort.close).toHaveBeenCalledOnce();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/render.test.ts b/crates/trusted-server-js/lib/test/services/render.test.ts
new file mode 100644
index 000000000..6db23c88b
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/render.test.ts
@@ -0,0 +1,3758 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import apsEnvelope from '../fixtures/aps-renderer-v1.json';
+import { createBrowserMessagingAdapter } from '../../src/adapters/messaging';
+import { prepareAdmIframe } from '../../src/core/render';
+import { resizeCollapsedPucShell } from '../../src/core/puc_shell';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import { createRuntimeSession } from '../../src/kernel/sessions';
+import type { RenderAttemptScope, WinnerContext } from '../../src/kernel/sessions';
+import {
+  APS_PERMANENT_SANDBOX,
+  APS_RENDERER_SANDBOX,
+  APS_RENDERER_V2_PATH,
+  renderDirectApsAttempt,
+  renderPucApsAttempt,
+  resolveApsRendererV2Url,
+} from '../../src/integrations/aps/render';
+import {
+  bindCommittedArtifactGuard,
+  bindCommittedArtifactRetirement,
+  createArtifactHostPositionLeaseRegistry,
+  createCommittedArtifactStore,
+  createBootstrapNonceRegistry,
+  createRenderAttempt,
+  createRendererNonceRegistry,
+  createSlotOperation,
+  renderDirectAdmAttempt,
+  type CommittedRenderArtifact,
+  type DirectAdmIframeConstructor,
+  type DirectAdmIframeHandle,
+  type RenderAttempt,
+  type RenderAttemptDiagnosticsObservation,
+  type RenderAttemptSnapshot,
+  type RenderAttemptState,
+  type SlotOperation,
+  type SlotOperationOptions,
+} from '../../src/services/render';
+import {
+  createReservationService,
+  type ReservationClaimResult,
+  type ReservationRenderSource,
+  type ReservationService,
+} from '../../src/services/reservations';
+
+const ATTEMPT_ONE = 'a1_0000000000000000000000';
+const ATTEMPT_TWO = 'a1_0000000000000000000001';
+
+function indexedAttemptId(index: number): string {
+  return `a1_${index.toString().padStart(22, '0')}`;
+}
+
+function indexedRendererNonce(index: number): string {
+  return `n1_${index.toString().padStart(22, '0')}`;
+}
+
+function indexedBootstrapNonce(index: number): string {
+  return `b1_${index.toString().padStart(22, '0')}`;
+}
+
+const ADM_SOURCE = Object.freeze({
+  type: 'adm' as const,
+  version: 1 as const,
+  adm: '<div>fictional creative</div>',
+  width: 300,
+  height: 250,
+});
+
+const APS_SOURCE = Object.freeze({
+  type: 'aps' as const,
+  version: 1 as const,
+  accountId: 'fictional-account',
+  bidId: 'fictional-bid',
+  tagType: 'iframe' as const,
+  creativeUrl: 'https://creative.example/render',
+  width: 300,
+  height: 250,
+  aaxResponse: 'e30=',
+});
+
+const DIRECT_APS_BID = apsEnvelope.seatbid[0]!.bid[0]!;
+const DIRECT_APS_SOURCE = Object.freeze({
+  type: 'aps' as const,
+  version: 1 as const,
+  accountId: 'fictional-account',
+  bidId: DIRECT_APS_BID.id,
+  creativeId: 'fictional-creative',
+  tagType: DIRECT_APS_BID.ext.tagtype as 'iframe',
+  creativeUrl: DIRECT_APS_BID.ext.creativeurl,
+  width: DIRECT_APS_BID.w,
+  height: DIRECT_APS_BID.h,
+  aaxResponse: btoa(JSON.stringify(apsEnvelope)),
+});
+
+const WINNER_CONTEXT = Object.freeze({ selectedCpm: 1 });
+
+describe('collapsed PUC shell resize', () => {
+  function collapsedShell(): {
+    readonly frame: HTMLIFrameElement;
+    readonly wrapper: HTMLDivElement;
+  } {
+    const wrapper = document.createElement('div');
+    const frame = document.createElement('iframe');
+    wrapper.style.width = '1px';
+    wrapper.style.height = '1px';
+    frame.setAttribute('width', '1');
+    frame.setAttribute('height', '1');
+    frame.style.width = '1px';
+    frame.style.height = '1px';
+    wrapper.appendChild(frame);
+    document.body.appendChild(wrapper);
+    return { frame, wrapper };
+  }
+
+  it('resizes only the exact connected source iframe and its collapsed immediate wrapper once', () => {
+    const selected = collapsedShell();
+    const sibling = collapsedShell();
+
+    try {
+      expect(
+        resizeCollapsedPucShell({
+          source: selected.frame.contentWindow!,
+          width: 300,
+          height: 250,
+        })
+      ).toBe(true);
+      expect(selected.frame.style.width).toBe('300px');
+      expect(selected.frame.style.height).toBe('250px');
+      expect(selected.wrapper.style.width).toBe('300px');
+      expect(selected.wrapper.style.height).toBe('250px');
+      expect(sibling.frame.style.width).toBe('1px');
+      expect(sibling.wrapper.style.width).toBe('1px');
+
+      expect(
+        resizeCollapsedPucShell({
+          source: selected.frame.contentWindow!,
+          width: 300,
+          height: 250,
+        })
+      ).toBe(false);
+    } finally {
+      selected.wrapper.remove();
+      sibling.wrapper.remove();
+    }
+  });
+
+  it('rejects invalid dimensions and non-ordinary, expanded, detached, or replaced shells atomically', () => {
+    const cases: Array<(shell: ReturnType<typeof collapsedShell>) => void> = [
+      ({ wrapper }) => {
+        wrapper.style.width = '2px';
+      },
+      ({ frame }) => {
+        frame.style.position = 'fixed';
+      },
+      ({ wrapper }) => {
+        wrapper.style.position = 'sticky';
+      },
+      ({ wrapper }) => {
+        wrapper.setAttribute('data-anchor-status', 'displayed');
+      },
+      ({ frame }) => {
+        frame.remove();
+      },
+    ];
+
+    for (const mutate of cases) {
+      const shell = collapsedShell();
+      const source = shell.frame.contentWindow!;
+      mutate(shell);
+      try {
+        expect(resizeCollapsedPucShell({ source, width: 300, height: 250 })).toBe(false);
+        expect(shell.wrapper.style.height).toBe('1px');
+        expect(shell.frame.style.height).toBe('1px');
+      } finally {
+        shell.wrapper.remove();
+      }
+    }
+
+    const invalid = collapsedShell();
+    try {
+      expect(
+        resizeCollapsedPucShell({
+          source: invalid.frame.contentWindow!,
+          width: Number.NaN,
+          height: 250,
+        })
+      ).toBe(false);
+      expect(invalid.frame.style.width).toBe('1px');
+      expect(invalid.wrapper.style.width).toBe('1px');
+    } finally {
+      invalid.wrapper.remove();
+    }
+  });
+
+  it('rejects a collapsed ordinary wrapper nested inside an anchor shell', () => {
+    const shell = collapsedShell();
+    const anchor = document.createElement('a');
+    shell.wrapper.replaceWith(anchor);
+    anchor.appendChild(shell.wrapper);
+
+    try {
+      expect(
+        resizeCollapsedPucShell({
+          source: shell.frame.contentWindow!,
+          width: 300,
+          height: 250,
+        })
+      ).toBe(false);
+      expect(shell.frame.style.width).toBe('1px');
+      expect(shell.wrapper.style.width).toBe('1px');
+    } finally {
+      anchor.remove();
+    }
+  });
+});
+
+function prepareRenderSource(candidate: unknown) {
+  if (candidate === ADM_SOURCE) return ADM_SOURCE;
+  if (candidate === APS_SOURCE) return APS_SOURCE;
+  if (candidate === DIRECT_APS_SOURCE) return DIRECT_APS_SOURCE;
+  return undefined;
+}
+
+const RESERVATION_ID = 'r1_0000000000000000000000';
+const attemptReservations = new WeakMap<RenderAttempt, ReservationService>();
+const matrixClaims = new WeakMap<RenderAttempt, object>();
+
+function reservations(): ReservationService {
+  return createReservationService({ now: () => 0, prepareRenderSource });
+}
+
+type TestOwner = RenderAttemptScope & {
+  admitClaimedContext(context: WinnerContext): void;
+  disposeFromNavigation(): void;
+};
+
+function owner(
+  id = ATTEMPT_ONE,
+  slot = 'fictional-slot',
+  navigationGeneration = Object.freeze({})
+): TestOwner {
+  let current = true;
+  let disposed = false;
+  let winnerContext: WinnerContext | undefined;
+  const callbacks: Array<() => void> = [];
+  const controller = new AbortController();
+  const scope = {
+    id,
+    slot,
+    generation: Object.freeze({}),
+    navigationGeneration,
+    interfaces: Object.freeze({}),
+    get disposed() {
+      return disposed;
+    },
+    get signal() {
+      return controller.signal;
+    },
+    get winnerContext() {
+      return winnerContext;
+    },
+    capture:
+      <Arguments extends readonly unknown[]>(callback: (...arguments_: Arguments) => unknown) =>
+      (...arguments_: Arguments): boolean => {
+        if (!scope.isCurrent()) return false;
+        callback(...arguments_);
+        return true;
+      },
+    isCurrent: () => current && !disposed,
+    prepareWinnerContext: (context: WinnerContext) => {
+      if (!scope.isCurrent()) return undefined;
+      const previous = winnerContext;
+      if (previous !== undefined && previous !== context) return undefined;
+      let committed = false;
+      return Object.freeze({
+        commit: () => {
+          if (committed) return winnerContext === context;
+          if (!scope.isCurrent() || winnerContext !== previous) return false;
+          winnerContext = context;
+          committed = true;
+          return true;
+        },
+        rollback: () => {
+          if (committed && previous === undefined && winnerContext === context) {
+            winnerContext = undefined;
+          }
+          committed = false;
+          return winnerContext === previous;
+        },
+      });
+    },
+    onDispose: (_kind: string, callback: () => void) => {
+      callbacks.push(callback);
+    },
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      controller.abort();
+      for (let index = callbacks.length - 1; index >= 0; index -= 1) callbacks[index]?.();
+    },
+    disposeFromNavigation: () => {
+      current = false;
+      scope.dispose();
+    },
+    admitClaimedContext: (context: WinnerContext) => {
+      winnerContext = context;
+    },
+  } satisfies TestOwner;
+  return scope;
+}
+
+function artifact(
+  render: Pick<RenderAttemptScope, 'id' | 'slot' | 'navigationGeneration'>,
+  kind: CommittedRenderArtifact['kind'] = 'direct_iframe'
+): CommittedRenderArtifact & { dispose: ReturnType<typeof vi.fn> } {
+  return Object.freeze({
+    kind,
+    attemptId: render.id,
+    slot: render.slot,
+    navigationGeneration: render.navigationGeneration,
+    dispose: vi.fn(),
+  });
+}
+
+function apsArtifactBinding() {
+  return Object.freeze({
+    commit: vi.fn(() => true),
+    finalize: vi.fn(),
+    isCurrent: vi.fn(() => true),
+    previousArtifact: undefined,
+    release: vi.fn(),
+    rollback: vi.fn(),
+  });
+}
+
+function attempt(
+  scope = owner(),
+  options: Partial<Parameters<typeof createRenderAttempt>[0]> = {}
+): RenderAttempt {
+  const reservationService = options.reservations ?? reservations();
+  const result = createRenderAttempt({
+    artifacts: options.artifacts ?? createCommittedArtifactStore(),
+    owner: scope,
+    prepareRenderSource: options.prepareRenderSource ?? prepareRenderSource,
+    reservations: reservationService,
+    ...(options.parentAttemptId === undefined ? {} : { parentAttemptId: options.parentAttemptId }),
+    ...(options.publishDiagnostics === undefined
+      ? {}
+      : { publishDiagnostics: options.publishDiagnostics }),
+    ...(options.scheduler === undefined ? {} : { scheduler: options.scheduler }),
+  });
+  expect(result).toMatchObject({ ok: true });
+  if (!result.ok) throw new Error('should create an attempt');
+  attemptReservations.set(result.value, reservationService);
+  return result.value;
+}
+
+function rendererPort() {
+  return Object.freeze({ close: vi.fn() });
+}
+
+function browserMessagePort() {
+  const listeners = new Set<(event: unknown) => void>();
+  const messageErrorListeners = new Set<(event: unknown) => void>();
+  return {
+    addEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      (type === 'messageerror' ? messageErrorListeners : listeners).add(listener);
+    }),
+    close: vi.fn(),
+    emit(data: unknown): void {
+      for (const listener of listeners) listener({ data });
+    },
+    emitError(): void {
+      for (const listener of messageErrorListeners) listener({});
+    },
+    postMessage: vi.fn(),
+    removeEventListener: vi.fn((type: string, listener: (event: unknown) => void) => {
+      (type === 'messageerror' ? messageErrorListeners : listeners).delete(listener);
+    }),
+    start: vi.fn(),
+  };
+}
+
+describe('APS role-separated nonce registries', () => {
+  it('owns independent 256-entry bootstrap and renderer capacities', () => {
+    let bootstrapDraw = 0;
+    let rendererDraw = 0;
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () =>
+        Object.freeze({ ok: true as const, value: indexedBootstrapNonce(bootstrapDraw++) }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () =>
+        Object.freeze({ ok: true as const, value: indexedRendererNonce(rendererDraw++) }),
+    });
+    for (let index = 0; index < 256; index += 1) {
+      const render = attempt(owner(indexedAttemptId(index), `slot-${index}`));
+      expect(bootstraps.issue({ attempt: render })).toMatchObject({ ok: true });
+      expect(renderers.issue({ attempt: render })).toMatchObject({ ok: true });
+    }
+    const overflow = attempt(owner(indexedAttemptId(999), 'slot-overflow'));
+    expect(bootstraps.issue({ attempt: overflow })).toEqual({
+      ok: false,
+      reason: 'capability_registry_full',
+    });
+    expect(renderers.issue({ attempt: overflow })).toEqual({
+      ok: false,
+      reason: 'capability_registry_full',
+    });
+    expect(bootstraps.snapshotForTest()).toMatchObject({ bindings: 256, liveNonces: 256 });
+    expect(renderers.snapshotForTest()).toMatchObject({ bindings: 256, liveNonces: 256 });
+  });
+
+  it('rejects crossed roles and binds a deferred source/port exactly once', () => {
+    const render = attempt();
+    const bootstrapNonce = indexedBootstrapNonce(1);
+    const port = rendererPort();
+    const source = Object.freeze({ outer: true });
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: bootstrapNonce }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: bootstrapNonce }),
+    });
+
+    expect(bootstraps.issue({ attempt: render })).toEqual({ ok: true, nonce: bootstrapNonce });
+    expect(renderers.issue({ attempt: render })).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    const expectation = Object.freeze({
+      nonce: bootstrapNonce,
+      attempt: render,
+      generation: render.generation,
+      source,
+      port,
+    });
+    expect(bootstraps.bindSource(expectation)).toBe(true);
+    expect(bootstraps.bindSource(expectation)).toBe(false);
+    expect(bootstraps.consume(expectation)).toBe(true);
+    expect(bootstraps.consume(expectation)).toBe(false);
+    expect(port.close).not.toHaveBeenCalled();
+    expect(render.fail('internal_error')).toBe(true);
+    expect(port.close).toHaveBeenCalledOnce();
+  });
+
+  it('exhausts bootstrap collisions after exactly eight draws', () => {
+    const collision = indexedBootstrapNonce(1);
+    const mintNonce = vi.fn(() => Object.freeze({ ok: true as const, value: collision }));
+    const registry = createBootstrapNonceRegistry({ mintNonce });
+    expect(registry.issue({ attempt: attempt() })).toEqual({ ok: true, nonce: collision });
+    expect(registry.issue({ attempt: attempt(owner(indexedAttemptId(2), 'slot-2')) })).toEqual({
+      ok: false,
+      reason: 'identity_generation_failed',
+    });
+    expect(mintNonce).toHaveBeenCalledTimes(9);
+  });
+});
+
+describe('renderer nonce registry', () => {
+  it('admits exactly 256 active bindings and refuses the 257th without drawing', () => {
+    let draw = 0;
+    const mintNonce = vi.fn(() =>
+      Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) })
+    );
+    const registry = createRendererNonceRegistry({ mintNonce });
+
+    for (let index = 0; index < 257; index += 1) {
+      const render = attempt(owner(indexedAttemptId(index), `slot-${index}`));
+      const issued = registry.issue({
+        attempt: render,
+        source: Object.freeze({ index }),
+        port: rendererPort(),
+      });
+      if (index < 256) {
+        expect(issued).toEqual({ ok: true, nonce: indexedRendererNonce(index) });
+        expect(registry.snapshotForTest()).toMatchObject({
+          bindings: index + 1,
+          liveNonces: index + 1,
+        });
+      } else {
+        expect(issued).toEqual({ ok: false, reason: 'capability_registry_full' });
+      }
+    }
+    expect(mintNonce).toHaveBeenCalledTimes(256);
+  });
+
+  it('uses eight total collision draws and contains identity-source failure', () => {
+    const nonce = indexedRendererNonce(7);
+    const collisionMint = vi.fn(() => Object.freeze({ ok: true as const, value: nonce }));
+    const registry = createRendererNonceRegistry({ mintNonce: collisionMint });
+    const first = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const second = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    expect(
+      registry.issue({ attempt: first, source: Object.freeze({}), port: rendererPort() })
+    ).toEqual({ ok: true, nonce });
+    expect(
+      registry.issue({ attempt: second, source: Object.freeze({}), port: rendererPort() })
+    ).toEqual({ ok: false, reason: 'identity_generation_failed' });
+    expect(collisionMint).toHaveBeenCalledTimes(9);
+
+    const failedMint = vi.fn(() =>
+      Object.freeze({ ok: false as const, reason: 'identity_generation_failed' as const })
+    );
+    const failedRegistry = createRendererNonceRegistry({ mintNonce: failedMint });
+    expect(
+      failedRegistry.issue({
+        attempt: attempt(owner(indexedAttemptId(3), 'slot-3')),
+        source: Object.freeze({}),
+        port: rendererPort(),
+      })
+    ).toEqual({ ok: false, reason: 'identity_generation_failed' });
+    expect(failedMint).toHaveBeenCalledOnce();
+  });
+
+  it.each([
+    ['undefined', () => undefined],
+    ['null', () => null],
+    ['primitive', () => 1],
+    [
+      'accessor',
+      () =>
+        Object.freeze(
+          Object.defineProperties(
+            {},
+            {
+              ok: {
+                enumerable: true,
+                get: () => {
+                  throw new Error('sensitive issuer result');
+                },
+              },
+              value: { enumerable: true, value: indexedRendererNonce(1) },
+            }
+          )
+        ),
+    ],
+    [
+      'proxy',
+      () =>
+        new Proxy(Object.freeze({ ok: true, value: indexedRendererNonce(1) }), {
+          ownKeys: () => {
+            throw new Error('sensitive issuer proxy');
+          },
+        }),
+    ],
+    [
+      'malformed success',
+      () => Object.freeze({ ok: true, value: indexedRendererNonce(1), unexpected: true }),
+    ],
+    ['malformed failure', () => Object.freeze({ ok: false, reason: 'different_failure' })],
+  ])('fails closed for a hostile %s issuer result', (_label, hostileResult) => {
+    const registry = createRendererNonceRegistry({
+      mintNonce: hostileResult as never,
+    });
+    let result: unknown;
+    expect(() => {
+      result = registry.issue({
+        attempt: attempt(owner(indexedAttemptId(9), 'slot-9')),
+        source: Object.freeze({}),
+        port: rendererPort(),
+      });
+    }).not.toThrow();
+    expect(result).toEqual({ ok: false, reason: 'identity_generation_failed' });
+  });
+
+  it('consumes once only for the exact nonce, source, port, attempt, and generation', () => {
+    const nonce = indexedRendererNonce(1);
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: nonce }),
+    });
+    const render = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const other = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    const source = Object.freeze({});
+    const port = rendererPort();
+    expect(registry.issue({ attempt: render, source, port })).toEqual({ ok: true, nonce });
+
+    expect(
+      registry.consume({
+        nonce: indexedRendererNonce(2),
+        attempt: render,
+        generation: render.generation,
+        source,
+        port,
+      })
+    ).toBe(false);
+    expect(
+      registry.consume({
+        nonce,
+        attempt: other,
+        generation: render.generation,
+        source,
+        port,
+      })
+    ).toBe(false);
+    expect(
+      registry.consume({
+        nonce,
+        attempt: render,
+        generation: Object.freeze({}),
+        source,
+        port,
+      })
+    ).toBe(false);
+    expect(
+      registry.consume({
+        nonce,
+        attempt: render,
+        generation: render.generation,
+        source: Object.freeze({}),
+        port,
+      })
+    ).toBe(false);
+    expect(
+      registry.consume({
+        nonce,
+        attempt: render,
+        generation: render.generation,
+        source,
+        port: rendererPort(),
+      })
+    ).toBe(false);
+    const exact = { nonce, attempt: render, generation: render.generation, source, port };
+    expect(registry.consume(exact)).toBe(true);
+    expect(registry.consume(exact)).toBe(false);
+    expect(registry.snapshotForTest()).toMatchObject({ bindings: 1, liveNonces: 0 });
+    expect(port.close).not.toHaveBeenCalled();
+  });
+
+  it('issues before insertion and binds exactly one later renderer source before consumption', () => {
+    const nonce = indexedRendererNonce(1);
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: nonce }),
+    });
+    const render = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const other = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    const port = rendererPort();
+    const source = Object.freeze({ window: true });
+    const wrongSource = Object.freeze({ window: false });
+    expect(registry.issue({ attempt: render, port })).toEqual({ ok: true, nonce });
+    const exact = Object.freeze({
+      nonce,
+      attempt: render,
+      generation: render.generation,
+      source,
+      port,
+    });
+
+    expect(registry.consume(exact)).toBe(false);
+    expect(registry.bindSource(Object.freeze({ ...exact, nonce: indexedRendererNonce(2) }))).toBe(
+      false
+    );
+    expect(registry.bindSource(Object.freeze({ ...exact, attempt: other }))).toBe(false);
+    expect(registry.bindSource(Object.freeze({ ...exact, generation: Object.freeze({}) }))).toBe(
+      false
+    );
+    expect(registry.bindSource(Object.freeze({ ...exact, source: wrongSource }))).toBe(true);
+    expect(registry.bindSource(exact)).toBe(false);
+    expect(registry.consume(exact)).toBe(false);
+    expect(registry.consume(Object.freeze({ ...exact, source: wrongSource }))).toBe(true);
+    expect(registry.consume(Object.freeze({ ...exact, source: wrongSource }))).toBe(false);
+  });
+
+  it('cannot bind a deferred renderer source after attempt or registry disposal', () => {
+    let draw = 0;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) }),
+    });
+    const settled = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const settledPort = rendererPort();
+    const settledIssue = registry.issue({ attempt: settled, port: settledPort });
+    if (!settledIssue.ok) throw new Error('Expected deferred binding');
+    expect(settled.fail('internal_error')).toBe(true);
+    expect(
+      registry.bindSource(
+        Object.freeze({
+          nonce: settledIssue.nonce,
+          attempt: settled,
+          generation: settled.generation,
+          source: Object.freeze({}),
+          port: settledPort,
+        })
+      )
+    ).toBe(false);
+    expect(settledPort.close).toHaveBeenCalledOnce();
+
+    const disposed = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    const disposedPort = rendererPort();
+    const disposedIssue = registry.issue({ attempt: disposed, port: disposedPort });
+    if (!disposedIssue.ok) throw new Error('Expected deferred binding');
+    registry.dispose();
+    expect(
+      registry.bindSource(
+        Object.freeze({
+          nonce: disposedIssue.nonce,
+          attempt: disposed,
+          generation: disposed.generation,
+          source: Object.freeze({}),
+          port: disposedPort,
+        })
+      )
+    ).toBe(false);
+    expect(disposedPort.close).toHaveBeenCalledOnce();
+  });
+
+  it('lets exactly one nested deferred source bind win before a hostile outer replay', () => {
+    const nonce = indexedRendererNonce(1);
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: nonce }),
+    });
+    const render = attempt();
+    const port = rendererPort();
+    const nestedSource = Object.freeze({ nested: true });
+    const outerSource = Object.freeze({ outer: true });
+    expect(registry.issue({ attempt: render, port })).toEqual({ ok: true, nonce });
+    const nestedExpectation = Object.freeze({
+      nonce,
+      attempt: render,
+      generation: render.generation,
+      source: nestedSource,
+      port,
+    });
+    const outerExpectation = Object.freeze({
+      nonce,
+      attempt: render,
+      generation: render.generation,
+      source: outerSource,
+      port,
+    });
+    let nested: boolean | undefined;
+    let reentered = false;
+    const replay = new Proxy(outerExpectation, {
+      ownKeys: (target) => {
+        if (!reentered) {
+          reentered = true;
+          nested = registry.bindSource(nestedExpectation);
+        }
+        return Reflect.ownKeys(target);
+      },
+    });
+
+    expect(registry.bindSource(replay)).toBe(false);
+    expect(nested).toBe(true);
+    expect(registry.consume(outerExpectation)).toBe(false);
+    expect(registry.consume(nestedExpectation)).toBe(true);
+  });
+
+  it('rejects cross-attempt retained-port reuse without taking failed-issue ownership', () => {
+    let draw = 0;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) }),
+    });
+    const port = rendererPort();
+    const first = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const second = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    expect(registry.issue({ attempt: first, source: Object.freeze({}), port })).toMatchObject({
+      ok: true,
+    });
+    expect(registry.issue({ attempt: second, source: Object.freeze({}), port })).toEqual({
+      ok: false,
+      reason: 'invalid_attempt',
+    });
+    expect(port.close).not.toHaveBeenCalled();
+    expect(second.fail('internal_error')).toBe(true);
+    expect(port.close).not.toHaveBeenCalled();
+    expect(first.fail('internal_error')).toBe(true);
+    expect(port.close).toHaveBeenCalledOnce();
+    expect(
+      registry.issue({
+        attempt: attempt(owner(indexedAttemptId(3), 'slot-3')),
+        source: Object.freeze({}),
+        port,
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+    registry.dispose();
+    expect(port.close).toHaveBeenCalledOnce();
+  });
+
+  it('retires a transferred port before close can reenter issuance', () => {
+    let draw = 0;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) }),
+    });
+    const first = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const second = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    let nested: unknown;
+    const port = Object.freeze({
+      close: vi.fn(() => {
+        nested = registry.issue({ attempt: second, source: Object.freeze({}), port });
+      }),
+    });
+    expect(registry.issue({ attempt: first, source: Object.freeze({}), port })).toMatchObject({
+      ok: true,
+    });
+    expect(first.fail('internal_error')).toBe(true);
+    expect(nested).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(port.close).toHaveBeenCalledOnce();
+  });
+
+  it('makes branded settlement registration and revalidation intrinsic under prototype mutation', () => {
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(1) }),
+    });
+    const render = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    let closes = 0;
+    const port = Object.freeze({
+      close: () => {
+        closes += 1;
+      },
+    });
+    const nativePush = Array.prototype.push;
+    const nativeSlice = Array.prototype.slice;
+    let poisonCalls = 0;
+    const push = vi.spyOn(Array.prototype, 'push').mockImplementation(function (
+      this: unknown[],
+      ...values
+    ) {
+      poisonCalls += 1;
+      Reflect.apply(nativePush, this, values);
+      throw new Error('hostile observer registration');
+    });
+    let sliceCalls = 0;
+    const slice = vi.spyOn(Array.prototype, 'slice').mockImplementation(function (
+      this: unknown[],
+      start?: number,
+      end?: number
+    ) {
+      sliceCalls += 1;
+      const result = Reflect.apply(nativeSlice, this, [start, end]);
+      if (sliceCalls >= 4) throw new Error('hostile post-registration snapshot');
+      return result;
+    });
+    let issued: unknown;
+    try {
+      issued = registry.issue({ attempt: render, source: Object.freeze({}), port });
+    } finally {
+      slice.mockRestore();
+      push.mockRestore();
+    }
+    expect(poisonCalls).toBe(0);
+    expect(sliceCalls).toBe(0);
+    expect(issued).toEqual({ ok: true, nonce: indexedRendererNonce(1) });
+    expect(closes).toBe(0);
+    expect(render.fail('internal_error')).toBe(true);
+    expect(closes).toBe(1);
+  });
+
+  it('drains terminal observers intrinsically before prototype splice can throw', () => {
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(1) }),
+    });
+    const render = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    let closes = 0;
+    const port = Object.freeze({
+      close: () => {
+        closes += 1;
+      },
+    });
+    expect(registry.issue({ attempt: render, source: Object.freeze({}), port })).toMatchObject({
+      ok: true,
+    });
+    const nativeSplice = Array.prototype.splice;
+    let spliceCalls = 0;
+    const splice = vi.spyOn(Array.prototype, 'splice').mockImplementation(function (
+      this: unknown[],
+      start: number,
+      deleteCount?: number
+    ) {
+      spliceCalls += 1;
+      Reflect.apply(nativeSplice, this, [start, deleteCount]);
+      throw new Error('hostile terminal observer drain');
+    });
+    let iteratorCalls = 0;
+    const iterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    Object.defineProperty(Array.prototype, Symbol.iterator, {
+      configurable: true,
+      writable: true,
+      value: () => {
+        iteratorCalls += 1;
+        throw new Error('hostile terminal observer iteration');
+      },
+    });
+    let settled: boolean | undefined;
+    let thrown: unknown;
+    try {
+      settled = render.fail('internal_error');
+    } catch (error) {
+      thrown = error;
+    } finally {
+      if (iterator) Object.defineProperty(Array.prototype, Symbol.iterator, iterator);
+      splice.mockRestore();
+    }
+    expect(thrown).toBeUndefined();
+    expect(settled).toBe(true);
+    expect(spliceCalls).toBe(0);
+    expect(iteratorCalls).toBe(0);
+    expect(closes).toBe(1);
+  });
+
+  it('binds pending and live issuance to the exact issued attempt generation', () => {
+    let draw = 0;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) }),
+    });
+    const sharedOwner = owner(indexedAttemptId(1), 'slot-1');
+    const first = attempt(sharedOwner);
+    const second = attempt(sharedOwner);
+    const secondPort = rendererPort();
+    expect(
+      registry.issue({ attempt: first, source: Object.freeze({}), port: rendererPort() })
+    ).toMatchObject({ ok: true });
+    expect(
+      registry.issue({ attempt: second, source: Object.freeze({}), port: secondPort })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(secondPort.close).not.toHaveBeenCalled();
+
+    const nestedOwner = owner(indexedAttemptId(2), 'slot-2');
+    const outer = attempt(nestedOwner);
+    const inner = attempt(nestedOwner);
+    const innerPort = rendererPort();
+    let nested: unknown;
+    let recurse = true;
+    const reentrantRegistry = createRendererNonceRegistry({
+      mintNonce: () => {
+        if (recurse) {
+          recurse = false;
+          nested = reentrantRegistry.issue({
+            attempt: inner,
+            source: Object.freeze({}),
+            port: innerPort,
+          });
+        }
+        return Object.freeze({ ok: true as const, value: indexedRendererNonce(9) });
+      },
+    });
+    expect(
+      reentrantRegistry.issue({
+        attempt: outer,
+        source: Object.freeze({}),
+        port: rendererPort(),
+      })
+    ).toMatchObject({ ok: true });
+    expect(nested).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(innerPort.close).not.toHaveBeenCalled();
+  });
+
+  it('cannot publish after the issuer reentrantly disposes the registry', () => {
+    const port = rendererPort();
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => {
+        registry.dispose();
+        return Object.freeze({ ok: true as const, value: indexedRendererNonce(1) });
+      },
+    });
+    const issued = registry.issue({
+      attempt: attempt(owner(indexedAttemptId(1), 'slot-1')),
+      source: Object.freeze({}),
+      port,
+    });
+    expect(issued).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(issued).not.toHaveProperty('nonce');
+    expect(port.close).not.toHaveBeenCalled();
+    expect(registry.snapshotForTest()).toEqual({
+      bindings: 0,
+      disposed: true,
+      liveNonces: 0,
+    });
+  });
+
+  it('reserves attempt and capacity before invoking a reentrant issuer', () => {
+    let draw = 0;
+    let reenter: (() => void) | undefined;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => {
+        const callback = reenter;
+        reenter = undefined;
+        callback?.();
+        return Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) });
+      },
+    });
+
+    for (let index = 0; index < 255; index += 1) {
+      expect(
+        registry.issue({
+          attempt: attempt(owner(indexedAttemptId(index), `slot-${index}`)),
+          source: Object.freeze({}),
+          port: rendererPort(),
+        })
+      ).toMatchObject({ ok: true });
+    }
+    const outerAttempt = attempt(owner(indexedAttemptId(255), 'slot-255'));
+    const innerAttempt = attempt(owner(indexedAttemptId(256), 'slot-256'));
+    let nestedCapacity: unknown;
+    reenter = () => {
+      nestedCapacity = registry.issue({
+        attempt: innerAttempt,
+        source: Object.freeze({}),
+        port: rendererPort(),
+      });
+    };
+    expect(
+      registry.issue({
+        attempt: outerAttempt,
+        source: Object.freeze({}),
+        port: rendererPort(),
+      })
+    ).toMatchObject({ ok: true });
+    expect(nestedCapacity).toEqual({ ok: false, reason: 'capability_registry_full' });
+    expect(registry.snapshotForTest()).toMatchObject({ bindings: 256, liveNonces: 256 });
+
+    const sameAttempt = attempt(owner(indexedAttemptId(999), 'slot-999'));
+    const sameInput = {
+      attempt: sameAttempt,
+      source: Object.freeze({}),
+      port: rendererPort(),
+    };
+    let nestedSameAttempt: unknown;
+    let recurse = true;
+    const sameAttemptRegistry = createRendererNonceRegistry({
+      mintNonce: () => {
+        if (recurse) {
+          recurse = false;
+          nestedSameAttempt = sameAttemptRegistry.issue(sameInput);
+        }
+        return Object.freeze({ ok: true as const, value: indexedRendererNonce(998) });
+      },
+    });
+    expect(sameAttemptRegistry.issue(sameInput)).toMatchObject({ ok: true });
+    expect(nestedSameAttempt).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(sameAttemptRegistry.snapshotForTest()).toMatchObject({ bindings: 1, liveNonces: 1 });
+  });
+
+  it('lets exactly one nested exact consume win before a hostile outer replay', () => {
+    const nonce = indexedRendererNonce(1);
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: nonce }),
+    });
+    const render = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const source = Object.freeze({});
+    const port = rendererPort();
+    expect(registry.issue({ attempt: render, source, port })).toEqual({ ok: true, nonce });
+    const exact = Object.freeze({
+      nonce,
+      attempt: render,
+      generation: render.generation,
+      source,
+      port,
+    });
+    let nested: boolean | undefined;
+    let reentered = false;
+    const replay = new Proxy(exact, {
+      ownKeys: (target) => {
+        if (!reentered) {
+          reentered = true;
+          nested = registry.consume(exact);
+        }
+        return Reflect.ownKeys(target);
+      },
+    });
+
+    expect(registry.consume(replay)).toBe(false);
+    expect(nested).toBe(true);
+    expect(registry.consume(exact)).toBe(false);
+  });
+
+  it('closes and removes attempt-owned bindings on settlement with no nonce history', () => {
+    const nonce = indexedRendererNonce(1);
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: nonce }),
+    });
+    const first = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const firstPort = rendererPort();
+    const firstSource = Object.freeze({});
+    expect(registry.issue({ attempt: first, source: firstSource, port: firstPort })).toEqual({
+      ok: true,
+      nonce,
+    });
+    expect(
+      registry.consume({
+        nonce,
+        attempt: first,
+        generation: first.generation,
+        source: firstSource,
+        port: firstPort,
+      })
+    ).toBe(true);
+    expect(
+      registry.issue({ attempt: first, source: Object.freeze({}), port: rendererPort() })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(first.fail('internal_error')).toBe(true);
+    expect(first.fail('internal_error')).toBe(false);
+    expect(firstPort.close).toHaveBeenCalledOnce();
+    expect(registry.snapshotForTest()).toEqual({
+      bindings: 0,
+      disposed: false,
+      liveNonces: 0,
+    });
+
+    const second = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    expect(
+      registry.issue({ attempt: second, source: Object.freeze({}), port: rendererPort() })
+    ).toEqual({ ok: true, nonce });
+    expect(
+      registry.issue({ attempt: second, source: Object.freeze({}), port: rendererPort() })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+  });
+
+  it('disposes live and consumed runtime bindings exactly once and remains terminal', () => {
+    let draw = 0;
+    const registry = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(draw++) }),
+    });
+    const live = attempt(owner(indexedAttemptId(1), 'slot-1'));
+    const consumed = attempt(owner(indexedAttemptId(2), 'slot-2'));
+    const liveSource = Object.freeze({ live: true });
+    const consumedSource = Object.freeze({ consumed: true });
+    let liveCloses = 0;
+    let consumedCloses = 0;
+    const livePort = Object.freeze({ close: () => (liveCloses += 1) });
+    const consumedPort = Object.freeze({ close: () => (consumedCloses += 1) });
+    const liveIssue = registry.issue({ attempt: live, source: liveSource, port: livePort });
+    const consumedIssue = registry.issue({
+      attempt: consumed,
+      source: consumedSource,
+      port: consumedPort,
+    });
+    if (!liveIssue.ok || !consumedIssue.ok) throw new Error('Expected nonce bindings');
+    const consumedExpectation = Object.freeze({
+      nonce: consumedIssue.nonce,
+      attempt: consumed,
+      generation: consumed.generation,
+      source: consumedSource,
+      port: consumedPort,
+    });
+    expect(registry.consume(consumedExpectation)).toBe(true);
+
+    const iterator = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    let iteratorCalls = 0;
+    Object.defineProperty(Array.prototype, Symbol.iterator, {
+      configurable: true,
+      writable: true,
+      value: () => {
+        iteratorCalls += 1;
+        throw new Error('hostile registry disposal iteration');
+      },
+    });
+    let disposeError: unknown;
+    try {
+      registry.dispose();
+    } catch (error) {
+      disposeError = error;
+    } finally {
+      if (iterator) Object.defineProperty(Array.prototype, Symbol.iterator, iterator);
+    }
+    expect(disposeError).toBeUndefined();
+    expect(iteratorCalls).toBe(0);
+    expect(liveCloses).toBe(1);
+    expect(consumedCloses).toBe(1);
+    expect(registry.snapshotForTest()).toEqual({
+      bindings: 0,
+      disposed: true,
+      liveNonces: 0,
+    });
+    registry.dispose();
+    expect(live.fail('internal_error')).toBe(true);
+    expect(consumed.fail('internal_error')).toBe(true);
+    expect(liveCloses).toBe(1);
+    expect(consumedCloses).toBe(1);
+    expect(registry.consume(consumedExpectation)).toBe(false);
+
+    const rejectedPort = rendererPort();
+    expect(
+      registry.issue({
+        attempt: attempt(owner(indexedAttemptId(3), 'slot-3')),
+        source: Object.freeze({}),
+        port: rejectedPort,
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(rejectedPort.close).not.toHaveBeenCalled();
+  });
+});
+
+describe('direct APS attempt rendering', () => {
+  it('mounts only the bootstrap frame before completing the exact three-phase handoff', () => {
+    vi.useFakeTimers();
+    document.body.innerHTML = '<div id="fictional-slot"><span>placeholder</span></div>';
+    const render = attempt();
+    expect(render.admitDirectWinner(DIRECT_APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const bootstrapNonce = indexedBootstrapNonce(1);
+    const rendererNonce = indexedRendererNonce(1);
+    let captureListener: ((event: MessageEvent) => void) | undefined;
+    const target = {
+      addEventListener: vi.fn(
+        (_type: 'message', listener: (event: MessageEvent) => void, _capture: true) => {
+          captureListener = listener;
+        }
+      ),
+      removeEventListener: vi.fn(),
+    };
+    const messaging = createBrowserMessagingAdapter(target);
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: bootstrapNonce }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: rendererNonce }),
+    });
+    const rendererPort = browserMessagePort();
+
+    try {
+      expect(
+        renderDirectApsAttempt({
+          attempt: render,
+          bindArtifactGuard: bindCommittedArtifactGuard,
+          bootstrapNonces: bootstraps,
+          container: document.getElementById('fictional-slot')!,
+          messaging,
+          nonces: renderers,
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      const frame = document.querySelector<HTMLIFrameElement>('#fictional-slot iframe')!;
+      const source = frame.contentWindow!;
+      const postMessage = vi.spyOn(source, 'postMessage');
+      expect(frame.getAttribute('src')).toBe(
+        `${window.location.origin}${APS_RENDERER_V2_PATH}#${bootstrapNonce}`
+      );
+      expect(frame.getAttribute('sandbox')).toBe(APS_RENDERER_SANDBOX);
+      expect(document.querySelectorAll('#fictional-slot iframe')).toHaveLength(1);
+      expect(captureListener).toBeTypeOf('function');
+      expect(rendererPort.postMessage).not.toHaveBeenCalled();
+
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce,
+        }),
+        origin: 'null',
+        ports: [],
+        source,
+      } as unknown as MessageEvent);
+      expect(frame.getAttribute('sandbox')).toBe(APS_PERMANENT_SANDBOX);
+      expect(postMessage).toHaveBeenCalledOnce();
+      const navigation = postMessage.mock.calls[0]?.[0];
+      expect(navigation).toBeTypeOf('string');
+      const parsedNavigation = JSON.parse(navigation as string) as Record<string, unknown>;
+      expect(parsedNavigation).toEqual({
+        message: 'TS APS Bootstrap Configure',
+        version: 2,
+        bootstrapNonce,
+        rendererNonce,
+        creativeOrigin: 'https://creative.example',
+        tagType: 'iframe',
+      });
+      expect(navigation).toBe(JSON.stringify(parsedNavigation));
+      expect(postMessage.mock.calls[0]?.slice(1)).toEqual(['*', []]);
+
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce,
+          rendererNonce,
+        }),
+        origin: 'null',
+        ports: [rendererPort],
+        source,
+      } as unknown as MessageEvent);
+      expect(rendererPort.postMessage).toHaveBeenCalledOnce();
+      expect(rendererPort.postMessage.mock.calls[0]?.[0]).toEqual({
+        version: 1,
+        nonce: rendererNonce,
+        publisherOrigin: window.location.origin,
+        renderer: DIRECT_APS_SOURCE,
+      });
+      rendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      expect(render.snapshot().state).toBe('waiting_for_aps_completion');
+      rendererPort.emit({
+        message: 'TS APS Runner Loaded',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      expect(render.snapshot().outcome).toBeUndefined();
+      rendererPort.emit({
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      expect(render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+      expect(document.querySelector('#fictional-slot span')).toBeNull();
+      expect(frame.isConnected).toBe(true);
+    } finally {
+      bootstraps.dispose();
+      renderers.dispose();
+      document.body.innerHTML = '';
+      vi.useRealTimers();
+    }
+  });
+
+  function directApsHarness(
+    renderOptions: Partial<Parameters<typeof createRenderAttempt>[0]> = {}
+  ) {
+    document.body.innerHTML = '<div id="fictional-slot"><span>placeholder</span></div>';
+    const render = attempt(owner(), renderOptions);
+    expect(render.admitDirectWinner(DIRECT_APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const bootstrapNonce = indexedBootstrapNonce(2);
+    const rendererNonce = indexedRendererNonce(2);
+    let captureListener: ((event: MessageEvent) => void) | undefined;
+    const target = {
+      addEventListener: vi.fn(
+        (_type: 'message', listener: (event: MessageEvent) => void, _capture: true) => {
+          captureListener = listener;
+        }
+      ),
+      removeEventListener: vi.fn(),
+    };
+    const messaging = createBrowserMessagingAdapter(target);
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: bootstrapNonce }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: rendererNonce }),
+    });
+    const rawRendererPort = browserMessagePort();
+    const container = document.getElementById('fictional-slot')!;
+    const mounted = renderDirectApsAttempt({
+      attempt: render,
+      bindArtifactGuard: bindCommittedArtifactGuard,
+      bootstrapNonces: bootstraps,
+      container,
+      messaging,
+      nonces: renderers,
+      publisherOrigin: window.location.origin,
+    });
+    const frame = container.querySelector<HTMLIFrameElement>('iframe');
+    const sourceWindow = frame?.contentWindow;
+
+    const emitGlobal = (
+      data: string,
+      ports: readonly unknown[] = [],
+      source: unknown = sourceWindow,
+      origin = 'null'
+    ): void => {
+      captureListener?.({ data, origin, ports, source } as unknown as MessageEvent);
+    };
+    const bootstrapReady = (
+      ports: readonly unknown[] = [],
+      source: unknown = sourceWindow,
+      origin = 'null'
+    ): void => {
+      emitGlobal(
+        JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce,
+        }),
+        ports,
+        source,
+        origin
+      );
+    };
+    const containerReady = (
+      ports: readonly unknown[] = [rawRendererPort],
+      source: unknown = sourceWindow,
+      origin = 'null'
+    ): void => {
+      emitGlobal(
+        JSON.stringify({
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce,
+          rendererNonce,
+        }),
+        ports,
+        source,
+        origin
+      );
+    };
+    const cleanup = (): void => {
+      if (render.snapshot().outcome === undefined) render.cancel('caller_aborted');
+      bootstraps.dispose();
+      renderers.dispose();
+      document.body.innerHTML = '';
+    };
+    return {
+      bootstrapNonce,
+      bootstrapReady,
+      bootstraps,
+      captureListener,
+      cleanup,
+      container,
+      containerReady,
+      emitGlobal,
+      frame,
+      messaging,
+      mounted,
+      rawRendererPort,
+      render,
+      rendererNonce,
+      renderers,
+      sourceWindow,
+      target,
+    };
+  }
+
+  function completeDirectApsHandshake(harness: ReturnType<typeof directApsHarness>): void {
+    harness.bootstrapReady();
+    harness.containerReady();
+  }
+
+  it('rejects noncanonical, wrong-source, wrong-origin, and wrong-port bootstrap readiness', () => {
+    vi.useFakeTimers();
+    const ignored = directApsHarness();
+    try {
+      expect(ignored.mounted).toBe(true);
+      ignored.emitGlobal(
+        JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce: ignored.bootstrapNonce,
+        }),
+        [],
+        Object.freeze({})
+      );
+      ignored.emitGlobal(
+        JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce: ignored.bootstrapNonce,
+        }),
+        [],
+        ignored.sourceWindow,
+        window.location.origin
+      );
+      ignored.emitGlobal(
+        ' {"message":"TS APS Bootstrap Ready","version":1,"bootstrapNonce":"' +
+          ignored.bootstrapNonce +
+          '"}',
+        []
+      );
+      expect(ignored.frame?.getAttribute('sandbox')).toBe(APS_RENDERER_SANDBOX);
+      expect(ignored.render.snapshot()).toMatchObject({
+        outcome: undefined,
+        state: 'waiting_for_document',
+      });
+    } finally {
+      ignored.cleanup();
+    }
+
+    const rejected = directApsHarness();
+    const unexpectedPort = browserMessagePort();
+    try {
+      rejected.bootstrapReady([unexpectedPort]);
+      expect(unexpectedPort.close).toHaveBeenCalledOnce();
+      expect(rejected.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+      expect(rejected.container.querySelector('iframe')).toBeNull();
+    } finally {
+      rejected.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it('shares one three-second deadline through bootstrap, navigation, channel, and acceptance', () => {
+    vi.useFakeTimers();
+    const noBootstrap = directApsHarness();
+    try {
+      expect(noBootstrap.mounted).toBe(true);
+      vi.advanceTimersByTime(2_999);
+      expect(noBootstrap.render.snapshot().outcome).toBeUndefined();
+      vi.advanceTimersByTime(1);
+      expect(noBootstrap.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+      expect(noBootstrap.container.querySelector('iframe')).toBeNull();
+    } finally {
+      noBootstrap.cleanup();
+    }
+
+    const noAcceptance = directApsHarness();
+    try {
+      completeDirectApsHandshake(noAcceptance);
+      vi.advanceTimersByTime(2_999);
+      expect(noAcceptance.render.snapshot().outcome).toBeUndefined();
+      vi.advanceTimersByTime(1);
+      expect(noAcceptance.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+      expect(noAcceptance.rawRendererPort.close).toHaveBeenCalledOnce();
+    } finally {
+      noAcceptance.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it('starts the sole ten-second completion deadline at document acceptance', () => {
+    vi.useFakeTimers();
+    const harness = directApsHarness();
+    try {
+      completeDirectApsHandshake(harness);
+      harness.rawRendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: harness.rendererNonce,
+      });
+      harness.rawRendererPort.emit({
+        message: 'TS APS Runner Loaded',
+        version: 1,
+        nonce: harness.rendererNonce,
+      });
+      vi.advanceTimersByTime(9_999);
+      expect(harness.render.snapshot()).toMatchObject({
+        outcome: undefined,
+        state: 'waiting_for_aps_completion',
+      });
+      vi.advanceTimersByTime(1);
+      expect(harness.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'runner_failed',
+      });
+      expect(harness.container.querySelector('iframe')).toBeNull();
+    } finally {
+      harness.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it.each([
+    ['descriptor_invalid', 'winner_not_renderable'],
+    ['runner_no_load', 'runner_no_load'],
+    ['runner_failed', 'runner_failed'],
+  ] as const)('maps renderer failure %s to %s', (wireReason, expectedReason) => {
+    vi.useFakeTimers();
+    const harness = directApsHarness();
+    try {
+      completeDirectApsHandshake(harness);
+      harness.rawRendererPort.emit({
+        message: 'TS APS Render Failed',
+        version: 1,
+        nonce: harness.rendererNonce,
+        reason: wireReason,
+      });
+      expect(harness.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: expectedReason,
+      });
+      expect(harness.container.querySelector('iframe')).toBeNull();
+    } finally {
+      harness.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it('makes frame mutation, port errors, cancellation, and late replays terminal and inert', () => {
+    vi.useFakeTimers();
+    const mutated = directApsHarness();
+    try {
+      mutated.frame?.setAttribute(
+        'src',
+        window.location.origin + APS_RENDERER_V2_PATH + '#b1_9999999999999999999999'
+      );
+      mutated.bootstrapReady();
+      expect(mutated.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+      expect(mutated.container.querySelector('iframe')).toBeNull();
+    } finally {
+      mutated.cleanup();
+    }
+
+    const errored = directApsHarness();
+    try {
+      completeDirectApsHandshake(errored);
+      errored.rawRendererPort.emitError();
+      expect(errored.render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+      expect(errored.rawRendererPort.close).toHaveBeenCalledOnce();
+    } finally {
+      errored.cleanup();
+    }
+
+    const cancelled = directApsHarness();
+    try {
+      completeDirectApsHandshake(cancelled);
+      expect(cancelled.render.cancel('caller_aborted')).toBe(true);
+      expect(cancelled.container.querySelector('iframe')).toBeNull();
+      expect(cancelled.rawRendererPort.close).toHaveBeenCalledOnce();
+      cancelled.rawRendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: cancelled.rendererNonce,
+      });
+      cancelled.rawRendererPort.emit({
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: cancelled.rendererNonce,
+      });
+      expect(cancelled.render.snapshot().outcome).toEqual({
+        outcome: 'cancelled',
+        reason: 'caller_aborted',
+      });
+      expect(cancelled.target.removeEventListener).toHaveBeenCalledOnce();
+    } finally {
+      cancelled.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it('removes only insertion-time predecessors after completion', () => {
+    vi.useFakeTimers();
+    const harness = directApsHarness();
+    const duringRender = document.createElement('div');
+    duringRender.id = 'during-render';
+    let reentrant: HTMLDivElement | undefined;
+    expect(
+      harness.render.onSettled((outcome) => {
+        if (outcome.outcome !== 'accepted') return;
+        reentrant = document.createElement('div');
+        reentrant.id = 'reentrant';
+        harness.container.appendChild(reentrant);
+      })
+    ).toBe(true);
+    try {
+      completeDirectApsHandshake(harness);
+      harness.rawRendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: harness.rendererNonce,
+      });
+      harness.container.appendChild(duringRender);
+      harness.rawRendererPort.emit({
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: harness.rendererNonce,
+      });
+      expect(harness.render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+      expect(harness.container.querySelector('span')).toBeNull();
+      expect(duringRender.parentNode).toBe(harness.container);
+      expect(reentrant?.parentNode).toBe(harness.container);
+      expect(harness.frame?.parentNode).toBe(harness.container);
+    } finally {
+      harness.cleanup();
+      vi.useRealTimers();
+    }
+  });
+
+  it('rejects invalid descriptors before nonce allocation, listener installation, or DOM mutation', () => {
+    document.body.innerHTML = '<div id="fictional-slot"></div>';
+    const render = attempt();
+    expect(render.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const target = {
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    const bootstraps = createBootstrapNonceRegistry();
+    const renderers = createRendererNonceRegistry();
+    const container = document.getElementById('fictional-slot')!;
+
+    expect(
+      renderDirectApsAttempt({
+        attempt: render,
+        bindArtifactGuard: bindCommittedArtifactGuard,
+        bootstrapNonces: bootstraps,
+        container,
+        messaging: createBrowserMessagingAdapter(target),
+        nonces: renderers,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(false);
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'winner_not_renderable',
+    });
+    expect(target.addEventListener).not.toHaveBeenCalled();
+    expect(bootstraps.snapshotForTest().bindings).toBe(0);
+    expect(renderers.snapshotForTest().bindings).toBe(0);
+    expect(container.children).toHaveLength(0);
+    bootstraps.dispose();
+    renderers.dispose();
+    document.body.innerHTML = '';
+  });
+
+  it('allows HTTPS and loopback HTTP renderer origins but rejects production HTTP', () => {
+    expect(resolveApsRendererV2Url('https://publisher.example')).toBe(
+      'https://publisher.example/integrations/aps/renderer/v2'
+    );
+    expect(resolveApsRendererV2Url('http://localhost:8080')).toBe(
+      'http://localhost:8080/integrations/aps/renderer/v2'
+    );
+    expect(resolveApsRendererV2Url('http://127.0.0.1:8080')).toBe(
+      'http://127.0.0.1:8080/integrations/aps/renderer/v2'
+    );
+    expect(resolveApsRendererV2Url('http://[::1]:8080')).toBe(
+      'http://[::1]:8080/integrations/aps/renderer/v2'
+    );
+    expect(resolveApsRendererV2Url('http://publisher.example')).toBeUndefined();
+  });
+
+  it('keeps a PUC APS overlay hidden until completion and preserves the slot host', () => {
+    document.body.innerHTML = '<div id="fictional-slot"><span>GAM content</span></div>';
+    const scope = owner();
+    const artifactStore = createCommittedArtifactStore();
+    const hostPositions = createArtifactHostPositionLeaseRegistry();
+    const render = attempt(scope, { artifacts: artifactStore });
+    expect(render.beginGamClaim()).toBe(true);
+    expect(render.admitClaimedWinner(claimed(render, scope, DIRECT_APS_SOURCE))).toBe(true);
+    expect(render.ownerClaimed()).toBe(true);
+    expect(render.ownerRegistered()).toBe(true);
+    const baseArtifact = artifact(scope, 'puc');
+    const bootstrapNonce = indexedBootstrapNonce(41);
+    const rendererNonce = indexedRendererNonce(41);
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: bootstrapNonce }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: rendererNonce }),
+    });
+    let captureListener: ((event: MessageEvent) => void) | undefined;
+    const messaging = createBrowserMessagingAdapter({
+      addEventListener: (
+        _type: 'message',
+        listener: (event: MessageEvent) => void,
+        _capture: true
+      ) => {
+        captureListener = listener;
+      },
+      removeEventListener: vi.fn(),
+    });
+    const container = document.getElementById('fictional-slot')!;
+    const rendererPort = browserMessagePort();
+    const isBindingCurrent = vi.fn(() => true);
+    const onArtifactTransferred = vi.fn();
+    const artifactBinding = apsArtifactBinding();
+
+    try {
+      expect(
+        renderPucApsAttempt({
+          attempt: render,
+          bindArtifactGuard: bindCommittedArtifactGuard,
+          baseArtifact,
+          bindArtifact: () => artifactBinding,
+          bootstrapNonces: bootstraps,
+          container,
+          hostPositions,
+          isBindingCurrent,
+          messaging,
+          nonces: renderers,
+          onArtifactTransferred,
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      const frame = container.querySelector<HTMLIFrameElement>('iframe')!;
+      const source = frame.contentWindow!;
+      expect(onArtifactTransferred).toHaveBeenCalledOnce();
+      expect(container.querySelector('span')?.textContent).toBe('GAM content');
+      expect(container.style.position).toBe('relative');
+      expect(frame.style.position).toBe('absolute');
+      expect(frame.style.visibility).toBe('hidden');
+
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce,
+        }),
+        origin: 'null',
+        ports: [],
+        source,
+      } as unknown as MessageEvent);
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce,
+          rendererNonce,
+        }),
+        origin: 'null',
+        ports: [rendererPort],
+        source,
+      } as unknown as MessageEvent);
+      rendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      rendererPort.emit({
+        message: 'TS APS Runner Loaded',
+        version: 1,
+        nonce: rendererNonce,
+      });
+      expect(frame.style.visibility).toBe('hidden');
+      rendererPort.emit({
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: rendererNonce,
+      });
+
+      expect(render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+      expect(artifactBinding.commit).toHaveBeenCalledOnce();
+      expect(artifactBinding.finalize).toHaveBeenCalledOnce();
+      expect(artifactBinding.release).not.toHaveBeenCalled();
+      expect(artifactBinding.rollback).not.toHaveBeenCalled();
+      expect(frame.style.visibility).toBe('visible');
+      expect(container.querySelector('span')?.textContent).toBe('GAM content');
+      expect(baseArtifact.dispose).not.toHaveBeenCalled();
+
+      container.style.setProperty('position', 'absolute', 'important');
+      expect(artifactStore.sweep()).toBe(1);
+      expect(frame.isConnected).toBe(false);
+      expect(container.querySelector('span')?.textContent).toBe('GAM content');
+      expect(container.style.getPropertyValue('position')).toBe('absolute');
+      expect(container.style.getPropertyPriority('position')).toBe('important');
+      expect(baseArtifact.dispose).toHaveBeenCalledOnce();
+      expect(artifactBinding.release).toHaveBeenCalledOnce();
+    } finally {
+      bootstraps.dispose();
+      renderers.dispose();
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('transfers one host-position lease across consecutive accepted PUC overlays', () => {
+    document.body.innerHTML = '<div id="fictional-slot"><span>publisher</span></div>';
+    const generation = Object.freeze({});
+    const artifactStore = createCommittedArtifactStore();
+    const hostPositions = createArtifactHostPositionLeaseRegistry();
+    const container = document.getElementById('fictional-slot')!;
+    let physicalArtifact: CommittedRenderArtifact | undefined;
+    const resources: Array<{ dispose: () => void }> = [];
+
+    const bindArtifact = (candidate: CommittedRenderArtifact) => {
+      const previousArtifact = physicalArtifact;
+      let phase: 'prepared' | 'committed' | 'finalized' | 'released' | 'rolled_back' = 'prepared';
+      return Object.freeze({
+        commit: (): boolean => {
+          if (phase !== 'prepared' || physicalArtifact !== previousArtifact) return false;
+          physicalArtifact = candidate;
+          phase = 'committed';
+          return true;
+        },
+        finalize: (): void => {
+          if (phase === 'committed') phase = 'finalized';
+        },
+        isCurrent: (): boolean =>
+          (phase === 'committed' || phase === 'finalized') && physicalArtifact === candidate,
+        previousArtifact,
+        release: (): void => {
+          if (phase === 'released' || phase === 'rolled_back') return;
+          if (physicalArtifact === candidate) {
+            physicalArtifact = phase === 'committed' ? previousArtifact : undefined;
+          }
+          phase = 'released';
+        },
+        rollback: (): void => {
+          if (phase === 'committed' && physicalArtifact === candidate) {
+            physicalArtifact = previousArtifact;
+          }
+          phase = 'rolled_back';
+        },
+      });
+    };
+
+    const mountAndComplete = (index: number): CommittedRenderArtifact => {
+      const scope = owner(indexedAttemptId(index), 'fictional-slot', generation);
+      const render = attempt(scope, { artifacts: artifactStore });
+      expect(render.beginGamClaim()).toBe(true);
+      expect(render.admitClaimedWinner(claimed(render, scope, DIRECT_APS_SOURCE))).toBe(true);
+      expect(render.ownerClaimed()).toBe(true);
+      expect(render.ownerRegistered()).toBe(true);
+      const bootstraps = createBootstrapNonceRegistry({
+        mintNonce: () => Object.freeze({ ok: true as const, value: indexedBootstrapNonce(index) }),
+      });
+      const renderers = createRendererNonceRegistry({
+        mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(index) }),
+      });
+      resources.push(bootstraps, renderers);
+      let captureListener: ((event: MessageEvent) => void) | undefined;
+      const rendererPort = browserMessagePort();
+      expect(
+        renderPucApsAttempt({
+          attempt: render,
+          baseArtifact: artifact(scope, 'puc'),
+          bindArtifact,
+          bindArtifactGuard: bindCommittedArtifactGuard,
+          bootstrapNonces: bootstraps,
+          container,
+          hostPositions,
+          isBindingCurrent: () => true,
+          messaging: createBrowserMessagingAdapter({
+            addEventListener: (
+              _type: 'message',
+              listener: (event: MessageEvent) => void,
+              _capture: true
+            ) => {
+              captureListener = listener;
+            },
+            removeEventListener: vi.fn(),
+          }),
+          nonces: renderers,
+          onArtifactTransferred: vi.fn(),
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      const frames = [...container.querySelectorAll('iframe')];
+      const frame = frames[frames.length - 1]!;
+      const source = frame.contentWindow!;
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Bootstrap Ready',
+          version: 1,
+          bootstrapNonce: indexedBootstrapNonce(index),
+        }),
+        origin: 'null',
+        ports: [],
+        source,
+      } as unknown as MessageEvent);
+      captureListener?.({
+        data: JSON.stringify({
+          message: 'TS APS Container Ready',
+          version: 1,
+          bootstrapNonce: indexedBootstrapNonce(index),
+          rendererNonce: indexedRendererNonce(index),
+        }),
+        origin: 'null',
+        ports: [rendererPort],
+        source,
+      } as unknown as MessageEvent);
+      rendererPort.emit({
+        message: 'TS APS Document Accepted',
+        version: 1,
+        nonce: indexedRendererNonce(index),
+      });
+      rendererPort.emit({
+        message: 'TS APS Render Completed',
+        version: 1,
+        nonce: indexedRendererNonce(index),
+      });
+      expect(render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+      const committed = artifactStore.current('fictional-slot');
+      expect(committed).toBe(physicalArtifact);
+      if (!committed) throw new Error('should promote the APS overlay');
+      return committed;
+    };
+
+    try {
+      const first = mountAndComplete(51);
+      expect(container.style.position).toBe('relative');
+      const second = mountAndComplete(52);
+      expect(second).not.toBe(first);
+      expect(first.dispose).toBeTypeOf('function');
+      expect(container.style.position).toBe('relative');
+      expect(container.querySelectorAll('iframe')).toHaveLength(1);
+      expect(container.querySelector('span')?.textContent).toBe('publisher');
+
+      expect(artifactStore.release(second)).toBe(true);
+      expect(container.style.position).toBe('');
+      expect(container.querySelectorAll('iframe')).toHaveLength(0);
+      expect(container.querySelector('span')?.textContent).toBe('publisher');
+    } finally {
+      for (const resource of resources) resource.dispose();
+      artifactStore.dispose();
+      document.body.innerHTML = '';
+    }
+  });
+
+  it('removes only the failed PUC overlay and compare-restores its host position', () => {
+    document.body.innerHTML = '<div id="fictional-slot"><span>publisher</span></div>';
+    const scope = owner();
+    const render = attempt(scope);
+    expect(render.beginGamClaim()).toBe(true);
+    expect(render.admitClaimedWinner(claimed(render, scope, DIRECT_APS_SOURCE))).toBe(true);
+    expect(render.ownerClaimed()).toBe(true);
+    expect(render.ownerRegistered()).toBe(true);
+    const baseArtifact = artifact(scope, 'puc');
+    const bootstraps = createBootstrapNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedBootstrapNonce(42) }),
+    });
+    const renderers = createRendererNonceRegistry({
+      mintNonce: () => Object.freeze({ ok: true as const, value: indexedRendererNonce(42) }),
+    });
+    const container = document.getElementById('fictional-slot')!;
+    const artifactBinding = apsArtifactBinding();
+    const hostPositions = createArtifactHostPositionLeaseRegistry();
+
+    try {
+      expect(
+        renderPucApsAttempt({
+          attempt: render,
+          bindArtifactGuard: bindCommittedArtifactGuard,
+          baseArtifact,
+          bindArtifact: () => artifactBinding,
+          bootstrapNonces: bootstraps,
+          container,
+          hostPositions,
+          isBindingCurrent: () => true,
+          messaging: createBrowserMessagingAdapter({
+            addEventListener: vi.fn(),
+            removeEventListener: vi.fn(),
+          }),
+          nonces: renderers,
+          onArtifactTransferred: vi.fn(),
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      expect(container.style.position).toBe('relative');
+      expect(render.fail('runner_failed')).toBe(true);
+      expect(container.querySelector('iframe')).toBeNull();
+      expect(container.querySelector('span')?.textContent).toBe('publisher');
+      expect(container.style.position).toBe('');
+      expect(baseArtifact.dispose).toHaveBeenCalledOnce();
+      expect(artifactBinding.commit).not.toHaveBeenCalled();
+      expect(artifactBinding.finalize).not.toHaveBeenCalled();
+      expect(artifactBinding.release).toHaveBeenCalledOnce();
+    } finally {
+      bootstraps.dispose();
+      renderers.dispose();
+      document.body.innerHTML = '';
+    }
+  });
+});
+
+function claimed(
+  render: RenderAttempt,
+  scope: TestOwner,
+  source: ReservationRenderSource
+): Extract<ReservationClaimResult, { claimed: true }> {
+  const service = attemptReservations.get(render);
+  if (!service) throw new Error('should own a reservation service');
+  const registered = service.registerRender({
+    reservationId: RESERVATION_ID,
+    slot: scope.slot,
+    navigation: {
+      generation: scope.navigationGeneration,
+      isCurrent: scope.isCurrent,
+      onDispose: scope.onDispose,
+    },
+    attemptId: scope.id,
+    renderSource: source,
+    winnerContext: WINNER_CONTEXT,
+  });
+  if (!registered.ok) throw new Error('should register a render reservation');
+  const result = service.claim({
+    reservationId: RESERVATION_ID,
+    slot: scope.slot,
+    navigationGeneration: scope.navigationGeneration,
+    attempt: scope,
+    pucSource: Object.freeze({}),
+  });
+  if (!result.recognized || !result.claimed) throw new Error('should claim a reservation');
+  return result;
+}
+
+function slotOperation(options: SlotOperationOptions): SlotOperation {
+  const result = createSlotOperation(options);
+  expect(result).toMatchObject({ ok: true });
+  if (!result.ok) throw new Error('should create a slot operation');
+  return result.value;
+}
+
+describe('direct ADM attempt rendering', () => {
+  it('accepts the exact intended srcdoc and promotes its iframe artifact', () => {
+    document.body.innerHTML = '<div id="fictional-slot"><span>placeholder</span></div>';
+    const artifacts = createCommittedArtifactStore();
+    const render = attempt(owner(), { artifacts });
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const container = document.getElementById('fictional-slot')!;
+
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(true);
+    expect(render.snapshot()).toMatchObject({ outcome: undefined, state: 'waiting_for_adm' });
+    const frame = container.querySelector('iframe');
+    expect(frame).not.toBeNull();
+    expect(frame?.srcdoc).toContain('fictional creative');
+    expect(frame?.hasAttribute('src')).toBe(false);
+    expect(container.querySelector('span')).not.toBeNull();
+
+    frame?.dispatchEvent(new Event('load'));
+    expect(render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+    expect(container.querySelector('span')).toBeNull();
+    expect(container.querySelector('iframe')).toBe(frame);
+    expect(artifacts.current('fictional-slot')).toMatchObject({
+      attemptId: render.id,
+      kind: 'direct_iframe',
+    });
+
+    artifacts.dispose();
+    expect(frame?.isConnected).toBe(false);
+    document.body.innerHTML = '';
+  });
+
+  it('commits predecessors despite settlement-time iterator poisoning', () => {
+    document.body.innerHTML = '<div id="fictional-slot"><span>placeholder</span></div>';
+    const container = document.getElementById('fictional-slot')!;
+    const predecessor = container.querySelector('span');
+    const render = attempt();
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const iteratorDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    const nativeIterator = Array.prototype[Symbol.iterator];
+    let ownedIteratorCalls = 0;
+    expect(iteratorDescriptor).toBeDefined();
+    expect(
+      render.onSettled(() => {
+        Object.defineProperty(Array.prototype, Symbol.iterator, {
+          ...iteratorDescriptor,
+          value: function (this: unknown[]) {
+            const first = this[0];
+            const isAttributeTuple =
+              this.length === 2 &&
+              typeof first === 'string' &&
+              (first === 'sandbox' ||
+                first === 'referrerpolicy' ||
+                first === 'width' ||
+                first === 'height' ||
+                first === 'scrolling' ||
+                first === 'frameborder' ||
+                first === 'marginwidth' ||
+                first === 'marginheight' ||
+                first === 'title' ||
+                first === 'aria-label' ||
+                first === 'style');
+            const isAttributeList =
+              this.length === 11 && Array.isArray(first) && first[0] === 'sandbox';
+            const isPredecessorSnapshot = this.length === 1 && first === predecessor;
+            if (isAttributeTuple || isAttributeList || isPredecessorSnapshot) {
+              ownedIteratorCalls += 1;
+              throw new Error('hostile owned-array iterator');
+            }
+            return Reflect.apply(nativeIterator, this, []);
+          },
+        });
+      })
+    ).toBe(true);
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(true);
+    const frame = container.querySelector('iframe');
+    expect(frame).not.toBeNull();
+
+    try {
+      frame?.dispatchEvent(new Event('load'));
+    } finally {
+      if (iteratorDescriptor) {
+        Object.defineProperty(Array.prototype, Symbol.iterator, iteratorDescriptor);
+      }
+    }
+
+    expect(render.snapshot().outcome).toEqual({ outcome: 'accepted' });
+    expect(ownedIteratorCalls).toBe(0);
+    expect(predecessor?.isConnected).toBe(false);
+    expect(frame?.isConnected).toBe(true);
+    document.body.innerHTML = '';
+  });
+
+  it.each(['property', 'append', 'current', 'activate'] as const)(
+    'contains a throwing ADM handle %s phase and disposes its exact frame',
+    (phase) => {
+      document.body.innerHTML = '<div id="fictional-slot"></div>';
+      const container = document.getElementById('fictional-slot')!;
+      const render = attempt();
+      expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+      let underlying: DirectAdmIframeHandle | undefined;
+      const prepareIframe: DirectAdmIframeConstructor = (options) => {
+        underlying = prepareAdmIframe(options);
+        if (!underlying) return undefined;
+        if (phase === 'property') {
+          return new Proxy(underlying, {
+            get(target, property, receiver) {
+              if (property === 'append') throw new Error('hostile append property');
+              return Reflect.get(target, property, receiver);
+            },
+          });
+        }
+        return Object.freeze({
+          frame: underlying.frame,
+          append: () => {
+            const appended = underlying?.append() === true;
+            if (phase === 'append') throw new Error('hostile append');
+            return appended;
+          },
+          activate: () => {
+            const activated = underlying?.activate() === true;
+            if (phase === 'activate') throw new Error('hostile activate');
+            return activated;
+          },
+          commit: () => underlying?.commit() === true,
+          current: () => {
+            if (phase === 'current') throw new Error('hostile current');
+            return underlying?.current() === true;
+          },
+          dispose: () => underlying?.dispose(),
+        });
+      };
+
+      expect(() =>
+        renderDirectAdmAttempt({
+          attempt: render,
+          container,
+          prepareIframe,
+          publisherOrigin: window.location.origin,
+        })
+      ).not.toThrow();
+      expect(render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'adm_document_no_load',
+      });
+      expect(container.querySelector('iframe')).toBeNull();
+      expect(underlying?.append()).toBe(false);
+      document.body.innerHTML = '';
+    }
+  );
+
+  it('rejects a non-publisher creative origin before inserting a frame', () => {
+    document.body.innerHTML = '<div id="fictional-slot"></div>';
+    const render = attempt();
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const container = document.getElementById('fictional-slot')!;
+
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: 'https://not-the-publisher.example',
+      })
+    ).toBe(false);
+    expect(container.querySelector('iframe')).toBeNull();
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'winner_not_renderable',
+    });
+    document.body.innerHTML = '';
+  });
+
+  it('anchors the five-second deadline after inserting a complete srcdoc frame', () => {
+    document.body.innerHTML = '<div id="fictional-slot"></div>';
+    const render = attempt(owner(), {
+      scheduler: Object.freeze({
+        clear: vi.fn(),
+        set: (callback: () => void) => {
+          callback();
+          return Object.freeze({});
+        },
+      }),
+    });
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const container = document.getElementById('fictional-slot')!;
+    const observer = new MutationObserver(() => undefined);
+    observer.observe(container, { childList: true });
+
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(false);
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'adm_document_no_load',
+    });
+    const mutations = observer.takeRecords();
+    const inserted = mutations
+      .flatMap((mutation) => [...mutation.addedNodes])
+      .find((node): node is HTMLIFrameElement => node instanceof HTMLIFrameElement);
+    expect(inserted?.srcdoc).toContain('fictional creative');
+    expect(inserted?.hasAttribute('src')).toBe(false);
+    expect(mutations.some((mutation) => mutation.removedNodes.length === 1)).toBe(true);
+    expect(container.querySelector('iframe')).toBeNull();
+    observer.disconnect();
+    document.body.innerHTML = '';
+  });
+
+  it.each(['error', 'removed', 'replaced-srcdoc'] as const)(
+    'fails and removes an unaccepted frame when it is %s',
+    (failure) => {
+      document.body.innerHTML = '<div id="fictional-slot"></div>';
+      const render = attempt();
+      expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+      const container = document.getElementById('fictional-slot')!;
+      expect(
+        renderDirectAdmAttempt({
+          attempt: render,
+          container,
+          prepareIframe: prepareAdmIframe,
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      const frame = container.querySelector('iframe');
+      expect(frame).not.toBeNull();
+      if (!frame) throw new Error('should insert an ADM frame');
+
+      if (failure === 'error') frame.dispatchEvent(new Event('error'));
+      if (failure === 'removed') {
+        frame.remove();
+        frame.dispatchEvent(new Event('load'));
+      }
+      if (failure === 'replaced-srcdoc') {
+        frame.srcdoc = '<!doctype html><title>publisher replacement</title>';
+        frame.dispatchEvent(new Event('load'));
+      }
+
+      expect(render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'adm_document_no_load',
+      });
+      expect(frame.isConnected).toBe(false);
+      document.body.innerHTML = '';
+    }
+  );
+
+  it.each([
+    ['sandbox', (frame: HTMLIFrameElement) => frame.setAttribute('sandbox', 'allow-scripts')],
+    [
+      'referrer policy',
+      (frame: HTMLIFrameElement) => frame.setAttribute('referrerpolicy', 'unsafe-url'),
+    ],
+    ['dimensions', (frame: HTMLIFrameElement) => frame.setAttribute('width', '301')],
+    ['layout style', (frame: HTMLIFrameElement) => frame.style.setProperty('width', '301px')],
+  ] as const)(
+    'refuses acceptance after publisher mutation of the exact %s contract',
+    (_field, mutate) => {
+      document.body.innerHTML = '<div id="fictional-slot"></div>';
+      const render = attempt();
+      expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+      const container = document.getElementById('fictional-slot')!;
+      expect(
+        renderDirectAdmAttempt({
+          attempt: render,
+          container,
+          prepareIframe: prepareAdmIframe,
+          publisherOrigin: window.location.origin,
+        })
+      ).toBe(true);
+      const frame = container.querySelector('iframe');
+      expect(frame).not.toBeNull();
+      if (!frame) throw new Error('should insert an ADM frame');
+
+      mutate(frame);
+      frame.dispatchEvent(new Event('load'));
+
+      expect(render.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'adm_document_no_load',
+      });
+      expect(frame.isConnected).toBe(false);
+      document.body.innerHTML = '';
+    }
+  );
+
+  it('removes on cancellation and makes every late frame event inert', () => {
+    document.body.innerHTML = '<div id="fictional-slot"></div>';
+    const render = attempt();
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    const container = document.getElementById('fictional-slot')!;
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(true);
+    const frame = container.querySelector('iframe');
+    expect(frame).not.toBeNull();
+
+    expect(render.cancel('caller_aborted')).toBe(true);
+    expect(frame?.isConnected).toBe(false);
+    frame?.dispatchEvent(new Event('load'));
+    frame?.dispatchEvent(new Event('error'));
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'cancelled',
+      reason: 'caller_aborted',
+    });
+    document.body.innerHTML = '';
+  });
+
+  it('rejects an admitted but malformed frozen ADM source before DOM mutation', () => {
+    const malformed = Object.freeze({
+      type: 'adm' as const,
+      version: 1 as const,
+      adm: '',
+      width: 0,
+      height: 250,
+    });
+    document.body.innerHTML = '<div id="fictional-slot"></div>';
+    const render = attempt(owner(), {
+      prepareRenderSource: (candidate) => (candidate === malformed ? malformed : undefined),
+    });
+    expect(render.admitDirectWinner(malformed, WINNER_CONTEXT)).toBe(true);
+    const container = document.getElementById('fictional-slot')!;
+
+    expect(
+      renderDirectAdmAttempt({
+        attempt: render,
+        container,
+        prepareIframe: prepareAdmIframe,
+        publisherOrigin: window.location.origin,
+      })
+    ).toBe(false);
+    expect(container.querySelector('iframe')).toBeNull();
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'winner_not_renderable',
+    });
+    document.body.innerHTML = '';
+  });
+});
+
+describe('RenderAttempt state machine', () => {
+  it('implements the exact PUC APS state table and makes invalid/replay transitions inert', () => {
+    const scope = owner();
+    const candidate = artifact(scope, 'aps_mount');
+    const render = attempt(scope);
+    const observed: RenderAttemptState[] = [];
+
+    expect(render.beginGamClaim()).toBe(true);
+    expect(render.beginDirect()).toBe(false);
+    expect(render.admitClaimedWinner(claimed(render, scope, APS_SOURCE))).toBe(true);
+    expect(render.ownerClaimed()).toBe(true);
+    expect(render.ownerRegistered()).toBe(true);
+    expect(render.beginApsDocument(candidate)).toBe(true);
+    expect(render.beginAdm(candidate)).toBe(false);
+    expect(render.apsDocumentAccepted()).toBe(true);
+    expect(render.accept()).toBe(true);
+    expect(render.accept()).toBe(false);
+    expect(render.fail('runner_failed')).toBe(false);
+    expect(candidate.dispose).not.toHaveBeenCalled();
+
+    for (const state of render.snapshot().history) observed.push(state);
+    expect(observed).toEqual([
+      'created',
+      'waiting_for_gam_and_claim',
+      'waiting_for_owner',
+      'waiting_for_insertion',
+      'waiting_for_document',
+      'waiting_for_aps_completion',
+      'accepted',
+    ]);
+    expect(render.snapshot()).toMatchObject({
+      state: 'accepted',
+      outcome: { outcome: 'accepted' },
+    });
+    expect(scope.disposed).toBe(true);
+  });
+
+  it('implements direct and owner ADM paths without permitting APS-only transitions', () => {
+    const directOwner = owner();
+    const directArtifact = artifact(directOwner);
+    const direct = attempt(directOwner);
+    expect(direct.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(direct.beginDirect()).toBe(true);
+    expect(direct.beginAdm(directArtifact)).toBe(true);
+    expect(direct.apsDocumentAccepted()).toBe(false);
+    expect(direct.accept()).toBe(true);
+
+    const pucOwner = owner(ATTEMPT_TWO);
+    const pucArtifact = artifact(pucOwner, 'puc');
+    const puc = attempt(pucOwner);
+    expect(puc.beginGamClaim()).toBe(true);
+    expect(puc.admitClaimedWinner(claimed(puc, pucOwner, ADM_SOURCE))).toBe(true);
+    expect(puc.ownerClaimed()).toBe(true);
+    expect(puc.ownerRegistered()).toBe(true);
+    expect(puc.beginAdm(pucArtifact)).toBe(true);
+    expect(puc.accept()).toBe(true);
+    expect(puc.snapshot().history).toEqual([
+      'created',
+      'waiting_for_gam_and_claim',
+      'waiting_for_owner',
+      'waiting_for_insertion',
+      'waiting_for_adm',
+      'accepted',
+    ]);
+  });
+
+  it('rejects source and artifact combinations from a different render path', () => {
+    const directApsOwner = owner();
+    const directAps = attempt(directApsOwner);
+    expect(directAps.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(directAps.beginDirect()).toBe(true);
+    expect(directAps.beginAdm(artifact(directApsOwner))).toBe(false);
+    expect(directAps.beginApsDocument(artifact(directApsOwner, 'puc'))).toBe(false);
+    expect(directAps.beginApsDocument(artifact(directApsOwner, 'aps_mount'))).toBe(true);
+
+    const directAdmOwner = owner(ATTEMPT_TWO);
+    const directAdm = attempt(directAdmOwner);
+    expect(directAdm.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(directAdm.beginDirect()).toBe(true);
+    expect(directAdm.beginApsDocument(artifact(directAdmOwner))).toBe(false);
+    expect(directAdm.beginAdm(artifact(directAdmOwner, 'puc'))).toBe(false);
+    expect(directAdm.beginAdm(artifact(directAdmOwner))).toBe(true);
+
+    const pucApsOwner = owner('a1_0000000000000000000002');
+    const pucAps = attempt(pucApsOwner);
+    expect(pucAps.beginGamClaim()).toBe(true);
+    expect(pucAps.admitClaimedWinner(claimed(pucAps, pucApsOwner, APS_SOURCE))).toBe(true);
+    expect(pucAps.ownerClaimed()).toBe(true);
+    expect(pucAps.ownerRegistered()).toBe(true);
+    expect(pucAps.beginAdm(artifact(pucApsOwner, 'puc'))).toBe(false);
+    expect(pucAps.beginApsDocument(artifact(pucApsOwner))).toBe(false);
+    expect(pucAps.beginApsDocument(artifact(pucApsOwner, 'aps_mount'))).toBe(true);
+  });
+
+  it('admits a claimed winner only through the exact one-shot source/context claim', () => {
+    const scope = owner();
+    const render = attempt(scope);
+    expect(render.beginGamClaim()).toBe(true);
+    const exactClaim = claimed(render, scope, APS_SOURCE);
+    const exactContext = scope.winnerContext;
+    if (!exactContext) throw new Error('should admit the exact reservation context');
+
+    const mismatchedOwner = owner(ATTEMPT_TWO);
+    const mismatched = attempt(mismatchedOwner);
+    expect(mismatched.beginGamClaim()).toBe(true);
+    mismatchedOwner.admitClaimedContext(exactContext);
+    expect(mismatched.admitClaimedWinner(exactClaim)).toBe(false);
+    expect(mismatched.renderSource).toBeUndefined();
+    mismatched.cancel('caller_aborted');
+
+    expect(render.admitClaimedWinner(Object.freeze({}))).toBe(false);
+    expect(render.admitClaimedWinner(exactClaim)).toBe(true);
+    expect(render.renderSource).toEqual(APS_SOURCE);
+    expect(render.winnerContext).toBe(exactContext);
+    expect(render.admitClaimedWinner(exactClaim)).toBe(false);
+  });
+
+  it('enforces every valid, invalid, and replay transition in the state table', () => {
+    type Transition =
+      | 'admit_direct'
+      | 'admit_claimed'
+      | 'begin_gam_claim'
+      | 'owner_claimed'
+      | 'owner_registered'
+      | 'begin_direct'
+      | 'begin_aps_document'
+      | 'begin_adm'
+      | 'aps_document_accepted'
+      | 'accept'
+      | 'no_bid'
+      | 'gam_empty'
+      | 'fail'
+      | 'cancel';
+    type ScenarioName =
+      | 'created'
+      | 'created_direct'
+      | 'waiting_for_gam_and_claim'
+      | 'waiting_for_gam_and_claim_admitted'
+      | 'waiting_for_owner'
+      | 'waiting_for_insertion_aps'
+      | 'waiting_for_insertion_adm'
+      | 'rendering_direct_aps'
+      | 'rendering_direct_adm'
+      | 'waiting_for_document'
+      | 'waiting_for_aps_completion'
+      | 'waiting_for_adm'
+      | 'accepted'
+      | 'no_bid'
+      | 'failed'
+      | 'cancelled';
+
+    const transitions: readonly Transition[] = [
+      'admit_direct',
+      'admit_claimed',
+      'begin_gam_claim',
+      'owner_claimed',
+      'owner_registered',
+      'begin_direct',
+      'begin_aps_document',
+      'begin_adm',
+      'aps_document_accepted',
+      'accept',
+      'no_bid',
+      'gam_empty',
+      'fail',
+      'cancel',
+    ];
+    const valid = new Map<ScenarioName, ReadonlySet<Transition>>([
+      ['created', new Set(['admit_direct', 'begin_gam_claim', 'no_bid', 'fail', 'cancel'])],
+      ['created_direct', new Set(['begin_direct', 'fail', 'cancel'])],
+      ['waiting_for_gam_and_claim', new Set(['admit_claimed', 'gam_empty', 'fail', 'cancel'])],
+      [
+        'waiting_for_gam_and_claim_admitted',
+        new Set(['owner_claimed', 'gam_empty', 'fail', 'cancel']),
+      ],
+      ['waiting_for_owner', new Set(['owner_registered', 'fail', 'cancel'])],
+      ['waiting_for_insertion_aps', new Set(['begin_aps_document', 'fail', 'cancel'])],
+      ['waiting_for_insertion_adm', new Set(['begin_adm', 'fail', 'cancel'])],
+      ['rendering_direct_aps', new Set(['begin_aps_document', 'fail', 'cancel'])],
+      ['rendering_direct_adm', new Set(['begin_adm', 'fail', 'cancel'])],
+      ['waiting_for_document', new Set(['aps_document_accepted', 'fail', 'cancel'])],
+      ['waiting_for_aps_completion', new Set(['accept', 'fail', 'cancel'])],
+      ['waiting_for_adm', new Set(['accept', 'fail', 'cancel'])],
+      ['accepted', new Set()],
+      ['no_bid', new Set()],
+      ['failed', new Set()],
+      ['cancelled', new Set()],
+    ]);
+
+    const build = (name: ScenarioName): RenderAttempt => {
+      const scope = owner();
+      const render = attempt(scope);
+      const claim = (source: typeof APS_SOURCE | typeof ADM_SOURCE): void => {
+        render.beginGamClaim();
+        render.admitClaimedWinner(claimed(render, scope, source));
+      };
+      switch (name) {
+        case 'created':
+          break;
+        case 'created_direct':
+          render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+          break;
+        case 'waiting_for_gam_and_claim':
+          render.beginGamClaim();
+          matrixClaims.set(render, claimed(render, scope, APS_SOURCE));
+          break;
+        case 'waiting_for_gam_and_claim_admitted':
+          claim(APS_SOURCE);
+          break;
+        case 'waiting_for_owner':
+          claim(APS_SOURCE);
+          render.ownerClaimed();
+          break;
+        case 'waiting_for_insertion_aps':
+          claim(APS_SOURCE);
+          render.ownerClaimed();
+          render.ownerRegistered();
+          break;
+        case 'waiting_for_insertion_adm':
+          claim(ADM_SOURCE);
+          render.ownerClaimed();
+          render.ownerRegistered();
+          break;
+        case 'rendering_direct_aps':
+          render.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          break;
+        case 'rendering_direct_adm':
+          render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          break;
+        case 'waiting_for_document':
+          render.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          render.beginApsDocument(artifact(scope, 'aps_mount'));
+          break;
+        case 'waiting_for_aps_completion':
+          render.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          render.beginApsDocument(artifact(scope, 'aps_mount'));
+          render.apsDocumentAccepted();
+          break;
+        case 'waiting_for_adm':
+          render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          render.beginAdm(artifact(scope));
+          break;
+        case 'accepted':
+          render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+          render.beginDirect();
+          render.beginAdm(artifact(scope));
+          render.accept();
+          break;
+        case 'no_bid':
+          render.noBid();
+          break;
+        case 'failed':
+          render.fail('internal_error');
+          break;
+        case 'cancelled':
+          render.cancel('caller_aborted');
+          break;
+      }
+      return render;
+    };
+
+    const invoke = (render: RenderAttempt, transition: Transition): boolean => {
+      switch (transition) {
+        case 'admit_direct':
+          return render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+        case 'admit_claimed':
+          return render.admitClaimedWinner(matrixClaims.get(render) ?? Object.freeze({}));
+        case 'begin_gam_claim':
+          return render.beginGamClaim();
+        case 'owner_claimed':
+          return render.ownerClaimed();
+        case 'owner_registered':
+          return render.ownerRegistered();
+        case 'begin_direct':
+          return render.beginDirect();
+        case 'begin_aps_document':
+          return render.beginApsDocument(artifact(render, 'aps_mount'));
+        case 'begin_adm':
+          return render.beginAdm(
+            artifact(
+              render,
+              render.snapshot().state === 'waiting_for_insertion' ? 'puc' : 'direct_iframe'
+            )
+          );
+        case 'aps_document_accepted':
+          return render.apsDocumentAccepted();
+        case 'accept':
+          return render.accept();
+        case 'no_bid':
+          return render.noBid();
+        case 'gam_empty':
+          return render.fail('gam_empty');
+        case 'fail':
+          return render.fail('internal_error');
+        case 'cancel':
+          return render.cancel('caller_aborted');
+      }
+    };
+
+    for (const [scenario, expectedTransitions] of valid) {
+      for (const transition of transitions) {
+        const render = build(scenario);
+        const expected = expectedTransitions.has(transition);
+        expect(invoke(render, transition), `${scenario} -> ${transition}`).toBe(expected);
+        if (expected) {
+          expect(invoke(render, transition), `${scenario} -> ${transition} replay`).toBe(false);
+        }
+        if (!render.snapshot().outcome) render.cancel('caller_aborted');
+      }
+    }
+  });
+
+  it('owns the exact admitted source and winner context for a direct APS path', () => {
+    const scope = owner();
+    const render = attempt(scope);
+    expect(render.beginDirect()).toBe(false);
+    expect(render.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(render.renderSource).toBe(APS_SOURCE);
+    expect(render.winnerContext).toBe(WINNER_CONTEXT);
+    expect(render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(false);
+
+    const candidate = artifact(scope, 'aps_mount');
+    expect(render.beginDirect()).toBe(true);
+    expect(render.beginApsDocument(candidate)).toBe(true);
+    expect(render.apsDocumentAccepted()).toBe(true);
+    expect(render.accept()).toBe(true);
+    expect(render.renderSource).toBeUndefined();
+    expect(render.winnerContext).toBeUndefined();
+  });
+
+  it('allows no_bid only for the exact parsed decision before rendering starts', () => {
+    const noBid = attempt();
+    expect(noBid.noBid()).toBe(true);
+    expect(noBid.snapshot()).toMatchObject({ state: 'no_bid', outcome: { outcome: 'no_bid' } });
+    expect(noBid.beginDirect()).toBe(false);
+
+    const rendering = attempt(owner(ATTEMPT_TWO));
+    expect(rendering.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(rendering.beginDirect()).toBe(true);
+    expect(rendering.noBid()).toBe(false);
+    expect(rendering.fail('invalid_response')).toBe(true);
+  });
+
+  it('races state-owned timeout, success, failure, abort, and navigation disposal through one latch', () => {
+    vi.useFakeTimers();
+    try {
+      const timedOwner = owner();
+      const timedArtifact = artifact(timedOwner);
+      const timed = attempt(timedOwner, {
+        owner: timedOwner,
+        artifacts: createCommittedArtifactStore(),
+      });
+      expect(timed.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+      expect(timed.beginDirect()).toBe(true);
+      expect(timed.beginAdm(timedArtifact)).toBe(true);
+      vi.advanceTimersByTime(5_000);
+      expect(timed.snapshot()).toMatchObject({
+        outcome: { outcome: 'failed', reason: 'adm_document_no_load' },
+      });
+      expect(timedArtifact.dispose).toHaveBeenCalledOnce();
+      expect(timed.accept()).toBe(false);
+      expect(timed.cancel('caller_aborted')).toBe(false);
+
+      const aborted = attempt(owner(ATTEMPT_TWO));
+      expect(aborted.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+      expect(aborted.beginDirect()).toBe(true);
+      expect(aborted.cancel('caller_aborted')).toBe(true);
+      expect(aborted.fail('internal_error')).toBe(false);
+
+      const navigationOwner = owner('a1_0000000000000000000002');
+      const navigationAttempt = attempt(navigationOwner);
+      expect(navigationAttempt.beginGamClaim()).toBe(true);
+      navigationOwner.disposeFromNavigation();
+      expect(navigationAttempt.snapshot()).toMatchObject({
+        outcome: { outcome: 'cancelled', reason: 'navigation_disposed' },
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('uses fixed transition-owned deadline timings and failure mappings', () => {
+    vi.useFakeTimers();
+    try {
+      const registrationOwner = owner();
+      const registration = attempt(registrationOwner);
+      registration.beginGamClaim();
+      registration.admitClaimedWinner(claimed(registration, registrationOwner, APS_SOURCE));
+      registration.ownerClaimed();
+      vi.advanceTimersByTime(2_999);
+      expect(registration.snapshot().state).toBe('waiting_for_owner');
+      vi.advanceTimersByTime(1);
+      expect(registration.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'owner_registration_timeout',
+      });
+
+      const insertionOwner = owner(ATTEMPT_TWO);
+      const insertion = attempt(insertionOwner);
+      insertion.beginGamClaim();
+      insertion.admitClaimedWinner(claimed(insertion, insertionOwner, APS_SOURCE));
+      insertion.ownerClaimed();
+      insertion.ownerRegistered();
+      vi.advanceTimersByTime(1_000);
+      expect(insertion.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'owner_insertion_timeout',
+      });
+
+      const documentOwner = owner('a1_0000000000000000000002');
+      const documentAttempt = attempt(documentOwner);
+      documentAttempt.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+      documentAttempt.beginDirect();
+      documentAttempt.beginApsDocument(artifact(documentOwner, 'aps_mount'));
+      vi.advanceTimersByTime(3_000);
+      expect(documentAttempt.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'renderer_document_no_load',
+      });
+
+      const completionOwner = owner('a1_0000000000000000000003');
+      const completion = attempt(completionOwner);
+      completion.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+      completion.beginDirect();
+      completion.beginApsDocument(artifact(completionOwner, 'aps_mount'));
+      completion.apsDocumentAccepted();
+      vi.advanceTimersByTime(10_000);
+      expect(completion.snapshot().outcome).toEqual({
+        outcome: 'failed',
+        reason: 'runner_failed',
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('reserves transition and terminal latches before hostile scheduler and artifact cleanup', () => {
+    const transitionReference: { current?: RenderAttempt } = {};
+    let clearReenters = false;
+    const scheduler = {
+      set: vi.fn(() => Object.freeze({})),
+      clear: vi.fn(() => {
+        if (clearReenters) transitionReference.current?.cancel('caller_aborted');
+      }),
+    };
+    const transitionOwner = owner();
+    const transitionAttempt = attempt(transitionOwner, { scheduler });
+    transitionReference.current = transitionAttempt;
+    transitionAttempt.admitDirectWinner(APS_SOURCE, WINNER_CONTEXT);
+    transitionAttempt.beginDirect();
+    transitionAttempt.beginApsDocument(artifact(transitionOwner, 'aps_mount'));
+    clearReenters = true;
+
+    expect(transitionAttempt.apsDocumentAccepted()).toBe(true);
+    expect(transitionAttempt.snapshot().outcome).toEqual({
+      outcome: 'cancelled',
+      reason: 'caller_aborted',
+    });
+    expect(transitionAttempt.snapshot().history.slice(-2)).toEqual([
+      'waiting_for_aps_completion',
+      'cancelled',
+    ]);
+
+    const disposalReference: { current?: RenderAttempt } = {};
+    const disposalOwner = owner(ATTEMPT_TWO);
+    const hostileArtifact = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: disposalOwner.id,
+      slot: disposalOwner.slot,
+      navigationGeneration: disposalOwner.navigationGeneration,
+      dispose: vi.fn(() => disposalReference.current?.cancel('superseded')),
+    });
+    const disposalAttempt = attempt(disposalOwner);
+    disposalReference.current = disposalAttempt;
+    disposalAttempt.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    disposalAttempt.beginDirect();
+    disposalAttempt.beginAdm(hostileArtifact);
+
+    expect(disposalAttempt.fail('internal_error')).toBe(true);
+    expect(disposalAttempt.snapshot().outcome).toEqual({
+      outcome: 'failed',
+      reason: 'internal_error',
+    });
+    expect(disposalAttempt.snapshot().history.filter((state) => state === 'failed')).toHaveLength(
+      1
+    );
+    expect(disposalAttempt.snapshot().history).not.toContain('cancelled');
+  });
+
+  it('does not promote after deadline cleanup reentrantly settles the attempt', () => {
+    const artifacts = createCommittedArtifactStore();
+    const reference: { current?: RenderAttempt } = {};
+    let cancelOnClear = false;
+    const scheduler = {
+      set: vi.fn(() => Object.freeze({})),
+      clear: vi.fn(() => {
+        if (cancelOnClear) reference.current?.cancel('caller_aborted');
+      }),
+    };
+    const scope = owner();
+    const candidate = artifact(scope);
+    const render = attempt(scope, { artifacts, scheduler });
+    reference.current = render;
+    render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    render.beginDirect();
+    render.beginAdm(candidate);
+    cancelOnClear = true;
+
+    expect(render.accept()).toBe(false);
+    expect(render.snapshot().outcome).toEqual({
+      outcome: 'cancelled',
+      reason: 'caller_aborted',
+    });
+    expect(candidate.dispose).toHaveBeenCalledOnce();
+    expect(artifacts.current(scope.slot)).toBeUndefined();
+  });
+
+  it('rejects malformed or stale attempt ownership before registering work', () => {
+    const malformed = owner('bad-attempt');
+    expect(
+      createRenderAttempt({
+        owner: malformed,
+        artifacts: createCommittedArtifactStore(),
+        reservations: reservations(),
+        prepareRenderSource,
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+
+    const stale = owner();
+    stale.disposeFromNavigation();
+    expect(
+      createRenderAttempt({
+        owner: stale,
+        artifacts: createCommittedArtifactStore(),
+        reservations: reservations(),
+        prepareRenderSource,
+      })
+    ).toEqual({ ok: false, reason: 'stale_owner' });
+  });
+
+  it('transactionally disposes owners when lifecycle registration cannot commit', () => {
+    for (const mode of ['throw', 'callback', 'identity'] as const) {
+      const scope = owner();
+      const originalDispose = scope.dispose;
+      const dispose = vi.fn(() => originalDispose());
+      Object.defineProperty(scope, 'dispose', { configurable: true, value: dispose });
+      Object.defineProperty(scope, 'onDispose', {
+        configurable: true,
+        value: (_kind: string, callback: () => void) => {
+          if (mode === 'callback') callback();
+          if (mode === 'identity') {
+            Object.defineProperty(scope, 'id', { configurable: true, value: ATTEMPT_TWO });
+          }
+          if (mode === 'throw') throw new Error('registration failed');
+        },
+      });
+
+      expect(
+        createRenderAttempt({
+          owner: scope,
+          artifacts: createCommittedArtifactStore(),
+          reservations: reservations(),
+          prepareRenderSource,
+        })
+      ).toEqual({ ok: false, reason: 'stale_owner' });
+      expect(dispose, mode).toHaveBeenCalledOnce();
+    }
+  });
+
+  it('releases real session indexes after every post-issuance construction rejection', () => {
+    let issuedByte = 0;
+    const runtime = createRuntimeSession({
+      createIdentityIssuer: () =>
+        createTestNavigationIdentityIssuer({
+          getRandomValues: (target) => {
+            target.fill(issuedByte);
+            issuedByte += 1;
+            return target;
+          },
+        }),
+    });
+    const navigation = runtime.startInitialNavigation();
+    if (!navigation.ok) throw new Error('should start a navigation');
+    const batch = navigation.value.createAuctionBatch('batch-render-construction');
+    if (!batch) throw new Error('should create an auction batch');
+    const slot = 'fictional-slot';
+
+    const unbrandedOwner = batch.createRenderAttempt(slot);
+    if (!unbrandedOwner.ok) throw new Error('should issue the first owner');
+    expect(
+      createRenderAttempt({
+        owner: unbrandedOwner.value,
+        artifacts: { ...createCommittedArtifactStore() },
+        reservations: reservations(),
+        prepareRenderSource,
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+
+    const invalidSchedulerOwner = batch.createRenderAttempt(slot);
+    expect(invalidSchedulerOwner).toMatchObject({ ok: true });
+    if (!invalidSchedulerOwner.ok) throw new Error('should retry after provenance rejection');
+    expect(
+      createRenderAttempt({
+        owner: invalidSchedulerOwner.value,
+        artifacts: createCommittedArtifactStore(),
+        reservations: reservations(),
+        prepareRenderSource,
+        scheduler: { set: undefined as never, clear: () => undefined },
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+
+    const unbrandedReservationsOwner = batch.createRenderAttempt(slot);
+    expect(unbrandedReservationsOwner).toMatchObject({ ok: true });
+    if (!unbrandedReservationsOwner.ok) {
+      throw new Error('should retry after scheduler rejection');
+    }
+    expect(
+      createRenderAttempt({
+        owner: unbrandedReservationsOwner.value,
+        artifacts: createCommittedArtifactStore(),
+        prepareRenderSource,
+        reservations: {
+          ...reservations(),
+          consumeClaim: () =>
+            Object.freeze({
+              renderSource: ADM_SOURCE,
+              winnerContext: WINNER_CONTEXT,
+            }),
+        },
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+
+    expect(batch.createRenderAttempt(slot)).toMatchObject({ ok: true });
+    runtime.dispose();
+  });
+
+  it('runtime-rejects invalid terminal reasons instead of publishing malformed outcomes', () => {
+    const render = attempt();
+    expect(render.fail('invented_failure' as never)).toBe(false);
+    expect(render.cancel('invented_cancellation' as never)).toBe(false);
+    expect(render.snapshot()).toMatchObject({ state: 'created', outcome: undefined });
+    expect(render.fail('internal_error')).toBe(true);
+  });
+});
+
+describe('committed artifact ownership', () => {
+  it('retires a lost guarded artifact synchronously and exactly once', () => {
+    const store = createCommittedArtifactStore();
+    const candidate = artifact(owner());
+    const retireAssociation = vi.fn();
+    let current = true;
+    expect(bindCommittedArtifactGuard(candidate, () => current)).toBe(true);
+    expect(bindCommittedArtifactRetirement(candidate, retireAssociation)).toBe(true);
+    expect(bindCommittedArtifactRetirement(candidate, vi.fn())).toBe(false);
+    expect(store.promote(candidate)).toBe(true);
+
+    expect(store.sweep()).toBe(0);
+    current = false;
+    expect(store.sweep()).toBe(1);
+    expect(store.current(candidate.slot)).toBeUndefined();
+    expect(retireAssociation).toHaveBeenCalledOnce();
+    expect(candidate.dispose).toHaveBeenCalledOnce();
+    expect(store.sweep()).toBe(0);
+    expect(candidate.dispose).toHaveBeenCalledOnce();
+    expect(retireAssociation).toHaveBeenCalledOnce();
+  });
+
+  it('promotes before attempt disposal, preserves accepted DOM, and disposes the prior artifact before replacement', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const firstOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+    const firstArtifact = artifact(firstOwner);
+    const first = attempt(firstOwner, { owner: firstOwner, artifacts: store });
+    first.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    first.beginDirect();
+    first.beginAdm(firstArtifact);
+    expect(first.accept()).toBe(true);
+    expect(firstOwner.disposed).toBe(true);
+    expect(firstArtifact.dispose).not.toHaveBeenCalled();
+    expect(store.current('fictional-slot')).toBe(firstArtifact);
+
+    const secondOwner = owner(ATTEMPT_TWO, 'fictional-slot', generation);
+    const secondArtifact = artifact(secondOwner);
+    const second = attempt(secondOwner, { owner: secondOwner, artifacts: store });
+    second.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    second.beginDirect();
+    second.beginAdm(secondArtifact);
+    expect(second.accept()).toBe(true);
+    expect(firstArtifact.dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBe(secondArtifact);
+    expect(secondArtifact.dispose).not.toHaveBeenCalled();
+
+    store.disposeNavigation(generation);
+    expect(secondArtifact.dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBeUndefined();
+  });
+
+  it('disposes only uncommitted artifacts on failure or cancellation', () => {
+    for (const [index, settle] of (['failed', 'cancelled'] as const).entries()) {
+      const scope = owner(`a1_000000000000000000000${index}`);
+      const candidate = artifact(scope);
+      const render = attempt(scope);
+      render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+      render.beginDirect();
+      render.beginAdm(candidate);
+      if (settle === 'failed') expect(render.fail('adm_document_no_load')).toBe(true);
+      else expect(render.cancel('superseded')).toBe(true);
+      expect(candidate.dispose).toHaveBeenCalledOnce();
+    }
+  });
+
+  it('does not publish a replacement when prior-artifact disposal reentrantly cancels it', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const secondOwner = owner(ATTEMPT_TWO, 'fictional-slot', generation);
+    const firstOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+    const firstArtifact = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: firstOwner.id,
+      slot: 'fictional-slot',
+      navigationGeneration: generation,
+      dispose: vi.fn(() => secondOwner.disposeFromNavigation()),
+    });
+    const first = attempt(firstOwner, { owner: firstOwner, artifacts: store });
+    first.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    first.beginDirect();
+    first.beginAdm(firstArtifact);
+    first.accept();
+
+    const secondArtifact = artifact(secondOwner);
+    const second = attempt(secondOwner, { owner: secondOwner, artifacts: store });
+    second.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    second.beginDirect();
+    second.beginAdm(secondArtifact);
+
+    expect(second.accept()).toBe(false);
+    expect(second.snapshot()).toMatchObject({
+      outcome: { outcome: 'cancelled', reason: 'navigation_disposed' },
+    });
+    expect(firstArtifact.dispose).toHaveBeenCalledOnce();
+    expect(secondArtifact.dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBeUndefined();
+  });
+
+  it('requires an immutable exact-attempt artifact without invoking accessors', () => {
+    const scope = owner();
+    const render = attempt(scope);
+    render.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    render.beginDirect();
+    const wrongAttempt = Object.freeze({
+      ...artifact(scope),
+      attemptId: ATTEMPT_TWO,
+    });
+    expect(render.beginAdm(wrongAttempt)).toBe(false);
+
+    const getter = vi.fn(() => 'direct_iframe');
+    const hostile = Object.freeze(
+      Object.defineProperties(
+        {},
+        {
+          attemptId: { enumerable: true, value: scope.id },
+          dispose: { enumerable: true, value: vi.fn() },
+          kind: { enumerable: true, get: getter },
+          navigationGeneration: { enumerable: true, value: scope.navigationGeneration },
+          slot: { enumerable: true, value: scope.slot },
+        }
+      )
+    );
+    expect(render.beginAdm(hostile as CommittedRenderArtifact)).toBe(false);
+    expect(getter).not.toHaveBeenCalled();
+  });
+
+  it('defers reentrant navigation disposal and never publishes into a disposed generation', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const firstOwner = owner(ATTEMPT_ONE, 'slot-one', generation);
+    const secondOwner = owner(ATTEMPT_TWO, 'slot-two', generation);
+    const replacementOwner = owner('a1_0000000000000000000002', 'slot-one', generation);
+    const first = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: firstOwner.id,
+      slot: firstOwner.slot,
+      navigationGeneration: generation,
+      dispose: vi.fn(() => store.disposeNavigation(generation)),
+    });
+    const second = artifact(secondOwner);
+    const replacement = artifact(replacementOwner);
+    expect(store.promote(first)).toBe(true);
+    expect(store.promote(second)).toBe(true);
+
+    expect(store.promote(replacement)).toBe(false);
+    expect(first.dispose).toHaveBeenCalledOnce();
+    expect(second.dispose).toHaveBeenCalledOnce();
+    expect(store.current('slot-one')).toBeUndefined();
+    expect(store.current('slot-two')).toBeUndefined();
+  });
+
+  it('never retries a throwing artifact disposer', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const firstOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+    const replacementOwner = owner(ATTEMPT_TWO, 'fictional-slot', generation);
+    const dispose = vi.fn(() => {
+      throw new Error('partial artifact disposal');
+    });
+    const first = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: firstOwner.id,
+      slot: firstOwner.slot,
+      navigationGeneration: generation,
+      dispose,
+    });
+    expect(store.promote(first)).toBe(true);
+    expect(store.promote(artifact(replacementOwner))).toBe(false);
+    expect(store.current('fictional-slot')).toBe(first);
+
+    store.disposeNavigation(generation);
+    expect(dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBeUndefined();
+  });
+
+  it('fails closed and contains an asynchronous artifact disposer', async () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const firstOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+    const replacementOwner = owner(ATTEMPT_TWO, 'fictional-slot', generation);
+    const dispose = vi.fn(async () => {
+      throw new Error('asynchronous artifact disposal is unsupported');
+    });
+    const first = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: firstOwner.id,
+      slot: firstOwner.slot,
+      navigationGeneration: generation,
+      dispose,
+    });
+    expect(store.promote(first)).toBe(true);
+
+    expect(store.promote(artifact(replacementOwner))).toBe(false);
+    await Promise.resolve();
+
+    expect(dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBe(first);
+  });
+
+  it.each(['fulfilled_promise', 'fulfilling_thenable'] as const)(
+    'contains an asynchronous %s disposer without publishing a replacement',
+    async (mode) => {
+      const store = createCommittedArtifactStore();
+      const generation = Object.freeze({});
+      const firstOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+      const replacementOwner = owner(ATTEMPT_TWO, 'fictional-slot', generation);
+      const dispose = vi.fn(() =>
+        mode === 'fulfilled_promise'
+          ? Promise.resolve()
+          : {
+              then: (fulfilled: () => void) => {
+                queueMicrotask(() => fulfilled());
+              },
+            }
+      );
+      const first = Object.freeze({
+        kind: 'direct_iframe' as const,
+        attemptId: firstOwner.id,
+        slot: firstOwner.slot,
+        navigationGeneration: generation,
+        dispose,
+      });
+      expect(store.promote(first)).toBe(true);
+
+      expect(store.promote(artifact(replacementOwner))).toBe(false);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      expect(dispose).toHaveBeenCalledOnce();
+      expect(store.current('fictional-slot')).toBe(first);
+    }
+  );
+
+  it('never republishes an artifact after its disposal has started', () => {
+    const store = createCommittedArtifactStore();
+    const candidate = artifact(owner());
+    expect(store.promote(candidate)).toBe(true);
+    expect(store.release(candidate)).toBe(true);
+    expect(candidate.dispose).toHaveBeenCalledOnce();
+
+    expect(store.promote(candidate)).toBe(false);
+    expect(store.current(candidate.slot)).toBeUndefined();
+    expect(candidate.dispose).toHaveBeenCalledOnce();
+  });
+
+  it('preserves the prior artifact when promotion currentness is already false', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const current = artifact(owner(ATTEMPT_ONE, 'fictional-slot', generation));
+    const candidate = artifact(owner(ATTEMPT_TWO, 'fictional-slot', generation));
+    expect(store.promote(current)).toBe(true);
+
+    expect(store.promote(candidate, () => false)).toBe(false);
+    expect(current.dispose).not.toHaveBeenCalled();
+    expect(candidate.dispose).not.toHaveBeenCalled();
+    expect(store.current('fictional-slot')).toBe(current);
+  });
+
+  it('does not publish a candidate whose exact association is lost during prior disposal', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    let associationCurrent = true;
+    const currentOwner = owner(ATTEMPT_ONE, 'fictional-slot', generation);
+    const current = Object.freeze({
+      kind: 'aps_mount' as const,
+      attemptId: currentOwner.id,
+      slot: currentOwner.slot,
+      navigationGeneration: generation,
+      dispose: vi.fn(() => {
+        associationCurrent = false;
+      }),
+    });
+    const candidate = artifact(owner(ATTEMPT_TWO, 'fictional-slot', generation), 'aps_mount');
+    expect(bindCommittedArtifactGuard(candidate, () => associationCurrent)).toBe(true);
+    expect(store.promote(current)).toBe(true);
+
+    expect(store.promote(candidate)).toBe(false);
+    expect(current.dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBeUndefined();
+    expect(candidate.dispose).not.toHaveBeenCalled();
+  });
+
+  it('never publishes after its navigation generation or whole store is disposed', () => {
+    const generation = Object.freeze({});
+    const navigationStore = createCommittedArtifactStore();
+    const navigationArtifact = artifact(owner(ATTEMPT_ONE, 'fictional-slot', generation));
+    navigationStore.disposeNavigation(generation);
+    expect(navigationStore.promote(navigationArtifact)).toBe(false);
+    expect(navigationStore.current('fictional-slot')).toBeUndefined();
+
+    const runtimeStore = createCommittedArtifactStore();
+    const runtimeArtifact = artifact(owner(ATTEMPT_TWO, 'fictional-slot', generation));
+    expect(
+      runtimeStore.promote(runtimeArtifact, () => {
+        runtimeStore.dispose();
+        return true;
+      })
+    ).toBe(false);
+    expect(runtimeStore.current('fictional-slot')).toBeUndefined();
+  });
+
+  it('contains collection prototype tampering at every artifact-store boundary', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const first = artifact(owner(ATTEMPT_ONE, 'fictional-slot', generation));
+    const replacement = artifact(owner(ATTEMPT_TWO, 'fictional-slot', generation));
+    const originalMapGet = Map.prototype.get;
+    const originalSetAdd = Set.prototype.add;
+    const originalWeakMapHas = WeakMap.prototype.has;
+
+    let promoted: boolean | undefined;
+    Map.prototype.get = () => {
+      throw new Error('tampered Map.get');
+    };
+    try {
+      promoted = store.promote(first);
+    } finally {
+      Map.prototype.get = originalMapGet;
+    }
+    expect(promoted).toBe(true);
+
+    let released: boolean | undefined;
+    WeakMap.prototype.has = () => {
+      throw new Error('tampered WeakMap.has');
+    };
+    try {
+      released = store.release(first);
+    } finally {
+      WeakMap.prototype.has = originalWeakMapHas;
+    }
+    expect(released).toBe(true);
+    expect(first.dispose).toHaveBeenCalledOnce();
+
+    expect(store.promote(replacement)).toBe(true);
+    Set.prototype.add = () => {
+      throw new Error('tampered Set.add');
+    };
+    try {
+      store.disposeNavigation(generation);
+    } finally {
+      Set.prototype.add = originalSetAdd;
+    }
+    expect(replacement.dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBeUndefined();
+  });
+
+  it('keeps store bookkeeping valid when a disposer tampers with collection prototypes', () => {
+    const store = createCommittedArtifactStore();
+    const generation = Object.freeze({});
+    const originalMapGet = Map.prototype.get;
+    const dispose = vi.fn(() => {
+      Map.prototype.get = () => {
+        throw new Error('tampered Map.get');
+      };
+    });
+    const current = Object.freeze({
+      kind: 'direct_iframe' as const,
+      attemptId: ATTEMPT_ONE,
+      slot: 'fictional-slot',
+      navigationGeneration: generation,
+      dispose,
+    });
+    const replacement = artifact(owner(ATTEMPT_TWO, 'fictional-slot', generation));
+    expect(store.promote(current)).toBe(true);
+    let promoted: boolean | undefined;
+    try {
+      promoted = store.promote(replacement);
+    } finally {
+      Map.prototype.get = originalMapGet;
+    }
+
+    expect(promoted).toBe(true);
+    expect(dispose).toHaveBeenCalledOnce();
+    expect(store.current('fictional-slot')).toBe(replacement);
+  });
+});
+
+describe('RenderAttempt diagnostics producer', () => {
+  it('publishes one frozen terminal observation only after accepted artifact state commits', () => {
+    const artifacts = createCommittedArtifactStore();
+    const attemptReference: { current?: RenderAttempt } = {};
+    const snapshots: RenderAttemptSnapshot[] = [];
+    const publishDiagnostics = vi.fn((observation: RenderAttemptDiagnosticsObservation) => {
+      expect(Object.isFrozen(observation)).toBe(true);
+      expect(Object.isFrozen(observation.outcome)).toBe(true);
+      snapshots.push(attemptReference.current!.snapshot());
+      throw new Error('fictional diagnostics failure');
+    });
+    const renderAttempt = attempt(owner(), { artifacts, publishDiagnostics });
+    attemptReference.current = renderAttempt;
+    expect(renderAttempt.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(renderAttempt.beginDirect()).toBe(true);
+    const committed = artifact(renderAttempt);
+    expect(renderAttempt.beginAdm(committed)).toBe(true);
+
+    expect(renderAttempt.accept()).toBe(true);
+
+    expect(artifacts.current(renderAttempt.slot)).toBe(committed);
+    expect(snapshots).toEqual([
+      expect.objectContaining({ state: 'accepted', outcome: { outcome: 'accepted' } }),
+    ]);
+    expect(publishDiagnostics).toHaveBeenCalledOnce();
+    expect(publishDiagnostics).toHaveBeenCalledWith({
+      kind: 'render_attempt',
+      attemptId: renderAttempt.id,
+      slotId: renderAttempt.slot,
+      path: 'auction',
+      rendered: true,
+      injected: true,
+      servedFrom: 'inline',
+      state: 'accepted',
+      outcome: { outcome: 'accepted' },
+    });
+  });
+
+  it('publishes source-owned APS trace identity without exposing the creative payload', () => {
+    const publishDiagnostics = vi.fn();
+    const renderAttempt = attempt(owner(), { publishDiagnostics });
+    expect(renderAttempt.admitDirectWinner(DIRECT_APS_SOURCE, WINNER_CONTEXT)).toBe(true);
+    expect(renderAttempt.beginDirect()).toBe(true);
+    const committed = artifact(renderAttempt, 'aps_mount');
+    expect(renderAttempt.beginApsDocument(committed)).toBe(true);
+    expect(renderAttempt.apsDocumentAccepted()).toBe(true);
+
+    expect(renderAttempt.accept()).toBe(true);
+
+    expect(publishDiagnostics).toHaveBeenCalledWith(
+      expect.objectContaining({
+        bidId: DIRECT_APS_SOURCE.bidId,
+        creativeId: DIRECT_APS_SOURCE.creativeId,
+        injected: true,
+        rendered: true,
+      })
+    );
+    const observation = publishDiagnostics.mock.calls[0]?.[0] as Record<string, unknown>;
+    expect(observation).not.toHaveProperty('aaxResponse');
+    expect(observation).not.toHaveProperty('creativeUrl');
+  });
+
+  it('publishes terminal failure after the lifecycle state commit and never republishes', () => {
+    const attemptReference: { current?: RenderAttempt } = {};
+    const observedStates: RenderAttemptState[] = [];
+    const publishDiagnostics = vi.fn(() => {
+      observedStates.push(attemptReference.current!.snapshot().state);
+      return false;
+    });
+    const renderAttempt = attempt(owner(), { publishDiagnostics });
+    attemptReference.current = renderAttempt;
+
+    expect(renderAttempt.fail('runner_failed')).toBe(true);
+    expect(renderAttempt.cancel('superseded')).toBe(false);
+
+    expect(observedStates).toEqual(['failed']);
+    expect(publishDiagnostics).toHaveBeenCalledOnce();
+  });
+});
+
+describe('SlotOperation result isolation', () => {
+  it('rejects an unbranded structural primary before observing or starting fallback', () => {
+    const createFallback = vi.fn();
+    const forged = {
+      id: ATTEMPT_ONE,
+      slot: 'fictional-slot',
+      navigationGeneration: Object.freeze({}),
+      onSettled: vi.fn(),
+      snapshot: vi.fn(),
+    } as unknown as RenderAttempt;
+
+    expect(createSlotOperation({ primary: forged, createFallback })).toEqual({
+      ok: false,
+      reason: 'invalid_attempt',
+    });
+    expect(forged.onSettled).not.toHaveBeenCalled();
+    expect(createFallback).not.toHaveBeenCalled();
+  });
+
+  it('retains immutable primary gam_empty and settles from one distinct fallback child', () => {
+    const primary = attempt();
+    let fallback: RenderAttempt | undefined;
+    const operation = slotOperation({
+      primary,
+      createFallback: (parentAttemptId) => {
+        const childOwner = owner(ATTEMPT_TWO, primary.slot, primary.navigationGeneration);
+        const result = createRenderAttempt({
+          owner: childOwner,
+          artifacts: createCommittedArtifactStore(),
+          reservations: reservations(),
+          prepareRenderSource,
+          parentAttemptId,
+        });
+        if (result.ok) fallback = result.value;
+        return result;
+      },
+    });
+
+    primary.beginGamClaim();
+    expect(primary.fail('gam_empty')).toBe(true);
+    expect(fallback).toBeDefined();
+    expect(fallback?.parentAttemptId).toBe(primary.id);
+    expect(fallback?.id).not.toBe(primary.id);
+    expect(fallback?.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT)).toBe(true);
+    fallback?.beginDirect();
+    const fallbackArtifact = artifact(fallback!);
+    fallback?.beginAdm(fallbackArtifact);
+    expect(fallback?.accept()).toBe(true);
+
+    expect(operation.snapshot()).toEqual({
+      settled: true,
+      result: {
+        path: 'fallback',
+        outcome: { outcome: 'accepted' },
+        primaryAttemptId: ATTEMPT_ONE,
+        primary: { outcome: 'failed', reason: 'gam_empty' },
+        fallbackAttemptId: ATTEMPT_TWO,
+        fallback: { outcome: 'accepted' },
+      },
+    });
+    expect(Object.isFrozen(operation.snapshot().result)).toBe(true);
+  });
+
+  it('does not start fallback for ineligible primary results or settle twice', () => {
+    const primary = attempt();
+    const createFallback = vi.fn();
+    const operation = slotOperation({ primary, createFallback });
+    primary.admitDirectWinner(ADM_SOURCE, WINNER_CONTEXT);
+    primary.beginDirect();
+    primary.fail('runner_failed');
+
+    expect(createFallback).not.toHaveBeenCalled();
+    expect(operation.snapshot()).toMatchObject({
+      settled: true,
+      result: {
+        path: 'primary',
+        outcome: { outcome: 'failed', reason: 'runner_failed' },
+      },
+    });
+    expect(primary.cancel('superseded')).toBe(false);
+  });
+
+  it('cannot forge fallback with gam_empty outside an attributable GAM state', () => {
+    const primary = attempt();
+    const createFallback = vi.fn();
+    const operation = slotOperation({ primary, createFallback });
+
+    expect(primary.fail('gam_empty')).toBe(false);
+    expect(createFallback).not.toHaveBeenCalled();
+    expect(operation.snapshot()).toEqual({ settled: false });
+    expect(primary.cancel('caller_aborted')).toBe(true);
+  });
+
+  it('rejects a fallback child from another navigation generation', () => {
+    const primary = attempt();
+    let child: RenderAttempt | undefined;
+    const operation = slotOperation({
+      primary,
+      createFallback: (parentAttemptId) => {
+        const result = createRenderAttempt({
+          owner: owner(ATTEMPT_TWO),
+          artifacts: createCommittedArtifactStore(),
+          reservations: reservations(),
+          prepareRenderSource,
+          parentAttemptId,
+        });
+        if (result.ok) child = result.value;
+        return result;
+      },
+    });
+    primary.beginGamClaim();
+    primary.fail('gam_empty');
+
+    expect(child?.snapshot().outcome).toEqual({
+      outcome: 'cancelled',
+      reason: 'superseded',
+    });
+    expect(operation.snapshot()).toMatchObject({
+      settled: true,
+      result: {
+        path: 'fallback',
+        outcome: { outcome: 'failed', reason: 'internal_error' },
+      },
+    });
+  });
+
+  it('fails closed when fallback identity issuance fails', () => {
+    const primary = attempt();
+    const operation = slotOperation({
+      primary,
+      createFallback: () => Object.freeze({ ok: false, reason: 'identity_generation_failed' }),
+    });
+    primary.beginGamClaim();
+    primary.fail('gam_empty');
+
+    expect(operation.snapshot()).toMatchObject({
+      settled: true,
+      result: {
+        path: 'fallback',
+        primary: { outcome: 'failed', reason: 'gam_empty' },
+        outcome: { outcome: 'failed', reason: 'identity_generation_failed' },
+      },
+    });
+  });
+
+  it('contains hostile fallback result getters and child subscription failures', () => {
+    const getterPrimary = attempt();
+    const getterOperation = slotOperation({
+      primary: getterPrimary,
+      createFallback: () =>
+        Object.defineProperty({}, 'ok', {
+          get: () => {
+            throw new Error('hostile result getter');
+          },
+        }) as never,
+    });
+    getterPrimary.beginGamClaim();
+    getterPrimary.fail('gam_empty');
+    expect(getterOperation.snapshot()).toMatchObject({
+      settled: true,
+      result: { outcome: { outcome: 'failed', reason: 'internal_error' } },
+    });
+
+    const subscriptionPrimary = attempt(owner(ATTEMPT_ONE, 'fictional-slot', Object.freeze({})));
+    const hostileChild = {
+      id: ATTEMPT_TWO,
+      slot: subscriptionPrimary.slot,
+      parentAttemptId: subscriptionPrimary.id,
+      navigationGeneration: subscriptionPrimary.navigationGeneration,
+      cancel: vi.fn(() => true),
+      onSettled: () => {
+        throw new Error('hostile child subscription');
+      },
+    } as unknown as RenderAttempt;
+    const subscriptionOperation = slotOperation({
+      primary: subscriptionPrimary,
+      createFallback: () => Object.freeze({ ok: true, value: hostileChild }),
+    });
+    subscriptionPrimary.beginGamClaim();
+    subscriptionPrimary.fail('gam_empty');
+    expect(subscriptionOperation.snapshot()).toMatchObject({
+      settled: true,
+      result: { outcome: { outcome: 'failed', reason: 'internal_error' } },
+    });
+    expect(hostileChild.cancel).toHaveBeenCalledOnce();
+  });
+
+  it('rejects a fallback result accessor without rereading or cancelling another value', () => {
+    const primary = attempt();
+    const first = { cancel: vi.fn() };
+    const second = { cancel: vi.fn() };
+    let reads = 0;
+    const result = Object.freeze(
+      Object.defineProperties(
+        {},
+        {
+          ok: { enumerable: true, value: true },
+          value: {
+            enumerable: true,
+            get: () => {
+              reads += 1;
+              return reads === 1 ? first : second;
+            },
+          },
+        }
+      )
+    );
+    const operation = slotOperation({ primary, createFallback: () => result as never });
+    primary.beginGamClaim();
+    primary.fail('gam_empty');
+
+    expect(operation.snapshot()).toMatchObject({
+      settled: true,
+      result: { outcome: { outcome: 'failed', reason: 'internal_error' } },
+    });
+    expect(reads).toBe(0);
+    expect(first.cancel).not.toHaveBeenCalled();
+    expect(second.cancel).not.toHaveBeenCalled();
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/reservations.test.ts b/crates/trusted-server-js/lib/test/services/reservations.test.ts
new file mode 100644
index 000000000..af90dbbb0
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/reservations.test.ts
@@ -0,0 +1,2279 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { parseBidRenderSourceV1 } from '../../src/core/contracts/auction_projection';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import {
+  createRuntimeSession,
+  type NavigationSession,
+  type RenderAttemptScope,
+  type WinnerContext,
+} from '../../src/kernel/sessions';
+import {
+  PREBID_ADMISSION_LEASE_MS,
+  RENDER_RESERVATION_LIFETIME_MS,
+  createReservationService,
+  isRendererReservationId,
+  type ReservationOwner,
+  type ReservationRenderSource,
+} from '../../src/services/reservations';
+
+function reservationId(index = 0): string {
+  return `r1_${index.toString(36).padStart(22, '0')}`;
+}
+
+function runtimeNavigation(): {
+  readonly navigation: NavigationSession;
+  readonly runtime: ReturnType<typeof createRuntimeSession>;
+} {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(7);
+          return target;
+        },
+      }),
+  });
+  const navigation = runtime.startInitialNavigation();
+  if (!navigation.ok) throw new Error('Expected a navigation');
+  return { navigation: navigation.value, runtime };
+}
+
+function renderAttempt(navigation: NavigationSession, slot = 'fictional-slot'): RenderAttemptScope {
+  const batch = navigation.createAuctionBatch(`batch-${slot}`);
+  if (!batch) throw new Error('Expected an auction batch');
+  const attempt = batch.createRenderAttempt(slot);
+  if (!attempt.ok) throw new Error('Expected a render attempt');
+  return attempt.value;
+}
+
+function admSource(markup = '<div>fictional creative</div>') {
+  return { type: 'adm', version: 1, adm: markup, width: 300, height: 250 } as const;
+}
+
+function apsSource() {
+  const creativeUrl = 'https://creative.example/render';
+  const envelope = {
+    seatbid: [
+      {
+        bid: [
+          {
+            id: 'upstream-bid',
+            w: 300,
+            h: 250,
+            price: 1.25,
+            ext: { creativeurl: creativeUrl, tagtype: 'iframe' },
+          },
+        ],
+      },
+    ],
+  };
+  return {
+    type: 'aps',
+    version: 1,
+    accountId: 'fictional-account',
+    bidId: 'upstream-bid',
+    creativeId: 'fictional-creative',
+    tagType: 'iframe',
+    creativeUrl,
+    aaxResponse: btoa(JSON.stringify(envelope)),
+    width: 300,
+    height: 250,
+  } as const;
+}
+
+function serviceAt(readNow: () => number) {
+  return createReservationService({
+    now: readNow,
+    prepareRenderSource: (candidate) => {
+      const source = parseBidRenderSourceV1(candidate);
+      return source?.type === 'pbs_cache' ? undefined : source;
+    },
+  });
+}
+
+function registerRender(
+  service: ReturnType<typeof createReservationService>,
+  navigation: NavigationSession,
+  attempt: RenderAttemptScope,
+  id = reservationId(),
+  renderSource: unknown = admSource(),
+  selectedCpm = 1.25
+) {
+  return service.registerRender({
+    reservationId: id,
+    slot: attempt.slot,
+    navigation,
+    attemptId: attempt.id,
+    renderSource,
+    winnerContext: { selectedCpm },
+  });
+}
+
+function claim(
+  service: ReturnType<typeof createReservationService>,
+  navigation: NavigationSession,
+  attempt: RenderAttemptScope,
+  id = reservationId(),
+  pucSource: object = Object.freeze({})
+) {
+  return service.claim({
+    reservationId: id,
+    slot: attempt.slot,
+    navigationGeneration: navigation.generation,
+    attempt,
+    pucSource,
+  });
+}
+
+function tombstone(
+  service: ReturnType<typeof createReservationService>,
+  navigation: NavigationSession,
+  attempt: RenderAttemptScope,
+  id: string,
+  state: 'disposed' | 'stale'
+) {
+  return service.tombstone(
+    {
+      reservationId: id,
+      slot: attempt.slot,
+      navigationGeneration: navigation.generation,
+      attemptId: attempt.id,
+    },
+    state
+  );
+}
+
+describe('renderer reservation identity and registration', () => {
+  it('atomically adopts unexpired first-display tombstones in the local clock epoch', () => {
+    let now = 100;
+    const service = serviceAt(() => now);
+
+    expect(
+      service.adoptFirstDisplayTombstones({
+        clockEpochMs: 40,
+        tombstones: [
+          { expiresAtMs: 140, reservationId: reservationId(1) },
+          { expiresAtMs: 30, reservationId: reservationId(2) },
+        ],
+      })
+    ).toBe(true);
+    expect(service.recognize(reservationId(1))).toMatchObject({
+      recognized: true,
+      state: 'consumed',
+      expiresAt: 200,
+    });
+    expect(service.recognize(reservationId(2))).toEqual({ recognized: false });
+
+    now = 200;
+    expect(service.recognize(reservationId(1))).toEqual({ recognized: false });
+    expect(service.adoptFirstDisplayTombstones({ clockEpochMs: 200, tombstones: [] })).toBe(false);
+  });
+
+  it('rejects malformed first-display tombstones without publishing a partial set', () => {
+    const service = serviceAt(() => 100);
+
+    expect(
+      service.adoptFirstDisplayTombstones({
+        clockEpochMs: 50,
+        tombstones: [
+          { expiresAtMs: 200, reservationId: reservationId(1) },
+          { expiresAtMs: 210, reservationId: reservationId(1) },
+        ],
+      })
+    ).toBe(false);
+    expect(service.recognize(reservationId(1))).toEqual({ recognized: false });
+  });
+
+  it.each([
+    [reservationId(), true],
+    [`r1_${'A'.repeat(22)}`, true],
+    [`r1_${'_'.repeat(22)}`, true],
+    [`r1_${'-'.repeat(22)}`, true],
+    [`r1_${'a'.repeat(21)}`, false],
+    [`r1_${'a'.repeat(23)}`, false],
+    [`r2_${'a'.repeat(22)}`, false],
+    [`r1_${'a'.repeat(21)}=`, false],
+    [`r1_${'a'.repeat(21)}+`, false],
+    ['', false],
+    [undefined, false],
+  ])('validates the exact server-minted identity %j', (candidate, expected) => {
+    expect(isRendererReservationId(candidate)).toBe(expected);
+  });
+
+  it('copies and freezes one exact APS or ADM source without retaining projection input', () => {
+    const { navigation } = runtimeNavigation();
+    const sources = [apsSource(), admSource()];
+
+    for (const [index, source] of sources.entries()) {
+      const service = serviceAt(() => 5);
+      const attempt = renderAttempt(navigation, `slot-${index}`);
+      const mutable = structuredClone(source) as Record<string, unknown>;
+      expect(registerRender(service, navigation, attempt, reservationId(index), mutable).ok).toBe(
+        true
+      );
+      mutable.width = 1;
+
+      const result = claim(service, navigation, attempt, reservationId(index));
+      expect(result).toMatchObject({ recognized: true, claimed: true });
+      if (!result.recognized || !result.claimed) throw new Error('Expected a claim');
+      const context = attempt.winnerContext;
+      if (!context) throw new Error('Expected an admitted winner context');
+      const admission = service.consumeClaim(result, {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext: context,
+      });
+      expect(admission?.renderSource).toEqual(source);
+      expect(admission?.renderSource).not.toBe(mutable);
+      expect(Object.isFrozen(admission?.renderSource)).toBe(true);
+      expect(Object.isFrozen(admission?.winnerContext)).toBe(true);
+    }
+  });
+
+  it('binds one consumed claim object to its exact attempt source and winner context', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 5);
+    const attempt = renderAttempt(navigation);
+    expect(registerRender(service, navigation, attempt)).toMatchObject({ ok: true });
+    const result = claim(service, navigation, attempt);
+    if (!result.recognized || !result.claimed) throw new Error('Expected a claim');
+    expect(Object.getOwnPropertyNames(result).sort()).toEqual([
+      'claimed',
+      'expiresAt',
+      'pucSource',
+      'recognized',
+    ]);
+    expect(result).not.toHaveProperty('renderSource');
+    expect(result).not.toHaveProperty('winnerContext');
+    const context = attempt.winnerContext;
+    if (!context) throw new Error('Expected an admitted winner context');
+
+    expect(
+      Reflect.apply(service.consumeClaim, service, [
+        result,
+        {
+          attemptId: attempt.id,
+          slot: attempt.slot,
+          navigationGeneration: navigation.generation,
+          winnerContext: context,
+        },
+      ])
+    ).toBeUndefined();
+    const replayedAttempt = Object.freeze({ ...attempt });
+    expect(
+      service.consumeClaim(result, {
+        attempt: replayedAttempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext: context,
+      })
+    ).toBeUndefined();
+    expect(
+      service.consumeClaim(result, {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: Object.freeze({}),
+        winnerContext: context,
+      })
+    ).toBeUndefined();
+    expect(
+      service.consumeClaim(result, {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext: Object.freeze({ selectedCpm: context.selectedCpm }),
+      })
+    ).toBeUndefined();
+    expect(
+      service.consumeClaim(Object.freeze({ ...result }), {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext: context,
+      })
+    ).toBeUndefined();
+
+    const admission = service.consumeClaim(result, {
+      attempt,
+      attemptId: attempt.id,
+      slot: attempt.slot,
+      navigationGeneration: navigation.generation,
+      winnerContext: context,
+    });
+    expect(admission).toEqual({
+      renderSource: admSource(),
+      winnerContext: context,
+    });
+    expect(admission?.winnerContext).toBe(context);
+    expect(Object.isFrozen(admission)).toBe(true);
+    expect(
+      service.consumeClaim(result, {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext: context,
+      })
+    ).toBeUndefined();
+  });
+
+  it.each(['navigation_disposed', 'service_disposed', 'expired'] as const)(
+    'invalidates a consumed claim when its authority is %s',
+    (mode) => {
+      let now = 5;
+      const { navigation } = runtimeNavigation();
+      const service = serviceAt(() => now);
+      const attempt = renderAttempt(navigation);
+      expect(registerRender(service, navigation, attempt)).toMatchObject({ ok: true });
+      const result = claim(service, navigation, attempt);
+      if (!result.recognized || !result.claimed) throw new Error('Expected a claim');
+      const context = attempt.winnerContext;
+      if (!context) throw new Error('Expected an admitted winner context');
+
+      if (mode === 'navigation_disposed') navigation.dispose();
+      else if (mode === 'service_disposed') service.dispose();
+      else now = result.expiresAt;
+
+      expect(
+        service.consumeClaim(result, {
+          attempt,
+          attemptId: attempt.id,
+          slot: attempt.slot,
+          navigationGeneration: navigation.generation,
+          winnerContext: context,
+        })
+      ).toBeUndefined();
+    }
+  );
+
+  it('rejects duplicate identity against live and tombstoned entries without overwriting either', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    const first = renderAttempt(navigation, 'first');
+    const second = renderAttempt(navigation, 'second');
+
+    expect(registerRender(service, navigation, first)).toMatchObject({ ok: true });
+    expect(registerRender(service, navigation, second)).toEqual({
+      ok: false,
+      reason: 'reservation_collision',
+    });
+    expect(claim(service, navigation, first)).toMatchObject({ claimed: true });
+    expect(registerRender(service, navigation, second)).toEqual({
+      ok: false,
+      reason: 'reservation_collision',
+    });
+  });
+
+  it('rejects nonfinite, negative, accessor, and extra-field winner contexts before publication', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    for (const winnerContext of [
+      { selectedCpm: Number.NaN },
+      { selectedCpm: Number.POSITIVE_INFINITY },
+      { selectedCpm: -0.01 },
+      { selectedCpm: 1, extra: true },
+      Object.defineProperty({}, 'selectedCpm', { enumerable: true, get: () => 1 }),
+    ]) {
+      const service = serviceAt(() => 0);
+      expect(
+        service.registerRender({
+          reservationId: reservationId(),
+          slot: attempt.slot,
+          navigation,
+          attemptId: attempt.id,
+          renderSource: admSource(),
+          winnerContext,
+        })
+      ).toEqual({ ok: false, reason: 'invalid_winner_context' });
+      expect(service.snapshotInventoryForTest().size).toBe(0);
+    }
+  });
+
+  it('contains hostile sources, owners, and prototype poisoning without partial live publication', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    const hostileSource = Object.defineProperty({}, 'type', {
+      enumerable: true,
+      get() {
+        throw new Error('hostile getter');
+      },
+    });
+
+    expect(() =>
+      registerRender(service, navigation, attempt, reservationId(), hostileSource)
+    ).not.toThrow();
+    expect(registerRender(service, navigation, attempt, reservationId(), hostileSource)).toEqual({
+      ok: false,
+      reason: 'invalid_render_source',
+    });
+
+    const originalGet = Map.prototype.get;
+    const originalSet = Map.prototype.set;
+    const originalDelete = Map.prototype.delete;
+    Map.prototype.get = function poisonedGet() {
+      throw new Error('poisoned get');
+    };
+    Map.prototype.set = function poisonedSet() {
+      throw new Error('poisoned set');
+    };
+    Map.prototype.delete = function poisonedDelete() {
+      throw new Error('poisoned delete');
+    };
+    try {
+      expect(
+        service.registerRender({
+          reservationId: reservationId(),
+          slot: attempt.slot,
+          navigation: {
+            generation: navigation.generation,
+            isCurrent: () => true,
+            onDispose: vi.fn(),
+          },
+          attemptId: attempt.id,
+          renderSource: admSource(),
+          winnerContext: { selectedCpm: 1.25 },
+        })
+      ).toMatchObject({ ok: true });
+      let adopted: WinnerContext | undefined;
+      expect(
+        service.claim({
+          reservationId: reservationId(),
+          slot: attempt.slot,
+          navigationGeneration: navigation.generation,
+          attempt: {
+            id: attempt.id,
+            slot: attempt.slot,
+            get winnerContext() {
+              return adopted;
+            },
+            isCurrent: () => true,
+            prepareWinnerContext: (context) => {
+              return {
+                commit: () => {
+                  adopted = context;
+                  return true;
+                },
+                rollback: () => {
+                  if (adopted === context) adopted = undefined;
+                  return true;
+                },
+              };
+            },
+          },
+          pucSource: Object.freeze({}),
+        })
+      ).toMatchObject({ claimed: true });
+    } finally {
+      Map.prototype.get = originalGet;
+      Map.prototype.set = originalSet;
+      Map.prototype.delete = originalDelete;
+    }
+  });
+
+  it('uses captured identity and UTF-8 validators after their prototypes are poisoned', () => {
+    const generation = Object.freeze({});
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    const owner: ReservationOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: () => undefined,
+    };
+    const originalRegExpTest = RegExp.prototype.test;
+    const originalTextEncoderEncode = TextEncoder.prototype.encode;
+    let validIdentity: boolean | undefined;
+    let invalidIdentity: boolean | undefined;
+    let invalidSlot: ReturnType<typeof service.registerRender> | undefined;
+    let validRegistration: ReturnType<typeof service.registerRender> | undefined;
+    let thrown: unknown;
+
+    RegExp.prototype.test = function poisonedRegExpTest() {
+      throw new Error('poisoned RegExp.test');
+    };
+    TextEncoder.prototype.encode = function poisonedTextEncoderEncode() {
+      throw new Error('poisoned TextEncoder.encode');
+    };
+    try {
+      validIdentity = isRendererReservationId(reservationId());
+      invalidIdentity = isRendererReservationId('not-a-reservation');
+      invalidSlot = service.registerRender({
+        reservationId: reservationId(),
+        slot: 'x'.repeat(257),
+        navigation: owner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      });
+      validRegistration = service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: owner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      });
+    } catch (error) {
+      thrown = error;
+    } finally {
+      RegExp.prototype.test = originalRegExpTest;
+      TextEncoder.prototype.encode = originalTextEncoderEncode;
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(validIdentity).toBe(true);
+    expect(invalidIdentity).toBe(false);
+    expect(invalidSlot).toEqual({ ok: false, reason: 'invalid_slot' });
+    expect(validRegistration).toMatchObject({ ok: true });
+  });
+
+  it('uses captured code-unit validation when String.charCodeAt returns benign data', () => {
+    const generation = Object.freeze({});
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    const originalCharCodeAt = String.prototype.charCodeAt;
+    const results: ReturnType<typeof service.registerRender>[] = [];
+    String.prototype.charCodeAt = () => 0x61;
+    try {
+      for (const [index, slot] of ['control\u0000slot', 'lone-surrogate\ud800'].entries()) {
+        results[results.length] = service.registerRender({
+          reservationId: reservationId(index),
+          slot,
+          navigation: { generation, isCurrent: () => true, onDispose: () => undefined },
+          attemptId: 'a1_0000000000000000000000',
+          renderSource,
+          winnerContext: { selectedCpm: 1 },
+        });
+      }
+    } finally {
+      String.prototype.charCodeAt = originalCharCodeAt;
+    }
+
+    expect(results).toEqual([
+      { ok: false, reason: 'invalid_slot' },
+      { ok: false, reason: 'invalid_slot' },
+    ]);
+    expect(service.snapshotInventoryForTest().size).toBe(0);
+  });
+
+  it('contains throwing String.charCodeAt poisoning without publishing', () => {
+    const generation = Object.freeze({});
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    const originalCharCodeAt = String.prototype.charCodeAt;
+    let result: ReturnType<typeof service.registerRender> | undefined;
+    let thrown: unknown;
+    String.prototype.charCodeAt = () => {
+      throw new Error('poisoned String.charCodeAt');
+    };
+    try {
+      result = service.registerRender({
+        reservationId: reservationId(),
+        slot: 'control\u0000slot',
+        navigation: { generation, isCurrent: () => true, onDispose: () => undefined },
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      });
+    } catch (error) {
+      thrown = error;
+    } finally {
+      String.prototype.charCodeAt = originalCharCodeAt;
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(result).toEqual({ ok: false, reason: 'invalid_slot' });
+    expect(service.snapshotInventoryForTest().size).toBe(0);
+  });
+
+  it.each([
+    ['throws before applying', false],
+    ['throws after applying', true],
+  ] as const)('contains a captured Map.set that %s', async (_name, applyFirst) => {
+    vi.resetModules();
+    const originalSet = Map.prototype.set;
+    Map.prototype.set = function poisonedReservationSet(key, value) {
+      if (typeof key !== 'string' || !key.startsWith('r1_')) {
+        return Reflect.apply(originalSet, this, [key, value]) as Map<unknown, unknown>;
+      }
+      if (applyFirst) Reflect.apply(originalSet, this, [key, value]);
+      throw new Error('captured reservation Map.set failure');
+    };
+    let isolated: typeof import('../../src/services/reservations');
+    try {
+      isolated = await import('../../src/services/reservations');
+    } finally {
+      Map.prototype.set = originalSet;
+    }
+    const generation = Object.freeze({});
+    let cleanup: (() => void) | undefined;
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = isolated.createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    let result: ReturnType<typeof service.registerRender> | undefined;
+    let thrown: unknown;
+    try {
+      result = service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: {
+          generation,
+          isCurrent: () => true,
+          onDispose: (_kind, callback) => {
+            cleanup = callback;
+          },
+        },
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      });
+    } catch (error) {
+      thrown = error;
+    }
+
+    expect(thrown).toBeUndefined();
+    if (applyFirst) {
+      expect(result).toMatchObject({ ok: true });
+      expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+      cleanup?.();
+      expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    } else {
+      expect(result).toEqual({ ok: false, reason: 'service_disposed' });
+      expect(service.recognize(reservationId())).toEqual({ recognized: false });
+      expect(cleanup).toBeTypeOf('function');
+      expect(() => cleanup?.()).not.toThrow();
+    }
+  });
+
+  it.each([
+    ['throws before applying', false],
+    ['throws after applying', true],
+  ] as const)('contains a captured WeakMap.set that %s', async (_name, applyFirst) => {
+    vi.resetModules();
+    const originalSet = WeakMap.prototype.set;
+    WeakMap.prototype.set = function poisonedOwnerSet(key, value) {
+      const record = value as Record<string, unknown> | undefined;
+      if (!record || !('identity' in record) || !('ready' in record)) {
+        return Reflect.apply(originalSet, this, [key, value]) as WeakMap<object, unknown>;
+      }
+      if (applyFirst) Reflect.apply(originalSet, this, [key, value]);
+      throw new Error('captured owner WeakMap.set failure');
+    };
+    let isolated: typeof import('../../src/services/reservations');
+    try {
+      isolated = await import('../../src/services/reservations');
+    } finally {
+      WeakMap.prototype.set = originalSet;
+    }
+    const generation = Object.freeze({});
+    let cleanup: (() => void) | undefined;
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = isolated.createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    let result: ReturnType<typeof service.registerRender> | undefined;
+    let thrown: unknown;
+    try {
+      result = service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: {
+          generation,
+          isCurrent: () => true,
+          onDispose: (_kind, callback) => {
+            cleanup = callback;
+          },
+        },
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      });
+    } catch (error) {
+      thrown = error;
+    }
+
+    expect(thrown).toBeUndefined();
+    if (applyFirst) {
+      expect(result).toMatchObject({ ok: true });
+      expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+      cleanup?.();
+      expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    } else {
+      expect(result).toEqual({ ok: false, reason: 'stale_owner' });
+      expect(cleanup).toBeUndefined();
+      expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    }
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it('contains a captured WeakMap.get failure in a navigation callback', async () => {
+    vi.resetModules();
+    const originalGet = WeakMap.prototype.get;
+    let poisoned = false;
+    WeakMap.prototype.get = function poisonedOwnerGet(key) {
+      if (poisoned) throw new Error('captured owner WeakMap.get failure');
+      return Reflect.apply(originalGet, this, [key]) as unknown;
+    };
+    let isolated: typeof import('../../src/services/reservations');
+    try {
+      isolated = await import('../../src/services/reservations');
+    } finally {
+      WeakMap.prototype.get = originalGet;
+    }
+    const generation = Object.freeze({});
+    let cleanup: (() => void) | undefined;
+    const renderSource = admSource() as ReservationRenderSource;
+    const service = isolated.createReservationService({
+      now: () => 0,
+      prepareRenderSource: (candidate) => (candidate === renderSource ? renderSource : undefined),
+    });
+    expect(
+      service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: {
+          generation,
+          isCurrent: () => true,
+          onDispose: (_kind, callback) => {
+            cleanup = callback;
+          },
+        },
+        attemptId: 'a1_0000000000000000000000',
+        renderSource,
+        winnerContext: { selectedCpm: 1 },
+      })
+    ).toMatchObject({ ok: true });
+    poisoned = true;
+
+    expect(() => cleanup?.()).not.toThrow();
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it('checks publication identity after the final reentrant owner call', () => {
+    const service = serviceAt(() => 0);
+    const generation = Object.freeze({});
+    let cleanup: (() => void) | undefined;
+    let currentChecks = 0;
+    const owner: ReservationOwner = {
+      generation,
+      isCurrent: () => {
+        currentChecks += 1;
+        if (currentChecks === 3) cleanup?.();
+        return true;
+      },
+      onDispose: (_kind, callback) => {
+        cleanup = callback;
+      },
+    };
+
+    expect(
+      service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: owner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+      })
+    ).toEqual({ ok: false, reason: 'stale_owner' });
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+  });
+
+  it('tombstones a registration if owner generation changes during disposal publication', () => {
+    const service = serviceAt(() => 0);
+    const initialGeneration = Object.freeze({});
+    let generation = initialGeneration;
+    const owner: ReservationOwner = {
+      get generation() {
+        return generation;
+      },
+      isCurrent: () => true,
+      onDispose: () => {
+        generation = Object.freeze({});
+      },
+    };
+
+    expect(
+      service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: owner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+      })
+    ).toEqual({ ok: false, reason: 'stale_owner' });
+    expect(service.recognize(reservationId())).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+  });
+
+  it('preserves the established callback when another identity reuses its live generation', () => {
+    const service = serviceAt(() => 0);
+    const generation = Object.freeze({});
+    let establishedCleanup: (() => void) | undefined;
+    const firstOwner: ReservationOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        establishedCleanup = callback;
+      },
+    };
+    expect(
+      service.registerRender({
+        reservationId: reservationId(),
+        slot: 'first-slot',
+        navigation: firstOwner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+      })
+    ).toMatchObject({ ok: true });
+    const replacementOnDispose = vi.fn(() => {
+      throw new Error('replacement callback publication failed');
+    });
+
+    expect(
+      service.registerRender({
+        reservationId: reservationId(1),
+        slot: 'second-slot',
+        navigation: {
+          generation,
+          isCurrent: () => true,
+          onDispose: replacementOnDispose,
+        },
+        attemptId: 'a1_0000000000000000000001',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 2 },
+      })
+    ).toEqual({ ok: false, reason: 'stale_owner' });
+    expect(replacementOnDispose).not.toHaveBeenCalled();
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+    expect(service.recognize(reservationId(1))).toMatchObject({ state: 'disposed' });
+
+    establishedCleanup?.();
+
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 2,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it('requires a fresh generation when a different owner identity arrives after expiry', () => {
+    let now = 0;
+    const service = serviceAt(() => now);
+    const generation = Object.freeze({});
+    let oldCleanup: (() => void) | undefined;
+    const oldOwner: ReservationOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        oldCleanup = callback;
+      },
+    };
+    const input = {
+      reservationId: reservationId(),
+      slot: 'fictional-slot',
+      attemptId: 'a1_0000000000000000000000',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+    };
+    expect(service.registerRender({ ...input, navigation: oldOwner })).toMatchObject({ ok: true });
+    now = RENDER_RESERVATION_LIFETIME_MS;
+    expect(service.recognize(reservationId())).toEqual({ recognized: false });
+
+    const newOwner: ReservationOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: vi.fn(),
+    };
+    expect(service.registerRender({ ...input, navigation: newOwner })).toEqual({
+      ok: false,
+      reason: 'stale_owner',
+    });
+    expect(newOwner.onDispose).not.toHaveBeenCalled();
+    oldCleanup?.();
+
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+});
+
+describe('fixed expiry, capacity, and tombstones', () => {
+  it('is live exactly before the 15-minute boundary and prunes at and after expiry', () => {
+    for (const offset of [-1, 0, 1]) {
+      let now = 100;
+      const { navigation } = runtimeNavigation();
+      const attempt = renderAttempt(navigation);
+      const service = serviceAt(() => now);
+      const registration = registerRender(service, navigation, attempt);
+      expect(registration).toEqual({ ok: true, expiresAt: 100 + RENDER_RESERVATION_LIFETIME_MS });
+
+      now = 100 + RENDER_RESERVATION_LIFETIME_MS + offset;
+      expect(service.recognize(reservationId()).recognized).toBe(offset < 0);
+    }
+  });
+
+  it.each([
+    [
+      'throwing',
+      (): number => {
+        throw new Error('clock failed');
+      },
+    ],
+    ['nonfinite', (): number => Number.NaN],
+    ['backward', (): number => 99],
+  ] as const)('retains and suppresses every known id after a %s clock fault', (_name, fault) => {
+    let readNow = (): number => 100;
+    const { navigation } = runtimeNavigation();
+    const liveAttempt = renderAttempt(navigation, 'live-slot');
+    const tombstonedAttempt = renderAttempt(navigation, 'tombstoned-slot');
+    const nextAttempt = renderAttempt(navigation, 'next-slot');
+    const service = serviceAt(() => readNow());
+    expect(registerRender(service, navigation, liveAttempt, reservationId())).toMatchObject({
+      ok: true,
+    });
+    expect(registerRender(service, navigation, tombstonedAttempt, reservationId(1))).toMatchObject({
+      ok: true,
+    });
+    expect(tombstone(service, navigation, tombstonedAttempt, reservationId(1), 'disposed')).toBe(
+      true
+    );
+
+    readNow = fault;
+
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+    expect(service.recognize(reservationId(1))).toMatchObject({ state: 'disposed' });
+    expect(claim(service, navigation, liveAttempt)).toEqual({
+      recognized: true,
+      claimed: false,
+      state: 'renderable',
+    });
+    expect(claim(service, navigation, tombstonedAttempt, reservationId(1))).toEqual({
+      recognized: true,
+      claimed: false,
+      state: 'disposed',
+    });
+    expect(registerRender(service, navigation, nextAttempt, reservationId(2))).toEqual({
+      ok: false,
+      reason: 'service_disposed',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      clockFaulted: true,
+      disposed: false,
+      size: 2,
+      live: 1,
+      tombstones: 1,
+    });
+  });
+
+  it('releases live render and lease payloads when navigation disposes after a clock fault', () => {
+    let now = 100;
+    const { navigation, runtime } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => now);
+    expect(registerRender(service, navigation, attempt, reservationId())).toEqual({
+      ok: true,
+      expiresAt: 100 + RENDER_RESERVATION_LIFETIME_MS,
+    });
+    expect(
+      service.registerPrebidLease({
+        reservationId: reservationId(1),
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: Object.freeze({ cpm: 1 }),
+      })
+    ).toEqual({ ok: true, expiresAt: 100 + PREBID_ADMISSION_LEASE_MS });
+    now = Number.NaN;
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+
+    runtime.replaceNavigation();
+
+    expect(service.recognize(reservationId())).toEqual({
+      recognized: true,
+      state: 'disposed',
+      expiresAt: 100 + RENDER_RESERVATION_LIFETIME_MS,
+    });
+    expect(service.recognize(reservationId(1))).toEqual({
+      recognized: true,
+      state: 'aborted',
+      expiresAt: 100 + PREBID_ADMISSION_LEASE_MS,
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      clockFaulted: true,
+      live: 0,
+      tombstones: 2,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it('allows exact explicit terminal tombstones after a clock fault', () => {
+    let now = 100;
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => now);
+    registerRender(service, navigation, attempt, reservationId());
+    const bid = Object.freeze({ cpm: 1 });
+    const registerLease = (id: string, auctionId: string) =>
+      service.registerPrebidLease({
+        reservationId: id,
+        slot: 'fictional-slot',
+        navigation,
+        auctionId,
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: bid,
+      });
+    registerLease(reservationId(1), 'single-auction');
+    registerLease(reservationId(2), 'group-auction');
+    registerLease(reservationId(3), 'group-auction');
+    now = Number.NaN;
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+
+    expect(tombstone(service, navigation, attempt, reservationId(), 'stale')).toBe(true);
+    expect(
+      service.tombstonePrebidLease(
+        {
+          reservationId: reservationId(1),
+          auctionId: 'single-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: navigation.generation,
+        },
+        'prebid_admission_failed'
+      )
+    ).toBe(true);
+    expect(
+      service.tombstonePrebidGroup(
+        {
+          auctionId: 'group-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: navigation.generation,
+        },
+        'prebid_selection_timeout'
+      )
+    ).toBe(2);
+
+    expect(service.recognize(reservationId())).toEqual({
+      recognized: true,
+      state: 'stale',
+      expiresAt: 100 + RENDER_RESERVATION_LIFETIME_MS,
+    });
+    for (const [index, state] of [
+      [1, 'prebid_admission_failed'],
+      [2, 'prebid_selection_timeout'],
+      [3, 'prebid_selection_timeout'],
+    ] as const) {
+      expect(service.recognize(reservationId(index))).toEqual({
+        recognized: true,
+        state,
+        expiresAt: 100 + PREBID_ADMISSION_LEASE_MS,
+      });
+    }
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 4,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it.each([
+    ['negative', (): number => -1],
+    ['nonfinite', (): number => Number.NaN],
+    [
+      'throwing',
+      (): number => {
+        throw new Error('clock failed');
+      },
+    ],
+    ['overflowing deadline', (): number => Number.MAX_VALUE],
+  ] as const)('fails closed without publication for a %s monotonic clock', (_name, now) => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(now);
+
+    expect(registerRender(service, navigation, attempt)).toEqual({
+      ok: false,
+      reason: 'service_disposed',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      disposed: true,
+      size: 0,
+      live: 0,
+      tombstones: 0,
+    });
+  });
+
+  it('prunes safely while Array push and iteration prototypes are poisoned', () => {
+    let now = 0;
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => now);
+    registerRender(service, navigation, attempt);
+    now = RENDER_RESERVATION_LIFETIME_MS;
+    const originalPush = Array.prototype.push;
+    const originalIterator = Array.prototype[Symbol.iterator];
+    let recognition: ReturnType<typeof service.recognize> | undefined;
+    Array.prototype.push = function poisonedPush() {
+      throw new Error('poisoned push');
+    };
+    Array.prototype[Symbol.iterator] = function poisonedIterator() {
+      throw new Error('poisoned iterator');
+    };
+    try {
+      recognition = service.recognize(reservationId());
+    } finally {
+      Array.prototype.push = originalPush;
+      Array.prototype[Symbol.iterator] = originalIterator;
+    }
+    expect(recognition).toEqual({ recognized: false });
+  });
+
+  it('uses captured Map iterator operations after their prototypes are poisoned', () => {
+    let now = 0;
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => now);
+    registerRender(service, navigation, attempt);
+    const originalValues = Map.prototype.values;
+    const originalEntries = Map.prototype.entries;
+    const iteratorPrototype = Object.getPrototypeOf(new Map().values()) as {
+      next: () => IteratorResult<unknown>;
+    };
+    const originalNext = iteratorPrototype.next;
+    let recognition: ReturnType<typeof service.recognize> | undefined;
+    Map.prototype.values = function poisonedValues() {
+      throw new Error('poisoned values');
+    };
+    Map.prototype.entries = function poisonedEntries() {
+      throw new Error('poisoned entries');
+    };
+    iteratorPrototype.next = function poisonedNext() {
+      throw new Error('poisoned next');
+    };
+    now = RENDER_RESERVATION_LIFETIME_MS;
+    try {
+      recognition = service.recognize(reservationId());
+    } finally {
+      Map.prototype.values = originalValues;
+      Map.prototype.entries = originalEntries;
+      iteratorPrototype.next = originalNext;
+    }
+    expect(recognition).toEqual({ recognized: false });
+  });
+
+  it('consumption never extends expiry and leaves only minimum suppression metadata', () => {
+    let now = 200;
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => now);
+    registerRender(service, navigation, attempt);
+    now = 400;
+
+    expect(claim(service, navigation, attempt)).toMatchObject({ claimed: true });
+    expect(service.recognize(reservationId())).toEqual({
+      recognized: true,
+      state: 'consumed',
+      expiresAt: 200 + RENDER_RESERVATION_LIFETIME_MS,
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it.each(['stale', 'disposed'] as const)(
+    'retains an exact %s tombstone through the original expiry',
+    (state) => {
+      let now = 0;
+      const { navigation } = runtimeNavigation();
+      const attempt = renderAttempt(navigation);
+      const service = serviceAt(() => now);
+      registerRender(service, navigation, attempt);
+      now = 50;
+
+      expect(tombstone(service, navigation, attempt, reservationId(), state)).toBe(true);
+      expect(service.recognize(reservationId())).toEqual({
+        recognized: true,
+        state,
+        expiresAt: RENDER_RESERVATION_LIFETIME_MS,
+      });
+      expect(service.snapshotInventoryForTest().entriesWithRenderSource).toBe(0);
+      now = RENDER_RESERVATION_LIFETIME_MS;
+      expect(service.recognize(reservationId())).toEqual({ recognized: false });
+    }
+  );
+
+  it('allows only the exact slot, generation, and attempt owner to tombstone a live entry', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+    const exact = {
+      reservationId: reservationId(),
+      slot: attempt.slot,
+      navigationGeneration: navigation.generation,
+      attemptId: attempt.id,
+    };
+
+    expect(service.tombstone({ ...exact, slot: 'other-slot' }, 'stale')).toBe(false);
+    expect(service.tombstone({ ...exact, navigationGeneration: Object.freeze({}) }, 'stale')).toBe(
+      false
+    );
+    expect(service.tombstone({ ...exact, attemptId: `${attempt.id}-other` }, 'stale')).toBe(false);
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+    expect(service.tombstone(exact, 'stale')).toBe(true);
+  });
+
+  it('rejects invalid runtime tombstone states without changing live entries', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    const bid = Object.freeze({ cpm: 1 });
+    registerRender(service, navigation, attempt, reservationId());
+    for (const index of [1, 2]) {
+      service.registerPrebidLease({
+        reservationId: reservationId(index),
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: bid,
+      });
+    }
+    const hostileState = Object.defineProperty({}, Symbol.toPrimitive, {
+      value() {
+        throw new Error('state must not be coerced');
+      },
+    });
+
+    expect(
+      service.tombstone(
+        {
+          reservationId: reservationId(),
+          slot: attempt.slot,
+          navigationGeneration: navigation.generation,
+          attemptId: attempt.id,
+        },
+        hostileState as never
+      )
+    ).toBe(false);
+    expect(
+      service.tombstonePrebidLease(
+        {
+          reservationId: reservationId(1),
+          auctionId: 'fictional-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: navigation.generation,
+        },
+        'consumed' as never
+      )
+    ).toBe(false);
+    expect(
+      service.tombstonePrebidGroup(
+        {
+          auctionId: 'fictional-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: navigation.generation,
+        },
+        'renderable' as never
+      )
+    ).toBe(0);
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'renderable' });
+    expect(service.recognize(reservationId(1))).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+    expect(service.recognize(reservationId(2))).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({ live: 3, tombstones: 0 });
+  });
+
+  it('shares capacity 320 across live and tombstones, never evicts, and still serves oldest', () => {
+    let now = 0;
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => now);
+    const attempts: RenderAttemptScope[] = [];
+    for (let index = 0; index < 320; index += 1) {
+      const attempt = renderAttempt(navigation, `slot-${index}`);
+      attempts.push(attempt);
+      expect(registerRender(service, navigation, attempt, reservationId(index))).toMatchObject({
+        ok: true,
+      });
+      if (index % 2 === 0) {
+        tombstone(service, navigation, attempt, reservationId(index), 'disposed');
+      }
+    }
+    const overflow = renderAttempt(navigation, 'overflow');
+
+    expect(registerRender(service, navigation, overflow, reservationId(320))).toEqual({
+      ok: false,
+      reason: 'registry_full',
+    });
+    expect(claim(service, navigation, attempts[1]!, reservationId(1))).toMatchObject({
+      claimed: true,
+    });
+    expect(service.snapshotInventoryForTest().size).toBe(320);
+
+    now = RENDER_RESERVATION_LIFETIME_MS;
+    expect(registerRender(service, navigation, overflow, reservationId(320))).toMatchObject({
+      ok: true,
+    });
+  });
+
+  it('automatically tombstones navigation-owned live entries and retains no source/context', () => {
+    const { navigation, runtime } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+
+    runtime.replaceNavigation();
+
+    expect(service.recognize(reservationId())).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it('installs one owner disposer across sequential expired leases', () => {
+    let now = 0;
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => now);
+    const bid = Object.freeze({ cpm: 1 });
+
+    for (let index = 0; index < 1_000; index += 1) {
+      expect(
+        service.registerPrebidLease({
+          reservationId: reservationId(),
+          slot: 'fictional-slot',
+          navigation,
+          auctionId: `auction-${index}`,
+          adUnitCode: 'fictional-slot',
+          renderSource: admSource(),
+          winnerContext: { selectedCpm: 1 },
+          prebidBid: bid,
+        })
+      ).toMatchObject({ ok: true });
+      now += PREBID_ADMISSION_LEASE_MS;
+      expect(service.recognize(reservationId())).toEqual({ recognized: false });
+    }
+
+    expect(navigation.snapshotInventoryForTest().activeDisposers).toBe(1);
+    expect(service.snapshotInventoryForTest().size).toBe(0);
+  });
+
+  it('one owner callback tombstones every live state for its exact generation', () => {
+    const { navigation, runtime } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt, reservationId());
+    service.registerPrebidLease({
+      reservationId: reservationId(1),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: Object.freeze({ cpm: 1 }),
+    });
+
+    expect(navigation.snapshotInventoryForTest().activeDisposers).toBe(1);
+    runtime.replaceNavigation();
+
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'disposed' });
+    expect(service.recognize(reservationId(1))).toMatchObject({ state: 'aborted' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({ live: 0, tombstones: 2 });
+  });
+});
+
+describe('Prebid admission leases and selection', () => {
+  it('marks a navigation-disposed Prebid lease aborted through its original short expiry', () => {
+    const { navigation, runtime } = runtimeNavigation();
+    const service = serviceAt(() => 10);
+    service.registerPrebidLease({
+      reservationId: reservationId(),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: Object.freeze({ cpm: 1 }),
+    });
+
+    runtime.replaceNavigation();
+
+    expect(service.recognize(reservationId())).toEqual({
+      recognized: true,
+      state: 'aborted',
+      expiresAt: 10 + PREBID_ADMISSION_LEASE_MS,
+    });
+  });
+
+  it('does not adopt context when a clock jump makes promotion stale', () => {
+    let now = 0;
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => now);
+    const bid = Object.freeze({ cpm: 1 });
+    service.registerPrebidLease({
+      reservationId: reservationId(),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: bid,
+    });
+    const attempt = renderAttempt(navigation);
+    now = Number.MAX_VALUE;
+
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(),
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      })
+    ).toEqual({ ok: false, reason: 'reservation_not_live' });
+    expect(attempt.winnerContext).toBeUndefined();
+    expect(service.snapshotInventoryForTest().live).toBe(0);
+  });
+
+  it('requires a frozen bid with exact CPM equality and does not retain native Prebid identity', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    const base = {
+      reservationId: reservationId(),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1.25 },
+    };
+
+    expect(service.registerPrebidLease({ ...base, prebidBid: { cpm: 1.25 } })).toEqual({
+      ok: false,
+      reason: 'prebid_cpm_mismatch',
+    });
+    expect(
+      service.registerPrebidLease({ ...base, prebidBid: Object.freeze({ cpm: 2, adId: 'native' }) })
+    ).toEqual({ ok: false, reason: 'prebid_cpm_mismatch' });
+    expect(
+      service.registerPrebidLease({ ...base, prebidBid: Object.freeze({ cpm: 1.25 }) })
+    ).toEqual({ ok: true, expiresAt: PREBID_ADMISSION_LEASE_MS });
+    expect(service.recognize('native')).toEqual({ recognized: false });
+  });
+
+  it('promotes one selected ADM lease from ten seconds to 15 minutes', () => {
+    let now = 10;
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => now);
+    const bid = Object.freeze({ cpm: 1.25 });
+    const base = {
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1.25 },
+      prebidBid: bid,
+    };
+    expect(service.registerPrebidLease({ ...base, reservationId: reservationId(1) })).toEqual({
+      ok: true,
+      expiresAt: 10 + PREBID_ADMISSION_LEASE_MS,
+    });
+    expect(service.registerPrebidLease({ ...base, reservationId: reservationId(2) })).toMatchObject(
+      {
+        ok: true,
+      }
+    );
+    const attempt = renderAttempt(navigation);
+    now = 1_000;
+
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(1),
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      })
+    ).toEqual({ ok: true, expiresAt: 1_000 + RENDER_RESERVATION_LIFETIME_MS });
+    expect(attempt.winnerContext).toEqual({ selectedCpm: 1.25 });
+    expect(service.recognize(reservationId(1))).toMatchObject({
+      recognized: true,
+      state: 'renderable',
+      expiresAt: 1_000 + RENDER_RESERVATION_LIFETIME_MS,
+    });
+    expect(service.recognize(reservationId(2))).toEqual({
+      recognized: true,
+      state: 'unselected',
+      expiresAt: 10 + PREBID_ADMISSION_LEASE_MS,
+    });
+    const selected = claim(service, navigation, attempt, reservationId(1));
+    const winnerContext = attempt.winnerContext;
+    if (!selected.recognized || !selected.claimed || !winnerContext) {
+      throw new Error('Expected the promoted ADM lease to remain claimable');
+    }
+    expect(
+      service.consumeClaim(selected, {
+        attempt,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext,
+      })
+    ).toEqual({ renderSource: admSource(), winnerContext });
+  });
+
+  it('promotes only before the admission boundary and prunes at and after ten seconds', () => {
+    for (const offset of [-1, 0, 1]) {
+      let now = 100;
+      const { navigation } = runtimeNavigation();
+      const service = serviceAt(() => now);
+      const bid = Object.freeze({ cpm: 1 });
+      service.registerPrebidLease({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: bid,
+      });
+      const attempt = renderAttempt(navigation);
+      now = 100 + PREBID_ADMISSION_LEASE_MS + offset;
+
+      const result = service.promotePrebidSelection({
+        reservationId: reservationId(),
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      });
+      expect(result.ok).toBe(offset < 0);
+      expect(service.recognize(reservationId()).recognized).toBe(offset < 0);
+    }
+  });
+
+  it('tombstones losers only in the selected exact auction and ad unit', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    const bid = Object.freeze({ cpm: 1 });
+    const register = (id: string, auctionId: string, adUnitCode: string) =>
+      service.registerPrebidLease({
+        reservationId: id,
+        slot: adUnitCode,
+        navigation,
+        auctionId,
+        adUnitCode,
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: bid,
+      });
+    register(reservationId(1), 'selected-auction', 'selected-slot');
+    register(reservationId(2), 'selected-auction', 'selected-slot');
+    register(reservationId(3), 'other-auction', 'selected-slot');
+    register(reservationId(4), 'selected-auction', 'other-slot');
+    const attempt = renderAttempt(navigation, 'selected-slot');
+
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(1),
+        auctionId: 'selected-auction',
+        adUnitCode: 'selected-slot',
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      })
+    ).toMatchObject({ ok: true });
+    expect(service.recognize(reservationId(2))).toMatchObject({ state: 'unselected' });
+    expect(service.recognize(reservationId(3))).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+    expect(service.recognize(reservationId(4))).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+  });
+
+  it('does not tombstone a same-string loser owned by another navigation generation', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    const bid = Object.freeze({ cpm: 1 });
+    const selected = renderAttempt(navigation, 'fictional-slot');
+    service.registerPrebidLease({
+      reservationId: reservationId(1),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'reused-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: bid,
+    });
+    const otherGeneration = Object.freeze({});
+    service.registerPrebidLease({
+      reservationId: reservationId(2),
+      slot: 'fictional-slot',
+      navigation: {
+        generation: otherGeneration,
+        isCurrent: () => true,
+        onDispose: vi.fn(),
+      },
+      auctionId: 'reused-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: bid,
+    });
+
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(1),
+        auctionId: 'reused-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+        attempt: selected,
+        prebidBid: bid,
+      })
+    ).toMatchObject({ ok: true });
+    expect(service.recognize(reservationId(2))).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+  });
+
+  it('promotes and tombstones losers atomically under poisoned Array prototypes', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    const bid = Object.freeze({ cpm: 1 });
+    for (const id of [reservationId(1), reservationId(2)]) {
+      service.registerPrebidLease({
+        reservationId: id,
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: bid,
+      });
+    }
+    const attempt = renderAttempt(navigation);
+    const originalPush = Array.prototype.push;
+    const originalIterator = Array.prototype[Symbol.iterator];
+    let result: ReturnType<typeof service.promotePrebidSelection> | undefined;
+    Array.prototype.push = function poisonedPush() {
+      throw new Error('poisoned push');
+    };
+    Array.prototype[Symbol.iterator] = function poisonedIterator() {
+      throw new Error('poisoned iterator');
+    };
+    try {
+      result = service.promotePrebidSelection({
+        reservationId: reservationId(1),
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      });
+    } finally {
+      Array.prototype.push = originalPush;
+      Array.prototype[Symbol.iterator] = originalIterator;
+    }
+    expect(result).toMatchObject({ ok: true });
+    expect(service.recognize(reservationId(2))).toMatchObject({ state: 'unselected' });
+  });
+
+  it.each(['aborted', 'prebid_selection_timeout', 'unselected'] as const)(
+    'tombstones %s leases only through their original admission expiry',
+    (reason) => {
+      let now = 25;
+      const { navigation } = runtimeNavigation();
+      const service = serviceAt(() => now);
+      service.registerPrebidLease({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 0 },
+        prebidBid: Object.freeze({ cpm: 0 }),
+      });
+      now = 50;
+
+      expect(
+        service.tombstonePrebidGroup(
+          {
+            auctionId: 'fictional-auction',
+            adUnitCode: 'fictional-slot',
+            navigationGeneration: navigation.generation,
+          },
+          reason
+        )
+      ).toBe(1);
+      expect(service.recognize(reservationId())).toEqual({
+        recognized: true,
+        state: reason,
+        expiresAt: 25 + PREBID_ADMISSION_LEASE_MS,
+      });
+    }
+  );
+
+  it('makes a stale navigation Prebid group tombstone callback inert', () => {
+    const { navigation } = runtimeNavigation();
+    const service = serviceAt(() => 0);
+    service.registerPrebidLease({
+      reservationId: reservationId(),
+      slot: 'fictional-slot',
+      navigation,
+      auctionId: 'reused-auction',
+      adUnitCode: 'fictional-slot',
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: Object.freeze({ cpm: 1 }),
+    });
+
+    expect(
+      service.tombstonePrebidGroup(
+        {
+          auctionId: 'reused-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: Object.freeze({}),
+        },
+        'aborted'
+      )
+    ).toBe(0);
+    expect(service.recognize(reservationId())).toMatchObject({
+      state: 'awaiting_prebid_selection',
+    });
+    expect(
+      service.tombstonePrebidGroup(
+        {
+          auctionId: 'reused-auction',
+          adUnitCode: 'fictional-slot',
+          navigationGeneration: navigation.generation,
+        },
+        'aborted'
+      )
+    ).toBe(1);
+  });
+
+  it('suppresses and contract-failure tombstones a PUC claim against a preselection lease', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    service.registerPrebidLease({
+      reservationId: reservationId(),
+      slot: attempt.slot,
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: attempt.slot,
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: Object.freeze({ cpm: 1 }),
+    });
+
+    expect(claim(service, navigation, attempt)).toEqual({
+      recognized: true,
+      claimed: false,
+      state: 'prebid_contract_violation',
+    });
+    expect(service.recognize(reservationId())).toEqual({
+      recognized: true,
+      state: 'prebid_contract_violation',
+      expiresAt: PREBID_ADMISSION_LEASE_MS,
+    });
+    expect(attempt.winnerContext).toBeUndefined();
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it.each(['prebid_admission_failed', 'prebid_contract_violation'] as const)(
+    'tombstones exact-owner %s admission failure through the original lease',
+    (state) => {
+      const { navigation } = runtimeNavigation();
+      const service = serviceAt(() => 0);
+      service.registerPrebidLease({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation,
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+        prebidBid: Object.freeze({ cpm: 1 }),
+      });
+      const exact = {
+        reservationId: reservationId(),
+        auctionId: 'fictional-auction',
+        adUnitCode: 'fictional-slot',
+        navigationGeneration: navigation.generation,
+      };
+
+      expect(
+        service.tombstonePrebidLease({ ...exact, navigationGeneration: Object.freeze({}) }, state)
+      ).toBe(false);
+      expect(service.tombstonePrebidLease(exact, state)).toBe(true);
+      expect(service.recognize(reservationId())).toEqual({
+        recognized: true,
+        state,
+        expiresAt: PREBID_ADMISSION_LEASE_MS,
+      });
+    }
+  );
+});
+
+describe('atomic claims and disposal', () => {
+  it('does not acquire, transfer, or consume for a mismatched slot, generation, attempt, or stale owner', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    const source = Object.freeze({});
+    const cases = [
+      { slot: 'other-slot', generation: navigation.generation, attempted: attempt },
+      { slot: attempt.slot, generation: Object.freeze({}), attempted: attempt },
+      {
+        slot: attempt.slot,
+        generation: navigation.generation,
+        attempted: { ...attempt, id: `${attempt.id}-other` },
+      },
+      {
+        slot: attempt.slot,
+        generation: navigation.generation,
+        attempted: { ...attempt, isCurrent: () => false },
+      },
+    ];
+
+    for (const [index, candidate] of cases.entries()) {
+      const id = reservationId(index + 10);
+      registerRender(service, navigation, attempt, id);
+      expect(
+        service.claim({
+          reservationId: id,
+          slot: candidate.slot,
+          navigationGeneration: candidate.generation,
+          attempt: candidate.attempted,
+          pucSource: source,
+        })
+      ).toEqual({ recognized: true, claimed: false, state: 'renderable' });
+      expect(service.recognize(id)).toMatchObject({ state: 'renderable' });
+    }
+    expect(attempt.winnerContext).toBeUndefined();
+    expect(service.snapshotInventoryForTest().entriesWithPucSource).toBe(0);
+  });
+  it('preserves one ADM source and immutable context after registration input mutation', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    const source = admSource();
+    const context = { selectedCpm: 7.5 };
+    service.registerRender({
+      reservationId: reservationId(),
+      slot: attempt.slot,
+      navigation,
+      attemptId: attempt.id,
+      renderSource: source,
+      winnerContext: context,
+    });
+    context.selectedCpm = 99;
+    const observedStates: string[] = [];
+    const sink = {
+      id: attempt.id,
+      slot: attempt.slot,
+      get winnerContext(): WinnerContext | undefined {
+        return attempt.winnerContext;
+      },
+      isCurrent: () => attempt.isCurrent(),
+      prepareWinnerContext(winnerContext: WinnerContext) {
+        const recognition = service.recognize(reservationId());
+        if (recognition.recognized) observedStates.push(recognition.state);
+        return attempt.prepareWinnerContext(winnerContext);
+      },
+    };
+
+    const result = service.claim({
+      reservationId: reservationId(),
+      slot: attempt.slot,
+      navigationGeneration: navigation.generation,
+      attempt: sink,
+      pucSource: Object.freeze({}),
+    });
+
+    expect(observedStates).toEqual(['renderable']);
+    expect(result).toMatchObject({ recognized: true, claimed: true });
+    expect(attempt.winnerContext).toEqual({ selectedCpm: 7.5 });
+    expect(Object.isFrozen(attempt.winnerContext)).toBe(true);
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'consumed' });
+    const winnerContext = attempt.winnerContext;
+    if (!result.recognized || !result.claimed || !winnerContext) {
+      throw new Error('Expected one claimed ADM winner');
+    }
+    expect(
+      service.consumeClaim(result, {
+        attempt: sink,
+        attemptId: attempt.id,
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        winnerContext,
+      })
+    ).toEqual({ renderSource: source, winnerContext });
+  });
+
+  it('allows exactly one of two simultaneous/reentrant claims and never replaces its PUC source', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+    const firstSource = Object.freeze({ name: 'first' });
+    const secondSource = Object.freeze({ name: 'second' });
+    let nested: ReturnType<typeof service.claim> | undefined;
+    let acceptedContext: WinnerContext | undefined;
+    const sink = {
+      id: attempt.id,
+      slot: attempt.slot,
+      get winnerContext(): WinnerContext | undefined {
+        return acceptedContext;
+      },
+      isCurrent: () => true,
+      prepareWinnerContext(context: WinnerContext) {
+        return {
+          commit(): boolean {
+            nested = service.claim({
+              reservationId: reservationId(),
+              slot: attempt.slot,
+              navigationGeneration: navigation.generation,
+              attempt: sink,
+              pucSource: secondSource,
+            });
+            acceptedContext = context;
+            return true;
+          },
+          rollback(): boolean {
+            if (acceptedContext === context) acceptedContext = undefined;
+            return true;
+          },
+        };
+      },
+    };
+
+    const first = service.claim({
+      reservationId: reservationId(),
+      slot: attempt.slot,
+      navigationGeneration: navigation.generation,
+      attempt: sink,
+      pucSource: firstSource,
+    });
+
+    expect(first).toMatchObject({ recognized: true, claimed: true, pucSource: firstSource });
+    expect(nested).toEqual({ recognized: true, claimed: false, state: 'renderable' });
+    expect(claim(service, navigation, attempt, reservationId(), secondSource)).toEqual({
+      recognized: true,
+      claimed: false,
+      state: 'consumed',
+    });
+  });
+
+  it('terminally suppresses a throwing context preparation without retaining PUC source', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+    const throwingSink = {
+      id: attempt.id,
+      slot: attempt.slot,
+      winnerContext: undefined,
+      isCurrent: () => true,
+      prepareWinnerContext() {
+        throw new Error('partial transfer failed');
+      },
+    };
+
+    expect(
+      service.claim({
+        reservationId: reservationId(),
+        slot: attempt.slot,
+        navigationGeneration: navigation.generation,
+        attempt: throwingSink,
+        pucSource: Object.freeze({}),
+      })
+    ).toEqual({ recognized: true, claimed: false, state: 'stale' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it('terminally suppresses a claim when winner admission mutates, reenters, and throws', () => {
+    const { navigation } = runtimeNavigation();
+    const realAttempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, realAttempt);
+    const firstSource = Object.freeze({ name: 'first' });
+    const secondSource = Object.freeze({ name: 'second' });
+    let accepted: WinnerContext | undefined;
+    let nested: ReturnType<typeof service.claim> | undefined;
+    const attempt = {
+      id: realAttempt.id,
+      slot: realAttempt.slot,
+      get winnerContext(): WinnerContext | undefined {
+        return accepted;
+      },
+      isCurrent: () => true,
+      prepareWinnerContext(context: WinnerContext) {
+        return {
+          commit(): boolean {
+            accepted = context;
+            nested = service.claim({
+              reservationId: reservationId(),
+              slot: realAttempt.slot,
+              navigationGeneration: navigation.generation,
+              attempt,
+              pucSource: secondSource,
+            });
+            throw new Error('commit failed after mutation');
+          },
+          rollback(): boolean {
+            if (accepted === context) accepted = undefined;
+            return true;
+          },
+        };
+      },
+    };
+
+    expect(
+      service.claim({
+        reservationId: reservationId(),
+        slot: realAttempt.slot,
+        navigationGeneration: navigation.generation,
+        attempt,
+        pucSource: firstSource,
+      })
+    ).toEqual({ recognized: true, claimed: false, state: 'stale' });
+    expect(nested).toEqual({ recognized: true, claimed: false, state: 'renderable' });
+    expect(accepted).toBeUndefined();
+    expect(claim(service, navigation, realAttempt, reservationId(), secondSource)).toEqual({
+      recognized: true,
+      claimed: false,
+      state: 'stale',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it('terminally suppresses a Prebid promotion when winner admission has unknown postcondition', () => {
+    const { navigation } = runtimeNavigation();
+    const realAttempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    const bid = Object.freeze({ cpm: 1 });
+    service.registerPrebidLease({
+      reservationId: reservationId(),
+      slot: realAttempt.slot,
+      navigation,
+      auctionId: 'fictional-auction',
+      adUnitCode: realAttempt.slot,
+      renderSource: admSource(),
+      winnerContext: { selectedCpm: 1 },
+      prebidBid: bid,
+    });
+    let accepted: WinnerContext | undefined;
+    const attempt = {
+      id: realAttempt.id,
+      slot: realAttempt.slot,
+      get winnerContext(): WinnerContext | undefined {
+        throw new Error('winner context postcondition unavailable');
+      },
+      isCurrent: () => true,
+      prepareWinnerContext(context: WinnerContext) {
+        return {
+          commit(): boolean {
+            accepted = context;
+            return true;
+          },
+          rollback(): boolean {
+            if (accepted === context) accepted = undefined;
+            return true;
+          },
+        };
+      },
+    };
+
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(),
+        auctionId: 'fictional-auction',
+        adUnitCode: realAttempt.slot,
+        navigationGeneration: navigation.generation,
+        attempt,
+        prebidBid: bid,
+      })
+    ).toEqual({ ok: false, reason: 'invalid_attempt' });
+    expect(accepted).toBeUndefined();
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'stale' });
+    expect(
+      service.promotePrebidSelection({
+        reservationId: reservationId(),
+        auctionId: 'fictional-auction',
+        adUnitCode: realAttempt.slot,
+        navigationGeneration: navigation.generation,
+        attempt: realAttempt,
+        prebidBid: bid,
+      })
+    ).toEqual({ ok: false, reason: 'reservation_not_live' });
+  });
+
+  it('uses captured freezing during a claim without retaining busy claim state', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+    const pucSource = Object.freeze({});
+    const originalFreeze = Object.freeze;
+    let result: ReturnType<typeof service.claim> | undefined;
+    let thrown: unknown;
+
+    Object.freeze = function poisonedFreeze() {
+      throw new Error('poisoned Object.freeze');
+    };
+    try {
+      result = claim(service, navigation, attempt, reservationId(), pucSource);
+    } catch (error) {
+      thrown = error;
+    } finally {
+      Object.freeze = originalFreeze;
+    }
+
+    expect(thrown).toBeUndefined();
+    expect(result).toMatchObject({ recognized: true, claimed: true });
+    expect(service.recognize(reservationId())).toMatchObject({ state: 'consumed' });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithPucSource: 0,
+    });
+  });
+
+  it('retains only a disposed suppression tombstone when owner publication rolls back', () => {
+    const service = serviceAt(() => 0);
+    const generation = Object.freeze({});
+    const owner: ReservationOwner = {
+      generation,
+      isCurrent: () => true,
+      onDispose: (_kind, callback) => {
+        callback();
+        throw new Error('publication failed after disposal');
+      },
+    };
+
+    expect(
+      service.registerRender({
+        reservationId: reservationId(),
+        slot: 'fictional-slot',
+        navigation: owner,
+        attemptId: 'a1_0000000000000000000000',
+        renderSource: admSource(),
+        winnerContext: { selectedCpm: 1 },
+      })
+    ).toEqual({ ok: false, reason: 'stale_owner' });
+    expect(service.recognize(reservationId())).toMatchObject({
+      recognized: true,
+      state: 'disposed',
+    });
+    expect(service.snapshotInventoryForTest()).toMatchObject({
+      live: 0,
+      tombstones: 1,
+      entriesWithRenderSource: 0,
+      entriesWithWinnerContext: 0,
+    });
+  });
+
+  it('disposes the whole runtime store without making old identities reusable in that service', () => {
+    const { navigation } = runtimeNavigation();
+    const attempt = renderAttempt(navigation);
+    const service = serviceAt(() => 0);
+    registerRender(service, navigation, attempt);
+
+    service.dispose();
+
+    expect(service.snapshotInventoryForTest()).toMatchObject({ disposed: true, size: 0 });
+    expect(registerRender(service, navigation, attempt)).toEqual({
+      ok: false,
+      reason: 'service_disposed',
+    });
+    expect(service.recognize(reservationId())).toEqual({ recognized: false });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/slots.test.ts b/crates/trusted-server-js/lib/test/services/slots.test.ts
new file mode 100644
index 000000000..3592932b4
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/slots.test.ts
@@ -0,0 +1,4982 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  createBrowserGoogletagAdapter,
+  GoogletagReplacementError,
+  type GoogletagAdapter,
+  type GoogletagFacade,
+  type GoogletagPublisherCallAdmission,
+  type GoogletagReplacementCommitAdmission,
+  type GoogletagReplacementDefinition,
+  type GptSlotTokenV1,
+} from '../../src/adapters/googletag';
+import { createTestNavigationIdentityIssuer } from '../../src/kernel/identity';
+import { createRuntimeSession, type NavigationSession } from '../../src/kernel/sessions';
+import {
+  MAX_ACTIVE_SLOT_RECORDS,
+  createBrowserSlotReconciliationBoundary,
+  createSlotService,
+  type GptSlotBinding,
+  type SlotReconciliationBoundary,
+  type SlotRegistration,
+  type SlotService,
+} from '../../src/services/slots';
+import {
+  bindCommittedArtifactRetirement,
+  createCommittedArtifactStore,
+  type CommittedRenderArtifact,
+} from '../../src/services/render';
+
+function createNavigation(): NavigationSession {
+  return createRuntimeWithNavigation().navigation;
+}
+
+function committedArtifact(navigationGeneration: object): CommittedRenderArtifact {
+  return Object.freeze({
+    attemptId: `a1_${'c'.repeat(22)}`,
+    dispose: vi.fn(),
+    kind: 'aps_mount' as const,
+    navigationGeneration,
+    slot: 'slot',
+  });
+}
+
+function createRuntimeWithNavigation() {
+  const runtime = createRuntimeSession({
+    createIdentityIssuer: () =>
+      createTestNavigationIdentityIssuer({
+        getRandomValues: (target) => {
+          target.fill(1);
+          return target;
+        },
+      }),
+  });
+  const result = runtime.startInitialNavigation();
+  if (!result.ok) throw new Error('Expected a navigation');
+  return { navigation: result.value, runtime };
+}
+
+function createGptHarness(
+  options: {
+    initialLoadDisabled?: boolean;
+    deferDestroyedResult?: boolean;
+    missingRefresh?: boolean;
+    orphanOnReplace?: object;
+    returnOldOnReplace?: boolean;
+    synchronousRun?: boolean;
+    servicesEnabled?: boolean;
+  } = {}
+) {
+  const listeners = new Map<string, Set<(event: unknown) => void>>();
+  const slots: object[] = [];
+  const display = vi.fn();
+  const refresh = vi.fn();
+  const destroySlots = vi.fn((_slots: readonly object[]) => true);
+  const defineSlot = vi.fn(
+    (_path: string, _sizes: unknown, elementId: string): object | undefined => {
+      const slot = { elementId, replacement: true };
+      slots.push(slot);
+      return slot;
+    }
+  );
+  const addService = vi.fn();
+  const operationDisposals: Array<ReturnType<typeof vi.fn>> = [];
+  const bindingToken = Object.freeze({});
+  const traceTokens = new WeakMap<object, GptSlotTokenV1>();
+  let nextTraceToken = 1;
+  let deferredDestroyedResolved = false;
+  let resolveDeferredDestroyedPromise!: () => void;
+  const deferredDestroyedPromise = new Promise<void>((resolve) => {
+    resolveDeferredDestroyedPromise = resolve;
+  });
+  let deferredDestroyedUsed = false;
+  const facade: GoogletagFacade = Object.freeze({
+    bindingToken: () => bindingToken,
+    clearTargeting: vi.fn(),
+    enableServices: vi.fn(),
+    transactionalDefine: () => Object.freeze({ status: 'discarded' as const }),
+    display,
+    getTargeting: vi.fn(() => []),
+    observeTargeting: () => Object.assign(vi.fn(), { isCurrent: () => true }),
+    refresh: options.missingRefresh
+      ? (undefined as unknown as GoogletagFacade['refresh'])
+      : refresh,
+    serviceState: () =>
+      Object.freeze({
+        apiReady: true,
+        initialLoadDisabled: options.initialLoadDisabled === true,
+        pubadsReady: options.servicesEnabled !== false,
+      }),
+    setTargeting: vi.fn(),
+    slotElementId: () => undefined,
+    slots: () => Object.freeze([...slots]),
+    subscribe: (eventType: string, listener: (event: unknown) => void) => {
+      const registered = listeners.get(eventType) ?? new Set();
+      registered.add(listener);
+      listeners.set(eventType, registered);
+      return () => registered.delete(listener);
+    },
+    transactionalReplace: (
+      oldSlot: object,
+      definition: GoogletagReplacementDefinition | undefined,
+      isCurrent: () => boolean,
+      prepareCommit: (replacement: object) => GoogletagReplacementCommitAdmission
+    ) => {
+      if (!destroySlots([oldSlot])) throw new Error('gpt_request_failed');
+      if (!definition || !isCurrent()) return Object.freeze({ status: 'destroyed' as const });
+      const replacement = options.returnOldOnReplace
+        ? oldSlot
+        : defineSlot(definition.adUnitPath, definition.sizes, definition.elementId);
+      if (!replacement) throw new GoogletagReplacementError(undefined, true);
+      if (replacement === oldSlot) {
+        if (!destroySlots([replacement])) {
+          throw new GoogletagReplacementError(replacement, true);
+        }
+        throw new GoogletagReplacementError(undefined, true);
+      }
+      if (!isCurrent()) {
+        destroySlots([replacement]);
+        return Object.freeze({ status: 'destroyed' as const });
+      }
+      addService(replacement);
+      if (options.orphanOnReplace) {
+        throw new GoogletagReplacementError(options.orphanOnReplace, true);
+      }
+      if (!isCurrent()) {
+        destroySlots([replacement]);
+        return Object.freeze({ status: 'destroyed' as const });
+      }
+      const admission = prepareCommit(replacement);
+      if (!admission.commit()) {
+        admission.rollback();
+        destroySlots([replacement]);
+        throw new Error('gpt_request_failed');
+      }
+      if (!isCurrent()) {
+        admission.rollback();
+        destroySlots([replacement]);
+        return Object.freeze({ status: 'destroyed' as const });
+      }
+      return Object.freeze({ status: 'replaced' as const, slot: replacement });
+    },
+  });
+  const adapter: GoogletagAdapter = Object.freeze({
+    bindingStatus: () => 'present',
+    enqueueGamAttribution: vi.fn(() => true),
+    diagnosticsIdentity: () => undefined,
+    dispose: vi.fn(),
+    notifyReady: vi.fn(),
+    observeDiagnostics: () => vi.fn(),
+    observePublisherCalls: () => vi.fn(),
+    traceToken: (slot: object) => {
+      let token = traceTokens.get(slot);
+      if (!token) {
+        token = `gt1_${nextTraceToken.toString(36)}` as GptSlotTokenV1;
+        nextTraceToken += 1;
+        traceTokens.set(slot, token);
+      }
+      return token;
+    },
+    run: <T>(command: (gpt: Readonly<GoogletagFacade>) => T) => {
+      let disposed = false;
+      const dispose = vi.fn(() => {
+        disposed = true;
+      });
+      operationDisposals.push(dispose);
+      let result: Promise<T>;
+      if (options.synchronousRun !== false) {
+        try {
+          const value = command(facade);
+          const deferResult =
+            options.deferDestroyedResult === true &&
+            !deferredDestroyedUsed &&
+            typeof value === 'object' &&
+            value !== null &&
+            'status' in value &&
+            value.status === 'destroyed';
+          if (deferResult) {
+            deferredDestroyedUsed = true;
+            result = deferredDestroyedPromise.then(() => value);
+          } else {
+            result = Promise.resolve(value);
+          }
+        } catch (error) {
+          result = Promise.reject(error);
+        }
+      } else {
+        result = Promise.resolve().then(() => {
+          if (disposed) throw new Error('disposed');
+          return command(facade);
+        });
+      }
+      return Object.freeze({
+        status: 'present' as const,
+        result,
+        dispose,
+      });
+    },
+  });
+  return {
+    adapter,
+    addService,
+    defineSlot,
+    destroySlots,
+    display,
+    emit: (type: string, event: unknown) => {
+      for (const listener of listeners.get(type) ?? []) listener(event);
+    },
+    facade,
+    operationDisposals,
+    refresh,
+    resolveDeferredDestroyed: () => {
+      if (deferredDestroyedResolved) return;
+      deferredDestroyedResolved = true;
+      resolveDeferredDestroyedPromise();
+    },
+  };
+}
+
+function serverRegistration(
+  id: string,
+  overrides: Partial<SlotRegistration> = {}
+): SlotRegistration {
+  return {
+    registeredSlotId: id,
+    source: 'server',
+    ...overrides,
+  };
+}
+
+function bindTrustedSlot(service: SlotService, navigation: NavigationSession, id = 'slot') {
+  const slot = { id };
+  expect(
+    service.register(navigation, [
+      serverRegistration(id, {
+        adUnitCode: `/network/${id}`,
+        domAliases: [`${id}-div`],
+      }),
+    ])
+  ).toMatchObject({ ok: true });
+  expect(
+    service.adoptGptSlot(navigation.generation, id, {
+      definition: {
+        adUnitPath: `/network/${id}`,
+        elementId: `${id}-div`,
+        sizes: Object.freeze([[300, 250]]),
+      },
+      ownership: 'trusted_server',
+      slot,
+    })
+  ).toEqual({ ok: true });
+  return slot;
+}
+
+function createReconciliationBoundary() {
+  let listener: (() => void) | undefined;
+  const connected = new WeakSet<object>();
+  const elements = new Map<string, object[]>();
+  const observe = vi.fn((callback: () => void) => {
+    listener = callback;
+    return vi.fn(() => {
+      if (listener === callback) listener = undefined;
+    });
+  });
+  const boundary: SlotReconciliationBoundary = Object.freeze({
+    observe,
+    isConnected: (element: object) => connected.has(element),
+    resolve: (elementIds: readonly string[]) => {
+      const matches = new Set<object>();
+      let matchedId: string | undefined;
+      for (const elementId of elementIds) {
+        for (const element of elements.get(elementId) ?? []) {
+          if (!connected.has(element)) continue;
+          matches.add(element);
+          matchedId = elementId;
+        }
+      }
+      if (matches.size === 0) return Object.freeze({ status: 'unresolved' as const });
+      if (matches.size !== 1 || matchedId === undefined) {
+        return Object.freeze({ status: 'ambiguous' as const });
+      }
+      return Object.freeze({
+        status: 'unique' as const,
+        element: [...matches][0]!,
+        elementId: matchedId,
+      });
+    },
+  });
+  const put = (elementId: string, element: object): void => {
+    connected.add(element);
+    elements.set(elementId, [element]);
+  };
+  const replace = (elementId: string, element: object): void => {
+    const previous = elements.get(elementId) ?? [];
+    for (const candidate of previous) connected.delete(candidate);
+    put(elementId, element);
+    listener?.();
+  };
+  const replaceAmbiguously = (elementId: string, replacements: readonly object[]): void => {
+    const previous = elements.get(elementId) ?? [];
+    for (const candidate of previous) connected.delete(candidate);
+    for (const replacement of replacements) connected.add(replacement);
+    elements.set(elementId, [...replacements]);
+    listener?.();
+  };
+  const disconnect = (elementId: string): void => {
+    for (const candidate of elements.get(elementId) ?? []) connected.delete(candidate);
+    elements.delete(elementId);
+    listener?.();
+  };
+  return {
+    boundary,
+    disconnect,
+    observe,
+    put,
+    replace,
+    replaceAmbiguously,
+    trigger: () => listener?.(),
+  };
+}
+
+describe('slot registry', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('copies the adapter-owned canonical token into the adopted SlotRecord', () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const physical = {};
+    expect(service.register(navigation, [serverRegistration('token-slot')])).toMatchObject({
+      ok: true,
+    });
+
+    expect(
+      service.adoptGptSlot(navigation.generation, 'token-slot', {
+        ownership: 'publisher',
+        slot: physical,
+      })
+    ).toEqual({ ok: true });
+    const record = service.resolveRegisteredSlot('token-slot');
+    expect(record?.traceToken).toBe('gt1_1');
+    expect(Object.isFrozen(record)).toBe(true);
+    expect(harness.adapter.traceToken(physical)).toBe(record?.traceToken);
+  });
+
+  it('accepts exact nonempty 256-byte ids and rejects empty, 257-byte, and ASCII controls', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const valid = `${'a'.repeat(254)}é`;
+
+    expect(new TextEncoder().encode(valid)).toHaveLength(256);
+    expect(service.register(navigation, [serverRegistration(valid)])).toMatchObject({ ok: true });
+
+    for (const invalid of [
+      '',
+      'a'.repeat(257),
+      'nul\0id',
+      'line\nid',
+      `del${String.fromCharCode(0x7f)}id`,
+    ]) {
+      expect(service.register(navigation, [serverRegistration(invalid)])).toEqual({
+        ok: false,
+        reason: 'invalid_slot_id',
+      });
+    }
+
+    expect(
+      service.register(navigation, [serverRegistration(`c1${String.fromCharCode(0x85)}id`)])
+    ).toMatchObject({ ok: true });
+  });
+
+  it('reserves the combined 256-record capacity atomically', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const first = Array.from({ length: 255 }, (_, index) => serverRegistration(`server-${index}`));
+
+    expect(service.register(navigation, first)).toMatchObject({ ok: true });
+    expect(
+      service.register(navigation, [
+        { registeredSlotId: 'programmatic-256', source: 'programmatic' },
+      ])
+    ).toMatchObject({ ok: true });
+    expect(service.snapshotForTest().records).toBe(MAX_ACTIVE_SLOT_RECORDS);
+    expect(
+      service.register(navigation, [
+        { registeredSlotId: 'programmatic-257', source: 'programmatic' },
+      ])
+    ).toEqual({ ok: false, reason: 'registry_capacity' });
+    expect(service.resolveRegisteredSlot('programmatic-257')).toBeUndefined();
+    expect(service.snapshotForTest().records).toBe(MAX_ACTIVE_SLOT_RECORDS);
+  });
+
+  it('snapshots navigation-local registration order with detached programmatic auction units', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const directAuctionUnit = Object.freeze({ code: 'programmatic' });
+
+    expect(
+      service.register(navigation, [
+        serverRegistration('server'),
+        {
+          directAuctionUnit,
+          registeredSlotId: 'programmatic',
+          source: 'programmatic',
+        },
+      ])
+    ).toMatchObject({ ok: true });
+    expect(service.snapshotRegisteredSlots(navigation)).toEqual([
+      expect.objectContaining({ ordinal: 0, registeredSlotId: 'server', source: 'server' }),
+      expect.objectContaining({
+        directAuctionUnit,
+        ordinal: 1,
+        registeredSlotId: 'programmatic',
+        source: 'programmatic',
+      }),
+    ]);
+    expect(Object.isFrozen(service.snapshotRegisteredSlots(navigation))).toBe(true);
+
+    expect(service.adoptRegistrationHighWater(navigation.generation, 9)).toBe(true);
+    expect(service.adoptRegistrationHighWater(navigation.generation, 10)).toBe(false);
+    expect(
+      service.register(navigation, [{ registeredSlotId: 'after-handoff', source: 'programmatic' }])
+    ).toMatchObject({
+      ok: true,
+      records: [expect.objectContaining({ ordinal: 9, registeredSlotId: 'after-handoff' })],
+    });
+
+    expect(
+      service.register(navigation, [
+        {
+          directAuctionUnit: { code: 'unfrozen' },
+          registeredSlotId: 'unfrozen',
+          source: 'programmatic',
+        },
+      ])
+    ).toEqual({ ok: false, reason: 'invalid_slot_id' });
+
+    runtime.dispose();
+    expect(service.snapshotRegisteredSlots(navigation)).toBeUndefined();
+  });
+
+  it('rejects exact registered-id collisions without partial indexes', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    expect(service.register(navigation, [serverRegistration('existing')])).toMatchObject({
+      ok: true,
+    });
+
+    expect(
+      service.register(navigation, [
+        serverRegistration('fresh', { domAliases: ['fresh-div'] }),
+        serverRegistration('existing', { domAliases: ['leaked-div'] }),
+      ])
+    ).toEqual({ ok: false, reason: 'duplicate_slot' });
+    expect(service.resolveRegisteredSlot('fresh')).toBeUndefined();
+    expect(service.resolveDomAlias('fresh-div')).toBeUndefined();
+  });
+
+  it('resolves only unique ad-unit codes and DOM aliases without normalizing or choosing first', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    expect(
+      service.register(navigation, [
+        serverRegistration('Exact-Slot', { adUnitCode: '/same', domAliases: ['same-div'] }),
+        serverRegistration('other', { adUnitCode: '/same', domAliases: ['same-div'] }),
+      ])
+    ).toMatchObject({ ok: true });
+
+    expect(service.resolveRegisteredSlot('Exact-Slot')?.registeredSlotId).toBe('Exact-Slot');
+    expect(service.resolveRegisteredSlot('exact-slot')).toBeUndefined();
+    expect(service.resolveAdUnitCode('/same')).toBeUndefined();
+    expect(service.resolveDomAlias('same-div')).toBeUndefined();
+  });
+
+  it('binds one GPT object identity to at most one record and releases navigation records', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const shared = {};
+    expect(
+      service.register(navigation, [serverRegistration('one'), serverRegistration('two')])
+    ).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'one', {
+        ownership: 'publisher',
+        slot: shared,
+      })
+    ).toEqual({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'two', {
+        ownership: 'publisher',
+        slot: shared,
+      })
+    ).toEqual({ ok: false, reason: 'gpt_object_collision' });
+
+    navigation.dispose();
+    expect(service.snapshotForTest().records).toBe(0);
+    expect(service.resolveRegisteredSlot('one')).toBeUndefined();
+  });
+
+  it('latches a publication request to the exact bound GPT identity', async () => {
+    const gpt = createGptHarness();
+    const service = createSlotService({ googletag: gpt.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+
+    const stale = service.request({
+      expectedSlot: {},
+      intentId: 'stale-publication',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(stale.result).resolves.toEqual({ status: 'failed', reason: 'slot_unresolved' });
+    expect(gpt.display).not.toHaveBeenCalled();
+
+    const current = service.request({
+      expectedSlot: slot,
+      intentId: 'current-publication',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(current.status).toBe('active');
+    expect(gpt.display).toHaveBeenCalledExactlyOnceWith(slot);
+  });
+
+  it('publishes the exact TS request intent before GPT starts and isolates observer failure', async () => {
+    const gpt = createGptHarness();
+    const observed = vi.fn((input: Readonly<{ registeredSlotId: string; slot: object }>) => {
+      expect(input).toEqual({ registeredSlotId: 'slot', slot });
+      expect(Object.isFrozen(input)).toBe(true);
+      expect(gpt.display).not.toHaveBeenCalled();
+      throw new Error('fictional diagnostics failure');
+    });
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      onTrustedServerRequest: observed,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+
+    const request = service.request({
+      expectedSlot: slot,
+      intentId: 'diagnostic-publication',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observed).toHaveBeenCalledExactlyOnceWith({ registeredSlotId: 'slot', slot });
+    expect(gpt.display).toHaveBeenCalledExactlyOnceWith(slot);
+    expect(request.status).toBe('active');
+  });
+
+  it('does not publish a request fact when disabled-load display is claimed synchronously', async () => {
+    const gpt = createGptHarness({ initialLoadDisabled: true });
+    const observed = vi.fn();
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      onTrustedServerRequest: observed,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+    gpt.display.mockImplementationOnce(() => gpt.emit('slotRequested', { slot }));
+
+    const request = service.request({
+      expectedSlot: slot,
+      intentId: 'synchronous-publisher-claim',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'cycle_unattributable',
+    });
+
+    expect(observed).not.toHaveBeenCalled();
+    expect(gpt.refresh).not.toHaveBeenCalled();
+  });
+
+  it('enables GPT services at the shared request boundary before display', async () => {
+    const gpt = createGptHarness({ servicesEnabled: false });
+    const service = createSlotService({ googletag: gpt.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+
+    const request = service.request({
+      expectedSlot: slot,
+      intentId: 'enable-services-before-display',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(gpt.facade.enableServices).toHaveBeenCalledOnce();
+    expect(vi.mocked(gpt.facade.enableServices).mock.invocationCallOrder[0]).toBeLessThan(
+      gpt.display.mock.invocationCallOrder[0]!
+    );
+    expect(request.status).toBe('active');
+  });
+
+  it('recognizes the exact live GPT binding regardless of who defined the slot', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const trustedSlot = bindTrustedSlot(service, navigation, 'trusted');
+
+    expect(service.isBoundGptSlot(navigation.generation, 'trusted', trustedSlot)).toBe(true);
+    expect(service.isBoundGptSlot(navigation.generation, 'other', trustedSlot)).toBe(false);
+    expect(service.isBoundGptSlot({}, 'trusted', trustedSlot)).toBe(false);
+    expect(service.isBoundGptSlot(navigation.generation, 'trusted', {})).toBe(false);
+
+    const publisherSlot = {};
+    expect(service.register(navigation, [serverRegistration('publisher')])).toMatchObject({
+      ok: true,
+    });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'publisher', {
+        ownership: 'publisher',
+        slot: publisherSlot,
+      })
+    ).toEqual({ ok: true });
+    expect(service.isBoundGptSlot(navigation.generation, 'publisher', publisherSlot)).toBe(true);
+
+    runtime.dispose();
+    expect(service.isBoundGptSlot(navigation.generation, 'trusted', trustedSlot)).toBe(false);
+  });
+
+  it('hands an exact late publisher definition the TS slot and consumes only duplicate requests', async () => {
+    const gpt = createGptHarness({ initialLoadDisabled: true });
+    const warnPublisherHandoffMismatch = vi.fn(() => {
+      throw new Error('fictional local logger failure');
+    });
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      warnPublisherHandoffMismatch,
+    });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+
+    expect(
+      service.claimPublisherGptSlot({
+        adUnitPath: '/publisher/mismatch',
+        elementId: 'slot-div',
+        initialLoadDisabled: true,
+        sizes: Object.freeze([[728, 90]]),
+      })
+    ).toEqual({ action: 'handoff', slot });
+    expect(warnPublisherHandoffMismatch).toHaveBeenCalledExactlyOnceWith(
+      'GPT publisher handoff metadata mismatch',
+      Object.freeze({ formatsMismatch: true, pathMismatch: true })
+    );
+    expect(JSON.stringify(warnPublisherHandoffMismatch.mock.calls[0]).length).toBeLessThanOrEqual(
+      128
+    );
+    expect(
+      service.preparePublisherDisplay({ initialLoadDisabled: true, target: 'slot-div' })
+    ).toEqual({ action: 'suppress' });
+    expect(
+      service.preparePublisherDisplay({ initialLoadDisabled: true, target: 'slot-div' })
+    ).toEqual({ action: 'forward' });
+
+    const unrelated = {};
+    expect(
+      service.preparePublisherRefresh({
+        requestedSlots: undefined,
+        slots: Object.freeze([slot, unrelated]),
+      })
+    ).toEqual({ action: 'replace', slots: [unrelated] });
+    const forwardedRefresh = service.preparePublisherRefresh({
+      requestedSlots: Object.freeze([slot]),
+      slots: Object.freeze([slot]),
+    });
+    expect(forwardedRefresh.action).toBe('forward');
+    if (forwardedRefresh.action === 'forward') {
+      expect(forwardedRefresh.admission).toBeDefined();
+      forwardedRefresh.admission?.commit();
+    }
+
+    const request = service.request({
+      intentId: 'after-publisher-refresh',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'cycle_unattributable',
+    });
+
+    runtime.dispose();
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+  });
+
+  it('does not warn when an exact publisher handoff matches path and formats', () => {
+    const warnPublisherHandoffMismatch = vi.fn();
+    const service = createSlotService({
+      googletag: createGptHarness().adapter,
+      warnPublisherHandoffMismatch,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+
+    expect(
+      service.claimPublisherGptSlot({
+        adUnitPath: '/network/slot',
+        elementId: 'slot-div',
+        initialLoadDisabled: false,
+        sizes: Object.freeze([[300, 250]]),
+      })
+    ).toEqual({ action: 'handoff', slot });
+    expect(warnPublisherHandoffMismatch).not.toHaveBeenCalled();
+  });
+
+  it('rolls back a pending publisher display without settling active or queued TS work', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    expect(
+      service.claimPublisherGptSlot({
+        adUnitPath: '/network/slot',
+        elementId: 'slot-div',
+        initialLoadDisabled: false,
+        sizes: [300, 250],
+      })
+    ).toEqual({ action: 'handoff', slot });
+    expect(
+      service.preparePublisherDisplay({ initialLoadDisabled: false, target: 'slot-div' })
+    ).toEqual({ action: 'suppress' });
+    const active = service.request({
+      intentId: 'active-before-publisher-display',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    const queued = service.request({
+      intentId: 'queued-before-publisher-display',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    expect(active.status).toBe('active');
+    expect(queued.status).toBe('queued');
+
+    const decision = service.preparePublisherDisplay({
+      initialLoadDisabled: false,
+      target: 'slot-div',
+    }) as Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>;
+    expect(decision.action).toBe('forward');
+    expect(decision.admission).toBeDefined();
+    expect(active.status).toBe('active');
+    expect(queued.status).toBe('queued');
+
+    decision.admission?.rollback();
+    decision.admission?.rollback();
+
+    expect(active.status).toBe('active');
+    expect(queued.status).toBe('queued');
+    service.dispose();
+    await expect(active.result).resolves.toMatchObject({ status: 'cancelled' });
+    await expect(queued.result).resolves.toMatchObject({ status: 'cancelled' });
+  });
+
+  it('keeps a publisher cycle consumed before display rollback and makes later rollback inert', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.claimPublisherGptSlot({
+      adUnitPath: '/network/slot',
+      elementId: 'slot-div',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    service.preparePublisherDisplay({ initialLoadDisabled: false, target: 'slot-div' });
+    const decision = service.preparePublisherDisplay({
+      initialLoadDisabled: false,
+      target: 'slot-div',
+    }) as Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>;
+    expect(decision.admission).toBeDefined();
+
+    service.handleGptEvent('slotRequested', { slot });
+    expect(service.snapshotForTest().cycles).toBe(1);
+    decision.admission?.rollback();
+    decision.admission?.commit();
+    expect(service.snapshotForTest().cycles).toBe(1);
+
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+    expect(service.snapshotForTest().cycles).toBe(0);
+  });
+
+  it('rolls back repeated display plus explicit and global refresh admissions without residue', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'first');
+    const second = bindTrustedSlot(service, navigation, 'second');
+    for (const registeredSlotId of ['first', 'second'] as const) {
+      service.claimPublisherGptSlot({
+        adUnitPath: `/network/${registeredSlotId}`,
+        elementId: `${registeredSlotId}-div`,
+        initialLoadDisabled: false,
+        sizes: [300, 250],
+      });
+      service.preparePublisherDisplay({
+        initialLoadDisabled: false,
+        target: `${registeredSlotId}-div`,
+      });
+    }
+
+    for (let attempt = 0; attempt < 70; attempt += 1) {
+      const display = service.preparePublisherDisplay({
+        initialLoadDisabled: false,
+        target: 'first-div',
+      }) as Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>;
+      expect(display.admission).toBeDefined();
+      display.admission?.rollback();
+    }
+    const explicit = service.preparePublisherRefresh({
+      requestedSlots: Object.freeze([first]),
+      slots: Object.freeze([first]),
+    }) as Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>;
+    const global = service.preparePublisherRefresh({
+      requestedSlots: undefined,
+      slots: Object.freeze([first, second]),
+    }) as Readonly<{ action: 'forward'; admission?: GoogletagPublisherCallAdmission }>;
+    expect(explicit.admission).toBeDefined();
+    expect(global.admission).toBeDefined();
+    explicit.admission?.rollback();
+    global.admission?.rollback();
+
+    const firstRequest = service.request({
+      intentId: 'after-rolled-back-explicit-refresh',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'first',
+      requestClass: 'primary',
+    });
+    const secondRequest = service.request({
+      intentId: 'after-rolled-back-global-refresh',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'second',
+      requestClass: 'primary',
+    });
+    expect(firstRequest.status).toBe('active');
+    expect(secondRequest.status).toBe('active');
+  });
+
+  it('commits a global refresh only for the publisher physicals snapshotted before native entry', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'first');
+    bindTrustedSlot(service, navigation, 'second');
+    service.claimPublisherGptSlot({
+      adUnitPath: '/network/first',
+      elementId: 'first-div',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    const global = service.preparePublisherRefresh({
+      requestedSlots: undefined,
+      slots: Object.freeze([first]),
+    });
+    expect(global.action).toBe('forward');
+    if (global.action !== 'forward') throw new Error('Expected global refresh forwarding');
+    expect(global.admission).toBeDefined();
+
+    service.claimPublisherGptSlot({
+      adUnitPath: '/network/second',
+      elementId: 'second-div',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    global.admission?.commit();
+
+    const firstRequest = service.request({
+      intentId: 'global-snapshot-first',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'first',
+      requestClass: 'primary',
+    });
+    const secondRequest = service.request({
+      intentId: 'global-snapshot-second',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'second',
+      requestClass: 'primary',
+    });
+    await expect(firstRequest.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    expect(secondRequest.status).toBe('active');
+  });
+
+  it('makes a pending publisher admission inert after navigation and service disposal', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    bindTrustedSlot(service, navigation);
+    service.claimPublisherGptSlot({
+      adUnitPath: '/network/slot',
+      elementId: 'slot-div',
+      initialLoadDisabled: false,
+      sizes: [300, 250],
+    });
+    service.preparePublisherDisplay({ initialLoadDisabled: false, target: 'slot-div' });
+    const decision = service.preparePublisherDisplay({
+      initialLoadDisabled: false,
+      target: 'slot-div',
+    });
+    expect(decision.action).toBe('forward');
+    if (decision.action !== 'forward') throw new Error('Expected display forwarding');
+    expect(decision.admission).toBeDefined();
+
+    runtime.dispose();
+    expect(() => decision.admission?.commit()).not.toThrow();
+    expect(() => decision.admission?.rollback()).not.toThrow();
+    service.dispose();
+    expect(() => decision.admission?.commit()).not.toThrow();
+    expect(() => decision.admission?.rollback()).not.toThrow();
+  });
+
+  it('hydrates only one disconnected TS fallback with the configured prefix, path, and sizes', () => {
+    const dom = createReconciliationBoundary();
+    const firstElement = {};
+    const secondElement = {};
+    dom.put('slot-first', firstElement);
+    dom.put('slot-second', secondElement);
+    const warnPublisherHandoffMismatch = vi.fn();
+    const service = createSlotService({
+      googletag: createGptHarness().adapter,
+      reconciliation: dom.boundary,
+      warnPublisherHandoffMismatch,
+    });
+    const navigation = createNavigation();
+    expect(
+      service.register(navigation, [serverRegistration('first'), serverRegistration('second')])
+    ).toMatchObject({ ok: true });
+    const first = {};
+    const second = {};
+    for (const [id, slot] of [
+      ['first', first],
+      ['second', second],
+    ] as const) {
+      expect(
+        service.adoptGptSlot(navigation.generation, id, {
+          definition: {
+            adUnitPath: '/network/hydrated',
+            elementId: `slot-${id}`,
+            sizes: Object.freeze([[300, 250]]),
+          },
+          elementIdPrefix: 'slot-',
+          ownership: 'trusted_server',
+          slot,
+        })
+      ).toEqual({ ok: true });
+      dom.disconnect(`slot-${id}`);
+    }
+
+    const hydration = Object.freeze({
+      adUnitPath: '/network/hydrated',
+      elementId: 'slot-hydrated',
+      initialLoadDisabled: false,
+      sizes: Object.freeze([300, 250]),
+    });
+    expect(service.claimPublisherGptSlot(hydration)).toEqual({ action: 'forward' });
+    expect(service.recordPublisherDestruction(second)).toBe(true);
+    expect(
+      service.claimPublisherGptSlot({ ...hydration, adUnitPath: '/network/mismatch' })
+    ).toEqual({ action: 'forward' });
+    expect(service.claimPublisherGptSlot({ ...hydration, sizes: [728, 90] })).toEqual({
+      action: 'forward',
+    });
+    expect(service.claimPublisherGptSlot(hydration)).toEqual({ action: 'handoff', slot: first });
+    expect(warnPublisherHandoffMismatch).not.toHaveBeenCalled();
+  });
+
+  it('suppresses the exact first explicit refresh after a disabled-load handoff', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    expect(
+      service.claimPublisherGptSlot({
+        adUnitPath: '/network/slot',
+        elementId: 'slot-div',
+        initialLoadDisabled: true,
+        sizes: [300, 250],
+      })
+    ).toEqual({ action: 'handoff', slot });
+
+    expect(
+      service.preparePublisherRefresh({
+        requestedSlots: Object.freeze([slot]),
+        slots: Object.freeze([slot]),
+      })
+    ).toEqual({ action: 'suppress' });
+    const forwarded = service.preparePublisherRefresh({
+      requestedSlots: Object.freeze([slot]),
+      slots: Object.freeze([slot]),
+    });
+    expect(forwarded.action).toBe('forward');
+    if (forwarded.action === 'forward') {
+      expect(forwarded.admission).toBeDefined();
+      forwarded.admission?.commit();
+    }
+  });
+
+  it('uses captured Set validation intrinsics on a hostile page', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const originalHas = Set.prototype.has;
+    const originalAdd = Set.prototype.add;
+    Set.prototype.has = function (): boolean {
+      throw new Error('poisoned has');
+    } as typeof Set.prototype.has;
+    Set.prototype.add = function (): Set<unknown> {
+      throw new Error('poisoned add');
+    } as typeof Set.prototype.add;
+    let result: ReturnType<typeof service.register> | undefined;
+    try {
+      result = service.register(navigation, [
+        serverRegistration('captured', { domAliases: ['captured-div'] }),
+      ]);
+    } finally {
+      Set.prototype.has = originalHas;
+      Set.prototype.add = originalAdd;
+    }
+    expect(result).toMatchObject({ ok: true });
+    expect(service.resolveDomAlias('captured-div')?.registeredSlotId).toBe('captured');
+  });
+
+  it('rolls back GPT identity publication when ownership becomes stale during adoption', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    expect(service.register(navigation, [serverRegistration('old')])).toMatchObject({ ok: true });
+    const slot = {};
+    const racedBinding = Object.defineProperties(
+      {},
+      {
+        definition: { value: undefined },
+        ownership: {
+          get: () => {
+            runtime.replaceNavigation();
+            return 'publisher';
+          },
+        },
+        slot: { value: slot },
+      }
+    ) as GptSlotBinding;
+
+    expect(service.adoptGptSlot(navigation.generation, 'old', racedBinding)).toEqual({
+      ok: false,
+      reason: 'stale_owner',
+    });
+    const next = runtime.currentNavigation;
+    if (!next) throw new Error('Expected replacement navigation');
+    expect(service.register(next, [serverRegistration('next')])).toMatchObject({ ok: true });
+    expect(service.adoptGptSlot(next.generation, 'next', { ownership: 'publisher', slot })).toEqual(
+      { ok: true }
+    );
+  });
+
+  it('conditionally deletes a WeakMap identity published just before a stale-owner check', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    let phase: 'adopt' | 'register' | 'steady' = 'register';
+    let adoptChecks = 0;
+    const generation = {};
+    const owner = {
+      generation,
+      isCurrent: () => {
+        if (phase !== 'adopt') return true;
+        adoptChecks += 1;
+        return adoptChecks < 3;
+      },
+      onDispose: vi.fn(),
+    } as unknown as NavigationSession;
+    expect(service.register(owner, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    const slot = {};
+    phase = 'adopt';
+
+    expect(service.adoptGptSlot(generation, 'slot', { ownership: 'publisher', slot })).toEqual({
+      ok: false,
+      reason: 'stale_owner',
+    });
+    phase = 'steady';
+    expect(service.adoptGptSlot(generation, 'slot', { ownership: 'publisher', slot })).toEqual({
+      ok: true,
+    });
+  });
+});
+
+describe('navigation-owned DOM reconciliation', () => {
+  afterEach(() => vi.useRealTimers());
+
+  async function completedApsMountCycle(
+    ownership: 'publisher' | 'trusted_server' = 'trusted_server',
+    disposeCommittedArtifact = vi.fn()
+  ) {
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    const element = Object.freeze({ element: 'top-slot' });
+    dom.put('slot-div', element);
+    const service = createSlotService({
+      bindCommittedArtifactRetirement,
+      disposeCommittedArtifact,
+      googletag: gpt.adapter,
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    let slot: object;
+    if (ownership === 'trusted_server') {
+      slot = bindTrustedSlot(service, navigation);
+    } else {
+      slot = Object.freeze({ publisher: true });
+      expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({
+        ok: true,
+      });
+      expect(
+        service.adoptGptSlot(navigation.generation, 'slot', {
+          definition: Object.freeze({
+            adUnitPath: '/network/slot',
+            elementId: 'slot-div',
+            sizes: Object.freeze([[300, 250] as const]),
+          }),
+          ownership,
+          slot,
+        })
+      ).toEqual({ ok: true });
+    }
+    const intentId = `a1_${'m'.repeat(22)}`;
+    const request = service.request({
+      intentId,
+      expectedSlot: slot,
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'aps-top-mount',
+      slot,
+    });
+    await expect(request.result).resolves.toMatchObject({ status: 'rendered' });
+    return { disposeCommittedArtifact, dom, element, intentId, navigation, service, slot };
+  }
+
+  it('claims one exact completed TS cycle and invalidates it on DOM replacement', async () => {
+    const h = await completedApsMountCycle();
+    const binding = h.service.resolveApsMountBinding(h.navigation.generation, 'slot', h.intentId);
+
+    expect(binding).toMatchObject({ element: h.element, physicalSlot: h.slot });
+    expect(binding?.isCurrent()).toBe(true);
+    expect(
+      h.service.resolveApsMountBinding(h.navigation.generation, 'slot', h.intentId)
+    ).toBeUndefined();
+
+    h.dom.replace('slot-div', Object.freeze({ element: 'replacement' }));
+    expect(binding?.isCurrent()).toBe(false);
+  });
+
+  it('refuses a publisher-owned cycle when its exact host was replaced before binding', async () => {
+    const h = await completedApsMountCycle('publisher');
+    h.dom.replace('slot-div', Object.freeze({ element: 'publisher-replacement' }));
+
+    expect(
+      h.service.resolveApsMountBinding(h.navigation.generation, 'slot', h.intentId)
+    ).toBeUndefined();
+  });
+
+  it('retires a committed overlay for a publisher cycle but retains it for an exact TS replacement', async () => {
+    const publisher = await completedApsMountCycle('publisher');
+    const publisherBinding = publisher.service.resolveApsMountBinding(
+      publisher.navigation.generation,
+      'slot',
+      publisher.intentId
+    )!;
+    const publisherArtifact = committedArtifact(publisher.navigation.generation);
+    expect(publisherBinding.bindArtifact(publisherArtifact)?.commit()).toBe(true);
+
+    publisher.service.handleGptEvent('slotRequested', { slot: publisher.slot });
+    expect(publisher.disposeCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      publisher.navigation.generation,
+      'slot',
+      publisherArtifact
+    );
+
+    const trusted = await completedApsMountCycle();
+    const trustedBinding = trusted.service.resolveApsMountBinding(
+      trusted.navigation.generation,
+      'slot',
+      trusted.intentId
+    )!;
+    const trustedArtifact = committedArtifact(trusted.navigation.generation);
+    expect(trustedBinding.bindArtifact(trustedArtifact)?.commit()).toBe(true);
+    const replacement = trusted.service.request({
+      expectedSlot: trusted.slot,
+      intentId: 'exact-ts-replacement',
+      navigationGeneration: trusted.navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+
+    trusted.service.handleGptEvent('slotRequested', { slot: trusted.slot });
+    expect(trusted.disposeCommittedArtifact).not.toHaveBeenCalled();
+    replacement.dispose();
+    expect(trusted.disposeCommittedArtifact).not.toHaveBeenCalled();
+  });
+
+  it('restores the prior physical artifact when a provisional replacement is released', async () => {
+    const h = await completedApsMountCycle();
+    const prior = committedArtifact(h.navigation.generation);
+    expect(h.service.adoptCommittedArtifact(h.navigation.generation, 'slot', prior)).toBe(true);
+    const binding = h.service.resolveApsMountBinding(h.navigation.generation, 'slot', h.intentId)!;
+    const replacement = Object.freeze({
+      ...committedArtifact(h.navigation.generation),
+      attemptId: `a1_${'d'.repeat(22)}`,
+    });
+    const admission = binding.bindArtifact(replacement)!;
+    expect(admission.commit()).toBe(true);
+
+    admission.release();
+    admission.rollback();
+    h.service.handleGptEvent('slotRequested', { slot: h.slot });
+
+    expect(h.disposeCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      h.navigation.generation,
+      'slot',
+      prior
+    );
+  });
+
+  it('refuses missing, ambiguous, disconnected, and stale APS mount bindings', async () => {
+    const ambiguous = await completedApsMountCycle();
+    ambiguous.dom.replaceAmbiguously('slot-div', [
+      Object.freeze({ element: 'first' }),
+      Object.freeze({ element: 'second' }),
+    ]);
+    expect(
+      ambiguous.service.resolveApsMountBinding(
+        ambiguous.navigation.generation,
+        'slot',
+        ambiguous.intentId
+      )
+    ).toBeUndefined();
+
+    const disconnected = await completedApsMountCycle();
+    disconnected.dom.disconnect('slot-div');
+    expect(
+      disconnected.service.resolveApsMountBinding(
+        disconnected.navigation.generation,
+        'slot',
+        disconnected.intentId
+      )
+    ).toBeUndefined();
+
+    const stale = await completedApsMountCycle();
+    stale.navigation.dispose();
+    expect(
+      stale.service.resolveApsMountBinding(stale.navigation.generation, 'slot', stale.intentId)
+    ).toBeUndefined();
+    expect(
+      stale.service.resolveApsMountBinding(stale.navigation.generation, 'missing', stale.intentId)
+    ).toBeUndefined();
+  });
+
+  it('installs reconciliation only for one explicit reversible deferred owner', () => {
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+
+    expect(dom.observe).not.toHaveBeenCalled();
+    const release = service.activateReconciliation();
+    expect(dom.observe).toHaveBeenCalledOnce();
+    const disconnect = dom.observe.mock.results[0]?.value;
+    expect(typeof disconnect).toBe('function');
+    expect(() => service.activateReconciliation()).toThrow('unavailable');
+
+    release();
+    release();
+    expect(disconnect).toHaveBeenCalledOnce();
+
+    const releaseAgain = service.activateReconciliation();
+    expect(dom.observe).toHaveBeenCalledTimes(2);
+    releaseAgain();
+    expect(dom.observe.mock.results[1]?.value).toHaveBeenCalledOnce();
+  });
+
+  it('preserves the physical slot when DOM connectivity cannot be established', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: Object.freeze({
+        ...dom.boundary,
+        isConnected: () => {
+          throw new Error('fictional DOM connectivity failure');
+        },
+      }),
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+
+    dom.trigger();
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+  });
+
+  it('reconciles a TS slot whose original DOM element was already absent at adoption', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+
+    dom.put('slot-div', {});
+    dom.trigger();
+    await vi.advanceTimersByTimeAsync(250);
+
+    expect(gpt.defineSlot).toHaveBeenCalledExactlyOnceWith(
+      '/network/slot',
+      [[300, 250]],
+      'slot-div'
+    );
+  });
+
+  it('clears an adopted physical artifact association when its store retires the exact artifact', () => {
+    const gpt = createGptHarness();
+    const service = createSlotService({
+      bindCommittedArtifactRetirement,
+      googletag: gpt.adapter,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const store = createCommittedArtifactStore();
+    const first = committedArtifact(navigation.generation);
+    const second = committedArtifact(navigation.generation);
+    expect(store.promote(first)).toBe(true);
+    expect(service.adoptCommittedArtifact(navigation.generation, 'slot', first)).toBe(true);
+
+    expect(store.release(first)).toBe(true);
+    expect(service.adoptCommittedArtifact(navigation.generation, 'slot', second)).toBe(true);
+  });
+
+  it('debounces an exact disconnected TS slot through the 249/250 ms boundary', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    const disposeCommittedArtifact = vi.fn(() => {
+      throw new Error('fictional artifact cleanup failure');
+    });
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      bindCommittedArtifactRetirement,
+      disposeCommittedArtifact,
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const artifact = committedArtifact(navigation.generation);
+    expect(service.adoptCommittedArtifact(navigation.generation, 'slot', artifact)).toBe(true);
+    service.activate();
+
+    dom.replace('slot-div', {});
+    await vi.advanceTimersByTimeAsync(249);
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(gpt.destroySlots).toHaveBeenCalledExactlyOnceWith([
+      expect.objectContaining({ id: 'slot' }),
+    ]);
+    expect(gpt.defineSlot).toHaveBeenCalledExactlyOnceWith(
+      '/network/slot',
+      [[300, 250]],
+      'slot-div'
+    );
+    expect(disposeCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      navigation.generation,
+      'slot',
+      artifact
+    );
+
+    const request = service.request({
+      intentId: 'after-rebind',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(request.status).toBe('active');
+    expect(gpt.display).toHaveBeenCalledExactlyOnceWith(gpt.defineSlot.mock.results[0]?.value);
+  });
+
+  it('settles an invocation tied to the orphan before publishing the replacement', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    const orphan = bindTrustedSlot(service, navigation);
+    service.activate();
+    const request = service.request({
+      intentId: 'before-rebind',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(gpt.display).toHaveBeenCalledExactlyOnceWith(orphan);
+
+    dom.replace('slot-div', {});
+    await vi.advanceTimersByTimeAsync(250);
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'gpt_request_failed',
+    });
+    await vi.advanceTimersByTimeAsync(3_000);
+    expect(gpt.destroySlots).toHaveBeenCalledExactlyOnceWith([orphan]);
+
+    service.request({
+      intentId: 'after-rebind',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+    expect(gpt.display).toHaveBeenLastCalledWith(gpt.defineSlot.mock.results[0]?.value);
+  });
+
+  it('runs one final unresolved pass at 5,000 ms and settles exact work', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(2_999);
+    const request = service.request({
+      intentId: 'orphaned',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(request.status).toBe('active');
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(request.result).resolves.toEqual({ status: 'failed', reason: 'slot_unresolved' });
+    expect(gpt.destroySlots).toHaveBeenCalledExactlyOnceWith([
+      expect.objectContaining({ id: 'slot' }),
+    ]);
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['unresolved', 'destroy_false'],
+    ['unresolved', 'destroy_throw'],
+    ['ambiguous', 'destroy_false'],
+    ['ambiguous', 'destroy_throw'],
+  ] as const)('settles final %s cleanup %s as gpt_request_failed', async (resolution, failure) => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    if (failure === 'destroy_false') gpt.destroySlots.mockReturnValue(false);
+    else {
+      gpt.destroySlots.mockImplementation(() => {
+        throw new Error('fictional destroy failure');
+      });
+    }
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    if (resolution === 'ambiguous') dom.replaceAmbiguously('slot-div', [{}, {}]);
+    else dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(4_999);
+    const request = service.request({
+      intentId: `${resolution}-${failure}`,
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await vi.advanceTimersByTimeAsync(1);
+
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'gpt_request_failed',
+    });
+    expect(gpt.destroySlots).toHaveBeenCalledExactlyOnceWith([
+      expect.objectContaining({ id: 'slot' }),
+    ]);
+  });
+
+  it('keeps final cleanup pending and lets navigation cancellation beat its late result', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness({ deferDestroyedResult: true });
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const oldSlot = bindTrustedSlot(service, navigation);
+    service.activate();
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(4_999);
+    const request = service.request({
+      intentId: 'navigation-wins-late-cleanup',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    vi.advanceTimersByTime(1);
+    expect(request.status).toBe('active');
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+    const nextResult = runtime.replaceNavigation();
+    expect(nextResult.ok).toBe(true);
+    if (!nextResult.ok) throw new Error('Expected replacement navigation');
+    const next = nextResult.value;
+    await expect(request.result).resolves.toEqual({
+      status: 'cancelled',
+      reason: 'navigation_disposed',
+    });
+    expect(
+      service.register(next, [
+        serverRegistration('slot', {
+          adUnitCode: '/network/slot',
+          domAliases: ['slot-div'],
+        }),
+      ])
+    ).toEqual({ ok: false, reason: 'slot_quarantined' });
+
+    gpt.resolveDeferredDestroyed();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(request.status).toBe('terminal');
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+    const replacement = bindTrustedSlot(service, next);
+    gpt.resolveDeferredDestroyed();
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'late-old-slot',
+      slot: oldSlot,
+    });
+    expect(service.recordPublisherDestruction(oldSlot)).toBe(false);
+    expect(service.isBoundGptSlot(next.generation, 'slot', replacement)).toBe(true);
+  });
+
+  it('lets request supersession win while final cleanup completes later', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness({ synchronousRun: false });
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(4_999);
+    const request = service.request({
+      intentId: 'supersession-wins-late-cleanup',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    vi.advanceTimersByTime(1);
+    expect(request.status).toBe('active');
+    request.dispose();
+    await expect(request.result).resolves.toEqual({
+      status: 'cancelled',
+      reason: 'superseded',
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(request.status).toBe('terminal');
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+  });
+
+  it('releases the exact committed artifact before retiring a failed reconciliation', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    const disposeCommittedArtifact = vi.fn();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      bindCommittedArtifactRetirement,
+      disposeCommittedArtifact,
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const artifact = committedArtifact(navigation.generation);
+    expect(service.adoptCommittedArtifact(navigation.generation, 'slot', artifact)).toBe(true);
+    service.activate();
+
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    expect(disposeCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      navigation.generation,
+      'slot',
+      artifact
+    );
+    expect(disposeCommittedArtifact.mock.invocationCallOrder[0]).toBeLessThan(
+      gpt.destroySlots.mock.invocationCallOrder[0] as number
+    );
+    expect(gpt.destroySlots).toHaveBeenCalledOnce();
+  });
+
+  it('commits a unique replacement found only by the final 5,000 ms pass', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(250);
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(4_749);
+    dom.put('slot-div', {});
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(gpt.defineSlot).toHaveBeenCalledExactlyOnceWith(
+      '/network/slot',
+      [[300, 250]],
+      'slot-div'
+    );
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+  });
+
+  it('keeps an ambiguous replacement unresolved through the final pass', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    dom.replaceAmbiguously('slot-div', [{}, {}]);
+    await vi.advanceTimersByTimeAsync(2_999);
+    const request = service.request({
+      intentId: 'ambiguous',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await vi.advanceTimersByTimeAsync(2_001);
+    await expect(request.result).resolves.toEqual({ status: 'failed', reason: 'slot_unresolved' });
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+  });
+
+  it.each(['destroy_false', 'destroy_throw', 'define'] as const)(
+    'settles %s transaction failure as gpt_request_failed without a second physical slot',
+    async (failure) => {
+      vi.useFakeTimers();
+      vi.setSystemTime(0);
+      const gpt = createGptHarness();
+      if (failure === 'destroy_false') gpt.destroySlots.mockReturnValue(false);
+      else if (failure === 'destroy_throw') {
+        gpt.destroySlots.mockImplementation(() => {
+          throw new Error('fictional destroy failure');
+        });
+      } else gpt.defineSlot.mockReturnValueOnce(undefined);
+      const dom = createReconciliationBoundary();
+      dom.put('slot-div', {});
+      const service = createSlotService({
+        googletag: gpt.adapter,
+        now: () => Date.now(),
+        reconciliation: dom.boundary,
+      });
+      const navigation = createNavigation();
+      bindTrustedSlot(service, navigation);
+      service.activate();
+      const request = service.request({
+        intentId: `failed-${failure}`,
+        navigationGeneration: navigation.generation,
+        operation: 'display',
+        registeredSlotId: 'slot',
+        requestClass: 'primary',
+      });
+      await vi.advanceTimersByTimeAsync(0);
+
+      dom.replace('slot-div', {});
+      await vi.advanceTimersByTimeAsync(250);
+      await expect(request.result).resolves.toEqual({
+        status: 'failed',
+        reason: 'gpt_request_failed',
+      });
+      expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+      expect(gpt.defineSlot).toHaveBeenCalledTimes(failure === 'define' ? 1 : 0);
+      expect(service.snapshotForTest().physicalSlots).toBe(0);
+    }
+  );
+
+  it('quarantines an exact replacement candidate the adapter could not destroy', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const orphan = Object.freeze({ orphan: true });
+    const gpt = createGptHarness({ orphanOnReplace: orphan });
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    const request = service.request({
+      intentId: 'orphaned-replacement',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    dom.replace('slot-div', {});
+    await vi.advanceTimersByTimeAsync(250);
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'gpt_request_failed',
+    });
+    const replacementBinding = {
+      definition: {
+        adUnitPath: '/network/slot',
+        elementId: 'slot-div',
+        sizes: Object.freeze([[300, 250]]),
+      },
+      ownership: 'trusted_server' as const,
+      slot: Object.freeze({ replacementAfterOrphan: true }),
+    };
+    expect(service.adoptGptSlot(navigation.generation, 'slot', replacementBinding)).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+
+    expect(service.recordPublisherDestruction(orphan)).toBe(true);
+    expect(service.adoptGptSlot(navigation.generation, 'slot', replacementBinding)).toEqual({
+      ok: true,
+    });
+  });
+
+  it('lets expiry beat a final-pass replacement that cannot commit synchronously', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness({ synchronousRun: false });
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+    await Promise.resolve();
+
+    dom.disconnect('slot-div');
+    await vi.advanceTimersByTimeAsync(250);
+    await vi.advanceTimersByTimeAsync(4_749);
+    dom.put('slot-div', {});
+    const request = service.request({
+      intentId: 'expiry-wins',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'slot_unresolved',
+    });
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('lets publisher ownership transfer cancel a queued reconciliation transaction', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness({ synchronousRun: false });
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+    await Promise.resolve();
+
+    dom.replace('slot-div', {});
+    vi.advanceTimersByTime(250);
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        ownership: 'publisher',
+        slot,
+      })
+    ).toEqual({ ok: true });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(gpt.defineSlot).not.toHaveBeenCalled();
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('allows two successful rebinds and fails a third disconnect immediately', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    service.activate();
+
+    dom.replace('slot-div', {});
+    await vi.advanceTimersByTimeAsync(250);
+    dom.replace('slot-div', {});
+    await vi.advanceTimersByTimeAsync(250);
+    expect(gpt.defineSlot).toHaveBeenCalledTimes(2);
+
+    const request = service.request({
+      intentId: 'capacity',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    dom.disconnect('slot-div');
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'reconciliation_capacity',
+    });
+    expect(gpt.defineSlot).toHaveBeenCalledTimes(2);
+    expect(gpt.destroySlots).toHaveBeenCalledTimes(3);
+  });
+
+  it('cancels reconciliation on publisher transfer and disconnects with navigation', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    const gpt = createGptHarness();
+    const dom = createReconciliationBoundary();
+    dom.put('slot-div', {});
+    const service = createSlotService({
+      googletag: gpt.adapter,
+      now: () => Date.now(),
+      reconciliation: dom.boundary,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    service.activate();
+    dom.disconnect('slot-div');
+
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        ownership: 'publisher',
+        slot,
+      })
+    ).toEqual({ ok: true });
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+
+    navigation.dispose();
+    expect(dom.observe).toHaveBeenCalledTimes(1);
+    dom.trigger();
+    await vi.runAllTimersAsync();
+    expect(gpt.destroySlots).not.toHaveBeenCalled();
+  });
+});
+
+describe('browser reconciliation boundary', () => {
+  it('resolves only one exact connected element and releases its observer', async () => {
+    const boundary = createBrowserSlotReconciliationBoundary(document, MutationObserver);
+    expect(boundary).toBeDefined();
+    if (!boundary) throw new Error('Expected the browser reconciliation boundary');
+    const host = document.createElement('section');
+    const first = document.createElement('div');
+    first.id = 'tsjs-reconciliation-exact';
+    host.append(first);
+    document.body.append(host);
+    const callback = vi.fn();
+    const release = boundary.observe(callback);
+
+    expect(boundary.resolve(['tsjs-reconciliation-exact'])).toEqual({
+      status: 'unique',
+      element: first,
+      elementId: 'tsjs-reconciliation-exact',
+    });
+    expect(boundary.isConnected(first)).toBe(true);
+
+    const duplicate = document.createElement('div');
+    duplicate.id = first.id;
+    host.append(duplicate);
+    await vi.waitFor(() => expect(callback).toHaveBeenCalled());
+    expect(boundary.resolve([first.id])).toEqual({ status: 'ambiguous' });
+
+    const callsBeforeRelease = callback.mock.calls.length;
+    release();
+    host.remove();
+    await Promise.resolve();
+    expect(callback).toHaveBeenCalledTimes(callsBeforeRelease);
+    expect(boundary.isConnected(first)).toBe(false);
+    expect(boundary.resolve([first.id])).toEqual({ status: 'unresolved' });
+  });
+});
+
+function createReplacementHarness() {
+  const replacement = { addService: vi.fn() };
+  const destroySlots = vi.fn((_slots: readonly object[]) => true);
+  const defineSlot = vi.fn((): object | undefined => replacement);
+  const pubads = {
+    addEventListener: vi.fn(),
+    getSlots: () => [],
+    refresh: vi.fn(),
+    removeEventListener: vi.fn(),
+  };
+  const adapter = createBrowserGoogletagAdapter({
+    googletag: {
+      apiReady: true,
+      cmd: { push: (command: () => void) => command() },
+      defineSlot,
+      destroySlots,
+      display: vi.fn(),
+      pubads: () => pubads,
+      pubadsReady: true,
+    },
+  });
+  return { adapter, defineSlot, destroySlots, pubads, replacement };
+}
+
+describe('adapter-owned GPT replacement transaction', () => {
+  const definition = Object.freeze({
+    adUnitPath: '/network/slot',
+    elementId: 'slot-div',
+    sizes: Object.freeze([[300, 250]]),
+  });
+  const commitReplacement = () => Object.freeze({ commit: () => true, rollback: vi.fn() });
+
+  it.each(['throw', 'false'] as const)(
+    'never publishes a second physical slot after %s failure',
+    async (failure) => {
+      const harness = createReplacementHarness();
+      if (failure === 'throw') {
+        harness.destroySlots.mockImplementation(() => {
+          throw new Error('destroy failed');
+        });
+      } else if (failure === 'false') {
+        harness.destroySlots.mockReturnValue(false);
+      }
+      const operation = harness.adapter.run((gpt) =>
+        gpt.transactionalReplace({}, definition, () => true, commitReplacement)
+      );
+
+      await expect(operation.result).rejects.toBeDefined();
+      expect(harness.defineSlot).not.toHaveBeenCalled();
+      expect(harness.replacement.addService).not.toHaveBeenCalled();
+    }
+  );
+
+  it.each([
+    ['after-destroy', 1, 0, 1],
+    ['after-define', 2, 1, 2],
+    ['after-addService', 3, 1, 2],
+  ] as const)(
+    'checks stale generation %s and cleans any newly-defined object',
+    async (_site, staleAt, expectedDefinitions, expectedDestroys) => {
+      const harness = createReplacementHarness();
+      let checks = 0;
+      const operation = harness.adapter.run((gpt) =>
+        gpt.transactionalReplace(
+          {},
+          definition,
+          () => {
+            checks += 1;
+            return checks < staleAt;
+          },
+          commitReplacement
+        )
+      );
+
+      await expect(operation.result).resolves.toEqual({ status: 'destroyed' });
+      expect(harness.defineSlot).toHaveBeenCalledTimes(expectedDefinitions);
+      expect(harness.destroySlots).toHaveBeenCalledTimes(expectedDestroys);
+      expect(harness.replacement.addService).toHaveBeenCalledTimes(staleAt === 3 ? 1 : 0);
+    }
+  );
+
+  it('surfaces failure to destroy a newly-defined stale replacement', async () => {
+    const harness = createReplacementHarness();
+    harness.destroySlots.mockReturnValueOnce(true).mockReturnValueOnce(false);
+    let checks = 0;
+    const operation = harness.adapter.run((gpt) =>
+      gpt.transactionalReplace(
+        {},
+        definition,
+        () => {
+          checks += 1;
+          return checks < 2;
+        },
+        commitReplacement
+      )
+    );
+
+    await expect(operation.result).rejects.toBeDefined();
+    expect(harness.destroySlots).toHaveBeenCalledTimes(2);
+  });
+
+  it('normalizes a defineSlot throw after destroying the old slot', async () => {
+    const harness = createReplacementHarness();
+    const publisherFailure = new Error('publisher define failed');
+    harness.defineSlot.mockImplementation(() => {
+      throw publisherFailure;
+    });
+    const operation = harness.adapter.run((gpt) =>
+      gpt.transactionalReplace({}, definition, () => true, commitReplacement)
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      cause: publisherFailure,
+      code: 'gpt_replacement_failed',
+      oldSlotDestroyed: true,
+      orphanedSlot: undefined,
+    });
+    expect(harness.destroySlots).toHaveBeenCalledOnce();
+  });
+
+  it('normalizes a generation callback throw after destroying the old slot', async () => {
+    const harness = createReplacementHarness();
+    const ownerFailure = new Error('generation check failed');
+    const operation = harness.adapter.run((gpt) =>
+      gpt.transactionalReplace(
+        {},
+        definition,
+        () => {
+          throw ownerFailure;
+        },
+        commitReplacement
+      )
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      cause: ownerFailure,
+      code: 'gpt_replacement_failed',
+      oldSlotDestroyed: true,
+      orphanedSlot: undefined,
+    });
+    expect(harness.defineSlot).not.toHaveBeenCalled();
+    expect(harness.destroySlots).toHaveBeenCalledOnce();
+  });
+
+  it('normalizes commit-admission throws and destroys the exact uncommitted candidate', async () => {
+    const harness = createReplacementHarness();
+    const admissionFailure = new Error('commit admission failed');
+    const operation = harness.adapter.run((gpt) =>
+      gpt.transactionalReplace(
+        {},
+        definition,
+        () => true,
+        () => {
+          throw admissionFailure;
+        }
+      )
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      cause: admissionFailure,
+      code: 'gpt_replacement_failed',
+      oldSlotDestroyed: true,
+      orphanedSlot: undefined,
+    });
+    expect(harness.replacement.addService).not.toHaveBeenCalled();
+    expect(harness.destroySlots).toHaveBeenCalledTimes(2);
+    expect(harness.destroySlots).toHaveBeenNthCalledWith(2, [harness.replacement]);
+  });
+
+  it('leaves the service unbound after the real adapter destroys old then defineSlot throws', async () => {
+    vi.useFakeTimers();
+    const harness = createReplacementHarness();
+    harness.defineSlot.mockImplementation(() => {
+      throw new Error('publisher define failed');
+    });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const oldSlot = { old: true };
+    expect(
+      service.register(navigation, [
+        serverRegistration('slot', {
+          adUnitCode: '/network/slot',
+          domAliases: ['slot-div'],
+        }),
+      ])
+    ).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition,
+        ownership: 'trusted_server',
+        slot: oldSlot,
+      })
+    ).toEqual({ ok: true });
+    const request = service.request({
+      intentId: 'real-define-throw',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(service.recordPublisherDestruction(oldSlot)).toBe(false);
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition,
+        ownership: 'trusted_server',
+        slot: { retry: true },
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it('leaves the service unbound when its generation check throws after old-slot destruction', async () => {
+    vi.useFakeTimers();
+    const harness = createReplacementHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const oldSlot = { old: true };
+    let oldSlotDestroyed = false;
+    const ownerFailure = new Error('owner check failed after destroy');
+    const isCurrent = vi.spyOn(navigation, 'isCurrent').mockImplementation(() => {
+      if (oldSlotDestroyed) throw ownerFailure;
+      return true;
+    });
+    harness.destroySlots.mockImplementation((slots) => {
+      if (slots[0] === oldSlot) oldSlotDestroyed = true;
+      return true;
+    });
+    expect(
+      service.register(navigation, [
+        serverRegistration('slot', {
+          adUnitCode: '/network/slot',
+          domAliases: ['slot-div'],
+        }),
+      ])
+    ).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition,
+        ownership: 'trusted_server',
+        slot: oldSlot,
+      })
+    ).toEqual({ ok: true });
+    const request = service.request({
+      intentId: 'real-current-throw',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(service.recordPublisherDestruction(oldSlot)).toBe(false);
+    isCurrent.mockImplementation(() => true);
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition,
+        ownership: 'trusted_server',
+        slot: { retry: true },
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it('rejects a defineSlot candidate that is the retired old object', async () => {
+    const harness = createReplacementHarness();
+    const oldSlot = { addService: vi.fn() };
+    harness.defineSlot.mockReturnValue(oldSlot);
+    const commit = vi.fn();
+    const operation = harness.adapter.run((gpt) =>
+      (
+        gpt.transactionalReplace as unknown as (
+          old: object,
+          candidateDefinition: GoogletagReplacementDefinition,
+          current: () => boolean,
+          prepareCommit: (candidate: object) => { commit: () => boolean; rollback: () => void }
+        ) => unknown
+      )(
+        oldSlot,
+        definition,
+        () => true,
+        () => ({ commit, rollback: vi.fn() })
+      )
+    );
+
+    await expect(operation.result).rejects.toBeDefined();
+    expect(commit).not.toHaveBeenCalled();
+    expect(harness.replacement.addService).not.toHaveBeenCalled();
+  });
+
+  it('surfaces the reused old identity when rejecting it cannot clean it up', async () => {
+    const harness = createReplacementHarness();
+    const oldSlot = { addService: vi.fn() };
+    harness.defineSlot.mockReturnValue(oldSlot);
+    harness.destroySlots.mockReturnValueOnce(true).mockReturnValueOnce(false);
+    const operation = harness.adapter.run((gpt) =>
+      gpt.transactionalReplace(oldSlot, definition, () => true, commitReplacement)
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'gpt_replacement_failed',
+      oldSlotDestroyed: true,
+      orphanedSlot: oldSlot,
+    });
+    expect(harness.destroySlots).toHaveBeenCalledTimes(2);
+  });
+
+  it('rolls back a synchronous service commit when the post-commit generation check is stale', async () => {
+    const harness = createReplacementHarness();
+    let checks = 0;
+    let bound: object | undefined;
+    const rollback = vi.fn(() => {
+      bound = undefined;
+    });
+    const operation = harness.adapter.run((gpt) =>
+      (
+        gpt.transactionalReplace as unknown as (
+          old: object,
+          candidateDefinition: GoogletagReplacementDefinition,
+          current: () => boolean,
+          prepareCommit: (candidate: object) => { commit: () => boolean; rollback: () => void }
+        ) => unknown
+      )(
+        {},
+        definition,
+        () => {
+          checks += 1;
+          return checks < 4;
+        },
+        (candidate) => ({
+          commit: () => {
+            bound = candidate;
+            return true;
+          },
+          rollback,
+        })
+      )
+    );
+
+    await expect(operation.result).resolves.toEqual({ status: 'destroyed' });
+    expect(rollback).toHaveBeenCalledOnce();
+    expect(bound).toBeUndefined();
+    expect(harness.destroySlots).toHaveBeenCalledTimes(2);
+  });
+
+  it('surfaces the exact orphan candidate when post-commit cleanup cannot destroy it', async () => {
+    const harness = createReplacementHarness();
+    harness.destroySlots.mockReturnValueOnce(true).mockReturnValueOnce(false);
+    const rollback = vi.fn();
+    let checks = 0;
+    const operation = harness.adapter.run((gpt) =>
+      (
+        gpt.transactionalReplace as unknown as (
+          old: object,
+          candidateDefinition: GoogletagReplacementDefinition,
+          current: () => boolean,
+          prepareCommit: (candidate: object) => { commit: () => boolean; rollback: () => void }
+        ) => unknown
+      )(
+        {},
+        definition,
+        () => {
+          checks += 1;
+          return checks < 4;
+        },
+        () => ({ commit: () => true, rollback })
+      )
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'gpt_replacement_failed',
+      orphanedSlot: harness.replacement,
+    });
+    expect(rollback).toHaveBeenCalledOnce();
+  });
+});
+
+function readyListenerBinding() {
+  const addEventListener = vi.fn();
+  const removeEventListener = vi.fn();
+  const pubads = {
+    addEventListener,
+    getSlots: () => [],
+    refresh: vi.fn(),
+    removeEventListener,
+  };
+  return {
+    addEventListener,
+    binding: {
+      apiReady: true,
+      cmd: { push: (command: () => void) => command() },
+      display: vi.fn(),
+      pubads: () => pubads,
+      pubadsReady: true,
+    },
+    removeEventListener,
+  };
+}
+
+describe('binding-aware GPT listener activation', () => {
+  it('installs observation without timers and starts readiness only after commit', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const service = createSlotService({ googletag: adapter });
+    service.activate();
+    expect(vi.getTimerCount()).toBe(0);
+
+    const missing = service.start();
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(10_000);
+    await expect(missing.result).rejects.toMatchObject({ code: 'external_ready_timeout' });
+
+    const ready = readyListenerBinding();
+    target.googletag = ready.binding;
+    await expect(service.start().result).resolves.toBeUndefined();
+    await expect(service.start().result).resolves.toBeUndefined();
+
+    expect(ready.addEventListener.mock.calls.map(([type]) => type)).toEqual([
+      'slotRequested',
+      'slotRenderEnded',
+    ]);
+  });
+
+  it('subscribes a replacement binding before allowing later operations without duplicating either', async () => {
+    const first = readyListenerBinding();
+    const second = readyListenerBinding();
+    const target: { googletag?: unknown } = { googletag: first.binding };
+    const adapter = createBrowserGoogletagAdapter(target);
+    const service = createSlotService({ googletag: adapter });
+    service.activate();
+    await expect(service.start().result).resolves.toBeUndefined();
+    target.googletag = second.binding;
+    await expect(service.start().result).resolves.toBeUndefined();
+    await expect(service.start().result).resolves.toBeUndefined();
+
+    expect(first.addEventListener).toHaveBeenCalledTimes(2);
+    expect(second.addEventListener).toHaveBeenCalledTimes(2);
+    expect(first.removeEventListener).toHaveBeenCalledTimes(2);
+    service.dispose();
+    expect(first.removeEventListener).toHaveBeenCalledTimes(2);
+    expect(second.removeEventListener).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('physical GPT cycles', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('preserves external_queue_full when GPT readiness admission is saturated', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const service = createSlotService({ googletag: adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    for (let index = 0; index < 64; index += 1) {
+      const queued = adapter.run(() => undefined);
+      void queued.result.catch(() => undefined);
+    }
+
+    const request = service.request({
+      intentId: 'queue-capacity',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'external_queue_full',
+    });
+    service.dispose();
+    adapter.dispose();
+  });
+
+  it('preserves external_ready_timeout when GPT never becomes ready', async () => {
+    vi.useFakeTimers();
+    const target: { googletag?: unknown } = {};
+    const adapter = createBrowserGoogletagAdapter(target);
+    const service = createSlotService({ googletag: adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'readiness-deadline',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    await expect(request.result).resolves.toEqual({
+      status: 'failed',
+      reason: 'external_ready_timeout',
+    });
+    service.dispose();
+    adapter.dispose();
+  });
+
+  it('records intent before a synchronous slotRequested event and supports SRA per slot', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'first');
+    const second = bindTrustedSlot(service, navigation, 'second');
+    harness.display.mockImplementation((slot: object) => {
+      service.handleGptEvent('slotRequested', { slot });
+    });
+
+    const firstRequest = service.request({
+      intentId: 'intent-first',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'first',
+    });
+    const secondRequest = service.request({
+      intentId: 'intent-second',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'second',
+    });
+    await Promise.resolve();
+    expect(harness.display.mock.calls.map(([slot]) => slot)).toEqual([first, second]);
+
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'response-first',
+      slot: first,
+    });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: true,
+      responseIdentifier: 'response-second',
+      slot: second,
+    });
+    await expect(firstRequest.result).resolves.toEqual({
+      responseIdentifier: 'response-first',
+      status: 'rendered',
+    });
+    await expect(secondRequest.result).resolves.toEqual({
+      responseIdentifier: 'response-second',
+      status: 'empty',
+    });
+  });
+
+  it('uses display only for registration under disabled initial load and one exact refresh', async () => {
+    const harness = createGptHarness({ initialLoadDisabled: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+
+    service.request({
+      intentId: 'intent',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+
+    expect(harness.display).toHaveBeenCalledExactlyOnceWith(slot);
+    expect(harness.refresh).toHaveBeenCalledExactlyOnceWith(
+      [slot],
+      Object.freeze({ changeCorrelator: false })
+    );
+  });
+
+  it('treats a slotRequested raised by disabled-load display as publisher overlap and skips refresh', async () => {
+    const harness = createGptHarness({ initialLoadDisabled: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    harness.display.mockImplementation(() => {
+      service.handleGptEvent('slotRequested', { slot });
+    });
+    const request = service.request({
+      intentId: 'display-overlap',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+
+    await expect(request.result).resolves.toEqual({
+      reason: 'cycle_unattributable',
+      status: 'failed',
+    });
+    expect(harness.refresh).not.toHaveBeenCalled();
+  });
+
+  it('fails a disabled-initial-load request when refresh throws', async () => {
+    const harness = createGptHarness({ initialLoadDisabled: true });
+    harness.refresh.mockImplementation(() => {
+      throw new Error('refresh unavailable');
+    });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+
+    const request = service.request({
+      intentId: 'intent',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+
+    await expect(request.result).resolves.toEqual({
+      reason: 'gpt_request_failed',
+      status: 'failed',
+    });
+  });
+
+  it('fails a disabled-initial-load request when refresh is unavailable', async () => {
+    const harness = createGptHarness({ initialLoadDisabled: true, missingRefresh: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'missing-refresh',
+      navigationGeneration: navigation.generation,
+      operation: 'display',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+
+    await expect(request.result).resolves.toEqual({
+      reason: 'gpt_request_failed',
+      status: 'failed',
+    });
+  });
+
+  it('records every SRA intent before one refresh and fans out events by object identity', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'sra-first');
+    const second = bindTrustedSlot(service, navigation, 'sra-second');
+
+    const requests = service.requestBatch([
+      {
+        intentId: 'sra-intent-first',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'sra-first',
+      },
+      {
+        intentId: 'sra-intent-second',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'sra-second',
+      },
+    ]);
+    await Promise.resolve();
+    expect(harness.refresh).toHaveBeenCalledExactlyOnceWith(
+      [first, second],
+      Object.freeze({ changeCorrelator: false })
+    );
+    service.handleGptEvent('slotRequested', { slot: first });
+    service.handleGptEvent('slotRequested', { slot: second });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'sra-first-response',
+      slot: first,
+    });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: true,
+      responseIdentifier: 'sra-second-response',
+      slot: second,
+    });
+    await expect(Promise.all(requests.map(({ result }) => result))).resolves.toEqual([
+      { responseIdentifier: 'sra-first-response', status: 'rendered' },
+      { responseIdentifier: 'sra-second-response', status: 'empty' },
+    ]);
+  });
+
+  it('arms every display intent before a synchronous SRA request can emit sibling events', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'display-first');
+    const second = bindTrustedSlot(service, navigation, 'display-second');
+    harness.display.mockImplementation(() => {
+      harness.emit('slotRequested', { slot: first });
+      harness.emit('slotRequested', { slot: second });
+      harness.emit('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: 'display-first-response',
+        slot: first,
+      });
+      harness.emit('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: 'display-second-response',
+        slot: second,
+      });
+    });
+    const displayBatch = [
+      {
+        expectedSlot: first,
+        intentId: 'display-first-intent',
+        navigationGeneration: navigation.generation,
+        operation: 'display' as const,
+        registeredSlotId: 'display-first',
+        requestClass: 'primary',
+      },
+      {
+        expectedSlot: second,
+        intentId: 'display-second-intent',
+        navigationGeneration: navigation.generation,
+        operation: 'display' as const,
+        registeredSlotId: 'display-second',
+        requestClass: 'primary',
+      },
+    ] as const;
+    const runtimeRequestBatch = service.requestBatch as unknown as (
+      inputs: typeof displayBatch
+    ) => readonly ReturnType<SlotService['request']>[];
+
+    const requests = runtimeRequestBatch(displayBatch);
+    await expect(Promise.all(requests.map(({ result }) => result))).resolves.toEqual([
+      { responseIdentifier: 'display-first-response', status: 'rendered' },
+      { responseIdentifier: 'display-second-response', status: 'rendered' },
+    ]);
+    expect(harness.display).toHaveBeenCalledOnce();
+    expect(harness.refresh).not.toHaveBeenCalled();
+  });
+
+  it.each(['unknown-slot', 'duplicate-slot', 'duplicate-intent', 'mixed-navigation'] as const)(
+    'prevalidates the entire SRA batch atomically: %s',
+    (failure) => {
+      const harness = createGptHarness();
+      const service = createSlotService({ googletag: harness.adapter });
+      const firstNavigation = createNavigation();
+      const secondNavigation = createNavigation();
+      bindTrustedSlot(service, firstNavigation, 'first');
+      bindTrustedSlot(service, firstNavigation, 'second');
+      bindTrustedSlot(service, secondNavigation, 'other-navigation');
+      const first = {
+        intentId: 'first-intent',
+        navigationGeneration: firstNavigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'first',
+        requestClass: 'primary',
+      };
+      const second = {
+        intentId: failure === 'duplicate-intent' ? first.intentId : 'second-intent',
+        navigationGeneration:
+          failure === 'mixed-navigation' ? secondNavigation.generation : firstNavigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId:
+          failure === 'unknown-slot'
+            ? 'missing'
+            : failure === 'duplicate-slot'
+              ? first.registeredSlotId
+              : failure === 'mixed-navigation'
+                ? 'other-navigation'
+                : 'second',
+        requestClass: 'primary',
+      };
+      const inventory = service.snapshotForTest();
+
+      expect(service.requestBatch([first, second])).toEqual([]);
+      expect(service.snapshotForTest()).toEqual(inventory);
+      expect(harness.refresh).not.toHaveBeenCalled();
+    }
+  );
+
+  it('treats an empty SRA batch as an inert rejection', () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    expect(service.requestBatch([])).toEqual([]);
+    expect(service.snapshotForTest()).toEqual({
+      cycles: 0,
+      intents: 0,
+      physicalSlots: 0,
+      records: 0,
+    });
+    expect(harness.refresh).not.toHaveBeenCalled();
+  });
+
+  it('contains a throwing batch length read before validation', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const hostileInputs = new Proxy([], {
+      get: (target, key, receiver) => {
+        if (key === 'length') throw new Error('hostile batch length');
+        return Reflect.get(target, key, receiver);
+      },
+    });
+    const runtimeRequestBatch = service.requestBatch as unknown as (
+      inputs: readonly object[]
+    ) => unknown;
+    let outcome: unknown;
+
+    expect(() => {
+      outcome = runtimeRequestBatch(hostileInputs);
+    }).not.toThrow();
+    expect(outcome).toEqual([]);
+    expect(service.snapshotForTest()).toEqual({
+      cycles: 0,
+      intents: 0,
+      physicalSlots: 0,
+      records: 0,
+    });
+  });
+
+  it('does not leak partial admission through a poisoned Array map', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation, 'map-first');
+    bindTrustedSlot(service, navigation, 'map-second');
+    const inputs = [
+      {
+        intentId: 'poison-map-first',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'map-first',
+        requestClass: 'primary',
+      },
+      {
+        intentId: 'poison-map-second',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'map-second',
+        requestClass: 'primary',
+      },
+    ];
+    const originalMap = Array.prototype.map;
+    Array.prototype.map = function <Value, Result>(
+      this: Value[],
+      callback: (value: Value, index: number, array: Value[]) => Result,
+      thisArgument?: unknown
+    ): Result[] {
+      let targeted = false;
+      for (let index = 0; index < this.length; index += 1) {
+        const value = this[index] as { intentId?: unknown } | undefined;
+        if (value?.intentId === 'poison-map-first') targeted = true;
+      }
+      if (targeted) {
+        Reflect.apply(callback, thisArgument, [this[0], 0, this]);
+        throw new Error('poisoned map after partial admission');
+      }
+      return Reflect.apply(originalMap, this, [callback, thisArgument]) as Result[];
+    };
+    let handles: readonly ReturnType<SlotService['request']>[] | undefined;
+    let escaped: unknown;
+    try {
+      handles = service.requestBatch(inputs);
+    } catch (error) {
+      escaped = error;
+    } finally {
+      Array.prototype.map = originalMap;
+    }
+
+    expect(escaped).toBeUndefined();
+    expect(handles).toHaveLength(2);
+    for (const handle of handles ?? []) handle.dispose();
+    await expect(Promise.all((handles ?? []).map(({ result }) => result))).resolves.toEqual([
+      { reason: 'superseded', status: 'cancelled' },
+      { reason: 'superseded', status: 'cancelled' },
+    ]);
+    await Promise.resolve();
+    expect(harness.refresh).not.toHaveBeenCalled();
+    expect(service.snapshotForTest().intents).toBe(0);
+  });
+
+  it('does not leak post-admission intents through a poisoned Array iterator', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation, 'iterator-first');
+    bindTrustedSlot(service, navigation, 'iterator-second');
+    const inputs = [
+      {
+        intentId: 'poison-iterator-first',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'iterator-first',
+        requestClass: 'primary',
+      },
+      {
+        intentId: 'poison-iterator-second',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'iterator-second',
+        requestClass: 'primary',
+      },
+    ];
+    const originalIterator = Array.prototype[Symbol.iterator];
+    Array.prototype[Symbol.iterator] = function (): ArrayIterator<unknown> {
+      for (let index = 0; index < this.length; index += 1) {
+        const value = this[index] as { intentId?: unknown } | undefined;
+        if (value?.intentId === 'poison-iterator-first') {
+          throw new Error('poisoned iterator after admission');
+        }
+      }
+      return Reflect.apply(originalIterator, this, []) as ArrayIterator<unknown>;
+    };
+    let handles: readonly ReturnType<SlotService['request']>[] | undefined;
+    let escaped: unknown;
+    try {
+      handles = service.requestBatch(inputs);
+    } catch (error) {
+      escaped = error;
+    } finally {
+      Array.prototype[Symbol.iterator] = originalIterator;
+    }
+
+    expect(escaped).toBeUndefined();
+    expect(handles).toHaveLength(2);
+    for (let index = 0; index < (handles?.length ?? 0); index += 1) {
+      handles?.[index]?.dispose();
+    }
+    await expect(Promise.all((handles ?? []).map(({ result }) => result))).resolves.toEqual([
+      { reason: 'superseded', status: 'cancelled' },
+      { reason: 'superseded', status: 'cancelled' },
+    ]);
+    await Promise.resolve();
+    expect(harness.refresh).not.toHaveBeenCalled();
+    expect(service.snapshotForTest().intents).toBe(0);
+  });
+
+  it('rolls back every admitted batch handle when a later request unexpectedly throws', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    let poison = false;
+    let batchChecks = 0;
+    const owner = {
+      generation: {},
+      isCurrent: () => {
+        if (!poison) return true;
+        batchChecks += 1;
+        if (batchChecks === 4) throw new Error('second request admission failed');
+        return true;
+      },
+      onDispose: vi.fn(),
+    } as unknown as NavigationSession;
+    bindTrustedSlot(service, owner, 'rollback-first');
+    bindTrustedSlot(service, owner, 'rollback-second');
+    const inventory = service.snapshotForTest();
+    poison = true;
+
+    expect(
+      service.requestBatch([
+        {
+          intentId: 'rollback-first',
+          navigationGeneration: owner.generation,
+          operation: 'refresh',
+          registeredSlotId: 'rollback-first',
+          requestClass: 'primary',
+        },
+        {
+          intentId: 'rollback-second',
+          navigationGeneration: owner.generation,
+          operation: 'refresh',
+          registeredSlotId: 'rollback-second',
+          requestClass: 'primary',
+        },
+      ])
+    ).toEqual([]);
+    expect(service.snapshotForTest()).toEqual(inventory);
+  });
+
+  it('keeps publisher display intent publisher-owned and fails ambiguous overlap', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+
+    const request = service.request({
+      intentId: 'intent',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+
+    await expect(request.result).resolves.toEqual({
+      reason: 'cycle_unattributable',
+      status: 'failed',
+    });
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'publisher',
+      slot,
+    });
+    expect(harness.refresh).not.toHaveBeenCalled();
+  });
+
+  it('allows one queued replacement, supersedes its same-class predecessor, and rejects opposite overlap', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = (intentId: string, requestClass: string) =>
+      service.request({
+        intentId,
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass,
+        registeredSlotId: 'slot',
+      });
+    const active = request('active', 'primary');
+    const replaced = request('queued-one', 'primary');
+    const queued = request('queued-two', 'primary');
+    await expect(replaced.result).resolves.toEqual({
+      reason: 'superseded',
+      status: 'cancelled',
+    });
+    const conflicting = request('queued-fallback', 'fallback');
+    await expect(queued.result).resolves.toEqual({
+      reason: 'cycle_unattributable',
+      status: 'failed',
+    });
+    await expect(conflicting.result).resolves.toEqual({
+      reason: 'cycle_unattributable',
+      status: 'failed',
+    });
+    await expect(active.result).resolves.toEqual({
+      reason: 'cycle_unattributable',
+      status: 'failed',
+    });
+  });
+
+  it('queues one same-class replacement behind an open trusted-server cycle', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const first = service.request({
+      intentId: 'first-primary',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+
+    const second = service.request({
+      intentId: 'second-primary',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    expect(second.status).toBe('queued');
+    expect(harness.refresh).toHaveBeenCalledTimes(1);
+
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'first-primary-response',
+      slot,
+    });
+    await expect(first.result).resolves.toEqual({
+      responseIdentifier: 'first-primary-response',
+      status: 'rendered',
+    });
+    await Promise.resolve();
+    expect(harness.refresh).toHaveBeenCalledTimes(2);
+
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: true,
+      responseIdentifier: 'second-primary-response',
+      slot,
+    });
+    await expect(second.result).resolves.toEqual({
+      responseIdentifier: 'second-primary-response',
+      status: 'empty',
+    });
+  });
+
+  it('promotes a queued replacement when its active predecessor cancels before invocation', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const first = service.request({
+      intentId: 'cancelled-before-invocation',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    const second = service.request({
+      intentId: 'promoted-after-cancellation',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    expect(second.status).toBe('queued');
+
+    first.dispose();
+    await expect(first.result).resolves.toEqual({
+      reason: 'superseded',
+      status: 'cancelled',
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(harness.refresh).toHaveBeenCalledTimes(1);
+    expect(second.status).toBe('active');
+
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'promoted-response',
+      slot,
+    });
+    await expect(second.result).resolves.toEqual({
+      responseIdentifier: 'promoted-response',
+      status: 'rendered',
+    });
+    expect(service.snapshotForTest()).toMatchObject({ cycles: 0, intents: 0 });
+  });
+
+  it('fails active and queued TS work when publisher intent makes ownership ambiguous', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const active = service.request({
+      intentId: 'active',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    const queued = service.request({
+      intentId: 'queued',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+    await expect(active.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    await expect(queued.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'publisher',
+      slot,
+    });
+    expect(service.snapshotForTest().intents).toBe(0);
+  });
+
+  it('disposes an operation that settled synchronously before its handle was published', async () => {
+    const harness = createGptHarness({ synchronousRun: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    harness.refresh.mockImplementation(() => {
+      service.handleGptEvent('slotRequested', { slot });
+      service.handleGptEvent('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: 'synchronous',
+        slot,
+      });
+    });
+
+    const request = service.request({
+      intentId: 'synchronous',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await expect(request.result).resolves.toMatchObject({ status: 'rendered' });
+    expect(
+      harness.operationDisposals[harness.operationDisposals.length - 1]
+    ).toHaveBeenCalledOnce();
+  });
+
+  it('safe-retires an invoked pre-cycle cancellation instead of clearing its only safety timer', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'cancelled',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    request.dispose();
+    await expect(request.result).resolves.toMatchObject({ reason: 'superseded' });
+    await Promise.resolve();
+
+    expect(harness.destroySlots).toHaveBeenCalledTimes(1);
+    expect(harness.defineSlot).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([
+    [2_999, true],
+    [3_001, false],
+  ] as const)('arbitrates slotRequested at %i ms without timeout re-arm', async (at, wins) => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: `intent-${at}`,
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+
+    if (at < 3_000) {
+      await vi.advanceTimersByTimeAsync(at);
+      service.handleGptEvent('slotRequested', { slot });
+    } else {
+      await vi.advanceTimersByTimeAsync(at);
+      service.handleGptEvent('slotRequested', { slot });
+    }
+
+    if (wins) {
+      service.handleGptEvent('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: `response-${at}`,
+        slot,
+      });
+      await expect(request.result).resolves.toMatchObject({ status: 'rendered' });
+    } else {
+      await expect(request.result).resolves.toEqual({
+        reason: 'gpt_request_timeout',
+        status: 'failed',
+      });
+      service.handleGptEvent('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: `late-${at}`,
+        slot,
+      });
+      expect(service.snapshotForTest().cycles).toBe(0);
+    }
+  });
+
+  it.each(['event-first', 'timeout-first'] as const)(
+    'arbitrates callback registration order at the exact 3,000 ms boundary: %s',
+    async (order) => {
+      vi.useFakeTimers();
+      const harness = createGptHarness();
+      const service = createSlotService({ googletag: harness.adapter });
+      const navigation = createNavigation();
+      const slot = bindTrustedSlot(service, navigation);
+      if (order === 'event-first') {
+        setTimeout(() => service.handleGptEvent('slotRequested', { slot }), 3_000);
+      }
+      const request = service.request({
+        intentId: order,
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await Promise.resolve();
+      if (order === 'timeout-first') {
+        setTimeout(() => service.handleGptEvent('slotRequested', { slot }), 3_000);
+      }
+      await vi.advanceTimersByTimeAsync(3_000);
+
+      if (order === 'event-first') {
+        service.handleGptEvent('slotRenderEnded', {
+          isEmpty: false,
+          responseIdentifier: order,
+          slot,
+        });
+        await expect(request.result).resolves.toMatchObject({ status: 'rendered' });
+      } else {
+        await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+      }
+    }
+  );
+
+  it.each([
+    [9_999, true],
+    [10_001, false],
+  ] as const)('arbitrates slotRenderEnded at %i ms from invocation', async (at, wins) => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: `intent-${at}`,
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+
+    if (at < 10_000) {
+      await vi.advanceTimersByTimeAsync(at);
+      service.handleGptEvent('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: `response-${at}`,
+        slot,
+      });
+    } else {
+      await vi.advanceTimersByTimeAsync(at);
+    }
+
+    await expect(request.result).resolves.toEqual(
+      wins
+        ? { responseIdentifier: `response-${at}`, status: 'rendered' }
+        : { reason: 'gpt_completion_timeout', status: 'failed' }
+    );
+  });
+
+  it.each(['event-first', 'timeout-first'] as const)(
+    'arbitrates callback registration order at the exact 10,000 ms boundary: %s',
+    async (order) => {
+      vi.useFakeTimers();
+      const harness = createGptHarness();
+      const service = createSlotService({ googletag: harness.adapter });
+      const navigation = createNavigation();
+      const slot = bindTrustedSlot(service, navigation);
+      const request = service.request({
+        intentId: `completion-${order}`,
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await Promise.resolve();
+      if (order === 'event-first') {
+        setTimeout(
+          () =>
+            service.handleGptEvent('slotRenderEnded', {
+              isEmpty: false,
+              responseIdentifier: order,
+              slot,
+            }),
+          10_000
+        );
+      }
+      service.handleGptEvent('slotRequested', { slot });
+      if (order === 'timeout-first') {
+        setTimeout(
+          () =>
+            service.handleGptEvent('slotRenderEnded', {
+              isEmpty: false,
+              responseIdentifier: order,
+              slot,
+            }),
+          10_000
+        );
+      }
+      await vi.advanceTimersByTimeAsync(10_000);
+
+      await expect(request.result).resolves.toMatchObject(
+        order === 'event-first' ? { status: 'rendered' } : { reason: 'gpt_completion_timeout' }
+      );
+    }
+  );
+
+  it('deduplicates a response identifier without completing a replacement cycle', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const first = service.request({
+      intentId: 'first',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'duplicate',
+      slot,
+    });
+    await expect(first.result).resolves.toMatchObject({ status: 'rendered' });
+
+    const second = service.request({
+      intentId: 'second',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'duplicate',
+      slot,
+    });
+    await vi.advanceTimersByTimeAsync(10_000);
+    await expect(second.result).resolves.toEqual({
+      reason: 'gpt_completion_timeout',
+      status: 'failed',
+    });
+  });
+
+  it('recovers a completion timeout through the exact destroy/redefine transaction', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const disposeCommittedArtifact = vi.fn();
+    const service = createSlotService({
+      bindCommittedArtifactRetirement,
+      disposeCommittedArtifact,
+      googletag: harness.adapter,
+    });
+    const navigation = createNavigation();
+    const oldSlot = bindTrustedSlot(service, navigation);
+    const artifact = committedArtifact(navigation.generation);
+    expect(service.adoptCommittedArtifact(navigation.generation, 'slot', artifact)).toBe(true);
+    const first = service.request({
+      intentId: 'completion-timeout',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot: oldSlot });
+    await vi.advanceTimersByTimeAsync(10_000);
+    await expect(first.result).resolves.toMatchObject({ reason: 'gpt_completion_timeout' });
+    await Promise.resolve();
+    const replacement = harness.defineSlot.mock.results[0]?.value;
+    if (typeof replacement !== 'object' || replacement === null) {
+      throw new Error('Expected completion-timeout replacement');
+    }
+    expect(harness.destroySlots).toHaveBeenCalledExactlyOnceWith([oldSlot]);
+    expect(disposeCommittedArtifact).toHaveBeenCalledExactlyOnceWith(
+      navigation.generation,
+      'slot',
+      artifact
+    );
+
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'late-completion',
+      slot: oldSlot,
+    });
+    const recovered = service.request({
+      intentId: 'recovered',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    expect(recovered.status).toBe('active');
+    expect(harness.refresh).toHaveBeenLastCalledWith(
+      [replacement],
+      Object.freeze({ changeCorrelator: false })
+    );
+    service.handleGptEvent('slotRequested', { slot: replacement });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'replacement-completion',
+      slot: replacement,
+    });
+    await expect(recovered.result).resolves.toEqual({
+      responseIdentifier: 'replacement-completion',
+      status: 'rendered',
+    });
+  });
+
+  it('never releases publisher request-timeout quarantine from later GPT events', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = { publisher: true };
+    expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        ownership: 'publisher',
+        slot,
+      })
+    ).toEqual({ ok: true });
+    const timedOut = service.request({
+      intentId: 'publisher-timeout',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(timedOut.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'unattributable-late',
+      slot,
+    });
+    const later = service.request({
+      intentId: 'publisher-later',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await expect(later.result).resolves.toEqual({
+      reason: 'gpt_request_failed',
+      status: 'failed',
+    });
+  });
+
+  it.each(['throw', 'false'] as const)(
+    'keeps one retired object and quarantines failed request-timeout recovery: %s',
+    async (failure) => {
+      vi.useFakeTimers();
+      const harness = createGptHarness();
+      if (failure === 'throw') {
+        harness.destroySlots.mockImplementation(() => {
+          throw new Error('destroy failed');
+        });
+      } else {
+        harness.destroySlots.mockReturnValue(false);
+      }
+      const service = createSlotService({ googletag: harness.adapter });
+      const navigation = createNavigation();
+      bindTrustedSlot(service, navigation);
+      const timedOut = service.request({
+        intentId: 'timed-out',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await Promise.resolve();
+      await vi.advanceTimersByTimeAsync(3_000);
+      await expect(timedOut.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+      await Promise.resolve();
+
+      const later = service.request({
+        intentId: 'later',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await expect(later.result).resolves.toEqual({
+        reason: 'gpt_request_failed',
+        status: 'failed',
+      });
+      expect(harness.defineSlot).not.toHaveBeenCalled();
+      expect(service.snapshotForTest().physicalSlots).toBe(1);
+    }
+  );
+
+  it('binds one successful request-timeout replacement and ignores events from the retired object', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const oldSlot = bindTrustedSlot(service, navigation);
+    const timedOut = service.request({
+      intentId: 'timed-out',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(timedOut.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+    const replacement = harness.defineSlot.mock.results[0]?.value;
+    if (typeof replacement !== 'object' || replacement === null) {
+      throw new Error('Expected a replacement slot');
+    }
+
+    service.handleGptEvent('slotRequested', { slot: oldSlot });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'retired-old',
+      slot: oldSlot,
+    });
+    const later = service.request({
+      intentId: 'later',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    expect(harness.refresh).toHaveBeenLastCalledWith(
+      [replacement],
+      Object.freeze({ changeCorrelator: false })
+    );
+    service.handleGptEvent('slotRequested', { slot: replacement });
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'replacement',
+      slot: replacement,
+    });
+    await expect(later.result).resolves.toMatchObject({ status: 'rendered' });
+  });
+
+  it('destroys a replacement created after generation became stale and never binds it', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    harness.defineSlot.mockImplementation((_path, _sizes, elementId) => {
+      const replacement = { elementId, replacement: true };
+      navigation.dispose();
+      return replacement;
+    });
+    const request = service.request({
+      intentId: 'stale',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      requestClass: 'primary',
+      registeredSlotId: 'slot',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(harness.destroySlots).toHaveBeenCalledTimes(2);
+    expect(service.resolveRegisteredSlot('slot')).toBeUndefined();
+  });
+
+  it('keeps publisher-owned navigation quarantine until its exact completion', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = { publisher: true };
+    expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        ownership: 'publisher',
+        slot,
+      })
+    ).toEqual({ ok: true });
+    service.recordPublisherIntent(slot);
+    service.handleGptEvent('slotRequested', { slot });
+    navigation.dispose();
+    expect(harness.destroySlots).not.toHaveBeenCalled();
+
+    const next = createNavigation();
+    expect(service.register(next, [serverRegistration('next')])).toMatchObject({ ok: true });
+    expect(service.adoptGptSlot(next.generation, 'next', { ownership: 'publisher', slot })).toEqual(
+      { ok: false, reason: 'slot_quarantined' }
+    );
+    service.handleGptEvent('slotRenderEnded', {
+      isEmpty: false,
+      responseIdentifier: 'old-navigation',
+      slot,
+    });
+    expect(service.adoptGptSlot(next.generation, 'next', { ownership: 'publisher', slot })).toEqual(
+      { ok: true }
+    );
+  });
+
+  it('blocks an active publisher placement across navigation until its completion drains', () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const registration = serverRegistration('slot', {
+      adUnitCode: '/network/slot',
+      domAliases: ['slot-div'],
+    });
+    const slot = { publisher: true };
+    expect(service.register(navigation, [registration])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', { ownership: 'publisher', slot })
+    ).toEqual({ ok: true });
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+    service.handleGptEvent('slotRequested', { slot });
+    navigation.dispose();
+
+    const next = createNavigation();
+    expect(service.register(next, [registration])).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+    expect(service.register(next, [registration])).toMatchObject({ ok: true });
+  });
+
+  it.each(['before', 'after'] as const)(
+    'keeps an old completion inert %s replacement completion on the same DOM id',
+    async (order) => {
+      const harness = createGptHarness();
+      const service = createSlotService({ googletag: harness.adapter });
+      const { navigation, runtime } = createRuntimeWithNavigation();
+      const oldSlot = bindTrustedSlot(service, navigation);
+      const oldRequest = service.request({
+        intentId: 'old',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await Promise.resolve();
+      service.handleGptEvent('slotRequested', { slot: oldSlot });
+
+      const replaced = runtime.replaceNavigation();
+      if (!replaced.ok) throw new Error('Expected replacement navigation');
+      await expect(oldRequest.result).resolves.toMatchObject({ reason: 'navigation_disposed' });
+      const newSlot = bindTrustedSlot(service, replaced.value);
+      const newRequest = service.request({
+        intentId: 'new',
+        navigationGeneration: replaced.value.generation,
+        operation: 'refresh',
+        requestClass: 'primary',
+        registeredSlotId: 'slot',
+      });
+      await Promise.resolve();
+      service.handleGptEvent('slotRequested', { slot: newSlot });
+      const finishOld = () =>
+        service.handleGptEvent('slotRenderEnded', {
+          isEmpty: false,
+          responseIdentifier: `old-${order}`,
+          slot: oldSlot,
+        });
+      const finishNew = () =>
+        service.handleGptEvent('slotRenderEnded', {
+          isEmpty: false,
+          responseIdentifier: `new-${order}`,
+          slot: newSlot,
+        });
+      if (order === 'before') {
+        finishOld();
+        finishNew();
+      } else {
+        finishNew();
+        finishOld();
+      }
+
+      await expect(newRequest.result).resolves.toEqual({
+        responseIdentifier: `new-${order}`,
+        status: 'rendered',
+      });
+      expect(service.snapshotForTest().cycles).toBe(0);
+    }
+  );
+
+  it('releases a navigation-disposed TS physical slot with no late cycle bookkeeping', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+
+    navigation.dispose();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(harness.destroySlots).toHaveBeenCalledTimes(1);
+    expect(service.snapshotForTest()).toMatchObject({ physicalSlots: 0, records: 0 });
+  });
+});
+
+describe('Task 11 adversarial ownership review', () => {
+  afterEach(() => vi.useRealTimers());
+
+  it('accepts paired UTF-16 surrogates and rejects unpaired identities and aliases', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+
+    expect(service.register(navigation, [serverRegistration('paired-😀')])).toMatchObject({
+      ok: true,
+    });
+
+    for (const registration of [
+      serverRegistration('broken-\ud800'),
+      serverRegistration('broken-\udc00'),
+      serverRegistration('slot', { adUnitCode: 'path-\ud800' }),
+      serverRegistration('slot', { domAliases: ['alias-\udc00'] }),
+    ]) {
+      expect(service.register(navigation, [registration])).toEqual({
+        ok: false,
+        reason: 'invalid_slot_id',
+      });
+    }
+  });
+
+  it('re-adopts an idle publisher object without retaining its old navigation strongly', () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const slot = { publisher: true };
+    expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', { ownership: 'publisher', slot })
+    ).toEqual({ ok: true });
+
+    const next = runtime.replaceNavigation();
+    if (!next.ok) throw new Error('Expected replacement navigation');
+    expect(service.snapshotForTest()).toMatchObject({ physicalSlots: 0, records: 0 });
+    expect(service.register(next.value, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(next.value.generation, 'slot', { ownership: 'publisher', slot })
+    ).toEqual({ ok: true });
+    expect(service.snapshotForTest().physicalSlots).toBe(1);
+  });
+
+  it('rejects an existing GPT identity when the destination record already owns another object', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const first = {};
+    const second = {};
+    expect(
+      service.register(navigation, [serverRegistration('one'), serverRegistration('two')])
+    ).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'one', { ownership: 'publisher', slot: first })
+    ).toEqual({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'two', { ownership: 'publisher', slot: second })
+    ).toEqual({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'two', { ownership: 'publisher', slot: first })
+    ).toEqual({ ok: false, reason: 'gpt_object_collision' });
+  });
+
+  it('releases an exact publisher quarantine only through explicit publisher destruction', async () => {
+    vi.useFakeTimers();
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const slot = { publisher: true };
+    expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', { ownership: 'publisher', slot })
+    ).toEqual({ ok: true });
+    const request = service.request({
+      intentId: 'publisher-timeout',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+
+    const next = runtime.replaceNavigation();
+    if (!next.ok) throw new Error('Expected replacement navigation');
+    expect(service.register(next.value, [serverRegistration('slot')])).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+    expect(service.recordPublisherDestruction(slot)).toBe(true);
+    expect(service.register(next.value, [serverRegistration('slot')])).toMatchObject({ ok: true });
+  });
+
+  it('quarantines every failed TS placement key and never retries its destroy on navigation', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    harness.destroySlots.mockReturnValue(false);
+    const service = createSlotService({ googletag: harness.adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'timeout',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    expect(harness.destroySlots).toHaveBeenCalledTimes(1);
+
+    const next = runtime.replaceNavigation();
+    if (!next.ok) throw new Error('Expected replacement navigation');
+    await Promise.resolve();
+    expect(harness.destroySlots).toHaveBeenCalledTimes(1);
+    for (const registration of [
+      serverRegistration('slot'),
+      serverRegistration('other-id', { adUnitCode: '/network/slot' }),
+      serverRegistration('other-alias', { domAliases: ['slot-div'] }),
+    ]) {
+      expect(service.register(next.value, [registration])).toEqual({
+        ok: false,
+        reason: 'slot_quarantined',
+      });
+    }
+    expect(service.recordPublisherDestruction(slot)).toBe(true);
+    expect(service.register(next.value, [serverRegistration('slot')])).toMatchObject({ ok: true });
+  });
+
+  it('requires a usable replacement definition for trusted-server adoption', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        ownership: 'trusted_server',
+        slot: {},
+      })
+    ).toEqual({ ok: false, reason: 'gpt_request_failed' });
+  });
+
+  it('reads a replacement definition once and owns an immutable placement snapshot', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    expect(
+      service.register(navigation, [
+        serverRegistration('slot', {
+          adUnitCode: '/network/original',
+          domAliases: ['original-div'],
+        }),
+      ])
+    ).toMatchObject({ ok: true });
+    let adUnitPath = '/network/original';
+    let elementId = 'original-div';
+    const sizes = [[300, 250]];
+    const reads = { adUnitPath: 0, elementId: 0, sizes: 0 };
+    const definition = {
+      get adUnitPath() {
+        reads.adUnitPath += 1;
+        return adUnitPath;
+      },
+      get elementId() {
+        reads.elementId += 1;
+        return elementId;
+      },
+      get sizes() {
+        reads.sizes += 1;
+        return sizes;
+      },
+    };
+    const slot = { original: true };
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition,
+        ownership: 'trusted_server',
+        slot,
+      })
+    ).toEqual({ ok: true });
+    expect(reads).toEqual({ adUnitPath: 1, elementId: 1, sizes: 1 });
+
+    adUnitPath = '/network/redirected';
+    elementId = 'redirected-div';
+    sizes[0] = [999, 999];
+    const request = service.request({
+      intentId: 'immutable-definition',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(reads).toEqual({ adUnitPath: 1, elementId: 1, sizes: 1 });
+    expect(harness.defineSlot).toHaveBeenCalledWith(
+      '/network/original',
+      [[300, 250]],
+      'original-div'
+    );
+  });
+
+  it.each(['outer-array', 'inner-pair'] as const)(
+    'contains a hostile replacement sizes graph without adoption mutation: %s',
+    (failure) => {
+      const service = createSlotService({ googletag: createGptHarness().adapter });
+      const navigation = createNavigation();
+      expect(service.register(navigation, [serverRegistration('slot')])).toMatchObject({
+        ok: true,
+      });
+      const innerPair = new Proxy([300, 250], {
+        get: (target, key, receiver) => {
+          if (failure === 'inner-pair' && key === '0') throw new Error('hostile pair index');
+          return Reflect.get(target, key, receiver);
+        },
+      });
+      const sizes = new Proxy([innerPair], {
+        get: (target, key, receiver) => {
+          if (failure === 'outer-array' && key === 'length') {
+            throw new Error('hostile sizes length');
+          }
+          return Reflect.get(target, key, receiver);
+        },
+      });
+      const inventory = service.snapshotForTest();
+
+      expect(
+        service.adoptGptSlot(navigation.generation, 'slot', {
+          definition: {
+            adUnitPath: '/network/slot',
+            elementId: 'slot-div',
+            sizes,
+          },
+          ownership: 'trusted_server',
+          slot: {},
+        })
+      ).toEqual({ ok: false, reason: 'gpt_request_failed' });
+      expect(service.snapshotForTest()).toEqual(inventory);
+      expect(service.resolveRegisteredSlot('slot')).toBeDefined();
+    }
+  );
+
+  it('counts multiple publisher intents and preserves two publisher cycles', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+
+    service.handleGptEvent('slotRequested', { slot });
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+    service.handleGptEvent('slotRequested', { slot });
+    expect(service.snapshotForTest().cycles).toBe(1);
+    service.handleGptEvent('slotRenderEnded', { isEmpty: true, slot });
+    expect(service.snapshotForTest().cycles).toBe(0);
+  });
+
+  it('returns an exact accepted cycle handle and retires it on replacement and navigation', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+
+    const first = service.handleGptEvent('slotRequested', { slot });
+    expect(Object.isFrozen(first)).toBe(true);
+    expect(Reflect.ownKeys(first ?? {})).toEqual(['isRetired']);
+    expect(first?.isRetired()).toBe(false);
+    expect(service.handleGptEvent('slotRequested', { slot })).toBeUndefined();
+    expect(
+      service.handleGptEvent('slotRenderEnded', {
+        isEmpty: false,
+        responseIdentifier: 'first-response',
+        slot,
+      })
+    ).toBe(first);
+    expect(first?.isRetired()).toBe(false);
+
+    const second = service.handleGptEvent('slotRequested', { slot });
+    expect(second).not.toBe(first);
+    expect(first?.isRetired()).toBe(true);
+    expect(second?.isRetired()).toBe(false);
+
+    navigation.dispose();
+    expect(second?.isRetired()).toBe(true);
+  });
+
+  it('bounds publisher intent accounting and fails closed on overflow', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    for (let index = 0; index < 64; index += 1) {
+      expect(service.recordPublisherIntent(slot)).toBe(true);
+    }
+    expect(service.recordPublisherIntent(slot)).toBe(false);
+
+    const blocked = service.request({
+      intentId: 'publisher-overflow',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(blocked.result).resolves.toEqual({
+      reason: 'gpt_request_failed',
+      status: 'failed',
+    });
+  });
+
+  it('fails and conservatively drains a TS cycle overlapped by publisher intent', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const active = service.request({
+      intentId: 'active',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+    await expect(active.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    const blocked = service.request({
+      intentId: 'blocked',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(blocked.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+    service.handleGptEvent('slotRequested', { slot });
+    expect(service.snapshotForTest().cycles).toBe(1);
+  });
+
+  it('rejects the first opposite-class queued request with the active intent', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const active = service.request({
+      intentId: 'active',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    const opposite = service.request({
+      intentId: 'opposite',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'fallback',
+    });
+
+    await expect(active.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    await expect(opposite.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+  });
+
+  it('quarantines a synchronous requested cycle when the external invocation then throws', async () => {
+    const harness = createGptHarness({ synchronousRun: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    harness.refresh.mockImplementation(() => {
+      service.handleGptEvent('slotRequested', { slot });
+      throw new Error('after-side-effect');
+    });
+    const request = service.request({
+      intentId: 'partial',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_failed' });
+    const blocked = service.request({
+      intentId: 'blocked',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await expect(blocked.result).resolves.toMatchObject({ reason: 'slot_quarantined' });
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+  });
+
+  it('keeps a shared synchronous SRA operation alive for an unfinished sibling', async () => {
+    const harness = createGptHarness({ synchronousRun: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'first');
+    const second = bindTrustedSlot(service, navigation, 'second');
+    harness.refresh.mockImplementation(() => {
+      service.handleGptEvent('slotRequested', { slot: first });
+      service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot: first });
+      service.handleGptEvent('slotRequested', { slot: second });
+    });
+    const requests = service.requestBatch([
+      {
+        intentId: 'first',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'first',
+        requestClass: 'primary',
+      },
+      {
+        intentId: 'second',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'second',
+        requestClass: 'primary',
+      },
+    ]);
+    await expect(requests[0]?.result).resolves.toMatchObject({ status: 'rendered' });
+    expect(requests[1]?.status).toBe('active');
+    expect(
+      harness.operationDisposals[harness.operationDisposals.length - 1]
+    ).not.toHaveBeenCalled();
+    service.handleGptEvent('slotRenderEnded', { isEmpty: true, slot: second });
+    await expect(requests[1]?.result).resolves.toMatchObject({ status: 'empty' });
+  });
+
+  it('does not invoke an SRA batch after its subscription continuation is disposed', async () => {
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation, 'deferred-first');
+    bindTrustedSlot(service, navigation, 'deferred-second');
+    const requests = service.requestBatch([
+      {
+        intentId: 'deferred-first',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'deferred-first',
+        requestClass: 'primary',
+      },
+      {
+        intentId: 'deferred-second',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'deferred-second',
+        requestClass: 'primary',
+      },
+    ]);
+    navigation.dispose();
+
+    await expect(Promise.all(requests.map(({ result }) => result))).resolves.toEqual([
+      { reason: 'navigation_disposed', status: 'cancelled' },
+      { reason: 'navigation_disposed', status: 'cancelled' },
+    ]);
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(harness.refresh).not.toHaveBeenCalled();
+  });
+
+  it('enforces delayed-handler deadlines from invocation with a monotonic injected clock', async () => {
+    vi.useFakeTimers();
+    let current = 100;
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter, now: () => current });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'delayed',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    current = 3_101;
+    service.handleGptEvent('slotRequested', { slot });
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+  });
+
+  it('does not let a timer fire before the injected clock reaches its deadline', async () => {
+    vi.useFakeTimers();
+    let current = 0;
+    const service = createSlotService({
+      googletag: createGptHarness().adapter,
+      now: () => current,
+    });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'lagged-clock',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    current = 2_999;
+    await vi.advanceTimersByTimeAsync(3_000);
+    expect(request.status).toBe('active');
+    current = 3_000;
+    await vi.advanceTimersByTimeAsync(1);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+  });
+
+  it('fails closed on malformed completion truth instead of rendering it', async () => {
+    vi.useFakeTimers();
+    const malformedEvents = [
+      {},
+      { isEmpty: 'false' },
+      Object.defineProperty({}, 'isEmpty', { get: () => false }),
+    ];
+    for (let index = 0; index < malformedEvents.length; index += 1) {
+      const service = createSlotService({ googletag: createGptHarness().adapter });
+      const navigation = createNavigation();
+      const slot = bindTrustedSlot(service, navigation, `slot-${index}`);
+      const request = service.request({
+        intentId: `malformed-${index}`,
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: `slot-${index}`,
+        requestClass: 'primary',
+      });
+      await Promise.resolve();
+      service.handleGptEvent('slotRequested', { slot });
+      const event = { slot };
+      const malformed = malformedEvents[index];
+      const descriptor = malformed
+        ? Object.getOwnPropertyDescriptor(malformed, 'isEmpty')
+        : undefined;
+      if (descriptor) Object.defineProperty(event, 'isEmpty', descriptor);
+      service.handleGptEvent('slotRenderEnded', event);
+      expect(request.status).toBe('active');
+      await vi.advanceTimersByTimeAsync(10_000);
+      await expect(request.result).resolves.toMatchObject({ reason: 'gpt_completion_timeout' });
+    }
+  });
+
+  it('enforces the completion deadline in the handler when timer delivery is blocked', async () => {
+    vi.useFakeTimers();
+    let current = 0;
+    const harness = createGptHarness();
+    const service = createSlotService({
+      googletag: harness.adapter,
+      now: () => current,
+    });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'blocked-completion-timer',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    current = 100;
+    service.handleGptEvent('slotRequested', { slot });
+    current = 10_001;
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot });
+
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_completion_timeout' });
+    expect(service.snapshotForTest().cycles).toBe(0);
+    const replacement = harness.defineSlot.mock.results[0]?.value;
+    if (typeof replacement !== 'object' || replacement === null) {
+      throw new Error('Expected handler-enforced timeout replacement');
+    }
+
+    const next = service.request({
+      intentId: 'after-late-exact-completion',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    expect(harness.refresh).toHaveBeenCalledTimes(2);
+    service.handleGptEvent('slotRequested', { slot: replacement });
+    service.handleGptEvent('slotRenderEnded', { isEmpty: false, slot: replacement });
+    await expect(next.result).resolves.toMatchObject({ status: 'rendered' });
+  });
+
+  it('fails active and queued work when publisher intent overlaps the opened TS cycle', async () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const active = service.request({
+      intentId: 'active',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    const queued = service.request({
+      intentId: 'queued',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    service.handleGptEvent('slotRequested', { slot });
+
+    expect(service.recordPublisherIntent(slot)).toBe(true);
+    await expect(active.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+    await expect(queued.result).resolves.toMatchObject({ reason: 'cycle_unattributable' });
+  });
+
+  it('keeps promoted listeners across an async command that emits synchronously and then throws', async () => {
+    const commands: Array<() => void> = [];
+    const listeners = new Map<string, Set<(event: unknown) => void>>();
+    const pubads = {
+      addEventListener: (type: string, listener: (event: unknown) => void) => {
+        const current = listeners.get(type) ?? new Set();
+        current.add(listener);
+        listeners.set(type, current);
+      },
+      getSlots: () => [slot],
+      refresh: vi.fn(() => {
+        for (const listener of listeners.get('slotRequested') ?? []) listener({ slot });
+        throw new Error('after synchronous event');
+      }),
+      removeEventListener: (type: string, listener: (event: unknown) => void) => {
+        listeners.get(type)?.delete(listener);
+      },
+    };
+    const adapter = createBrowserGoogletagAdapter({
+      googletag: {
+        apiReady: true,
+        cmd: { push: (command: () => void) => commands.push(command) },
+        display: vi.fn(),
+        pubads: () => pubads,
+        pubadsReady: true,
+      },
+    });
+    const service = createSlotService({ googletag: adapter });
+    const navigation = createNavigation();
+    const slot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'async-partial',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    commands.shift()?.();
+    await Promise.resolve();
+    await Promise.resolve();
+    commands.shift()?.();
+
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_failed' });
+    expect(listeners.get('slotRequested')?.size).toBe(1);
+    expect(listeners.get('slotRenderEnded')?.size).toBe(1);
+    for (const listener of listeners.get('slotRenderEnded') ?? []) {
+      listener({ isEmpty: false, slot });
+    }
+  });
+
+  it('quarantines every synchronously opened SRA cycle when shared refresh throws', async () => {
+    const harness = createGptHarness({ synchronousRun: true });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const first = bindTrustedSlot(service, navigation, 'first-partial');
+    const second = bindTrustedSlot(service, navigation, 'second-partial');
+    harness.refresh.mockImplementation(() => {
+      service.handleGptEvent('slotRequested', { slot: first });
+      service.handleGptEvent('slotRequested', { slot: second });
+      throw new Error('shared refresh failed');
+    });
+    const requests = service.requestBatch([
+      {
+        intentId: 'first-partial',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'first-partial',
+        requestClass: 'primary',
+      },
+      {
+        intentId: 'second-partial',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'second-partial',
+        requestClass: 'primary',
+      },
+    ]);
+
+    await expect(Promise.all(requests.map(({ result }) => result))).resolves.toEqual([
+      { reason: 'gpt_request_failed', status: 'failed' },
+      { reason: 'gpt_request_failed', status: 'failed' },
+    ]);
+    expect(service.snapshotForTest().cycles).toBe(2);
+  });
+
+  it('tracks an exact orphan candidate until publisher destruction releases its placement', async () => {
+    vi.useFakeTimers();
+    const orphan = { orphan: true };
+    const harness = createGptHarness({ orphanOnReplace: orphan });
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'orphan',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+    expect(service.recordPublisherDestruction(orphan)).toBe(true);
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition: {
+          adUnitPath: '/network/slot',
+          elementId: 'slot-div',
+          sizes: [[300, 250]],
+        },
+        ownership: 'trusted_server',
+        slot: { replacementAfterOrphan: true },
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it('retains a reused old identity when rejecting it cannot destroy the candidate', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness({ returnOldOnReplace: true });
+    harness.destroySlots.mockReturnValueOnce(true).mockReturnValueOnce(false);
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const oldSlot = bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'reused-old-orphan',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition: {
+          adUnitPath: '/network/slot',
+          elementId: 'slot-div',
+          sizes: [[300, 250]],
+        },
+        ownership: 'trusted_server',
+        slot: { blocked: true },
+      })
+    ).toEqual({ ok: false, reason: 'slot_quarantined' });
+    expect(service.recordPublisherDestruction(oldSlot)).toBe(true);
+  });
+
+  it.each([true, false])(
+    'never cleans or republishes a replacement candidate owned by another record: cleanup=%s',
+    async (candidateCleanupWouldSucceed) => {
+      vi.useFakeTimers();
+      const harness = createReplacementHarness();
+      harness.destroySlots
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(candidateCleanupWouldSucceed);
+      const service = createSlotService({ googletag: harness.adapter });
+      const navigation = createNavigation();
+      const firstDefinition = Object.freeze({
+        adUnitPath: '/network/first',
+        elementId: 'first-div',
+        sizes: Object.freeze([[300, 250]]),
+      });
+      const secondDefinition = Object.freeze({
+        adUnitPath: '/network/second',
+        elementId: 'second-div',
+        sizes: Object.freeze([[300, 250]]),
+      });
+      const oldSlot = { old: true };
+      expect(
+        service.register(navigation, [
+          serverRegistration('first', {
+            adUnitCode: firstDefinition.adUnitPath,
+            domAliases: [firstDefinition.elementId],
+          }),
+          serverRegistration('second', {
+            adUnitCode: secondDefinition.adUnitPath,
+            domAliases: [secondDefinition.elementId],
+          }),
+        ])
+      ).toMatchObject({ ok: true });
+      expect(
+        service.adoptGptSlot(navigation.generation, 'first', {
+          definition: firstDefinition,
+          ownership: 'trusted_server',
+          slot: oldSlot,
+        })
+      ).toEqual({ ok: true });
+      expect(
+        service.adoptGptSlot(navigation.generation, 'second', {
+          definition: secondDefinition,
+          ownership: 'trusted_server',
+          slot: harness.replacement,
+        })
+      ).toEqual({ ok: true });
+      const request = service.request({
+        intentId: `collision-${String(candidateCleanupWouldSucceed)}`,
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'first',
+        requestClass: 'primary',
+      });
+      await Promise.resolve();
+      await vi.advanceTimersByTimeAsync(3_000);
+      await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+      await Promise.resolve();
+
+      expect(harness.destroySlots).toHaveBeenCalledOnce();
+      expect(harness.replacement.addService).not.toHaveBeenCalled();
+      expect(
+        service.adoptGptSlot(navigation.generation, 'second', {
+          definition: secondDefinition,
+          ownership: 'trusted_server',
+          slot: harness.replacement,
+        })
+      ).toEqual({ ok: true });
+      const blocked = service.request({
+        intentId: 'original-remains-quarantined',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh',
+        registeredSlotId: 'first',
+        requestClass: 'primary',
+      });
+      await expect(blocked.result).resolves.toMatchObject({ reason: 'gpt_request_failed' });
+    }
+  );
+
+  it('leaves a clean define failure unbound and immediately re-adoptable', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    harness.defineSlot.mockReturnValue(undefined);
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const request = service.request({
+      intentId: 'define-failure',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+
+    expect(
+      service.adoptGptSlot(navigation.generation, 'slot', {
+        definition: {
+          adUnitPath: '/network/slot',
+          elementId: 'slot-div',
+          sizes: [[300, 250]],
+        },
+        ownership: 'trusted_server',
+        slot: { retry: true },
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it('deletes a stale destroyed identity so a later navigation may adopt it', async () => {
+    vi.useFakeTimers();
+    const harness = createGptHarness();
+    const service = createSlotService({ googletag: harness.adapter });
+    const { navigation, runtime } = createRuntimeWithNavigation();
+    const oldSlot = bindTrustedSlot(service, navigation);
+    harness.defineSlot.mockImplementation((_path, _sizes, elementId) => {
+      const candidate = { elementId };
+      runtime.replaceNavigation();
+      return candidate;
+    });
+    const request = service.request({
+      intentId: 'stale-destroyed',
+      navigationGeneration: navigation.generation,
+      operation: 'refresh',
+      registeredSlotId: 'slot',
+      requestClass: 'primary',
+    });
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(3_000);
+    await expect(request.result).resolves.toMatchObject({ reason: 'gpt_request_timeout' });
+    await Promise.resolve();
+    const next = runtime.currentNavigation;
+    if (!next) throw new Error('Expected replacement navigation');
+    expect(service.register(next, [serverRegistration('slot')])).toMatchObject({ ok: true });
+    expect(
+      service.adoptGptSlot(next.generation, 'slot', { ownership: 'publisher', slot: oldSlot })
+    ).toEqual({ ok: true });
+  });
+
+  it.each(['single', 'batch'] as const)(
+    'rolls back provisional service subscription admission after %s preflight rejection',
+    async (kind) => {
+      const harness = createGptHarness({ synchronousRun: true });
+      const subscribe = vi.fn((_type: string, _listener: (event: unknown) => void) => vi.fn());
+      const facade = Object.freeze({ ...harness.facade, subscribe });
+      let rejectNext = true;
+      const adapter: GoogletagAdapter = Object.freeze({
+        bindingStatus: () => 'present',
+        enqueueGamAttribution: vi.fn(() => true),
+        diagnosticsIdentity: () => undefined,
+        dispose: vi.fn(),
+        notifyReady: vi.fn(),
+        observeDiagnostics: () => vi.fn(),
+        observePublisherCalls: () => vi.fn(),
+        traceToken: () => undefined,
+        run: <T>(command: (gpt: Readonly<GoogletagFacade>) => T) => {
+          let value: T;
+          try {
+            value = command(facade);
+          } catch (error) {
+            return Object.freeze({
+              status: 'present' as const,
+              result: Promise.reject(error),
+              dispose: vi.fn(),
+            });
+          }
+          const result = rejectNext
+            ? Promise.reject(new Error('post-command rejection'))
+            : Promise.resolve(value);
+          rejectNext = false;
+          return Object.freeze({ status: 'present' as const, result, dispose: vi.fn() });
+        },
+      });
+      const service = createSlotService({ googletag: adapter });
+      const navigation = createNavigation();
+      bindTrustedSlot(service, navigation);
+      const input = {
+        intentId: 'preflight',
+        navigationGeneration: navigation.generation,
+        operation: 'refresh' as const,
+        registeredSlotId: 'slot',
+        requestClass: 'primary',
+      };
+      const failed = kind === 'single' ? [service.request(input)] : service.requestBatch([input]);
+      await expect(failed[0]?.result).resolves.toMatchObject({ reason: 'gpt_request_failed' });
+      const retried = service.request({ ...input, intentId: 'retry' });
+      await Promise.resolve();
+
+      expect(subscribe).toHaveBeenCalledTimes(4);
+      retried.dispose();
+    }
+  );
+
+  it('fails closed after bounded placement quarantine storage saturates', () => {
+    const harness = createGptHarness();
+    harness.destroySlots.mockReturnValue(false);
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    for (let recordIndex = 0; recordIndex < 9; recordIndex += 1) {
+      const id = `saturated-${recordIndex}`;
+      const aliases = Array.from({ length: 256 }, (_, aliasIndex) => `${id}-alias-${aliasIndex}`);
+      expect(
+        service.register(navigation, [
+          serverRegistration(id, { adUnitCode: `/network/${id}`, domAliases: aliases }),
+        ])
+      ).toMatchObject({ ok: true });
+      expect(
+        service.adoptGptSlot(navigation.generation, id, {
+          definition: {
+            adUnitPath: `/network/${id}`,
+            elementId: aliases[0] ?? `${id}-div`,
+            sizes: [[300, 250]],
+          },
+          ownership: 'trusted_server',
+          slot: { id },
+        })
+      ).toEqual({ ok: true });
+    }
+    navigation.dispose();
+    const next = createNavigation();
+    expect(service.register(next, [serverRegistration('unrelated')])).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+  });
+
+  it('clears saturated placement quarantine only after every saturated owner releases once', () => {
+    const harness = createGptHarness();
+    harness.destroySlots.mockReturnValue(false);
+    const service = createSlotService({ googletag: harness.adapter });
+    const navigation = createNavigation();
+    const oldSlots: object[] = [];
+    for (let recordIndex = 0; recordIndex < 9; recordIndex += 1) {
+      const id = `recover-saturated-${recordIndex}`;
+      const aliases = Array.from({ length: 256 }, (_, aliasIndex) => `${id}-${aliasIndex}`);
+      const slot = { id };
+      oldSlots[oldSlots.length] = slot;
+      expect(
+        service.register(navigation, [
+          serverRegistration(id, { adUnitCode: `/network/${id}`, domAliases: aliases }),
+        ])
+      ).toMatchObject({ ok: true });
+      expect(
+        service.adoptGptSlot(navigation.generation, id, {
+          definition: {
+            adUnitPath: `/network/${id}`,
+            elementId: aliases[0] ?? `${id}-div`,
+            sizes: [[300, 250]],
+          },
+          ownership: 'trusted_server',
+          slot,
+        })
+      ).toEqual({ ok: true });
+    }
+    navigation.dispose();
+    const next = createNavigation();
+    expect(service.register(next, [serverRegistration('unrelated-after-saturation')])).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+
+    for (let index = 0; index < oldSlots.length - 1; index += 1) {
+      expect(service.recordPublisherDestruction(oldSlots[index] as object)).toBe(true);
+    }
+    expect(service.recordPublisherDestruction(oldSlots[7] as object)).toBe(false);
+    expect(service.register(next, [serverRegistration('unrelated-after-saturation')])).toEqual({
+      ok: false,
+      reason: 'slot_quarantined',
+    });
+
+    expect(service.recordPublisherDestruction(oldSlots[8] as object)).toBe(true);
+    expect(
+      service.register(next, [serverRegistration('unrelated-after-saturation')])
+    ).toMatchObject({
+      ok: true,
+    });
+  });
+
+  it.each(['throw-before', 'mutate-then-throw'] as const)(
+    'releases only confirmed shared-key quarantine increments: %s',
+    async (failure) => {
+      const originalSet = Map.prototype.set;
+      let poison = false;
+      Map.prototype.set = function <Key, Value>(
+        this: Map<Key, Value>,
+        key: Key,
+        value: Value
+      ): Map<Key, Value> {
+        const targeted = poison && key === ('ad-unit:/shared' as Key) && value === (2 as Value);
+        if (targeted && failure === 'throw-before') throw new Error('failed before increment');
+        const result = Reflect.apply(originalSet, this, [key, value]) as Map<Key, Value>;
+        if (targeted) throw new Error('failed after increment');
+        return result;
+      };
+      vi.resetModules();
+      let fresh: typeof import('../../src/services/slots');
+      try {
+        fresh = await import('../../src/services/slots');
+      } finally {
+        Map.prototype.set = originalSet;
+      }
+      const harness = createGptHarness();
+      harness.destroySlots.mockReturnValue(false);
+      const service = fresh.createSlotService({ googletag: harness.adapter });
+      const navigation = createNavigation();
+      const firstSlot = { first: true };
+      const secondSlot = { second: true };
+      for (const [id, slot] of [
+        ['first', firstSlot],
+        ['second', secondSlot],
+      ] as const) {
+        expect(
+          service.register(navigation, [
+            serverRegistration(id, { adUnitCode: '/shared', domAliases: [`${id}-div`] }),
+          ])
+        ).toMatchObject({ ok: true });
+        expect(
+          service.adoptGptSlot(navigation.generation, id, {
+            definition: {
+              adUnitPath: `/network/${id}`,
+              elementId: `${id}-div`,
+              sizes: [[300, 250]],
+            },
+            ownership: 'trusted_server',
+            slot,
+          })
+        ).toEqual({ ok: true });
+      }
+      poison = true;
+      navigation.dispose();
+      const next = createNavigation();
+
+      expect(service.recordPublisherDestruction(secondSlot)).toBe(true);
+      expect(service.recordPublisherDestruction(secondSlot)).toBe(false);
+      expect(
+        service.register(next, [serverRegistration('third', { adUnitCode: '/shared' })])
+      ).toEqual({ ok: false, reason: 'slot_quarantined' });
+
+      expect(service.recordPublisherDestruction(firstSlot)).toBe(true);
+      expect(
+        service.register(next, [serverRegistration('third', { adUnitCode: '/shared' })])
+      ).toMatchObject({ ok: true });
+    }
+  );
+
+  it('rolls back a Map publication whose captured set mutates and then throws', async () => {
+    const originalSet = Map.prototype.set;
+    let poison = false;
+    Map.prototype.set = function <K, V>(this: Map<K, V>, key: K, value: V): Map<K, V> {
+      const result = Reflect.apply(originalSet, this, [key, value]) as Map<K, V>;
+      if (poison && key === 'mutate-then-throw-slot') throw new Error('mutated then threw');
+      return result;
+    };
+    vi.resetModules();
+    let fresh: typeof import('../../src/services/slots');
+    try {
+      fresh = await import('../../src/services/slots');
+    } finally {
+      Map.prototype.set = originalSet;
+    }
+    const service = fresh.createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    poison = true;
+    expect(service.register(navigation, [serverRegistration('mutate-then-throw-slot')])).toEqual({
+      ok: false,
+      reason: 'stale_owner',
+    });
+    poison = false;
+    expect(service.resolveRegisteredSlot('mutate-then-throw-slot')).toBeUndefined();
+    expect(service.snapshotForTest().records).toBe(0);
+  });
+
+  it('uses captured iterator next intrinsics after publisher prototype poisoning', () => {
+    const service = createSlotService({ googletag: createGptHarness().adapter });
+    const navigation = createNavigation();
+    bindTrustedSlot(service, navigation);
+    const mapIteratorPrototype = Object.getPrototypeOf(new Map().values()) as {
+      next: () => IteratorResult<unknown>;
+    };
+    const setIteratorPrototype = Object.getPrototypeOf(new Set().values()) as {
+      next: () => IteratorResult<unknown>;
+    };
+    const mapNext = mapIteratorPrototype.next;
+    const setNext = setIteratorPrototype.next;
+    mapIteratorPrototype.next = () => {
+      throw new Error('poisoned map iterator');
+    };
+    setIteratorPrototype.next = () => {
+      throw new Error('poisoned set iterator');
+    };
+    try {
+      expect(service.snapshotForTest()).toMatchObject({ physicalSlots: 1, records: 1 });
+      expect(() => service.dispose()).not.toThrow();
+    } finally {
+      mapIteratorPrototype.next = mapNext;
+      setIteratorPrototype.next = setNext;
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/services/targeting.test.ts b/crates/trusted-server-js/lib/test/services/targeting.test.ts
new file mode 100644
index 000000000..a3dfd09f2
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/services/targeting.test.ts
@@ -0,0 +1,832 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createBrowserGoogletagAdapter } from '../../src/adapters/googletag';
+import { createTargetingService } from '../../src/services/targeting';
+
+function createTargetingHarness(initial: Record<string, readonly string[]> = {}) {
+  const values = new Map<string, readonly string[]>(Object.entries(initial));
+  const clearTargeting = vi.fn((key?: string) => {
+    if (key === undefined) values.clear();
+    else values.delete(key);
+  });
+  const getTargeting = vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])]));
+  const setTargeting = vi.fn((key: string, value: string | readonly string[]) => {
+    values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+  });
+  return { clearTargeting, getTargeting, setTargeting, values };
+}
+
+describe('owner-aware targeting journal', () => {
+  it('adopts an installed first-display value without rewriting it and restores its predecessor', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['trusted'] });
+
+    const frame = service.adopt(
+      slot,
+      'key',
+      'trusted',
+      Object.freeze(['publisher']),
+      'first-display-owner',
+      targeting
+    );
+
+    expect(frame).toBeDefined();
+    expect(targeting.setTargeting).not.toHaveBeenCalled();
+    frame?.release();
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+  });
+
+  it('rejects adoption when its targeting read observes a same-value publisher write', async () => {
+    const values = new Map<string, readonly string[]>([['key', ['trusted']]]);
+    let reenter = true;
+    const slot = {
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      }),
+      getTargeting: vi.fn((key: string) => {
+        if (reenter) {
+          reenter = false;
+          slot.setTargeting(key, 'trusted');
+        }
+        return Object.freeze([...(values.get(key) ?? [])]);
+      }),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      }),
+    };
+    const adapter = adapterForTargetingSlot(slot);
+    const service = createTargetingService();
+    await expect(service.observePublisherMutations(slot, adapter).result).resolves.toBeUndefined();
+
+    const ownership = await adapter.run((gpt) =>
+      service.adopt(slot, 'key', 'trusted', Object.freeze(['publisher']), 'handoff-owner', {
+        clearTargeting: (key) => gpt.clearTargeting(slot, key),
+        getTargeting: (key) => gpt.getTargeting(slot, key),
+        setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+      })
+    ).result;
+
+    expect(ownership).toBeUndefined();
+    ownership?.release();
+    expect(values.get('key')).toEqual(['trusted']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('restores the exact publisher predecessor after the current TS owner releases', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const frame = service.own(slot, 'key', 'trusted', 'owner-one', targeting);
+    expect(frame).toBeDefined();
+    expect(targeting.values.get('key')).toEqual(['trusted']);
+
+    frame?.release();
+
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(targeting.setTargeting).toHaveBeenLastCalledWith('key', ['publisher']);
+  });
+
+  it('keeps equal-string generations distinct and rebases non-top release without a GPT write', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const older = service.own(slot, 'key', 'same', 'older', targeting);
+    const newer = service.own(slot, 'key', 'same', 'newer', targeting);
+    targeting.setTargeting.mockClear();
+
+    older?.release();
+    expect(targeting.setTargeting).not.toHaveBeenCalled();
+    expect(targeting.clearTargeting).not.toHaveBeenCalled();
+    newer?.release();
+
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(targeting.setTargeting).toHaveBeenCalledExactlyOnceWith('key', ['publisher']);
+  });
+
+  it.each(['same', 'different'] as const)(
+    'invalidates the restoration chain before a publisher %s-value write',
+    (publisherValue) => {
+      const service = createTargetingService();
+      const slot = {};
+      const targeting = createTargetingHarness({ key: ['publisher'] });
+      const frame = service.own(slot, 'key', 'same', 'owner', targeting);
+
+      service.invalidatePublisherMutation(slot, 'key');
+      targeting.setTargeting('key', publisherValue === 'same' ? 'same' : 'publisher-new');
+      targeting.setTargeting.mockClear();
+      frame?.release();
+
+      expect(targeting.setTargeting).not.toHaveBeenCalled();
+      expect(targeting.clearTargeting).not.toHaveBeenCalled();
+      expect(targeting.values.get('key')).toEqual([
+        publisherValue === 'same' ? 'same' : 'publisher-new',
+      ]);
+    }
+  );
+
+  it('invalidates one key or all keys for publisher clear operations', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ one: ['publisher-one'], two: ['publisher-two'] });
+    const one = service.own(slot, 'one', 'ts-one', 'owner', targeting);
+    const two = service.own(slot, 'two', 'ts-two', 'owner', targeting);
+    service.invalidatePublisherMutation(slot, 'one');
+    targeting.clearTargeting('one');
+    one?.release();
+    expect(targeting.values.get('one')).toBeUndefined();
+
+    service.invalidatePublisherMutation(slot);
+    targeting.clearTargeting();
+    two?.release();
+    expect(targeting.values.size).toBe(0);
+  });
+
+  it('drops a stale chain instead of overwriting a publisher mutation before the next TS write', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const stale = service.own(slot, 'key', 'old-ts', 'old-owner', targeting);
+    targeting.setTargeting('key', 'publisher-race');
+    const current = service.own(slot, 'key', 'new-ts', 'new-owner', targeting);
+    stale?.release();
+    current?.release();
+
+    expect(targeting.values.get('key')).toEqual(['publisher-race']);
+  });
+
+  it('preserves sibling-key journals when a stale key is replaced', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ one: ['publisher-one'], two: ['publisher-two'] });
+    const stale = service.own(slot, 'one', 'old-one', 'old-owner', targeting);
+    const sibling = service.own(slot, 'two', 'trusted-two', 'sibling-owner', targeting);
+    targeting.setTargeting('one', 'publisher-race');
+
+    const current = service.own(slot, 'one', 'new-one', 'new-owner', targeting);
+    expect(service.snapshotForTest()).toEqual({ frames: 2, slots: 1 });
+    stale?.release();
+    current?.release();
+    sibling?.release();
+
+    expect(targeting.values.get('one')).toEqual(['publisher-race']);
+    expect(targeting.values.get('two')).toEqual(['publisher-two']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('rolls back publication when setTargeting throws and contains cleanup failures', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    targeting.setTargeting.mockImplementationOnce(() => {
+      throw new Error('set failed');
+    });
+
+    expect(() => service.own(slot, 'key', 'ts', 'owner', targeting)).toThrow('set failed');
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+
+    const frame = service.own(slot, 'key', 'ts', 'owner', targeting);
+    targeting.setTargeting.mockImplementationOnce(() => {
+      throw new Error('restore failed');
+    });
+    expect(() => frame?.release()).not.toThrow();
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    service.disposeOwner('owner');
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('uses the real adapter to invalidate before publisher set, per-key clear, and clear-all', async () => {
+    const values = new Map<string, readonly string[]>([['key', ['publisher']]]);
+    const slot = {
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      }),
+      getTargeting: vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])])),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      }),
+    };
+    const serviceObject = {
+      addEventListener: vi.fn(),
+      getSlots: () => [slot],
+      refresh: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    const googletag = {
+      apiReady: true,
+      cmd: { push: (command: () => void) => command() },
+      display: vi.fn(),
+      pubads: () => serviceObject,
+      pubadsReady: true,
+    };
+    const adapter = createBrowserGoogletagAdapter({ googletag });
+    const service = createTargetingService();
+    const observation = service.observePublisherMutations(slot, adapter);
+    await expect(observation.result).resolves.toBeUndefined();
+    const write = adapter.run((gpt) =>
+      service.own(slot, 'key', 'trusted', 'owner', {
+        clearTargeting: (key) => gpt.clearTargeting(slot, key),
+        getTargeting: (key) => gpt.getTargeting(slot, key),
+        setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+      })
+    );
+    const frame = await write.result;
+    expect(values.get('key')).toEqual(['trusted']);
+
+    slot.setTargeting('key', 'publisher-new');
+    frame?.release();
+    expect(values.get('key')).toEqual(['publisher-new']);
+
+    const perKey = await adapter.run((gpt) =>
+      service.own(slot, 'key', 'trusted-two', 'owner-two', {
+        clearTargeting: (key) => gpt.clearTargeting(slot, key),
+        getTargeting: (key) => gpt.getTargeting(slot, key),
+        setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+      })
+    ).result;
+    slot.clearTargeting('key');
+    perKey?.release();
+    expect(values.get('key')).toBeUndefined();
+
+    values.set('key', ['publisher-three']);
+    const clearAll = await adapter.run((gpt) =>
+      service.own(slot, 'key', 'trusted-three', 'owner-three', {
+        clearTargeting: (key) => gpt.clearTargeting(slot, key),
+        getTargeting: (key) => gpt.getTargeting(slot, key),
+        setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+      })
+    ).result;
+    slot.clearTargeting();
+    clearAll?.release();
+    expect(values.size).toBe(0);
+  });
+
+  it('invalidates a TS journal when its captured native setter reenters a same-value publisher set', async () => {
+    const values = new Map<string, readonly string[]>([['key', ['publisher']]]);
+    let reentered = false;
+    const slot = {
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      }),
+      getTargeting: vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])])),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+        if (reentered) return;
+        reentered = true;
+        slot.setTargeting(key, value);
+      }),
+    };
+    const adapter = adapterForTargetingSlot(slot);
+    const service = createTargetingService();
+    await expect(service.observePublisherMutations(slot, adapter).result).resolves.toBeUndefined();
+
+    const frame = await adapter.run((gpt) =>
+      service.own(slot, 'key', 'trusted', 'owner', {
+        clearTargeting: (key) => gpt.clearTargeting(slot, key),
+        getTargeting: (key) => gpt.getTargeting(slot, key),
+        setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+      })
+    ).result;
+    frame?.release();
+
+    expect(values.get('key')).toEqual(['trusted']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it.each(['same_set', 'different_set', 'per_key_clear', 'clear_all'] as const)(
+    'invalidates after publisher wrapper replacement for %s without calling that replacement on release',
+    async (mutation) => {
+      const values = new Map<string, readonly string[]>([
+        ['key', ['publisher']],
+        ['sibling', ['publisher-sibling']],
+      ]);
+      const slot = {
+        clearTargeting: vi.fn((key?: string) => {
+          if (key === undefined) values.clear();
+          else values.delete(key);
+        }),
+        getTargeting: vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])])),
+        setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+          values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+        }),
+      };
+      const adapter = adapterForTargetingSlot(slot);
+      const service = createTargetingService();
+      await expect(
+        service.observePublisherMutations(slot, adapter).result
+      ).resolves.toBeUndefined();
+      const frame = await adapter.run((gpt) =>
+        service.own(slot, 'key', 'trusted', 'owner', {
+          clearTargeting: (key) => gpt.clearTargeting(slot, key),
+          getTargeting: (key) => gpt.getTargeting(slot, key),
+          setTargeting: (key, value) => gpt.setTargeting(slot, key, value),
+        })
+      ).result;
+
+      const publisherSet = vi.fn((key: string, value: string | readonly string[]) => {
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      });
+      const publisherClear = vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      });
+      if (mutation === 'same_set' || mutation === 'different_set') {
+        slot.setTargeting = publisherSet;
+        slot.setTargeting('key', mutation === 'same_set' ? 'trusted' : 'publisher-new');
+      } else {
+        slot.clearTargeting = publisherClear;
+        slot.clearTargeting(mutation === 'per_key_clear' ? 'key' : undefined);
+      }
+
+      frame?.release();
+
+      expect(publisherSet).toHaveBeenCalledTimes(
+        mutation === 'same_set' || mutation === 'different_set' ? 1 : 0
+      );
+      expect(publisherClear).toHaveBeenCalledTimes(
+        mutation === 'per_key_clear' || mutation === 'clear_all' ? 1 : 0
+      );
+      if (mutation === 'same_set') expect(values.get('key')).toEqual(['trusted']);
+      else if (mutation === 'different_set') expect(values.get('key')).toEqual(['publisher-new']);
+      else expect(values.get('key')).toBeUndefined();
+      if (mutation === 'clear_all') expect(values.size).toBe(0);
+      expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+    }
+  );
+
+  it('invalidates when a targeting read replaces an observed wrapper during release', async () => {
+    const values = new Map<string, readonly string[]>([['key', ['publisher']]]);
+    const publisherReplacement = vi.fn((key: string, value: string | readonly string[]): void => {
+      values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+    });
+    const slot = {
+      clearTargeting: vi.fn((key?: string) => {
+        if (key === undefined) values.clear();
+        else values.delete(key);
+      }),
+      getTargeting: vi.fn((key: string) => Object.freeze([...(values.get(key) ?? [])])),
+      setTargeting: vi.fn((key: string, value: string | readonly string[]) => {
+        values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      }),
+    };
+    const adapter = adapterForTargetingSlot(slot);
+    const service = createTargetingService();
+    await expect(service.observePublisherMutations(slot, adapter).result).resolves.toBeUndefined();
+    const frame = service.own(slot, 'key', 'trusted', 'owner', {
+      clearTargeting: (key) => {
+        adapter.run((gpt) => gpt.clearTargeting(slot, key));
+      },
+      getTargeting: (key) => {
+        let current: readonly string[] = Object.freeze([]);
+        adapter.run((gpt) => {
+          current = gpt.getTargeting(slot, key);
+        });
+        return current;
+      },
+      setTargeting: (key, value) => {
+        adapter.run((gpt) => gpt.setTargeting(slot, key, value));
+      },
+    });
+    slot.getTargeting.mockImplementationOnce((key: string) => {
+      slot.setTargeting = publisherReplacement;
+      return Object.freeze([...(values.get(key) ?? [])]);
+    });
+
+    frame?.release();
+
+    expect(publisherReplacement).not.toHaveBeenCalled();
+    expect(values.get('key')).toEqual(['trusted']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+});
+
+function adapterForTargetingSlot(slot: object) {
+  const pubads = {
+    addEventListener: vi.fn(),
+    getSlots: () => [slot],
+    refresh: vi.fn(),
+    removeEventListener: vi.fn(),
+  };
+  return createBrowserGoogletagAdapter({
+    googletag: {
+      apiReady: true,
+      cmd: { push: (command: () => void) => command() },
+      display: vi.fn(),
+      pubads: () => pubads,
+      pubadsReady: true,
+    },
+  });
+}
+
+describe('adapter-owned targeting interception', () => {
+  it('suppresses TS facade writes and preserves publisher order, arguments, return, and throw', async () => {
+    const order: string[] = [];
+    const publisherError = new Error('native clear failed');
+    const setTargeting = vi.fn((key: string, value: string) => {
+      order.push(`native-set:${key}:${value}`);
+      return 'native-result';
+    });
+    const clearTargeting = vi.fn(() => {
+      order.push('native-clear');
+      throw publisherError;
+    });
+    const slot = { clearTargeting, getTargeting: () => [], setTargeting };
+    const adapter = adapterForTargetingSlot(slot);
+    const observer = vi.fn((_slot: object, key?: string) => order.push(`observer:${key ?? '*'}`));
+    const operation = adapter.run((gpt) => {
+      gpt.observeTargeting(slot, { beforePublisherMutation: observer });
+      gpt.setTargeting(slot, 'ts-key', 'ts-value');
+    });
+    await expect(operation.result).resolves.toBeUndefined();
+    expect(observer).not.toHaveBeenCalled();
+    order.length = 0;
+
+    expect(slot.setTargeting('publisher-key', 'publisher-value')).toBe('native-result');
+    expect(order).toEqual(['observer:publisher-key', 'native-set:publisher-key:publisher-value']);
+    order.length = 0;
+    expect(() => slot.clearTargeting()).toThrow(publisherError);
+    expect(order).toEqual(['observer:*', 'native-clear']);
+  });
+
+  it('uses one wrapper with independent observers and restores exactly after out-of-order release', async () => {
+    const originalSet = vi.fn();
+    const originalClear = vi.fn();
+    const slot = {
+      clearTargeting: originalClear,
+      getTargeting: () => [],
+      setTargeting: originalSet,
+    };
+    const adapter = adapterForTargetingSlot(slot);
+    const first = vi.fn();
+    const second = vi.fn();
+    const releases = await adapter.run(
+      (gpt) =>
+        [
+          gpt.observeTargeting(slot, { beforePublisherMutation: first }),
+          gpt.observeTargeting(slot, { beforePublisherMutation: second }),
+        ] as const
+    ).result;
+    const installedSet = slot.setTargeting;
+
+    slot.setTargeting('both', 'value');
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).toHaveBeenCalledOnce();
+    releases[0]();
+    expect(slot.setTargeting).toBe(installedSet);
+    slot.setTargeting('second', 'value');
+    expect(first).toHaveBeenCalledOnce();
+    expect(second).toHaveBeenCalledTimes(2);
+    releases[1]();
+
+    expect(slot.setTargeting).toBe(originalSet);
+    expect(slot.clearTargeting).toBe(originalClear);
+    slot.setTargeting('native', 'value');
+    expect(second).toHaveBeenCalledTimes(2);
+  });
+
+  it('reports wrapper replacement fail-closed and never overwrites a publisher replacement', async () => {
+    const originalSet = vi.fn();
+    const originalClear = vi.fn();
+    const replacementSet = vi.fn();
+    const target = {
+      clearTargeting: originalClear,
+      getTargeting: () => [],
+      setTargeting: originalSet,
+    };
+    let trapDescriptors = false;
+    const slot = new Proxy(target, {
+      getOwnPropertyDescriptor: (current, key) => {
+        if (trapDescriptors) throw new Error('publisher descriptor trap');
+        return Reflect.getOwnPropertyDescriptor(current, key);
+      },
+    });
+    const adapter = adapterForTargetingSlot(slot);
+    const observation = await adapter.run((gpt) =>
+      gpt.observeTargeting(slot, { beforePublisherMutation: vi.fn() })
+    ).result;
+
+    expect(observation.isCurrent()).toBe(true);
+    target.setTargeting = replacementSet;
+    expect(observation.isCurrent()).toBe(false);
+    observation();
+    expect(target.setTargeting).toBe(replacementSet);
+    expect(target.clearTargeting).toBe(originalClear);
+
+    const trapped = await adapter.run((gpt) =>
+      gpt.observeTargeting(slot, { beforePublisherMutation: vi.fn() })
+    ).result;
+    trapDescriptors = true;
+    expect(() => trapped.isCurrent()).not.toThrow();
+    expect(trapped.isCurrent()).toBe(false);
+    expect(() => trapped()).not.toThrow();
+  });
+
+  it('rolls back the first method when transactional observer installation cannot wrap the second', async () => {
+    const originalSet = vi.fn();
+    const originalClear = vi.fn();
+    const slot = { getTargeting: () => [], setTargeting: originalSet } as unknown as {
+      clearTargeting: () => void;
+      getTargeting: () => readonly string[];
+      setTargeting: (key: string, value: string) => void;
+    };
+    Object.defineProperty(slot, 'clearTargeting', {
+      configurable: false,
+      value: originalClear,
+      writable: false,
+    });
+    const adapter = adapterForTargetingSlot(slot);
+    const operation = adapter.run((gpt) =>
+      gpt.observeTargeting(slot, { beforePublisherMutation: vi.fn() })
+    );
+
+    await expect(operation.result).rejects.toMatchObject({
+      code: 'external_artifact_incompatible',
+    });
+    expect(slot.setTargeting).toBe(originalSet);
+    expect(slot.clearTargeting).toBe(originalClear);
+  });
+
+  it.each(['false', 'throw'] as const)(
+    'compare-restores setTargeting when a Proxy define trap mutates then returns %s',
+    async (failure) => {
+      const originalSet = vi.fn();
+      const originalClear = vi.fn();
+      const target = {
+        clearTargeting: originalClear,
+        getTargeting: () => [],
+        setTargeting: originalSet,
+      };
+      let attempted = false;
+      const slot = new Proxy(target, {
+        defineProperty: (current, key, descriptor) => {
+          const result = Reflect.defineProperty(current, key, descriptor);
+          if (key === 'setTargeting' && !attempted) {
+            attempted = true;
+            if (failure === 'throw') throw new Error('mutated then threw');
+            return false;
+          }
+          return result;
+        },
+      });
+      const adapter = adapterForTargetingSlot(slot);
+      const operation = adapter.run((gpt) =>
+        gpt.observeTargeting(slot, { beforePublisherMutation: vi.fn() })
+      );
+
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+      expect(target.setTargeting).toBe(originalSet);
+      expect(target.clearTargeting).toBe(originalClear);
+    }
+  );
+
+  it.each(['false', 'throw'] as const)(
+    'restores both wrappers when the clearTargeting Proxy define trap mutates then returns %s',
+    async (failure) => {
+      const originalSet = vi.fn();
+      const originalClear = vi.fn();
+      const target = {
+        clearTargeting: originalClear,
+        getTargeting: () => [],
+        setTargeting: originalSet,
+      };
+      let attempted = false;
+      const slot = new Proxy(target, {
+        defineProperty: (current, key, descriptor) => {
+          const result = Reflect.defineProperty(current, key, descriptor);
+          if (key === 'clearTargeting' && !attempted) {
+            attempted = true;
+            if (failure === 'throw') throw new Error('mutated then threw');
+            return false;
+          }
+          return result;
+        },
+      });
+      const adapter = adapterForTargetingSlot(slot);
+      const operation = adapter.run((gpt) =>
+        gpt.observeTargeting(slot, { beforePublisherMutation: vi.fn() })
+      );
+
+      await expect(operation.result).rejects.toMatchObject({
+        code: 'external_artifact_incompatible',
+      });
+      expect(target.setTargeting).toBe(originalSet);
+      expect(target.clearTargeting).toBe(originalClear);
+    }
+  );
+
+  it('lets one observation dispose its wrappers after its adapter operation settled', async () => {
+    const originalSet = vi.fn();
+    const originalClear = vi.fn();
+    const slot = {
+      clearTargeting: originalClear,
+      getTargeting: () => [],
+      setTargeting: originalSet,
+    };
+    const adapter = adapterForTargetingSlot(slot);
+    const service = createTargetingService();
+    const observation = service.observePublisherMutations(slot, adapter);
+    await expect(observation.result).resolves.toBeUndefined();
+    expect(slot.setTargeting).not.toBe(originalSet);
+
+    observation.dispose();
+
+    expect(slot.setTargeting).toBe(originalSet);
+    expect(slot.clearTargeting).toBe(originalClear);
+  });
+});
+
+describe('targeting mutate-then-throw recovery', () => {
+  it('rejects a successful no-op write and removes only its failed frame', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const older = service.own(slot, 'key', 'older', 'older-owner', targeting);
+    targeting.setTargeting.mockImplementationOnce(() => undefined);
+
+    expect(() => service.own(slot, 'key', 'newer', 'newer-owner', targeting)).toThrow(
+      'GPT targeting postcondition failed'
+    );
+    expect(targeting.values.get('key')).toEqual(['older']);
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    older?.release();
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('retains owner-disposable quarantine when a successful write leaves the wrong value', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    targeting.setTargeting.mockImplementationOnce((key) => {
+      targeting.values.set(key, Object.freeze(['wrong-value']));
+    });
+
+    expect(() => service.own(slot, 'key', 'trusted', 'owner', targeting)).toThrow(
+      'GPT targeting postcondition failed'
+    );
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    service.disposeOwner('owner');
+    expect(targeting.values.get('key')).toEqual(['wrong-value']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('restores the publisher predecessor when installation mutates then throws', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    targeting.setTargeting.mockImplementationOnce((key, value) => {
+      targeting.values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      throw new Error('mutated then threw');
+    });
+
+    expect(() => service.own(slot, 'key', 'trusted', 'owner', targeting)).toThrow(
+      'mutated then threw'
+    );
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('retains owner-disposable quarantine when failed restoration did not mutate', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const frame = service.own(slot, 'key', 'trusted', 'owner', targeting);
+    targeting.setTargeting.mockImplementationOnce(() => {
+      throw new Error('failed before mutation');
+    });
+
+    frame?.release();
+
+    expect(targeting.values.get('key')).toEqual(['trusted']);
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    service.disposeOwner('owner');
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('removes ownership when restoration mutates to the predecessor and then throws', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const frame = service.own(slot, 'key', 'trusted', 'owner', targeting);
+    targeting.setTargeting.mockImplementationOnce((key, value) => {
+      targeting.values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      throw new Error('mutated then threw');
+    });
+
+    frame?.release();
+
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('retains an owner-disposable frame when post-failure state cannot be read', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    targeting.setTargeting.mockImplementationOnce((key, value) => {
+      targeting.values.set(key, Object.freeze(typeof value === 'string' ? [value] : [...value]));
+      throw new Error('mutated then threw');
+    });
+    targeting.getTargeting
+      .mockImplementationOnce(() => ['publisher'])
+      .mockImplementationOnce(() => {
+        throw new Error('unreadable after failure');
+      });
+
+    expect(() => service.own(slot, 'key', 'trusted', 'owner', targeting)).toThrow(
+      'mutated then threw'
+    );
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    targeting.getTargeting.mockImplementation((key: string) =>
+      Object.freeze([...(targeting.values.get(key) ?? [])])
+    );
+    service.disposeOwner('owner');
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('retains owner-disposable quarantine when failed installation leaves unknown state', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    targeting.setTargeting.mockImplementationOnce((key) => {
+      targeting.values.set(key, Object.freeze(['publisher-interference']));
+      throw new Error('mutated unpredictably then threw');
+    });
+
+    expect(() => service.own(slot, 'key', 'trusted', 'owner', targeting)).toThrow(
+      'mutated unpredictably then threw'
+    );
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    service.disposeOwner('owner');
+    expect(targeting.values.get('key')).toEqual(['publisher-interference']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('rolls back only a newer failed publication when the older TS value never changed', () => {
+    const service = createTargetingService();
+    const slot = {};
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    const older = service.own(slot, 'key', 'older', 'older-owner', targeting);
+    targeting.setTargeting.mockImplementationOnce(() => {
+      throw new Error('newer failed before mutation');
+    });
+
+    expect(() => service.own(slot, 'key', 'newer', 'newer-owner', targeting)).toThrow(
+      'newer failed before mutation'
+    );
+    expect(targeting.values.get('key')).toEqual(['older']);
+    expect(service.snapshotForTest()).toEqual({ frames: 1, slots: 1 });
+    older?.release();
+    expect(targeting.values.get('key')).toEqual(['publisher']);
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+
+  it('releases service observation ownership when adapter promotion rejects', async () => {
+    const externalRelease = vi.fn();
+    const facade = {
+      observeTargeting: () => externalRelease,
+    } as never;
+    const adapter = {
+      run: (command: (gpt: never) => void) => {
+        command(facade);
+        return Object.freeze({
+          status: 'incompatible' as const,
+          result: Promise.reject(new Error('promotion rejected')),
+          dispose: vi.fn(),
+        });
+      },
+    } as never;
+    const service = createTargetingService();
+    const observation = service.observePublisherMutations({}, adapter);
+
+    await expect(observation.result).rejects.toThrow('promotion rejected');
+    expect(externalRelease).toHaveBeenCalledOnce();
+    service.dispose();
+    expect(externalRelease).toHaveBeenCalledOnce();
+  });
+
+  it('disposes frames through captured Set iterator next after prototype poisoning', () => {
+    const service = createTargetingService();
+    const targeting = createTargetingHarness({ key: ['publisher'] });
+    service.own({}, 'key', 'trusted', 'owner', targeting);
+    const iteratorPrototype = Object.getPrototypeOf(new Set().values()) as {
+      next: () => IteratorResult<unknown>;
+    };
+    const originalNext = iteratorPrototype.next;
+    iteratorPrototype.next = () => {
+      throw new Error('poisoned iterator');
+    };
+    try {
+      expect(() => service.disposeOwner('owner')).not.toThrow();
+    } finally {
+      iteratorPrototype.next = originalNext;
+    }
+    expect(service.snapshotForTest()).toEqual({ frames: 0, slots: 0 });
+  });
+});
diff --git a/crates/trusted-server-js/lib/test/shared/beacon_guard.test.ts b/crates/trusted-server-js/lib/test/shared/beacon_guard.test.ts
index 881a4515f..92f4d0593 100644
--- a/crates/trusted-server-js/lib/test/shared/beacon_guard.test.ts
+++ b/crates/trusted-server-js/lib/test/shared/beacon_guard.test.ts
@@ -1,37 +1,61 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 
-import { createBeaconGuard, BeaconGuardConfig } from '../../src/shared/beacon_guard';
+import { createBeaconGuard } from '../../src/shared/beacon_guard';
+import type { BeaconGuardConfig } from '../../src/shared/beacon_guard';
+
+function hasHttpHostname(url: string, hostname: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return (
+      (parsed.protocol === 'https:' || parsed.protocol === 'http:') && parsed.hostname === hostname
+    );
+  } catch {
+    return false;
+  }
+}
+
+function rewriteToProxy(url: string, proxyPath: string): string {
+  const parsed = new URL(url);
+  return `http://localhost${proxyPath}${parsed.pathname}${parsed.search}${parsed.hash}`;
+}
 
 describe('Beacon Guard', () => {
-  let originalSendBeacon: typeof navigator.sendBeacon;
-  let originalFetch: typeof window.fetch;
+  let originalSendBeaconDescriptor: PropertyDescriptor | undefined;
+  let originalFetchDescriptor: PropertyDescriptor | undefined;
   let sendBeaconSpy: ReturnType<typeof vi.fn>;
   let fetchSpy: ReturnType<typeof vi.fn>;
   let config: BeaconGuardConfig;
 
   beforeEach(() => {
     // Save originals
-    originalSendBeacon = navigator.sendBeacon;
-    originalFetch = window.fetch;
+    originalSendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    originalFetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
 
     // Create spies that simulate real sendBeacon/fetch behaviour
     sendBeaconSpy = vi.fn(() => true);
-    navigator.sendBeacon = sendBeaconSpy;
+    navigator.sendBeacon = sendBeaconSpy as typeof navigator.sendBeacon;
 
     fetchSpy = vi.fn(() => Promise.resolve(new Response('', { status: 200 })));
-    window.fetch = fetchSpy;
+    window.fetch = fetchSpy as typeof window.fetch;
 
     config = {
       name: 'Test',
-      isTargetUrl: (url: string) => url.includes('analytics.example.com'),
-      rewriteUrl: (url: string) =>
-        url.replace(/https?:\/\/analytics\.example\.com/, 'http://localhost/proxy'),
+      isTargetUrl: (url: string) => hasHttpHostname(url, 'analytics.example.com'),
+      rewriteUrl: (url: string) => rewriteToProxy(url, '/proxy'),
     };
   });
 
   afterEach(() => {
-    navigator.sendBeacon = originalSendBeacon;
-    window.fetch = originalFetch;
+    if (originalSendBeaconDescriptor) {
+      Object.defineProperty(navigator, 'sendBeacon', originalSendBeaconDescriptor);
+    } else {
+      Reflect.deleteProperty(navigator, 'sendBeacon');
+    }
+    if (originalFetchDescriptor) {
+      Object.defineProperty(window, 'fetch', originalFetchDescriptor);
+    } else {
+      Reflect.deleteProperty(window, 'fetch');
+    }
   });
 
   describe('createBeaconGuard', () => {
@@ -82,6 +106,18 @@ describe('Beacon Guard', () => {
       expect(sendBeaconSpy).toHaveBeenCalledWith('https://other.example.com/track', 'data');
     });
 
+    it.each([
+      'https://analytics.example.com.evil.test/collect',
+      'https://analytics.example.com@evil.test/collect',
+    ])('should pass through an analytics hostname lookalike: %s', (url) => {
+      const guard = createBeaconGuard(config);
+      guard.install();
+
+      navigator.sendBeacon(url, 'data');
+
+      expect(sendBeaconSpy).toHaveBeenCalledWith(url, 'data');
+    });
+
     it('should forward body data', () => {
       const guard = createBeaconGuard(config);
       guard.install();
@@ -130,7 +166,7 @@ describe('Beacon Guard', () => {
       await window.fetch(request);
 
       // The spy should receive a new Request with the rewritten URL
-      const calledArg = fetchSpy.mock.calls[0][0];
+      const calledArg = fetchSpy.mock.calls[0]![0] as Request;
       expect(calledArg).toBeInstanceOf(Request);
       expect(calledArg.url).toContain('/proxy/g/collect?tid=G-TEST');
     });
@@ -146,12 +182,177 @@ describe('Beacon Guard', () => {
     });
   });
 
+  it('restores the exact publisher-owned descriptors on reset', () => {
+    const sendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const guard = createBeaconGuard(config);
+
+    guard.install();
+    guard.reset();
+
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconDescriptor);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchDescriptor);
+  });
+
+  it.each(['sendBeacon', 'fetch'] as const)(
+    'leaves a publisher %s replacement intact while releasing the other wrapper',
+    (replaced) => {
+      const sendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+      const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+      const guard = createBeaconGuard(config);
+      guard.install();
+      const replacementSendBeacon = vi.fn(() => false) as typeof navigator.sendBeacon;
+      const replacementFetch = vi.fn(() => Promise.resolve(new Response())) as typeof window.fetch;
+      if (replaced === 'sendBeacon') navigator.sendBeacon = replacementSendBeacon;
+      else window.fetch = replacementFetch;
+
+      guard.reset();
+
+      if (replaced === 'sendBeacon') {
+        expect(navigator.sendBeacon).toBe(replacementSendBeacon);
+        expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchDescriptor);
+      } else {
+        expect(window.fetch).toBe(replacementFetch);
+        expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(
+          sendBeaconDescriptor
+        );
+      }
+    }
+  );
+
+  it('leaves descriptor-attribute changes to the installed wrappers intact', () => {
+    const guard = createBeaconGuard(config);
+    guard.install();
+    const installedSendBeacon = navigator.sendBeacon;
+    const installedFetch = window.fetch;
+    const sendBeaconReplacement = {
+      configurable: true,
+      enumerable: false,
+      value: installedSendBeacon,
+      writable: true,
+    } satisfies PropertyDescriptor;
+    const fetchReplacement = {
+      configurable: true,
+      enumerable: false,
+      value: installedFetch,
+      writable: true,
+    } satisfies PropertyDescriptor;
+    Object.defineProperty(navigator, 'sendBeacon', sendBeaconReplacement);
+    Object.defineProperty(window, 'fetch', fetchReplacement);
+
+    guard.reset();
+
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconReplacement);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchReplacement);
+  });
+
+  it('does not invoke or replace hostile publisher accessors during reset', () => {
+    const guard = createBeaconGuard(config);
+    guard.install();
+    const sendBeaconGetter = vi.fn(() => {
+      throw new Error('sendBeacon getter must remain inert');
+    });
+    const fetchGetter = vi.fn(() => {
+      throw new Error('fetch getter must remain inert');
+    });
+    const sendBeaconReplacement = {
+      configurable: true,
+      enumerable: true,
+      get: sendBeaconGetter,
+    } satisfies PropertyDescriptor;
+    const fetchReplacement = {
+      configurable: true,
+      enumerable: true,
+      get: fetchGetter,
+    } satisfies PropertyDescriptor;
+    Object.defineProperty(navigator, 'sendBeacon', sendBeaconReplacement);
+    Object.defineProperty(window, 'fetch', fetchReplacement);
+
+    expect(() => guard.reset()).not.toThrow();
+
+    expect(sendBeaconGetter).not.toHaveBeenCalled();
+    expect(fetchGetter).not.toHaveBeenCalled();
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconReplacement);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchReplacement);
+  });
+
+  it('isolates hostile descriptor inspection and still releases the other wrapper', () => {
+    const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const guard = createBeaconGuard(config);
+    guard.install();
+    const installedSendBeacon = navigator.sendBeacon;
+    const nativeDescriptor = Object.getOwnPropertyDescriptor;
+    const descriptor = vi
+      .spyOn(Object, 'getOwnPropertyDescriptor')
+      .mockImplementation((target, property) => {
+        if (target === navigator && property === 'sendBeacon') {
+          throw new Error('publisher descriptor inspection failed');
+        }
+        return nativeDescriptor(target, property);
+      });
+
+    expect(() => guard.reset()).not.toThrow();
+    descriptor.mockRestore();
+
+    expect(navigator.sendBeacon).toBe(installedSendBeacon);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchDescriptor);
+  });
+
+  it('releases an installed wrapper after a later patch assignment fails', () => {
+    const sendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    if (!fetchDescriptor || !('value' in fetchDescriptor)) {
+      throw new Error('test requires an own fetch data descriptor');
+    }
+    const nonWritableFetchDescriptor = {
+      ...fetchDescriptor,
+      writable: false,
+    } satisfies PropertyDescriptor;
+    Object.defineProperty(window, 'fetch', nonWritableFetchDescriptor);
+    const guard = createBeaconGuard(config);
+
+    expect(() => guard.install()).toThrow(TypeError);
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).not.toEqual(
+      sendBeaconDescriptor
+    );
+
+    expect(() => guard.reset()).not.toThrow();
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconDescriptor);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(nonWritableFetchDescriptor);
+  });
+
+  it('restores stacked guards in reverse order and remains idempotent', () => {
+    const sendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    const first = createBeaconGuard(config);
+    const second = createBeaconGuard({
+      ...config,
+      name: 'Second',
+    });
+    first.install();
+    const firstSendBeaconDescriptor = Object.getOwnPropertyDescriptor(navigator, 'sendBeacon');
+    const firstFetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
+    second.install();
+
+    second.reset();
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(
+      firstSendBeaconDescriptor
+    );
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(firstFetchDescriptor);
+
+    first.reset();
+    first.reset();
+    second.reset();
+    expect(Object.getOwnPropertyDescriptor(navigator, 'sendBeacon')).toEqual(sendBeaconDescriptor);
+    expect(Object.getOwnPropertyDescriptor(window, 'fetch')).toEqual(fetchDescriptor);
+  });
+
   describe('multiple guards', () => {
     it('should allow independent guards to coexist', () => {
       const config2: BeaconGuardConfig = {
         name: 'Other',
-        isTargetUrl: (url: string) => url.includes('other-tracker.com'),
-        rewriteUrl: (url: string) => url.replace(/https?:\/\/other-tracker\.com/, '/other-proxy'),
+        isTargetUrl: (url: string) => hasHttpHostname(url, 'other-tracker.com'),
+        rewriteUrl: (url: string) => rewriteToProxy(url, '/other-proxy'),
       };
 
       const guard1 = createBeaconGuard(config);
@@ -160,8 +361,12 @@ describe('Beacon Guard', () => {
       guard1.install();
       guard2.install();
 
+      const lookalikeUrl = 'https://other-tracker.com.evil.test/collect';
+      navigator.sendBeacon(lookalikeUrl, 'data');
+
       expect(guard1.isInstalled()).toBe(true);
       expect(guard2.isInstalled()).toBe(true);
+      expect(sendBeaconSpy).toHaveBeenCalledWith(lookalikeUrl, 'data');
     });
   });
 });
diff --git a/crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts b/crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts
index 84cf21ae3..a2a17ebfd 100644
--- a/crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts
+++ b/crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts
@@ -82,6 +82,11 @@ describe('DOM insertion dispatcher', () => {
     container.appendChild(permutiveScript);
     expect(permutiveScript.src).toContain('/integrations/permutive/sdk');
 
+    const permutiveLookalike = document.createElement('script');
+    permutiveLookalike.src = 'https://cdn.permutive.com.attacker.example/abc123-web.js';
+    container.appendChild(permutiveLookalike);
+    expect(permutiveLookalike.src).toBe('https://cdn.permutive.com.attacker.example/abc123-web.js');
+
     const dataDomeScript = document.createElement('script');
     dataDomeScript.src = 'https://js.datadome.co/tags.js';
     container.appendChild(dataDomeScript);
diff --git a/crates/trusted-server-js/lib/test/shared/origin.test.ts b/crates/trusted-server-js/lib/test/shared/origin.test.ts
index 9b0963398..b5951c973 100644
--- a/crates/trusted-server-js/lib/test/shared/origin.test.ts
+++ b/crates/trusted-server-js/lib/test/shared/origin.test.ts
@@ -1,36 +1,39 @@
 import { describe, expect, it } from 'vitest';
 
-import { normalizeTrustedOrigin } from '../../src/shared/origin';
+import { trustedDocumentHttpOrigin, trustedHttpOrigin } from '../../src/shared/origin';
 
-describe('shared/origin.ts', () => {
-  it('accepts ordinary http(s) origins', () => {
-    expect(normalizeTrustedOrigin('https://news.publisher.example')).toBe(
-      'https://news.publisher.example'
+describe('trustedHttpOrigin', () => {
+  it('derives the exact publisher origin from a stamped or inherited base URL', () => {
+    expect(trustedHttpOrigin('https://publisher.example')).toBe('https://publisher.example');
+    expect(trustedHttpOrigin('http://publisher.example:8080/path/index.html')).toBe(
+      'http://publisher.example:8080'
     );
-    expect(normalizeTrustedOrigin('http://localhost:7676')).toBe('http://localhost:7676');
   });
 
-  it('accepts IPv6 literal origins', () => {
-    // A DNS-shaped pattern rejects bracketed hosts, which would drop the stamp
-    // and push the opaque-origin runtime onto the <base>-sensitive baseURI.
-    expect(normalizeTrustedOrigin('http://[::1]:7676')).toBe('http://[::1]:7676');
-    expect(normalizeTrustedOrigin('https://[2001:db8::1]')).toBe('https://[2001:db8::1]');
+  it.each([
+    '',
+    'about:srcdoc',
+    'data:text/html,creative',
+    'javascript:alert(1)',
+    'https://user:password@publisher.example/path',
+  ])('fails closed for an unusable trusted base URL: %s', (candidate) => {
+    expect(trustedHttpOrigin(candidate)).toBe('');
   });
+});
 
-  it('normalizes a full URL down to its origin', () => {
-    expect(normalizeTrustedOrigin('https://publisher.example/some/page?q=1#frag')).toBe(
-      'https://publisher.example'
-    );
+describe('trustedDocumentHttpOrigin', () => {
+  it('keeps a real document origin authoritative over a creative-only stamp', () => {
+    expect(
+      trustedDocumentHttpOrigin(
+        'https://publisher.example',
+        'https://publisher-script-spoof.example'
+      )
+    ).toBe('https://publisher.example');
   });
 
-  it('rejects opaque, non-http(s), and unparseable values', () => {
-    expect(normalizeTrustedOrigin('null')).toBe('');
-    expect(normalizeTrustedOrigin('about:srcdoc')).toBe('');
-    expect(normalizeTrustedOrigin('javascript:alert(1)')).toBe('');
-    expect(normalizeTrustedOrigin('data:text/html,x')).toBe('');
-    expect(normalizeTrustedOrigin('/first-party/proxy')).toBe('');
-    expect(normalizeTrustedOrigin('')).toBe('');
-    expect(normalizeTrustedOrigin(undefined)).toBe('');
-    expect(normalizeTrustedOrigin(42)).toBe('');
+  it('uses the stamped base only for an opaque document origin', () => {
+    expect(trustedDocumentHttpOrigin('null', 'https://publisher.example/article')).toBe(
+      'https://publisher.example'
+    );
   });
 });
diff --git a/crates/trusted-server-js/lib/test/shared/scheduler.test.ts b/crates/trusted-server-js/lib/test/shared/scheduler.test.ts
index aa4a21ecc..59f8a6bd9 100644
--- a/crates/trusted-server-js/lib/test/shared/scheduler.test.ts
+++ b/crates/trusted-server-js/lib/test/shared/scheduler.test.ts
@@ -42,4 +42,18 @@ describe('shared/scheduler', () => {
     await Promise.resolve();
     expect(perform).toHaveBeenCalledTimes(2);
   });
+
+  it('cancels queued and future work after disposal', async () => {
+    const perform = vi.fn();
+    const schedule = createMutationScheduler(perform);
+    const el = document.createElement('div');
+
+    schedule(el);
+    schedule.dispose();
+    await Promise.resolve();
+    schedule(el);
+    await Promise.resolve();
+
+    expect(perform).not.toHaveBeenCalled();
+  });
 });
diff --git a/crates/trusted-server-js/lib/test/shared/script_guard.test.ts b/crates/trusted-server-js/lib/test/shared/script_guard.test.ts
new file mode 100644
index 000000000..15a2771c0
--- /dev/null
+++ b/crates/trusted-server-js/lib/test/shared/script_guard.test.ts
@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createScriptGuard } from '../../src/shared/script_guard';
+
+describe('shared layered script guard', () => {
+  const guards: Array<{ reset(): void }> = [];
+
+  afterEach(() => {
+    for (let index = guards.length - 1; index >= 0; index -= 1) guards[index]?.reset();
+    guards.length = 0;
+  });
+
+  it('owns document-write rewriting and restores the exact native method', () => {
+    const nativeWrite = vi.fn<(...args: string[]) => void>();
+    document.write = nativeWrite as unknown as typeof document.write;
+    const guard = createScriptGuard({
+      deepInterception: { documentWriteUrlHint: 'sdk.example' },
+      id: 'shared-layered-test',
+      isTargetUrl: (url) => new URL(url, window.location.href).hostname === 'sdk.example',
+      rewriteUrl: (url) => {
+        const parsed = new URL(url, window.location.href);
+        return `${window.location.origin}/proxy${parsed.pathname}`;
+      },
+    });
+    guards.push(guard);
+
+    guard.install();
+    const installedWrite = document.write;
+    document.write('<script src="https://sdk.example/runtime.js"></script>');
+
+    expect(nativeWrite).toHaveBeenCalledTimes(1);
+    expect(nativeWrite.mock.calls[0]?.[0]).toContain('/proxy/runtime.js');
+
+    guard.reset();
+    expect(document.write).toBe(nativeWrite);
+    expect(installedWrite).not.toBe(nativeWrite);
+  });
+
+  it('removes fallback instance src descriptors during reset', () => {
+    const nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    const descriptorSpy = vi
+      .spyOn(Object, 'getOwnPropertyDescriptor')
+      .mockImplementation(
+        (target: object, property: PropertyKey): PropertyDescriptor | undefined => {
+          if (target === HTMLScriptElement.prototype && property === 'src') return undefined;
+          return nativeGetOwnPropertyDescriptor(target, property);
+        }
+      );
+    const guard = createScriptGuard({
+      deepInterception: { documentWriteUrlHint: 'sdk.example' },
+      id: 'shared-layered-instance-test',
+      isTargetUrl: (url) => new URL(url, window.location.href).hostname === 'sdk.example',
+      rewriteUrl: (url) => {
+        const parsed = new URL(url, window.location.href);
+        return `${window.location.origin}/proxy${parsed.pathname}`;
+      },
+    });
+    guards.push(guard);
+
+    try {
+      guard.install();
+      const script = document.createElement('script');
+      script.src = 'https://sdk.example/first.js';
+      expect(script.src).toContain('/proxy/first.js');
+
+      guard.reset();
+      script.src = 'https://sdk.example/after-reset.js';
+      expect(script.src).toBe('https://sdk.example/after-reset.js');
+    } finally {
+      descriptorSpy.mockRestore();
+    }
+  });
+});
diff --git a/crates/trusted-server-js/lib/tsconfig.json b/crates/trusted-server-js/lib/tsconfig.json
index b17377a14..4c2fed413 100644
--- a/crates/trusted-server-js/lib/tsconfig.json
+++ b/crates/trusted-server-js/lib/tsconfig.json
@@ -1,16 +1,21 @@
 {
   "compilerOptions": {
     "target": "ES2018",
-    "lib": ["ES2020", "DOM"],
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
     "module": "ESNext",
     "moduleResolution": "Bundler",
     "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "verbatimModuleSyntax": true,
+    "noImplicitOverride": true,
+    "useUnknownInCatchVariables": true,
     "skipLibCheck": true,
     "noEmit": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
-    "types": ["vitest/globals", "node"]
+    "types": ["vitest/globals", "node", "vite/client"]
   },
   "include": ["src", "test"]
 }
diff --git a/crates/trusted-server-js/lib/vite.config.ts b/crates/trusted-server-js/lib/vite.config.ts
index a28bcc092..9ed8544ee 100644
--- a/crates/trusted-server-js/lib/vite.config.ts
+++ b/crates/trusted-server-js/lib/vite.config.ts
@@ -2,4 +2,8 @@ import { defineConfig } from 'vite';
 
 // Build configuration has moved to build-all.mjs.
 // This file is retained for vitest, which uses it for test resolution.
-export default defineConfig({});
+export default defineConfig({
+  define: {
+    __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__: JSON.stringify(20),
+  },
+});
diff --git a/crates/trusted-server-js/lib/vitest.config.ts b/crates/trusted-server-js/lib/vitest.config.ts
index acb591cdc..8bea63182 100644
--- a/crates/trusted-server-js/lib/vitest.config.ts
+++ b/crates/trusted-server-js/lib/vitest.config.ts
@@ -1,19 +1,38 @@
 import path from 'node:path';
 
-import { defineConfig } from 'vitest/config';
+import { configDefaults, defineConfig } from 'vitest/config';
+
+import { RELEASE_CATALOG } from './src/kernel/release_catalog.ts';
+
+const integrationIds = RELEASE_CATALOG.map(({ id }) => id);
 
 export default defineConfig({
+  define: {
+    __TSJS_EMBEDDED_RELEASE_ID_V1__: JSON.stringify('a'.repeat(64)),
+    __TSJS_EMBEDDED_INTEGRATION_IDS_V1__: JSON.stringify(integrationIds),
+    __TSJS_EMBEDDED_MAX_MANIFEST_MODULES_V1__: JSON.stringify(integrationIds.length),
+    __TSJS_EMBEDDED_RUNTIME_CATALOG_V1__: JSON.stringify(
+      RELEASE_CATALOG.map(({ id, phase, trigger, config, consumes, provides }) => ({
+        id,
+        phase,
+        trigger,
+        config,
+        consumes,
+        provides,
+      }))
+    ),
+  },
   resolve: {
     alias: {
       // prebid.js doesn't expose src/adapterManager.js via its package
       // "exports" map, but we need it for client-side bidder validation.
       // Map the specifier to the actual dist file.
       'prebid.js/src/adapterManager.js': path.resolve(
-        __dirname,
+        import.meta.dirname,
         'node_modules/prebid.js/dist/src/src/adapterManager.js'
       ),
       'prebid.js/src/adRendering.js': path.resolve(
-        __dirname,
+        import.meta.dirname,
         'node_modules/prebid.js/dist/src/src/adRendering.js'
       ),
     },
@@ -21,11 +40,19 @@ export default defineConfig({
   test: {
     environment: 'jsdom',
     globals: true,
-    // Run tests in the main thread to avoid spawning
-    // child processes/workers, which are blocked in this sandbox.
-    threads: false,
-    // Explicitly use thread pool (no forks) when workers are enabled.
-    // Kept for clarity if threads are re-enabled later.
+    // These suites deliberately use node:test. CI invokes them through their
+    // package scripts; importing them through Vitest either rewrites the VM
+    // contract fixture or leaves Vitest with no registered suite.
+    exclude: [
+      ...configDefaults.exclude,
+      'test/contract/aps-renderer-es5.test.mjs',
+      'test/eslint/no-adtech-globals.test.mjs',
+      'test/build/*.test.mjs',
+    ],
+    // Bound JSDOM concurrency so the package-wide suite does not starve its
+    // five-second lifecycle assertions while retaining per-file isolation.
+    maxWorkers: 2,
+    // Use worker threads rather than child processes.
     pool: 'threads',
     setupFiles: [],
     // The GPT diagnostics export contract is expressed as `expectTypeOf`
diff --git a/crates/trusted-server-js/src/bundle.rs b/crates/trusted-server-js/src/bundle.rs
index be5aa35cc..0a742be0d 100644
--- a/crates/trusted-server-js/src/bundle.rs
+++ b/crates/trusted-server-js/src/bundle.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use hex::encode;
@@ -6,6 +6,73 @@ use sha2::{Digest as _, Sha256};
 
 include!(concat!(env!("OUT_DIR"), "/tsjs_modules.rs"));
 
+/// Release artifact role recorded in the generated inventory.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum TsjsArtifactRole {
+    /// Inline minimal bootstrap controller and fallback artifact.
+    Bootstrap,
+    /// Base of the parser-blocking provisional first-display artifact.
+    FirstDisplayBase,
+    /// One closed, server-selected provisional first-display slice.
+    FirstDisplaySlice,
+    /// Sole TSJS kernel artifact.
+    Core,
+    /// Catalogued takeover or deferred integration module.
+    Integration,
+}
+
+/// Fixed catalog phase for one integration module.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum TsjsModulePhase {
+    /// Parser-blocking provisional phase, disposed or adopted after protected paint.
+    FirstDisplay,
+    /// Persistent module prepared for the atomic runtime takeover.
+    Takeover,
+    /// Authenticated module loaded only after the protected phase gate.
+    Deferred,
+}
+
+/// Immutable generated artifact metadata shared with the server.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct TsjsArtifactMetadata {
+    /// Canonical artifact identifier.
+    pub id: &'static str,
+    /// Artifact release role.
+    pub role: TsjsArtifactRole,
+    /// Catalog phase for integration artifacts.
+    pub phase: Option<TsjsModulePhase>,
+    /// Fixed deferred trigger, when applicable.
+    pub trigger: Option<&'static str>,
+    /// Declared consumed capability edges.
+    pub inputs: &'static [&'static str],
+    /// Server-owned inclusion predicate from the canonical catalog.
+    pub include: Option<&'static str>,
+    /// Declared provided capability keys.
+    pub outputs: &'static [&'static str],
+    /// Generated artifact filename.
+    pub file: &'static str,
+    /// SHA-256 over exact uncompressed response bytes.
+    pub hash: &'static str,
+}
+
+/// Maximum catalogued takeover modules.
+pub const MAX_TAKEOVER_MODULES: usize = GENERATED_MAX_TAKEOVER_MODULES;
+/// Maximum integrations in one boot manifest.
+pub const MAX_MANIFEST_MODULES: usize = GENERATED_MAX_MANIFEST_MODULES;
+/// Return the sentinel-normalized release identifier shared by every bundle.
+#[must_use]
+#[inline]
+pub const fn release_id() -> &'static str {
+    TSJS_RELEASE_ID
+}
+
+/// Return the generated, executable TSJS bootstrap controller.
+#[must_use]
+#[inline]
+pub const fn bootstrap_bundle() -> &'static str {
+    TSJS_BOOTSTRAP
+}
+
 /// Return the JS bundle content for a given module ID (e.g., "core", "prebid").
 #[must_use]
 #[inline]
@@ -17,7 +84,123 @@ pub fn module_bundle(id: &str) -> Option<&'static str> {
 #[must_use]
 #[inline]
 pub fn all_module_ids() -> Vec<&'static str> {
-    TSJS_MODULES.iter().map(|module| module.id).collect()
+    TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| artifact.role == "core" || artifact.role == "integration")
+        .map(|artifact| artifact.id)
+        .collect()
+}
+
+/// Return all closed first-display component IDs in canonical mask order.
+#[must_use]
+pub fn all_first_display_ids() -> Vec<&'static str> {
+    TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| {
+            artifact.role == "first_display_base" || artifact.role == "first_display_slice"
+        })
+        .map(|artifact| artifact.id)
+        .collect()
+}
+
+/// Return whether the generated release admits this exact mask under every size ceiling.
+#[must_use]
+pub fn first_display_mask_is_permitted(mask: u16) -> bool {
+    PERMITTED_FIRST_DISPLAY_MASKS.binary_search(&mask).is_ok()
+}
+
+/// Return all catalogued integration IDs in canonical phase/injection order.
+#[must_use]
+pub fn all_integration_ids() -> Vec<&'static str> {
+    TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| artifact.role == "integration")
+        .map(|artifact| artifact.id)
+        .collect()
+}
+
+/// Return generated metadata for bootstrap, core, and every catalog module.
+#[must_use]
+pub fn all_artifact_metadata() -> Vec<TsjsArtifactMetadata> {
+    TSJS_ARTIFACTS.iter().map(public_metadata).collect()
+}
+
+/// Return generated metadata for the twenty integration modules.
+#[must_use]
+pub fn all_integration_metadata() -> Vec<TsjsArtifactMetadata> {
+    TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| artifact.role == "integration")
+        .map(public_metadata)
+        .collect()
+}
+
+/// Return generated metadata for the base and thirteen first-display slices.
+#[must_use]
+pub fn all_first_display_metadata() -> Vec<TsjsArtifactMetadata> {
+    TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| {
+            artifact.role == "first_display_base" || artifact.role == "first_display_slice"
+        })
+        .map(public_metadata)
+        .collect()
+}
+
+/// Return the exact generated bytes for one closed first-display component.
+#[must_use]
+pub fn first_display_component_bundle(id: &str) -> Option<&'static str> {
+    TSJS_ARTIFACTS
+        .iter()
+        .find(|artifact| {
+            (artifact.role == "first_display_base" || artifact.role == "first_display_slice")
+                && artifact.id == id
+        })
+        .map(|artifact| artifact.bundle)
+}
+
+/// Compose selected optional first-display slices in canonical order.
+///
+/// The logical base is physically owned by the inline bootstrap. Unknown,
+/// duplicate, or explicitly supplied base IDs fail closed.
+#[must_use]
+pub fn concatenate_first_display_slices(ids: &[&str]) -> Option<String> {
+    let selected = ids.iter().copied().collect::<HashSet<_>>();
+    if selected.len() != ids.len() || selected.contains("first_display") {
+        return None;
+    }
+    if selected.iter().any(|id| {
+        !TSJS_ARTIFACTS
+            .iter()
+            .any(|artifact| artifact.role == "first_display_slice" && artifact.id == *id)
+    }) {
+        return None;
+    }
+    let parts = TSJS_ARTIFACTS
+        .iter()
+        .filter(|artifact| artifact.role == "first_display_slice" && selected.contains(artifact.id))
+        .map(|artifact| artifact.bundle)
+        .collect::<Vec<_>>();
+    Some(parts.join(";\n"))
+}
+
+/// SHA-256 of one validated, canonically ordered first-display composition.
+#[must_use]
+pub fn concatenated_first_display_hash(ids: &[&str]) -> Option<String> {
+    concatenate_first_display_slices(ids).map(|body| {
+        let mut hasher = Sha256::new();
+        hasher.update(body.as_bytes());
+        encode(hasher.finalize())
+    })
+}
+
+/// Return generated metadata for a catalogued integration module.
+#[must_use]
+pub fn integration_metadata(id: &str) -> Option<TsjsArtifactMetadata> {
+    TSJS_ARTIFACTS
+        .iter()
+        .find(|artifact| artifact.role == "integration" && artifact.id == id)
+        .map(public_metadata)
 }
 
 /// Concatenate core + the requested integration modules into a single JS string.
@@ -58,8 +241,11 @@ pub fn concatenated_hash(ids: &[&str]) -> String {
 /// Used for cache-busting URLs of deferred modules served individually.
 #[must_use]
 #[inline]
-pub fn single_module_hash(id: &str) -> Option<&'static str> {
-    module_meta_map().get(id).map(|module| module.sha256)
+pub fn single_module_hash(id: &str) -> Option<String> {
+    TSJS_ARTIFACTS
+        .iter()
+        .find(|artifact| artifact.role == "integration" && artifact.id == id)
+        .map(|artifact| artifact.hash.to_owned())
 }
 
 fn concatenated_module_ids(ids: &[&str]) -> Vec<&'static str> {
@@ -108,12 +294,14 @@ where
     }
 }
 
-fn module_meta_map() -> &'static HashMap<&'static str, &'static TsjsModuleMeta> {
-    static MAP: OnceLock<HashMap<&'static str, &'static TsjsModuleMeta>> = OnceLock::new();
+fn module_meta_map() -> &'static HashMap<&'static str, &'static TsjsGeneratedArtifactMeta> {
+    static MAP: OnceLock<HashMap<&'static str, &'static TsjsGeneratedArtifactMeta>> =
+        OnceLock::new();
     MAP.get_or_init(|| {
-        TSJS_MODULES
+        TSJS_ARTIFACTS
             .iter()
-            .map(|module| (module.id, module))
+            .filter(|artifact| artifact.role == "core" || artifact.role == "integration")
+            .map(|artifact| (artifact.id, artifact))
             .collect()
     })
 }
@@ -130,57 +318,141 @@ fn concatenated_hash_cache() -> &'static Mutex<HashMap<Vec<&'static str>, String
     CACHE.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
+fn public_metadata(artifact: &TsjsGeneratedArtifactMeta) -> TsjsArtifactMetadata {
+    TsjsArtifactMetadata {
+        id: artifact.id,
+        role: match artifact.role {
+            "bootstrap" => TsjsArtifactRole::Bootstrap,
+            "first_display_base" => TsjsArtifactRole::FirstDisplayBase,
+            "first_display_slice" => TsjsArtifactRole::FirstDisplaySlice,
+            "core" => TsjsArtifactRole::Core,
+            "integration" => TsjsArtifactRole::Integration,
+            _ => unreachable!("generated artifact role should be validated"),
+        },
+        phase: artifact.phase.map(|phase| match phase {
+            "first_display" => TsjsModulePhase::FirstDisplay,
+            "takeover" => TsjsModulePhase::Takeover,
+            "deferred" => TsjsModulePhase::Deferred,
+            _ => unreachable!("generated artifact phase should be validated"),
+        }),
+        trigger: artifact.trigger,
+        include: artifact.include,
+        inputs: artifact.inputs,
+        outputs: artifact.outputs,
+        file: artifact.file,
+        hash: artifact.hash,
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    fn sha256_hex(bytes: &[u8]) -> String {
-        encode(Sha256::digest(bytes))
+    #[test]
+    fn generated_catalog_metadata_has_exact_phase_order_and_derived_capacities() {
+        let metadata = all_integration_metadata();
+        let generated = include_str!(concat!(env!("OUT_DIR"), "/tsjs_modules.rs"));
+
+        assert_eq!(metadata.len(), 20, "should embed all catalog modules");
+        assert_eq!(MAX_TAKEOVER_MODULES, 14);
+        assert_eq!(MAX_MANIFEST_MODULES, 20);
+        assert!(
+            !generated.contains("INTERNAL_DIAGNOSTICS_SUBSCRIPTIONS"),
+            "the synchronous diagnostics ingress must not generate subscription capacity"
+        );
+        assert_eq!(metadata[0].id, "render_runtime");
+        assert_eq!(metadata[0].phase, Some(TsjsModulePhase::Takeover));
+        assert_eq!(metadata[13].id, "testlight");
+        assert_eq!(metadata[13].phase, Some(TsjsModulePhase::Takeover));
+        assert_eq!(metadata[14].id, "diagnostics_presentation");
+        assert_eq!(metadata[14].phase, Some(TsjsModulePhase::Deferred));
+        assert_eq!(metadata[19].id, "sourcepoint_lifecycle");
+        assert_eq!(metadata[19].trigger, Some("first_display_or_idle"));
+        assert_eq!(
+            metadata[0].outputs,
+            &[
+                "slots.v1",
+                "auction.v1",
+                "render.v1",
+                "messages.v1",
+                "trace.v1",
+                "trace.presentation.v1",
+                "direct.v1"
+            ]
+        );
     }
 
     #[test]
-    fn generated_single_module_hashes_match_bundle_contents() {
-        for id in all_module_ids() {
-            let bundle = module_bundle(id).expect("should have module bundle");
-            let generated_hash = single_module_hash(id).expect("should have generated hash");
+    fn generated_artifact_inventory_includes_bootstrap_core_and_catalog_once() {
+        let artifacts = all_artifact_metadata();
 
-            assert_eq!(
-                generated_hash,
-                sha256_hex(bundle.as_bytes()),
-                "generated hash for module {id} should match included bundle bytes"
-            );
-        }
+        assert_eq!(artifacts.len(), 36);
+        assert_eq!(artifacts[0].id, "bootstrap");
+        assert_eq!(artifacts[0].role, TsjsArtifactRole::Bootstrap);
+        assert_eq!(artifacts[1].id, "first_display");
+        assert_eq!(artifacts[1].role, TsjsArtifactRole::FirstDisplayBase);
+        assert!(
+            artifacts[2..15]
+                .iter()
+                .all(|artifact| artifact.role == TsjsArtifactRole::FirstDisplaySlice)
+        );
+        assert_eq!(artifacts[15].id, "core");
+        assert_eq!(artifacts[15].role, TsjsArtifactRole::Core);
+        assert!(
+            artifacts[16..]
+                .iter()
+                .all(|artifact| artifact.role == TsjsArtifactRole::Integration)
+        );
+        assert_eq!(all_module_ids().len(), 21);
+        assert_eq!(all_first_display_ids().len(), 14);
     }
 
     #[test]
-    fn concatenated_hash_matches_concatenated_bundle_contents() {
-        let available_ids = all_module_ids();
-        let non_core_ids = available_ids
-            .iter()
-            .copied()
-            .filter(|id| *id != "core")
-            .take(3)
-            .collect::<Vec<_>>();
-
-        let mut cases: Vec<Vec<&str>> = vec![Vec::new()];
-        if let Some(first) = non_core_ids.first().copied() {
-            cases.push(vec![first]);
-        }
-        if non_core_ids.len() >= 2 {
-            cases.push(non_core_ids[..2].to_vec());
-            cases.push(non_core_ids[..2].iter().rev().copied().collect());
-        }
-        if non_core_ids.len() >= 3 {
-            cases.push(non_core_ids[..3].to_vec());
-        }
+    fn first_display_composition_is_closed_and_canonical() {
+        let body = concatenate_first_display_slices(&["gpt_initial", "aps_initial"])
+            .expect("should compose known unique slices");
+        let base = first_display_component_bundle("first_display")
+            .expect("should embed first-display base");
+        let aps = first_display_component_bundle("aps_initial")
+            .expect("should embed APS first-display slice");
+        let gpt = first_display_component_bundle("gpt_initial")
+            .expect("should embed GPT first-display slice");
 
-        for ids in cases {
-            let concatenated = concatenate_modules(&ids);
+        assert_eq!(
+            body,
+            [aps, gpt].join(";\n"),
+            "should exclude the logical base marker and compose selected slices canonically"
+        );
+        assert!(!body.contains(base));
+        assert!(concatenate_first_display_slices(&["aps_initial", "aps_initial"]).is_none());
+        assert!(concatenate_first_display_slices(&["first_display"]).is_none());
+        assert!(concatenate_first_display_slices(&["unknown"]).is_none());
+    }
+
+    #[test]
+    fn generated_runtime_modules_resolve_from_artifact_metadata() {
+        for artifact in TSJS_ARTIFACTS
+            .iter()
+            .filter(|artifact| artifact.role == "core" || artifact.role == "integration")
+        {
             assert_eq!(
-                concatenated_hash(&ids),
-                sha256_hex(concatenated.as_bytes()),
-                "concatenated hash should match concatenated bundle bytes for {ids:?}"
+                module_bundle(artifact.id),
+                Some(artifact.bundle),
+                "generated module bundle should resolve for {}",
+                artifact.id
             );
         }
     }
+
+    #[test]
+    fn concatenated_hash_matches_the_generated_module_bytes() {
+        let ids = ["gpt", "prebid"];
+        let body = concatenate_modules(&ids);
+
+        assert_eq!(
+            concatenated_hash(&ids),
+            encode(Sha256::digest(body.as_bytes())),
+            "concatenated hash should cover the exact generated bytes"
+        );
+    }
 }
diff --git a/crates/trusted-server-js/src/lib.rs b/crates/trusted-server-js/src/lib.rs
index 2c816b154..a286ae4d5 100644
--- a/crates/trusted-server-js/src/lib.rs
+++ b/crates/trusted-server-js/src/lib.rs
@@ -6,5 +6,10 @@
 pub mod bundle;
 
 pub use bundle::{
-    all_module_ids, concatenate_modules, concatenated_hash, module_bundle, single_module_hash,
+    MAX_MANIFEST_MODULES, MAX_TAKEOVER_MODULES, TsjsArtifactMetadata, TsjsArtifactRole,
+    TsjsModulePhase, all_artifact_metadata, all_first_display_ids, all_first_display_metadata,
+    all_integration_ids, all_integration_metadata, all_module_ids, bootstrap_bundle,
+    concatenate_first_display_slices, concatenate_modules, concatenated_first_display_hash,
+    concatenated_hash, first_display_component_bundle, first_display_mask_is_permitted,
+    integration_metadata, module_bundle, release_id, single_module_hash,
 };
diff --git a/docs/.gitignore b/docs/.gitignore
index 57a09c39d..097c22936 100644
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -1,3 +1,4 @@
 node_modules
 .vitepress/dist
 .vitepress/cache
+.vitepress/.temp
diff --git a/docs/guide/auction-orchestration.md b/docs/guide/auction-orchestration.md
index fe2e54fdf..eca67a728 100644
--- a/docs/guide/auction-orchestration.md
+++ b/docs/guide/auction-orchestration.md
@@ -156,13 +156,8 @@ sequenceDiagram
   %% === Creative Rendering ===
   rect rgb(239,246,255)
     Note over Client,Mock: Creative Rendering
-    alt APS winner
-      Client->>Client: Validate renderer descriptor<br/>Create opaque sandbox iframe<br/>Load /integrations/aps/renderer
-      Note right of Client: Fragment-bound nonce and one-time acknowledgement<br/>No allow-same-origin on the outer frame
-    else Ordinary creative
-      Client->>Client: Inject winning creative<br/>Render iframe<br/>Load creative resources
-      Note right of Client: Default: first-party proxy/click URLs<br/>rewrite_creatives=false: accepted external URLs remain direct
-    end
+    Client->>Client: Validate renderer descriptor<br/>Create opaque sandbox iframe<br/>Load /integrations/aps/renderer/v2
+    Note right of Client: Fragment-bound nonce and one-time acknowledgement<br/>No allow-same-origin on the outer frame
     deactivate Client
   end
 ```
@@ -704,7 +699,7 @@ Each proxied URL includes a `tstoken` HMAC signature for tamper protection. See
 
 ### Full example
 
-```toml
+````toml
 [auction]
 enabled = true
 sanitize_creatives = false     # Opt-in; blanks script-based creatives when enabled
@@ -739,12 +734,61 @@ account_id = "example-aps-account"
 debug = false
 allow_script_creatives = false
 
-[integrations.aps]
-enabled = true
-rendering_mode = "trusted_server"
 
-[auction.bidders.example-server]
-provider = "pbs-main"
+### Configuration Reference
+
+#### `[auction]`
+
+| Field                | Type     | Default | Description                                                     |
+| -------------------- | -------- | ------- | --------------------------------------------------------------- |
+| `enabled`            | bool     | `false` | Enable the auction system                                       |
+| `sanitize_creatives` | bool     | `false` | Strip executable markup from winning-bid `adm` before delivery  |
+| `rewrite_creatives`  | bool     | `true`  | Rewrite winning-bid `adm` through first-party endpoints         |
+| `providers`          | string[] | `[]`    | Ordered list of provider names to call                          |
+| `mediator`           | string?  | `null`  | Provider name to use as mediator (enables `parallel_mediation`) |
+| `timeout_ms`         | u32      | `2000`  | Overall auction timeout in milliseconds                         |
+
+Both creative-processing fields must be present in the TOML for their
+environment overrides to apply; see
+[Environment Variable Overrides](#environment-variable-overrides).
+
+#### `[integrations.prebid]`
+
+| Field            | Type     | Default           | Description                                                                            |
+| ---------------- | -------- | ----------------- | -------------------------------------------------------------------------------------- |
+| `enabled`        | bool     | `true`            | Enable Prebid provider                                                                 |
+| `server_url`     | string   | —                 | Prebid Server URL (required)                                                           |
+| `timeout_ms`     | u32      | `1000`            | Request timeout                                                                        |
+| `bidders`        | string[] | `["mocktioneer"]` | Default bidders when not specified per-slot                                            |
+| `auto_configure` | bool     | `true`            | Auto-remove client-side prebid.js scripts                                              |
+| `debug`          | bool     | `false`           | Enable Prebid debug mode (sets `ext.prebid.debug` and `ext.prebid.returnallbidstatus`) |
+| `test_mode`      | bool     | `false`           | Set OpenRTB `test: 1` for non-billable test traffic                                    |
+
+#### APS provider profile
+
+APS is enabled only by an `[auction.providers.<id>]` row with
+`profile = "aps"`. Its common `endpoint` and `timeout_ms` fields belong on that
+provider row. Put `account_id`, `debug`, `inventory_domain`,
+`inventory_page_origin`, and `allow_script_creatives` under the provider's
+`profile_config` table. The compiled plan also owns browser renderer and runner
+route registration; there is no separate browser-mode switch.
+
+#### `[integrations.adserver_mock]`
+
+| Field         | Type   | Default                                  | Description               |
+| ------------- | ------ | ---------------------------------------- | ------------------------- |
+| `enabled`     | bool   | `false`                                  | Enable mediator           |
+| `endpoint`    | string | `http://localhost:6767/adserver/mediate` | Mediator service endpoint |
+| `timeout_ms`  | u32    | `500`                                    | Request timeout           |
+| `price_floor` | f64?   | `null`                                   | Global price floor CPM    |
+
+### Timeout Tuning
+
+The orchestrator timeout should exceed the sum of provider timeouts to allow all providers to respond. Providers that exceed their individual timeouts are collected as they finish — the orchestrator doesn't wait indefinitely.
+
+```toml
+[auction]
+timeout_ms = 2000              # Overall ceiling
 
 [integrations.prebid]
 enabled = true
@@ -760,7 +804,7 @@ allowed_domains = ["assets.example.com"]
 enabled = true
 endpoint = "https://mediator.example.com/mediate"
 timeout_ms = 500
-```
+````
 
 `[auction.providers]` is a map, not a provider-name list. Each provider ID owns
 endpoint/backend correlation and telemetry. `[auction.bidders]` maps each
diff --git a/docs/guide/cli.md b/docs/guide/cli.md
index 0e0ee9553..8bd721504 100644
--- a/docs/guide/cli.md
+++ b/docs/guide/cli.md
@@ -294,6 +294,7 @@ Given a site whose ad units track the section, the run produces:
 
 ```toml
 [creative_opportunities]
+enabled = true
 gam_network_id = "99999"
 section_root = "homepage"
 section_segment = 0
diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md
index 313599048..d58fa8c6f 100644
--- a/docs/guide/configuration.md
+++ b/docs/guide/configuration.md
@@ -873,11 +873,16 @@ fetches never carry Basic credentials, so every visitor gets `401` — on
 `/_ts/page-bids` that means no ads after any client-side navigation. Match the
 admin routes specifically (`^/_ts/admin`) instead.
 
-Upgrading from a release before `/_ts/page-bids` existed: if any handler
-pattern covers it, narrow the pattern. The Trusted Server JS bundle falls back
-to the deprecated `/__ts/page-bids` alias in the meantime, but that alias is
-scheduled for removal
-([#970](https://github.com/IABTechLab/trusted-server/issues/970)).
+If an older deployment used a different SPA auction path, update its handler
+rules at the same time as the TSJS cutover. `/_ts/page-bids` is the only SPA
+auction endpoint; older path spellings are unknown routes.
+
+The `/integrations/aps/*` family is different: its renderer and live-runner
+routes are reserved before `[[handlers]]` is evaluated. They are browser-facing
+resources and are intentionally anonymous, so a handler pattern that matches
+`/integrations/aps/` does **not** add Basic Auth. Apply any admission control,
+rate limiting, or request shielding for those routes in the deployment platform,
+not through `[[handlers]]`.
 
 :::
 
@@ -1816,37 +1821,9 @@ Defines the ad slots the trusted server offers on a page: which pages each slot
 appears on (`page_patterns`), its supported sizes (`formats`), and the GAM ad
 unit it maps to (`gam_unit_path`).
 
-`enabled` is the dedicated server-side ad-template switch. It defaults to `true`
-for compatibility with existing configurations. Set it to `false` to stop
-publisher HTML and SPA page-bids template delivery while retaining the slot
-configuration and direct `POST /auction` endpoint.
-
-#### Publisher document cache policy
-
-For a successful GET publisher document, Trusted Server applies the
-browser-only `Cache-Control: private, max-age=60` policy from
-[#1007](https://github.com/IABTechLab/trusted-server/issues/1007) when the
-server-side ad stack is structurally inactive. Trusted Server also applies this
-policy to a subsequent `304 Not Modified` response so revalidation cannot
-restore the origin freshness policy. This includes an absent
-`[creative_opportunities]` section, `enabled = false`, no slot matching the
-path, or a disabled auction. The `private` directive prevents shared caches
-that use `Cache-Control` from storing the document. The policy replaces the
-origin browser cache policy except when the origin sends `private` or
-`no-store`, which are preserved. Bot, prefetch, and consent-denied requests
-also retain the origin policy because they can produce a request-specific
-representation for the same URL. Error responses and non-document requests
-retain the origin policy.
-
-Trusted Server leaves origin validators and CDN-specific cache headers
-unchanged. Those headers continue to control supporting CDNs independently of
-the browser-only policy. If a response using the generated inactive-stack
-policy later carries `Set-Cookie`, cookie privacy finalization replaces it with
-`Cache-Control: private, max-age=0` and removes the CDN-specific cache headers.
-
 ```toml
 [creative_opportunities]
-enabled = true # set to false to disable server-side ad templates
+enabled = true
 gam_network_id = "123456789"
 price_granularity = "dense"
 
@@ -2073,9 +2050,18 @@ publisher-specific. Startup fails if `{section}` is used without a valid
 `section_root`. Startup rejects a blank `gam_network_id` only when an absent
 path/default or a `{network_id}` template consumes it; static paths and
 templates without `{network_id}` do not consume it. A
-`[creative_opportunities]` block with `enabled = false` or no slots is
-inactive, so no publisher templates are delivered and its `gam_network_id` is
-not checked when no slot uses it.
+`enabled = false` explicitly disables publisher and page-bids template delivery:
+Trusted Server performs no publisher slot matching or automatic auction, injects no
+initial slot/auction projection, and does not install SPA page-bids navigation hooks.
+`/_ts/page-bids` returns the canonical empty projection. Direct `POST /auction`
+remains live under its ordinary auction and consent gates. A successful inactive
+publisher HTML `GET` receives `Cache-Control: max-age=60` unless the origin policy
+contains `private` or `no-store` (case-insensitive); origin validators and
+surrogate/CDN directives remain intact. Non-HTML, failed, and non-`GET` responses
+retain the origin cache policy. An enabled block with no slots has no templates to
+match, so its `gam_network_id` is not checked. The `enabled` key is required whenever
+the table is present, and disabling delivery does not bypass startup validation of
+its slots, assembly mode, or template-cache fields.
 
 Both knobs are config-driven, so the URL→section convention stays with the
 publisher: `section_segment` selects which segment names the section, and
diff --git a/docs/guide/creative-processing.md b/docs/guide/creative-processing.md
index 24e8dc0c3..b50b1d354 100644
--- a/docs/guide/creative-processing.md
+++ b/docs/guide/creative-processing.md
@@ -71,12 +71,12 @@ rewrite_creatives = true
 Regardless of mode, a creative larger than the 1 MiB per-creative cap is
 rejected and its `adm` is dropped.
 
-| `sanitize_creatives` | `rewrite_creatives` | Auction winning-bid `adm` behavior                                                                                                                                                                                                                                         |
-| -------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `false` (default)    | `false`             | Deliver the creative exactly as the bidder returned it (subject to the size cap).                                                                                                                                                                                          |
-| `true`               | `false`             | Strip executable markup (`script`/`object`/`embed`/`form`, event handlers) with its inner content, then deliver without rewriting. Sanitizer-accepted external resource, click, and inline CSS URLs remain direct.                                                         |
-| `false`              | `true` (default)    | Rewrite eligible resource/CSS and click URLs in the raw bidder markup to signed first-party endpoints, removing any bidder `<base>` element. Executable markup is preserved.                                                                                               |
-| `true`               | `true`              | Sanitize first, then rewrite. `POST /auction` emits root-relative endpoints and injects creative TSJS exactly once, whether or not the bidder supplied a `<body>`; SSAT/page-bids emits absolute endpoints for its foreign-origin renderer and does not inject the bundle. |
+| `sanitize_creatives` | `rewrite_creatives` | Auction winning-bid `adm` behavior                                                                                                                                                                                                                             |
+| -------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `false` (default)    | `false`             | Deliver the creative exactly as the bidder returned it (subject to the size cap).                                                                                                                                                                              |
+| `true`               | `false`             | Strip executable markup (`script`/`object`/`embed`/`form`, event handlers) with its inner content, then deliver without rewriting. Sanitizer-accepted external resource, click, and inline CSS URLs remain direct.                                             |
+| `false`              | `true` (default)    | Rewrite eligible resource/CSS and click URLs in the raw bidder markup to signed first-party endpoints, removing any bidder `<base>` element. Executable markup is preserved.                                                                                   |
+| `true`               | `true`              | Sanitize first, then rewrite. `POST /auction` emits root-relative endpoints and injects creative TSJS exactly once, including for body-less fragments; SSAT/page-bids emits absolute endpoints for its foreign-origin renderer and does not inject the bundle. |
 
 ::: warning Sanitization blanks script-based creatives
 Sanitization removes `script`/`object`/`embed`/`form` and similar elements
@@ -108,8 +108,9 @@ separately constrained asset capability is tracked in
 
 The second is **dynamic** resource signing,
 which rewrites URLs on elements a creative inserts at runtime. It is installed
-only when `renderGuard` is enabled in `tsCreativeConfig`, and that is `false`
-by default — deployments using the default configuration are unaffected. Where
+only when `renderGuard` is enabled in the immutable
+`window.tsjs.boot.creative` configuration, and that is `false` by default —
+deployments using the default configuration are unaffected. Where
 it is enabled, runtime-inserted `<img>`/`<iframe>` URLs cannot be signed from an
 opaque origin (the signing request is blocked by CORS), so they load directly
 from third parties; the sandbox still isolates them from the publisher origin,
@@ -753,30 +754,34 @@ impl IntegrationScriptRewriter for NextJsIntegration {
 
 ### Head Injectors
 
-Integrations can inject HTML snippets at the start of `<head>`, immediately after the unified TSJS bundle:
+Integrations can inject HTML snippets at the start of `<head>`, before the unified TSJS bundle:
 
-**Example**: An integration injects configuration that runs after the TSJS API is available
+**Example**: An integration emits release-bound configuration through the one transient pre-core transport
 
 ```rust
 impl IntegrationHeadInjector for MyIntegration {
     fn integration_id(&self) -> &'static str { "my_integration" }
 
     fn head_inserts(&self, ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        vec![format!(
-            r#"<script>tsjs.setConfig({{ host: "{}" }});</script>"#,
-            ctx.request_host
-        )]
+        let config_json = serde_json::to_string(&serde_json::json!({
+            "host": ctx.request_host,
+        }))
+        .expect("should serialize integration config")
+        .replace("</", "<\\/");
+        vec![super::integration_config_script("my_integration", &config_json)]
     }
 }
 ```
 
 **Behavior**:
 
-- Snippets are prepended into `<head>` after the TSJS bundle tag
+- Snippets are prepended into `<head>` before the TSJS bundle tags
 - Called once per HTML response
 - Multiple integrations can each contribute snippets
 - If no snippets are returned, no extra markup is added
 
+The core snapshots and freezes each manifest integration's configuration, deletes the transient transport, and exposes only the final immutable `window.tsjs.boot` and `TsjsApi` surfaces.
+
 See [Integration Guide](/guide/integration-guide) for creating custom rewriters.
 
 ## TSJS Injection
diff --git a/docs/guide/error-reference.md b/docs/guide/error-reference.md
index b45cac63a..aefacb668 100644
--- a/docs/guide/error-reference.md
+++ b/docs/guide/error-reference.md
@@ -635,7 +635,7 @@ Warning: viceroy version mismatch
 **Solution:**
 
 ```bash
-cargo install viceroy --version 0.17.0 --locked --force
+cargo install viceroy --version 0.19.0 --locked --force
 ```
 
 ---
diff --git a/docs/guide/getting-started.md b/docs/guide/getting-started.md
index 7d73235b0..8ae43a3b3 100644
--- a/docs/guide/getting-started.md
+++ b/docs/guide/getting-started.md
@@ -50,7 +50,7 @@ Simulates the full Fastly production environment locally.
 Install and configure the Fastly CLI using the [Fastly setup guide](/guide/fastly), then install Viceroy:
 
 ```bash
-cargo install viceroy --version 0.17.0 --locked --force
+cargo install viceroy --version 0.19.0 --locked --force
 ```
 
 Start the local Fastly simulator:
diff --git a/docs/guide/integration-guide.md b/docs/guide/integration-guide.md
index cf7da71f6..2c6ccd6c6 100644
--- a/docs/guide/integration-guide.md
+++ b/docs/guide/integration-guide.md
@@ -215,19 +215,42 @@ impl IntegrationScriptRewriter for MyIntegration {
 Returning `AttributeRewriteAction::remove_element()` (or `ScriptRewriteAction::RemoveNode` for inline content) removes the element entirely, so integrations can drop publisher-provided markup when the Trusted Server already injects a safe alternative. Prebid, for example, removes publisher `prebid.js` tags because Trusted Server injects a first-party `/integrations/prebid/bundle.js` URL for the configured external bundle.
 :::
 
-### 5b. Implement Head Injection (Optional)
+### 5b. Project Browser Configuration (When TSJS Needs It)
 
-If the integration needs to inject HTML snippets at the start of `<head>` (for example, configuration scripts or global bootstraps), implement `IntegrationHeadInjector`. Snippets are prepended into `<head>` before the TSJS bundle tags, so they run first.
+Browser configuration is part of the immutable version-1 boot document. Define a
+small serializable projection containing only browser-safe fields and attach it to
+the registration. Products with no browser-selectable fields must attach the exact
+empty projection.
+
+```rust
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct MyBrowserConfigV1 {
+    mode: String,
+}
+
+IntegrationRegistration::builder("my_integration")
+    .with_browser_config_v1(&MyBrowserConfigV1 {
+        mode: "strict".to_string(),
+    })?
+    .build()
+```
+
+The registry validates the selected product set, serializes entries in canonical
+order, and places the exact carrier inside `BootV1`. The runtime snapshots and
+freezes that boot document, then attenuates each product's entry to its own module.
+Do not emit a separate mutable configuration global or inline configuration script.
+
+### 5c. Implement Head Injection (Optional)
+
+If the integration needs to inject unrelated HTML snippets at the start of `<head>`, implement `IntegrationHeadInjector`. Snippets are prepended into `<head>` before the TSJS bundle tags, so they run first. Browser configuration belongs in the immutable boot projection described above, not in this hook.
 
 ```rust
 impl IntegrationHeadInjector for MyIntegration {
     fn integration_id(&self) -> &'static str { "my_integration" }
 
-    fn head_inserts(&self, ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
-        vec![format!(
-            r#"<script>tsjs.setConfig({{ mode: "my_integration", host: "{}" }});</script>"#,
-            ctx.request_host
-        )]
+    fn head_inserts(&self, _ctx: &IntegrationHtmlContext<'_>) -> Vec<String> {
+        vec![r#"<meta name="my-integration" content="enabled">"#.to_string()]
     }
 }
 ```
@@ -235,7 +258,7 @@ impl IntegrationHeadInjector for MyIntegration {
 `html_processor.rs` calls `head_inserts` once per HTML response when the `<head>` element is first encountered. The returned snippets are concatenated before the unified script tag, so ordering between integrations is not guaranteed — keep snippets self-contained.
 
 ::: tip When to Use Head Injection
-Use `IntegrationHeadInjector` when you need to emit configuration, inline scripts, or `<meta>` tags that must appear early in `<head>`. For attribute or script content changes on existing elements, prefer `IntegrationAttributeRewriter` or `IntegrationScriptRewriter` instead.
+Use `IntegrationHeadInjector` when you need to emit metadata or other markup that must appear early in `<head>`. For attribute or script content changes on existing elements, prefer `IntegrationAttributeRewriter` or `IntegrationScriptRewriter` instead.
 :::
 
 ### 6. Register the Module
@@ -342,7 +365,7 @@ endpoint or bidder fields.
 
 **3. HTML Rewrites Through the Registry**
 
-When the integration is enabled, the `IntegrationAttributeRewriter` removes any `<script src="prebid*.js">` or `<link href=…>` references that match `script_patterns`. Trusted Server injects `window.__tsjs_prebid` plus a same-origin `<script defer src="/integrations/prebid/bundle.js">` tag, so dropping publisher assets prevents duplicate downloads while configuration is available before the external bundle initializes.
+When the integration is enabled, the `IntegrationAttributeRewriter` removes any `<script src="prebid*.js">` or `<link href=…>` references that match `script_patterns`. Trusted Server emits the release-bound typed integration configuration and a same-origin `<script defer src="/integrations/prebid/bundle.js">` tag. The module loader validates, snapshots, freezes, and consumes that configuration before the public API commits, so no mutable window flag remains. Dropping publisher assets prevents duplicate downloads while configuration is available before the external bundle initializes.
 
 **4. External Bundle Assets & Testing**
 
diff --git a/docs/guide/integrations/aps.md b/docs/guide/integrations/aps.md
index d25db5af6..208f2db9d 100644
--- a/docs/guide/integrations/aps.md
+++ b/docs/guide/integrations/aps.md
@@ -25,18 +25,11 @@ The integration does not implement:
 
 ## Configuration
 
-APS server ownership is entirely under an auction provider. The optional
-`[integrations.aps]` table controls browser renderer ownership only. It does not
-own the APS account, endpoint, timeout, debug behavior, or script policy. APS
-renderer support is registered whenever the compiled auction plan contains an
-`aps` profile, even if `[integrations.aps]` is absent or disabled.
-
-```toml
-[integrations.aps]
-enabled = true
-# Default. Use publisher_native only for the controlled experiment below.
-rendering_mode = "trusted_server"
-```
+APS server and browser ownership are both derived from the compiled auction
+plan. Selecting `profile = "aps"` registers the provider, the opaque renderer,
+and the live runner proxy as one unit. Do not add a separate
+`[integrations.aps]` table; account, endpoint, timeout, debug behavior, and
+script policy all belong to the APS provider profile.
 
 ```toml
 [auction]
@@ -44,37 +37,27 @@ enabled = true
 timeout_ms = 2000
 ```
 
-`profile_config.account_id` is the canonical field. The config-first schema does not accept the legacy `pub_id` alias.
+`account_id` is required. It accepts a non-empty string or integer account identifier; no alternate field name is supported.
+
+This is a hard config cutover. Before deploying the new binary, rename the former
+APS account field to the canonical `account_id`, quote any numeric
+identifier so it is a TOML string, and remove legacy or unknown APS keys. Run
+`ts config validate`, then push the canonical configuration while the old binary
+that accepts `account_id` is still serving. Deploy the new binary only after that
+push succeeds. The new binary has no legacy field alias, numeric-ID coercion, or
+compatibility parser.
 
 `debug` defaults to `false`. Enable it only on controlled test sites because it includes the raw APS request and response, including identity, consent, device, page, account, bid, and creative data, in the client-visible `/auction` response.
 
 `allow_script_creatives` defaults to `false`. While disabled, APS script bids are rejected before per-impression reduction, floors, mediation, and winner selection. Enable it only for a controlled cohort after the browser-security checks in [Rollout](#rollout) pass.
 
-`integrations.aps.rendering_mode` is a strict enum. `trusted_server` is the default and retains the opaque static renderer route. `publisher_native` disables that route and adds `data-ts-aps-rendering-mode="publisher_native"` to the server-generated TSJS bundle tag. TSJS captures this server-owned attribute when the bundle executes, so markup added later cannot change the mode. The attribute works under a publisher CSP that blocks inline scripts. Unknown values fail configuration deserialization.
-
-### Publisher-native runner experiment
-
-`publisher_native` is an opt-in browser experiment, **not** general APS compatibility proof. No public `apstag` API was found that accepts an externally selected OpenRTB `aaxResponse`. In controlled browser testing, `apstag.renderImp(document, bidId)` did not render the Trusted Server bid because that bid was absent from the SDK's browser-auction state. Trusted Server therefore does not call `apstag`, `fetchBids`, or `setDisplayBids`, mutate the publisher's APS SDK, or start a second auction. Instead, this mode reuses the same `prebid/creative/render` runner contract already used by `trusted_server` mode, but inside a publisher-origin frame; that observed vendor contract still requires APS account-team validation.
-
-No publisher JavaScript change is required. After validating and freezing the exact selected descriptor, Trusted Server JS:
-
-1. resolves the direct-auction slot or its injected GAM div mapping;
-2. creates a hidden, publisher-origin friendly iframe sized to the winner;
-3. initializes only that fresh frame's account-scoped `_aps` event queue;
-4. queues `prebid/creative/render` with the selected `aaxResponse` and bid ID; and
-5. loads the fixed `https://client.aps.amazon-adsystem.com/prebid-creative.js` runner.
-
-The existing publisher content remains visible until the runner script loads. A runner error, a blocked script, a missing slot, a superseding dispatch, or a load taking longer than 10 seconds removes the pending frame and visibly declines the bid. It never falls back to `/integrations/aps/renderer` or sends a Universal Creative renderer response. Trusted Server treats runner load as successful handoff; the runner owns subsequent creative completion and resource loading.
-
-Unlike `trusted_server` mode, this friendly frame deliberately has no opaque-origin sandbox. Its initial document inherits the publisher CSP, so the publisher policy controls whether the APS runner and required creative resources can load. Trusted Server sets the frame document's referrer policy to `no-referrer`, matching the static renderer's existing protection. The fixed APS runner and its creative otherwise execute with publisher-origin privileges, so `publisher_native` has a larger security surface, especially when `allow_script_creatives = true`. Use only a controlled cohort.
-
-For a client-side Prebid APS capability, Trusted Server consumes the one-shot capability before starting the runner and calls `markWinningBidAsUsed` only after the runner loads. For server/GPT ownership, it similarly claims the slot/ad ID first. This prevents native and Trusted Server rendering from both owning the same response.
-
-Disable or coordinate existing publisher-native APS demand for every `publisher_native` cohort. Otherwise the publisher's normal APS auction and this server-selected bid can duplicate demand. Validate the exact account, inventory, CSP, iframe/script creative behavior, impression reporting, and click-through behavior with the APS account team before any production rollout.
+There is one browser rendering mode: the Trusted Server-owned opaque renderer.
+Publisher-origin friendly-frame rendering and runtime mode switches are not part
+of the hard-cutover contract.
 
 Set `inventory_domain` and `inventory_page_origin` together only when the public deployment hostname differs from the inventory identity authorized by APS. The domain becomes `site.domain`. The HTTPS page origin replaces the current page's scheme and host while preserving its path; query and fragment data are removed before forwarding. The origin must be the inventory domain or one of its subdomains and cannot include credentials, a port, path, query, or fragment. These values come only from operator configuration; Trusted Server never accepts APS inventory identity from the client auction payload.
 
-APS uses ordinary auction slot IDs and banner formats. Legacy creative-opportunity APS `slot_id` configuration is accepted for compatibility but ignored, and `bidders.aps.slotID` is not required. Remove both during migration.
+APS uses ordinary auction slot IDs and banner formats. It does not read APS-specific creative-opportunity slot IDs or `bidders.aps.slotID`.
 
 The APS provider may also participate through a configured mediator:
 
@@ -109,7 +92,7 @@ rejected. `timeout_ms` belongs beside `endpoint`; when omitted, the `aps`
 profile default is 800 ms. Runtime caps it by the remaining auction budget.
 
 `profile_config.account_id` is required, nonempty, and at most 1024 bytes. It is
-the canonical field; integration-owned `account_id`, `pub_id`, endpoint, and
+the canonical field; integration-owned account, endpoint, and
 timeout fields are not part of the public schema. `debug` and
 `allow_script_creatives` both default to `false`.
 
@@ -240,7 +223,18 @@ Trusted Server does not insert APS creative markup into the publisher document.
 
 Seats, `impid`, markup, notifications, user-sync data, sibling bids, losing seats, and unknown fields are not exposed. The browser decodes this envelope and cross-checks the ID, dimensions, URL, and tag type before any DOM mutation or message suppression.
 
-In `trusted_server` mode, both rendering paths use `GET /integrations/aps/renderer`, a static Trusted Server document with its own restrictive CSP. The document initializes the account-keyed APS queue and then loads only the fixed runner at `https://client.aps.amazon-adsystem.com/prebid-creative.js`.
+Both rendering paths use `GET /integrations/aps/renderer/v2`, a versioned static Trusted Server materializer with its own restrictive CSP. After the first APS action, the top page sends only independent nonces, the validated creative origin, and tag type. The materializer creates the opaque outer and inner data documents; only the inner document receives and validates the descriptor, initializes the account-keyed APS queue, and loads the live runner through the fixed first-party proxy at `GET /integrations/aps/runner.js`. Trusted Server neither vendors nor pins the upstream runner bytes.
+
+Both paths are reserved before configured `[[handlers]]` are evaluated. They are
+browser-facing and intentionally anonymous; Basic Auth handler patterns do not
+protect `/integrations/aps/*`. Apply any operator-required admission control or
+rate limiting at the deployment platform.
+
+The runner is a live, unversioned proxy dependency. Trusted Server does not vendor,
+pin, archive, or cache its bytes, and the successful runner response adds no
+`Cache-Control` requirement. Platform admission control, rate limiting, and request
+shielding are operator concerns; they must not turn the runner into TS-owned source
+or a pinned release artifact.
 
 The outer iframe uses these sandbox permissions:
 
@@ -253,22 +247,26 @@ allow-scripts
 allow-top-navigation-by-user-activation
 ```
 
-It deliberately omits `allow-same-origin`, so APS and bidder execution remains below an opaque-origin boundary. The renderer response repeats these restrictions with a CSP `sandbox` directive, preventing another embedding path from restoring publisher-origin execution by omitting the iframe attribute. Trusted Server generates a fresh 128-bit nonce, binds it in the iframe URL fragment before navigation, and requires the same one-time nonce in the parent message and renderer acknowledgement. Existing slot content is retained until the static renderer has accepted the descriptor and loaded the fixed runner.
+It deliberately omits `allow-same-origin` during bootstrap, so APS and bidder execution remains below an opaque-origin boundary. The renderer response is an intentional transport-CSP superset with no CSP `sandbox` directive. The generated outer and inner meta CSPs narrow it to the exact Trusted Server and creative origins, while the iframe `sandbox` attributes enforce the exact phase-specific restrictions. Trusted Server generates independent 128-bit bootstrap and renderer nonces, binds each to its own phase, and accepts each exactly once. No descriptor or data-document URL crosses the bootstrap configuration channel. Existing slot content is retained until the inner renderer has accepted the descriptor and APS reports render completion.
 
 ### Direct `/auction`
 
-In `trusted_server` mode, the TSJS auction client validates the typed renderer descriptor, creates the opaque renderer iframe, and sends the minimized envelope after the frame loads. In `publisher_native` mode it creates the injected friendly iframe and queues the response for the fixed APS Prebid creative runner. Ordinary non-APS `adm` continues through the existing sanitizer and generic creative iframe.
+The TSJS auction client validates the typed renderer descriptor, creates the
+opaque renderer iframe, and sends the minimized envelope after the frame loads.
+Ordinary non-APS `adm` continues through the existing sanitizer and generic
+creative iframe.
 
 ### GAM and Universal Creative
 
-For initial navigation and page-bids, Trusted Server publishes the same descriptor in `window.tsjs.bids`. The source-checked Prebid Universal Creative bridge accepts requests only from the iframe that owns the matching `hb_adid` and validates the complete envelope. In `trusted_server` mode it returns a static dynamic-renderer program that creates the same opaque renderer iframe. After the response is delivered, the bridge expands an authenticated ordinary display iframe only when its width and height attributes and computed geometry are still 1x1. It resizes that source iframe and every collapsed clipping ancestor through the authenticated slot root to the validated winning dimensions. Ambiguous sources, stale navigation or refresh completions, anchors, interstitials, fixed or sticky frames, invalid dimensions, and already-expanded frames remain unchanged. The same guard applies to APS capabilities, inline `adm`, and PBS Cache responses.
-
-In `publisher_native` mode the bridge instead resolves the publisher div and starts the friendly-frame runner without sending a Universal Creative renderer response. That renderer replaces the slot through a different owner and does not run the collapsed-shell helper.
-
-After the native runner loads, Trusted Server replaces the existing children of the resolved publisher div with the friendly frame. This removes the GAM or Universal Creative iframe when it is inside that div. If the runner fails, the existing iframe remains, but its Universal Creative request receives no response because Trusted Server has already claimed the selected bid. This one-owner behavior avoids a second render path, but GAM impression and viewability reporting must be validated with the APS account team for the controlled cohort.
+For initial navigation, Trusted Server publishes the descriptor in the immutable `tsjs.boot.auctionProjection`. A later SPA page-bids response replaces only that navigation session's internal projection and never mutates `tsjs.boot`. The source-checked Prebid Universal Creative bridge accepts requests only from the iframe that owns the matching `hb_adid`, validates the complete envelope, and returns a static dynamic-renderer program that creates the same opaque renderer iframe.
 
 For client-side `trustedServer` adapter auctions, Prebid generates its own `hb_adid`. Trusted Server binds that generated ID to the validated APS descriptor in a bounded, expiring browser registry before GAM refresh. The bridge verifies that the requesting Universal Creative iframe belongs to the same ad unit, consumes the capability once, and passes the APS bid ID separately to the Amazon runner.
 
+The protected browser conformance environment uses Prebid Universal Creative
+`1.17.2`. Configure that release in GAM outside this repository. Trusted Server
+does not vendor, proxy, pin, archive, or serve PUC bytes; the version is test and
+operator metadata for the externally hosted creative only.
+
 These paths do not fetch PBS Cache, fire generic APS win/billing beacons, or call `apstag.setDisplayBids()` for the Trusted Server winner. Publisher-owned native APS objects are otherwise left untouched.
 
 ## Publisher CSP
@@ -295,22 +293,22 @@ If script rendering requires weakening the outer sandbox, leave `allow_script_cr
 
 This release is a direct configuration and protocol cutover:
 
-1. Move `endpoint` and `timeout_ms` to `[auction.providers.<id>]` and use
-   `/e/pb/bid`; `/e/dtb/bid` remains rejected.
-2. Move `account_id`, `debug`, `allow_script_creatives`, and inventory overrides
-   to the provider's `profile_config`; `pub_id` is not part of the new schema.
-3. Remove APS-specific slot ID configuration and any APS entry from old Prebid
-   Server bidder lists. Use `routing = "all_eligible"` or an explicit
-   `[auction.bidders.aps]` route.
-4. Prepare GAM line items and Universal Creative for `hb_bidder=aps` and the
-   selected APS `hb_adid`.
-5. Disable publisher-native APS demand for the Trusted Server test cohort.
-
-There is no legacy runtime switch. Roll back by disabling `[auction]` or
-removing the APS provider, restoring native APS for the cohort, or deploying
-the prior binary.
-
-Changing `rendering_mode` does not update pages that are already loaded or stored in an HTML cache. A cached `trusted_server` page can continue requesting `/integrations/aps/renderer` after a native-mode deployment removes that route. A cached `publisher_native` page continues using its captured native mode after rollback. Coordinate the mode change with HTML cache expiry or purge and reload active test sessions before judging the result.
+1. In the operator configuration, rename the former APS account field
+   to `account_id`, quote numeric identifiers, and remove legacy or unknown APS keys.
+2. Run `ts config validate`, then push that canonical configuration while the old
+   binary that accepts `account_id` is still serving.
+3. Deploy the new binary. It rejects the former field, numeric IDs, aliases, mixed
+   legacy shapes, and unknown APS keys; there is no compatibility parser.
+4. Replace the legacy `/e/dtb/bid` endpoint with `/e/pb/bid`.
+5. Remove APS-specific slot ID configuration and remove `aps` from Prebid Server bidder lists. Trusted Server also filters APS from PBS requests for this path.
+6. Prepare GAM line items and Universal Creative for `hb_bidder=aps` and the selected APS `hb_adid`.
+7. Disable publisher-native APS demand for the Trusted Server test cohort.
+
+There is no legacy runtime switch. To stop new APS admission and disable both
+reserved browser routes, remove the APS-profile provider from the effective
+auction plan and deploy that configuration. Restore publisher-native APS for the
+cohort only after the Trusted Server plan no longer admits APS. Deploying the
+prior binary remains the binary rollback path.
 
 ## Rollout
 
@@ -318,12 +316,13 @@ Use fictional values in source-controlled configuration and fixtures. Supply con
 
 1. Obtain APS account-team confirmation for edge-originated OpenRTB traffic.
 2. Enable Trusted Server APS only for an isolated cohort and disable native APS demand there.
-3. Keep the default `trusted_server` mode and `allow_script_creatives = false`; observe iframe bids through direct and GAM paths.
+3. Keep `allow_script_creatives = false`; observe iframe bids through direct and GAM paths.
 4. Confirm outbound privacy fields, aggregate diagnostics, decoded-price competition, line-item targeting, dimensions, click-throughs, and opaque-origin isolation.
-5. In a still-smaller cohort, set `rendering_mode = "publisher_native"` and confirm the fixed runner request, friendly-frame dimensions, iframe creatives, impression reporting, and click-throughs without a request to `/integrations/aps/renderer`.
-6. Purge or expire cached HTML and reload active test sessions when changing modes. Confirm the publisher CSP permits the runner but does not need to permit inline Trusted Server scripts.
-7. Only after reviewing the friendly-frame security tradeoff, enable script creatives for the isolated native cohort and validate them in a real browser.
-8. Expand traffic only after APS confirmation and successful controlled validation.
+5. Confirm the fixed live-runner proxy request, opaque-frame dimensions, iframe
+   creatives, impression reporting, and click-through behavior.
+6. Enable script creatives only for a smaller isolated cohort and validate them
+   in a real browser without weakening the outer sandbox.
+7. Expand traffic only after APS confirmation and successful controlled validation.
 
 ## Troubleshooting
 
@@ -341,12 +340,12 @@ Use fictional values in source-controlled configuration and fixtures. Supply con
 
 ### Winner targets but does not render
 
-- In `trusted_server` mode, confirm `GET /integrations/aps/renderer` returns HTML with its CSP and `Referrer-Policy: no-referrer`, and that publisher CSP permits `frame-src 'self'`.
-- In `publisher_native` mode, confirm the `#trustedserver-js` bundle tag carries `data-ts-aps-rendering-mode="publisher_native"`, the slot receives a hidden friendly iframe, and publisher CSP does not block `https://client.aps.amazon-adsystem.com/prebid-creative.js` or the selected creative's resources. The static renderer route is intentionally absent in this mode. Runner script load is the handoff signal, not proof that the creative painted.
+- Confirm `GET /integrations/aps/renderer/v2` returns HTML with its CSP and `Referrer-Policy: no-referrer`.
+- Confirm publisher CSP permits `frame-src 'self'`.
 - Confirm the GAM creative uses the supported Prebid Universal Creative bridge and the winning `hb_adid`.
-- For client-side `trustedServer` adapter auctions, confirm Prebid's `bidResponse` contains a generated `adId` and that the corresponding capability appears briefly in `window.tsjs.apsPrebidRenderers` before rendering.
-- Ensure no publisher APS auction is trying to handle the same cohort.
-- Keep script creatives disabled while diagnosing either rendering mode.
+- For client-side `trustedServer` adapter auctions, confirm the bid joins the server-minted `r1_` reservation and that the private PUC bridge accepts exactly one claim for it.
+- Ensure no native APS path is trying to handle the same cohort.
+- Keep script creatives disabled while diagnosing iframe rendering.
 
 ## Verification
 
diff --git a/docs/guide/integrations/datadome.md b/docs/guide/integrations/datadome.md
index ed671b4a2..d7c67a102 100644
--- a/docs/guide/integrations/datadome.md
+++ b/docs/guide/integrations/datadome.md
@@ -68,29 +68,29 @@ patterns = ["(?i)\\.(avi|flv|mka|mkv|mov|mp4|mpeg|mpg|mp3|flac|ogg|ogm|opus|wav|
 
 ### Configuration options
 
-| Option                                 | Type    | Default                          | Description                                                                    |
-| -------------------------------------- | ------- | -------------------------------- | ------------------------------------------------------------------------------ |
-| `enabled`                              | boolean | `false`                          | Enable the DataDome integration                                                |
-| `sdk_origin`                           | string  | `https://js.datadome.co`         | DataDome SDK origin URL for `tags.js`                                          |
-| `api_origin`                           | string  | `https://api-js.datadome.co`     | DataDome signal collection API origin URL for `/js/*`                          |
-| `cache_ttl_seconds`                    | integer | `3600`                           | Cache TTL for `tags.js`                                                        |
-| `rewrite_sdk`                          | boolean | `true`                           | Rewrite DataDome script URLs in HTML to first-party paths                      |
-| `enable_protection`                    | boolean | `false`                          | Call the Protection API before route matching                                  |
-| `server_side_key_secret_name`          | string  | none                             | Default-store secret reference required when protection is enabled             |
-| `protection_api_origin`                | string  | `https://api-fastly.datadome.co` | Protection API origin                                                          |
-| `timeout_ms`                           | integer | `1500`                           | Dynamic backend first-byte timeout for Protection API calls                    |
-| `protection_excluded_methods`          | array   | `["OPTIONS"]`                    | HTTP methods skipped before the Protection API call                            |
-| `protection_excluded_asns`             | array   | `[]`                             | Client autonomous system numbers skipped before the Protection API call        |
-| `protection_excluded_ip_cidrs`         | array   | `[]`                             | Inline client IP CIDR ranges skipped before the Protection API call            |
-| `protection_excluded_ip_cidr_sources`  | array   | `[]`                             | Config Store sources containing dynamic client IP CIDR bypass lists            |
-| `protection_ip_list_cache_ttl_seconds` | integer | `300`                            | Process-local cache TTL for Config Store-backed IP CIDR bypass lists           |
-| `protection_exclusion_rules`           | array   | Static asset path regex          | Structured method/path/query/IP/ASN exclusion rules                            |
-| `protection_test_bypass`               | object  | omitted                          | Configuration-gated fixed-header bypass; secret must contain at least 32 bytes |
-| `enable_graphql_support`               | boolean | `false`                          | Reserved for future GraphQL body inspection; ignored in v1                     |
-| `client_side_key`                      | string  | `""`                             | DataDome client-side JavaScript key used for tag injection                     |
-| `inject_client_side_tag`               | boolean | `true`                           | Auto-inject the browser tag when `client_side_key` is non-empty                |
-| `client_side_tag_url`                  | string  | `/integrations/datadome/tags.js` | Root-relative or HTTPS script URL used by auto-injection                       |
-| `client_side_configuration`            | object  | `{ ajaxListenerPath = true }`    | Options assigned to `window.ddoptions`                                         |
+| Option                                 | Type    | Default                          | Description                                                             |
+| -------------------------------------- | ------- | -------------------------------- | ----------------------------------------------------------------------- |
+| `enabled`                              | boolean | `false`                          | Enable the DataDome integration                                         |
+| `sdk_origin`                           | string  | `https://js.datadome.co`         | DataDome SDK origin URL for `tags.js`                                   |
+| `api_origin`                           | string  | `https://api-js.datadome.co`     | DataDome signal collection API origin URL for `/js/*`                   |
+| `cache_ttl_seconds`                    | integer | `3600`                           | Cache TTL for `tags.js`                                                 |
+| `rewrite_sdk`                          | boolean | `true`                           | Rewrite DataDome script URLs in HTML to first-party paths               |
+| `enable_protection`                    | boolean | `false`                          | Call the Protection API before route matching                           |
+| `server_side_key_secret_store`         | string  | `ts_secrets`                     | Runtime secret store containing the DataDome server-side key            |
+| `server_side_key_secret_name`          | string  | `datadome_server_side_key`       | Secret name containing the DataDome server-side key                     |
+| `protection_api_origin`                | string  | `https://api-fastly.datadome.co` | Protection API origin                                                   |
+| `timeout_ms`                           | integer | `1500`                           | Dynamic backend first-byte timeout for Protection API calls             |
+| `protection_excluded_methods`          | array   | `["OPTIONS"]`                    | HTTP methods skipped before the Protection API call                     |
+| `protection_excluded_asns`             | array   | `[]`                             | Client autonomous system numbers skipped before the Protection API call |
+| `protection_excluded_ip_cidrs`         | array   | `[]`                             | Inline client IP CIDR ranges skipped before the Protection API call     |
+| `protection_excluded_ip_cidr_sources`  | array   | `[]`                             | Config Store sources containing dynamic client IP CIDR bypass lists     |
+| `protection_ip_list_cache_ttl_seconds` | integer | `300`                            | Process-local cache TTL for Config Store-backed IP CIDR bypass lists    |
+| `protection_exclusion_rules`           | array   | Static asset path regex          | Structured method/path/query/IP/ASN exclusion rules                     |
+| `enable_graphql_support`               | boolean | `false`                          | Reserved for future GraphQL body inspection; ignored in v1              |
+| `client_side_key`                      | string  | `""`                             | DataDome client-side JavaScript key used for tag injection              |
+| `inject_client_side_tag`               | boolean | `true`                           | Auto-inject the browser tag when `client_side_key` is non-empty         |
+| `client_side_tag_url`                  | string  | `/integrations/datadome/tags.js` | Root-relative or HTTPS script URL used by auto-injection                |
+| `client_side_configuration`            | object  | `{ ajaxListenerPath = true }`    | Options assigned to `window.ddoptions`                                  |
 
 ## Client-side setup
 
@@ -168,90 +168,11 @@ A request is protected when all of the following are true:
 5. The client IP does not match `protection_excluded_ip_cidrs` or any Config Store-backed CIDR source.
 6. The client ASN is not listed in `protection_excluded_asns`.
 7. No `protection_exclusion_rules` match.
-8. The request does not contain a matching enabled `protection_test_bypass` credential.
 
 Static assets are excluded by default using a case-insensitive file-extension regex. Trusted Server internal routes such as `/static/tsjs=`, `/integrations/`, `/first-party/`, admin routes, discovery routes, and signature-verification routes are also excluded by default.
 
 Auction traffic at `/auction` is protected by default.
 
-### Test bypass
-
-For short-lived browser automation on an access-controlled staging site, you
-can configure a static header credential that skips only the server-side
-Protection API:
-
-```toml
-[integrations.datadome.protection_test_bypass]
-enabled = true
-credential_secret_name = "datadome_test_bypass"
-```
-
-`protection_test_bypass` requires `enable_protection = true`; it is disabled
-when omitted or when its `enabled` field is false. Store a randomly generated
-credential containing at least 32 bytes of high-entropy material under the
-referenced key in the logical default Secret Store (`trusted_server_secrets` by
-default), configure this section only while needed, and protect the site with an
-outer access control such as Basic Auth. Remove the section when testing
-finishes.
-
-Whenever the enabled DataDome request filter runs on the Fastly adapter, the
-fixed `x-ts-datadome-bypass` header is removed before configuration or
-credential checks. It therefore cannot reach DataDome or the publisher origin
-through that path when the bypass is absent, disabled, or invalid. Active
-credentials are compared in constant time and never logged. Duplicate header
-values fail closed. Scope the header to the test origin; do not attach it to
-every request in a browser context because that can disclose the credential to
-third-party origins. With Playwright:
-
-```ts
-await context.route('https://staging.example.com/**', async (route) => {
-  const headers = {
-    ...route.request().headers(),
-    'x-ts-datadome-bypass': process.env.DATADOME_TEST_BYPASS!,
-  }
-  await route.continue({ headers })
-})
-```
-
-### Client-side tag suppression behavior
-
-On the Fastly adapter, a request that matches an IP-based DataDome exclusion
-or the configured test-bypass credential also omits Trusted Server's
-automatically injected client-side DataDome tag from processed HTML. This keeps
-the client-side layer consistent with the server-side Protection API skip.
-
-This behavior applies to:
-
-- `protection_excluded_ip_cidrs`;
-- `protection_excluded_ip_cidr_sources`;
-- structured `ip_cidr` rules;
-- structured `ip_cidr_source` rules; and
-- a matching enabled `protection_test_bypass` credential.
-
-Method, ASN, path, query-parameter, static-asset, and internal-route exclusions
-alone do not suppress the client-side tag. However, a simultaneous matching IP
-exclusion suppresses it regardless of which first-match rule and reason are
-logged. DataDome tags already present in publisher HTML are not removed or
-changed by this behavior, and `/integrations/datadome/tags.js` remains available
-when requested directly.
-
-Because the processed HTML differs by client IP or test credential,
-tag-suppressed HTML is marked `private, no-store`, has origin validators
-removed, and has shared-surrogate cache directives removed. This response-time
-policy cannot invalidate tag-bearing HTML already held by a shared cache in
-front of Trusted Server. Guaranteed suppression requires bypassing or purging
-that cache, or avoiding shared caching ahead of Trusted Server.
-
-IP-exclusion suppression skips are logged at `info` for navigations and `debug`
-for subresources; matching test-bypass events remain at `info` as security audit
-events. Protection API result logs classify `allowed`, `blocked`, and
-`failed_open` outcomes and use distinct `api_status` and `datadome_status`
-fields. For example:
-
-```text
-[datadome] protection decision=skipped rule=protection-test-bypass reason=test_bypass client_tag=omitted method=GET
-```
-
 ### Structured exclusion rules
 
 Use structured rules for all DataDome protection exclusions. Each rule has an `id`, optional `methods`, and a typed matcher. The default configuration includes a `path_regex` rule for common static assets.
diff --git a/docs/guide/integrations/didomi.md b/docs/guide/integrations/didomi.md
index 8b27ec924..79e11f6db 100644
--- a/docs/guide/integrations/didomi.md
+++ b/docs/guide/integrations/didomi.md
@@ -99,7 +99,7 @@ With this configuration, requests are served at `/my-custom-consent/*` instead o
 - `"privacy/manage"` → serves at `/privacy/manage/*`
 - `"/my-cmp-path"` → serves at `/my-cmp-path/*`
 
-The custom path is automatically passed to the client-side JavaScript bundle via `window.__tsjs_didomi.proxyPath`, so the Didomi SDK URL rewriting continues to work without additional frontend configuration.
+The custom path is passed as release-bound typed integration configuration. The module loader validates, snapshots, freezes, and consumes it before the public TSJS API commits, so Didomi URL rewriting needs no frontend configuration and exposes no mutable window flag.
 
 ## Endpoints
 
diff --git a/docs/guide/integrations/gpt-diagnostics.md b/docs/guide/integrations/gpt-diagnostics.md
index e419a1a79..9d0199bc7 100644
--- a/docs/guide/integrations/gpt-diagnostics.md
+++ b/docs/guide/integrations/gpt-diagnostics.md
@@ -45,10 +45,12 @@ and non-storeable.
 
 ### Auction correlation token
 
-Enabling the integration has one further server-side effect, beyond module
-availability, that does not depend on browser activation. For each server-side auction
-that produced winning bids, Trusted Server mints a fresh correlation token and publishes
-it as `hb_auction_id` on each winning bid in `window.tsjs.bids`:
+Enabling the integration has one server-side effect that does not depend on browser
+activation. For each server-side auction that produced winning bids, Trusted Server
+mints a fresh correlation token and publishes it as `hb_auction_id` on each winning
+bid targeting record in the initial immutable `tsjs.boot.auctionProjection`. A later
+SPA page-bids response keeps its replacement projection internal to that navigation
+session:
 
 ```text
 ts-auc-2f8c1d5a4b7e4c0f9a3d6b1e8c5f2a7d
@@ -390,7 +392,7 @@ use live on a separate internal channel (`window.tsjs.gptDiagnosticsRecorder`) t
 is not part of this contract and is not supported for operator use.
 
 ```js
-const diagnostics = window.tsjs.gptDiagnostics
+const diagnostics = window.tsjs.diagnostics.gpt
 
 diagnostics.snapshot()
 diagnostics.export()
diff --git a/docs/guide/integrations/gpt.md b/docs/guide/integrations/gpt.md
index b55f65f7e..e5d6481b3 100644
--- a/docs/guide/integrations/gpt.md
+++ b/docs/guide/integrations/gpt.md
@@ -55,7 +55,6 @@ Add GPT configuration to `trusted-server.toml`:
 enabled = true
 gam_attribution_enabled = false
 script_url = "https://securepubads.g.doubleclick.net/tag/js/gpt.js"
-cache_ttl_seconds = 3600
 rewrite_script = true
 ```
 
@@ -66,7 +65,6 @@ rewrite_script = true
 | `enabled`                 | boolean | No       | `true`                                                 | Enable/disable the integration                                    |
 | `gam_attribution_enabled` | boolean | No       | `false`                                                | Add fixed page-level `ts=true` targeting for GAM cohort reporting |
 | `script_url`              | string  | No       | `https://securepubads.g.doubleclick.net/tag/js/gpt.js` | URL for the GPT bootstrap script                                  |
-| `cache_ttl_seconds`       | integer | No       | `3600`                                                 | Cache TTL for proxied scripts (60--86400s)                        |
 | `rewrite_script`          | boolean | No       | `true`                                                 | Whether to rewrite GPT script URLs in HTML                        |
 
 The environment override
diff --git a/docs/guide/integrations/prebid.md b/docs/guide/integrations/prebid.md
index 675ed02ae..8e095f916 100644
--- a/docs/guide/integrations/prebid.md
+++ b/docs/guide/integrations/prebid.md
@@ -431,8 +431,8 @@ owned by Trusted Server.
 
 ### How it works
 
-1. The server injects the `clientSideBidders` list into the page via `window.__tsjs_prebid`.
-2. When `pbjs.requestBids()` is called, the TSJS shim checks each bid against the list.
+1. The server emits `clientSideBidders` as release-bound typed integration configuration; the module loader validates, freezes, and consumes it before committing the public API.
+2. When `pbjs.requestBids()` is called, the Prebid adapter checks each bid against the immutable list.
 3. **Client-side bidders** are left as standalone bids — their native Prebid.js adapters handle them in the browser.
 4. **Bidders present in `[auction.bidders]`** are absorbed into the
    `trustedServer` adapter and routed through `/auction` to their configured
diff --git a/docs/guide/testing.md b/docs/guide/testing.md
index e1751bc49..d8258948a 100644
--- a/docs/guide/testing.md
+++ b/docs/guide/testing.md
@@ -10,7 +10,7 @@ Viceroy is the local test runtime for Fastly Compute applications. It simulates
 
 ```bash
 # Install viceroy
-cargo install viceroy --version 0.17.0 --locked --force
+cargo install viceroy --version 0.19.0 --locked --force
 
 # Run Fastly/WASM crate tests (viceroy is invoked automatically via .cargo/config.toml runner)
 cargo test-fastly
diff --git a/docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md b/docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md
new file mode 100644
index 000000000..6054b2d0d
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md
@@ -0,0 +1,1922 @@
+# APS Render Fix and TSJS Resilience Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use
+> `superpowers:subagent-driven-development` (recommended) or
+> `superpowers:executing-plans` to implement this plan task-by-task. Steps use
+> checkbox (`- [ ]`) syntax for tracking. Use
+> `superpowers:test-driven-development` for every behavior change and
+> `superpowers:verification-before-completion` before claiming a task, phase, or
+> plan complete.
+
+**Goal:** Finish the APS render fix and resilient TSJS hard cutover on the exact
+`rc/202608` base, preserving all affected rc behavior while closing every remaining
+revision-44 contract gap.
+
+**Architecture:** Keep the already-landed single-runtime/first-display architecture
+and complete it rather than replaying its historical implementation. The browser
+receives one server-sealed canonical JSON transport, synchronously validates its
+critical release relationships, and freezes one immutable boot snapshot; no-agent pages synchronously prepare,
+activate, and commit the only persistent runtime, while eligible projected pages use
+the bounded first-display owner and atomic post-paint takeover. APS rendering moves
+to a Trusted Server-owned top-page mount with independent bootstrap and renderer
+nonces, nested TS-authored data documents, an exact MessageChannel envelope, and one
+committed-artifact lifecycle for direct and PUC paths.
+
+**Tech Stack:** Rust 1.95 (`serde`, `error-stack`, `http`), TypeScript 6, Vitest,
+Node test runner, esbuild, Playwright, the four runtime adapters, GitHub Actions, and
+checked-in shell/Node CI scripts.
+
+---
+
+## Authority, current state, and execution rules
+
+The sole design authority is
+`docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md`
+revision 44. This is the sole implementation plan for that design.
+
+The implementation branch is `feature/aps-tsjs-resilience-rc202608`. It is created
+directly from fetched `origin/rc/202608` commit
+`07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf`. Previously reviewed feature and merge
+SHAs are historical review references only; their approved changes were replayed
+and reconciled onto this exact base and are not parent or implementation authority.
+That replayed history already
+implements the descriptor/projection contract, proxy route, core runtime, first-
+display split, integration catalog, hard cutover, package upgrade, and most
+verification surfaces. Those commits are implementation history, not evidence that
+revision 44 is complete.
+
+The final Task 17 refresh fetched and integrated `origin/rc/202608` at
+`07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf` on 2026-08-28. Its rc-owned package and
+operator-document changes are retained. Its raw-global GAM-attribution transport is
+superseded by the typed immutable GPT configuration carrier and sole parser-time GPT
+owner, and its mutable publisher-native APS experiment is superseded by the single
+Trusted Server renderer owner required by revision 44. The refresh also retains the
+config-first auction-provider contract, strict first-party proxy allowlist
+enforcement, edge-validated Basic-auth template eligibility, and the latest
+first-impression arbitration behavior behind the revision-44 owners.
+
+`origin/rc/202608` is the behavior, API, dependency, CI, and performance baseline.
+Do not merge `main` separately. Before final verification, fetch the release branch;
+if it advanced, merge its exact tip and repeat the overlap audit and complete gates.
+The PR targets `rc/202608`.
+
+The retired historical snapshot named by the design is concept evidence only. It is
+never fetched, merged, rebased, cherry-picked, built, or used as a performance
+baseline. EdgeZero, CLI, SSAT debug, admin, response-cache, analytics, persistence,
+billing, experiments, and deployment routing receive no feature work. Preserve rc
+changes in those areas if a merge overlaps them.
+
+Hard-cutover rules are non-negotiable:
+
+- no backward-compatible alias, dual runtime, protocol fallback, mutable generic
+  config surface, or old route/API;
+- no vendored, pinned, cached, hashed, or offline APS runner, GPT, or PUC bytes;
+- the APS runner remains the live fixed-target proxy at
+  `/integrations/aps/runner.js` and receives no Trusted Server successful-response
+  cache requirement;
+- the separately built `prebid.js@10.26.0` artifact remains the only explicitly
+  isolated external artifact and contains no TSJS behavior;
+- no DynamoDB, Tinybird, new cache project, or analytics requirement;
+- preserve the rc PBS Cache behavior as a GPT-owned black-box regression surface;
+- no new design or plan document. Schemas, fixtures, scripts, tests, and evidence
+  are implementation artifacts and may remain separate files;
+- workflow logic beyond simple command invocation lives in checked-in script files,
+  not inline shell, JavaScript, or Python embedded in Actions YAML.
+
+For every production change, follow strict RED -> GREEN -> REFACTOR:
+
+1. add the smallest focused failing test;
+2. run it and confirm it fails for the intended missing behavior, not setup;
+3. implement the minimum complete contract;
+4. rerun the focused test and adjacent regressions;
+5. run formatting for touched languages;
+6. inspect `git diff --check` and `git status --short`;
+7. commit only the task's paths with a sentence-case imperative subject and no
+   semantic prefix.
+
+If a planned RED test already passes on the reconciled branch, inspect the actual
+owner and adversarial boundaries. Record the requirement as verified in this plan,
+do not manufacture a failure, and make no production edit for that requirement.
+
+Never run bare `cargo test --workspace`. Use the adapter aliases from `CLAUDE.md`.
+
+## Remaining source ownership
+
+```text
+Rust boot/config owner
+  crates/trusted-server-core/src/tsjs.rs
+  crates/trusted-server-core/src/integrations/registry.rs
+  crates/trusted-server-core/src/html_processor.rs
+  crates/trusted-server-core/src/integrations/*.rs
+
+Immutable boot and runtime transaction
+  crates/trusted-server-js/lib/src/core/{bootstrap,types}.ts
+  crates/trusted-server-js/lib/src/kernel/{integration_registry,runtime,phase_loader,release_catalog}.ts
+  crates/trusted-server-js/lib/src/shared/{first_display_contracts,first_display_handoff}.ts
+  crates/trusted-server-js/lib/src/first_display/**
+
+APS top-mount protocol
+  crates/trusted-server-core/src/integrations/aps.rs
+  scripts/generate-aps-renderer-contract.mjs
+  crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts
+  crates/trusted-server-js/lib/src/adapters/messaging.ts
+  crates/trusted-server-js/lib/src/services/{render,slots,puc_bridge}.ts
+  crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts
+  crates/trusted-server-js/lib/src/integrations/aps/{render,module}.ts
+  crates/trusted-server-js/lib/src/first_display/{render_bridge,leaf/aps_protocol,slices/aps}.ts
+
+Rc behavior preservation
+  crates/trusted-server-core/src/{creative_opportunities,publisher,settings}.rs
+  crates/trusted-server-core/src/integrations/{gpt,gpt_diagnostics,prebid}.rs
+  crates/trusted-server-js/lib/src/integrations/{gpt,gpt_diagnostics,prebid}/**
+  docs/guide/integrations/{aps,gpt,gpt-diagnostics,prebid}.md
+
+Release proof
+  crates/trusted-server-js/lib/scripts/**
+  scripts/ci/**
+  scripts/validate-tsjs-performance-evidence.mjs
+  crates/trusted-server-integration-tests/browser/**
+  .github/workflows/{test,tsjs-performance-gate,aps-real-gam}.yml
+```
+
+## Phase 0 — Prove the rc baseline and identify actual gaps
+
+### Task 0: Add the schema-bumped rc-baseline concept audit
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json`
+- Modify: `crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs`
+- Modify: `crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs`
+- Modify: `crates/trusted-server-js/lib/package.json`
+- Modify: `.github/workflows/test.yml`
+
+- [ ] **Step 1: Add failing checker tests for two immutable evidence layers.** Require
+      a schema-versioned root containing the untouched historical-main rows and one
+      `rcBaseline` object bound to the exact rc SHA. Require exactly 23 rc rows with
+      exact keys `id`, `baselineSha`, `classification`, `ownerPaths`, `testPath`,
+      `command`, `result`, and `disposition`; final classifications are only
+      `baseline-owned` or `implementation-gap`. Reject missing fields, stale SHA,
+      duplicate ids, proof-pending/coverage-gap, retired-source commands, or mutation
+      of historical evidence.
+
+- [ ] **Step 2: Run the RED proof.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/contract/retired-concept-audit.test.mjs
+  ```
+
+  Expected: FAIL because the fixture/checker has only the historical-main layer.
+
+- [ ] **Step 3: Implement the versioned fixture and checker.** Preserve every
+      historical row byte-for-byte as provenance. Add the rc layer, make the checker
+      print both layers, and make only a complete passing rc layer satisfy phase
+      exit. Keep the existing in-spec 144-path inventory digest authoritative.
+
+- [ ] **Step 4: Classify every ledger row against the untouched rc baseline.** Use a
+      detached worktree at the recorded SHA. For each row, identify the baseline
+      owner and run the exact focused contract. A setup failure remains proof-pending;
+      author a test-only proof before classifying a gap. Do not copy production code
+      from historical evidence.
+
+- [ ] **Step 5: Put CI orchestration in a script.** If the workflow needs more than
+      `npm run check:concept-audit`, add or modify a checked-in `.mjs` or `.sh` file
+      and have Actions invoke it. Do not place an inline program in the workflow.
+
+- [ ] **Step 6: Run the GREEN proof and integrity checks.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib run check:concept-audit
+  npm --prefix crates/trusted-server-js/lib test -- --run test/contract/retired-concept-audit.test.mjs
+  git diff --check
+  ```
+
+  Expected: PASS; all 23 rc rows are final and reproducible.
+
+- [ ] **Step 7: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json crates/trusted-server-js/lib/scripts/check-retired-concept-audit.mjs crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs crates/trusted-server-js/lib/package.json .github/workflows/test.yml
+  git commit -m "Classify TSJS concepts against the rc baseline"
+  ```
+
+### Task 1: Reconcile the overlapping rc changes before new behavior
+
+**Files:**
+
+- Modify only if a demonstrated gap exists: rc-overlapping files named by the Task
+  0 owner paths
+- Test: `crates/trusted-server-core/src/publisher.rs`
+- Test: `crates/trusted-server-core/src/integrations/gpt.rs`
+- Test: `crates/trusted-server-core/src/integrations/gpt_diagnostics.rs`
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/`
+- Test: `crates/trusted-server-js/lib/test/integrations/datadome/`
+
+- [ ] **Step 1: Run the rc overlap contracts before editing.** Cover #1008 template
+      enablement/cache policy, #1013 C2/ESI assembly, #1025/#1032 diagnostics, #1034
+      GAM attribution, #992 DataDome exclusions, and all existing adapter-parity
+      contracts. Record owner and pass/gap in Task 0's rc rows.
+
+- [ ] **Step 2: Resolve demonstrated gaps only.** The design supersedes #1008 only
+      by making `creative_opportunities.enabled` required. Preserve C2/ESI,
+      diagnostics, GAM attribution, DataDome, CLI/admin/SSAT debug/response-cache,
+      and EdgeZero behavior without broad refactoring.
+
+- [ ] **Step 3: Run focused Rust and JS regressions.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" publisher
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::gpt
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::gpt_diagnostics
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/module.test.ts test/integrations/gpt_diagnostics test/integrations/datadome
+  ```
+
+  Expected: PASS. If no gap required a production edit, mark the task verified and
+  do not create an empty commit.
+
+- [ ] **Step 4: Re-verify the already-landed direct-development toolchain upgrade.**
+      Confirm the lockfile uses the newest stable mutually compatible TypeScript,
+      `typescript-eslint`, ESLint, Vitest, Vite, esbuild, Prettier, jsdom, and Node
+      declarations supported by the repository-pinned Node major. Keep
+      `prebid.js@10.26.0` exact. Require a clean install, peer-clean dependency tree,
+      strict typecheck, lint, tests, build, and external-Prebid verification; update
+      package files test-first only if the current lockfile no longer satisfies that
+      contract.
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib ci
+  npm --prefix crates/trusted-server-js/lib ls --all
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib test
+  npm --prefix crates/trusted-server-js/lib run build:prebid-external
+  ```
+
+## Phase 1 — One immutable boot snapshot and one parser-time runtime
+
+### Task 2: Emit the exact typed integration-config carrier
+
+**Files:**
+
+- Modify: `crates/trusted-server-core/src/tsjs.rs`
+- Modify: `crates/trusted-server-core/src/integrations/registry.rs`
+- Modify: `crates/trusted-server-core/src/html_processor.rs`
+- Modify as needed for explicit browser projections:
+  `crates/trusted-server-core/src/integrations/{aps,datadome,didomi,google_tag_manager,gpt,lockr,osano,permutive,prebid,sourcepoint,testlight}.rs`
+- Test: colocated Rust tests in the files above
+
+- [ ] **Step 1: Add failing serialization/admission tests.** Require
+      `IntegrationConfigsV1 {version:1,entries}` with the exact ordered id union
+      `aps, datadome, didomi, google_tag_manager, gpt, lockr, osano, permutive,
+prebid, sourcepoint, testlight`. Emit each enabled product once, omit disabled
+      products, emit APS `{}` when enabled, and reject a manifest/config predicate
+      mismatch. Prove secrets, credentials, server endpoints, cookies, auth headers,
+      and private policy have no browser projection type.
+
+- [ ] **Step 2: Run the RED Rust tests.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" tsjs::tests
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::registry::tests
+  ```
+
+  Expected: FAIL because `TsjsBootV1` has no `integrations` field.
+
+- [ ] **Step 3: Implement explicit typed projections.** Build config from existing
+      typed rc settings during registry construction, not request-time reflection.
+      Serialize once inside `TsjsBootV1`; do not create integration-config script
+      tags or `window.__tsjs_*` globals. Keep creative and diagnostics in their
+      dedicated typed boot fields.
+
+- [ ] **Step 4: Enforce server-side caps and exactness.** Reject more than 11
+      entries, wrong order/duplicates, invalid JSON values, depth above 16, more than
+      4,096 values, strings/keys above 4,096 UTF-8 bytes, one entry above 65,536
+      canonical bytes, or the carrier above 524,288 bytes.
+
+- [ ] **Step 5: Run GREEN and adapter-facing Rust regressions.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" tsjs::tests
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::registry::tests
+  cargo test-cloudflare
+  cargo test-spin
+  cargo fmt --all -- --check
+  ```
+
+  Expected: PASS.
+
+- [ ] **Step 6: Commit.**
+
+  ```bash
+  git add crates/trusted-server-core/src/tsjs.rs crates/trusted-server-core/src/integrations/registry.rs crates/trusted-server-core/src/html_processor.rs crates/trusted-server-core/src/integrations
+  git commit -m "Add typed TSJS integration boot configuration"
+  ```
+
+### Task 3: Validate, copy, freeze, and attenuate boot configuration
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/core/types.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/bootstrap.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/release_catalog.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/integration_registry.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/runtime.ts`
+- Modify: `crates/trusted-server-js/lib/src/shared/first_display_contracts.ts`
+- Modify: `crates/trusted-server-js/lib/src/shared/first_display_handoff.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/agent.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/slices/*.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/*/module.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/{osano,permutive,sourcepoint}/*.ts`
+- Test: `crates/trusted-server-js/lib/test/core/bootstrap.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/{integration_registry,runtime,release_catalog}.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/{agent,handoff,slices}.test.ts`
+- Test: integration module tests under `crates/trusted-server-js/lib/test/integrations/`
+
+- [ ] **Step 1: Add failing exact-shape and hostile-object tests.** At the complete
+      runtime/public object-form boundaries, cover all caps from Task 2 plus
+      accessors, symbols, sparse arrays, custom prototypes, cycles, repeated aliases,
+      non-finite numbers, UTF-8 boundaries, throwing traps, and copy/freeze failure.
+      Require validation before effects and `abi_mismatch` on failure. Task 15A
+      separately hard-cuts the production inline wire to canonical JSON text.
+
+- [ ] **Step 2: Add failing immutable-snapshot tests.** Mutate/replace the public boot
+      target after bootstrap capture and prove the parsed lexical payload is never
+      reread. Agent,
+      prepared runtime, deferred modules, and final `tsjs.boot` must all observe the
+      same recursively frozen copy and canonical config digest. Handoff carries the
+      digest, never a recopy of config.
+
+- [ ] **Step 3: Add failing attenuation tests.** Each catalog module receives only
+      its product's exact config, or the dedicated creative/diagnostics field, or
+      `undefined` when catalogued as none. A module cannot read the complete map.
+      Later modules share the same product value, not a second entry.
+
+- [ ] **Step 4: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/core/bootstrap.test.ts test/kernel/integration_registry.test.ts test/kernel/runtime.test.ts test/kernel/release_catalog.test.ts test/first_display/agent.test.ts test/first_display/handoff.test.ts test/first_display/slices.test.ts
+  ```
+
+- [ ] **Step 5: Implement admission and catalog binding.** At object-form boundaries,
+      use own property descriptors only, copy into ordinary objects/arrays,
+      recursively freeze, retain the closure snapshot, calculate the canonical
+      digest, and pass only the catalog-declared value to first-display slices and
+      integration preparation. Delete raw per-integration bootstrap globals and
+      activation attributes. Task 15A later removes this full validator graph from
+      the trusted production lexical transport without weakening these boundaries.
+
+- [ ] **Step 6: Add exact typed validators in each product module.** Unknown or
+      missing fields and manifest/config inclusion mismatches are `abi_mismatch`;
+      there are no silent browser-data defaults.
+
+- [ ] **Step 7: Run GREEN plus all module tests.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/core/bootstrap.test.ts test/kernel test/first_display test/integrations
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  ```
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src crates/trusted-server-js/lib/test
+  git commit -m "Validate and attenuate immutable TSJS boot configuration"
+  ```
+
+### Task 4: Make no-agent takeover preparation synchronous
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/kernel/integration_registry.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/runtime.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/bootstrap.ts`
+- Modify: every takeover registration in `crates/trusted-server-js/lib/src/integrations/**`
+- Modify: `crates/trusted-server-js/lib/src/composition/browser_test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/{integration_registry,runtime}.test.ts`
+- Test: every affected module test
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts`
+
+- [ ] **Step 1: Add failing registration-shape tests.** A takeover registration has
+      exactly six keys and requires both callable `prepareSync` and `prepare`; a
+      deferred registration has exactly five keys and only `prepare`. Reject missing,
+      extra, inherited, accessor-backed, wrong-phase, or Promise/thenable-returning
+      synchronous entry points.
+
+- [ ] **Step 2: Add failing no-yield ordering tests.** On a no-agent page, assert one
+      classic parser-blocking evaluation performs every `prepareSync`, then every
+      synchronous `activate`, then kernel commit before publisher parser work,
+      microtasks, timers, network, or callbacks. Check the monotonic deadline before
+      and after every activation and before commit.
+
+- [ ] **Step 3: Add failing agent-takeover tests.** Post-paint takeover uses only
+      `prepare`, may await effect-inert work, and adopts parser-time obligations
+      without installing a competing guard/listener/attribution owner.
+
+- [ ] **Step 4: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel/integration_registry.test.ts test/kernel/runtime.test.ts test/first_display/takeover.test.ts
+  ```
+
+- [ ] **Step 5: Implement the discriminated registration ABI and execution modes.**
+      Share pure construction behind the two takeover entry points. Do not allow a
+      detached continuation, activation during preparation, or a second activation.
+      Keep all request-capable/SDK/network work behind `afterCommit`.
+
+- [ ] **Step 6: Add `prepareSync` to every takeover module.** Preserve module order,
+      interfaces, reverse-order rollback, and existing effect ownership. Do not add
+      `prepareSync` to deferred lifecycle/later modules.
+
+- [ ] **Step 7: Run GREEN and parser-order browser proof.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel test/integrations test/first_display/takeover.test.ts
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-integration-tests/browser test -- --project=chromium tests/shared/tsjs-runtime.spec.ts
+  ```
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src crates/trusted-server-js/lib/test crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts
+  git commit -m "Activate no-agent TSJS synchronously"
+  ```
+
+## Phase 2 — Harden APS containment and top-page ownership
+
+### Task 5: Hard-cut the renderer route to the v2 materialization bootstrap
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.schema.json`
+- Modify: `crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.json`
+- Modify: `crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json`
+- Modify: `scripts/generate-aps-renderer-contract.mjs`
+- Modify generated: `crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js`
+- Delete generated: `crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v1.html`
+- Create generated: `crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html`
+- Modify: `crates/trusted-server-core/src/integrations/aps.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `scripts/integration-tests-aps-runner-proxy.sh`
+- Modify: `crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs`
+- Test: `crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs`
+- Test: colocated APS Rust tests
+- Test: `scripts/integration-tests-aps-runner-proxy.sh`
+
+- [ ] **Step 1: Add failing renderer response tests.** The v2 HTTP response is an
+      immutable descriptor-free materialization bootstrap with exact CSP, content
+      type, cache, nosniff, no-referrer, no X-Frame-Options, and exact initial
+      sandbox. It accepts only its `b1_` fragment and one canonical v2 policy
+      configuration from the exact parent. It embeds TS-authored templates, the ES5
+      validator, and the fixed runner-proxy path, but no concrete descriptor value,
+      vendor bytes, publisher DOM authority, or pre-navigation network operation.
+
+- [ ] **Step 2: Add failing route/security tests.** APS-enabled final publisher
+      responses append an independent `Content-Security-Policy: frame-ancestors
+'self'`; operator CSP cannot replace it. Disabled APS, wrong methods, unknown
+      versions, and the abandoned versioned runner route remain exact local failures
+      and never fall through.
+
+- [ ] **Step 3: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib run check:aps-contract
+  node --test crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::aps::tests
+  ```
+
+- [ ] **Step 4: Update the single renderer generator and generated contract.** Keep
+      the schema's `x-*` semantic markers documentary; generator code remains the
+      enforcement authority. Generate deterministic ES5-compatible v2 bootstrap
+      bytes, reuse the shared corpus across Rust, TypeScript, and Node tests, delete
+      the v1 body, and serve v1 as an unknown local `404` with no compatibility path.
+
+- [ ] **Step 5: Preserve the live runner proxy exactly.** Keep its fixed target,
+      credential/referrer stripping, duplicate-header evidence, identity encoding,
+      8 MiB cap, exact media types, five-second total transport deadline, unchanged
+      successful bytes, local empty 502 failures, and four-adapter parity. Do not
+      store runner bytes or add a success cache header.
+
+- [ ] **Step 6: Make the Cloudflare/Wrangler readiness proof exact.** Before the
+      adversarial corpus starts, require two consecutive
+      `PROPFIND /integrations/aps/renderer/v2` responses with the complete local 405
+      contract, including `Allow: GET` and `Cache-Control: no-store`. Any other
+      result resets the consecutive count. Implement this in the actual adapter
+      harness `crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs`;
+      the shell wrapper only builds/selects the runtime. Keep the corpus's own later,
+      independent PROPFIND assertion; do not change production request handling.
+
+- [ ] **Step 7: Run GREEN across generator and adapters.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib run generate:aps-contract
+  npm --prefix crates/trusted-server-js/lib run check:aps-contract
+  node --test crates/trusted-server-js/lib/test/contract/aps-renderer-es5.test.mjs
+  cargo test-fastly integrations::aps::tests
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::aps::tests
+  cargo test-cloudflare
+  cargo test-spin
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime axum
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime fastly
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime cloudflare
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime spin
+  ```
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.schema.json crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.json crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1-corpus.json scripts/generate-aps-renderer-contract.mjs scripts/integration-tests-aps-runner-proxy.sh crates/trusted-server-integration-tests/tests/aps_runner_proxy.rs crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v1.html crates/trusted-server-core/src/integrations/aps.rs crates/trusted-server-core/src/publisher.rs
+  git commit -m "Hard-cut APS rendering to the v2 bootstrap"
+  ```
+
+### Task 6: Materialize the exact APS data documents after first action
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/shared/aps_documents.ts`
+- Modify: `scripts/generate-aps-renderer-contract.mjs`
+- Modify generated: `crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts`
+- Modify: `crates/trusted-server-js/lib/src/adapters/messaging.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/aps/render.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/leaf/aps_protocol.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/aps/documents.test.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/aps/render.test.ts`
+- Test: `crates/trusted-server-js/lib/test/adapters/messaging.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/slices.test.ts`
+
+- [ ] **Step 1: Add failing template tests.** Have the v2 server bootstrap generate
+      detached documents only after it receives the first-action policy message, using
+      independent `b1_` and `n1_` nonces, exact origin validation, exact permanent
+      sandbox order, sentinel-once substitution, context escaping, and separate
+      65,536-byte pre-encoding caps. The outer document contains only origins,
+      nonces, sandbox, and encoded inner template; it contains no descriptor or
+      lifecycle authority.
+
+- [ ] **Step 2: Add failing conditional-CSP tests.** For iframe creatives, only the
+      Trusted Server origin is an external script source at both inheritance levels.
+      For explicitly enabled script creatives, add exactly the validated creative
+      HTTPS origin to `script-src` at both levels. Never emit the union policy for an
+      iframe creative. The publisher origin cannot be a creative frame target.
+
+- [ ] **Step 3: Add failing channel tests.** Outer accepts the exact inner
+      `WindowProxy`/`n1_` readiness once, then transfers port1 inward and port2 to the
+      checked top parent. Inner accepts only port1 from its exact outer parent and
+      then one exact `ApsDocumentEnvelopeV1 {version,nonce,publisherOrigin,renderer}`.
+      Reject unknown keys, wrong prototypes, accessors, wrong ports/sources/nonces,
+      replays, and oversized messages before effects.
+
+- [ ] **Step 4: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/aps/documents.test.ts test/integrations/aps/render.test.ts test/adapters/messaging.test.ts test/first_display/slices.test.ts
+  ```
+
+- [ ] **Step 5: Implement build-time document materialization and exact parsers.**
+      Keep the templates and ES5 validator as generator/test authorities, emit them
+      into the server-owned v2 response, and remove them from both first-display and
+      persistent production TSJS graphs. The top page sends only exact nonces,
+      creative origin, and tag type; no descriptor or generated URL crosses that
+      channel. The inner
+      clears its fragment, queues the APS event with one-shot resolve/reject, loads
+      only the same-origin proxy with anonymous CORS/no-referrer, treats script load
+      as progress, and sends completion/failure only on callback settlement.
+
+- [ ] **Step 6: Run GREEN, typecheck, lint, and architecture checks.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/aps test/adapters/messaging.test.ts test/first_display/slices.test.ts
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib run check:architecture
+  ```
+
+- [ ] **Step 7: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src/shared/aps_documents.ts crates/trusted-server-js/lib/src/integrations/aps crates/trusted-server-js/lib/src/core/contracts/aps_renderer.ts crates/trusted-server-js/lib/src/adapters/messaging.ts crates/trusted-server-js/lib/src/first_display crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs scripts/generate-aps-renderer-contract.mjs crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html crates/trusted-server-js/lib/test
+  git commit -m "Materialize APS documents after first action"
+  ```
+
+### Task 7: Mount direct APS through the three-phase top-page protocol
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/integrations/aps/render.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/render.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/render_bridge.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/identity.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/aps/render.test.ts`
+- Test: `crates/trusted-server-js/lib/test/services/render.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/render_bridge.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/identity.test.ts`
+
+- [ ] **Step 1: Add failing nonce-registry tests.** `b1_` and `n1_` are distinct
+      CSPRNG roles with two independent live-only registries capped at 256 entries,
+      eight collision retries, one-use phase checks, and no cross-role acceptance.
+      Cover independent 255/256/257 boundaries and collision exhaustion. Neither
+      registry creates a tombstone or expiry entry: attempt disposal removes both
+      live entries, the bootstrap listener, and the renderer channel, while exact
+      source/port/attempt/generation checks make late work inert.
+
+- [ ] **Step 2: Add failing direct-mount state-machine tests.** Create only the
+      bootstrap iframe initially. Require exact node/parent/src/WindowProxy/
+      generation/nonce checks before sandbox mutation and the v2 policy-only
+      configuration message, then exact materialized outer
+      readiness and one port before sending the envelope. Enforce one-second
+      insertion, one shared three-second document deadline, and the kernel-owned
+      ten-second completion deadline beginning at document acceptance.
+
+- [ ] **Step 3: Add failing outcome/disposal tests.** Completion alone accepts;
+      runner load is progress. Map script/CORS/proxy load to `runner_no_load`, reject
+      to `runner_failed`, malformed/timeout to the specified reason. Abort,
+      supersession, navigation, port error, and late/replayed messages settle once,
+      close channels, clear timers, and remove only the pending mount.
+
+- [ ] **Step 4: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel/identity.test.ts test/integrations/aps/render.test.ts test/services/render.test.ts test/first_display/render_bridge.test.ts
+  ```
+
+- [ ] **Step 5: Implement the shared top-page mount service for direct APS.** Keep
+      descriptor validation before DOM mutation, permanent sandbox after bootstrap
+      readiness, policy-only server materialization after first action, exact winning
+      size/layout, and one terminal latch. Direct mount is an ordinary child and does
+      not acquire overlay styling.
+
+- [ ] **Step 6: Run GREEN and adjacent direct-ADM regressions.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel/identity.test.ts test/integrations/aps test/services/render.test.ts test/first_display/render_bridge.test.ts test/first_display/adm_render_bridge.test.ts
+  ```
+
+- [ ] **Step 7: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src/integrations/aps crates/trusted-server-js/lib/src/services/render.ts crates/trusted-server-js/lib/src/first_display/render_bridge.ts crates/trusted-server-js/lib/src/kernel/identity.ts crates/trusted-server-js/lib/test
+  git commit -m "Mount direct APS through the top-page owner"
+  ```
+
+### Task 8: Cut PUC APS over to protocol v4 top mounts
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/puc_shell.ts`
+- Modify: `crates/trusted-server-js/lib/src/adapters/messaging.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/puc_bridge.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/slots.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/render.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt/module.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/{render_bridge,leaf/aps_protocol}.ts`
+- Modify: `crates/trusted-server-js/lib/src/composition/browser_test.ts`
+- Test: corresponding unit tests
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts`
+
+- [ ] **Step 1: Add failing v4 protocol tests.** The PUC outer response contains
+      only renderer version `4`, the TS dynamic owner, and ready/refused owner
+      metadata. Remove `rendererUrl`, descriptor, ADM, nonce, and old APS-start
+      payloads. The dynamic owner performs only helper registration, the 20-second
+      control watchdog, and Promise settlement; it never creates an APS iframe.
+
+- [ ] **Step 2: Add failing exact top-slot binding tests.** The authenticated PUC
+      `WindowProxy` is never mapped to DOM. Resolve the reservation's exact
+      `SlotRecord`, physical GPT object, active cycle, generation, uniquely connected
+      top-page slot element, and binding epoch. Revalidate before insertion and
+      commit; missing, ambiguous, replaced, disconnected, stale, or multiply claimed
+      binding fails `slot_unresolved` without a fallback locator.
+
+- [ ] **Step 3: Add failing overlay tests.** Append one absolute hidden child inside
+      the exact slot host. Compare-own `position:relative` only when computed position
+      is static. Keep GAM/PUC/SafeFrame content connected. Document acceptance and
+      runner load stay hidden; only valid render completion reveals and commits the
+      overlay. Failure removes only TS state and compare-restores only still-owned
+      styles.
+
+- [ ] **Step 4: Add failing owner-control tests.** Kernel sends only
+      `TS APS Top Mount Started` informational control data, then exactly one final
+      `TS Owner Settled`. Abort remains attempt-owned. Malformed data, messageerror,
+      silent channel, watchdog, disposal, or replay rejects once; settlement-post
+      throw cannot alter kernel outcome. Keep PUC ADM on its existing exact owner
+      protocol.
+
+- [ ] **Step 5: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel/contracts/puc_dynamic_owner.test.ts test/services/puc_bridge.test.ts test/services/slots.test.ts test/services/render.test.ts test/integrations/gpt/module.test.ts test/first_display/render_bridge.test.ts test/adapters/messaging.test.ts
+  ```
+
+- [ ] **Step 6: Implement v4 and delete old protocol fields.** Do not retain an alias
+      or parser branch for the prior renderer version. Do not vendor PUC or add its
+      bytes to fixtures; use only the locally authored public-contract harness.
+
+- [ ] **Step 7: Run GREEN including browser lifecycle.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/kernel/contracts/puc_dynamic_owner.test.ts test/services test/integrations/gpt/module.test.ts test/first_display test/adapters/messaging.test.ts
+  npm --prefix crates/trusted-server-integration-tests/browser test -- --project=chromium tests/shared/aps-puc-lifecycle.spec.ts
+  ```
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src crates/trusted-server-js/lib/test crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts
+  git commit -m "Move PUC APS rendering to top-page mounts"
+  ```
+
+### Task 9: Give committed APS overlays one exact retirement owner
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/adapters/googletag.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/slots.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/render.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt/{module,later}.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/adapters/googletag.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/{agent,render_bridge}.ts`
+- Test: corresponding unit tests
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts`
+- Test: `crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts`
+
+- [ ] **Step 1: Add failing cycle-retirement tests.** The earliest sole GPT
+      `slotRequested` listener classifies origin before later listeners. Publisher,
+      competing, or ambiguous cycles synchronously retire the old overlay before the
+      callback returns. An exactly attributable TS replacement retains the old
+      artifact until the new one commits; a failed replacement keeps it visible.
+
+- [ ] **Step 2: Add failing destruction tests.** Wrap publisher-originated
+      `destroySlots` without changing receiver, arguments, order, return, or throw.
+      Snapshot exact live objects before forwarding and retire only after successful
+      return; omitted args cover all live objects. False/throw keeps connected
+      artifacts intact.
+
+- [ ] **Step 3: Add failing DOM-integrity tests.** Disconnect/replacement of host,
+      removal/reparenting of the exact overlay, navigation, or exact artifact
+      replacement retires once. Remove the TS node wherever it moved, compare-restore
+      only owned style/targeting, never traverse/remove publisher children, destroy
+      publisher GPT objects, or repeat PUC settlement.
+
+- [ ] **Step 4: Run RED, implement the shared exact-once latch, and rerun GREEN.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/adapters/googletag.test.ts test/services/slots.test.ts test/services/render.test.ts test/integrations/gpt/module.test.ts test/integrations/gpt/later.test.ts test/first_display/gpt_adapter.test.ts test/first_display/render_bridge.test.ts
+  ```
+
+- [ ] **Step 5: Run browser refresh/navigation proof.**
+
+  ```bash
+  npm --prefix crates/trusted-server-integration-tests/browser test -- --project=chromium tests/shared/aps-puc-lifecycle.spec.ts tests/nextjs/navigation.spec.ts
+  ```
+
+- [ ] **Step 6: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src crates/trusted-server-js/lib/test crates/trusted-server-integration-tests/browser/tests/shared/aps-puc-lifecycle.spec.ts crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts
+  git commit -m "Retire committed APS overlays exactly once"
+  ```
+
+## Phase 3 — Preserve rc behavior behind the final owners
+
+### Task 10: Make creative-opportunity enablement an explicit hard-cutover switch
+
+**Files:**
+
+- Modify: `crates/trusted-server-core/src/creative_opportunities.rs`
+- Modify: `crates/trusted-server-core/src/settings.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `crates/trusted-server-core/src/auction/endpoints.rs`
+- Modify: `trusted-server.example.toml`
+- Modify: `docs/guide/configuration.md`
+- Modify: inline configuration fixtures in the Rust owners above containing
+  `[creative_opportunities]`; this worktree has no separate fixture file
+- Test: colocated Rust tests
+
+- [ ] **Step 1: Add failing config tests.** A present table requires an explicit
+      boolean `enabled`; omission fails. Absence of the table remains valid. Disabled
+      configuration still parses and validates every slot/cache/assembly field.
+
+- [ ] **Step 2: Add failing behavior tests.** `enabled=false` suppresses publisher
+      matching, initial projection, automatic auction, slot injection, SPA init, and
+      page-bids delivery; page-bids returns the exact empty result. Direct
+      `POST /auction` remains live under ordinary auction gates.
+
+- [ ] **Step 3: Add failing cache-policy tests.** A successful inactive publisher
+      HTML GET receives `max-age=60` unless origin cache control contains `private`
+      or `no-store` case-insensitively. Preserve validators and surrogate/CDN policy
+      on inactive output; keep private/no-store and validator stripping for injected
+      per-navigation state. Non-HTML, failures, and direct auction are unchanged.
+
+- [ ] **Step 4: Run RED, implement the required field/gates, update every fixture,
+      update the official configuration guide and every fixture, and run GREEN.**
+      The guide's active and inactive examples must state `enabled` explicitly and
+      must not describe an empty slot list as the implicit enablement switch.
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" creative_opportunities
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" publisher
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" auction::endpoints
+  cargo test-fastly creative_opportunities
+  cargo fmt --all -- --check
+  ```
+
+- [ ] **Step 5: Commit.**
+
+  ```bash
+  git add crates/trusted-server-core/src/creative_opportunities.rs crates/trusted-server-core/src/settings.rs crates/trusted-server-core/src/publisher.rs crates/trusted-server-core/src/auction/endpoints.rs trusted-server.example.toml docs/guide/configuration.md
+  git commit -m "Require explicit creative opportunity enablement"
+  ```
+
+### Task 11: Preserve GPT diagnostics as a self-contained public contract
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/core/types.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt/diagnostics_facts.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/{api,data_api,store,slot_size_observer,badges,overlay,module}.ts`
+- Modify: `crates/trusted-server-core/src/integrations/gpt_diagnostics.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `docs/guide/integrations/gpt-diagnostics.md`
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/`
+- Test: `crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts`
+
+- [ ] **Step 1: Add failing public-type and data tests.** The design file is the
+      complete authority; public types do not import an older diagnostics spec.
+      Preserve exact callbacks, binding, request path, identities, response class,
+      issues, counters, privacy, caps, copied/frozen exports, and asynchronous
+      one-entry latest-snapshot notifications.
+
+- [ ] **Step 2: Add failing three-size tests.** Keep
+      `requestedSlotSizes` (copied/frozen, max 16 integer 1..4096 tuples), GPT
+      `size`, and fractional/nonnegative `observedSlotSize` distinct in store,
+      snapshot, badges, overlay, and export. Publisher/native requests never inherit
+      stale requested evidence. Cover refresh/rebind/navigation/observer/disposal
+      races and no-ResizeObserver fallback.
+
+- [ ] **Step 3: Add failing `ts_console` session tests.** Exact case-sensitive
+      `1|true` enables and `0|false` disables on eligible GET navigation; duplicates
+      or unknown values fail closed. Strip the reserved directive before publisher
+      handling, keep the HttpOnly host-only session, and expose no query/referrer/
+      cookies/targeting/creative data.
+
+- [ ] **Step 4: Run RED, implement demonstrated gaps, and run GREEN.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt_diagnostics test/integrations/gpt/diagnostics_facts.test.ts
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::gpt_diagnostics
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" publisher
+  npm --prefix crates/trusted-server-integration-tests/browser test -- --project=chromium tests/nextjs/gpt-diagnostics.spec.ts
+  ```
+
+- [ ] **Step 5: Commit only if production changed.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/src/core/types.ts crates/trusted-server-js/lib/src/integrations/gpt crates/trusted-server-js/lib/src/integrations/gpt_diagnostics crates/trusted-server-js/lib/test/integrations/gpt crates/trusted-server-js/lib/test/integrations/gpt_diagnostics crates/trusted-server-core/src/integrations/gpt_diagnostics.rs crates/trusted-server-core/src/publisher.rs crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts docs/guide/integrations/gpt-diagnostics.md
+  git commit -m "Preserve GPT diagnostics through the runtime cutover"
+  ```
+
+### Task 12: Move GAM attribution into the sole GPT owner
+
+**Files:**
+
+- Modify: `crates/trusted-server-core/src/integrations/gpt.rs`
+- Modify: `crates/trusted-server-core/src/tsjs.rs`
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt/module.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/slices/gpt.ts`
+- Delete obsolete raw-bootstrap transport from `crates/trusted-server-core/src/publisher.rs` if present
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/slices.test.ts`
+- Test: colocated Rust tests
+
+- [ ] **Step 1: Add failing order/idempotence tests.** The typed GPT boot config
+      carries `gamAttributionEnabled`, default false. Enabled pages enqueue exactly
+      one `googletag.setConfig({targeting:{ts:'true'}})` in parser-time activation
+      before publisher GPT commands, including preexisting `adInit`. No-agent uses
+      synchronous activation; agent takeover adopts the already-installed obligation
+      without a second call.
+
+- [ ] **Step 2: Add failing lifecycle tests.** Attribution persists through initial,
+      lazy, publisher-owned, refresh, Prebid refresh, and SPA requests. Neither
+      refresh nor cleanup clears page-level `ts`; targeting API absence/throw is
+      isolated. Disabled mode has zero side effects.
+
+- [ ] **Step 3: Run RED, implement one owner, and delete the raw global flag,
+      activation attribute, and duplicate fallback path.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations::gpt::tests
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations/gpt/module.test.ts test/first_display/slices.test.ts test/integrations/prebid/later.test.ts
+  ```
+
+- [ ] **Step 4: Commit.**
+
+  ```bash
+  git add crates/trusted-server-core/src/integrations/gpt.rs crates/trusted-server-core/src/tsjs.rs crates/trusted-server-core/src/publisher.rs crates/trusted-server-js/lib/src/integrations/gpt/module.ts crates/trusted-server-js/lib/src/first_display/slices/gpt.ts crates/trusted-server-js/lib/test
+  git commit -m "Make GPT own parser-time GAM attribution"
+  ```
+
+### Task 13: Lock the remaining rc GPT, Prebid, cache, and integration behavior
+
+**Files:**
+
+- Modify only for demonstrated gaps: integration modules and focused tests under
+  `crates/trusted-server-js/lib/src/integrations/` and
+  `crates/trusted-server-js/lib/test/integrations/`
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/module.test.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/prebid/{module,later}.test.ts`
+- Test: all remaining integration suites
+
+- [ ] **Step 1: Add or run the named RCJ-GPT-04 collapsed-shell unit step.** Resize
+      only the exact authenticated, connected, ordinary collapsed iframe after a
+      successful TS PUC response. Do not require same-origin access: the source
+      identity, width/height attributes, computed dimensions, current attempt, and
+      ordinary non-fixed/non-sticky shell checks are the authority. Reject anchor/
+      fixed/sticky/disconnected/already-expanded/unrelated frames and preserve
+      publisher styles outside the narrow guard.
+
+- [ ] **Step 2: Add or run the RCJ-PREBID-04 focused step.** Rebuild the Prebid
+      refresh GAM-path exclusion in `prebid_later`; prove no initial-admission
+      ownership, no native-bid interference, and no duplicate refresh.
+
+- [ ] **Step 3: Preserve PBS Cache as a black box.** Run exact rc request, parse,
+      macro, PUC response, failure reason, and collapsed-resize fixtures. The generic
+      mutable `setConfig/getConfig` runtime API stays deleted by the hard cutover;
+      cache parity must not retain or reintroduce it. Do not route cache IDs into
+      APS/ADM reservations or add new cache policy, deadline, schema, or endpoint.
+
+- [ ] **Step 4: Run the complete remaining-integration parity suite.** Cover
+      DataDome, Didomi, GTM, Lockr, Osano, Permutive, Sourcepoint, Testlight, Creative,
+      disposal, maximal catalog order, and throw isolation.
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  ```
+
+- [ ] **Step 5: Commit only demonstrated gaps.** Use a sentence-case subject naming
+      the behavior actually changed; do not create an empty parity commit.
+
+## Phase 4 — Browser, security, build, and release evidence
+
+### Task 14: Prove the four-level APS browser contract
+
+**Files:**
+
+- Modify: `crates/trusted-server-integration-tests/browser/fixtures/fictional-aps-runner.js`
+- Modify: `crates/trusted-server-integration-tests/browser/helpers/{gpt-stub,gam-test-network,tsjs-fixture}.ts`
+- Modify: `crates/trusted-server-integration-tests/browser/tests/shared/{aps-renderer,aps-puc-lifecycle,tsjs-runtime}.spec.ts`
+- Modify: `crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts`
+- Modify: `docs/guide/integrations/aps.md`
+
+- [ ] **Step 1: Extend the locally authored fictional harness.** Implement only the
+      public queue/resolve/reject behavior; never copy or store vendor bytes. Expose
+      the exact PUC release value `1.17.2` in protected test API metadata without
+      vendoring PUC.
+
+- [ ] **Step 2: Add Chromium/Firefox/WebKit containment tests.** Assert top slot ->
+      bootstrap/outer mount -> inner renderer -> descendant creative ancestry,
+      independent nonces, opaque data origins, exact sandbox/CSP pairs, no publisher
+      regain, no PUC/GAM/SafeFrame ancestor, exact ports/sources, and no descriptor in
+      bootstrap/outer/PUC payloads.
+
+- [ ] **Step 3: Add the required script-creative enforcement cases in every
+      browser.** Prove an iframe-policy document refuses external creative script,
+      an explicitly enabled same-origin script creative executes under the exact
+      script policy, and a cross-origin redirect or final script origin is refused.
+      Keep script creatives default-off and verify that enabling one origin never
+      broadens iframe creatives or another origin.
+
+- [ ] **Step 4: Add layout and visibility tests.** At every boundary fixture size,
+      all four levels have exact width/height/client/scroll dimensions, zero default
+      margins/overflow, and no clipping. The overlay stays hidden through acceptance
+      and runner load and becomes visible only on completion.
+
+- [ ] **Step 5: Add adversarial lifecycle tests.** Cover wrong source/origin/nonce/
+      port, replay, duplicate keys, malformed UTF-8 boundaries, timeout, runner
+      silence/reject/load-only, abort, navigation, host replacement, node movement,
+      publisher/competing/ambiguous cycles, successful/failed destroy, TS replacement
+      success/failure, and exact-once settlement/disposal.
+
+- [ ] **Step 6: Run the hermetic browser matrix.**
+
+  ```bash
+  npm --prefix crates/trusted-server-integration-tests/browser test -- tests/shared/aps-renderer.spec.ts tests/shared/aps-puc-lifecycle.spec.ts tests/shared/tsjs-runtime.spec.ts tests/nextjs/navigation.spec.ts --project=chromium --project=firefox --project=webkit
+  ```
+
+- [ ] **Step 7: Update operator docs.** State that APS browser routes are anonymous
+      reserved routes, platform shielding owns rate limits, runner bytes are live/
+      unversioned/unvendored/unpinned/uncached by Trusted Server, successful proxy
+      responses have no TS cache promise, APS can be disabled for containment, and
+      PUC 1.17.2 is configured outside this repository.
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add crates/trusted-server-integration-tests/browser docs/guide/integrations/aps.md
+  git commit -m "Prove APS top-mount containment in browsers"
+  ```
+
+### Task 15: Retarget bundle and performance gates to the exact rc PR base
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs`
+- Modify: `crates/trusted-server-js/lib/test/build/release-v1.test.mjs`
+- Modify: `crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json` only by appending the new candidate layer; never rewrite historical subtrees
+- Modify: `scripts/validate-tsjs-performance-evidence.mjs`
+- Modify: `scripts/ci/tsjs-performance.sh`
+- Modify: `scripts/ci/aps-tsjs-evidence.mjs`
+- Create: `scripts/ci/dispatch-aps-tsjs-gate.mjs`
+- Create: `scripts/ci/dispatch-aps-tsjs-gate.test.mjs`
+- Modify: `crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts`
+- Modify: `crates/trusted-server-integration-tests/browser/playwright.performance.config.ts`
+- Modify: `.github/workflows/tsjs-performance-gate.yml`
+- Modify: `.github/workflows/test.yml`
+
+- [ ] **Step 1: Add failing schema/base tests.** Replace moving-main inputs with an
+      exact `baseSha`/`baseline` identity. On PRs use `pull_request.base.sha`; manual
+      and called runs require the same explicit input. Verify the commit is 40 lower-
+      hex characters and reachable from fetched `origin/rc/202608`. Never derive a
+      fallback from candidate HEAD or a moving branch name.
+      Add a required `base_sha` input to manual/called workflow entrypoints and bind
+      PR runs directly to `pull_request.base.sha` as `TSJS_PERF_BASE_SHA`. Bind
+      `TSJS_PERF_HEAD_SHA` to `pull_request.head.sha`; neither writer nor validator
+      may read `GITHUB_SHA`, which names the synthetic PR merge commit.
+
+- [ ] **Step 2: Add failing legacy/phase-aware baseline-loader tests.** A detached
+      worktree builds the real artifact model at the exact base: legacy core+
+      creative+GPT where applicable, or release-v1 controller/artifacts after
+      cutover. Compare the same semantic first-action interval without demanding
+      candidate-only metadata from a legacy base.
+
+- [ ] **Step 3: Enforce all absolute and relative gates.** Keep immutable historical
+      and remediation captures report-only. Pin these independent raw/gzip/Brotli
+      ceilings exactly: bootstrap `48,000/16,000/14,000`; every permitted
+      first-display mask `90,000/30,000/26,000`; persistent reference
+      `524,288/163,840/131,072`; maximal non-bootstrap total
+      `1,048,576/327,680/262,144`. Require and name the minimal
+      `[first_display]`, GPT reference
+      `[first_display,creative_initial,gpt_initial,prebid_initial,datadome_initial]`,
+      and APS
+      `[first_display,render_owner_initial,aps_initial,creative_initial,gpt_initial]`
+      masks, plus the largest admitted mask per encoding. Record the complete
+      inline-plus-agent semantic transfer as diagnostic context. Require the GPT
+      candidate's one selected external agent to be no larger than the exact rc-base
+      selected agent in raw, gzip, and Brotli; allow the APS selected agent at most
+      the exact rc-base selected agent × 1.10 in each encoding. Keep the controller's
+      independent `48,000/16,000/14,000` ceiling and require both GPT and APS
+      candidate first-action p90 to be at most the exact rc base × 1.10 so the paired
+      timing measurement covers controller and agent transfer/parse end to end.
+
+      Pin the APS absolute table: bids-script→first GPT action p90 ≤900 ms; first
+      action→accepted completion p90 ≤1,500 ms; accepted completion→paint p90 ≤250
+      ms; bids-script→paint p90 ≤2,500 ms; forced-GC post-paint used size ≤3,145,728
+      bytes; post-takeover/queue-drain used size ≤3,932,160 bytes. Both variants in
+      the paired GPT case remain below 4,194,304 bytes at boot, first render, refresh,
+      and SPA navigation. Require real User Timing marks and no persistent/deferred request,
+      preload, prepare, or execution before paint.
+      The production source graph must prove that neither first-display nor
+      persistent artifacts reach `shared/aps_documents.ts` or the document-form ES5
+      validator; those authorities exist only in the generator and contract tests.
+      The mandatory APS + creative + GPT first-display mask must pass the unchanged
+      90,000/30,000/26,000 raw/gzip/Brotli ceilings.
+
+- [ ] **Step 4: Keep CI logic in scripts.** Workflow YAML may set immutable inputs,
+      install toolchains, and invoke checked-in scripts. Put Git ancestry validation,
+      worktree creation, build selection, sampling, and evidence validation in
+      `.sh`/`.mjs` files. Rename step labels from current-main to rc baseline.
+
+      Add a checked-in operator dispatch helper with exact `performance` and
+      `real-gam` subcommands. Before dispatch it requires a clean worktree and proves
+      the named remote branch resolves to local HEAD. It generates a unique bounded
+      evidence id from gate kind, HEAD, UTC time, and random suffix; records the
+      dispatch start; invokes `gh workflow run`; polls for exactly one run matching
+      workflow, exact evidence id, exact head SHA, and creation time; watches that
+      run; downloads the exact expected artifact; and invokes the owning validator.
+      `real-gam` derives `release_id` from the clean local artifact and requires only
+      the operator-owned rollback artifact id locally. The protected workflow—not
+      local shell—compares that release id with its environment-owned expected value.
+      Unit-test command construction, uniqueness, zero/multiple/stale-run rejection,
+      remote-HEAD mismatch, artifact naming, and validator invocation with an
+      injected fake command runner.
+
+      The performance job is fixed to Chromium `145.0.7632.6`, the
+      `github-hosted:ubuntu-24.04` runner class,
+      `tsjs-baseline-paired-network-v3` (150 ms, 200,000 bytes/s down, 93,750 bytes/s
+      up, zero loss), five warmups and 50 measured samples per variant, alternating
+      baseline/candidate order, a 40-minute browser budget, a 50-minute job budget,
+      exactly one post-sample candidate lifecycle observation, and separate paired
+      heap contexts. Add focused validator tests for every literal and reject an
+      environment override.
+
+- [ ] **Step 5: Run local self-tests and prove the intentional pre-remediation
+      RED.** Validator/schema/dispatch unit tests and the build must be GREEN. The
+      exact selected-agent-transfer and APS admission checks against the untouched
+      candidate are expected RED for the recorded revision-43 bytes/timing; preserve
+      that failure as the gate contract. Do not weaken membership, a threshold, or a
+      fixture to make Task 15 green. Tasks 15A/15B are the remediation, and Task 15B
+      Step 7 is the first required full acceptance GREEN.
+
+  ```bash
+  node scripts/validate-tsjs-performance-evidence.mjs --self-test
+  node --test scripts/ci/dispatch-aps-tsjs-gate.test.mjs
+  npm --prefix crates/trusted-server-js/lib run build
+  npm --prefix crates/trusted-server-js/lib run check:bundle
+  npm --prefix crates/trusted-server-js/lib run test:release
+  npm --prefix crates/trusted-server-js/lib run check:architecture
+  ```
+
+- [ ] **Step 6: Commit the gate and dispatch contract before any remote run.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs crates/trusted-server-js/lib/test/build/release-v1.test.mjs crates/trusted-server-js/lib/test/fixtures/performance/aps-tsjs-prechange.json scripts/validate-tsjs-performance-evidence.mjs scripts/ci/tsjs-performance.sh scripts/ci/aps-tsjs-evidence.mjs scripts/ci/dispatch-aps-tsjs-gate.mjs scripts/ci/dispatch-aps-tsjs-gate.test.mjs crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts crates/trusted-server-integration-tests/browser/playwright.performance.config.ts .github/workflows/tsjs-performance-gate.yml .github/workflows/test.yml
+  git commit -m "Compare TSJS performance with the exact rc base"
+  ```
+
+### Task 15A: Replace the production boot object graph with a sealed JSON transport
+
+**Files:**
+
+- Create: `crates/trusted-server-js/lib/src/core/contracts/server_boot_transport.ts`
+- Create: `crates/trusted-server-js/lib/src/core/contracts/sha256.ts`
+- Create: `crates/trusted-server-js/lib/src/core/contracts/bounded_string.ts`
+- Create: `crates/trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json`
+- Move: `crates/trusted-server-js/lib/src/core/release_capacity.ts` to
+  `crates/trusted-server-js/lib/src/kernel/contracts/release_capacity.ts`
+- Modify: `crates/trusted-server-core/src/creative.rs`
+- Modify: `crates/trusted-server-core/src/html_processor.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `crates/trusted-server-core/src/test_support.rs`
+- Modify: `crates/trusted-server-core/src/tsjs.rs`
+- Modify: `crates/trusted-server-js/lib/src/core/bootstrap.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/auction_projection.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/boot.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/integration_configs.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/index.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/registry.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/types.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/fallback.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/integration_registry.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/runtime.ts`
+- Modify: `crates/trusted-server-js/lib/src/services/context.ts`
+- Modify: `crates/trusted-server-js/lib/vite.config.ts`
+- Modify: `crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs`
+- Modify: `crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts`
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts`
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts`
+- Test: `crates/trusted-server-js/lib/test/core/bootstrap.test.ts`
+- Test: `crates/trusted-server-js/lib/test/core/index.test.ts`
+- Test: `crates/trusted-server-js/lib/test/core/request.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/fallback.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/integration_registry.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/runtime.test.ts`
+- Test: `crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs`
+- Test: `crates/trusted-server-js/lib/test/build/release-v1.test.mjs`
+- Test: `crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs`
+- Test: colocated `crates/trusted-server-core/src/tsjs.rs` tests
+
+- [ ] **Step 1: Add the RED production-transport tests.** Require Rust to emit one
+      inline lexical JSON string containing exact
+      `{version:1,boot,integrity,outline}` and no
+      object-form `__TSJS_SERVER_BOOT_INPUT_V1__`, raw boot global, compatibility
+      alias, or executable source value. Parse the emitted fragment in the test and
+      prove exact release, manifest, projection, carrier, creative, diagnostics,
+      always-present boot-integrity digests, the exact
+      `outline:null | TakeoverOutlineV1` union and non-null equality, escaping, and 10
+      MiB decoded-size behavior. Pin a shared Rust/JavaScript ECMAScript
+      `JSON.stringify` corpus covering negative zero, fixed/exponent thresholds,
+      IEEE-754 rounding, integer-index key ordering, and nested combinations so the
+      producer and verifier hash identical admitted bytes.
+
+- [ ] **Step 2: Add the RED compact-parser and graph tests.** Define the wished-for
+      `snapshotServerBootTransportV1(payload, releaseId)` contract. A canonical valid
+      string returns one recursively frozen fresh snapshot; malformed JSON, wrong or
+      extra root keys, release mismatch, bad first-display URL/mask/slices, bad
+      runtime URL, more than 14 takeover entries, a deferred source not bound to its
+      declared id, missing/malformed boot integrity, outline parity/count/digest
+      form or integrity mismatch, invalid dedicated booleans, or an oversized string
+      returns `undefined` before effects. Boundary-valid takeover counts and exact
+      deferred id/source pairs remain accepted. A direct-runtime snapshot has
+      `outline:null` but retains the integrity value. Add RED runtime/handoff tests
+      proving direct boot recomputes both digests, and takeover requires recomputed
+      boot = integrity = outline = handoff. Projection and integration-config
+      mismatches independently produce `abi_mismatch` before preparation,
+      activation, or publication; a valid carrier succeeds on both paths. At both
+      direct and takeover runtime boundaries, accessors are never invoked and custom
+      prototypes, symbols, sparse arrays, repeated aliases, or any mutable nested
+      manifest/projection/carrier/diagnostics value fail immediately. The release
+      metafile must prove `bootstrap` no longer reaches `core/contracts/boot.ts`,
+      `core/contracts/auction_projection.ts`, or
+      `core/contracts/integration_configs.ts`.
+
+      The generated fallback tests require the exact safe manifest, empty
+      `integrations:{version:1,entries:[]}`, empty fallback auction projection,
+      disabled creative/diagnostics defaults, every `requestAds` and `addAdUnits`
+      call refusing with the same classified unavailable reason without reading its
+      input, the same frozen reason in internal state,
+      both `initialDisplayCommitted` values, exact FIFO queue drain, accepted-DOM
+      preservation, no pending call, no artifact retry, and both
+      `abi_mismatch`/`bundle_partial` classifications. Fallback never needs the full
+      projection or public request validator. Full request validation belongs only
+      to a committed kernel. The persistent-core graph must consume a generated numeric manifest
+      capacity and exclude the build-time release catalog.
+
+- [ ] **Step 3: Run RED and inspect the expected failures.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" tsjs::tests
+  npm --prefix crates/trusted-server-js/lib test -- --run test/core/bootstrap.test.ts test/kernel/runtime.test.ts test/first_display/handoff.test.ts test/first_display/takeover.test.ts
+  node --test crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs
+  npm --prefix crates/trusted-server-js/lib run test:release
+  ```
+
+  Expected: the Rust shape still emits the object graph, the compact parser is
+  absent, and the bootstrap metafile still reaches the full validators.
+
+- [ ] **Step 4: Implement the minimal sealed transport.** Canonicalize and validate
+      in Rust, normalize the admitted projection and every generic configuration to
+      ECMAScript `JSON.stringify`-equivalent bytes, hash and embed those exact bytes,
+      serialize the payload once, escape it as a JS string, and keep `window.tsjs`
+      target acquisition outside the JSON. Do not hash raw `serde_json` spellings:
+      negative zero, exponent formatting, and integer-index key enumeration are
+      observably different in JavaScript. In the compact parser, use the parsed fresh
+      tree, perform only revision-43 critical release/manifest/integrity/outline
+      checks, recursively freeze, and return one snapshot.
+      Do not accept object form or move executable code into the payload.
+
+- [ ] **Step 5: Rewire only the production bootstrap.** Import the compact parser,
+      replace the generic config lookup with an exact scan over the already-frozen
+      ordered entries, and retain the full `snapshotTsjsBootV1` validators for core,
+      public, and test boundaries. First-display batch and slice validators remain
+      authoritative before their effects. Persistent core recomputes the canonical
+      projection and integration-config SHA-256 digests before direct use or handoff
+      adoption and compares them with the always-present integrity value; the
+      controller validates only exact digest form and outline/integrity relations.
+      Reuse the existing pure manifest validator and full auction-projection parser
+      in persistent core, validate the generic carrier there without importing its
+      bootstrap-hostile object graph, and split the synchronous SHA-256 primitive
+      into an effect-free leaf shared by the two boundaries. On rejection after the
+      one-use exact-source-authenticated claim, invoke its one-use completion
+      capability with `abi_mismatch` during the current runtime-script task; do not
+      let the watchdog later relabel a validation failure as `bundle_partial`. The
+      claim reserves a closure-private `claiming` state before any mutable DOM or
+      realm authentication boundary, and completion validates with primitive string
+      comparisons and consumes its guard before invoking a handler; reentrant claim
+      or completion cannot obtain or consume the capability twice. In
+      takeover mode, the persistent runtime never publishes fallback itself: it
+      reports preparation/activation failure through the same completion capability,
+      and the bootstrap owner alone preserves accepted DOM, snapshots
+      `initialDisplayCommitted`, disposes the agent, and commits fallback. Direct mode
+      retains the persistent runtime's existing terminal-fallback ownership.
+
+- [ ] **Step 6: Run GREEN and adjacent hard-cutover checks.**
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" tsjs::tests
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" html_processor::tests
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" injects_tsjs_creative_when_body_present
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" c2_reader_seam_inserts_one_complete_hard_cutover_boot
+  npm --prefix crates/trusted-server-js/lib test -- --run test/core/bootstrap.test.ts test/kernel/runtime.test.ts test/first_display
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib run build
+  npm --prefix crates/trusted-server-js/lib run test:release
+  npm --prefix crates/trusted-server-js/lib run check:hard-cutover-absence
+  npx --prefix crates/trusted-server-integration-tests/browser playwright test --list tests/shared/tsjs-runtime.spec.ts tests/shared/creative-sandbox.spec.ts
+  ```
+
+- [ ] **Step 7: Measure rather than infer transfer improvement.** Read the generated
+      bootstrap raw/gzip/Brotli values and its complete source-owner list. If the
+      graph exclusions pass but the bootstrap exceeds its independent ceiling or the
+      served GPT selected agent cannot fit beneath the exact rc selected agent, stop
+      and revisit the architecture instead of adding mangling or changing membership.
+      Keep the aggregate inline-plus-agent interval as diagnostic context and retain
+      the paired end-to-end timing gate. Generate the manifest-entry capacity as a
+      build constant so persistent core does not import the release catalog for one
+      number; assert both catalog exclusion and intentional tree-shaking of the
+      declaration module in the release metafile.
+
+- [ ] **Step 8: Commit.**
+
+  ```bash
+  git add -A docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md docs/superpowers/plans/2026-08-04-aps-tsjs-resilience-implementation.md crates/trusted-server-core/src/creative.rs crates/trusted-server-core/src/html_processor.rs crates/trusted-server-core/src/publisher.rs crates/trusted-server-core/src/test_support.rs crates/trusted-server-core/src/tsjs.rs crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts crates/trusted-server-js/lib/src/core crates/trusted-server-js/lib/src/kernel/contracts/release_capacity.ts crates/trusted-server-js/lib/src/kernel/fallback.ts crates/trusted-server-js/lib/src/kernel/integration_registry.ts crates/trusted-server-js/lib/src/kernel/runtime.ts crates/trusted-server-js/lib/src/services/context.ts crates/trusted-server-js/lib/vite.config.ts crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs crates/trusted-server-js/lib/test/fixtures/contracts/ecmascript-json-stringify-v1.json crates/trusted-server-js/lib/test/core/bootstrap.test.ts crates/trusted-server-js/lib/test/core/index.test.ts crates/trusted-server-js/lib/test/core/request.test.ts crates/trusted-server-js/lib/test/kernel/fallback.test.ts crates/trusted-server-js/lib/test/kernel/integration_registry.test.ts crates/trusted-server-js/lib/test/kernel/runtime.test.ts crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs crates/trusted-server-js/lib/test/build/release-v1.test.mjs crates/trusted-server-js/lib/test/contract/retired-concept-audit.test.mjs
+  git commit -m "Seal the production TSJS boot transport"
+  ```
+
+### Task 15B: Add the shared render-owner slice and thin the APS slice
+
+**Files:**
+
+- Create: `crates/trusted-server-js/lib/src/first_display/render_journal.ts`
+- Create: `crates/trusted-server-js/lib/src/first_display/slices/render_owner.ts`
+- Create: `crates/trusted-server-js/lib/test/first_display/helpers/render_owner_composition.ts`
+- Delete: `crates/trusted-server-js/lib/src/first_display/adm_render_bridge.ts`
+- Modify: `crates/trusted-server-core/src/auction/formats.rs`
+- Modify: `crates/trusted-server-core/src/integrations/registry.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `crates/trusted-server-core/src/tsjs.rs`
+- Modify: `crates/trusted-server-js/build.rs`
+- Modify: `crates/trusted-server-js/src/bundle.rs`
+- Modify: `crates/trusted-server-js/lib/src/first_display/agent.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/composition.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/render_bridge.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/leaf/aps_protocol.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/slices/*.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/bootstrap.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/boot.ts`
+- Modify: `crates/trusted-server-js/lib/src/core/contracts/server_boot_transport.ts`
+- Modify: `crates/trusted-server-js/lib/src/integrations/render_runtime/module.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/contracts/puc_dynamic_owner.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/integration_registry.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/release_catalog.ts`
+- Modify: `crates/trusted-server-js/lib/src/shared/first_display_transaction.ts`
+- Modify: `crates/trusted-server-js/lib/src/shared/first_display_registration.ts`
+- Modify: `crates/trusted-server-js/lib/src/shared/first_display_contracts.ts`
+- Modify: `crates/trusted-server-js/lib/build-all.mjs`
+- Modify: `crates/trusted-server-js/lib/scripts/bundle-metrics.mjs`
+- Modify: `crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs`
+- Modify: `crates/trusted-server-js/lib/scripts/print-release-id.mjs`
+- Modify: `scripts/validate-tsjs-performance-evidence.mjs`
+- Modify: `crates/trusted-server-integration-tests/browser/helpers/tsjs-fixture.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/{agent,adm_render_bridge,render_bridge,slices}.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/transaction.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/contracts.test.ts`
+- Test: `crates/trusted-server-js/lib/test/core/bootstrap.test.ts`
+- Test: `crates/trusted-server-js/lib/test/integrations/render_runtime/module.test.ts`
+- Test: `crates/trusted-server-js/lib/test/kernel/release_catalog.test.ts`
+- Test: `crates/trusted-server-js/lib/test/services/puc_bridge.test.ts`
+- Test: `crates/trusted-server-js/lib/test/build/generated-fallback.test.mjs`
+- Test: `crates/trusted-server-js/lib/test/build/release-v1.test.mjs`
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/{aps-renderer,aps-puc-lifecycle,tsjs-performance,tsjs-runtime}.spec.ts`
+
+- [ ] **Step 1: Add RED catalog, selection, and source-ownership tests.** Add
+      `render_owner_initial` as catalog order 2 and shift the remaining optional
+      slices by one. Enumerate exactly 3,584 reachable 14-bit masks. Select the slice
+      exactly for an ADM or APS reservation; require it for `aps_initial`; omit it
+      from no-bid/nonrendering masks. It owns one frozen source-neutral render-journal
+      interface for attempt collection, terminal latching, reservation/ticket state,
+      v4 PUC owner control, committed-artifact identity, handoff capture, detachment,
+      and exact-once retirement. `aps_initial` composes that interface and has no
+      second full journal/bridge implementation. The only APS-specific branch admitted
+      to the shared owner is the exact authority-free informational
+      `TS APS Top Mount Started` control message after APS kernel/top-mount start;
+      non-APS masks cannot reach APS descriptors, URLs, nonce registries,
+      renderer-document parsing, mount code, or top-mount policy. ADM-only masks still
+      receive the self-contained v4 owner. Assert exact catalog order 1–14 and the
+      implications APS ⇒ render owner ⇒ GPT, ADM ⇒ render owner without APS, and
+      no-bid/nonrendering ⇒ no render owner. Pin the server masks `0001` no-bid,
+      `0081` attribution-only, `0083` ADM, `008b` creative ADM, `0087` APS, `008f`
+      creative APS, and `1083` Prebid ADM. Reject an APS participation fact when APS
+      is not enabled. Update the Rust build consumer, generated Rust inventory,
+      release-id printer, persistent manifest capacity, and all slice registration
+      orders from 13/35 to 14/36 rather than leaving a dead build scalar or a stale
+      hard-coded index.
+
+- [ ] **Step 2: Add RED parity tests before extracting code.** Run the same journal
+      corpus against ADM-only, APS-only, and mixed APS/ADM batches. Cover accepted,
+      failed, cancelled, empty-GAM fallback, replacement success/failure, moved or
+      mutated nodes, navigation, handoff, post-detach reentrancy, overlay-lease
+      transfer, targeting restoration, and final retirement. Include the first-display
+      APS adoption → persistent APS replacement → final-retirement sequence and the
+      publisher-owned PUC handoff. Keep the old harness shape only in a test helper
+      that composes the neutral journal with the APS strategy; production has no
+      compatibility wrapper. The new tests must fail only because a shared base
+      journal is not yet exposed.
+
+- [ ] **Step 3: Add RED compact-owner tests.** Keep the exact successful/refused v4
+      outer shapes and the complete current adversarial corpus, while requiring the
+      checked-in dynamic owner to remain self-contained and contain no `fetch`,
+      dynamic import, script insertion, blob/worker loader, URL, descriptor, or APS
+      DOM authority. Exercise registration timeout/refusal/replay, port errors,
+      nested publisher callbacks, ADM insertion, APS informational start, settlement,
+      and Promise behavior through the actual serialized program. The release/static-
+      route test must also prove `render_owner_initial` is concatenated into the one
+      served mask body, has no independently routable/requested production asset, and
+      can create no script, preload, fetch, dynamic-import, worker, or blob request
+      before paint. Measure the browser-observed call-time boundary, not a potentially
+      backdated `PerformanceResourceTiming.startTime`, and assert the exact request
+      sequence document → selected first-display artifact → persistent runtime.
+
+- [ ] **Step 4: Run RED.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/first_display/agent.test.ts test/first_display/adm_render_bridge.test.ts test/first_display/render_bridge.test.ts test/first_display/slices.test.ts test/first_display/transaction.test.ts test/first_display/contracts.test.ts test/kernel/release_catalog.test.ts test/services/puc_bridge.test.ts test/build/release-v1.test.mjs
+  ```
+
+- [ ] **Step 5: Extract one render-owner slice and journal.** Replace—not wrap—the
+      common ADM/APS maps, reservation/ticket state, v4 PUC dispatcher/owner control,
+      terminal latch, committed artifact journal, mutation notification, handoff/
+      detach state, timers, and retirement bookkeeping. Expose only the exact frozen
+      operations the APS protocol needs through the release-private slice host. Keep
+      APS descriptor parsing, nonce registries, document parser, mount policy, and
+      overlay behavior in `aps_initial`. Instantiate exactly one journal during
+      render-owner activation, pass its one-use private capability through the base
+      host to APS, and let the render-owner slice disposer own it. The APS protocol
+      may import the neutral interface as a type only; the owner must have no runtime
+      dependency on APS.
+
+- [ ] **Step 6: Compact the dynamic owner in place.** Deduplicate its exact record,
+      event/port, timer, and terminal helpers without removing checks or changing a
+      message. Preserve the single self-contained `renderer` string and the existing
+      64 KiB/72 KiB caps; do not load another asset and do not rely on cross-artifact
+      property mangling.
+
+- [ ] **Step 7: Run GREEN, build, and inspect the actual APS mask.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib test -- --run test/first_display test/services/puc_bridge.test.ts test/integrations/aps test/services/render.test.ts test/build/release-v1.test.mjs
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib run build
+  npm --prefix crates/trusted-server-js/lib run check:bundle
+  node scripts/validate-tsjs-performance-evidence.mjs --self-test
+  node --test scripts/ci/dispatch-aps-tsjs-gate.test.mjs
+  npm --prefix crates/trusted-server-js/lib run test:release
+  npm --prefix crates/trusted-server-js/lib run check:architecture
+  ```
+
+  Expected: every focused behavior is unchanged, the production graph has one
+  render journal, and the exact mandatory APS mask remains admitted. If the combined
+  selected-agent bytes still exceed their rc comparator, stop and revisit the
+  approved split rather than weakening a gate. The aggregate inline-plus-agent bytes
+  remain recorded context and the inline controller still must pass its independent
+  ceiling. The release proof must
+  show 36 artifacts, 14 first-display rows, 3,584 reachable masks, the exact
+  generated admitted subset, a largest admitted first-display body no greater than
+  90,000/30,000/26,000 raw/gzip/Brotli bytes, and a maximal total that excludes the
+  bootstrap role.
+
+- [ ] **Step 8: Run the three-browser focused lifecycle proof.** In
+      `tsjs-runtime.spec.ts`, assert exactly one parser-blocking first-display TSJS
+      request before paint, no separately routed render-owner asset, and no script,
+      preload, fetch, dynamic-import, worker, or blob request from that owner.
+
+  ```bash
+  npm --prefix crates/trusted-server-integration-tests/browser test -- tests/shared/aps-renderer.spec.ts tests/shared/aps-puc-lifecycle.spec.ts tests/shared/tsjs-runtime.spec.ts --project=chromium --project=firefox --project=webkit
+  ```
+
+- [ ] **Step 9: Commit.**
+
+  ```bash
+  git add -A
+  git commit -m "Thin the APS first-display owner"
+  ```
+
+### Task 15C: Consolidate bootstrap and first-display base ownership
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/src/core/bootstrap.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/agent.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/registration_client.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/release_catalog.ts`
+- Modify: `crates/trusted-server-js/lib/build-all.mjs`
+- Modify: `crates/trusted-server-js/build.rs`
+- Modify: `crates/trusted-server-js/src/bundle.rs`
+- Modify: `crates/trusted-server-core/src/tsjs.rs`
+- Modify: `crates/trusted-server-core/src/publisher.rs`
+- Modify: `crates/trusted-server-js/lib/scripts/bundle-metrics.mjs`
+- Modify: `crates/trusted-server-js/lib/scripts/check-bundle-budgets.mjs`
+- Test: `crates/trusted-server-js/lib/test/core/bootstrap.test.ts`
+- Test: `crates/trusted-server-js/lib/test/first_display/agent.test.ts`
+- Test: `crates/trusted-server-js/lib/test/build/{generated-fallback,release-v1}.test.mjs`
+- Test: colocated `crates/trusted-server-core/src/{tsjs,publisher}.rs` tests
+- Test: `crates/trusted-server-integration-tests/browser/tests/shared/{tsjs-performance,tsjs-runtime}.spec.ts`
+
+- [ ] **Step 1: Add RED physical-ownership and route tests.** Keep the 14-bit
+      logical first-display catalog and exact mask order, but require
+      `first_display` to have physical owner `bootstrap`, no separately served
+      implementation, and no independently routable static asset. Assert that an
+      `008b` response is exactly render owner + creative + GPT initial bytes in
+      catalog order, with the base implementation present only in the inline
+      bootstrap graph. Reject a release where both bootstrap and the marker reach
+      base coordinator source, or where bootstrap reaches APS/GPT/creative/PUC or
+      another optional slice.
+
+- [ ] **Step 2: Add RED one-owner lifecycle tests.** Drive the generated bootstrap
+      followed by a selected slice response and prove one generation owns component
+      registration, action start, terminal/paint, queue ingress, fallback, and
+      takeover. Cover missing/partial selected bytes, duplicate or out-of-order slice
+      registration, reentrant registration/disposal, accepted DOM preservation, and
+      exact-once handoff. Assert there is no second base registration, controller,
+      timer, observer, or disposer.
+
+- [ ] **Step 3: Implement the minimal consolidation.** Move the source-neutral base
+      coordinator into the bootstrap physical graph and delete the separate base
+      registration path. Retain `first_display` as a release-stamped non-routable
+      logical marker so mask/capability ordering remains stable. Build and serve one
+      selected response containing optional slices only. Share one closure-private
+      generation and disposer stack; do not bridge two controllers or move code into
+      transport data.
+
+- [ ] **Step 4: Run focused GREEN and measure.** Run bootstrap, first-display,
+      release, static-route, typecheck, architecture, and bundle tests. Then run the
+      exact rc semantic comparator. If any raw/gzip/Brotli value still exceeds rc,
+      inspect the consolidated source graph and remove only duplicated owner state;
+      do not change the fixture, mask membership, baseline, or threshold.
+
+- [ ] **Step 5: Run full verification and commit.** Run the Task 15B three-browser
+      lifecycle proof, complete JS/Rust quality scripts, exact performance sample,
+      and clean-worktree checks before committing and pushing one replacement SHA.
+
+### Task 15D: Seal runtime admission and preserve the publisher script-policy chain
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/build-all.mjs`
+- Modify: `crates/trusted-server-js/lib/src/core/{bootstrap,index}.ts`
+- Modify: `crates/trusted-server-js/lib/src/first_display/registration_client.ts`
+- Modify: `crates/trusted-server-js/lib/src/kernel/phase_loader.ts`
+- Modify: `crates/trusted-server-core/src/{html_processor,publisher,tsjs}.rs`
+- Modify: `crates/trusted-server-core/src/integrations/{registry,datadome,prebid}.rs`
+- Modify: `crates/trusted-server-core/benches/html_processor_bench.rs`
+- Modify: `crates/trusted-server-js/lib/test/core/{index,request}.test.ts`
+- Modify: `crates/trusted-server-js/lib/test/build/{generated-fallback,release-v1}.test.mjs`
+- Modify: `crates/trusted-server-js/lib/test/kernel/phase_loader.test.ts`
+- Create: `crates/trusted-server-integration-tests/browser/tests/shared/tsjs-policy.spec.ts`
+- Modify: `crates/trusted-server-integration-tests/browser/tests/shared/tsjs-runtime.spec.ts`
+- Modify: `scripts/ci/aps-tsjs-cutover.sh`
+- Modify: `.github/workflows/integration-tests.yml`
+
+- [ ] **Step 1: Add RED admission-boundary tests.** Require the generated persistent
+      artifact's first expression to consume a one-read, non-configurable
+      `window.tsjs` gate and the selected script node's own non-configurable
+      `_claimRuntimeV1` before any core or module initializer. The exact frozen claim
+      is `{boot,integrity,complete,currentScript,source,target,mode,bind}`. Cover
+      replay, reentrant DOM authentication, wrong/disconnected/replaced source,
+      mutable/wrong-shape candidates, wrong mode, corrupted public
+      `document.currentScript`, and publisher/upstream mutation of realm intrinsics.
+      Prove ordinary namespace reads always retain the original target and only the
+      exact selected runtime task receives the script node once. Replace every test
+      harness that still reconstructs `_claimBootSnapshot`/`_claimDirectRuntime`.
+
+      For optional first-display slices, require one raw dense
+      `[1,id,releaseId,install]` carrier. Bootstrap must use its captured native
+      current-script/descriptor/array intrinsics, reserve registration before a
+      reentrant getter can run, authenticate the exact connected parser script,
+      freeze the carrier, retain only validated values, and reject wrong order,
+      duplicate, late, accessor, sparse, custom, or replayed registration.
+
+- [ ] **Step 2: Add RED server ordering and response-CSP tests.** Parse only
+      enforcing response headers using `script-src-elem` → `script-src` →
+      `default-src` precedence and select only one bounded nonce in the intersection
+      of nonce-bearing policies. Report-only, malformed, ambiguous, disjoint, and
+      meta-only values authorize no nonce. Thread the selected value through both
+      streaming and buffered HTML contexts. Prove exact output order
+      controller → live integration head inserts → selected TSJS artifact and the
+      same nonce on every Trusted Server executable tag, including DataDome's inline
+      plus external tags, Prebid's external tag, and request-scoped diagnostics.
+      Invalid input must emit no partial/escaped nonce attribute.
+
+- [ ] **Step 3: Add the RED-to-GREEN browser policy matrix.** In Chromium prove
+      direct self-source, matching response nonce, nonce-only, `strict-dynamic`, a
+      permitted named `trusted-server#tsjs-v1` policy, one exact-preserving default
+      policy fallback, mutation/throw/full block, missing deferred nonce, and
+      removed/replaced nodes. Prove the agent path creates the named policy only once
+      and leases it from persistent insertion to deferred loading. In all three
+      engines assert real first-display takeover, request/insertion outcomes, no
+      unauthorized diagnostics panel, and survival of the same committed kernel.
+      Keep exact `policy_blocked`/`load_error`/`registration_rejected` classification
+      in unit tests; do not add a production browser test seam for private enums.
+
+- [ ] **Step 4: Keep workflow behavior in checked-in scripts and run focused GREEN.**
+      Workflow YAML may select engines and invoke `scripts/ci/aps-tsjs-cutover.sh`;
+      policy setup, server lifecycle, and Playwright commands remain in repository
+      script files.
+
+  ```bash
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" controller_precedes_live_head_inserts_which_precede_selected_runtime
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" response_csp_nonce
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" head_injector_emits_external_bundle_script_with_hash_and_integrity
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" head_injector_emits_client_side_tag_when_key_configured
+  npm --prefix crates/trusted-server-js/lib test -- --run test/core/index.test.ts test/core/request.test.ts test/kernel/phase_loader.test.ts
+  npm --prefix crates/trusted-server-js/lib run build
+  npm --prefix crates/trusted-server-js/lib run test:release
+  npm --prefix crates/trusted-server-js/lib run check:hard-cutover-absence
+  TS_BROWSER_PROJECTS=chromium,firefox,webkit npx --prefix crates/trusted-server-integration-tests/browser playwright test tests/shared/tsjs-policy.spec.ts --project=chromium --project=firefox --project=webkit
+  ```
+
+- [ ] **Step 5: Commit the admission and policy chain.** Stage only the literal
+      files above after reviewing `git diff --check`; do not commit generated docs
+      temp/cache output.
+
+### Task 16: Enforce hard-cutover absence and supply-chain boundaries
+
+**Files:**
+
+- Modify: `crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs`
+- Modify: `crates/trusted-server-js/lib/test/eslint/no-adtech-globals.test.mjs`
+- Modify: `crates/trusted-server-js/lib/eslint-rules/no-adtech-globals.js`
+- Modify: `crates/trusted-server-js/lib/test/build/release-v1.test.mjs`
+- Modify: `scripts/ci/aps-tsjs-quality.sh`
+- Modify: `.github/workflows/test.yml`
+
+- [ ] **Step 1: Add failing absence tests.** Reject old renderer routes/version,
+      `rendererUrl` in v4 messages, old APS Start payloads, raw integration globals,
+      activation attributes, `TsjsApiV1`, compatibility aliases, second runtimes,
+      old public render/config APIs, and legacy globals/event names named in design
+      section 5.4.
+
+- [ ] **Step 2: Add failing vendor-byte scans.** Reject APS runner, GPT, or PUC
+      bytes, checksums, distributable artifacts, or stored vendor bodies in source,
+      dist, fixtures, or evidence. Permit only the required protected conformance
+      metadata `pucRelease: '1.17.2'`; it is not vendored code or a checksum. Keep the
+      pure lockfile-pinned Prebid artifact isolated and verify it contains no
+      auction/render behavior owned by TSJS.
+
+- [ ] **Step 3: Document static-analysis blind spots.** Note that dynamically
+      computed global keys and function-returned roots are not fully visible to the
+      ESLint rule; retain bundle/source scans and browser ownership tests as the
+      defense-in-depth layers.
+
+- [ ] **Step 4: Run RED, implement scripts/rules, and run GREEN.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib run check:hard-cutover-absence
+  npm --prefix crates/trusted-server-js/lib run test:architecture
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib run test:release
+  bash scripts/ci/aps-tsjs-quality.sh
+  ```
+
+- [ ] **Step 5: Commit.**
+
+  ```bash
+  git add crates/trusted-server-js/lib/scripts/check-hard-cutover-absence.mjs crates/trusted-server-js/lib/test/eslint/no-adtech-globals.test.mjs crates/trusted-server-js/lib/eslint-rules/no-adtech-globals.js crates/trusted-server-js/lib/test/build/release-v1.test.mjs scripts/ci/aps-tsjs-quality.sh .github/workflows/test.yml
+  git commit -m "Enforce final TSJS cutover boundaries"
+  ```
+
+## Phase 5 — Final rc refresh, verification, and PR
+
+### Task 17: Refresh `rc/202608` and rerun the overlap audit
+
+**Files:**
+
+- Modify only files conflicted by an advanced rc tip
+- Modify: `crates/trusted-server-js/lib/test/fixtures/contracts/current-main-concept-audit.json` rc layer
+- Modify: performance evidence inputs if the exact PR base changes
+
+- [ ] **Step 1: Require a clean, pushed task boundary, then fetch the release branch.**
+
+  ```bash
+  test -z "$(git status --porcelain)"
+  git fetch origin rc/202608
+  git merge --no-ff --no-commit origin/rc/202608
+  ```
+
+  If already an ancestor, abort the empty merge and record the no-op. If advanced,
+  resolve conflicts in favor of revision 44 where it explicitly supersedes rc and
+  otherwise in favor of rc. Do not merge `main` separately.
+
+- [ ] **Step 2: Produce an overlap inventory before committing.** For every
+      conflict or rc change touching TSJS, APS, publisher HTML, diagnostics,
+      integration config, build, or CI, name the final owner and focused test. Keep
+      EdgeZero and other excluded features unchanged.
+
+  Final refresh inventory for `07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf`:
+
+  | Rc overlap                                                   | Final disposition and owner                                                                                                                                                                                                                              | Focused proof                                                                                                        |
+  | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+  | APS provider, renderer, browser types, and guide             | Revision 44 supersedes the publisher-native experiment. `integrations/aps.rs`, `integrations/aps/render.ts`, and the shared render services retain one TS-owned renderer and the no-second-auction invariant.                                            | APS Rust tests, `test/integrations/aps/render.test.ts`, GPT/PUC ownership tests, hard-cutover scan                   |
+  | APS creative-frame scrollbar fix                             | Preserve the concept in the stronger proxy-owned documents: both document roots suppress overflow and the inner creative iframe is borderless, block-level, and full-size. No publisher-origin runner path is retained.                                  | APS document corpus, renderer unit suite, three-engine browser matrix                                                |
+  | Initial GPT scheduling one-shot and handoff latch            | Supersede both mutable `scheduleInitialAdInit` implementations. The authenticated first-display registration transaction accepts one exact ordered batch, deletes registration ingress before activation, and transfers one frozen handoff exactly once. | first-display transaction, bootstrap, agent, takeover, and handoff suites                                            |
+  | GPT diagnostics presentation review fixes                    | Preserve target-window scheduling, cancellable ownership, bounded badge size lists, shared size formatting, rounded observed boxes, destroyed-state guards, and record-currentness checks inside the data-only diagnostics owner.                        | GPT diagnostics binding, badge, overlay, slot-size, store, and public-type suites                                    |
+  | Shared-template delivery of initial work                     | Preserve rc's reader-specific delivery result while replacing its legacy scheduler call with the immutable boot projection and first-display agent transaction.                                                                                          | publisher/template assembly byte-identity tests, boot contract tests, first-display projection tests                 |
+  | Structural ad-template slot generation                       | Preserve rc's structural TOML update, contiguous provider tables, line-ending safeguards, and unmanaged-field check; add the required `enabled = true` only when the generator creates a hard-cutover section.                                           | focused `slot_toml` and CLI configuration suites                                                                     |
+  | GAM cohort attribution                                       | Preserve the configuration and reporting concept; supersede rc raw globals and the activation attribute with the frozen GPT config carrier and sole parser-time GPT owner.                                                                               | GPT Rust config tests, `tsjs.rs` selection tests, first-display GPT adapter/slice tests, persistent GPT module tests |
+  | GPT diagnostics correlation guide                            | Preserve the rc correlation evidence, rewritten to the immutable initial projection and navigation-internal page-bids projection.                                                                                                                        | GPT diagnostics store/API/data/overlay suites and docs format/build                                                  |
+  | Retired GPT bootstrap, request runtime, and legacy GPT tests | Keep the revision-44 deletions; no second runtime or compatibility file returns.                                                                                                                                                                         | hard-cutover scan, architecture test, release graph test                                                             |
+  | Docs TypeScript-ESLint update                                | Preserve rc package and lockfile ownership.                                                                                                                                                                                                              | docs install, lint, format, and build                                                                                |
+  | GPT operator wording and example config                      | Preserve rc's provider-neutral environment-overlay wording; do not add EdgeZero feature work.                                                                                                                                                            | docs format/build and config tests                                                                                   |
+  | Rc GAM review plan/spec artifacts                            | Preserve as release-branch documentation; they do not override revision 44's TSJS architecture.                                                                                                                                                          | docs format/build and plan-integrity scan                                                                            |
+  | Config-first auction providers                               | Preserve typed provider tables for direct `/auction`; do not use the test-only legacy provider map to prove production routing.                                                                                                                          | `direct_auction_remains_available_when_templates_are_disabled`                                                       |
+  | Edge-validated Basic auth and shared templates               | Preserve the rc cache behavior without adding a TSJS cache requirement. Only one unchanged authorization value marked by edge auth is reader-neutral; missing, repeated, or replaced values bypass.                                                      | auth middleware suites and `shared_template_authorization_requires_one_unchanged_edge_validated_value`               |
+  | First-party proxy allowlist enforcement                      | Preserve the server allowlist and carry its typed `blocked` result into the lifecycle-owned iframe/image guards. A policy denial never falls back to the rejected raw URL.                                                                               | proxy Rust suites and creative proxy-sign/image/iframe tests                                                         |
+  | First-impression token, refresh, and stale-creative repairs  | Supersede the mutable claim/global implementation with navigation-scoped slots, first-display GPT observation, transactional Prebid admission, pre-response attempt validation, and the authenticated nested-shell helper.                               | first-display driver/GPT/render-bridge, persistent GPT/Prebid, PUC bridge, and APS browser suites                    |
+  | Responsive/hydrated slot reconciliation                      | Supersede the standalone mutable resolver. Initial and persistent owners accept an exact element or one unambiguous non-container prefix; late handoff additionally validates path, sizes, connectivity, and exact physical replacement.                 | slot-service hydration, first-display GPT adapter/driver, and persistent GPT module tests                            |
+  | Rc secret, client-IP, CLI, and ad-template work              | Preserve the release-branch implementation and documentation unchanged except where its tests exercise the hard-cutover provider or HTML owners. No EdgeZero feature work is added.                                                                      | adapter, CLI, configuration, and full Rust gates                                                                     |
+
+- [ ] **Step 3: Update every rc-baseline row and rerun its exact proof.** No stale
+      SHA or prior pass satisfies the gate.
+
+- [ ] **Step 4: Run concept, package, and focused overlap checks.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib run check:concept-audit
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib test -- --run test/integrations test/kernel test/first_display
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" publisher
+  cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/^host: //p')" integrations
+  ```
+
+- [ ] **Step 5: Commit an actual rc integration only when the tip advanced.**
+      Stage each resolved conflict and refreshed audit/evidence file by its literal
+      path after reviewing `git status --short`; never use a broad path or placeholder
+      command. Then commit with subject `Integrate the latest rc baseline`.
+
+### Task 18: Run the complete verification matrix
+
+**Files:** no intended production changes; fix failures test-first in the owning task
+and rerun this task from the start.
+
+- [ ] **Step 1: Verify formatting and repository integrity.**
+
+  ```bash
+  cargo fmt --all -- --check
+  npm --prefix crates/trusted-server-js/lib run format
+  npm --prefix docs run format
+  git diff --check
+  ```
+
+- [ ] **Step 2: Verify TypeScript build, types, lint, contracts, and bundles.**
+
+  ```bash
+  npm --prefix crates/trusted-server-js/lib ci
+  npm --prefix crates/trusted-server-js/lib ls --all
+  npm --prefix crates/trusted-server-js/lib run typecheck
+  npm --prefix crates/trusted-server-js/lib run lint
+  npm --prefix crates/trusted-server-js/lib test
+  npm --prefix crates/trusted-server-js/lib run build
+  npm --prefix crates/trusted-server-js/lib run build:prebid-external
+  npm --prefix crates/trusted-server-js/lib run check:aps-contract
+  npm --prefix crates/trusted-server-js/lib run check:concept-audit
+  npm --prefix crates/trusted-server-js/lib run check:hard-cutover-absence
+  npm --prefix crates/trusted-server-js/lib run check:bundle
+  npm --prefix crates/trusted-server-js/lib run test:release
+  ```
+
+- [ ] **Step 3: Verify Rust and every runtime adapter.**
+
+  ```bash
+  cargo test-fastly
+  cargo test-axum
+  cargo test-cloudflare
+  cargo test-spin
+  cargo test --manifest-path crates/trusted-server-integration-tests/Cargo.toml --test parity
+  ./scripts/test-cli.sh
+  ```
+
+- [ ] **Step 4: Verify all target-matched clippy gates.**
+
+  ```bash
+  cargo clippy-fastly
+  cargo clippy-axum
+  cargo clippy-cloudflare
+  cargo clippy-cloudflare-wasm
+  cargo clippy-spin-native
+  cargo clippy-spin-wasm
+  ```
+
+- [ ] **Step 5: Verify APS proxy transport parity.**
+
+  ```bash
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime axum
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime fastly
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime cloudflare
+  ./scripts/integration-tests-aps-runner-proxy.sh --runtime spin
+  ```
+
+- [ ] **Step 6: Verify the hermetic browser matrix in all three engines.**
+
+  ```bash
+  bash scripts/ci/aps-tsjs-cutover.sh install-browsers
+  bash scripts/ci/aps-tsjs-cutover.sh run-browser
+  ```
+
+  The checked-in browser command includes `tests/shared/tsjs-policy.spec.ts`; no
+  multiline policy/server implementation is embedded in workflow YAML.
+
+- [ ] **Step 7: Push the exact locally verified candidate before remote gates.**
+      Require a clean worktree, confirm `origin/rc/202608` is the audited base, push
+      local HEAD to the named feature branch, and prove the remote ref equals local
+      HEAD. Any later code, workflow, script, evidence-validator, or rc-integration
+      change invalidates the remote evidence and restarts Task 18 from Step 1.
+
+  ```bash
+  test -z "$(git status --porcelain)"
+  git push origin HEAD:feature/aps-tsjs-resilience-rc202608
+  test "$(git rev-parse HEAD)" = "$(git ls-remote origin refs/heads/feature/aps-tsjs-resilience-rc202608 | awk '{print $1}')"
+  ```
+
+- [ ] **Step 8: Verify paired rc performance evidence on that exact remote HEAD.**
+      Preserve Chromium 145.0.7632.6, Ubuntu 24.04 class, the fixed network profile,
+      five warmups, 50 samples per variant, alternating order, one post-sample
+      lifecycle observation, and paired heap contexts. The helper generates and
+      records a unique evidence id, deterministically selects only the new run,
+      watches it, downloads its one immutable artifact, and validates exact evidence,
+      head, base, and mode bindings:
+
+  ```bash
+  node scripts/ci/dispatch-aps-tsjs-gate.mjs performance --ref feature/aps-tsjs-resilience-rc202608 --base-sha "$(git rev-parse origin/rc/202608)" --mode postswitch --output-dir target/aps-tsjs-final-performance
+  ```
+
+  Validation must finish and evidence must be written even when a soft Playwright
+  assertion fails; fix the owner, commit, repeat all local verification, push, and
+  repeat the complete sample rather than selectively rerunning rows.
+
+- [ ] **Step 9: Verify real-GAM conformance.** This gate runs only in the protected
+      `aps-real-gam` environment. Require a clean pushed commit, exact release id,
+      helper-generated unique evidence id, and operator-supplied immutable rollback
+      artifact id:
+
+  ```bash
+  test -n "${APS_REAL_GAM_PREVIOUS_ARTIFACT_ID:-}"
+  node scripts/ci/dispatch-aps-tsjs-gate.mjs real-gam --ref feature/aps-tsjs-resilience-rc202608 --previous-artifact-id "${APS_REAL_GAM_PREVIOUS_ARTIFACT_ID}" --output-dir target/aps-tsjs-final-real-gam
+  ```
+
+  The helper derives the dispatched release id from the clean local artifact; the
+  protected workflow compares it to `TS_REAL_GAM_EXPECTED_RELEASE_ID` supplied only
+  by the GitHub environment. Require the downloaded scrubbed attestation manifest to
+  name the exact evidence, release, rollback artifact, commit, successful conclusion,
+  and workflow run. The workflow invokes `bash scripts/ci/aps-real-gam.sh
+validate-inputs` and `run`; it tests PUC 1.17.2 in Chromium, Firefox, and WebKit.
+  This is the only release proof allowed to depend on the live proxied APS runner;
+  no fetched bytes are committed.
+
+- [ ] **Step 10: Inspect final state.**
+
+  ```bash
+  git status --short --branch
+  git log --oneline --decorate origin/rc/202608..HEAD
+  ```
+
+  Expected: clean worktree, all required commits present, no unrelated changes.
+
+### Task 19: Request final review, push, and update the replacement PR
+
+**Files:** no new implementation files.
+
+- [ ] **Step 1: Use `superpowers:requesting-code-review`.** Review the complete diff
+      against the exact PR base, design revision 44, this plan, the rc adoption
+      ledger, security protocol, lifecycle ownership, no-vendoring boundary, and
+      verification evidence. Resolve every blocking finding test-first and rerun the
+      affected task plus Task 18.
+
+      Before changing branch/PR wiring, record that the focused APS proxy, projection,
+      bootstrap transport, runtime admission, first-display/takeover, GPT/Prebid,
+      creative, diagnostics, remaining-integration, static-route, policy-browser,
+      architecture, bundle, and no-vendoring suites are already green. The final
+      branch operation may integrate the audited rc tip but must not introduce new
+      behavior while switching refs.
+
+- [ ] **Step 2: Use `superpowers:verification-before-completion`.** Confirm fresh
+      command output rather than relying on earlier runs.
+
+- [ ] **Step 3: Push the branch and ensure the PR base is `rc/202608`.** Use the
+      GitHub publishing workflow; do not retarget to `main`. The PR description must
+      identify the exact rc base, hard cutover, no-vendoring/proxy model, no cache or
+      analytics expansion, named rc behaviors preserved, test matrix, performance
+      evidence, and any external real-GAM prerequisite.
+
+- [ ] **Step 4: Confirm GitHub checks.** If a check fails, inspect the actual GitHub
+      job/log with the available repository GitHub workflow, reproduce locally where
+      practical, fix the owner test-first, push, and wait for the replacement run.
+
+- [ ] **Step 5: Use `superpowers:finishing-a-development-branch`.** Present the
+      verified PR and branch state. Do not claim implementation complete while any
+      required check, real-GAM gate, exact-base comparison, review finding, or
+      uncommitted change remains.
+
+## Completion checklist
+
+- [ ] Design revision 44 and this one plan agree on `rc/202608` authority.
+- [ ] All 23 concept rows have fresh final rc-baseline classifications.
+- [ ] No backward-compatibility path or second runtime remains.
+- [ ] No APS runner, GPT, or PUC bytes are vendored, pinned, cached, or stored.
+- [ ] The live runner proxy remains fixed-target, bounded, five-second, and
+      equivalent across all four adapters.
+- [ ] `TsjsBootV1` contains one exact frozen ordered integration-config carrier;
+      modules receive attenuated values only.
+- [ ] Production boot uses one server-sealed canonical JSON lexical transport;
+      bootstrap does not bundle the full object-form projection/config validators.
+- [ ] Bootstrap seals one authenticated runtime admission through the selected
+      script's `_claimRuntimeV1`; no retired two-claim harness or mutable namespace
+      admission remains.
+- [ ] One response-header CSP nonce, when uniquely admitted, covers every
+      Trusted Server executable tag and is copied only through the authenticated
+      runtime chain; the named Trusted Types policy is created at most once per path.
+- [ ] `ServerBootIntegrityV1` is always present; direct runtime and takeover both
+      recompute projection/config digests before effects, and takeover requires exact
+      integrity/outline/handoff equality.
+- [ ] No-agent preparation/activation/commit is synchronous and parser-blocking.
+- [ ] ADM and APS reservations select one `render_owner_initial` slice with the
+      source-neutral journal and compact self-contained PUC owner; `aps_initial`
+      owns only APS-specific descriptor/nonce/mount behavior.
+- [ ] APS uses top mount -> bootstrap -> outer data -> inner data -> creative with
+      independent `b1_`/`n1_` nonces and exact conditional CSP.
+- [ ] PUC protocol v4 owns registration/Promise settlement only, not APS DOM.
+- [ ] Committed overlays retire exactly once on every required lifecycle boundary.
+- [ ] `creative_opportunities.enabled` is required and preserves direct auction plus
+      the exact inactive HTML policy.
+- [ ] GPT diagnostics keep requested, GPT-fill, and observed sizes distinct.
+- [ ] GAM attribution has one typed parser-time GPT owner and no raw global path.
+- [ ] Rc C2/ESI, DataDome, PBS Cache, GPT, Prebid, creative, and remaining
+      integrations pass unchanged-behavior contracts.
+- [ ] Package, TypeScript, Prebid isolation, architecture, bundle, and hard-cutover
+      gates pass.
+- [ ] Hermetic three-browser, four-adapter proxy, paired rc performance, and
+      protected real-GAM gates pass.
+- [ ] Branch is clean, pushed, reviewed, and the PR targets `rc/202608`.
diff --git a/docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md b/docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md
new file mode 100644
index 000000000..fcd8bef45
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-04-aps-render-fix-and-tsjs-resilience-design.md
@@ -0,0 +1,6292 @@
+# APS Render Fix and TSJS Resilience Architecture — Design
+
+- **Status:** revision 44 — hard-cutover contract with a lean first-display owner,
+  atomic persistent-runtime takeover, an `rc/202608` implementation base,
+  retired-branch concept-gap coverage, rc behavior reconciliation, and
+  merge-blocking pre-action transfer remediation
+- **Date:** 2026-08-04
+- **Implementation baseline:** fetched `origin/rc/202608` at
+  `07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf` on 2026-08-28. The implementation
+  branch is created directly from that commit. Earlier feature and merge SHAs are
+  historical review references only; their approved changes were replayed and
+  reconciled onto this base, and they are not parents or implementation authority.
+  `main` is not a competing implementation authority.
+- **Final release-branch refresh:** fetched `origin/rc/202608` at
+  `07dfc1c6dddf69345ded17bd2d40a3d01bb39bcf` on 2026-08-28. The final overlap
+  audit and performance comparison use that exact tip. It already contains the
+  `main` ancestry selected by the release branch, so `main` is not merged separately.
+  The refresh includes the config-first auction-provider contract, strict
+  first-party proxy allowlist enforcement, edge-validated Basic-auth template
+  eligibility, and the latest first-impression arbitration repairs. Their behavior
+  is preserved by the final owners named in the implementation plan; their retired
+  GPT, Prebid, first-impression, and publisher-native APS mechanics are not restored.
+- **Retired-branch evidence:** the immutable historical snapshot
+  `905984e62a0858c53d9f0ff6dd3a1bf190cf311d` from retired `rc/july` is only a
+  finite TSJS concept-gap checklist. It is not a baseline, merge source, API
+  authority, or reason to preserve retired mechanics.
+- **Compatibility:** this is a coordinated hard cutover. No backward-compatible
+  aliases, permissive defaults retained only for rollback, dual APIs, or N/N-1
+  browser/server protocol are required.
+- **Decision:** this document covers APS render correctness, the TSJS architecture
+  needed to make that correctness durable, and preservation or explicit
+  architectural replacement of behavior in the exact rc baseline plus each
+  explicitly retained concept found by the retired-branch audit. It does not add
+  an external telemetry system or release experimentation.
+
+## 0. Scope and constraints
+
+### 0.1 Goals
+
+1. An accepted APS bid renders through every supported Trusted Server path:
+   SSAT/GPT, the Trusted Server Prebid adapter through GAM Universal Creative,
+   SPA page bids, and direct `/auction` rendering.
+2. Render ownership, identity, and completion are explicit. Races, stale SPA
+   work, ambiguous GPT events, duplicate creative requests, and timeouts settle
+   deterministically instead of failing silently.
+3. TSJS has one persistent runtime kernel, preceded only by the bounded
+   first-display agent in §5.2. The agent is not a second runtime: it publishes no
+   runtime API or capability broker, accepts only the immutable initial work selected
+   by the server, and retires through the one atomic ownership transfer. Integration
+   bundles cannot create independent copies of shared state.
+4. The Rust auction result, publisher projection, TypeScript parser, Prebid
+   registration, GPT targeting, Universal Creative bridge, and direct renderer
+   agree on one APS descriptor and identity contract.
+5. Security boundaries are testable: untrusted creative messages cannot claim a
+   different slot or attempt, replay a consumed capability, or revive work from a
+   prior navigation.
+6. Existing non-APS rendering behavior remains correct unless this design
+   explicitly replaces a shared lifecycle surface.
+7. Every affected TSJS behavior in the exact rc baseline is preserved, rebuilt behind the
+   new architecture, or explicitly superseded by a named and tested replacement
+   contract. The retired-branch audit additionally identifies required TSJS
+   concepts that are not already present in the baseline; the audit never makes retired
+   mechanics authoritative. No required behavior may disappear silently merely
+   because its old global, wrapper, bootstrap, or carrier is deleted.
+8. A server-projected initial display pays only for one server-composed lean
+   first-display artifact. The persistent runtime is neither requested nor prepared
+   until that immutable batch is terminal and has received its paint opportunity.
+   Optional integration behavior, diagnostics presentation, programmatic/direct
+   auctions, and later navigation therefore do not delay or compete with the
+   protected path. A page without eligible server-projected initial work loads the
+   persistent runtime directly; a later programmatic first display remains correct
+   but is not claimed to have the lean transfer profile.
+9. The inline controller consumes one server-sealed canonical JSON transport rather
+   than bundling the complete hostile-object validation graph. Rust remains the
+   producer authority, the controller synchronously parses, checks the critical
+   release/manifest/outline relationships, copies by parsing, and recursively freezes
+   the result before effects, and the first-display or persistent owner performs the
+   complete domain validation before using projection or product values.
+
+### 0.2 Non-goals
+
+- No change to analytics/telemetry schemas, durable data systems, billing,
+  experimentation, or deployment routing. Those belong to separate designs.
+- No DynamoDB, Tinybird, or other persistence/analytics dependency, schema, table,
+  sink, credential, workflow, or operational requirement.
+- No change to the APS upstream OpenRTB endpoint contract, including APS's
+  deliberate absence of `nurl` and `burl`.
+- No rewrite of Prebid.js itself or of the decoupled Prebid strategy.
+- No refactor of unrelated integration internals. They receive only the thin
+  registration/bootstrap changes required by the new TSJS runtime, plus any
+  mechanical disposal or adapter injection needed to preserve their baseline
+  behavior.
+
+Existing local render tracing, GPT diagnostics, logging, counters, debug output,
+and telemetry integrations remain functional through the cutover. They may move
+behind the core-owned diagnostics ingress, the GPT-owned fact stream, the trace
+owner's private presentation capability, or the final diagnostics namespace, but
+their observable concepts and non-interference guarantees are in scope. Correctness
+must not depend on a new observation reaching presentation code or an external sink.
+Any new analytics contract requires a separate design.
+
+### 0.3 Architectural rules
+
+- Make invalid states unrepresentable where practical and reject them at the
+  boundary otherwise.
+- Every asynchronous operation belongs to a runtime, navigation, auction batch,
+  or render-attempt lifetime and has a deterministic disposer.
+- Every render attempt reaches exactly one terminal result in memory.
+- A timeout cancels or fails only the object it owns; shared work is aborted only
+  when no live child still needs it.
+- Ad-tech globals are accessed only through adapters.
+- Cross-window messages are versioned, exact-shaped, capability-bound, and
+  source/port checked.
+- No correctness path waits for logging, telemetry, notification delivery, or any
+  other side effect unrelated to rendering.
+- Code that is unnecessary for the initial projected render cannot be imported by
+  the first-display entry. The production core is a post-paint takeover artifact,
+  not parser-blocking first-display code. A later module may join only the already
+  committed persistent runtime through its exact release-bound capability contract;
+  it cannot construct another runtime, adapter owner, slot registry, or message
+  dispatcher.
+
+### 0.4 `rc/202608` authority and retired-branch TSJS concept audit
+
+The exact `origin/rc/202608` commit recorded above is the normative starting point.
+Its source, behavior, tests, APIs, CI, dependency state, and performance shape are
+the baseline. The implementation branch was created directly from that exact rc
+commit; approved feature changes were replayed and reconciled rather than made a
+second-parent authority. A conflict resolution is not itself behavioral evidence:
+every overlapping rc behavior must be
+identified, assigned an owner, and proved after reconciliation. Unless this design
+explicitly supersedes an rc behavior, the rc behavior wins.
+
+Before release, the worktree fetches `origin/rc/202608` again. If it advanced, the
+new tip is merged, its SHA is recorded, and the same overlap audit and complete test
+gates run again. `main` is not separately merged: rc already carries the main
+ancestry chosen by the release branch. The PR targets `rc/202608`, not `main`.
+
+The `rc/july` branch is retired. It must not be fetched as an implementation input,
+merged, rebased, or cherry-picked into this work. The immutable historical snapshot
+`905984e62a0858c53d9f0ff6dd3a1bf190cf311d` is retained only because its TSJS tree,
+embedded bootstraps, tooling, and browser tests form a finite audit that can expose a
+required concept absent from the rc baseline. The in-spec manifest in §0.5 proves
+that this historical checklist is complete. For each ledger row, implementation
+first identifies the baseline owner and tests and reuses them when they satisfy
+this design. Only a concept explicitly retained by the ledger and missing or
+incomplete in the baseline becomes gap work. Historical source shape, names, incidental
+semantics, and unrelated retired-branch features are not requirements.
+
+The audit is behavioral, not commit-hash ancestry. The rc baseline may contain a concept
+through a squash, reimplementation, or later replacement even when a historical
+commit is not its Git ancestor. Every retained ledger row starts **proof-pending**.
+The implementation identifies or authors a focused contract and runs it against a
+detached, otherwise untouched worktree at the recorded rc baseline SHA:
+
+- **baseline-owned:** baseline source already has an owner and the focused contract
+  passes. Existing tests are reused; a newly authored test-only proof is retained in
+  the candidate without changing production behavior.
+- **implementation-gap:** the focused contract runs and fails because the required
+  behavior is absent or incomplete. Only that demonstrated gap becomes production
+  implementation work.
+- **coverage-gap:** no adequate focused contract exists yet. The next action is to
+  author the test alone and rerun it against the untouched rc baseline; this is an
+  intermediate blocked classification, never permission to implement or import
+  historical production code.
+
+An infrastructure/setup failure remains proof-pending rather than being relabeled as
+a behavioral failure. Each final classification records the rc SHA, baseline owner
+paths, exact test path/command, result, and disposition. Every row must end as
+baseline-owned or implementation-gap before production edits for that row. The
+historical patch is never applied merely because its original hash is absent.
+
+The existing checked-in concept-audit classification was captured against historical
+main SHA `f6a2fb85ce623bf8a574e3941e1ee349acc3412d`; its `mainSha`, `main-owned`, and
+command fields remain immutable provenance only. They do not satisfy this rc gate.
+The same audit fixture gains a separate schema-bumped `rcBaseline` classification
+for every ledger row, bound to the exact recorded rc SHA and using
+`baseline-owned | implementation-gap`. The checker prints and validates both layers,
+but only complete passing rc classifications satisfy phase exit. It rejects a row
+whose baseline SHA, owner path, command, result, or disposition is missing; it never
+rewrites the historical main evidence or treats its old pass as proof of rc behavior.
+
+Authority order is exact: this reviewed hard-cutover contract, then the exact rc
+baseline, then the retired snapshot as non-normative discovery evidence only. A
+contradiction is never resolved in favor of retired code implicitly. The
+implementation plan contains no `rc/july` merge task and no release gate comparing
+the candidate to `rc/july`.
+
+The following rc changes receive explicit reconciliation because they overlap this
+design or its tests. This is an adoption ledger, not permission to broaden scope:
+
+| Baseline source                                                            | Required disposition in this design                                                                                                                                                                                                                                    |
+| -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| #1008 server-side ad-template switch and inactive HTML cache policy        | **Preserve/supersede:** keep the independent switch, page/page-bids suppression, direct `POST /auction`, and `max-age=60` inactive policy. Because this is a hard cutover, `creative_opportunities.enabled` is a required boolean rather than a compatibility default. |
+| #1013 shared C2 template cache, hybrid ESI, and streaming assembly         | **Preserve:** retain the baseline implementation and tests at the publisher/HTML/TSJS seams. This design adds no cache mechanism, policy, backend, or requirement.                                                                                                     |
+| #1025 and #1032 GPT diagnostics documentation and slot-size evidence       | **Preserve/rebuild:** retain requested formats, GPT-reported fill, observed outer slot size, documentation, and API/export behavior under the sole diagnostics owner defined in §5.8.                                                                                  |
+| #1033 APS opaque-data containment                                          | **Rebuild:** the baseline later reverted the original patch. Reintroduce the security properties through §4.4's hard-cutover protocol, without its legacy APIs or vendored PUC fixture.                                                                                |
+| #1034 GAM cohort attribution                                               | **Preserve:** retain the rc behavior and configuration through the new runtime's typed registration/disposal boundaries. This design adds no new cohort, analytics schema, or experiment.                                                                              |
+| #992 DataDome exclusion and staging-bypass behavior                        | **Preserve:** retain its exact guard, privacy, and logging behavior through the DataDome integration module.                                                                                                                                                           |
+| rc CLI, SSAT debug, admin, response-cache configuration, and EdgeZero work | **Exclude from active changes:** preserve the baseline code and tests where merge overlap requires it; add no APS/TSJS requirement. EdgeZero receives no feature work in this design.                                                                                  |
+
+Each ledger entry has one of these dispositions:
+
+- **Preserve:** retain the observable behavior and its failure semantics.
+- **Rebuild:** retain the outcome but replace the old mechanism with the runtime,
+  adapter, service, or integration module named here.
+- **Supersede:** deliberately replace an old mechanism with a stricter named
+  contract. The ledger must state the behavioral change and prove either that the
+  new owner makes the old compensation unnecessary or that the new terminal
+  failure is complete, bounded, and preferable to a partial second runtime.
+- **Exclude:** keep the existing feature untouched because it is not TSJS work;
+  this disposition cannot hide affected baseline TSJS behavior or an explicitly
+  retained ledger concept.
+
+Hard cutover authorizes removal of old mechanisms and names. It does not authorize
+silent loss of baseline behavior or a retained ledger outcome. An observable
+outcome may change only through an explicit **Supersede** entry that names the old
+and final behavior, gives the architectural reason, and has boundary tests for the
+replacement contract. A source deletion is complete only when its baseline
+regression tests and ledger replacement/supersession proof pass.
+
+| ID                | Audited TSJS concept                                                                                                                                                                                          | Disposition and final owner                                                                                                                                                                                                                                                                    |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `RCJ-CORE-01`     | Core config/context, callback queue, auction parsing, direct request/rendering, SPA generation checks, and shared helpers continue to serve every enabled integration.                                        | **Rebuild:** kernel, services, and composition root; exact behavioral corpus runs before and after the switch.                                                                                                                                                                                 |
+| `RCJ-CORE-02`     | Programmatic ad-unit registration can drive direct `/auction`; core also exposes version/queue, placeholder render helpers, mutable generic config, and the local logger.                                     | **Preserve/supersede:** §5.4 defines the exact final API; typed registration/request APIs and immutable config replace placeholders/mutable config; logger methods/default remain, while invalid levels now throw without mutation instead of being retained with warn fallback.               |
+| `RCJ-BOOT-01`     | The edge-injected `gpt_bootstrap.js` duplicates initial-load tracking, slot handoff, hydration scheduling, GPT definition/targeting/display/refresh, and can render initial ads without the main TSJS bundle. | **Rebuild/supersede:** the bounded first-display agent owns only the immutable projected display and atomically transfers it to the persistent runtime; it publishes no degraded API/runtime. Missing/partial/takeover failure settles through §5.3 fallback without replay.                   |
+| `RCJ-TRACE-01`    | Render tracing records one honest impression timeline, bounded history, current-slot state, DOM stamps/badges, local overlay, no stale auction attribution, and emits `tsjs:adRendered`.                      | **Rebuild/supersede:** first-display facts cross the exact data-only handoff into the core trace reducer, `tsjs.diagnostics.renderTrace`, and deferred presentation attachment; public data subscription replaces mutable globals/CustomEvent, and no integration writes trace state directly. |
+| `RCJ-GPT-01`      | A TS fallback and a later publisher `defineSlot` share one physical GPT slot and one initial request; ownership transfer prevents later TS destruction.                                                       | **Rebuild:** the one-use first-display capsule transfers the exact physical object into the persistent GPT adapter/slot service, which then owns publisher handoff; no guessed reconstruction, function sentinel, duplicate wrapper, definition, or request.                                   |
+| `RCJ-GPT-02`      | Responsive/hydrated slot resolution chooses the unique active placement, recovers DOM replacement, and never silently chooses an ambiguous sibling.                                                           | **Rebuild:** navigation-scoped aliases plus runtime-owned DOM binding/reconciliation.                                                                                                                                                                                                          |
+| `RCJ-GPT-03`      | Native publisher GPT calls, service state, SRA, disabled initial load, refresh options, targeting cleanup, and publisher-owned slots retain their native semantics.                                           | **Preserve/Rebuild:** the sole GPT adapter owns interception and event fan-out; publisher activity never becomes TS-owned work.                                                                                                                                                                |
+| `RCJ-GPT-04`      | A TS-owned PUC response may resize only its authenticated still-collapsed ordinary 1×1 GAM shell, never unrelated, anchor, fixed, sticky, or already-expanded frames.                                         | **Preserve/Rebuild:** current render attempt owns one guarded resize after a response is successfully posted.                                                                                                                                                                                  |
+| `RCJ-PREBID-01`   | The publisher-specific artifact is pure Prebid.js; the Trusted Server shim is a separate TSJS integration module, and the external bundle remains independently useful if that module fails.                  | **Preserve/Rebuild:** external artifact plus Prebid adapter/integration module; TS code is not vendored into the external Prebid artifact.                                                                                                                                                     |
+| `RCJ-PREBID-02`   | Missing, late, duplicate, older, or partial Prebid artifacts fail safely: publisher queues drain, TS refresh handling is not installed without a real API, and installation is idempotent.                    | **Preserve/Rebuild:** artifact watchdog plus release-matched module transaction and bounded readiness queue.                                                                                                                                                                                   |
+| `RCJ-PREBID-03`   | Adapter manifests distinguish module names from registered bidder codes/aliases; client-side bidder coverage, user-ID modules, EIDs, native bids, and publisher callbacks keep working.                       | **Preserve:** typed artifact contract and black-box artifact tests; TS-owned bid identities alone are replaced.                                                                                                                                                                                |
+| `RCJ-PREBID-04`   | Configured GAM-path exclusions remove only matching slots from the synthetic Prebid refresh auction while clearing stale TS keys and retaining every slot/options in the GPT refresh.                         | **Preserve/Rebuild:** one refresh policy in the Prebid integration module over the GPT adapter; global, explicit, mixed, all-excluded, and fail-open path cases remain exact.                                                                                                                  |
+| `RCJ-APS-01`      | First-class APS OpenRTB admission, typed descriptor projection, direct rendering, Trusted Server Prebid-adapter rendering, and PUC rendering remain supported.                                                | **Preserve/Rebuild:** Rust admission plus the shared render lifecycle described in §§3–4.                                                                                                                                                                                                      |
+| `RCJ-APS-02`      | `bid.meta`, generated Prebid `adId`, upstream bid-id fallback, and old `hb_adid` precedence carried APS identity through lossy boundaries.                                                                    | **Supersede:** the server-minted `r1_` reservation is the only TS PUC authority; native Prebid IDs and PBS Cache UUIDs remain byte-preserved for their own purposes.                                                                                                                           |
+| `RCJ-APS-03`      | PUC uses one-use ports, APS callbacks—not script load—determine success, renderer tombstones are bounded, and lifecycle callbacks cannot corrupt later attempts.                                              | **Preserve/Rebuild:** bridge dispatcher, owner-control channel, reservation service, and terminal latch.                                                                                                                                                                                       |
+| `RCJ-APS-04`      | The APS presentation surface and descendant creative receive the winning dimensions without default margins, scrollbars, overflow, or clipping.                                                               | **Preserve/rebuild:** exact top-mount, outer-data, inner-renderer, and creative sizing contract in §4.4 and four-level browser assertions.                                                                                                                                                     |
+| `RCJ-CREATIVE-01` | Auction creative sanitization remains opt-in/default-off, rewriting retains its existing independent setting, and every delivery path observes the same configured processing boundary.                       | **Preserve:** creative integration module and server processing; this design does not silently enable sanitization or broaden rewriting.                                                                                                                                                       |
+| `RCJ-CREATIVE-02` | Opaque-origin click recovery accepts only validated absolute HTTP(S) navigation, persists the validated URL, rejects non-network schemes, and keeps creative sandbox isolation.                               | **Preserve/Rebuild:** creative integration module over shared origin/DOM helpers, with unit and real-browser sandbox coverage.                                                                                                                                                                 |
+| `RCJ-CREATIVE-03` | `tscreative.installGuards/setConfig/getConfig`, `tsCreativeConfig`, automatic install, click-guard default-on, and render-guard default-off control the creative browser guards.                              | **Preserve/supersede:** `CreativeBootV1` retains the defaults and the integration module auto-installs transactionally; mutable/install command globals are deleted and immutable `tsjs.boot.creative` is the only inspection/config surface.                                                  |
+| `RCJ-DIAG-01`     | GPT runtime diagnostics reports raw GPT observations, exact slot binding/replacement, request cycles/timing, bounded export, overlay/badges, and no lifecycle interference.                                   | **Preserve/Rebuild:** diagnostics integration module consumes the GPT adapter event stream and exposes `tsjs.diagnostics.gpt`; it never installs a second GPT control wrapper.                                                                                                                 |
+| `RCJ-INT-01`      | DataDome, Didomi, Google Tag Manager, Lockr, Osano, Permutive, Sourcepoint, and Testlight retain their current proxy guards, configuration, consent/segment, queue, and timing behavior.                      | **Preserve:** thin transactional integration modules plus complete pre/post-cutover black-box suites; internal feature behavior is otherwise unchanged.                                                                                                                                        |
+| `RCJ-INT-02`      | Shared script, beacon, DOM-insertion, scheduling, origin, and async helpers retain per-integration matching and failure isolation.                                                                            | **Rebuild where shared:** helper factories with integration-owned configuration; one module failure cannot unwind another integration module or publisher code.                                                                                                                                |
+| `RCJ-QUAL-01`     | Lint covers production source, tests, scripts, diagnostics, and build code; TypeScript and artifact checks cover the actual shipped combinations.                                                             | **Preserve/strengthen:** full-package lint/typecheck plus architecture, maximal-bundle, generated-artifact, browser, and retained-heap gates.                                                                                                                                                  |
+
+The commit clusters that exposed these concepts include the render-trace series
+starting at `966c8569c`; GPT recovery/handoff/responsive/native-behavior commits
+`4f45974e5`, `9b1985c8b`, `340d1efb4`, `0fdd13e7d`, `ca678fe69`, and
+`b200be53c`; Prebid decoupling/resilience and refresh commits `001ad385c`,
+`cdff89706`, `f3dc6ba70`, `60a85e661`, and `a007bd0d0`; creative hardening
+commits `1929dc83a`, `fde835110`, `9b21ba450`, `20977105f`, `1db074d4b`, and
+`3d9e2b693`; GPT diagnostics `11a4a7d25`; full-package lint `941473407`; APS
+admission/rendering commits from `f916ddf90` through `a08bebfbd`; and the final
+PUC/sizing chain `248fe9558`, `ed38f3e13`, `905984e62`. The executable tree
+inventory, not this illustrative hash list, is the completeness authority for the
+retired concept checklist only. The exact rc baseline and this design remain the
+behavior authorities.
+
+### 0.5 In-spec retired concept-inventory manifest
+
+To keep this a one-file design and make the audit runnable from an ordinary shallow
+checkout, the retired concept-inventory manifest embeds the complete materialized
+historical path list. No test resolves the retired commit or invokes `git ls-tree`.
+A contract test extracts `retired-rcjuly-tsjs-concept-manifest-v1`, requires the
+inventory to contain exactly 144 sorted unique paths, recomputes SHA-256 over their
+exact UTF-8 text with one LF after every path, and matches the recorded digest. It
+then requires every inventory path to match at least one `exact`, `prefix`, or
+`prefixes` mapping. A path receives the union of every matching row. Every
+`lib/src` path must receive at least one non-`RCJ-QUAL-01` id, and a mapping that
+matches no inventory path also fails. This proves only that the audit did not omit a
+historical TSJS concept; it needs no retired Git object and makes no historical
+source a build or behavior input. Separate ledger evidence maps every retained row
+to its rc-baseline owner/test or records a specific gap to implement.
+
+```json retired-rcjuly-tsjs-concept-manifest-v1
+{
+  "version": 1,
+  "authority": "concept-audit-only",
+  "retiredSnapshot": "905984e62a0858c53d9f0ff6dd3a1bf190cf311d",
+  "inventoryCount": 144,
+  "inventorySha256": "b1e28c8b30f0b8d95e38c0f8f57394df4ad43f760ae7abf5631e2054228aef08",
+  "inventory": [
+    "crates/trusted-server-core/src/integrations/aps.rs",
+    "crates/trusted-server-core/src/integrations/datadome.rs",
+    "crates/trusted-server-core/src/integrations/datadome/protection.rs",
+    "crates/trusted-server-core/src/integrations/datadome/protection_scope.rs",
+    "crates/trusted-server-core/src/integrations/didomi.rs",
+    "crates/trusted-server-core/src/integrations/google_tag_manager.rs",
+    "crates/trusted-server-core/src/integrations/gpt.rs",
+    "crates/trusted-server-core/src/integrations/gpt_bootstrap.js",
+    "crates/trusted-server-core/src/integrations/gpt_diagnostics.rs",
+    "crates/trusted-server-core/src/integrations/gpt_diagnostics_bootstrap.js",
+    "crates/trusted-server-core/src/integrations/lockr.rs",
+    "crates/trusted-server-core/src/integrations/mod.rs",
+    "crates/trusted-server-core/src/integrations/osano.rs",
+    "crates/trusted-server-core/src/integrations/permutive.rs",
+    "crates/trusted-server-core/src/integrations/prebid.rs",
+    "crates/trusted-server-core/src/integrations/sourcepoint.rs",
+    "crates/trusted-server-core/src/integrations/testlight.rs",
+    "crates/trusted-server-core/src/trace_cookie.rs",
+    "crates/trusted-server-core/src/tsjs.rs",
+    "crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts",
+    "crates/trusted-server-integration-tests/browser/tests/nextjs/api-passthrough.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/nextjs/form-rewriting.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/shared/script-bundle.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/shared/script-injection.spec.ts",
+    "crates/trusted-server-integration-tests/browser/tests/wordpress/admin-injection.spec.ts",
+    "crates/trusted-server-js/lib/.gitignore",
+    "crates/trusted-server-js/lib/.prettierignore",
+    "crates/trusted-server-js/lib/.prettierrc.json",
+    "crates/trusted-server-js/lib/build-all.mjs",
+    "crates/trusted-server-js/lib/build-prebid-external.mjs",
+    "crates/trusted-server-js/lib/eslint.config.js",
+    "crates/trusted-server-js/lib/package-lock.json",
+    "crates/trusted-server-js/lib/package.json",
+    "crates/trusted-server-js/lib/src/core/auction.ts",
+    "crates/trusted-server-js/lib/src/core/config.ts",
+    "crates/trusted-server-js/lib/src/core/context.ts",
+    "crates/trusted-server-js/lib/src/core/global.d.ts",
+    "crates/trusted-server-js/lib/src/core/index.ts",
+    "crates/trusted-server-js/lib/src/core/log.ts",
+    "crates/trusted-server-js/lib/src/core/queue.ts",
+    "crates/trusted-server-js/lib/src/core/registry.ts",
+    "crates/trusted-server-js/lib/src/core/render.ts",
+    "crates/trusted-server-js/lib/src/core/request.ts",
+    "crates/trusted-server-js/lib/src/core/styles/normalize.css",
+    "crates/trusted-server-js/lib/src/core/templates/iframe.html",
+    "crates/trusted-server-js/lib/src/core/trace.ts",
+    "crates/trusted-server-js/lib/src/core/types.ts",
+    "crates/trusted-server-js/lib/src/core/util.ts",
+    "crates/trusted-server-js/lib/src/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/aps/render.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/click.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/dynamic_src_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/iframe.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/image.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/creative/proxy_sign.ts",
+    "crates/trusted-server-js/lib/src/integrations/datadome/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/datadome/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/didomi/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/google_tag_manager/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/google_tag_manager/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/api.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/badges.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/binding.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/observer.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/overlay.ts",
+    "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/store.ts",
+    "crates/trusted-server-js/lib/src/integrations/lockr/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/lockr/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/osano/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/permutive/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/permutive/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/permutive/segments.ts",
+    "crates/trusted-server-js/lib/src/integrations/prebid/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/prebid/prebid_modules/aliases.d.ts",
+    "crates/trusted-server-js/lib/src/integrations/prebid/prebid_modules/liveIntentIdSystem.ts",
+    "crates/trusted-server-js/lib/src/integrations/prebid/user_id_modules.json",
+    "crates/trusted-server-js/lib/src/integrations/prebid/user_id_modules.ts",
+    "crates/trusted-server-js/lib/src/integrations/sourcepoint/index.ts",
+    "crates/trusted-server-js/lib/src/integrations/sourcepoint/script_guard.ts",
+    "crates/trusted-server-js/lib/src/integrations/testlight/index.ts",
+    "crates/trusted-server-js/lib/src/shared/async.ts",
+    "crates/trusted-server-js/lib/src/shared/beacon_guard.ts",
+    "crates/trusted-server-js/lib/src/shared/dom_insertion_dispatcher.ts",
+    "crates/trusted-server-js/lib/src/shared/globals.ts",
+    "crates/trusted-server-js/lib/src/shared/origin.ts",
+    "crates/trusted-server-js/lib/src/shared/scheduler.ts",
+    "crates/trusted-server-js/lib/src/shared/script_guard.ts",
+    "crates/trusted-server-js/lib/test/build-prebid-external.test.mjs",
+    "crates/trusted-server-js/lib/test/core/auction.test.ts",
+    "crates/trusted-server-js/lib/test/core/config.test.ts",
+    "crates/trusted-server-js/lib/test/core/context.test.ts",
+    "crates/trusted-server-js/lib/test/core/index.test.ts",
+    "crates/trusted-server-js/lib/test/core/registry.test.ts",
+    "crates/trusted-server-js/lib/test/core/render.test.ts",
+    "crates/trusted-server-js/lib/test/core/request.test.ts",
+    "crates/trusted-server-js/lib/test/core/trace.test.ts",
+    "crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.json",
+    "crates/trusted-server-js/lib/test/integrations/aps/render.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/creative/click.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/creative/helpers.ts",
+    "crates/trusted-server-js/lib/test/integrations/creative/iframe.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/creative/image.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/creative/proxy_sign.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/datadome/script_guard.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/didomi/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/google_tag_manager/script_guard.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/gpt_bootstrap.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/schedule_initial_ad_init.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/script_guard.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt/spa_hook.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/api.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/badges.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/binding.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/bootstrap.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/observer.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/overlay.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/store.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/types.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/lockr/script_guard.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/osano/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/permutive/segments.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/prebid/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/prebid/user_id_modules.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/sourcepoint/index.test.ts",
+    "crates/trusted-server-js/lib/test/integrations/sourcepoint/script_guard.test.ts",
+    "crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs",
+    "crates/trusted-server-js/lib/test/shared/async.test.ts",
+    "crates/trusted-server-js/lib/test/shared/beacon_guard.test.ts",
+    "crates/trusted-server-js/lib/test/shared/dom_insertion_dispatcher.test.ts",
+    "crates/trusted-server-js/lib/test/shared/scheduler.test.ts",
+    "crates/trusted-server-js/lib/tsconfig.json",
+    "crates/trusted-server-js/lib/vite.config.ts",
+    "crates/trusted-server-js/lib/vitest.config.ts"
+  ],
+  "includeRoots": [
+    "crates/trusted-server-js/lib",
+    "crates/trusted-server-integration-tests/browser/tests"
+  ],
+  "mappings": [
+    {
+      "exact": [
+        "crates/trusted-server-js/lib/.gitignore",
+        "crates/trusted-server-js/lib/.prettierignore",
+        "crates/trusted-server-js/lib/.prettierrc.json",
+        "crates/trusted-server-js/lib/eslint.config.js",
+        "crates/trusted-server-js/lib/package-lock.json",
+        "crates/trusted-server-js/lib/package.json",
+        "crates/trusted-server-js/lib/tsconfig.json",
+        "crates/trusted-server-js/lib/vite.config.ts",
+        "crates/trusted-server-js/lib/vitest.config.ts"
+      ],
+      "ids": ["RCJ-QUAL-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-js/lib/build-all.mjs",
+        "crates/trusted-server-js/lib/src/index.ts"
+      ],
+      "ids": ["RCJ-CORE-01", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-js/lib/build-prebid-external.mjs",
+        "crates/trusted-server-js/lib/test/build-prebid-external.test.mjs",
+        "crates/trusted-server-js/lib/test/prebid-artifact-integration.test.mjs"
+      ],
+      "ids": ["RCJ-PREBID-01", "RCJ-PREBID-02", "RCJ-PREBID-03", "RCJ-QUAL-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/core/",
+      "ids": ["RCJ-CORE-01"]
+    },
+    {
+      "exact": ["crates/trusted-server-js/lib/src/core/log.ts"],
+      "ids": ["RCJ-CORE-02"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-js/lib/src/core/config.ts",
+        "crates/trusted-server-js/lib/src/core/index.ts",
+        "crates/trusted-server-js/lib/src/core/registry.ts",
+        "crates/trusted-server-js/lib/src/core/request.ts"
+      ],
+      "ids": ["RCJ-CORE-02"]
+    },
+    {
+      "exact": ["crates/trusted-server-js/lib/src/core/trace.ts"],
+      "ids": ["RCJ-TRACE-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/shared/",
+      "ids": ["RCJ-CORE-01", "RCJ-INT-02"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/integrations/aps/",
+      "ids": ["RCJ-APS-01", "RCJ-APS-02", "RCJ-APS-03", "RCJ-APS-04"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/integrations/creative/",
+      "ids": ["RCJ-CREATIVE-01", "RCJ-CREATIVE-02", "RCJ-CREATIVE-03"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/integrations/gpt/",
+      "ids": ["RCJ-GPT-01", "RCJ-GPT-02", "RCJ-GPT-03", "RCJ-GPT-04"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/integrations/gpt_diagnostics/",
+      "ids": ["RCJ-DIAG-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/src/integrations/prebid/",
+      "ids": [
+        "RCJ-PREBID-01",
+        "RCJ-PREBID-02",
+        "RCJ-PREBID-03",
+        "RCJ-PREBID-04"
+      ]
+    },
+    {
+      "prefixes": [
+        "crates/trusted-server-js/lib/src/integrations/datadome/",
+        "crates/trusted-server-js/lib/src/integrations/didomi/",
+        "crates/trusted-server-js/lib/src/integrations/google_tag_manager/",
+        "crates/trusted-server-js/lib/src/integrations/lockr/",
+        "crates/trusted-server-js/lib/src/integrations/osano/",
+        "crates/trusted-server-js/lib/src/integrations/permutive/",
+        "crates/trusted-server-js/lib/src/integrations/sourcepoint/",
+        "crates/trusted-server-js/lib/src/integrations/testlight/"
+      ],
+      "ids": ["RCJ-INT-01", "RCJ-INT-02"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/core/",
+      "ids": ["RCJ-CORE-01", "RCJ-CORE-02", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": ["crates/trusted-server-js/lib/test/core/trace.test.ts"],
+      "ids": ["RCJ-TRACE-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/shared/",
+      "ids": ["RCJ-INT-02", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-js/lib/test/fixtures/aps-renderer-v1.json"
+      ],
+      "ids": ["RCJ-APS-01", "RCJ-APS-03", "RCJ-QUAL-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/integrations/aps/",
+      "ids": ["RCJ-APS-01", "RCJ-APS-02", "RCJ-APS-03", "RCJ-APS-04"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/integrations/creative/",
+      "ids": ["RCJ-CREATIVE-01", "RCJ-CREATIVE-02", "RCJ-CREATIVE-03"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/integrations/gpt/",
+      "ids": [
+        "RCJ-BOOT-01",
+        "RCJ-GPT-01",
+        "RCJ-GPT-02",
+        "RCJ-GPT-03",
+        "RCJ-GPT-04"
+      ]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/integrations/gpt_diagnostics/",
+      "ids": ["RCJ-DIAG-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-js/lib/test/integrations/prebid/",
+      "ids": [
+        "RCJ-PREBID-01",
+        "RCJ-PREBID-02",
+        "RCJ-PREBID-03",
+        "RCJ-PREBID-04"
+      ]
+    },
+    {
+      "prefixes": [
+        "crates/trusted-server-js/lib/test/integrations/datadome/",
+        "crates/trusted-server-js/lib/test/integrations/didomi/",
+        "crates/trusted-server-js/lib/test/integrations/google_tag_manager/",
+        "crates/trusted-server-js/lib/test/integrations/lockr/",
+        "crates/trusted-server-js/lib/test/integrations/osano/",
+        "crates/trusted-server-js/lib/test/integrations/permutive/",
+        "crates/trusted-server-js/lib/test/integrations/sourcepoint/"
+      ],
+      "ids": ["RCJ-INT-01", "RCJ-INT-02", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/integrations/gpt_bootstrap.js"],
+      "ids": ["RCJ-BOOT-01", "RCJ-GPT-01", "RCJ-GPT-02", "RCJ-GPT-03"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-core/src/integrations/gpt_diagnostics.rs",
+        "crates/trusted-server-core/src/integrations/gpt_diagnostics_bootstrap.js"
+      ],
+      "ids": ["RCJ-DIAG-01"]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/integrations/gpt.rs"],
+      "ids": ["RCJ-GPT-01", "RCJ-GPT-02", "RCJ-GPT-03", "RCJ-GPT-04"]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/integrations/prebid.rs"],
+      "ids": [
+        "RCJ-PREBID-01",
+        "RCJ-PREBID-02",
+        "RCJ-PREBID-03",
+        "RCJ-PREBID-04"
+      ]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/integrations/aps.rs"],
+      "ids": ["RCJ-APS-01", "RCJ-APS-02", "RCJ-APS-03", "RCJ-APS-04"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-core/src/integrations/datadome.rs",
+        "crates/trusted-server-core/src/integrations/datadome/protection.rs",
+        "crates/trusted-server-core/src/integrations/datadome/protection_scope.rs",
+        "crates/trusted-server-core/src/integrations/didomi.rs",
+        "crates/trusted-server-core/src/integrations/google_tag_manager.rs",
+        "crates/trusted-server-core/src/integrations/lockr.rs",
+        "crates/trusted-server-core/src/integrations/mod.rs",
+        "crates/trusted-server-core/src/integrations/osano.rs",
+        "crates/trusted-server-core/src/integrations/permutive.rs",
+        "crates/trusted-server-core/src/integrations/sourcepoint.rs",
+        "crates/trusted-server-core/src/integrations/testlight.rs"
+      ],
+      "ids": ["RCJ-INT-01", "RCJ-INT-02"]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/trace_cookie.rs"],
+      "ids": ["RCJ-TRACE-01"]
+    },
+    {
+      "exact": ["crates/trusted-server-core/src/tsjs.rs"],
+      "ids": ["RCJ-CORE-01", "RCJ-CORE-02", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-integration-tests/browser/helpers/gpt-stub.ts"
+      ],
+      "ids": ["RCJ-GPT-01", "RCJ-GPT-02", "RCJ-GPT-03", "RCJ-DIAG-01"]
+    },
+    {
+      "prefix": "crates/trusted-server-integration-tests/browser/tests/",
+      "ids": ["RCJ-CORE-01", "RCJ-INT-01", "RCJ-QUAL-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-integration-tests/browser/tests/nextjs/gpt-diagnostics.spec.ts"
+      ],
+      "ids": ["RCJ-DIAG-01"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-integration-tests/browser/tests/nextjs/navigation.spec.ts"
+      ],
+      "ids": ["RCJ-GPT-01", "RCJ-GPT-02", "RCJ-GPT-03"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-integration-tests/browser/tests/shared/aps-renderer.spec.ts"
+      ],
+      "ids": ["RCJ-APS-01", "RCJ-APS-02", "RCJ-APS-03", "RCJ-APS-04"]
+    },
+    {
+      "exact": [
+        "crates/trusted-server-integration-tests/browser/tests/shared/creative-sandbox.spec.ts"
+      ],
+      "ids": ["RCJ-CREATIVE-01", "RCJ-CREATIVE-02", "RCJ-CREATIVE-03"]
+    }
+  ]
+}
+```
+
+### 0.6 Approved review remediation
+
+The initial role-correct implementation exposed material first-display transfer and
+request-time work that its own post-change capture could not legitimately approve.
+The first mechanical remediation reduced the `[core, render_runtime, creative,
+gpt]` response to roughly 395 kB raw, but paired evidence at candidate
+`8ef8a40df` still measured 2,163.6 ms p90 against a 473.3 ms historical
+`main` reference: about 4.57×, where the release gate permits 1.10×. Co-bundling the
+same full ownership graph saves only duplicated module bytes and cannot close that
+gap. Both captures remain immutable evidence of reviewed intermediate states, not
+release baselines.
+
+Before merge, the implementation therefore replaces the oversized parser-blocking
+runtime with the bounded first-display agent and atomic takeover in §5.2. It also
+precomputes finite TSJS transport identities outside request handling and passes
+both the byte-accounting and network-shaped browser gates in §5.12. The persistent
+runtime remains architecturally complete after takeover; the load-time fix neither
+deletes resilience behavior nor weakens the gate. A gate captured from an oversized
+candidate cannot authorize that same candidate.
+
+This remediation does not reopen the hard-cutover decision. `pub_id`, numeric APS
+identifiers, unknown fields, old routes, and old browser APIs remain rejected rather
+than aliased. It also does not create an APS runner artifact or cache design: the
+runner stays live, unversioned, unvendored, unpinned, and uncached by Trusted Server.
+Reserved APS browser routes remain intentionally anonymous and are dispatched before
+publisher `[[handlers]]`; operators place admission control, rate limiting, or
+request shielding at the platform boundary.
+
+DataDome and the other integrations in `RCJ-INT-01` remain in scope only where their
+rc-baseline TSJS implementation is affected by runtime composition or where the
+retired audit identifies an explicitly retained TSJS gap. This is preservation
+behind the common runtime, not permission to import unrelated retired-branch work or
+redesign their server-side behavior. The server-side template switch, inactive HTML
+cache policy, and C2/ESI implementation are inherited rc behavior governed by the
+adoption ledger; this design adds no new cache requirement.
+
+## 1. Problem statement and evidence
+
+APS demand is integrated server-side, but APS creatives do not render reliably.
+Four serial fixes—the `bid.meta` carrier, decoupled shim, `hb_adid` fallback, and
+the historical PUC/collapsed-shell fix—each repaired one edge while leaving other
+independent failure points. The common failure is architectural: identity and
+state are copied across loosely coordinated server, GPT, Prebid, PUC, and iframe
+code, and many failures are swallowed.
+
+The TSJS library has the same structural problem: two large GPT/Prebid modules,
+duplicated ES5 and TypeScript behavior, imports in separately built IIFEs that do
+not share module state, global expandos, multiple GPT wrappers, and asynchronous
+work with no common owner.
+
+### 1.1 Supported flows
+
+| Flow      | Auction source                                  | Render owner             | APS route                                               |
+| --------- | ----------------------------------------------- | ------------------------ | ------------------------------------------------------- |
+| SSAT      | `tsjs.boot.auctionProjection`                   | GPT integration          | GAM Universal Creative → TS bridge → APS renderer       |
+| Prebid    | Trusted Server Prebid adapter                   | Prebid + GPT integration | GAM Universal Creative → TS bridge → APS renderer       |
+| Page bids | `/_ts/page-bids`                                | GPT integration          | GAM Universal Creative → TS bridge → APS renderer       |
+| Direct    | `/auction`                                      | render service           | TS-owned iframe → APS renderer                          |
+| Fallback  | opt-in child of an attributable empty GAM cycle | render service           | direct APS or direct ADM, according to the returned bid |
+
+### 1.2 Known failure surfaces
+
+| Area           | Failure                                                                                                                                                                                                               |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Admission      | A configured mediator can discard direct-provider bids; scripts can be rejected by policy; strict dimensions and APS response validation can drop bids without a useful local reason.                                 |
+| Identity       | PBS Cache UUID, upstream APS bid id, Prebid `adId`, GAM `hb_adid`, DOM id, and server slot id are different identities and have been conflated. GAM targeting values are capped at 40 characters.                     |
+| GPT            | `display()` under disabled initial load does not request; event listeners can be installed too late; multiple refresh wrappers and concurrent requests race; SafeFrame obscures frame ancestry.                       |
+| Bridge         | A `Prebid Request` can be duplicated, replayed, sent by a wrong frame, or arrive after navigation. A bare bid id is not enough to establish ownership.                                                                |
+| Renderer       | The opaque sandbox cannot observe HTTP failure; descriptor validation exists in Rust, TypeScript, and embedded ES5; nested-document containment, CSP, proxy, or runner loading can fail after the outer iframe loads. |
+| Direct auction | One fetch can contain several slots, but current cancellation and result handling are not batch-aware; failures collapse to an empty array.                                                                           |
+| Bootstrap      | Server bootstrap and bundle initialization can both believe they own runtime setup; a hung bundle can race the no-bundle fallback.                                                                                    |
+| Lifecycle      | There is no shared definition of attempt, ownership, supersession, terminal completion, or disposal.                                                                                                                  |
+
+## 2. Required behavior
+
+### 2.1 Outcome contract
+
+Each render attempt has one of four terminal outcomes:
+
+```ts
+type RenderFailureReason =
+  | 'auction_timeout'
+  | 'auction_disabled'
+  | 'consent_denied'
+  | 'slot_not_eligible'
+  | 'provider_timeout'
+  | 'provider_error'
+  | 'invalid_provider_response'
+  | 'mediation_failed'
+  | 'winner_not_renderable'
+  | 'internal_error'
+  | 'network_error'
+  | 'http_error'
+  | 'invalid_response'
+  | 'slot_unresolved'
+  | 'descriptor_invalid'
+  | 'invalid_dimensions'
+  | 'dimensions_out_of_range'
+  | 'no_render_source'
+  | 'registry_full'
+  | 'capability_registry_full'
+  | 'external_queue_full'
+  | 'external_ready_timeout'
+  | 'external_artifact_incompatible'
+  | 'prebid_admission_failed'
+  | 'prebid_contract_violation'
+  | 'prebid_selection_timeout'
+  | 'reservation_collision'
+  | 'identity_generation_failed'
+  | 'cycle_unattributable'
+  | 'slot_quarantined'
+  | 'gpt_request_failed'
+  | 'gpt_request_timeout'
+  | 'gpt_completion_timeout'
+  | 'reconciliation_capacity'
+  | 'gam_empty'
+  | 'bridge_claim_timeout'
+  | 'bridge_id_mismatch'
+  | 'owner_registration_timeout'
+  | 'owner_insertion_timeout'
+  | 'renderer_document_no_load'
+  | 'runner_no_load'
+  | 'runner_failed'
+  | 'adm_document_no_load'
+  | 'abi_mismatch'
+  | 'bundle_partial'
+
+type RenderOutcome =
+  | { outcome: 'accepted' }
+  | { outcome: 'no_bid' }
+  | { outcome: 'failed'; reason: RenderFailureReason }
+  | {
+      outcome: 'cancelled'
+      reason: 'caller_aborted' | 'superseded' | 'navigation_disposed'
+    }
+```
+
+`accepted` means the path-specific completion authority reported success:
+
+- APS: the sandboxed renderer document accepted the descriptor and the queued APS
+  `prebid/creative/render` event invoked its success callback. APS owns the runner and
+  its promise that it invokes this callback only after committing the nested creative
+  iframe; Trusted Server cannot independently prove that promise for mutable upstream
+  bytes. Loading the runner script alone is not acceptance.
+- Direct ADM: the TS-owned iframe fired its first `load` before timeout.
+- PUC ADM: the TS-authored PUC owner reported its owned iframe's first
+  `load` over the bound owner channel.
+
+It does not claim that pixels were viewable. `slotRenderEnded{isEmpty:false}` is
+evidence that GAM injected a creative, not evidence that APS completed.
+
+`no_bid` is reserved for an explicit, successfully parsed server auction decision
+with no valid winner for that slot. An attributable GPT
+`slotRenderEnded{isEmpty:true}` is
+`failed{reason:'gam_empty'}` so an opt-in fallback can name its exact parent cause.
+Network, timeout, HTTP, parse, descriptor, bridge, and renderer failures are not
+converted to `no_bid`.
+
+Every attempt owns one terminal latch. All competing callbacks, ports, iframe
+events, timers, aborts, and navigation disposal race through that latch. The first
+valid terminal transition wins, disposes attempt resources, and makes every later
+signal inert.
+
+#### Server-side template delivery switch
+
+When `[creative_opportunities]` exists, `enabled` is a required boolean. There is no
+serde default, omitted-field compatibility path, or serialization elision. Absence
+of the table means no configured server-side templates; `enabled = false` retains
+the typed slot definitions for operator tooling but disables publisher-HTML and
+`/_ts/page-bids` template delivery. The disabled state performs no slot matching,
+automatic auction dispatch, browser projection, initial ad-slot injection, or SPA
+ad initialization. Page-bids returns the exact valid empty slots/bids result. It does
+not disable direct `POST /auction`, whose caller-supplied request and ordinary
+auction gates remain authoritative.
+
+The switch does not weaken configuration validation. A present table and all of its
+slot/cache/assembly fields still parse, compile, and validate at startup even when
+disabled; disabling delivery is not a way to retain malformed configuration. Every
+checked-in example and test fixture states the boolean explicitly.
+
+For a successful publisher `GET` HTML response where Trusted Server injects no
+per-navigation auction state, the browser-facing policy becomes
+`Cache-Control: max-age=60` unless the origin already supplied a directive
+containing `private` or `no-store` case-insensitively. Origin validators and
+surrogate/CDN cache directives are preserved on this inactive path. A response that
+does receive synthesized per-navigation state retains the baseline private/no-store
+and validator-stripping policy. Non-HTML responses, failures, and direct auction
+responses are unchanged. This is the inherited #1008 behavior at the publisher
+boundary, not a new cache implementation.
+
+### 2.2 Identity model
+
+The implementation keeps these identities distinct:
+
+| Identity                | Purpose                          | Rules                                                          |
+| ----------------------- | -------------------------------- | -------------------------------------------------------------- |
+| server slot id          | auction and publisher projection | exact, case-sensitive, 1–256 UTF-8 bytes, no NUL/control       |
+| programmatic slot id    | direct-auction registration      | validated `code`; same bound; exact request/result identity    |
+| DOM/container alias     | locating a page element          | separate collision-detecting index; ambiguous aliases fail     |
+| upstream bid id         | provider provenance              | 1–64 UTF-8 bytes, no NUL/control, unique in provider response  |
+| candidate id            | mediator round-trip              | server-minted opaque 12-character token; never an ordering key |
+| PBS Cache UUID          | cache transport lookup           | preserved byte-for-byte as `cacheId`; never bridge authority   |
+| native Prebid `adId`    | non-TS Prebid renderer lookup    | untouched for native bids; never entered in the TS store       |
+| renderer reservation id | every TS-owned PUC capability    | `r1_` plus 22 base64url characters; exact `hb_adid`/TS `adId`  |
+| attempt id              | in-page lifecycle ownership      | `a1_` plus 22 base64url characters; navigation-unique          |
+| lifecycle ticket        | cross-window capability          | `t1_` plus 22 base64url characters; one-use and attempt-bound  |
+| bootstrap nonce         | outer-document capability        | `b1_` plus 22 base64url characters; one-use and attempt-bound  |
+| renderer nonce          | inner-document capability        | `n1_` plus 22 base64url characters; one-use and attempt-bound  |
+| GPT trace slot token    | diagnostic physical-object join  | adapter-minted canonical `gt1_` form; runtime-local, nonreused |
+| GPT trace cycle ordinal | diagnostic impression join       | 1..2^32-1 per physical object; valid only with its slot token  |
+
+Every TS-owned PUC source introduced by this design—APS or inline ADM—receives a renderer reservation
+id, and that id is copied exactly to GAM `hb_adid`. For the Trusted Server Prebid
+adapter bid, it also replaces the TS bid's generated `adId` before targeting;
+native Prebid bids are untouched. The server creates the id from 16 CSPRNG bytes
+encoded as unpadded base64url and prefixed with `r1_`; it retries a response-local
+collision at most eight times, then fails the bid with
+`identity_generation_failed`. The browser rejects a collision with any live/
+tombstoned reservation as `reservation_collision`. A PBS Cache UUID and the
+upstream/provider bid id retain their current transport/provenance purposes and are
+never fallback credentials for an APS or ADM reservation.
+
+Attempt ids require no unbounded issued-id set. At `NavigationSession` creation the
+browser obtains eight CSPRNG bytes with `crypto.getRandomValues` and keeps one
+unsigned 64-bit attempt ordinal as two 32-bit words. For each new attempt it
+increments the ordinal, concatenates the navigation prefix with the big-endian
+ordinal, base64url-encodes those 16 bytes without padding, and prefixes `a1_`. The
+fixed navigation prefix plus never-reused ordinal guarantees navigation-local
+uniqueness. Prefix-generation failure or ordinal exhaustion refuses the new attempt
+with `identity_generation_failed`; the ordinal never wraps. The active-attempt index
+contains at most one attempt per admitted slot and is therefore capped by
+`MAX_ACTIVE_SLOT_RECORDS = 256`; terminal settlement removes the strong entry, while
+generation plus the nonreused ordinal makes stale callbacks inert without retaining
+old ids.
+
+One runtime-owned capability registry stores lifecycle tickets and their tombstones
+with a shared capacity of 320. Before minting it prunes entries whose fixed
+three-second lifetime has expired; unexpired entries are never evicted. A ticket is
+16 fresh CSPRNG bytes encoded as the fixed `t1_` form and checked against every live/
+tombstoned ticket. A collision retries at most eight total draws, then fails the
+attempt with `identity_generation_failed`. Capacity exhaustion before a successful
+draw refuses the outer PUC response and fails the attempt with
+`capability_registry_full`. Consumption/disposal replaces the live entry with a
+tombstone carrying the same original expiry; it never extends the lifetime.
+
+APS document nonces use the same eight-draw CSPRNG/collision rule in two separate
+live registries capped at 256 entries each. Every active APS attempt owns exactly
+one `b1_` bootstrap nonce and one independent `n1_` renderer nonce. The bootstrap
+nonce authenticates only the outer bootstrap/window-message/navigation phase; the
+renderer nonce authenticates only the inner renderer/port-envelope phase. Their
+different prefixes are mandatory, and a value is never converted, reused, or
+accepted in the other role. Neither registry needs tombstones: the exact outer or
+inner `WindowProxy`, exact port where applicable, attempt id, and generation remain
+mandatory, and attempt disposal removes both live entries, removes the bootstrap
+listener, and closes the renderer channel before any later attempt can act. Either
+registry's capacity failure is `capability_registry_full`; collision exhaustion is
+`identity_generation_failed`. The ticket and both nonce registries never fall back
+to timestamps, `Math.random`, truncation, or eviction.
+
+### 2.3 Slot registry and bounded reservations
+
+One runtime-scoped slot service owns the registry:
+
+- `WeakMap<googletag.Slot, SlotRecord>` for GPT object identity;
+- exact registered-slot-id index covering server and programmatic registrations;
+- exact GPT ad-unit-code index;
+- separate DOM alias index that rejects collisions;
+- active render reservation map plus consumed/stale tombstones;
+- request-intent and active-cycle state per slot.
+
+`MAX_ACTIVE_SLOT_RECORDS` is 256 across server-projected and programmatically
+registered records in one `NavigationSession`. The immutable server projection is
+validated against that total before the kernel commits; an oversized projection is
+an `abi_mismatch` boot failure. `addAdUnits` reserves capacity for its whole input
+before mutation and rejects the whole call with
+`AdUnitRegistrationError{code:'registry_capacity'}` when the remaining capacity is
+insufficient. Navigation disposal synchronously removes every record and secondary
+index owned by that navigation; reservations/tombstones retain only their separate
+bounded lifecycle below.
+
+Registration rejects a missing, empty, or greater-than-256-UTF-8-byte server or
+programmatic slot id before indexing and assigns each valid slot a monotonically
+increasing, navigation-local ordinal. An exact registered-slot-id collision is
+rejected rather than overwritten. GPT ad-unit-code and DOM-alias indexes retain
+collision state: a lookup must resolve exactly one record, and zero or multiple
+matches fail `slot_unresolved`; registration order is never used to choose among
+collisions.
+
+The reservation map and tombstones share a capacity of 320. An SSAT/page-bid render
+reservation has a fixed 15-minute lifetime measured by the runtime's monotonic clock
+from browser registration; consumption does not extend it. A Prebid bid awaiting
+client-side selection instead receives a ten-second admission lease. Exact selection
+atomically promotes that lease to a render reservation with a new fixed 15-minute
+lifetime measured from promotion; this occurs before targeting can expose the id and
+is the only expiry replacement. An admission lease is suppress-only and cannot
+satisfy a PUC claim; a request carrying that id before selection is refused,
+tombstones the lease, and records `prebid_contract_violation`. Unselected, aborted,
+or selection-timed-out entries
+become tombstones only through their original ten-second lease expiry. Expired
+entries are pruned.
+Unexpired entries are never evicted because eviction would allow a late creative
+request to escape TS ownership. At capacity, registration fails with
+`registry_full`. A consumed, stale, or disposed reservation remains a tombstone
+until its original expiry and never produces a second response. While live, each
+admission lease or render reservation records its exact slot, render source,
+immutable `WinnerContext{selectedCpm}`, navigation generation, expiry, and state.
+`selectedCpm` is copied from the fully validated selected projected bid and is
+finite and nonnegative. Prebid admission verifies that the frozen bid's `cpm` is
+exactly this stored value, and selection promotion preserves the same context
+rather than reconstructing it from Prebid. A successful PUC claim transfers the
+context into the `RenderAttempt` before replacing the live entry with a tombstone.
+The exact frozen successful claim result is also a one-shot internal capability:
+`RenderAttempt` consumes that object to receive its already-bound render source and
+winner context from the service's bounded internal record. The claim object exposes
+neither field, so callers cannot pass, reconstruct, or swap them separately.
+Consumption additionally requires the branded reservation service, its live runtime,
+the original current attempt and navigation generation, and a time strictly before
+the reservation's fixed expiry. Disposal, expiry, or loss of exact attempt authority
+invalidates the claim capability.
+The tombstone discards the render source and winner context and retains only the id,
+original expiry, terminal state, and minimum suppression metadata. Neither the
+renderer descriptor nor any capability crossing a browser-context boundary contains
+CPM; the one-shot claim object remains internal to the same runtime.
+
+Ids are unique across all live/tombstoned entries, so lookup identifies one entry
+and then requires its exact active slot, cycle, and generation. The first compatible
+PUC claim acquires its source and winner context; a live or tombstoned TS id is
+suppressed before detailed validation.
+
+Direct `/auction` APS/ADM rendering does not round-trip through a PUC reservation.
+Its exact winner join creates the `RenderAttempt` with an immutable
+`WinnerContext{selectedCpm}` copied from that same validated projected winner before
+rendering. Thus the redesigned direct and PUC APS/ADM paths have the same CPM
+authority without inventing a bridge capability for direct rendering. Existing PBS
+Cache price expansion remains outside this contract and is regression-tested at its
+rc-baseline behavior.
+
+The current `__tsRenderGeneration`, `__tsRenderBid`, and function-sentinel
+expandos are removed.
+
+### 2.4 GPT request-cycle ownership
+
+GPT events describe physical requests and are not promises. The runtime therefore
+tracks request intent separately from physical cycles:
+
+1. A TS operation records an intent before calling `display()` or `refresh()`.
+2. A TS operation never treats `display()` as request-capable while initial load is
+   disabled. It uses `display()` only to register the slot, then invokes exactly one
+   `refresh([slot], {changeCorrelator:false})`; the request intent and three-second
+   start deadline attach only to that refresh. If the adapter cannot invoke refresh
+   or the call throws, the attempt fails `gpt_request_failed`. A publisher-owned
+   `display()` remains publisher activity and starts no TS attempt or fallback.
+3. A physical cycle opens only on `slotRequested` and closes on the corresponding
+   `slotRenderEnded`.
+4. One TS-owned cycle may be outstanding per slot, with at most one queued
+   replacement.
+5. Attribution requires exactly one live compatible intent. Overlap or a later
+   request-capable intent that makes ownership ambiguous fails the affected TS
+   cycle with `cycle_unattributable`; it is never guessed from timing.
+6. `responseIdentifier` deduplicates completion but is not an ownership token.
+7. A cycle is re-armed only by counted completion or safe TS-owned
+   destroy/redefine—never by a timeout or navigation disposal that merely hopes GPT
+   has finished.
+
+`slotRequested` and `slotRenderEnded` listeners are installed unconditionally
+before any TS display/refresh call. SRA opens one logical cycle per participating
+slot. Publisher-initiated GPT activity remains publisher-owned and cannot trigger
+TS fallback.
+
+An operation waiting for GPT or Prebid readiness has its own fixed ten-second
+deadline measured from enqueue and fails `external_ready_timeout`; public
+`requestAds.timeoutMs` never shortens or extends it. After a request-capable
+`display()` or `refresh()` is
+invoked, `slotRequested` must arrive within three seconds or the attempt fails
+`gpt_request_timeout`. Its matching `slotRenderEnded` must arrive within ten seconds
+of that same request invocation or the attempt fails `gpt_completion_timeout`.
+A timeout tombstones the reservation, closes owned ports,
+and settles the attempt, but does not pretend the physical GPT cycle completed.
+
+At `gpt_request_timeout`, no attributable physical cycle exists. The adapter
+immediately invokes the transactional TS-owned destroy/redefine contract in §5.7
+and permanently retires the old object. Failure defines no replacement and leaves
+the path quarantined; later TS work fails `gpt_request_failed`. A publisher-owned
+object enters page-lifetime quarantine and cannot
+accept new TS work until the publisher explicitly destroys that object or the page
+reloads; no later `slotRequested` or `slotRenderEnded` may release that quarantine
+because it cannot be attributed to the timed-out invocation. At
+`gpt_completion_timeout`, the already-open exact physical cycle stays retired or
+quarantined until its matching real completion, safe TS-owned destroy/redefine,
+publisher destruction, or reload. Late GPT events only drain an already attributable
+completion-timeout cycle; they cannot revive an attempt, start fallback, or re-arm a
+request-timeout quarantine.
+
+Navigation disposal does not manufacture a GPT completion. If the open slot is
+TS-owned, the adapter invokes the §5.7 transaction; a replacement is defined only
+when the current navigation still needs it and exact destruction succeeded. The
+retired object remains in the runtime `WeakMap` until its late completion drains and
+can never be matched to a replacement. Destroy failure leaves no second object and
+quarantines later TS work. If it is publisher-owned, the physical cycle
+is quarantined: new TS work for that GPT object fails `slot_quarantined` until the
+matching `slotRenderEnded`, publisher destruction, or full page reload. There is no
+timeout-based re-arm. In particular, an old completion after navigation but before
+the replacement's completion settles only the retired/quarantined cycle.
+
+### 2.5 SPA and concurrent work
+
+- `RuntimeSession` survives SPA navigations and owns the global lifetime plus
+  injected adapter/service disposers. Runtime-scoped slot and reservation services
+  own the slot-object map, bridge listener, reservations/tombstones, and physical
+  GPT cycle state; kernel code knows them only through interfaces.
+- `NavigationSession` owns route-specific slot aliases, request intents, auction
+  batches, attempts, timers, targeting history, and one internal immutable current
+  auction-projection snapshot.
+- A new navigation atomically replaces the prior `NavigationSession`; disposal
+  cancels its live attempts and prevents late callbacks from mutating the new one.
+- The initial session seeds its internal projection from the recursively frozen
+  `tsjs.boot.auctionProjection`. A later SPA session begins with no current
+  projection. Its page-bids controller accepts only one exact, fully validated
+  `BrowserAuctionProjectionV1` for the current navigation generation, deep-copies
+  and freezes it, transactionally registers all projected slots against the shared
+  256-slot cap, then commits it to the session. A stale, duplicate, malformed, or
+  over-cap response commits no slot, targeting, bid, or projection and cannot retain
+  the prior navigation's data. Programmatic registrations admitted before that
+  response count against the same transaction. The immutable public boot object is
+  document-generation input and is never rewritten into a mutable current-state
+  carrier.
+- An `AuctionBatch` owns one `/auction` fetch and one child attempt per requested
+  slot. Supersession cancels children individually. The shared fetch is aborted
+  only when every child is terminal, the caller aborts all children, the batch
+  response deadline expires, or navigation disposes.
+- After a parsed response is processed, every still-live child receives the exact
+  server decision for its slot; missing, duplicate, or inconsistent decisions are
+  `invalid_response`, never inferred as `no_bid`.
+
+### 2.6 Fallback
+
+`SlotOperation` owns the public per-slot result and one primary `RenderAttempt`.
+Fallback is opt-in and, when eligible, becomes a second child attempt. It may start
+only after an attributable TS-owned GAM cycle terminates empty. Publisher-owned,
+ambiguous, timed-out, quarantined, or stale cycles never trigger fallback. Each
+child has its own immutable terminal result and local history. The operation
+settles once: with the primary result when no fallback runs, or with the fallback
+child result and `path:'fallback'` after the primary `gam_empty`. A child never
+overwrites its parent or sibling.
+
+## 3. APS wire and server contracts
+
+### 3.1 One descriptor
+
+The only APS render descriptor is:
+
+```ts
+interface ApsRendererV1 {
+  type: 'aps'
+  version: 1
+  accountId: string
+  bidId: string
+  creativeId?: string
+  tagType: 'iframe' | 'script'
+  creativeUrl: string
+  width: number
+  height: number
+  aaxResponse: string
+}
+
+interface AdmRenderSourceV1 {
+  type: 'adm'
+  version: 1
+  adm: string
+  width: number
+  height: number
+}
+
+interface BaselinePbsCacheSourceV1 {
+  type: 'pbs_cache'
+  version: 1
+  cacheId: string
+  cacheHost: string
+  cachePath: string
+  width: number
+  height: number
+}
+
+type OwnedRenderSourceV1 = ApsRendererV1 | AdmRenderSourceV1
+type BidRenderSourceV1 = OwnedRenderSourceV1 | BaselinePbsCacheSourceV1
+```
+
+`ApsRendererV1` and `AdmRenderSourceV1` are the redesigned, reservation-owned
+sources. A selected internal Rust APS/ADM bid carries exactly one corresponding enum
+member; APS markup is not smuggled through `adm`, `meta`, or debug fields. Each
+tagged object rejects unknown keys. Limits are defined once and shared by the Rust
+producer, TypeScript parser, and embedded renderer validator:
+
+- nonempty `accountId` and optional nonempty `creativeId`, each at most 1,024
+  UTF-8 bytes;
+- nonempty `bidId` of at most 64 UTF-8 bytes;
+- numeric, finite, integral `width` and `height`, each in the inclusive shared
+  `RENDER_DIMENSION_MIN = 1` through `RENDER_DIMENSION_MAX = 4096` CSS-pixel range;
+- `creativeUrl` at most 4,096 UTF-8 bytes, HTTPS, no credentials, and not the
+  publisher origin;
+- canonical standard-base64 `aaxResponse`, decoded size at most 256 KiB;
+- exactly one decoded seat and one decoded bid;
+- decoded bid id, dimensions, `creativeurl`, and `tagtype` exactly match the
+  duplicated descriptor fields;
+- finite, nonnegative decoded price.
+
+A checked-in schema/corpus is the cross-language conformance source. Rust,
+TypeScript, and the ES5 renderer validator run the same positive and adversarial
+vectors. CI fails when generated ES5/schema output is stale. Semantic validation
+that cannot be represented in JSON Schema remains in small handwritten validators
+covered by the same corpus.
+
+For `adm`, markup is nonempty and at most 512 KiB. `BaselinePbsCacheSourceV1` is only
+a hard-cutover carrier for the rc-baseline cache coordinates
+occupied `hb_adid`, `hb_cache_host`, and `hb_cache_path`. It introduces no cache
+policy, URL construction, response validation, price authority, dimensions,
+deadline, error taxonomy, direct-cache feature, or PUC protocol. The GPT integration
+delegates it to the preserved rc-baseline cache implementation behind a thin
+generation/disposal boundary, and the rc-baseline black-box corpus is the authority
+for its behavior. A PBS bid with accepted ADM uses the ADM source even when cache
+coordinates coexist; that documents the current ADM-over-cache
+precedence. `pbs_cache` is used only when accepted ADM is absent. It retains its
+native cache UUID identity and never enters the `r1_` reservation registry.
+
+### 3.2 Per-slot auction decisions
+
+Every server auction entry point produces exactly one decision for every requested
+slot, in request order:
+
+```ts
+type AuctionSlotFailureReason =
+  | 'auction_disabled'
+  | 'consent_denied'
+  | 'slot_not_eligible'
+  | 'provider_timeout'
+  | 'provider_error'
+  | 'invalid_provider_response'
+  | 'mediation_failed'
+  | 'winner_not_renderable'
+  | 'identity_generation_failed'
+  | 'internal_error'
+
+type SlotAuctionDecisionV1 =
+  | { slot: string; outcome: 'winner'; candidateId: string }
+  | { slot: string; outcome: 'no_bid' }
+  | { slot: string; outcome: 'failed'; reason: AuctionSlotFailureReason }
+
+interface AuctionDecisionSetV1 {
+  version: 1
+  auctionId: string
+  results: SlotAuctionDecisionV1[]
+}
+
+interface BrowserProjectedBidBaseV1 {
+  candidateId: string
+  slot: string
+  provider: string
+  upstreamBidId: string
+  cpm: number
+  currency: 'USD'
+  targeting: Record<string, string>
+}
+
+type BrowserProjectedBidV1 =
+  | (BrowserProjectedBidBaseV1 & {
+      rendererReservationId: string
+      renderSource: OwnedRenderSourceV1
+    })
+  | (BrowserProjectedBidBaseV1 & {
+      renderSource: BaselinePbsCacheSourceV1
+    })
+
+interface BrowserAuctionProjectionV1 {
+  version: 1
+  auction: AuctionDecisionSetV1
+  slots: Array<{
+    slot: string
+    gamUnitPath: string
+    divId: string
+    formats: Array<readonly [number, number]>
+    targeting: Record<string, string>
+  }>
+  bids: BrowserProjectedBidV1[]
+}
+```
+
+`BrowserAuctionProjectionV1` is exact, deny-unknown, and bounded before any slot,
+reservation, targeting, or bid mutation. Its canonical UTF-8 JSON is at most
+`MAX_BROWSER_AUCTION_PROJECTION_BYTES = 8 * 1024 * 1024`; `auction.results`, `slots`,
+and `bids` each contain at most 256 entries; and all objects are plain own-data objects
+with no accessors. Canonical serialization uses the interface field order shown,
+request order for results, the same order for slots, matching result order for bids,
+lexically sorted targeting keys, and no insignificant whitespace. `auctionId` matches
+`^[A-Za-z0-9._:-]{1,128}$`; candidate ids use
+the exact 12-character base64url form from §3.4 and are unique; result slots are
+unique, follow the §2.2 bound, and contain no NUL or ASCII control; every winner has
+exactly one bid with the same slot/candidate and non-winners have none. An APS/ADM
+bid has one `rendererReservationId` using the exact unique `r1_` form from §2.2; a
+`pbs_cache` bid has no such field and retains the current cache UUID identity. Provider matches
+`^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$`; and upstream bid ids are 1–64 UTF-8 bytes with
+no NUL or ASCII control. CPM is a finite nonnegative number and currency is exactly
+`USD`.
+
+For initial HTML and `/_ts/page-bids`, `slots.length` equals
+`auction.results.length` exactly. Entry `slots[i].slot` equals
+`auction.results[i].slot`; slot ids are unique; and the entire projection is rejected
+if any placement is missing, duplicated, extra, or out of order. `gamUnitPath` and
+`divId` are nonempty, contain no NUL or ASCII control, and are each at most 256 UTF-8
+bytes. `formats` contains 1–64 exact two-number tuples and every width and height is
+an integer in 1–4096. Placement `targeting` uses the same exact key/value grammar and
+32-entry cap as bid targeting and cannot contain `hb_adid`.
+
+The direct `/auction` response does not expose this browser projection shape. Its
+internal use of the canonical decision/bid serializer supplies `slots:[]` because
+there is no server-rendered GAM placement to bind; the wire response remains the
+exact OpenRTB response plus decision extension. Rust canonicalization therefore
+accepts either full ordered placement coverage or the direct-only empty placement
+vector, while the browser boot/page-bids parser accepts only full ordered coverage.
+No browser consumer interprets an empty placement vector for a nonempty decision set.
+
+Each bid's `targeting` member is a plain own-data object with at most 32 entries. A key
+matches `^[A-Za-z0-9_]{1,20}$`, is unique and case-sensitive, and cannot be
+`hb_adid`, which the runtime alone synthesizes from the reservation. A value is
+nonempty, contains at most 40 Unicode scalar values and 160 UTF-8 bytes, and contains
+no NUL or ASCII control. The producer applies the same rules. A winning candidate
+that cannot be projected becomes `winner_not_renderable`.
+
+Aggregate overflow has one exact server outcome. The producer first constructs and
+measures the complete canonical projection. If it exceeds 8 MiB, it transactionally
+converts every `winner` result in that auction to
+`failed{reason:'winner_not_renderable'}`, emits no projected winner bids, and retains
+the existing no-bid/failed results in request order. For `/auction`, the corresponding
+TS winner bids are likewise absent from `seatbid`; no unmatched decision or bid is
+emitted. The reduced projection is guaranteed to fit from the 256-result/id bounds.
+Initial HTML, page-bids, and direct response production use this same all-winners
+rule, never a completion-order or first-fit subset. The aggregate measurement includes
+the complete ordered placement vector for browser projections. Boot rejects any independently
+malformed or oversized value as `abi_mismatch`; page-bids and direct response
+admission reject it transactionally as `invalid_response` with no partial slot,
+reservation, targeting, or bid state.
+
+Wrong type, nonfinite, fractional, zero, or negative render dimensions are
+`invalid_dimensions`; an otherwise integral dimension outside 1–4096 is
+`dimensions_out_of_range`. This exact distinction and range apply in the Rust
+producer, TypeScript projection/source parser, ES5 APS renderer validator,
+programmatic banner sizes, PUC/renderer DOM construction, and every
+CSS/attribute layout assertion. No adapter may clamp an accepted dimension.
+
+Each provider response is normalized internally to exactly one
+`ProviderSlotOutcome`—candidate, no-bid, or typed failure—for every slot dispatched
+to that provider. A successful response that omits a dispatched slot is a provider
+no-bid; launch, transport, timeout, HTTP, parsing, validation, and mediation errors
+are failures for the affected dispatched slots. Final aggregation is deterministic:
+
+1. Pre-dispatch gating returns `auction_disabled`, `consent_denied`, or
+   `slot_not_eligible` directly. A slot with zero eligible providers is exactly
+   `failed{reason:'slot_not_eligible'}`, never a no-bid. Provider currency rejection
+   is `invalid_provider_response`; there is no separate render-layer currency reason.
+2. A selected deliverable candidate is `winner`, even if another provider failed.
+3. Failure to mint a unique renderer reservation for the selected candidate is
+   `failed{reason:'identity_generation_failed'}`. Any other failure to validate or
+   project the selected candidate is `failed{reason:'winner_not_renderable'}`.
+4. With no winner, the slot is `no_bid` only when at least one provider was
+   dispatched and every eligible/dispatched provider
+   completed successfully with no candidate.
+5. With no winner and any provider or mediation failure, the slot is `failed` with
+   the first applicable reason in this closed priority order: `internal_error`,
+   `mediation_failed`, `invalid_provider_response`, `provider_error`,
+   `provider_timeout`, `consent_denied`, `auction_disabled`, `slot_not_eligible`.
+   `winner_not_renderable` and `identity_generation_failed` are selected directly by
+   rule 3 and do not participate in multi-provider priority. Completion order is
+   irrelevant.
+
+`/auction` keeps ordinary OpenRTB winners in `seatbid` and places the decision set
+at `ext.trusted_server.slot_results`. Every TS winner bid has this exact nested
+extension; unknown keys inside `trusted_server` are invalid:
+
+```ts
+interface TrustedServerOpenRtbBidExtV1 {
+  candidate_id: string
+  slot_id: string
+  render_source: BidRenderSourceV1
+}
+```
+
+For an APS/ADM source, the bid's standard `id` is the server-minted renderer
+reservation id from §2.2. An rc-baseline `pbs_cache` source retains its cache-id
+identity instead and never enters the reservation service. The provider's upstream
+id remains provenance and, for APS, the descriptor's `bidId`. The bid's standard `impid` must equal the request impression id mapped to
+`slot_id`. A winner decision joins by exact `slot`, `candidateId`, `impid`, and
+`slot_id` to exactly one bid. A no-bid or failed decision joins none. Missing,
+duplicate, extra, or mismatched joins make the entire response invalid to TSJS.
+TSJS renders only `render_source`; it never infers a source from standard OpenRTB
+fields. If a bid also carries standard `adm`, it is permitted only for an ADM source
+and must equal `render_source.adm` byte-for-byte; an `adm` on APS/cache or a mismatch
+is invalid. `/_ts/page-bids` returns `BrowserAuctionProjectionV1`, and initial HTML
+stores that same value at `tsjs.boot.auctionProjection`. They do not carry a second
+legacy `{slots,bids}` interpretation. The deprecated `/__ts/page-bids` endpoint and
+its JS fallback are deleted at cutover.
+
+### 3.3 APS response admission
+
+APS response handling is deterministic and reports typed local drop reasons:
+
+- upstream bid id is required, bounded to 64 UTF-8 bytes, and unique within the
+  provider response;
+- malformed `contextual`, missing `creativeurl`, invalid tag type, invalid URL,
+  invalid dimensions, disallowed script, and malformed price are rejected per bid
+  where safe; one bad bid does not discard unrelated valid bids;
+- dimensions must exactly match one requested size; values are never clamped;
+- script creatives remain default-off and require an explicit security-approved
+  setting; iframe creatives remain supported by default;
+- the validated AAX projection used in `aaxResponse` is derived from the accepted
+  bid, not re-parsed from a later lossy structure.
+
+Drop reasons must remain visible in the existing debug/log surfaces for all auction
+entry points. This is not a new external telemetry contract.
+
+APS configuration accepts only canonical `account_id`; the `pub_id` deserialization
+alias and its integer coercion are deleted at the hard cutover.
+
+Deployment is ordered so the old serving binary receives the canonical configuration
+first: replace `pub_id` with quoted string `account_id`, quote numeric identifiers,
+remove legacy and unknown APS keys, run `ts config validate`, and push while the old
+binary that accepts `account_id` is still active. Only then deploy the new binary.
+No alias or coercion is added to make an out-of-order deployment succeed.
+
+### 3.4 Mediation provenance
+
+This work preserves the configured mediator's existing candidate selection and
+timeout fallback behavior. It changes only the unsafe reconstruction boundary for
+renderer-bearing source candidates:
+
+1. Candidate provenance is `(provider_name, upstream_bid_id)`. Missing, duplicate,
+   or oversized upstream ids are rejected.
+2. Every candidate receives a response-unique, opaque, server-minted 12-character
+   base64url `candidate_id` from 9 CSPRNG bytes. Generation retries a
+   response-local collision at most eight times, then fails the affected slot with
+   `internal_error`; the id is never an ordering key.
+3. The mediation request carries it only at
+   `ext.trusted_server.candidate_id`. A mediator-selected source candidate must echo
+   exactly one known id. Missing, unknown, or duplicate echoes are
+   `mediation_failed` and cannot borrow render data from another candidate.
+4. The resolved candidate takes only the mediator-selected price and existing
+   selection metadata from the mediator. Provider, upstream id, render source,
+   dimensions, currency, and notifications come from the stored source candidate.
+   Mediator-native render sources are rejected as out of scope.
+5. Direct no-mediator selection keeps the repository's current highest-CPM rule;
+   an exact CPM tie is resolved deterministically by provider name and upstream bid
+   id. An APS bid explicitly declaring a non-USD currency is invalid. This design
+   adds no auction currency or winner-selection configuration requirement.
+
+### 3.5 Publisher projection and GAM targeting
+
+The publisher bid projection carries `renderSource: BidRenderSourceV1` intact on
+every path, plus the exact `candidateId` and, for APS/ADM only,
+`rendererReservationId`. Initial HTML
+stores the document-generation input at
+`tsjs.boot.auctionProjection: BrowserAuctionProjectionV1`. The initial
+`NavigationSession` seeds its internal current projection from that immutable boot
+value; an SPA page-bids response replaces only the new session's internal projection
+through the transaction in §2.5. It never mutates `tsjs.boot`. A winner decision
+must join exactly one projected bid and a no-bid/failed decision must join none.
+Every decision also joins its exact ordered `slots` placement. Static placement
+targeting is applied first, bid targeting overrides a duplicate static key, and the
+runtime alone synthesizes `hb_adid` from `rendererReservationId` for APS/ADM or the
+native cache UUID for `pbs_cache`; neither server targeting object may provide that
+key.
+Targeting uses the APS/ADM reservation id or the rc-baseline PBS Cache UUID according to
+the discriminated source and never truncates a value to fit GAM.
+If the chosen value cannot satisfy the 40-character targeting limit, the bid is
+rejected before targeting with an explicit local reason.
+
+Targeting cleanup is owner-and-value checked, not value-only. One runtime-owned
+journal stack per physical GPT slot and targeting key records an internal owner id,
+the exact installed string, and the predecessor value/owner for every TS write.
+The sole GPT adapter observes each live slot's `setTargeting` and `clearTargeting`
+calls and uses a closure-private reentrancy marker for TS-originated writes. Before
+forwarding any publisher-originated mutation it invalidates the affected key's TS
+restoration chain—or every chain for clear-all—regardless of whether the publisher
+writes the same string. This bookkeeping never changes the publisher call's
+arguments, return, throw, or order.
+Before a write, a mismatch between the actual GPT value and the current TS frame
+means publisher code changed the key; the runtime drops its restoration chain and
+preserves that publisher value. Otherwise the new attempt pushes a distinct owner
+frame before setting the value, even when its string equals the predecessor's.
+
+Supersession, empty render, terminal failure, and navigation disposal mutate GPT
+only when the disposing frame is current owner and the actual string still equals
+its installed string. A current provisional frame then restores its immediate live
+predecessor, or the original publisher value/absence. Disposing an older frame below
+a newer owner performs no GPT write and rebases the successor to the removed frame's
+predecessor. Acceptance promotes the new attempt's frames into its
+`CommittedRenderArtifact`; disposal of the prior accepted artifact uses that same
+non-top rebase. Thus two generations installing an identical string remain distinct:
+newer success cannot be cleared by older disposal, newer failure can reveal the
+still-live older value, and a publisher mutation is never overwritten.
+
+Publishing a TS-owned PUC bid is one ordered transaction. The browser first
+validates the winner, tagged source, slot join, and server-minted reservation id and
+prepares all targeting/bid objects without exposing them. It then inserts the
+reservation as live in the bounded store. Store capacity or collision therefore
+fails before a creative can observe the id.
+
+For SSAT/page-bids, only after successful insertion may it expose that same id as
+GAM `hb_adid`, publish other targeting, record GPT intent, and invoke a
+request-capable GPT operation—in that order. Any failure before request invocation
+tombstones the reservation, compare-restores targeting, and settles the attempt.
+
+The composition resolves each projected `divId` to the exact element first, then to
+one unambiguous responsive/hydrated prefix match; container-shell aliases are not
+treated as creative roots and ambiguity fails `slot_unresolved`. If GPT already owns
+exactly one live slot for the resolved element, the slot service adopts that publisher
+object and publishes with `refresh`. Otherwise the sole GPT adapter performs a
+transactional `defineSlot`/`addService`/adoption and publishes with `display`.
+Staleness destroys the unadopted candidate, and no path may leave a second physical
+slot. Initial boot and every successfully committed page-bids replacement use this
+same publisher. `pushState`, `replaceState`, and `popstate` share pathname-plus-query
+identity; identical routes are suppressed, a current failed/rejected response rolls
+back to the last committed path so the same route can retry, and an older response
+cannot roll back or publish over a newer navigation generation.
+
+For the Trusted Server Prebid adapter, the supported artifact is the content-addressed
+external bundle built from exactly lockfile-resolved Prebid.js 10.26.0. The external
+artifact contains no Trusted Server auction, admission, render, or refresh behavior.
+The TS-owned `PrebidAdapter` exposes one internal version-pinned
+`admitTrustedBid(preparedBid)` boundary:
+
+```ts
+interface PreparedTrustedBid {
+  readonly auctionId: string
+  readonly adUnitCode: string
+  readonly bid: Readonly<{
+    requestId: string
+    adId: string
+    cpm: number
+    width: number
+    height: number
+    ad: ''
+    ttl: 300
+    creativeId: string
+    netRevenue: true
+    currency: 'USD'
+    bidderCode: string
+    meta: Readonly<{
+      advertiserDomains: readonly string[]
+      tsAuctionId: string
+      tsBidId: string
+      tsAdmHash?: string
+    }>
+  }>
+}
+
+interface PrebidAdapter {
+  admitTrustedBid(
+    preparedBid: Readonly<PreparedTrustedBid>
+  ): 'admitted' | 'not_admitted'
+}
+```
+
+All strings and numbers already satisfy their canonical auction/projection bounds;
+`adId` is the exact admitted `r1_` reservation, and no renderer descriptor, ADM, cache
+coordinate, or other capability crosses this boundary. The empty `ad` is deliberate:
+the TS bridge resolves the already-stored tagged render source only after the PUC
+claim. The adapter owns the bound Prebid object, registered `trustedServer` bidder
+adapter, and the exact 10.26.0 response-admission callback; neither the external
+artifact stamp nor publisher code exposes this method.
+
+All validation, reservation insertion, exact replacement of the TS bid's `adId`, and
+frozen bid-object construction complete before the call; no targeting or other
+publisher-visible mutation precedes it. The boundary returns exactly
+`admitted | not_admitted`, and the 10.26.0 artifact fixture proves `not_admitted`
+leaves no bid/event/targeting state. `not_admitted` tombstones the reservation and settles
+`failed{reason:'prebid_admission_failed'}`. A throw settles the same failure; detected
+partial publication tombstones the id, suppresses every later PUC request, settles
+`failed{reason:'prebid_contract_violation'}`, and fails the artifact-conformance
+gate. Runtime handling is fail-closed even though the same violation blocks future
+release. A Prebid version change requires a reviewed contract-fixture update.
+
+`admitted` moves the reservation into an `awaiting_prebid_selection` state; it does
+not create a render attempt or transfer permanent ownership. The Prebid adapter's
+early synchronous `auctionEnd` listener uses the supported artifact's exact
+auction-id/ad-unit winner query before publisher targeting callbacks. It promotes
+only the exact selected TS `adId` to a render attempt and atomically tombstones every
+other TS reservation admitted for that auction/ad unit as unselected. A ten-second
+watchdog from admission performs the same tombstoning and records
+`prebid_selection_timeout` if no matching `auctionEnd` arrives. Navigation or auction
+abort tombstones the whole admitted set immediately. Subsequent GPT/render failure
+follows the normal terminal lifecycle for the selected reservation. A fast Universal
+Creative request can never race ahead of reservation lookup, and a losing bid cannot
+hold capacity until the 15-minute tombstone expiry as a live entry.
+
+### 3.6 Static renderer and APS runner proxy endpoints
+
+`/integrations/aps/renderer/v2` and `/integrations/aps/runner.js` are always-reserved
+Trusted Server routes. When APS is enabled, `GET` returns the local static bootstrap
+or proxies the APS-hosted creative runner respectively. When APS is disabled, `GET`
+returns a local `404 no-store`; neither route ever falls through to a publisher
+origin. The family is dispatched before publisher auth, EC, and generic integration
+filters. All adapters expose the same method, routing, security-header, and failure
+semantics. Unsupported methods return local `405` with `Allow: GET`; unknown
+renderer versions and the abandoned `/integrations/aps/runner/v1.js` shape return a
+local `404 no-store`.
+
+Because the two routes are loaded by browser documents, they are intentionally
+anonymous. A configured `[[handlers]]` pattern that matches
+`/integrations/aps/*` does not apply and must never be represented as protecting the
+renderer or runner. Operator-required admission control, rate limiting, and request
+shielding live at the deployment platform.
+
+The renderer v2 response is an immutable, descriptor-free materialization bootstrap
+served with a long-lived immutable cache policy. It embeds the TS-authored outer and
+inner document templates, the generated ES5 descriptor validator, and the fixed
+same-origin runner-proxy path. It contains no attempt descriptor, concrete bid or
+creative value, vendor bytes, publisher DOM authority, or pre-navigation network
+operation. It is not the document that receives the bid or executes the runner. Its
+TS-created iframe initially has exactly this sandbox token set, serialized in this
+order:
+
+```text
+allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation
+```
+
+It omits `allow-same-origin`, `allow-top-navigation`, downloads, modals,
+presentation, orientation lock, and storage-access escape. The bootstrap's exact
+response CSP is:
+
+```text
+default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' http: https:; connect-src http: https:; frame-src data: https:; img-src data: blob: http: https:; media-src blob: http: https:; style-src 'unsafe-inline' http: https:; font-src data: http: https:; worker-src blob: http: https:; frame-ancestors 'self'; form-action https:;
+```
+
+The browser inherits this response policy across the bootstrap's `data:`
+navigation. It is therefore an intentional transport superset and has no CSP
+`sandbox` directive: otherwise it would block the nested data frame, same-origin
+runner proxy, inline layout, and permanent creative sandbox tokens required by the
+generated documents. The descriptor-free bootstrap has no pre-configuration
+network operation. After configuration, the generated outer and inner meta CSPs
+intersect with this response policy and narrow every network-capable directive to
+the exact Trusted Server and validated creative origins for that attempt.
+
+The bootstrap validates its exact `b1_` fragment nonce, sends readiness only to its
+actual `parent`, and accepts one canonical JSON configuration from that exact
+`WindowProxy`, with an exact browser-reported HTTP(S) sender origin and no transferred
+ports. It has no `document.referrer` dependency, so a publisher's stricter referrer
+policy cannot disable the handshake:
+
+```ts
+{
+  message: 'TS APS Bootstrap Configure'
+  version: 2
+  bootstrapNonce: string
+  rendererNonce: string
+  creativeOrigin: string
+  tagType: 'iframe' | 'script'
+}
+```
+
+The complete configuration is capped at 16,384 UTF-8 bytes. `creativeOrigin` must
+be an exact HTTPS origin distinct from the parent, and the two nonces must have their
+exact independent `b1_` and `n1_` forms. The bootstrap then substitutes only those
+policy values into the checked templates, enforces the separate 65,536-byte document
+caps and 196,663-byte encoded-container cap, and replaces its own location with the
+fresh outer `data:text/html;charset=utf-8,` URL. It receives no descriptor and cannot
+make a runner or creative request before that navigation. The response also has
+exactly `Content-Type: text/html; charset=utf-8`,
+`Cache-Control: public, max-age=31536000, immutable`,
+`X-Content-Type-Options: nosniff`, and `Referrer-Policy: no-referrer`. It deliberately
+omits `X-Frame-Options`; `frame-ancestors 'self'` is mandatory because both direct and
+PUC paths mount the bootstrap from the publisher top page, never beneath GAM,
+Universal Creative, or bidder content. The TS-authored container and inner renderer
+remain `data:` documents rather than separately addressable HTTP artifacts and
+contain no third-party bytes. The checked-in generator materializes their source into
+the server-owned v2 response at build time; neither the first-display nor persistent
+TSJS production graph imports the document templates or generated ES5 validator.
+The abandoned renderer-v1 route is a local `404`, with no compatibility branch. Any
+shipped bootstrap body/header or data-document protocol change before this release
+updates the single v2 contract; after release it requires a new route/protocol
+version.
+
+When APS is enabled, final response privacy appends a separate
+`Content-Security-Policy: frame-ancestors 'self'` policy after operator headers. CSP
+policies intersect, so operator configuration cannot weaken it. This prevents an
+APS creative from framing a publisher document beneath the opaque data container
+and using a publisher-origin executable gadget to regain top-page access. It also
+means an APS-enabled publisher cannot itself be embedded cross-origin; an external
+embedder allowlist is a separate security design, not a compatibility exception.
+The policy is independent of cookies and cacheability.
+
+The runner endpoint is a thin runtime transport proxy, not an artifact store. Its
+only upstream is the fixed APS URL
+`https://client.aps.amazon-adsystem.com/prebid-creative.js`; no request field,
+configuration value, query parameter, or header can select another target. Trusted
+Server issues a credential-free, referrer-free `GET`, does not forward browser
+cookies, authorization, client IP, or publisher headers, requests
+`Accept-Encoding: identity`, and disables redirect following in the platform client.
+
+The platform HTTP abstraction exposes an internal `ProxyResponseEvidenceV1` policy
+used only by this route. It preserves upstream status and security-relevant evidence
+for every occurrence of `Content-Type`, `Content-Encoding`, and `Content-Length`
+before the generic proxy removes headers or consumes the body. An adapter that
+exposes duplicate fields separately returns every raw value. An adapter runtime that
+combines duplicates may return its exact combined value only when the combination is
+visible and cannot be mistaken for a valid singleton; the closed grammars below
+reject any comma/list form for all three headers. It is forbidden to split a combined
+value or normalize it into an apparently valid singleton. All other upstream headers
+are irrelevant because the successful response drops them.
+
+The policy requests identity encoding, prevents redirect following, and returns the
+identity body as a bounded stream or bounded buffer without transforming bytes.
+Cloudflare inspects the initial Workers `Headers` values before the generic adapter
+strips encoding/length; concatenated duplicate values remain combined and therefore
+fail the singleton grammars. If the runtime erases encoding evidence or decodes a
+non-identity response without exposing that fact, the evidence is `unavailable` and
+the proxy rejects it. Fastly and Axum apply the same evidence/no-decompression
+contract. No adapter may reconstruct erased evidence.
+
+The entire upstream operation—from dispatch through the final response-body byte—has
+a five-second monotonic deadline. Deadline expiry cancels the platform pending
+request, discards every collected byte, and makes any unavoidable late platform
+continuation self-discard without constructing a response. It returns the same local
+failure as any other proxy error and cannot outlive the ten-second APS-completion
+deadline. Spin does not use its current eager `spin_sdk::http::send` path for this
+policy: it calls the WASI HTTP outgoing handler with supported request options and
+polls the response/body stream against a monotonic-clock pollable for the total
+deadline. Failure to set the transport timeouts or cancel/drop the pending resources
+is `unavailable` evidence and prevents APS from being enabled on that build.
+
+The proxy accepts only status `200`. `Content-Encoding` must be absent or exactly one
+case-insensitive `identity` token; lists and every other coding are rejected. Exactly
+one parseable `Content-Type` header is required. Its case-insensitive essence must be
+`application/javascript` or `text/javascript`, with either no parameters or only one
+case-insensitive `charset=utf-8` parameter; duplicate or unknown parameters and every
+other media type or charset are rejected. The exact body cap is
+`APS_RUNNER_MAX_RESPONSE_BYTES = 8 MiB` on every adapter. If exactly one canonical
+decimal `Content-Length` matching `^(0|[1-9][0-9]*)$` is present, it is rejected
+before collection when above the cap and must equal the final identity-body byte
+count. Missing length is allowed; duplicate, malformed, mismatched, or conflicting
+values fail. Collection stops and cancels the request as soon as streamed or buffered
+bytes exceed the cap. The complete body must decode as UTF-8 without replacement;
+validation never transforms the bytes.
+
+A successful response relays the upstream body bytes unchanged while replacing
+transport headers with
+`Content-Type: application/javascript; charset=utf-8`,
+`Access-Control-Allow-Origin: *`,
+`Cross-Origin-Resource-Policy: cross-origin`,
+`X-Content-Type-Options: nosniff`, and `Referrer-Policy: no-referrer`. Upstream
+cookies and all other response headers are dropped. Upstream fetch, status, media
+type, content encoding, redirect, length, size, or deadline failure returns a local
+empty `502 no-store`; vendor bodies are never exposed in logs or error responses.
+The adversarial parity corpus executes through each real adapter transport, including
+Cloudflare and Spin wasm, rather than injecting already-normalized core responses. An
+adapter that cannot preserve the raw evidence, common cap, or total deadline cannot
+enable APS and blocks the release.
+
+Runtime-harness readiness is distinct from endpoint acceptance. In particular, the
+Cloudflare/Wrangler harness must not declare the service ready merely because one
+worker answers an unrelated `GET` while a service-binding worker can still return a
+transient startup `503`. Before the adversarial corpus begins, that harness requires
+two consecutive requests to the actual renderer route using the deliberately
+unsupported `PROPFIND` method to return the complete local `405` contract, including
+`Allow: GET` and `Cache-Control: no-store`; any other result resets the consecutive
+count. This readiness probe does not replace or relax the corpus's own independent
+`PROPFIND` assertion, and production request handling remains unchanged.
+
+No APS runner bytes, digest, vendor-version record, redistribution license, update
+script, generated artifact, or offline fallback is stored in Trusted Server source or
+release artifacts. The runner route is live, unversioned, unvendored, unpinned, and
+uncached by Trusted Server because it represents a mutable APS-owned dependency, not
+immutable TS-owned bytes. A successful relay adds no Trusted Server `Cache-Control`
+requirement. Platform shielding may bound upstream exposure operationally, but it
+cannot turn the runner into a repository or release artifact.
+
+Proxying does not make the runner trusted TS code or prove that it rendered. APS
+remains the runtime owner of those executable bytes and its resolve/reject semantics
+are a narrow external trust dependency. The nested opaque data documents, validated
+descriptor, one-shot lifecycle port, and completion deadline contain execution and
+reject missing, late, or misbound signals; they cannot determine whether APS told the
+truth when it invoked `resolve`. The proxy never rewrites, inspects, or repairs the
+JavaScript body.
+
+The inner data renderer accepts one port-delivered, nonce-bound descriptor plus the publisher
+origin captured by the kernel before iframe creation. Because its opaque origin has
+`location.origin === "null"`, it validates the supplied origin's shape and uses it
+only to repeat the descriptor's not-publisher-origin check. It clears the nonce from
+its URL and implements the TS side of `ApsRunnerContractV1`. Before runner load, it
+creates a one-shot Promise and queues exactly:
+
+```ts
+new CustomEvent('prebid/creative/render', {
+  detail: {
+    aaxResponse: renderer.aaxResponse,
+    seatBidId: renderer.bidId,
+    source: 'internal',
+    resolve,
+    reject,
+  },
+})
+```
+
+`resolve` and `reject` are the Promise's one-shot functions and are the only
+non-serializable fields. The server-owned v2 materializer encodes the exact validated HTTP(S)
+Trusted Server origin and absolute `/integrations/aps/runner.js` URL into the
+TS-authored inner data document before navigation. The inner CSP permits that exact
+origin as its only external script source, and the renderer loads only that route. It creates the
+script with `crossOrigin='anonymous'` and `referrerPolicy='no-referrer'`; it does not
+set SRI because the proxy relays a live APS-owned artifact rather than immutable
+TS-owned bytes. Under the APS conformance contract, the runner consumes the queued
+event and promises to call `resolve` only after its asynchronous handler commits the
+nested creative iframe, and to call `reject` for validation, load, or render failure.
+Promise resolution sends one completed result; rejection, proxy/CORS error, runner
+error, or script-load error sends one failed result over the transferred lifecycle
+port. Runner `load` is intermediate progress only. The inner renderer owns no APS
+completion timer. Proxy/CORS/script-load failure maps to `runner_no_load`; callback
+rejection maps to `runner_failed`.
+
+A locally authored fictional fixture implements the exact proxy and
+queue/resolve/reject behavior; it is not a copy, transformation, or derivative of the
+APS body. Real-GAM tests exercise the live proxied APS dependency in all three
+browsers and are a release prerequisite. The APS runner is allowed to change
+upstream. Load failure, explicit rejection, and silence fail closed through the
+existing APS-completion deadline. A changed or compromised APS runner can invoke
+`resolve` prematurely or incorrectly; this is an accepted external-dependency risk
+that the outer renderer cannot detect. Real-browser DOM/network conformance reduces
+but does not eliminate it. This design never loads the APS URL directly from the browser,
+executes a stored fallback, treats script `load` as completion, or uses a reusable
+global `postMessage` acknowledgement.
+
+## 4. Render lifecycle protocol
+
+The **ActiveRenderOwner** is one logical owner with non-overlapping agent and
+persistent epochs. On an eligible initial page, the agent epoch instantiates the
+§4 dispatcher, reservation/ticket/bootstrap-nonce/renderer-nonce registries, terminal latches, provisional
+GPT adapter/listeners, and APS/ADM channels for only the immutable projected batch.
+Every “kernel” or “runtime” action in this section is performed by that active epoch.
+At §5.2.1 takeover, all attempts and ports are terminal, tombstones/counters/facts
+cross in the exact handoff, live physical/committed objects cross only in the
+one-use capsule, and fresh persistent dispatcher/GPT listeners become the sole
+active epoch. On a no-agent page, persistent core is the first and only epoch.
+
+The agent records the correctness-required GPT `slotRequested` and
+`slotRenderEnded` facts before issuing the initial request. When diagnostics are
+enabled it also records all six bounded §5.8 observations, trace tokens/cycles, and
+overflow counters into the handoff; persistent diagnostics adopts and replays those
+facts before live delivery. No diagnostic listener is counted twice and loss of a
+diagnostic fact cannot change lifecycle authority. Any §4 wording that assigns the
+initial dispatcher/channel exclusively to “core” means the current
+`ActiveRenderOwner`, not necessarily the post-paint persistent artifact.
+
+### 4.1 State machine
+
+```text
+created
+  -> no_bid | waiting_for_gam_and_claim | rendering_direct | failed | cancelled
+waiting_for_gam_and_claim
+  -> waiting_for_owner | failed | cancelled
+waiting_for_owner
+  -> waiting_for_insertion | failed | cancelled
+waiting_for_insertion
+  -> waiting_for_document | waiting_for_adm | failed | cancelled
+rendering_direct
+  -> waiting_for_document | waiting_for_adm | failed | cancelled
+waiting_for_document
+  -> waiting_for_aps_completion | failed | cancelled
+waiting_for_aps_completion
+  -> accepted | failed | cancelled
+waiting_for_adm
+  -> accepted | failed | cancelled
+```
+
+`no_bid` is terminal and is valid only as `created -> no_bid`: it records the exact,
+successfully parsed server decision that the slot has no winner before any render path
+starts. It is invalid from every later state; GAM empty, transport, timeout, parse,
+descriptor, and renderer failures retain their explicit failure outcome.
+`failed` and `cancelled` remain valid from `created` so an auction child can settle
+when its exact server decision fails or its caller/batch/navigation cancels before a
+render path begins.
+
+Transitions are methods on `RenderAttempt`, not ad-hoc flag mutation. Each method
+checks the expected state and terminal latch. Timers are created at the transition
+whose deadline they enforce and are cleared by the transition that settles them.
+`waiting_for_document` accepts only an APS source; `waiting_for_adm` accepts only an
+ADM source. Direct and PUC APS stage only a top-page `aps_mount` artifact; PUC APS
+also stages Promise/control metadata but no remote renderer node. Direct ADM stages
+only a `direct_iframe` artifact, while PUC ADM stages only a `puc` artifact.
+The baseline PBS Cache path remains outside this new attempt-state expansion and is
+covered by §4.5 parity tests.
+Construction owns an already-issued attempt scope: every rejection after scope
+issuance best-effort disposes that exact scope so session indexes cannot retain a
+failed construction or block a same-slot retry.
+
+An accepted transition first atomically promotes durable DOM/targeting ownership
+from the attempt into one `CommittedRenderArtifact` owned by the exact slot and
+navigation. The attempt disposer removes only uncommitted resources; promotion
+detaches the committed iframe, targeting snapshot, and physical-slot metadata before
+the terminal latch disposes the attempt. Direct APS mounts retire on exact artifact
+replacement, owned-node/binding loss, or navigation disposal. PUC APS mounts also
+retire on the publisher/competing/ambiguous `slotRequested` and successful
+publisher-`destroySlots` paths defined below. Every retirement shares the same
+artifact exact-once latch. The physical GPT/PUC surface remains
+owned by its GPT slot: for a TS-owned slot the artifact may dispose it only through
+safe GPT destroy/redefine, while publisher-owned slot DOM remains publisher-controlled
+and the artifact releases only TS metadata and compare-restorable targeting. Before a
+slot publishes another accepted artifact it disposes the prior artifact. Navigation
+disposes artifacts according to those same ownership/quarantine rules.
+
+A committed GPT/PUC APS overlay is also bound to the exact physical GPT object and
+binding epoch that produced it. The sole early `slotRequested` listener classifies
+the new physical cycle before any later GPT listener runs. An exactly attributable
+TS-owned replacement cycle retains the prior accepted artifact until a new TS
+artifact commits, so a failed TS replacement does not blank a valid prior result. A
+publisher-owned, competing, or ambiguous cycle instead synchronously retires the
+prior TS artifact before that `slotRequested` callback returns: it removes only the
+TS overlay, releases compare-owned host style and targeting, and clears artifact
+metadata without destroying the GPT object, cancelling publisher work, or sending a
+second PUC settlement. An ambiguous/competing cycle separately fails any affected
+live TS attempt under §2.4. Thus native publisher refresh/display can never render
+behind a stale accepted overlay.
+
+Artifact DOM identity is guarded independently of GPT callbacks. The existing
+navigation binding observer treats a disconnected/replaced host, an overlay no
+longer parented by its exact host, or an overlay whose exact node was removed as
+artifact retirement. Its idempotent disposer removes the owned node wherever it was
+moved, compare-restores only the original host values still owned by TS, and drops
+the metadata; it never traverses or removes a publisher/GPT child. The GPT adapter
+also snapshots the exact targeted physical objects before a publisher-originated
+`destroySlots` call and, only when that call returns success, retires their artifacts
+before returning to the publisher. A throw/false result leaves a still-connected
+artifact intact, while the DOM guard still cleans up anything GPT actually removed.
+All these paths share the artifact's exact-once latch and race safely with TS
+replacement commit, navigation disposal, and late callbacks.
+
+Claim,
+registration, owner-control, and renderer-document ports/listeners that are no
+longer needed close after terminal settlement and are never promoted.
+Artifact disposal is synchronous and exact-once. A disposer that throws, returns a
+Promise/thenable, or otherwise violates the synchronous contract fails closed and
+cannot authorize publication of a replacement or later republication of the disposed
+artifact object.
+
+### 4.2 Universal Creative claim
+
+The supported GAM creative selects Prebid Universal Creative 1.17.2 outside the
+Trusted Server source tree, never `latest` or a publisher-selectable version. No PUC
+bytes, checksum, or distributable artifact is vendored into this repository. Its
+cross-domain request is a JSON
+string decoding to exactly
+`{message:"Prebid Request",adId,adServerDomain}` and carries exactly one transferred
+response port. All three values are strings; `adId` and `adServerDomain` are
+nonempty. Object-form or extended payloads are rejected. Universal Creative owns
+this shape, so it cannot carry a TS nonce. Hermetic unit and browser tests exercise a
+locally authored contract harness limited to that public message/helper behavior;
+the pre-production real-GAM conformance gate exercises the actual PUC release. The
+protected page's frozen test API exposes `pucRelease`, and the gate accepts only the
+exact value `1.17.2`; a missing, publisher-selected, or `latest` value blocks cutover.
+
+The bridge is one capture-phase dispatcher installed as the first reversible core
+effect in the synchronous activation barrier, before any integration-module
+activation and before any TS-owned GPT or Prebid script injection. This guarantees
+it precedes native non-capture listeners installed later by TS while leaving no
+dispatcher active during asynchronous preparation;
+publisher capture listeners that already ran are inside the publisher trust
+boundary. The runtime's dispatcher owns both the initial-request branch below and
+the owner-registration branch in §4.3; no second global listener exists. It performs
+this order:
+
+1. Perform only minimal, side-effect-free recognition. For a JSON string or a
+   clone-safe plain object, inspect own data properties only and extract string
+   `message`, `adId`, and an optional string `lifecycleTicket`. Do not read accessors
+   or traverse prototypes. Malformed or unrecognizable data is ignored.
+2. Route `message === 'TS Render Owner Register'` to §4.3. If
+   `message !== 'Prebid Request'`, ignore it. For `Prebid Request`, look up the
+   extracted `adId` in the global reservation/tombstone store before exact parsing,
+   port, or slot-local checks.
+3. For a non-TS id, do not suppress native Prebid. For a live or tombstoned TS id,
+   immediately call `stopImmediatePropagation()` so an extended/object-form request,
+   wrong port count, stolen capability, or replay cannot fall through.
+4. Only after suppression, require the supported exact JSON-string shape and exactly
+   one transferred port. A recognized TS id with invalid shape/port is generically
+   refused when a usable port exists; all available ports are closed. It never
+   reaches native Prebid.
+5. The first exact live claim during the compatible active GPT cycle acquires the
+   authoritative PUC `WindowProxy` from `MessageEvent.source` and stores that source
+   with its response port. This is the only source acquisition step; SafeFrame
+   ancestry is neither inspected nor guessed. Later owner messages must come from
+   this exact source. The unguessable reservation id, exact active slot/generation,
+   and one-time consumption authorize the first claim. Same-realm publisher code is
+   already inside the documented trust boundary.
+6. Join the buffered claim with an attributable nonempty `slotRenderEnded`. A claim
+   that arrives first is bounded by the owning GPT-cycle/attempt deadline, discloses
+   no render data, and holds only its source and port. A nonempty GAM result that
+   arrives first starts a three-second claim deadline. Only when both conditions are
+   true does the runtime atomically revalidate and consume the reservation.
+7. Empty GAM, navigation disposal, supersession, an incompatible cycle, or the
+   attempt deadline closes a buffered port, tombstones the reservation, and settles
+   the attempt. A second claim is generically refused; it never replaces the first.
+
+The successful outer response is an exact JSON string:
+
+```ts
+{
+  message: 'Prebid Response'
+  adId: string
+  renderer: string
+  rendererVersion: '4'
+  tsOwner: {
+    version: 1
+    status: 'ready'
+    kind: 'aps' | 'adm'
+    lifecycleTicket: string
+  }
+}
+```
+
+`rendererVersion:'4'` is the hard-cutover top-mount owner protocol; the old
+renderer-version value is not accepted or aliased. `renderer` is the checked-in TS
+dynamic-owner program, which owns only PUC registration and Promise settlement.
+It is returned directly in this response and remains self-contained: it does not
+fetch, import, inject, or evaluate another TSJS asset. Its implementation may be
+mechanically compacted and may share a smaller internal parser, but exact v4
+messages, source/port binding, watchdogs, ADM insertion, APS informational control,
+Promise settlement, and failure behavior are unchanged.
+`lifecycleTicket` is
+`t1_` plus 22 unpadded base64url characters from 16 CSPRNG bytes, bound to the
+attempt, generation, source, and reservation, with a fixed three-second TTL from
+posting the outer response. No descriptor or ADM appears in the outer response. A
+recognized TS id that cannot be served receives the same response shape with
+`tsOwner:{version:1,status:'refused'}` and no other `tsOwner` keys; the dynamic owner
+rejects immediately, causing PUC to emit its ordinary `adRenderFailed`. If no usable
+response port exists, the listener can only suppress and close available ports.
+The claim deadline expiry is `bridge_claim_timeout`.
+
+### 4.3 Owner-control registration
+
+PUC executes a dynamic renderer in a hidden `__pb_renderer__` iframe, so a global
+message posted by that hidden frame cannot satisfy source binding. The TS owner must
+instead call PUC's supplied `h.sendMessage(type,payload,onResponse)` helper. PUC
+adds `adId`, serializes the request, sends it from the original PUC frame, and
+creates the response channel.
+
+The owner calls:
+
+```ts
+h.sendMessage(
+  'TS Render Owner Register',
+  { version: 1, lifecycleTicket },
+  onRegistrationResponse
+)
+```
+
+The kernel therefore receives exact JSON
+`{message:"TS Render Owner Register",adId,version:1,lifecycleTicket}` from the
+captured PUC `WindowProxy` plus exactly one helper-created response port. It
+atomically consumes a live ticket and checks the exact `adId`, source, attempt, and
+generation. Success posts exact JSON
+`{message:"TS Render Owner Registered",adId,version:1,lifecycleTicket}` on that
+response port and transfers exactly one newly-created owner-control port. Refusal
+posts exact JSON `{message:"TS Render Owner Refused",adId,version:1}` with no
+transferred port. These are the only registration responses.
+
+This message is received by the same capture-phase dispatcher from §4.2. Its
+registration branch first looks up the minimally extracted `lifecycleTicket` in the
+runtime ticket/tombstone map. An unknown ticket is ignored for native/publisher
+listeners. For a live or tombstoned TS ticket it immediately calls
+`stopImmediatePropagation()` before exact JSON-shape or port validation, then checks
+the captured source, exact `adId`, ticket, attempt, generation, and exactly one port.
+A recognized invalid/replayed request is generically refused when a usable port
+exists and all available ports are closed. Ticket settlement, consumption, or
+attempt disposal replaces its live entry with a tombstone through the original fixed
+ticket expiry; expiry prunes either live or tombstoned state. The dispatcher itself
+is runtime-owned; attempt disposal performs that registry transition and removes
+attempt handlers, not the global dispatcher.
+
+The owner starts a three-second watchdog before invoking `h.sendMessage`, calls the
+helper's returned stop-listening disposer after the first response, and rejects on
+timeout, refusal, malformed data, or a port count other than one. The kernel owns
+the opposite control port and the owner owns the transferred port. Replay, wrong
+source, wrong port count, stale generation, or expiry cannot bind a channel. Kernel
+and owner each have a terminal latch; late registration, acknowledgement,
+settlement, or watchdog callbacks close their ports and remain inert.
+
+### 4.4 APS document and runner acknowledgement
+
+Direct and PUC APS use one top-page mount service owned by the current
+`ActiveRenderOwner`. The PUC dynamic owner never creates, contains, or navigates an
+APS iframe; it retains only its PUC Promise, registration disposer, watchdog, and
+owner-control port. After PUC registration the kernel posts this informational
+control message with no descriptor, URL, nonce, or transferred port:
+
+```ts
+{
+  message: 'TS APS Top Mount Started'
+  version: 1
+  lifecycleTicket: string
+}
+```
+
+The PUC claim's authenticated `WindowProxy` authorizes only the reservation claim
+and later owner messages; it is never mapped back to an iframe element and is never
+used to locate DOM. The reservation already joins one exact `SlotRecord`, physical
+GPT object, active GPT cycle, and binding epoch. For PUC, the mount service asks the
+slot service for that record's one connected, uniquely bound top-page slot element,
+then revalidates the exact record, physical object, cycle, generation, element, and
+binding epoch before insertion and again before commit. It appends one TS-owned
+overlay child inside that element. For direct rendering it appends one ordinary
+child inside the exact registered caller container. An absent, disconnected,
+ambiguous, changed, or multiply claimed binding fails `slot_unresolved` before
+publication; registration order and the PUC frame tree are never fallback locators.
+
+The PUC overlay uses compare-restorable top-page style ownership: when computed
+`position` is `static`, it sets the host's inline `position:relative` only while the
+artifact owns that exact prior inline value. The outer mount iframe is the absolute,
+initially `visibility:hidden` child with `inset:0`, `z-index:2147483647`, the exact
+winning pixel width/height, and zero margin/border/scrolling/overflow. Document
+acceptance and runner load leave it hidden; only the valid `TS APS Render Completed`
+terminal transition changes its own visibility and publishes it above the existing
+GPT/PUC content. It never hides, removes, reparents, or
+traverses the GAM, PUC, SafeFrame, or bidder-controlled surface; that surface stays
+connected and inert behind the TS-owned overlay while the dynamic owner retains only
+Promise settlement authority. Direct rendering does not acquire overlay styling.
+Failure removes only the pending TS child, compare-restores only style values still
+owned by the attempt, and rejects the PUC Promise. Accepted style/DOM ownership is
+promoted to the `CommittedRenderArtifact` and follows the complete §4.1 exact-once
+retirement contract: replacement, publisher/competing/ambiguous cycle, successful
+publisher destruction, DOM-integrity loss, or navigation disposal as applicable.
+
+The mount has three document phases:
+
+1. Create one iframe at the immutable renderer-v2 bootstrap URL with the attempt's
+   `b1_` bootstrap nonce in its fragment and the initial sandbox from §3.6. The
+   bootstrap is publisher-origin by URL but opaque because `allow-same-origin` is
+   absent. It can only send exact
+   `{message:'TS APS Bootstrap Ready',version:1,bootstrapNonce}` to its checked
+   parent.
+2. After exact element, parent, `src`, `WindowProxy`, generation, and bootstrap-nonce
+   checks,
+   add `allow-same-origin` to the sandbox and post exact
+   `{message:'TS APS Bootstrap Configure',version:2,bootstrapNonce,rendererNonce,creativeOrigin,tagType}`.
+   No descriptor or generated document URL crosses this channel. The bootstrap
+   verifies the exact parent, configuration, nonces, creative origin, and tag type,
+   materializes the attempt-owned outer and inner data documents, and performs
+   `location.replace`. The previously loaded bootstrap remains opaque while it
+   performs that navigation; the destination is naturally opaque because it is
+   `data:`.
+3. The materialized outer data container creates one inner data renderer whose `data:` URL
+   fragment is the independent `n1_` renderer nonce and whose permanent sandbox
+   contains the §3.6 tokens plus
+   `allow-same-origin`. Both final documents remain naturally opaque. After the
+   exact inner `WindowProxy` sends
+   `{message:'TS APS Inner Ready',version:1,rendererNonce}` to the outer container,
+   the container creates a `MessageChannel`, transfers `port1` to that exact inner
+   window in `{message:'TS APS Inner Bind',version:1,rendererNonce}`, and transfers
+   `port2` to the top page in exact
+   `{message:'TS APS Container Ready',version:1,bootstrapNonce,rendererNonce}`. The
+   top page accepts that message only from the exact outer `WindowProxy`, for its
+   live `b1_` and `n1_` entries, with exactly one port, then retains `port2` and sends
+   the descriptor envelope once over it. Neither the bootstrap nor outer container
+   receives the descriptor. The inner accepts only `port1` from its exact outer
+   parent and only once.
+
+The descriptor envelope sent over retained `port2` is the exact structured-clone
+object below. `publisherOrigin` is the same canonical trusted-document HTTP(S)
+origin captured before mount creation, and `nonce` is the attempt's live `n1_`
+renderer nonce. The inner document validates all four own data properties and the
+complete §3.1 descriptor before acknowledging; it accepts no message discriminator,
+reservation id, attempt id, lifecycle ticket, CPM, callback, or extra field.
+
+```ts
+interface ApsDocumentEnvelopeV1 {
+  readonly version: 1
+  readonly nonce: string
+  readonly publisherOrigin: string
+  readonly renderer: Readonly<ApsRendererV1>
+}
+```
+
+After bootstrap readiness, both the outer mount iframe and its inner renderer iframe
+use this exact permanent sandbox order:
+
+```text
+allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation
+```
+
+`<TS_ORIGIN>` is the canonical ASCII HTTP(S) origin of the bootstrap URL and
+`<CREATIVE_ORIGIN>` is the canonical ASCII HTTPS origin of the validated creative
+URL. They contain no path, query, fragment, credentials, whitespace, quote, semicolon,
+or control character. For `tagType:'iframe'`, the outer data container carries this
+exact meta-CSP after sentinel substitution:
+
+```text
+default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' <TS_ORIGIN>; connect-src https: <TS_ORIGIN>; frame-src data: <CREATIVE_ORIGIN>; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;
+```
+
+Its inner data renderer carries this intersecting exact meta-CSP:
+
+```text
+default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' <TS_ORIGIN>; connect-src https: <TS_ORIGIN>; frame-src <CREATIVE_ORIGIN>; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;
+```
+
+For the explicitly enabled `tagType:'script'` case, the generator instead uses the
+following two exact policies. The only difference is the additional validated
+`<CREATIVE_ORIGIN>` in `script-src` at both inheritance levels:
+
+```text
+default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' <TS_ORIGIN> <CREATIVE_ORIGIN>; connect-src https: <TS_ORIGIN>; frame-src data: <CREATIVE_ORIGIN>; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;
+```
+
+```text
+default-src 'none'; base-uri 'none'; object-src 'none'; script-src 'unsafe-inline' <TS_ORIGIN> <CREATIVE_ORIGIN>; connect-src https: <TS_ORIGIN>; frame-src <CREATIVE_ORIGIN>; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;
+```
+
+The descriptor's already validated `tagType` selects exactly one outer/inner pair
+before template generation or DOM mutation. The generator cannot emit the union for
+an iframe creative, omit `<CREATIVE_ORIGIN>` for a script creative, or accept a
+redirect/final script origin outside that exact source. Script bytes execute only in
+the naturally opaque inner data document; no creative script is inserted into the
+outer container or publisher realm.
+
+The selected outer policy must permit the inner document's runner/resource contract
+because it is inherited by a `data:` child; the selected inner policy narrows
+creative-frame authority and, for iframe creatives, external script authority again.
+Neither policy permits publisher origin as a frame
+target unless it is also the validated creative origin, which descriptor validation
+forbids. A loopback HTTP `<TS_ORIGIN>` is named explicitly for hermetic tests and does
+not broaden `https:` production sources.
+
+The generated outer-container document contains only the exact validated creative
+origin, exact Trusted Server origin, the `b1_` bootstrap nonce, the independent
+`n1_` renderer nonce, the permanent sandbox string,
+and the percent-encoded TS-authored inner renderer template. It contains no response
+envelope, bid id, creative path, price, reservation, attempt id, or lifecycle ticket.
+Its CSP permits child frames only from `data:` and the exact creative origin. The
+inner document's intersecting CSP permits inline TS bootstrap code, the exact
+Trusted Server runner-proxy origin, and the resource categories required below the
+creative; it never permits publisher origin as a frame target. The outer policy
+therefore blocks the inner frame from replacing itself with a publisher document,
+while the independent publisher `frame-ancestors 'self'` policy blocks a
+network-loaded creative from framing the publisher beneath itself.
+
+`MAX_APS_CONTAINER_DOCUMENT_BYTES` and `MAX_APS_INNER_DOCUMENT_BYTES` are each
+65,536 UTF-8 bytes before percent encoding. Template substitution must replace each
+sentinel exactly once, leave no sentinel, escape values by context, and pass the cap
+before any DOM mutation. The exact Trusted Server origin is HTTP only for a loopback
+hermetic harness and HTTPS otherwise; the creative origin is always HTTPS and must
+equal the already validated descriptor origin. Any generation, cap, URL, CSP, nonce,
+or substitution failure is `descriptor_invalid`.
+
+The publisher realm remains trusted for top-page DOM availability because TSJS
+executes in that realm; publisher code can always remove or sabotage TSJS-owned DOM.
+No GAM, PUC, SafeFrame, bidder, or creative realm is trusted as an APS embedding
+ancestor. The exact top-page slot-host mount and nested-data CSP remove those
+third-party ancestor navigation paths from the authority chain. A separately
+operated renderer origin is not required by this design.
+
+The inner renderer sends only these exact document-port messages:
+
+- `{message:"TS APS Document Accepted",version:1,nonce}` after the envelope's exact
+  `n1_` renderer nonce and descriptor validate;
+- `{message:"TS APS Runner Loaded",version:1,nonce}` with that renderer nonce when
+  the runner script loads, as nonterminal progress;
+- `{message:"TS APS Render Completed",version:1,nonce}` with that renderer nonce
+  when the queued APS render event invokes its one-shot success callback;
+- `{message:"TS APS Render Failed",version:1,nonce,reason}` with that renderer nonce,
+  where `reason` is
+  `descriptor_invalid | runner_no_load | runner_failed`.
+
+Insertion has a one-second deadline. Bootstrap readiness, configuration/materialization navigation,
+container-channel creation, descriptor transfer, and inner document acceptance share
+one three-second deadline from outer iframe insertion. The kernel is the sole owner
+of the ten-second APS-completion deadline beginning at inner document acceptance.
+Callback silence at that deadline maps to `runner_failed`; no document starts a competing
+completion timer. Script load never accepts. Failure, timeout, port error,
+supersession, or navigation disposal settles once. On a direct path the kernel
+removes its exact pending iframe. On a PUC path the iframe is top-page DOM owned only
+by the mount service; it removes that exact pending node and posts exactly
+one owner-control settlement:
+
+```ts
+type OwnerSettlementV1 =
+  | {
+      message: 'TS Owner Settled'
+      version: 1
+      lifecycleTicket: string
+      outcome: 'accepted'
+    }
+  | {
+      message: 'TS Owner Settled'
+      version: 1
+      lifecycleTicket: string
+      outcome: 'failed'
+      reason: RenderFailureReason
+    }
+  | {
+      message: 'TS Owner Settled'
+      version: 1
+      lifecycleTicket: string
+      outcome: 'cancelled'
+      reason: 'caller_aborted' | 'superseded' | 'navigation_disposed'
+    }
+```
+
+The top-page mount service owns the APS node, its DOM handlers, bootstrap listener,
+document port, and timers. An accepted settlement promotes that exact iframe into
+the slot's `CommittedRenderArtifact`; a failed or cancelled settlement removes it.
+The promoted PUC overlay then follows §4.1's exact publisher-cycle, successful
+publisher-destroy, DOM-integrity, replacement, and navigation retirement rules; PUC
+Promise settlement is already terminal and is never repeated during retirement.
+The PUC owner owns no APS node: it closes its control port and resolves or rejects
+the renderer Promise exactly once so PUC emits its ordinary completion/failure
+event. The same `render_owner_initial` dynamic program's PUC ADM branch remains
+governed by §4.5 and contains no APS DOM authority.
+
+When registration accepts the transferred control port, before waiting for an APS or
+ADM start message, the owner arms one fail-closed 20-second settlement/channel
+watchdog. Start does not extend or rearm it. The deadline is longer than every
+kernel-owned insertion/document/render deadline and also covers registration-to-
+start loss. The owner cancels it on settlement. A malformed control message,
+`messageerror`, local owner disposal, or watchdog expiry performs the failed/
+cancelled cleanup above and rejects once; a silently closed or lost control channel
+is therefore bounded. This watchdog is remote resource cleanup only and cannot
+report acceptance to the kernel or change its already-terminal outcome. A
+settlement-post throw is isolated in the kernel because the remote watchdog owns
+this failure path.
+
+A caller `AbortSignal` remains attempt-owned after owner registration. If it wins
+the terminal latch, the kernel closes its renderer-document channel, removes the
+top-page mount, and sends the exact cancelled/`caller_aborted` settlement. The PUC
+owner performs its Promise/control cleanup just specified. A
+later insert, load, document message, APS callback, settlement, or watchdog is inert.
+
+The winning descriptor dimensions are also the exact layout contract across the
+top-page mount iframe, outer data container, inner data renderer, and runner-created
+creative. The mount iframe is a block with matching positive width/height attributes
+and CSS pixels, zero border/margin, and no scrollbars. Both data documents set their
+root/body and sole child iframe to full width/height with zero margin/padding/border
+and hidden overflow. A 300×250 winner therefore has a 300×250 outer mount box,
+300×250 `clientWidth`, `clientHeight`, `scrollWidth`, and `scrollHeight` in both data
+documents, and a 300×250 descendant viewport, with no default body margin, clipping,
+or overflow. Equivalent assertions run for every boundary fixture dimension. This
+is layout correctness, not render completion; the callback contract above remains
+the acceptance authority.
+
+### 4.5 ADM ownership and cache non-regression
+
+Direct and PUC ADM use one TS-authored iframe constructor and this exact ordered
+sandbox value:
+
+```text
+allow-forms allow-popups allow-popups-to-escape-sandbox allow-scripts allow-top-navigation-by-user-activation
+```
+
+It omits `allow-same-origin`, downloads, modals, presentation, pointer lock, and
+storage-access escape. The iframe has `referrerPolicy='no-referrer'`, exact positive
+source dimensions in both attributes and CSS pixels, zero border/margin, hidden
+overflow, `display:block`, `scrolling='no'`, title `Ad content`, and aria-label
+`Advertisement`.
+
+The constructor creates the iframe detached, installs one-shot `load`/`error`
+handlers and disposal state, builds the complete ADM document, assigns exactly one
+`srcdoc`, and only then appends the iframe once. It never appends an empty iframe,
+sets `src`, or performs a TS-authored replacement navigation. A `load` is accepted
+only when the exact frame is still the pending frame for the current attempt and
+navigation generation, the intended `srcdoc` was assigned before append, and the
+terminal latch is open. Initial `about:blank`, pre-assignment, removed-frame,
+replaced-frame, stale-generation, post-disposal, duplicate, and error events cannot
+accept. Error, removal before acceptance, or the five-second deadline fails
+`adm_document_no_load`. Real-browser tests force initial-blank, replacement,
+removal, error, timeout, supersession, and stale-load orderings.
+
+For PUC ADM, the trusted TS-authored owner—not bidder creative code—uses the
+same registration protocol. The kernel sends exact
+`{message:"TS ADM Start",version:1,lifecycleTicket,source:AdmRenderSourceV1}` on the
+owner-control port with no transferred port. The owner reports
+`TS Owner Inserted` only after the shared constructor appends exactly one owned
+iframe, and reports exact
+`{message:"TS ADM Loaded",version:1,lifecycleTicket}` or
+`{message:"TS ADM Failed",version:1,lifecycleTicket}`. The kernel answers with one
+`OwnerSettlementV1`; only that settlement resolves or rejects the PUC renderer
+Promise. Insertion has a one-second deadline and load has a five-second deadline.
+Direct ADM uses the same constructor and accepts through its own terminal latch on
+the intended load. No secret or capability is injected into bidder-controlled
+markup.
+
+PBS Cache is not routed through this new owner protocol. The GPT integration retains
+the rc-baseline cache request/parse/macro/PUC-response/collapsed-resize behavior
+behind the runtime's generation check and disposer only. Cache success/failure,
+identity, price selection, response shapes, and timing are not redefined here. The
+black-box parity corpus runs the exact rc-baseline fixtures before and after cutover and
+fails any observable change; APS/ADM reservation ids are never accepted as cache
+UUIDs and cache UUIDs never claim APS/ADM work.
+
+### 4.6 Channel ownership and parsing
+
+| Channel                  | Creator                                | Retained endpoint             | Transferred endpoint                     | Lifetime                                          |
+| ------------------------ | -------------------------------------- | ----------------------------- | ---------------------------------------- | ------------------------------------------------- |
+| outer PUC response       | PUC `prebidMessenger`                  | original PUC frame            | kernel global listener                   | one ready/refused response or claim disposal      |
+| registration response    | PUC `h.sendMessage`                    | original PUC helper           | kernel global listener                   | one registered/refused response or owner watchdog |
+| owner control            | kernel after registration              | kernel attempt                | hidden TS dynamic owner                  | insertion through final owner settlement          |
+| bootstrap window channel | bootstrap/outer documents via `parent` | exact top-page mount listener | no `MessagePort`; source-bound messages  | bootstrap readiness through container readiness   |
+| renderer document        | outer data container after inner ready | top-page kernel retains port2 | exact inner data renderer receives port1 | document acceptance through APS completion        |
+
+Global window messages are JSON strings with the exact keys specified above. Port
+payloads are structured-clone objects with the exact keys specified above. Every
+parser rejects accessors, wrong prototypes, unknown keys, wrong literal/version,
+wrong port counts, oversized strings, and already-consumed capabilities before
+performing a state transition. The disposer clears handlers, closes both locally
+owned ports where possible, and makes queued callbacks generation-inert.
+
+The shared protocol corpus fixes these bounds and encodings:
+
+- before `JSON.parse`, an inbound top-page global-dispatcher string is at most 4,096
+  UTF-8 bytes; a larger value is unrecognizable and causes no property access or
+  state lookup. The distinct top-page-to-bootstrap configuration parser accepts only
+  its exact expected parent, exact `b1_`/`n1_` nonces, exact HTTPS creative origin,
+  and `iframe | script` tag type, and caps the complete canonical JSON instruction at
+  16,384 UTF-8 bytes. The bootstrap-created outer `containerUrl` never crosses that
+  channel; it is capped internally at 196,663 UTF-8 bytes (29-byte data prefix +
+  worst-case 3 × 65,536-byte encoded document + 26-byte `#b1_…` fragment). No other
+  global message receives a larger allowance;
+- a TS `adId` is exactly the 25-character `r1_` reservation form; a lifecycle ticket,
+  bootstrap nonce, renderer nonce, and attempt id are exactly the respective
+  25-character `t1_`, `b1_`, `n1_`, and `a1_` forms from §2.2;
+- `adServerDomain` is nonempty and at most 2,048 UTF-8 bytes. It is retained only for
+  exact PUC-shape conformance and is never a fetch target or authority;
+- `publisherOrigin` is at most 2,048 UTF-8 bytes and must serialize an exact HTTP(S)
+  origin with no path/query/fragment. The mount service locally derives the absolute
+  `/integrations/aps/renderer/v2` URL from that trusted origin, verifies no query or
+  fragment, and appends the exact `b1_` bootstrap-nonce fragment. `rendererUrl` is
+  never serialized in a v4 window or port message. The generated inner `data:` URL
+  independently appends its exact `n1_` renderer-nonce fragment;
+- a navigation/refresh generation is a nonnegative safe integer; and
+- the generated self-contained dynamic-owner `renderer` program is at most 64 KiB
+  UTF-8 and the
+  complete successful outer-response JSON is at most 72 KiB. Build tests enforce
+  both; refusal responses contain no renderer. The program has no external loader,
+  URL, cache dependency, or second pre-paint artifact.
+
+Across the exact global-message and structured-clone port corpora, fields use their
+own carrier's exact shape and these field-level limits: APS descriptor 256 KiB
+decoded AAX; ADM 512 KiB; `creativeUrl` 4,096 UTF-8 bytes;
+`publisherOrigin` and `adServerDomain` 2,048 UTF-8 bytes; server slot id 1–256 UTF-8 bytes with no NUL or
+ASCII control; and the fixed
+capability forms above. No generic unbounded string remains. Boundary-minus-one,
+boundary, boundary-plus-one, multi-byte UTF-8, duplicate-key, and malformed-encoding
+cases run through the producer plus both the global dispatcher and port parsers.
+
+### 4.7 Notifications
+
+APS has no `nurl` or `burl`; none is synthesized. Existing notifications on other
+bid formats remain nonblocking and exactly-once per accepted lifecycle transition.
+Notification transport failure cannot change a render outcome. Redesigning or
+measuring notification delivery is outside this spec.
+
+## 5. TSJS target architecture
+
+### 5.1 Layers
+
+```text
+kernel/        boot, phase registry, queue, sessions, disposal, logging
+adapters/      googletag, prebid, messaging
+services/      slots, auction batches, render lifecycle, consent
+integrations/  gpt, prebid, aps, creative, and existing publisher integrations
+composition/   small production core plus test-only composition seams
+```
+
+- Kernel imports no adapter, service, or integration.
+- Adapters import kernel contracts only and are the sole readers/writers of GPT,
+  Prebid, and cross-window messaging globals.
+- Services import kernel and adapter interfaces.
+- Integrations compose services and never import another integration.
+- The production core entry imports only the kernel, immutable boot/projection
+  contracts, queue/logger, and the minimum direct-auction functions that the public
+  API requires before any integration exists. It does not import every adapter,
+  service, integration runtime, diagnostics UI, no-op implementation, or test hook.
+- Each provider IIFE contains only the concrete adapter/service implementation it
+  owns; a consumer slice does not inline that implementation again. Every module
+  registers one inert factory. The kernel constructs one `RuntimeSession`, invokes
+  those factories transactionally, and retains their exact frozen interfaces in a
+  closure-private capability broker. An integration consumes only capabilities that
+  the embedded release catalog allows for that integration; it never imports another
+  integration or reads a public service locator.
+- The capability broker admits one provider per exact key, rejects undeclared keys,
+  validates frozen exact own-data-property interface objects with no accessors,
+  unknown keys, or custom prototype, removes a provider on disposal, and
+  is never exposed on `window.tsjs` or `_internal`. A takeover provider must exist
+  as a staged result of its provider's preparation before any takeover consumer
+  prepares, and provider-before-consumer order is enforced by the catalog. A
+  deferred consumer may bind only an already committed takeover provider.
+- Production and test composition entries are separate. Production output cannot
+  retain `*ForTest` accessors, injectable no-op adapters, corpus helpers, or fake
+  scheduler branches merely because tests need them.
+- Layering is enforced by ESLint restricted paths.
+- A custom scope-aware lint rule rejects GPT/Prebid global access outside adapters,
+  including same-file aliases of `window`, `globalThis`, `self`, `googletag`, or
+  `pbjs`.
+
+### 5.2 One runtime across IIFE bundles
+
+#### 5.2.1 Two non-overlapping ownership epochs
+
+The browser lifecycle has two ordered ownership epochs, never two independently
+live runtimes:
+
+```text
+bootstrap installing
+  -> first-display agent -> transferring -> persistent runtime
+  |                     \-> failed -----------------> fallback
+  \-> persistent runtime (no eligible server-projected batch)
+  \-> failed ---------------------------------------> fallback
+```
+
+The **first-display agent** is a release-owned provisional owner, not the legacy
+`gpt_bootstrap.js` and not a reduced public runtime. It is one parser-blocking,
+server-composed artifact containing only the fixed slices selected for the
+immutable server projection and parser-time obligations on that page. It may:
+
+- validate the boot manifest and initial projection;
+- install the one provisional GPT/message/guard interception needed before the
+  initial action;
+- define, target, request, and settle only the server-projected initial GPT batch;
+- render an APS or ADM winner through the exact §4 protocols, including an
+  attributable empty-GAM fallback for that batch; and
+- record the first-action, terminal, and protected-paint marks.
+
+It cannot publish `TsjsApi`, expose a capability broker, accept programmatic ad
+units or direct-auction calls, process SPA/page-bids work outside the immutable
+initial batch, load deferred modules, present diagnostics, refresh an accepted ad,
+or start later navigation/reconciliation. Publisher callbacks remain in the one
+bootstrap-owned ingress Array until persistent-runtime or fallback commit. The old
+bootstrap renderer, legacy API, and any second fallback runtime remain deleted.
+
+The server selects the agent only when every member of the projected initial batch
+is representable by the first-display slices: no bid, GPT-mediated ADM, or
+GPT-mediated APS/PUC (including its attributable empty-GAM fallback). PBS Cache,
+programmatic/direct `/auction`, an unknown source, or any initial behavior outside
+that closed set selects direct persistent boot instead; this design adds no new cache
+implementation or cache-path phase split. A page with no projected initial batch also
+uses direct persistent boot. Parser-time obligations join the agent only when that
+agent is already selected; otherwise their takeover modules activate in the one
+parser-blocking runtime artifact before upstream publisher activity. This is a
+server-owned manifest choice derived from frozen
+configuration and projection, not a publisher switch, experiment, or compatibility
+path. A programmatic `requestAds` invoked on such a page becomes usable only after
+the persistent runtime commits. The protected load-time claim applies to the
+server-projected agent path; subsequent programmatic work remains correct but is not
+relabeled as that measurement.
+
+The release build independently enumerates all 3,584 reachable masks: the base is
+always present, GPT may be absent for a closed no-bid batch, APS or Prebid
+participation requires GPT, and the shared render owner is present exactly when the
+batch contains an ADM or APS reservation. It measures and hashes every reachable composition with
+the frozen raw/gzip/Brotli algorithms, then emits the exact ordered subset satisfying
+all three first-display ceilings as `permittedFirstDisplayMasks`. Server selection
+must be both semantically eligible and present in that generated allowlist. A closed
+but size-unadmitted configuration takes direct persistent boot; it is never served an
+oversized agent and the request path never calculates a new size or relaxes a limit.
+The minimal, exact five-slice reference, and exact APS-plus-default-creative masks are
+mandatory: failure to admit any of those three fails the release build rather than
+routing the named performance cases around the gate.
+
+The agent artifact has one base entry plus only these build-catalogued slices. A
+slice absent from this table cannot enter the artifact. “Initial” means the exact
+immutable batch; it does not authorize later work from the same product:
+
+The conditional `render_owner_initial` slice owns the source-neutral attempt
+collection, terminal latch, reservation/ticket registry, v4 PUC claim and owner-
+control protocol, self-contained dynamic-owner program, committed-artifact journal,
+and handoff/retirement primitives shared by initial PUC ADM and APS. It is selected
+for an ADM or APS reservation and is absent from a no-bid/nonrendering mask; ADM-only
+therefore has the same v4 owner without importing APS. `aps_initial` requires that
+slice, composes its frozen release-private interface, and remains the sole owner of
+APS descriptors, bootstrap and renderer nonce roles, top-page mount, and renderer-
+document protocol. The only APS-specific literal or branch permitted in
+`render_owner_initial` is the exact informational `TS APS Top Mount Started` control
+message received after the APS kernel/top mount has started; it carries no descriptor,
+URL, nonce, port, or DOM authority. No other APS message, descriptor parser, nonce
+registry, renderer-document parser, mount implementation, or top-mount policy enters
+that slice, and neither slice imports or instantiates a second complete render bridge.
+
+| Slice id                     | Include iff                                                                        | Bounded obligation before transfer                                                                |
+| ---------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `first_display`              | an eligible initial batch exists                                                   | manifest/projection validation, provisional lifetime, timing, queue ingress, transfer coordinator |
+| `render_owner_initial`       | the initial GPT batch contains an ADM or APS reservation                           | source-neutral reservation/ticket, v4 PUC owner, render journal, and handoff/retirement contract  |
+| `aps_initial`                | the initial GPT batch can contain APS                                              | thin APS-specific descriptor, nonce/top-mount, and renderer-document protocol                     |
+| `creative_initial`           | an enabled creative guard has a parser-time obligation                             | current guard defaults and initial creative observation only                                      |
+| `datadome_initial`           | DataDome is enabled                                                                | initial script/preload route guard                                                                |
+| `didomi_initial`             | Didomi is enabled                                                                  | initial configured SDK-path installation                                                          |
+| `google_tag_manager_initial` | Google Tag Manager is enabled                                                      | initial script/preload/beacon/fetch guards                                                        |
+| `gpt_initial`                | GPT owns/may receive the initial batch or has a parser-time attribution obligation | sole provisional GPT adapter, page targeting, listeners, slot targeting/request, handoff capture  |
+| `lockr_initial`              | Lockr is enabled                                                                   | initial script guard and bounded readiness needed before SDK use                                  |
+| `osano_initial`              | Osano is enabled                                                                   | initial consent mirrors required by the initial batch                                             |
+| `permutive_initial`          | Permutive is enabled                                                               | initial guard/readiness and normalized segments                                                   |
+| `sourcepoint_initial`        | Sourcepoint is enabled                                                             | initial SDK guard and GPP mirror                                                                  |
+| `prebid_initial`             | Prebid participates in the initial batch                                           | artifact admission, publisher queue, bidder/user-ID/EID setup, initial TS bid/PUC path            |
+| `testlight_initial`          | Testlight is enabled                                                               | capture preexisting callbacks before publisher replacement/drain                                  |
+
+The canonical low-order examples are part of the server/build contract: no-bid is
+`0001`, GPT attribution-only is `0081`, ADM is `0083`, creative-guarded ADM is
+`008b`, APS is `0087`, creative-guarded APS is `008f`, and Prebid-plus-ADM is
+`1083`. These examples do not create aliases: the route accepts only the exact
+generated mask/hash pair admitted for the current configuration. APS participation
+without enabled APS configuration is invalid rather than a reason to select the
+render owner, and `render_owner_initial` has no independently routable production
+asset; its bytes exist only inside the selected first-display composition.
+
+Every optional slice submits one raw dense four-item carrier
+`[1,id,releaseId,install]` to the bootstrap's release-private first-display sink
+during the expected parser-inserted artifact task. The slice does not supply or
+retain script identity. Bootstrap authenticates the exact connected script with the
+closure-captured native `Document.prototype.currentScript` getter, reserves a
+private `registrationClaiming` state before any mutable realm access, exact-data
+validates the carrier with captured intrinsics, freezes it, and copies only the
+validated id/install values into its closure-private registry. The build fixes their
+order, interfaces, and allowed imports; there is no public service locator or
+third-party extension surface. The agent rejects an unknown, duplicate, omitted,
+misordered, wrong-release, accessor-backed, reentrant, or late slice before effects. Agent
+activation is one synchronous transaction with reverse-order rollback, the same
+inert-prepare/effectful-activate discipline used by the persistent catalog, and the
+same ten-second bootstrap deadline. All agent-owned timers, listeners, wrappers,
+observers, ports, nodes, and provisional GPT objects have named exact-once
+disposers.
+
+The persistent artifact may be requested only after every attempt in the protected
+initial batch is terminal and the §5.2 paint gate has recorded
+`tsjs:first-display-paint`. On an agent page, no persistent/deferred TSJS preload,
+fetch, preparation, or evaluation may begin earlier. The bootstrap creates the one
+authenticated classic same-origin runtime script using the manifest URL, expected
+element identity, `document.currentScript`, CSP nonce, and Trusted Types rules
+defined below. Independent ordinary deferred modules remain later than persistent
+runtime commit.
+
+Recording protected paint also **seals first-display TS admission** before the
+persistent request begins. From that boundary until persistent or fallback commit,
+the agent accepts no new TS bidder invocation, admission lease, render reservation,
+attempt, direct-auction request, refresh, or navigation work. A later invocation of
+the Trusted Server Prebid bidder fails before minting authority, invokes its bidder
+completion exactly once with no bid, and records the internal terminal reason
+`prebid_admission_failed`; it is never held for or replayed into the persistent
+runtime. Native publisher Prebid/GPT calls and non-TS bidder traffic remain immediate
+pass-through and may update the agent's bounded observational handoff facts, but
+cannot create TS authority. Because the immutable initial batch is the only TS work
+the agent may ever admit and every member is terminal before sealing, the seal must
+leave zero live TS admission lease, live render reservation, unconsumed ticket,
+attempt, port, or request-capable callback. Consumed/expired/stale entries that §2.3
+has already converted to unexpired terminal tombstones are required suppress-only
+state, not live authority: they remain until their original expiry and cross only as
+the bounded terminal tombstones below. Discovery of any other live TS entry is
+`bundle_partial`, not transferable state.
+
+If the initial batch has no accepted artifact—every slot is `no_bid`, failed, or
+cancelled—the same terminal/paint gate applies and takeover may proceed with an empty
+committed-artifact set. The candidate performance fixture continues to require an
+actual request action; an empty batch cannot manufacture `tsjs:first-display` or be
+included in the timing distribution.
+
+The sealed transport always carries this server-authored integrity value, including
+on a no-agent direct-runtime page:
+
+```ts
+interface ServerBootIntegrityV1 {
+  readonly version: 1
+  readonly projectionDigest: string
+  readonly integrationConfigDigest: string
+}
+```
+
+When an agent is selected, the sibling outline has this complete v1 contract; it is
+`null` on a direct-runtime page and there is no object-form compatibility shape:
+
+```ts
+interface TakeoverOutlineV1 {
+  readonly version: 1
+  readonly releaseId: string
+  readonly generation: number
+  readonly projectionDigest: string
+  readonly integrationConfigDigest: string
+  readonly slices: readonly FirstDisplaySliceId[]
+  readonly slotCount: number
+  readonly outcomeCount: number
+  readonly capabilities: readonly []
+  readonly objectKinds: readonly [] | readonly ['gpt_slot', 'dom_artifact']
+}
+```
+
+`releaseId`, both digests, and the selected slices equal the sibling boot manifest,
+always-present `ServerBootIntegrityV1`, and payload values exactly. `generation` is an
+integer in `1..2^32-1` and begins at `1` for the server projection. `slotCount` is the projection `slots.length`,
+`outcomeCount` is `auction.results.length`, both are in `1..256`, and complete
+ordered placement coverage makes them equal. `capabilities` is exactly empty in v1;
+live authority never crosses static preparation. `objectKinds` is exactly empty
+when `bids` is empty and otherwise exactly the ordered pair shown above; it is a
+capacity declaration, not evidence that an object already exists.
+
+Rust computes `integrity.projectionDigest` as lowercase SHA-256 over the exact
+canonical UTF-8 JSON bytes returned by the coordinated-cutover projection
+canonicalizer and embedded as `boot.auctionProjection`. It computes
+`integrity.integrationConfigDigest` as lowercase SHA-256 over the exact UTF-8
+`JSON.stringify`-equivalent serialization of the ordered `IntegrationConfigsV1`
+embedded as `boot.integrations`; object insertion order is the wire order and no
+insignificant whitespace is present. Rust must normalize both admitted trees to
+ECMAScript `JSON.stringify` spellings and enumeration order before hashing and
+embedding; hashing `serde_json` output directly is invalid because negative zero,
+fixed/exponent thresholds, IEEE-754 rounding, and integer-index object keys differ.
+A shared Rust/JavaScript corpus pins those edge cases and nested combinations. On an
+agent page Rust copies those exact values into the outline rather than hashing again.
+The compact controller checks integrity
+and outline digest form and, when the outline is non-null, their exact equality, but
+does not bundle SHA-256 or the full domain validators. The first-display owner
+completely validates the batch, retains the always-present sealed integrity values,
+and copies them into handoff. Before direct runtime use or final adoption, persistent
+core completely validates the boot and recomputes both digests from that frozen
+snapshot with the same UTF-8 SHA-256 helper; any mismatch with the sibling integrity
+value is `abi_mismatch` before persistent effects. Handoff adoption additionally
+requires exact integrity/outline/handoff digest equality. Thus no component invents a
+second canonicalization and no digest is treated as a publisher capability.
+
+The runtime bundle first performs an effect-inert **static takeover preparation**
+against only the bootstrap controller's exact immutable `TsjsBootV1` and
+`ServerBootIntegrityV1` snapshots and a frozen `TakeoverOutlineV1`: exact release/generation, projection digest, canonical
+integration-config digest, selected slice ids, counts, and the
+capabilities/object kinds that final adoption must support. The outline contains no
+slot outcome, mutable publisher/GPT state, artifact object, wrapper, observer, or
+time-sensitive expiry. Preparation constructs generic inert persistent owners and
+validates capacity; it cannot snapshot or depend on live agent state.
+
+The agent increments one unsigned 32-bit `mutationRevision` after every admitted
+publisher GPT/Prebid call, GPT event, DOM mutation/rebind, targeting or ownership
+change, parser-guard observation, consent/segment update, and terminal/tombstone
+change while runtime bytes download and prepare. It continues passing through and
+observing native publisher/external activity normally, subject to the sealed TS
+admission boundary above; no call is held, replayed, or allowed to act through a
+prepared persistent owner. Revision exhaustion fails takeover instead of wrapping.
+When static preparation is ready, the agent enters the synchronous task below,
+closes its own work ingress, records the final revision, drains all already-running
+synchronous mutations, and only then mints the final immutable
+`FirstDisplayHandoffV1` plus one-use capsule. Because JavaScript is run-to-completion,
+no GPT/Prebid/DOM/publisher task can mutate between that final snapshot and owner
+activation. The persistent owner validates the snapshot and revision during the same
+task; any mutation callback that arrives afterward sees only the new epoch.
+
+`FirstDisplayHandoffV1` is an exact-shaped, recursively frozen data tree containing:
+
+- release/generation identity plus the canonical initial-projection and
+  integration-config digests;
+- each slot's canonical id, aliases, DOM id, GAM path, normalized formats,
+  TS/publisher ownership, request-cycle outcome, and installed targeting snapshot;
+- every terminal attempt and reservation/ticket tombstone still inside its original
+  bounded expiry, without descriptor, ADM, capability, or creative payload bytes;
+- committed-artifact kind and ownership metadata; parser-time integration snapshot
+  data needed for its persistent owner; the ordered bounded GPT-diagnostics fact
+  buffer and its overflow count when diagnostics are active; and
+- the exact once-only first-display timing/paint facts;
+- the navigation attempt-prefix and next attempt ordinal, slot-registration-order
+  next ordinal, reservation/ticket monotonic-clock epoch and remaining expiries;
+- the next global GPT trace-slot ordinal; for each adopted object, its token, next
+  cycle ordinal, `unknownPriorCycle`, and all retained open/completed/retired cycle
+  records and quarantines permitted by the existing ten-record cap; and
+- the next trace sequence, per-slot impression counters, retained trace bindings,
+  and the final `mutationRevision`.
+
+The integration configuration is not recopied from the agent into the handoff. The
+bootstrap controller passes the same closure-retained, recursively frozen
+`TsjsBootV1` snapshot to the agent and prepared runtime; the handoff digest must equal
+that snapshot's canonical config digest before adoption. No slice or module re-reads
+`window.tsjs.boot`, and replacing the public pre-load object therefore cannot change
+the retained snapshot. The eventual committed `tsjs.boot` exposes that same frozen
+snapshot for inspection.
+
+The handoff contains no function, accessor, custom prototype, Promise, listener, timer,
+observer, `MessagePort`, `WindowProxy`, network handle, or mutable collection. A
+release-private one-use `FirstDisplayOwnershipCapsuleV1` accompanies it only during
+the same synchronous takeover call. The capsule may carry the exact already-
+committed GPT slot and DOM artifact object identities that cannot be reconstructed
+from data. It carries no live port, timer, listener, observer, in-flight attempt, or
+callable publisher surface. The capsule is generation/release bound, can be consumed
+once by the authenticated prepared runtime, and is cleared by agent rollback,
+fallback, or successful adoption. It is never stored on `window.tsjs`, `_internal`,
+boot data, diagnostics, a log, or an analytics event.
+
+The handoff contains at most the existing 256 initial slots/outcomes. Every `next`
+counter is strictly above every value ever minted in that generation, including a
+retired/pruned value absent from retained rows; adoption never derives a high-water
+mark from visible rows. Each reservation/ticket entry is an unexpired terminal
+tombstone and retains only the opaque value and
+expiry required to suppress replay; no live authority, descriptor, ADM, or creative
+payload survives. Each copied string/targeting collection retains its source grammar
+and capacity. The canonical non-diagnostics data-tree encoding is at most the
+existing 8 MiB boot-projection cap; the normalized diagnostics-fact subsection has
+its separate 512 KiB cap from §5.8, so the complete canonical handoff is at most
+8.5 MiB. The capsule has
+at most one physical GPT identity and one committed artifact identity per slot.
+Overflow or any nonterminal attempt/port makes takeover preparation fail; it cannot
+truncate, evict a live fact, or silently lose replay suppression.
+
+Takeover is one non-yielding JavaScript task after static preparation succeeds:
+
+1. Revalidate the current generation, exact runtime script, outline, terminal batch,
+   paint gate, and prepared runtime; close agent work ingress and record the final
+   mutation revision.
+2. Mint and validate the final handoff/capsule from current state. Synchronously
+   quiesce agent handlers and compare-restore every provisional wrapper. The
+   bootstrap callback Array remains the one append-only ingress until step 5; no
+   publisher callback is invoked in this interval.
+3. Detach committed artifacts from agent disposal, then dispose every remaining
+   agent listener, timer, observer, port, readiness waiter, registry entry, and
+   uncommitted node in reverse order.
+4. Activate fresh persistent wrappers/listeners/observers and owners in catalog
+   order, adopting capsule objects and handoff facts. A parser guard transfers only
+   bounded data such as installed configuration and seen-node identifiers, never its
+   wrapper/listener/observer. The new owner performs one bounded post-commit rescan
+   so records discarded while the old observer disconnects cannot be lost.
+   `adoptInitialDisplay:true` forbids parsing the projection as new
+   work, redefining an adopted GPT slot, reinstalling accepted targeting, issuing
+   `display`/`refresh`, creating a render iframe, or emitting any first-display mark.
+5. Revalidate that the generation/revision did not change, commit the complete
+   `TsjsApi`, permanently close both private registration sinks,
+   transfer committed artifacts to persistent slot/navigation ownership, run
+   persistent `afterCommit` work, and drain the single bootstrap queue exactly once.
+
+No task or microtask can observe the synchronous listener/wrapper transition.
+Momentary stack-local objects during that task do not constitute a second live
+owner; at every task boundary exactly one of agent, persistent runtime, or fallback
+owns ingress and side effects. Successful takeover leaves no agent timer, listener,
+port, observer, wrapper, registry, request authority, or strong reference except the
+committed objects now owned by the persistent runtime. Physical GPT identity and
+publisher handoff remain exact because the object itself, rather than a guessed
+path/DOM lookup, moves through the one-use capsule.
+
+Runtime download, authentication, or effect-inert preparation failure leaves the
+agent in control only until the bounded persistent-load deadline. It then settles
+the terminal fallback while preserving already committed ad DOM as inert publisher-
+visible output. A failure after step 2 rolls back partial persistent effects, does
+not resurrect the agent, and commits that same terminal shell. It never replays the
+projection, requests GAM again, removes an accepted publisher-owned ad, or constructs
+a degraded runtime. Failed takeover therefore sacrifices later TSJS behavior, not
+the correctness or exactly-once status of the completed first display.
+
+During this post-paint load window the bootstrap Array remains the only TSJS
+publisher-work ingress. Callable pushes are appended and run against neither owner;
+they are drained once only after persistent or fallback commit. The provisional
+transport intentionally has no `requestAds` or `addAdUnits`, so an attempted direct
+call before commit is ordinary use-before-ready and creates no accepted operation or
+Promise. On successful takeover, queued callbacks run against the complete kernel.
+On authentication, load, preparation, activation, or ten-second-deadline failure,
+fallback first classifies and freezes the exact `fallbackReason` under §5.3 and
+freezes `initialDisplayCommitted` to whether the completed protected batch contained
+at least one `accepted` result, then drains those same callbacks. Wrong
+release/source/manifest/ABI identity is `abi_mismatch`; transport/load/deadline,
+preparation/activation failure, or a live TS entry at the seal is `bundle_partial`.
+Every `requestAds` made by a drained or later callback rejects
+`TsjsUnavailableError{code:'runtime_unavailable',reason:fallbackReason}` without
+reading its argument. Every `addAdUnits` throws the same classified unavailable
+error without reading or validating its argument. This hard-cutover shell does not
+emulate kernel input validation or synthesize auction results when no kernel exists;
+it does not re-report, remove, or replay the completed initial display.
+`_internal.reason` is the same frozen classification. No queued callback or API call
+remains pending, and no post-paint transient failure retries the runtime artifact in
+that document generation.
+
+Every installed effect is a repository-owned primitive with a synchronous,
+nonthrowing, identity-checked disposer. Rollback attempts physical removal/restoration
+for every effect even after an earlier disposer reports failure. The mandatory
+security/correctness postcondition is generation-latched inertness: a publisher who
+replaced a global after agent installation may prevent literal restoration, but the
+old wrapper/listener/observer cannot authorize, request, render, or mutate TS state.
+Tests require literal removal where the platform operation succeeds and zero
+surviving authority in every case; “no second listener/wrapper survives” means no
+live TSJS authority, not control over publisher replacements.
+
+The atomic **takeover** transaction runs on an agent page; the ordinary bootstrap
+transaction runs on a page where the agent is omitted. Takeover module bytes never
+enter the first-display artifact. The agent path follows the terminal, paint, and
+takeover sequence above; the ten-second no-attempt guard remains only for a
+direct-to-runtime page with no server-projected agent batch.
+
+Each shipped integration remains a separately built IIFE with imports inlined, so
+module singletons cannot be the shared-runtime mechanism. `tsjs-core` installs the
+only runtime and keeps the capability broker in its composition closure. During
+boot or takeover, `_registerIntegration` collects exact release-bound takeover modules from the
+same server-composed script. After kernel commit it accepts only a currently loading,
+manifest-declared deferred module from the exact core-created script element. It is
+permanently refusing for unknown, duplicate, wrong-release, wrong-phase, publisher-
+invoked, replaced-node, or already-terminal registrations. `tsjs._internal` exposes
+only the frozen status described in §5.4, never the broker or phase loader.
+
+Every integration module registers through:
+
+```ts
+interface IntegrationPrepareContextV1 {
+  readonly config: unknown
+  readonly interfaces: Readonly<Record<string, unknown>>
+  readonly signal: AbortSignal
+  readonly onDispose: (callback: () => void) => void
+}
+
+interface IntegrationActivationContextV1 {
+  readonly signal: AbortSignal
+  readonly onDispose: (callback: () => void) => void
+  readonly afterCommit: (callback: () => void) => void
+  readonly adoption?: unknown
+}
+
+interface PreparedIntegrationV1 {
+  readonly activate: (ctx: Readonly<IntegrationActivationContextV1>) => void
+  readonly interfaces?: Readonly<Record<string, unknown>>
+}
+
+type IntegrationRegistrationV1 =
+  | Readonly<{
+      abi: 1
+      id: string
+      phase: 'takeover'
+      releaseId: string
+      prepareSync: (
+        ctx: Readonly<IntegrationPrepareContextV1>
+      ) => PreparedIntegrationV1
+      prepare: (
+        ctx: Readonly<IntegrationPrepareContextV1>
+      ) => PreparedIntegrationV1 | Promise<PreparedIntegrationV1>
+    }>
+  | Readonly<{
+      abi: 1
+      id: string
+      phase: 'deferred'
+      releaseId: string
+      prepare: (
+        ctx: Readonly<IntegrationPrepareContextV1>
+      ) => PreparedIntegrationV1 | Promise<PreparedIntegrationV1>
+    }>
+
+tsjs._registerIntegration(registration)
+```
+
+Every takeover module supplies both entry points because the same release-owned
+implementation has two boot contexts. A no-agent parser-blocking runtime calls only
+`prepareSync`; returning a Promise/thenable, throwing, or crossing the owning
+monotonic deadline fails the transaction before the parser resumes. An agent-page
+post-paint takeover calls only `prepare`, which may await effect-inert work under the
+same deadline. A deferred module has only `prepare`; supplying `prepareSync` is an
+unknown key and fails registration. Shared pure construction may sit behind the two
+takeover entry points, but neither entry point may activate twice or retain a
+detached continuation.
+
+This is a release-internal bundle handshake, not a publisher extension API. An
+**integration** remains the product capability; an **integration module** is only
+that integration's transactional TSJS implementation unit. The design introduces
+no separately installed or third-party plugin system.
+
+The build first emits the bootstrap controller, first-display base, every
+first-display slice, core, and every production integration module with the same
+fixed release sentinel,
+then computes one `releaseId`: 64 lowercase hexadecimal SHA-256 characters over a
+canonical ordered release inventory containing every artifact id, role, phase, and
+its sentinel-normalized
+bytes. It replaces exactly one sentinel in each bundle and verifies none remains.
+This avoids a self-referential hash while changing the id for any logical bundle or
+ordering/role/phase change. First-display base/slice role, order, mask bit, or byte
+changes therefore change the release identity. The same value is embedded in the
+bootstrap controller, every agent base/slice, core, and every integration bundle.
+The bootstrap controller, agent base/slices, and core use reserved artifact ids and
+never appear as persistent integration entries.
+Before core is injected, the server emits this exact manifest. This is the first and
+only `BootManifestV1` shape; the unreleased all-required draft has no compatibility
+status:
+
+```ts
+type BootManifestIntegrationV1 =
+  | Readonly<{
+      id: string
+      phase: 'takeover'
+    }>
+  | Readonly<{
+      id: string
+      phase: 'deferred'
+      trigger: 'first_display_or_idle'
+      src: string
+    }>
+
+interface BootManifestV1 {
+  readonly version: 1
+  readonly releaseId: string
+  readonly firstDisplay: null | Readonly<{
+    src: string
+    slices: readonly string[]
+  }>
+  readonly runtimeSrc: string
+  readonly integrations: readonly BootManifestIntegrationV1[]
+}
+
+type IntegrationConfigIdV1 =
+  | 'aps'
+  | 'datadome'
+  | 'didomi'
+  | 'google_tag_manager'
+  | 'gpt'
+  | 'lockr'
+  | 'osano'
+  | 'permutive'
+  | 'prebid'
+  | 'sourcepoint'
+  | 'testlight'
+
+type BootJsonPrimitiveV1 = null | boolean | number | string
+type BootJsonValueV1 =
+  | BootJsonPrimitiveV1
+  | readonly BootJsonValueV1[]
+  | Readonly<{ readonly [key: string]: BootJsonValueV1 }>
+
+interface IntegrationConfigEntryV1 {
+  readonly id: IntegrationConfigIdV1
+  readonly config: Readonly<{ readonly [key: string]: BootJsonValueV1 }>
+}
+
+interface IntegrationConfigsV1 {
+  readonly version: 1
+  readonly entries: readonly Readonly<IntegrationConfigEntryV1>[]
+}
+```
+
+`IntegrationConfigsV1` is the only generic browser configuration carrier. Its
+entries appear once each in the union order above, contain exactly the enabled
+product integrations for the document, and are capped at 11. APS emits `{}` when it
+is enabled but has no browser-selectable setting; an absent/disabled integration has
+no entry. The `gpt_later`, `prebid_later`, and consent/lifecycle deferred modules use
+their product's one existing entry rather than receiving a second config. Creative
+and diagnostics remain the dedicated typed `creative` and `diagnostics` boot fields
+because they are also stable public inspection surfaces. `render_runtime` and
+`diagnostics_presentation` have no independent config entry.
+
+The server serializes each integration's explicit browser-safe projection of its
+existing typed rc configuration into this carrier and rejects a manifest/config
+predicate mismatch before emitting HTML. Server credentials, secrets, auth headers,
+cookies, private endpoint policy, and unprojected configuration fields have no
+browser type and cannot enter the carrier.
+
+The production inline transport is one server-sealed canonical JSON string, not a
+browser-visible mutable object graph. Rust serializes exact
+`{version:1,boot,integrity,outline}` bytes only after the complete projection, manifest,
+configuration, creative, diagnostics, selection, digest, and count contracts pass;
+it then escapes that string for one inline-script lexical constant without changing
+the decoded JSON. The existing 8 MiB projection and 512 KiB integration-carrier
+limits remain authoritative, and the complete decoded transport is capped at 10 MiB
+UTF-8. The controller reads no boot global and accepts no object-form production
+transport or compatibility alias.
+
+The controller's production transport parser performs `JSON.parse` synchronously,
+which creates a fresh acyclic tree of ordinary objects, dense Arrays, and data
+properties and therefore cannot preserve a source accessor, Proxy, symbol, custom
+prototype, sparse hole, or repeated object identity. Before any DOM, timer, queue,
+GPT, attribution, or registration effect, the parser requires the exact root keys
+and version, embedded release equality, exact critical boot keys, manifest release
+and URL/mask/slice relationships, at most 14 takeover entries, every deferred source
+bound to its declared module id, the always-present exact integrity shape and digest
+forms, null/non-null first-display and outline parity, outline
+release/slice/count/digest forms and digest equality with integrity, dedicated
+creative/diagnostics booleans, and the configured decoded-size bound. It recursively freezes the parsed tree,
+retains that exact snapshot in the controller closure, and never again reads the
+lexical string or a public global. Parse, critical validation, or freeze failure is
+`abi_mismatch` before effects.
+
+This compact production parser is deliberately not a second domain validator. The
+first-display base validates its complete immutable projection/batch before
+activation; every selected slice validates its attenuated product value before its
+effect; and persistent core performs the complete manifest, projection, carrier,
+creative, and diagnostics validation before a direct boot or takeover uses them.
+If that post-claim validation fails, persistent core returns `abi_mismatch` through
+the one-use completion capability returned by the one-use,
+exact-source-authenticated closure claim during the current runtime script task; the
+controller commits fallback immediately instead of allowing the load watchdog to
+relabel the failure `bundle_partial`. Takeover preparation or activation failure is
+reported through that same capability. In takeover mode only the bootstrap owner may
+publish terminal fallback: it preserves accepted DOM, snapshots the agent's
+`initialDisplayCommitted` state, disposes the provisional agent, and commits once.
+The persistent runtime never publishes a competing takeover fallback. On a direct
+page, the persistent runtime remains the terminal-fallback owner after a valid claim.
+The full object-form validators retain their existing hostile-object contract for
+runtime/public/test boundaries: exact `version`/`entries`, unique ordered ids,
+plain configs, finite JSON values, dense Arrays, own enumerable data properties, no
+accessors/symbols/custom prototypes/cycles/aliases, depth 16, 4,096 values, 4,096-byte
+keys/strings, 65,536-byte entries, and the 524,288-byte carrier. The inline
+bootstrap artifact must not import those full validators or the complete auction-
+projection parser merely to revalidate the trusted lexical producer.
+The closure claim atomically reserves a private `claiming` state before it touches
+any mutable DOM or realm authentication surface and rolls back only after a failed
+authentication. Its completion capability admits outcomes through primitive string
+comparisons, consumes its one-use guard before invoking the selected handler, and
+therefore remains one-shot under reentrant claim and completion attempts.
+The generated persistent artifact starts with a build-owned banner whose first
+expression directly reads the sealed `window.tsjs` admission gate, directly reads
+the returned script node's own non-configurable `_claimRuntimeV1`, and calls it
+before core or any co-bundled module initializer runs. For exactly that authenticated
+runtime task, the non-configurable namespace getter returns the selected script node
+once; every ordinary or later read returns the retained bootstrap target. The claim
+returns one frozen exact record containing
+`{boot,integrity,complete,currentScript,source,target,mode,bind}`. Core rejects any
+other shape, source/current-script mismatch, mode mismatch, mutable record, or
+replayed claim before effects. The controller captured the native current-script
+getter and required object/array/descriptor intrinsics before any live upstream
+script could run; later mutation of public realm properties cannot forge admission.
+The compact fallback does not import either public request validator. Both public
+operations refuse as unavailable without reading publisher input; full validation
+belongs only to a successfully committed kernel.
+The persistent core receives the manifest-entry capacity as a generated numeric
+build constant; it does not import the build-time release catalog merely to learn
+that bound. Substitution may tree-shake the declaration module completely, and the
+release metafile must prove that the persistent core graph excludes the catalog.
+
+The release catalog binds every module id to exactly one config source: its product
+entry, `creative`, `diagnostics`, or none. The integration's generated exact typed
+validator runs during preparation and rejects unknown/missing fields or a
+manifest/config inclusion mismatch as `abi_mismatch`; it does not silently default
+browser data. `IntegrationPrepareContextV1.config` is only that module's frozen value,
+never the complete map, and deferred modules receive the same frozen product value
+captured at bootstrap. The first-display base likewise supplies each selected slice
+only its own attenuated value.
+
+Integration ids match `^[a-z0-9][a-z0-9_-]{0,63}$`, are unique, and appear in the actual
+server phase/injection order. Takeover entries precede deferred entries, the list
+contains exactly the enabled persistent-runtime modules for that page, and there are
+at most 20. `firstDisplay` is either exact `null` or the server-selected agent
+artifact and its canonical ordered subset of the 14 slice ids in §5.2.1; ids are
+unique and a list contains at most 14. The list and encoded mask represent exactly
+the same set. Its `src` is the exact same-origin
+`/static/tsjs=tsjs-first-display.min.js?m=<sliceMask>&v=<firstDisplayHash>` URL.
+`sliceMask` is exactly four lowercase hexadecimal digits encoding the 14 catalog
+rows in order; bit 0 (`first_display`) is required and unused upper bits are zero.
+The server configuration resolver enumerates the finite masks permitted by its
+enabled integration set and precomputes each exact body identity outside request
+handling. Since APS/GPT/Prebid participation is projection-dependent, a mask may
+omit an enabled slice but cannot add a disabled one; `first_display` is always set.
+The hash names the exact uncompressed base agent plus selected slice bytes in catalog
+order. A mask not permitted by current trusted configuration is not served even when
+its hash is otherwise valid.
+`runtimeSrc` is the exact same-origin
+`/static/tsjs=tsjs-unified.min.js?v=<runtimeHash>` URL emitted immediately after
+the bootstrap controller only when `firstDisplay` is `null`, and otherwise loaded by
+the controller after the agent's protected paint. `runtimeHash` is 64 lowercase
+hexadecimal characters equal to SHA-256 over the exact uncompressed UTF-8 response
+bytes. Those bytes are core followed by the manifest's takeover IIFEs in manifest
+order with the build's exact `;\n` separator; their embedded registrations and `releaseId` bind the
+URL to the catalog, phase, order, and release. Manifest URLs are transported only as
+canonical root-relative strings. During validation, the bootstrap controller and
+then core resolve each once against the trusted document origin—never
+`document.baseURI`—require the same
+origin and exact path/query round-trip, and freeze one absolute URL per entry. All
+DOM, Trusted Types, and current-script comparisons use only those canonical absolute
+values. With an agent, the controller accepts only one parser-inserted
+`script#trustedserver-js` whose resolved `src` equals the absolute first-display
+`src`; without an agent it accepts only that element with absolute `runtimeSrc`.
+The dynamically inserted runtime node uses the reserved
+`trustedserver-js-runtime` id. An absent, duplicate, or mismatched expected node
+fails the owning transaction. Redirect refusal is enforced by the local transport
+below.
+For an ordinary publisher document, the trusted document origin is the captured
+exact HTTP(S) `window.location.origin`. A sandboxed `srcdoc` creative has the opaque
+origin `"null"`; its server-owned parent therefore defines one own, non-enumerable,
+non-configurable, non-writable data property `window.__tsCreativeOrigin` containing
+the parent's exact HTTP(S) origin before any bidder markup or TSJS tag. Core accepts
+that stamp only when the document origin is exactly `"null"` and rejects an absent,
+accessor-backed, mutable, enumerable, credentialed, non-origin, or inherited value.
+The stamp authenticates only the local content-addressed TSJS URL; it is not a
+publisher API or a general cross-origin capability. Opaque creative documents have
+no deferred entries, so the phase loader never creates a dynamic script in that
+realm.
+Every deferred `src` is an exact same-origin `/static/tsjs=tsjs-<id>.min.js?v=<hash>`
+URL generated by the server for that release; accessors, arbitrary hosts, fragments,
+duplicate URLs, and mismatched ids/hashes fail manifest validation. That local
+static route must return the exact release artifact directly and never redirect.
+The persistent registration value must be a non-null plain object with exactly the
+six own enumerable data properties shown for takeover or the five shown for
+deferred; accessors, unknown/missing/inherited keys, a custom prototype, wrong
+literals/types, or a non-callable required entry point are rejected before the
+factory is retained. Registration requires exact id membership, phase, `releaseId` equality, expected script
+element identity, and `document.currentScript` identity. Integrations obtain stateful
+capabilities from the closure-private broker; they never construct a second runtime
+or replace an existing adapter, slot registry, dispatcher, or provider.
+
+The server emits exactly one parser-blocking TSJS artifact: the first-display agent
+when selected, otherwise the persistent runtime artifact. Agent bytes are its base
+followed by every selected slice in catalog order. Runtime bytes are core followed
+by every `phase:'takeover'` IIFE in manifest order. Each transaction therefore
+incurs one request and no integration waterfall. The server emits no parser-time tag
+for the other artifact or for a deferred module. The bootstrap alone creates the
+post-paint runtime node; after commit, core alone creates ordinary deferred nodes.
+`defer`, `async`, preload, or a post-commit callback attached to an already
+downloaded monolith does not satisfy this contract. In particular, transfer
+remediation cannot add a PUC-owner script, dynamic import, fetch, preload, worker,
+blob program, or other auxiliary TSJS asset before protected paint. The existing APS
+renderer-v2 iframe navigation remains the sole post-action renderer materialization
+request and does not become a code-loader for the top-page owner.
+
+The static transport is exact and shared by Fastly, Axum, Cloudflare, and Spin.
+Only `GET` and `HEAD` for
+`/static/tsjs=tsjs-first-display.min.js?m=<sliceMask>&v=<firstDisplayHash>`,
+`/static/tsjs=tsjs-unified.min.js?v=<runtimeHash>` and
+`/static/tsjs=tsjs-<deferred-id>.min.js?v=<moduleHash>` are admitted. The
+first-display query has exactly canonical `m` then `v`; the other routes have
+exactly one `v` and no other field. `firstDisplayHash` and `runtimeHash` use
+the exact composition rules above; `moduleHash` is SHA-256 over that deferred
+artifact's exact uncompressed UTF-8 bytes. The handler derives the enabled ordered
+first-display set from the validated mask plus trusted configuration, or the
+takeover/deferred catalog entry, recomputes the hash, and returns the current
+artifact only on an exact match. HTML composition chooses only a precomputed
+release-size-admitted mask from the immutable projection; the later static request never needs
+request-local projection state or a dynamic artifact cache. `HEAD` returns
+the same status and metadata as `GET` with an empty body. An unconditional success
+is `200`, `Content-Type: application/javascript; charset=utf-8`, and
+`X-Content-Type-Options: nosniff`; the existing strong-ETag/static-cache behavior,
+including a valid conditional `304`, is preserved without adding a new cache
+requirement. A missing/malformed/stale hash, unknown or disabled id, wrong method,
+unsupported method, legacy filename, or extra query field receives the adapter-local `404 no-store` and
+never falls through to publisher origin. Redirects are forbidden. Compression may
+change transfer bytes but not the uncompressed bytes named by `v`.
+
+This hard cutover serves only artifacts embedded in the active binary. It does not
+add an N/N-1 asset store or retain a previous release's TSJS routes. A page carrying
+an old manifest across deployment can receive the typed artifact/deferred failure
+defined here and must reload; the retained prior _binary_ in §8 is solely the whole-
+deployment rollback artifact. After rollback, that binary again serves its own
+release. This accepted stale-page break is not a cache or compatibility project.
+
+Upstream-library loading is orthogonal to TSJS bundling. The exact server emission
+order is the inline bootstrap controller, any enabled live integration head inserts,
+and then the one selected parser-blocking first-display or persistent TSJS artifact.
+The controller therefore captures its native intrinsics and installs all admission
+sinks before publisher/upstream code can run, while the upstream fetch can still
+overlap the selected TSJS request. The server may emit the existing fixed/configured
+live GPT tag through this interstitial path when GPT is required for the first
+projected display. When Prebid integration is enabled, its external artifact tag is
+always emitted there because the rc-baseline client readiness, bidder/user-ID/EID
+configuration, publisher queue, and initial auction contract are required before
+the first action. It remains an external script, never a TSJS source input or TSJS
+generated artifact. Its adapter installs and owns all request-capable actions only
+after the agent transaction commits, so an early library load cannot race a TS-owned
+display before correctness listeners.
+An optional/later upstream script follows its owning deferred module's trigger and
+cannot be prefetched by this path. The APS runner is never boot-preloaded: only a
+winning APS renderer document loads it through the live fixed-target proxy specified
+in §§3.6 and 4.4.
+
+Phase assignment is a release-catalog decision, not a publisher input or browser
+heuristic. Where one product supports initial and persistent behavior, the build
+defines the fixed first-display slice from §5.2.1 and the catalogued takeover module
+below. The server selects an exact first-display subset from trusted configuration
+and the immutable initial projection; it never relabels a module id or moves an
+unbounded implementation into the agent:
+
+- **first display** contains only the agent/slices required before the initial
+  request action, terminal result, and protected paint. APS/ADM protocol handling,
+  initial GPT/Prebid admission, and parser-time guards live here only when selected;
+- **takeover** contains the complete persistent owner for enabled behavior, including
+  programmatic/direct auctions, ongoing lifecycle state, publisher APIs, refresh,
+  later navigation, reconciliation, diagnostics data, rc-baseline behavior, and
+  retained audited concept gaps. On an agent page it prepares after paint and adopts initial state;
+  on a no-agent page it is the ordinary runtime boot transaction; and
+- **deferred** remains restricted to independently loadable behavior that has no
+  ownership or parser-time obligation at persistent-runtime commit, such as
+  presentation UI and a genuinely optional later lifecycle slice. A deferred
+  consumer binds only the already committed broker.
+
+A product integration may therefore have a first-display slice, one takeover module,
+and a deferred module. Those are release-owned implementation units of one product,
+not separately configurable products. The handoff record/capsule is the only bridge
+from the provisional slice; persistent/deferred sharing uses exact frozen broker
+capabilities from the one runtime.
+
+This is the canonical release catalog and its order. Capability lists use the exact
+keys shown; `—` means none. The inclusion predicate is server-owned and
+deny-unknown. A module id, phase, trigger, predicate, provider/consumer list, or
+obligation absent from this table is not a production module:
+
+| Order | Module id                  | Product     | Phase / trigger                    | Include iff                                         | Provides                                                                                               | Consumes                                                                                                     | Takeover obligation or deferred scope                                                              |
+| ----: | -------------------------- | ----------- | ---------------------------------- | --------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- |
+|     1 | `render_runtime`           | runtime     | takeover                           | always                                              | `slots.v1`, `auction.v1`, `render.v1`, `messages.v1`, `trace.v1`, `trace.presentation.v1`, `direct.v1` | `runtime.v1`                                                                                                 | Adopt initial facts/artifacts; own every later direct render, lifecycle, dispatcher, and trace     |
+|     2 | `aps`                      | APS         | takeover                           | APS integration enabled                             | `aps.v1`                                                                                               | `runtime.v1`, `slots.v1`, `render.v1`, `messages.v1`, `trace.v1`                                             | Adopt initial APS tombstones/artifacts; own all later APS and PUC work                             |
+|     3 | `creative`                 | creative    | takeover                           | `creative.enabled && (clickGuard \|\| renderGuard)` | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt parser-time guard state and own later creative behavior                                      |
+|     4 | `datadome`                 | DataDome    | takeover                           | DataDome enabled                                    | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt the initial guard state and own later route rewriting                                        |
+|     5 | `didomi`                   | Didomi      | takeover                           | Didomi enabled                                      | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt the configured SDK path and own later integration behavior                                   |
+|     6 | `google_tag_manager`       | GTM/GA      | takeover                           | Google Tag Manager enabled                          | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt the initial guards and own later matching traffic                                            |
+|     7 | `gpt`                      | GPT         | takeover                           | GPT integration enabled                             | `gpt.v1`, `gpt.events.v1`, `pbs_cache.baseline.v1`                                                     | `runtime.v1`, `slots.v1`, `auction.v1`, `render.v1`, `messages.v1`, `trace.v1`, and `aps.v1` iff APS enabled | Sole persistent GPT adapter/listeners; adopt initial physical slots and own handoff/reconciliation |
+|     8 | `gpt_diagnostics`          | diagnostics | takeover                           | `diagnostics.gpt.active`                            | `gpt_diag.v1`                                                                                          | `runtime.v1`, `gpt.events.v1`                                                                                | Consume persistent GPT facts and commit the final data-only public API                             |
+|     9 | `lockr`                    | Lockr       | takeover                           | Lockr enabled                                       | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt initial guard/readiness state and own later API-host rewriting                               |
+|    10 | `osano_consent`            | Osano       | takeover                           | Osano enabled                                       | `osano_consent.v1`                                                                                     | `runtime.v1`                                                                                                 | Adopt the initial consent mirror and own later consent-dependent work                              |
+|    11 | `permutive_context`        | Permutive   | takeover                           | Permutive enabled                                   | `permutive_context.v1`                                                                                 | `runtime.v1`                                                                                                 | Adopt initial normalized segments and own later context                                            |
+|    12 | `sourcepoint_consent`      | Sourcepoint | takeover                           | Sourcepoint enabled                                 | `sourcepoint_consent.v1`                                                                               | `runtime.v1`                                                                                                 | Adopt the initial GPP mirror/guard and own later consent work                                      |
+|    13 | `prebid`                   | Prebid      | takeover                           | Prebid integration enabled                          | `prebid.v1`                                                                                            | `runtime.v1`, `slots.v1`, `render.v1`, `messages.v1`, and `aps.v1` iff APS enabled                           | Adopt initial artifact/queue/bid state and own subsequent Prebid admission                         |
+|    14 | `testlight`                | Testlight   | takeover                           | Testlight enabled                                   | —                                                                                                      | `runtime.v1`                                                                                                 | Adopt initial callback capture and own later bridging                                              |
+|    15 | `diagnostics_presentation` | diagnostics | deferred / `first_display_or_idle` | `renderTraceOverlay \|\| diagnostics.gpt.active`    | —                                                                                                      | `runtime.v1`, `trace.presentation.v1`, and `gpt_diag.v1` iff active                                          | DOM overlay, badges, formatting, clipboard/download interaction                                    |
+|    16 | `gpt_later`                | GPT         | deferred / `first_display_or_idle` | GPT enabled                                         | —                                                                                                      | `runtime.v1`, `slots.v1`, `auction.v1`, `render.v1`, `gpt.v1`, `trace.v1`                                    | Post-first-display refresh, SPA navigation, and later reconciliation only                          |
+|    17 | `osano_lifecycle`          | Osano       | deferred / `first_display_or_idle` | Osano enabled                                       | —                                                                                                      | `runtime.v1`, `osano_consent.v1`                                                                             | Later retry/event/focus/visibility/clear maintenance                                               |
+|    18 | `permutive_lifecycle`      | Permutive   | deferred / `first_display_or_idle` | Permutive enabled                                   | —                                                                                                      | `runtime.v1`, `permutive_context.v1`                                                                         | Later SDK/segment refresh maintenance                                                              |
+|    19 | `prebid_later`             | Prebid      | deferred / `first_display_or_idle` | Prebid and GPT enabled                              | —                                                                                                      | `runtime.v1`, `slots.v1`, `gpt.v1`, `prebid.v1`                                                              | Synthetic refresh and GAM-path exclusion; never initial admission                                  |
+|    20 | `sourcepoint_lifecycle`    | Sourcepoint | deferred / `first_display_or_idle` | Sourcepoint enabled                                 | —                                                                                                      | `runtime.v1`, `sourcepoint_consent.v1`                                                                       | Later retry/visibility/focus/update/safe-clear maintenance                                         |
+
+`runtime.v1` is the kernel's only built-in capability: generation, disposal,
+clock/scheduler, queue, logger, validated boot data, capability access, and phase
+loading. All other keys have exactly the provider above. Optional consumption is
+allowed only where the table says `iff active`; absence in that case is never
+silently substituted. The maximal manifest therefore has 14 takeover plus six
+deferred entries: `MAX_TAKEOVER_MODULES = 14` and `MAX_MANIFEST_MODULES = 20`.
+The serializer, parser, registry, callback staging, tests, and fuzz/capacity fixtures
+derive 13/14/15 and 19/20/21 boundaries from this table rather than retaining a
+hand-written 16. The kernel diagnostics ingress has no integration-module
+subscription surface or subscription-capacity constant. GPT diagnostics consumes
+the separately bounded `gpt.events.v1` capability, while deferred diagnostics
+presentation alone consumes `trace.presentation.v1`. `attachPresentation` is absent
+from `trace.v1`, so APS, GPT, and `gpt_later` cannot obtain presentation authority
+even though they publish or consume trace facts. Public diagnostic subscriber limits
+remain separate.
+
+The release catalog records, for every module id, its product integration, phase,
+trigger, provided/consumed capability keys, and whether parser-time activation is a
+proved rc-baseline or retained-gap obligation. The build rejects dependency cycles, a deferred
+provider consumed by another module, two providers for one key, a phase override
+from server or publisher data, provider-after-consumer manifest order, and any
+takeover entry that imports a catalogued deferred source area. GPT, the APS runner,
+the external Prebid artifact, PUC, and all
+other upstream script bytes remain remote/live and are never copied into a TSJS
+bundle; only Trusted Server-owned adapters, contracts, and lifecycle code may be in
+these artifacts.
+
+Both persistent phases use the same module-transaction rules. Registration stores
+code but does not execute it. On an agent page, the post-paint takeover transaction
+calls `prepare(ctx)` in manifest order. On a no-agent page, the one parser-blocking
+runtime calls `prepareSync(ctx)` in manifest order and never opens an asynchronous
+preparation gap. Each deferred transaction calls its own `prepare(ctx)` independently
+after that module's accepted registration and `load` checkpoint, without awaiting or
+ordering against a deferred sibling. `prepare` may be synchronous or asynchronous;
+`prepareSync` must be synchronous. Their only legal effects are validating frozen configuration,
+obtaining declared capability interfaces, allocating private inert data/closures,
+and registering private-memory disposers. Preparation cannot read or write ad-tech
+globals, attach a listener/observer/wrapper, touch live DOM, inject a script, start a
+timer/fetch, schedule detached work, invoke publisher code, or call a stateful
+adapter/service method. For `prepare` only, the one Promise returned to and awaited
+by the phase owner, including its ordinary `await`/settlement continuations, is
+permitted; no continuation may be detached from that Promise or survive its
+settlement/abort. `prepareSync` returning a Promise or any thenable is an ABI failure.
+Preparation returns exactly one prepared module with a synchronous `activate(ctx)`
+function and its declared frozen capability interfaces. Core validates and stages a
+provider's interfaces immediately after that provider prepares, so later consumers
+can receive them in their preparation context; the interfaces remain effect-inert
+until provider activation and are removed during rollback. Preparation code cannot
+call a staged stateful capability. Takeover activation order is the same
+provider-before-consumer order, so no consumer becomes live first.
+
+After every takeover module prepares, core enters one synchronous takeover
+activation barrier in manifest order. On the no-agent path this barrier runs in the
+same classic parser-blocking script evaluation as every `prepareSync` call and the
+kernel commit; no Promise, microtask, timer, network wait, or publisher task can occur
+between preparation, activation, and commit. Every catalogued parser-time obligation
+therefore installs before the script returns. In particular, the GPT module installs
+correctness listeners and, when `gamAttributionEnabled`, synchronously enqueues the
+one `googletag.setConfig({targeting:{ts:'true'}})` command during activation. If the
+GPT command queue is already live it executes before activation returns; otherwise
+it precedes publisher parser work after the TSJS tag. Async SDK readiness and all
+request-capable work start only through `afterCommit`. On an agent page the
+first-display slice already owns those parser-time obligations; post-paint takeover
+adopts them through §5.2.1 instead of installing a competing guard.
+
+`activate(ctx)` may install only synchronously
+compare-restorable wrappers, listeners, observers, guards, provider live-state
+transitions, and service subscriptions. It registers the disposer before each mutation and may stage bounded
+post-commit work through `ctx.afterCommit(fn)`, but cannot inject/load a script,
+start network/timers, schedule work, drain a publisher queue, or invoke publisher
+callbacks directly. The persistent message-dispatcher and GPT-adapter provider
+modules occupy the catalogued provider positions before their consumers, and their
+correctness listeners are activated there rather than left live during asynchronous
+preparation. If any takeover activation throws, core synchronously
+runs every activated and prepared disposer once in reverse order before committing
+fallback. Since the barrier never yields and activation cannot call publisher code,
+no publisher task can observe a partial persistent generation.
+
+The takeover activation barrier checks its monotonic deadline immediately
+before and after every `activate` call and once more before kernel handoff. Elapsed
+time greater than or equal to 10,000 ms synchronously unwinds and commits fallback
+even when the timer task has not run. JavaScript cannot preempt an activation
+function that never returns; a malicious/nonreturning same-realm module can freeze
+the page and is an accepted platform limitation, not a second-runtime recovery case.
+
+After all takeover activations succeed, core commits the kernel API, runs takeover
+`afterCommit` callbacks in manifest order, and only then drains the bootstrap queue.
+Those callbacks may synchronously start required upstream scripts, timers, readiness
+work, and rc-baseline DOM scans; publisher code they intentionally invoke therefore
+sees the complete kernel. A callback throw is isolated to its module, runs that
+module's remaining disposers, records a bounded local runtime failure, and makes
+affected operations fail through their existing typed readiness/render result; it
+cannot roll back an already published kernel or create a fallback generation.
+
+Every deferred module uses the sole `first_display_or_idle` phase gate. Core arms a
+10,000 ms **attempt-creation** guard at kernel commit on every page, including one
+with no server projection, so an immediate programmatic `addAdUnits`/`requestAds`
+first display is protected. The first render batch to create an attempt during that
+window becomes the immutable protected first-display batch. The guard is cancelled,
+and deferred work waits without another fixed cutoff until every attempt in that
+batch reaches its terminal latch. Readiness plus GPT/renderer completion may
+therefore exceed ten seconds without a deferred race. The guard fires only when no
+server-projected or programmatic attempt was created by its boundary. Firing is the
+explicit runtime decision that no _startup-protected_ display exists; it releases the
+deferred phase even though publisher code may create a later first attempt. That
+post-window attempt uses the same correct persistent owners but may overlap already
+released later work. The design makes no absolute load-contention guarantee for a
+first display initiated after 10,000 ms.
+
+Terminal/no-attempt is not itself permission to fetch. On a visible document, the
+phase loader waits through two owned `requestAnimationFrame` callbacks, guaranteeing
+one intervening paint opportunity, and records the internal paint gate only in the
+second callback. If the document is hidden, it waits for the first of visibility
+return through that same two-frame gate or a 2,000 ms owned idle timeout; there is no
+visible paint to contend with while hidden. Only after that gate does it schedule
+deferred loading in `requestIdleCallback({timeout:2_000})`. The
+non-idle fallback is one owned 50 ms timer created after the paint/hidden gate, never
+a zero-delay task before paint.
+
+The catalog has no on-demand network trigger. A takeover provider may expose a
+bounded readiness facade for behavior implemented by a deferred slice. Each caller's
+existing deadline begins at its original enqueue time and may expire while the phase
+gate is closed. The shared module receives a separate ten-second load/transaction
+deadline only when `first_display_or_idle` actually triggers; only still-live
+waiters observe readiness. Expiring one waiter never aborts the shared module while
+another waiter or the catalogued background load still owns it.
+
+Core creates a classic same-origin script element with the canonical absolute form of
+the exact manifest `src`,
+stores its identity before insertion, and authenticates registration with that
+identity plus `document.currentScript`. It uses neither dynamic `import()` nor
+`eval`. After the common paint/idle gate, it starts every included deferred module's
+independent transaction in manifest order without awaiting another module. Each
+dynamically created classic script is `async = true`; network, evaluation, and local
+transaction completion may finish in any order. This is safe because the catalog
+forbids deferred-to-deferred capability edges. A hung, failed, or slow module cannot
+consume another module's deadline or delay its fetch, preparation, or activation.
+
+Deferred insertion preserves the publisher's script policy; it never rewrites a
+Content-Security-Policy header or meta element and never adds `unsafe-inline`,
+`unsafe-eval`, a source host, or a default Trusted Types policy. Before HTML
+transformation, the server examines only enforcing response
+`Content-Security-Policy` headers, applies `script-src-elem` → `script-src` →
+`default-src` precedence within each policy, validates bounded base64/base64url nonce
+tokens, and selects a nonce only when the intersection of nonce-bearing policies is
+one exact value. Report-only headers, malformed values, multiple candidates, and
+disjoint policies authorize no nonce. A nonce introduced only by publisher markup or
+a meta-delivered policy is unavailable before injection and is not inferred.
+
+When one response-header nonce is admitted, the server places that same value on
+every Trusted Server-generated executable tag in order: inline bootstrap controller,
+request-scoped inline diagnostics cleanup, live integration head inserts (including
+their inline and external script elements), and the selected parser-inserted
+first-display/runtime tag. Invalid or absent authority produces no `nonce`
+attribute. The parser-inserted tags remain subject to the publisher's effective CSP
+and are a deployment precondition just as TSJS injection is on the rc baseline. The
+controller/core copies only the authenticated parser-inserted element's `nonce` IDL
+value to the post-paint runtime and every deferred script before insertion. This
+supports nonce-only policies and preserves the trusted-root chain under
+`strict-dynamic`; an absent nonce is never synthesized or copied from an unrelated
+publisher element.
+
+`HTMLScriptElement.src` is a Trusted Types script-URL sink. When the browser exposes
+`trustedTypes`, the direct core path attempts once per document runtime to create the
+closure-private policy `trusted-server#tsjs-v1`. On an agent path, bootstrap creates
+that policy at most once for the post-paint persistent insertion and leases the same
+closure-private URL constructor to core for all deferred insertions; core never
+creates a competing policy. Its `createScriptURL` callback returns its canonical
+absolute argument only when that value is exact membership in the frozen absolute
+runtime/deferred URL set for the owning path; it rejects every other string and is
+never exposed. If publisher CSP does
+not permit that policy name or the name is unavailable, core may assign the raw
+manifest string so a publisher's existing default policy or a non-enforcing browser
+can process it, but it immediately verifies that the element's resolved `src` is
+still byte-for-byte the expected canonical absolute URL before insertion. A
+synchronous Trusted Types throw, empty value, mutation, or policy result outside the
+exact manifest is `policy_blocked`; TSJS does
+not try `setAttribute`, another policy name, a blob/data URL, `eval`, or a remote
+fallback. Under enforcing Trusted Types with neither the named policy nor a
+publisher default policy that preserves the exact URL, the affected deferred module
+therefore becomes unavailable while the committed runtime stays live. Publishers
+that restrict the `trusted-types` directive and require deferred TSJS behavior must
+allow the fixed `trusted-server#tsjs-v1` name; this grants only the exact release
+URLs already selected by the server. A nonce/source CSP rejection after insertion is
+observed through the script's `error` event and is `load_error`, not
+`policy_blocked`; the runtime installs no `SecurityPolicyViolationEvent` listener.
+A node removed or replaced after insertion may already have initiated a request, but
+its disconnected/replaced identity cannot register and settles as
+`registration_rejected` (or `load_error` if fetch rejection wins).
+
+Full document-runtime disposal aborts pending module readiness, clears idle/
+timer/load listeners, removes an uncommitted script node, and makes late registration
+inert. SPA navigation disposal cancels only waiters and state owned by that
+`NavigationSession`; the runtime-owned fetch/transaction may complete for the next
+session and cannot retain or act on the disposed one.
+No deferred request, preload, preparation, or execution may begin before its trigger,
+and a `first_display_or_idle` module must not begin before the reference fixture's
+`tsjs:first-display-paint` gate.
+
+Each deferred entry follows
+`not_triggered -> loading -> registered -> preparing -> activating -> ready`, with
+any nonterminal state able to move once to `unavailable`. Registration only stores
+the factory. The exact script `load` must then observe exactly that one accepted
+registration before preparation begins; `load` without registration, `error`, a
+second registration, or deadline/disposal wins the terminal latch and never invokes
+the factory. The load/error listeners and inert script node are removed as soon as
+that fetch/registration checkpoint becomes terminal; executing bytes remain owned
+only by the registered factory/module closure. The bounded internal unavailable reason distinguishes `load_error`,
+`load_without_registration`, `registration_rejected`, `prepare_failed`,
+`activation_failed`, `after_commit_failed`, `policy_blocked`, `module_timeout`, and
+`disposed` for local diagnostics/tests. It is not added to `TsjsApi` or an analytics
+schema.
+
+Each deferred module gets one fixed ten-second deadline from its trigger through
+script fetch, accepted registration, preparation, activation, and `afterCommit`.
+Queued dependent operations retain the independent original deadlines above and
+share the module readiness Promise only while live. With no waiting operation, the
+module deadline still retires its script and state rather than leaking indefinitely. The module's
+preparation and synchronous activation run against the already committed
+`RuntimeSession` and broker, after which its `afterCommit` callback runs. Failure,
+timeout, wrong bytes, or disposal marks only that module terminal-unavailable and
+settles dependent work through its existing exact typed reason (for example
+`external_ready_timeout` or `external_artifact_incompatible`). It does not roll back
+the kernel, activate the no-bundle fallback, retry indefinitely, or construct a
+second adapter/runtime. Once a deferred module reaches ready or unavailable, its
+registration is permanently closed. A capability provider removed during module or
+full-runtime disposal is never replaced within that generation; navigation disposal
+clears only navigation-scoped state and does not remove the document-runtime
+provider needed by the next `NavigationSession`.
+
+`ctx.signal` aborts pending preparation. `ctx.onDispose(fn)` is the only disposal
+registration mechanism; a disposer registered after disposal runs immediately, and
+one failing disposer does not prevent the rest. Each module may call
+`ctx.afterCommit` at most once. A second call by a takeover module unwinds the
+takeover barrier and commits `bundle_partial`; a second call by a deferred module
+marks only that module unavailable. Direct-to-runtime takeover shares the bootstrap
+deadline; post-paint agent takeover owns the separate deadline in §5.2.1. Deferred
+modules do not start another global boot clock.
+
+### 5.3 Bootstrap ownership
+
+Bootstrap uses a generation-scoped state machine:
+
+```text
+unclaimed -> installing -> agent -> transferring -> kernel
+                     |                         \-> fallback
+                     |-> kernel (no agent)
+                     \-> failed --------------------> fallback
+```
+
+Bootstrap retains an existing non-null object/function `window.tsjs` target or
+creates and assigns one only when the existing value is falsy; a conflicting truthy
+primitive fails closed. It normalizes only that target's queue/boot fields and does
+not replace a publisher-created object. Before the direct persistent task, or at
+protected paint before an agent creates the persistent task, bootstrap permanently
+seals `window.tsjs` as the one-read admission getter described above. Normal reads
+continue to return the exact retained target, so the public namespace identity does
+not change. The kernel remains externally inert and commits ownership only after all takeover
+integration modules prepare and synchronously activate in order. The agent also
+leaves the public runtime surface uncommitted. Deferred modules are not part of the
+bootstrap/takeover transaction. Before first-display or takeover module work, bootstrap
+normalizes `que` to one actual Array and defines the `tsjs.que` data
+property as writable false/configurable true for the installing generation. It keeps
+the ingress Array's native `push`
+throughout `installing`. Thus ordinary assignment cannot redirect the queue, and
+callbacks pushed at any point during the shared deadline append to the same ingress
+Array instead of a one-time snapshot. A preexisting non-Array `que` contributes no
+callbacks and is replaced; an Array's existing own data entries are retained in
+index order.
+
+Kernel and fallback use the same synchronous, non-interleavable commit handoff in one
+JavaScript task. Its order is exact:
+
+1. create an empty actual-Array final executor, install its own immediate-execution
+   `push`, and freeze the Array;
+2. snapshot the ingress Array's callable own data entries in ascending index order;
+3. clear the ingress Array and replace its `push` with a forwarder to the final
+   executor for publishers retaining the old reference;
+4. redefine `tsjs.que` as the final executor with a writable-false,
+   configurable-false descriptor while installing all other complete committed
+   `tsjs` fields;
+5. for a kernel commit, run every staged takeover `afterCommit` callback in takeover
+   manifest order; fallback has none; and
+6. drain the snapshot FIFO.
+
+No browser task or microtask can interleave steps 1–6. Code intentionally invoked by
+an `afterCommit` callback sees the complete API and committed queue. A callback is therefore either
+in the snapshot or reaches the final executor through one of the two queue
+references, never lost or invoked twice. A callback that pushes while the snapshot
+drains executes immediately through the committed queue before draining continues;
+one throw is isolated. Both ingress and final values satisfy
+`Array.isArray(...) === true`. The old ingress identity remains a live forwarding
+queue; the public `tsjs.que` identity changes exactly once at commit.
+
+One ten-second watchdog begins immediately before the parser-blocking artifact and
+covers agent registration/activation plus initial-action start, or direct-to-runtime
+registration, preparation, and synchronous takeover activation when no agent is
+selected. A preparation/activation failure, ABI mismatch, or deadline aborts the
+installing generation, synchronously unwinds registered disposers in reverse order,
+and then commits fallback. The completed agent batch uses the bounded per-attempt
+deadlines in §4; persistent loading/takeover has its own fixed ten-second deadline
+starting only after protected paint. A late artifact continuation that arrives after
+fallback is rejected and quarantined. Deferred loading never starts before kernel
+commit, so a deferred failure cannot select or replace fallback. Every late
+continuation verifies its owner generation and self-discards.
+
+The server-owned inline bootstrap controller is deliberately smaller than a runtime.
+It installs only the queue ingress, immutable boot/manifest inputs, generation latch,
+artifact error/watchdog observation, both release-internal registration sinks,
+User Timing start mark, and terminal fallback commit. It owns no adapter, slot,
+auction, renderer, integration feature, upstream loader, DOM scan, or publisher
+callback execution before handoff. The server follows it with only any
+first-display-required live upstream tags described in §5.2 and the one
+parser-blocking agent-or-runtime tag. There are no separate integration-configuration
+script tags or globals: all configuration is already inside the captured
+`TsjsBootV1` value.
+
+The old `gpt_bootstrap.js` asset and its initial-load hooks, handoff wrappers,
+hydration scheduler, slot definition, targeting, display, and refresh are deleted
+rather than retained as another runtime. The minimal controller/fallback is generated
+from one TypeScript source, embedded by the server, included in the release hash and
+its own §5.12 budget, and pinned by a staleness test; behavior is not hand-maintained
+in both ES5 and TypeScript. On an agent page, later GPT/render behaviors run only after the persistent
+runtime commits. This intentionally changes the missing/partial-artifact case: it no
+longer attempts a best-effort GPT render through a duplicated degraded runtime and no
+longer retains known-slot membership merely to report failure; it commits the empty
+terminal fallback below.
+
+The fallback is a terminal, non-rendering shell, not a reduced second runtime. Its
+commit atomically records one immutable boot failure reason:
+
+- `abi_mismatch` for invalid manifest shape, duplicate/unknown integration id, wrong
+  release, invalid phase/catalog/source binding, duplicate registration,
+  or incompatible ABI; or
+- `bundle_partial` for a missing first-display/takeover module, preparation
+  throw/rejection, activation/takeover throw, nonterminal TS state at the admission
+  seal, or the owning deadline.
+
+Before draining user work it installs `version:'1.0.0'`, the embedded `releaseId`, a
+safe frozen `TsjsBootV1`, unavailable-only `tsjs.requestAds` and
+`tsjs.addAdUnits`, the local `tsjs.log`, the
+immediate-executor `tsjs.que`, a permanently refusing internal
+`_registerIntegration`, and a frozen
+`tsjs._internal` value containing only
+`{state:'fallback',releaseId,reason,initialDisplayCommitted}`. It
+constructs no runtime session, slot registry, GPT/Prebid adapter, bridge dispatcher,
+timer, listener, port, or iframe. It never exposes a compatibility API.
+
+The safe fallback boot uses the independently embedded release and critically checked
+selected URLs in
+`manifest:{version:1,releaseId,firstDisplay,runtimeSrc,integrations:[]}` and uses
+`integrations:{version:1,entries:[]}` because fallback activates no integration. It
+always substitutes exactly
+`auctionProjection:{version:1,auction:{version:1,auctionId:'fallback',results:[]},slots:[],bids:[]}`
+and the creative/diagnostics disabled safe defaults from §§5.4/5.8. The controller
+does not retain or partially trust the server projection on a failure path and does
+not import §§3.1–3.2 merely to improve fallback reporting. Consequently
+`requestAds()` and every explicit selection reject the classified
+`TsjsUnavailableError` without inspecting slot ids or abort signals. This deliberate
+terminal-shell behavior is not a compatibility promise, input-validation substitute,
+or render recovery path.
+
+After installing those surfaces, fallback drains the preexisting callback queue FIFO
+exactly once with `this === tsjs`; one callback throw does not prevent later callbacks.
+Subsequent `que.push(fn)` executes a callable immediately once and ignores non-callable
+values. Every module registration is refused without invoking integration code, and
+every late bundle continuation self-discards. Browser tests cover each failure
+checkpoint, queued and later `requestAds`, callback throws, already-aborted signals,
+and late bundles; no valid call remains pending.
+
+### 5.4 Public surface after cutover
+
+There are no compatibility aliases:
+
+| Baseline surface                         | Final surface                                                                                                      |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| scattered `window.__tsjs_*` flags/config | `tsjs.boot.*`                                                                                                      |
+| `tsjs.adSlots`/`tsjs.bids`               | initial `tsjs.boot.auctionProjection` including exact ordered placements; internal navigation projection after SPA |
+| `tsjs.version === '0.1.0'`               | `tsjs.version === '1.0.0'` plus `tsjs.releaseId`                                                                   |
+| `globalThis.tscreative`                  | no callable equivalent; automatic creative module                                                                  |
+| `globalThis.tsCreativeConfig`            | `tsjs.boot.creative`                                                                                               |
+| void/callback `requestAds`               | `tsjs.requestAds(options): Promise<RequestAdsResult>`                                                              |
+| placeholder `renderAdUnit`               | `tsjs.requestAds({slots:[id]})`                                                                                    |
+| placeholder `renderAllAdUnits`           | `tsjs.requestAds()`                                                                                                |
+| generic mutable `setConfig`/`getConfig`  | immutable `tsjs.boot.*` plus typed integration config                                                              |
+| `tsjs.renders`/`renderLog`/`renderSeq`   | `tsjs.diagnostics.renderTrace`                                                                                     |
+| `window` event `tsjs:adRendered`         | `tsjs.diagnostics.renderTrace.subscribe(listener)`                                                                 |
+| `tsjs.gptDiagnostics`                    | `tsjs.diagnostics.gpt`                                                                                             |
+| `window.__tsjs_prebid_bundle`            | exact own `pbjs.__trustedServerArtifactV1` stamp                                                                   |
+| integration install/patch sentinels      | kernel integration registry/`WeakSet`                                                                              |
+| GPT slot expandos                        | `SlotRecord`                                                                                                       |
+
+`window.tsjs.que` remains the pre-load command queue because it is the bootstrap
+transport, not a legacy behavior alias.
+
+The complete committed public API is the following union; the pre-load
+`{que,boot,_registerIntegration}` transport and closure-private controller state are
+not a committed API generation:
+
+```ts
+interface CreativeBootV1 {
+  readonly version: 1
+  readonly enabled: boolean
+  readonly clickGuard: boolean
+  readonly renderGuard: boolean
+}
+
+interface TsjsBootV1 {
+  readonly abi: 1
+  readonly releaseId: string
+  readonly manifest: Readonly<BootManifestV1>
+  readonly auctionProjection: Readonly<BrowserAuctionProjectionV1>
+  readonly integrations: Readonly<IntegrationConfigsV1>
+  readonly creative: Readonly<CreativeBootV1>
+  readonly diagnostics: Readonly<DiagnosticsBootV1>
+}
+
+interface TsjsCommandQueue {
+  readonly length: 0
+  push(callback: unknown): 0
+}
+
+interface TsjsApiBase {
+  readonly version: '1.0.0'
+  readonly releaseId: string
+  readonly boot: Readonly<TsjsBootV1>
+  readonly que: TsjsCommandQueue
+  readonly log: TsjsLog
+  /** Release-internal sink; true only for the exact active module load. */
+  readonly _registerIntegration: (registration: unknown) => boolean
+  addAdUnits(
+    units: ProgrammaticAdUnit | readonly ProgrammaticAdUnit[]
+  ): AddAdUnitsResult
+  requestAds(options?: RequestAdsOptions): Promise<RequestAdsResult>
+}
+
+interface TsjsKernelApi extends TsjsApiBase {
+  readonly diagnostics: Readonly<TsjsDiagnostics>
+  readonly _internal: Readonly<{ state: 'kernel'; releaseId: string }>
+}
+
+interface TsjsFallbackApi extends TsjsApiBase {
+  readonly diagnostics?: never
+  readonly _internal: Readonly<{
+    state: 'fallback'
+    releaseId: string
+    reason: 'abi_mismatch' | 'bundle_partial'
+    initialDisplayCommitted: boolean
+  }>
+}
+
+type TsjsApi = TsjsKernelApi | TsjsFallbackApi
+```
+
+`version` is the semantic public-API generation and changes only with a reviewed API
+contract; `releaseId` identifies the exact bundle set and equals
+`boot.releaseId`/`boot.manifest.releaseId`. The bootstrap parses, critically validates,
+copies, and recursively freezes the sealed transport before effects. The selected
+first-display or persistent owner completes domain validation before using projection
+or integration values; fallback publishes only the independent safe boot above.
+`boot.integrations` is immutable public inspection data,
+not a mutable service locator: the composition root passes only the owning frozen
+entry through each module's preparation/activation context. The hard cutover emits
+no `window.__tsjs_*` integration-config value and deletes the old per-integration
+bootstrap globals/templates in the same release; no module aliases or falls back to
+them. `_internal` is a frozen, non-enumerable status
+value; the service registry remains in the composition closure and is available to
+integration modules only through those contexts during startup.
+
+Fallback `initialDisplayCommitted` is `true` only when takeover failed after the
+agent had already accepted at least one initial artifact; the fallback still reports
+later TSJS operations unavailable and owns no artifact control. It is `false` for
+every pre-display/bootstrap failure. This local status does not change a render
+result, remove accepted DOM, or create a recovery path.
+
+`_registerIntegration` is deliberately present only because separately downloaded
+release-owned IIFEs need one handshake. During takeover installation it accepts the
+next takeover registration from the server-composed runtime artifact. After kernel
+commit it returns `true` only while an expected deferred script element created by
+that kernel is the exact `document.currentScript`, and only for that element's
+declared id, phase, and `releaseId`. It returns `false` without invoking supplied code
+for publisher calls, unsolicited tags, wrong/replaced nodes, duplicates, terminal
+modules, fallback, or disposal. It is not a general extension API, and neither it
+nor `_internal` exposes readiness Promises, the broker, module state, or capability
+objects.
+
+The final queue is the frozen actual empty Array from the commit handoff and contains
+no retained callbacks. Its own `push` invokes one callable
+immediately and exactly once with `this === tsjs`, returns `0`, ignores a
+non-callable, and isolates/logs a throw. Pre-load callbacks are snapshotted and
+drained FIFO only after the committed API is installed, so publisher callbacks never
+run against a half-installed generation. Native mutators, borrowed Array mutators,
+index assignment, `length` assignment, deletion, and property definition cannot
+change the frozen executor or retain a callback; failure follows ordinary strict- or
+sloppy-mode JavaScript semantics and `length` remains `0`.
+
+#### 5.4.1 Programmatic ad-unit registration
+
+The clean public core surface retains programmatic direct-auction registration:
+
+```ts
+interface ProgrammaticAdUnit {
+  code: string
+  mediaTypes: {
+    banner: { sizes: readonly (readonly [number, number])[] }
+  }
+  bids?: readonly {
+    bidder: string
+    params?: Readonly<Record<string, unknown>>
+  }[]
+}
+
+interface AddAdUnitsResult {
+  readonly registered: readonly string[]
+}
+
+type AdUnitRegistrationErrorCode =
+  | 'invalid_units'
+  | 'invalid_unit'
+  | 'invalid_code'
+  | 'duplicate_code'
+  | 'slot_collision'
+  | 'invalid_media_types'
+  | 'invalid_dimensions'
+  | 'dimensions_out_of_range'
+  | 'invalid_bids'
+  | 'invalid_bidder'
+  | 'invalid_params'
+  | 'request_body_too_large'
+  | 'registry_capacity'
+
+class AdUnitRegistrationError extends Error {
+  readonly code: AdUnitRegistrationErrorCode
+  readonly unitIndex?: number
+}
+
+class TsjsUnavailableError extends Error {
+  readonly code: 'runtime_unavailable'
+  readonly releaseId: string
+  readonly reason: 'abi_mismatch' | 'bundle_partial'
+}
+```
+
+Registration is synchronous, all-or-nothing, and navigation-scoped. `code` becomes
+the exact slot id and must satisfy the server slot-id UTF-8 bound from §4.6. The
+argument is one unit or a nonempty array of at most 256 plain data objects. Codes are
+nonempty and unique in the call; banner sizes are nonempty integral number pairs in
+the shared 1–4096 renderer range; bidder names are nonempty and at most 64 UTF-8
+bytes; params are plain JSON-compatible data with the same request-body cap as
+`/auction`. Accessors,
+unknown media types, duplicate codes, or a collision with any server-projected or
+already registered slot reject the whole call with a typed
+`AdUnitRegistrationError` before state changes. There is no merge-by-code behavior.
+The outer shape/count maps to `invalid_units`; a non-plain unit or unknown/accessor
+unit field to `invalid_unit`; code shape, in-call duplicate, and registry collision to
+`invalid_code`, `duplicate_code`, and `slot_collision`; media/banner shape to
+`invalid_media_types`; a nonnumeric/nonfinite/fractional/nonpositive dimension to
+`invalid_dimensions`; an integral dimension outside 1–4096 to
+`dimensions_out_of_range`; bid-array and bidder-name shape to
+`invalid_bids`/`invalid_bidder`; non-JSON, cyclic, accessor-bearing, or otherwise
+unserializable params to `invalid_params`; and encoded body overflow to
+`request_body_too_large`. `unitIndex` is the lowest failing input index when the
+failure belongs to a unit and is absent for outer/capacity errors. Validation order
+is the order just listed, then capacity reservation; repeated runs return the same
+code/index without reading publisher accessors.
+
+Successful units receive registration ordinals after the immutable server projection
+and participate in later `requestAds` snapshots. They use the direct auction/render
+path unless an explicit future design gives them a GPT mapping; registration alone
+never defines, displays, refreshes, or targets GPT. The old placeholder-writing
+methods are deleted rather than aliased. `tsjs.log` retains the existing bounded
+level/method surface, while runtime configuration is immutable boot data or typed
+integration-owned configuration. Fallback validates `addAdUnits` input and then throws
+`TsjsUnavailableError` with the committed boot failure; it constructs no registry.
+
+The retained logger has this exact hard-cutover surface:
+
+```ts
+type TsjsLogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug'
+
+interface TsjsLog {
+  setLevel(level: TsjsLogLevel): void
+  getLevel(): TsjsLogLevel
+  error(...values: readonly unknown[]): void
+  warn(...values: readonly unknown[]): void
+  info(...values: readonly unknown[]): void
+  debug(...values: readonly unknown[]): void
+}
+```
+
+The initial level is `warn`. `setLevel` accepts only the five exact strings above;
+an invalid runtime value throws `TypeError` without changing the current level.
+Missing/throwing console methods are swallowed at the logger boundary, log failures
+never change ad behavior, and the logger does not retain argument arrays. The
+fallback exposes the same logger and level behavior.
+
+### 5.5 Direct auction API
+
+```ts
+interface RequestAdsOptions {
+  slots?: readonly string[]
+  timeoutMs?: number
+  signal?: AbortSignal
+}
+
+type RequestAdsInputErrorCode =
+  | 'invalid_options'
+  | 'invalid_slots'
+  | 'empty_slots'
+  | 'duplicate_slot'
+  | 'invalid_timeout'
+  | 'invalid_signal'
+
+class RequestAdsInputError extends Error {
+  readonly code: RequestAdsInputErrorCode
+}
+
+type RequestAdsSlotResult =
+  | { slot: string; path: 'primary' | 'fallback'; outcome: 'accepted' }
+  | { slot: string; path: 'primary' | 'fallback'; outcome: 'no_bid' }
+  | {
+      slot: string
+      path: 'primary' | 'fallback'
+      outcome: 'failed'
+      reason: RenderFailureReason
+    }
+  | {
+      slot: string
+      path: 'primary' | 'fallback'
+      outcome: 'cancelled'
+      reason: 'caller_aborted' | 'superseded' | 'navigation_disposed'
+    }
+
+interface RequestAdsResult {
+  slots: RequestAdsSlotResult[]
+}
+```
+
+Every `RequestAdsOptions.slots` entry is an exact, case-sensitive registered slot id:
+either a server slot id from §2.2 or a programmatic `code` admitted by §5.4.1. The
+public API never interprets an entry as a GPT ad-unit path, DOM id, or DOM alias. An
+explicit id absent from the invocation snapshot resolves individually as
+`failed{reason:'slot_unresolved'}` while valid siblings proceed. Internal GPT-path or
+DOM-alias lookup that has zero or multiple matches also fails the affected slot as
+`slot_unresolved`; it never selects the first registration.
+
+When `slots` is omitted, `requestAds` synchronously snapshots every server-projected
+and programmatic slot registered in the current `NavigationSession`, ordered by its
+navigation-local registration ordinal. That immutable snapshot is the batch
+membership and result order; a slot registered after invocation is excluded. When
+`slots` is present, its validated input order is the result order. The `slot` field in
+every result is always the exact registered slot id.
+
+When `timeoutMs` is omitted, the shared auction-response deadline is exactly 10,000
+milliseconds. An explicit value replaces that default and must satisfy the bounds
+below; renderer/GPT path deadlines remain independently fixed by their lifecycle
+transitions.
+
+Omitted/`undefined` options are valid. Otherwise the argument must be a non-null
+plain object whose prototype is this realm's `Object.prototype` or `null`, containing
+only `slots`, `timeoutMs`, and `signal` as own enumerable data properties. Accessors
+or unknown keys are `invalid_options`; non-array slots, non-string/empty/>256-byte
+slot values, and more than 256 values are `invalid_slots`; an explicitly empty array
+is `empty_slots`; an exact duplicate is `duplicate_slot`; a noninteger timeout
+outside `100..30_000` is `invalid_timeout`; and a value that fails the platform
+`AbortSignal.prototype.aborted` brand getter is `invalid_signal`. These reject
+before attempts with `RequestAdsInputError`. Once an attempt is created, the
+returned promise resolves with per-slot terminal results and does not reject for
+auction or render failures. Unknown requested slots fail individually while valid
+siblings proceed. Omitted slots with an empty registry resolve an empty `slots`
+array. A registration collision cannot alter the snapshot or result ordering.
+
+The response deadline governs only the shared auction fetch. Once a response parses,
+path-specific renderer deadlines take over. The caller signal remains active until
+all child attempts settle.
+
+### 5.6 Adapters and external readiness
+
+GPT and Prebid adapters expose `present | pending | timed_out | incompatible`.
+`timed_out` and `incompatible` are not permanent global failures: a later valid
+external replacement can satisfy later operations.
+Each queued operation owns its own deadline and disposal; an expired operation is
+removed instead of running unexpectedly when the external library appears later.
+Each adapter queue holds at most 64 live operations, drains FIFO, and fails only the
+overflowing operation with `external_queue_full`. The operation deadline is exactly
+ten seconds from enqueue and is independent of the auction-fetch response deadline;
+expiry is `external_ready_timeout`. Readiness at the boundary races through the
+operation's terminal latch, so exactly one of dispatch or timeout wins.
+
+The GPT adapter owns early event subscription, command-queue interaction,
+`display`, `refresh`, targeting, and service-state inspection. The Prebid adapter
+owns commands, event subscription, bid-response registration, and Universal
+Creative integration. Tests use adapter fakes rather than mutable global objects.
+
+The decoupled Prebid artifact remains pure Prebid.js and retains its independent
+five-second queue-drain watchdog. The generated wrapper arms that watchdog as its
+first statement, before stamp inspection or module initialization. At 5,000 ms it
+looks up the then-current real Prebid object and calls its idempotent `processQueue()`
+at most once for that wrapper, whether or not the TS integration installed, so
+publisher callbacks are not held hostage by stamp conflict, a missing TS bundle, or
+a partial/duplicate artifact. Duplicate wrappers may reach the idempotent API, but
+black-box tests require each queued publisher callback to execute once. A later TS integration module may call the idempotent API again.
+The module first verifies the real Prebid API, then installs transactionally. It does
+not install the synthetic-refresh policy, clear targeting, or mutate publisher bids
+when only the injected `{que,cmd}` stub exists. The artifact manifest carries both
+module stems and runtime bidder codes, including aliases.
+
+The artifact exposes this frozen plain-data runtime stamp; the separately emitted
+build manifest contains the same fields plus filename/integrity metadata:
+
+```ts
+interface ExternalPrebidArtifactV1 {
+  readonly abi: 1
+  readonly artifactReleaseId: string
+  readonly prebidVersion: '10.26.0'
+  readonly moduleStems: readonly string[]
+  readonly bidderCodes: readonly string[]
+  readonly bidderAliases: readonly {
+    readonly code: string
+    readonly moduleStem: string
+  }[]
+  readonly userIdModules: readonly {
+    readonly moduleName: string
+    readonly configNames: readonly string[]
+    readonly eidSources: readonly string[]
+  }[]
+}
+```
+
+After arming the watchdog and before executing embedded Prebid module factories, the
+wrapper inspects the current `window.pbjs` and its own descriptor for
+`__trustedServerArtifactV1`. If that object already has the required real API plus a
+valid recursively frozen stamp, an exact same-release/content duplicate reuses it and
+skips module initialization/redefinition; a different valid release refuses only the
+new wrapper and likewise leaves the already-working object untouched. A different
+artifact can become active only by replacing the whole `window.pbjs` object.
+
+Otherwise the wrapper initializes its embedded pure Prebid modules. It then attempts
+to define one own non-enumerable, non-writable, non-configurable data property whose
+value is the recursively frozen `ExternalPrebidArtifactV1` only when the descriptor
+is absent. Define failure is caught locally. An accessor, inherited-only value,
+invalid stamp, or hostile/different non-configurable value is left untouched and
+records at most one bounded console warning when possible. None of these paths
+throws, cancels the already-armed watchdog, or prevents publisher Prebid from
+initializing; they make only TS readiness incompatible.
+
+This inert build description is the artifact's only Trusted Server handshake. Apart
+from the independent Prebid queue self-start watchdog specified above, the generated
+wrapper performs no auction, admission, render, targeting, or refresh behavior. The
+Prebid adapter reads the property only through `Object.getOwnPropertyDescriptor`,
+rejects an accessor or inherited value, and captures both the `pbjs` object and stamp
+identities in one `PrebidArtifactBinding`. Every operation rechecks both identities;
+replacement of `window.pbjs` invalidates only that binding and later readiness may
+bind the new object if it carries a valid stamp. No `window.__tsjs_*` stamp or
+fallback lookup exists.
+
+The artifact build contains exactly one 64-zero-character release sentinel in that
+runtime stamp. It hashes the emitted JavaScript after normalizing that one field back
+to the sentinel, writes the resulting 64 lowercase hexadecimal SHA-256 characters
+into the field, and verifies that no sentinel remains. The separately emitted build
+manifest records that same `artifactReleaseId` plus the ordinary SHA-256/SRI of the
+final bytes. Thus the embedded id has a non-self-referential preimage; it is
+diagnostic artifact identity, not a requirement to match the TSJS `releaseId`.
+
+`prebidVersion` must be exactly `10.26.0`; changing it requires the reviewed
+artifact-contract fixture update in §3.5. Module/code/config names are nonempty,
+unique in their array, and at most 128
+UTF-8 bytes; EID sources are lowercase, nonempty, unique per module, and at most 256
+UTF-8 bytes. The manifest admits at most 256 module stems, 512 bidder codes, 512
+alias rows, and 128 user-ID modules with at most 64 config names and 64 EID sources
+each. Every alias code appears in `bidderCodes`, every alias module appears in
+`moduleStems`, and each configured `client_side_bidder` must appear in
+`bidderCodes`. Arrays are lexically sorted so build/runtime fixtures compare exact
+content.
+
+A missing stamp, wrong `abi`, invalid release/version, malformed/oversized member,
+missing configured bidder, missing required user-ID module/EID mapping, or a real API
+missing a required method makes the current readiness operation
+`external_artifact_incompatible`. It records one bounded local diagnostic and does
+not install TS refresh interception or mutate publisher state. An older unstamped
+artifact remains ordinary publisher Prebid: its own 5,000 ms watchdog drains its
+queue exactly once, and the later TS module does not replay publisher callbacks.
+Replacement by a valid artifact can satisfy later operations. Compatibility requires
+both `abi:1` and exact Prebid 10.26.0; external artifacts are not pinned to a TSJS
+release id.
+
+### 5.7 GPT correctness retained during decomposition
+
+- Subscribe to `slotRequested` and `slotRenderEnded` before any TS request.
+- Pass `changeCorrelator: false` for TS refreshes unless the explicit configuration
+  says otherwise.
+- Call `enableSingleRequest()` only before services are enabled; never reconfigure a
+  publisher-owned GPT service after `enableServices()`.
+- Restore the intended initial-load behavior represented by issue #922/PR #997 and
+  pin it with tests.
+- Responsive-size ambiguity fails `slot_unresolved` and never silently skips or
+  chooses an arbitrary container.
+- A TS fallback slot is defined on the resolved inner div, never its outer
+  `-container`. An exact later publisher `defineSlot` receives that same live slot
+  even when its path/formats differ, with a local mismatch warning, because defining
+  a second physical slot would violate the one-placement invariant. A
+  hydration-renamed alias is accepted only when the original element is gone and
+  exactly one live, unclaimed TS fallback shares the configured prefix, exact GAM
+  path, and normalized formats. Ambiguity remains native and cannot transfer TS
+  ownership.
+- Successful handoff synchronously transfers ownership, removes the slot from the
+  TS destroy set, suppresses exactly the publisher's duplicate initial `display`,
+  and under disabled initial load suppresses exactly its duplicate first refresh.
+  A global refresh expands the live GPT slot list, filters only one-shot suppressed
+  slots, and forwards unrelated slots with the original options.
+- Publisher calls are not held until TS targeting is ready. A publisher-owned
+  display/refresh remains publisher work, and its failures cannot start TS fallback.
+- The sole GPT adapter marks TS-originated `display`/`refresh`/`destroySlots` calls
+  with its closure-private reentrancy token and observes every other call as
+  publisher-originated without changing its receiver, arguments, order, return, or
+  throw. Its already-first `slotRequested` listener joins the exact physical object
+  to that request-intent evidence. Before returning from a publisher-owned,
+  competing, or ambiguous `slotRequested`, it invokes the §4.1 exact-once committed-
+  overlay retirement; an exactly attributable TS replacement leaves the prior
+  artifact visible until replacement commit. For publisher `destroySlots`, it
+  snapshots the exact requested live objects before forwarding and retires their
+  artifacts only after a successful return. Omitted-slot destruction snapshots all
+  then-live GPT objects. False/throw does not claim destruction, and DOM-integrity
+  retirement remains the backstop if GPT mutated the tree anyway.
+- Every TS-owned GPT destroy/redefine uses one adapter transaction. It first marks
+  the exact old object and cycle retired, then calls `destroySlots([old])` and
+  requires a successful return before attempting `defineSlot` for a replacement.
+  A throw/false destroy leaves the old identity retired and its path/aliases
+  quarantined, defines no second physical slot, and makes current or next TS work
+  fail `gpt_request_failed` until publisher destruction or reload. If destroy
+  succeeds but replacement definition fails, the slot stays unbound and the same
+  failure is returned; bindings and ownership commit only after one replacement is
+  successfully defined. A stale generation after either call disposes any newly
+  created TS-owned replacement and cannot bind it. Request-timeout, completion-
+  timeout recovery, navigation replacement, and DOM reconciliation all call this
+  transaction rather than open-coding destroy/redefine.
+- Runtime-owned DOM reconciliation detects when a framework replaces the element of
+  a TS-owned live slot. It debounces changes, retires/destroys only the orphaned
+  TS-owned GPT object, resolves the unique current element, and rebinds within the
+  current navigation. One `MutationObserver` per `NavigationSession` watches
+  `childList` changes under `document.documentElement`; it is disconnected on
+  navigation disposal. Once an exact owned element becomes disconnected, that slot
+  opens a 5,000 ms reconciliation window on the monotonic clock. The first resolution
+  pass runs after 250 ms without another relevant mutation; if it is unresolved or
+  ambiguous, exactly one final pass runs at the 5,000 ms boundary. A pass that finds
+  one unique current element may win the slot's terminal reconciliation latch only
+  after the destroy/redefine transaction commits its replacement. Destroy or define
+  failure settles current work as `gpt_request_failed`; it is not counted as a
+  successful rebind. The window expiry racing a successful final pass goes through
+  the same latch: success wins only if the unique replacement was committed first;
+  otherwise the slot records `slot_unresolved` and runs the failed-reconciliation
+  disposer. That disposer
+  cancels the slot's active TS request cycle, tombstones its live render reservation,
+  compare-restores only targeting still equal to TS-installed values, clears every
+  exact/alias binding to the orphan, and asks the GPT adapter to destroy that exact
+  still-TS-owned object. Before the destroy call it marks the object/cycle retired in
+  weak identity state, so a throw or later GPT callback is quarantined and cannot
+  re-enter selection, fallback, trace attribution, or targeting. It then releases
+  the timer, candidate set, and all strong references. Successful destruction
+  settles a nonterminal current attempt as `failed{reason:'slot_unresolved'}`;
+  throw/false destruction settles it as `failed{reason:'gpt_request_failed'}` and
+  adds one bounded local warning. Neither outcome restores ownership.
+
+  A second disconnect after one successful rebind may open one final window; two
+  successful rebinds is the per-slot, per-navigation maximum. A further disconnect
+  immediately runs that same disposer with
+  `failed{reason:'reconciliation_capacity'}` and cannot rebind again before the next
+  `NavigationSession`. Navigation disposal uses the same physical-object/targeting/
+  cycle cleanup without emitting a new failure. Reconciliation never destroys a
+  transferred or otherwise publisher-owned slot, and ownership transfer racing any
+  pass wins the latch, cancels TS reconciliation state, removes TS destroy ownership,
+  and leaves physical/targeting cleanup to the publisher.
+
+- Preserve the rc `gam_attribution_enabled` behavior as one typed GPT boot field and
+  one owner. It defaults to `false` independently of GPT enablement. When true, the
+  parser-time GPT owner enqueues exactly one idempotent
+  `googletag.setConfig({targeting:{ts:'true'}})` command before publisher GPT commands
+  can issue a request; it does so even when `tsjs.adInit` already exists. If no
+  server-projected batch selects the lean agent, the one parser-blocking persistent
+  runtime performs that same obligation before publisher activity. The command
+  applies to initial, lazy, publisher-owned, refreshed, and SPA-route requests in the
+  document-local PubAds service. The slot-level `ts_initial` key keeps its existing
+  lifecycle, and neither Prebid refresh nor SPA cleanup clears page-level `ts`.
+  Targeting API absence or throw is isolated and cannot stop later queue work.
+  Hard cutover deletes the old raw-bootstrap global flag, bundle activation
+  attribute, and duplicate fallback enqueue; there is no dual marker path. Tests
+  prove enabled-before-publisher order, disabled zero side effects, pre-existing
+  `adInit`, takeover idempotence, refresh/SPA persistence, publisher-owned slots, and
+  error isolation. Existing GAM reporting semantics and documentation remain; this
+  design adds no router, key/value variant, beacon, telemetry schema, or analysis.
+- The Prebid refresh policy preserves the exact `excluded_gam_ad_unit_path_suffixes`
+  behavior: path matching is literal/case-sensitive suffix matching; missing,
+  non-string, or throwing `getAdUnitPath()` fails open; stale TS/Prebid keys are
+  cleared from every target; only eligible slots enter the synthetic auction; and
+  the complete target slot list plus original options still reaches GPT.
+- Use one adapter-level refresh interception and one slot-service request path;
+  remove the three independent integration wrappers without removing handoff or
+  exclusion semantics.
+- Preserve the rc-baseline collapsed-shell resize as a guarded exception tied to the
+  current attempt. It runs only after a TS PUC response is posted and only when the
+  source is the exact connected iframe, width/height attributes and computed size
+  are still at most one pixel, dimensions are finite/positive, the frame/wrapper are
+  ordinary non-fixed/non-sticky display shells, and no anchor container is present.
+  Only that iframe and its still-collapsed immediate wrapper may be resized.
+
+### 5.8 Local diagnostics
+
+The kernel owns one bounded, failure-isolated diagnostics ingress. Render attempts
+and the GPT adapter call its closure-bound `publish(candidate: unknown): boolean`
+only after their correctness transition. An active ingress accepts only a data tree
+whose root is an ordinary or null-prototype record and whose descendants are null,
+booleans, finite numbers, strings, dense arrays, or ordinary/null-prototype records.
+Records must contain only own enumerable string data properties. Arrays must contain
+only their exact own `length` plus dense own data elements `0..length-1`; extra
+properties are invalid. Symbols, accessors, functions, `undefined`, bigint,
+non-finite numbers, sparse arrays, custom prototypes, cycles, repeated object
+references, and any proxy/trap failure are invalid. Runtime-local GPT slot identity
+therefore crosses this boundary as a bounded string token, never as retained object
+identity.
+
+The executable ingress limits are:
+
+```ts
+const MAX_DIAGNOSTICS_OBSERVATION_DEPTH = 16
+const MAX_DIAGNOSTICS_OBSERVATION_NODES = 512
+const MAX_DIAGNOSTICS_PROPERTY_NAME_BYTES = 128
+const MAX_DIAGNOSTICS_STRING_BYTES = 4096
+```
+
+The root has depth zero. Every encountered root, property value, or array element,
+including a primitive, consumes one node, so a flat record with 511 scalar values is
+the widest accepted record and one with 512 is rejected. Property-name and string
+limits count UTF-8 bytes independently. At or below every limit, ingress builds a
+fresh tree from own data descriptors, uses null-prototype objects for copied records,
+deep-freezes the copy, and retains no producer-owned array or record. A limit,
+descriptor, copy, encoding, or freeze failure returns `false` without invoking the
+reducer and never throws into the source operation.
+
+After a successful snapshot, ingress invokes the closure-private core trace reducer
+exactly once, synchronously. Reducer or local error-reporter failure is caught and
+cannot alter the source transition; because transport acceptance already succeeded,
+`publish` returns `true`. The ingress has no integration-module or publisher
+subscription API, listener identity, pending-delivery queue, scheduler/timer,
+overflow callback, or subscription-capacity constant. Its exact returned facade is
+frozen and contains only `publish` and `dispose`. `dispose` is idempotent, clears
+retained owner callbacks, and makes the bound `publish` return `false`; a retained
+facade from a disposed/replaced runtime epoch is likewise inert. Navigation-scoped
+producers must pass their owner-generation check before publication, and the reducer
+also ignores a semantically stale fact without treating diagnostics as authority.
+
+The core-ingress representation of one physical GPT slot is the exact branded data
+token `GptSlotTokenV1`. The sole GPT adapter owns its mint and no publisher input can
+select it:
+
+```ts
+type GptSlotTokenV1 = string & { readonly __brand: 'GptSlotTokenV1' }
+type GptTraceCycleOrdinalV1 = number & {
+  readonly __brand: 'GptTraceCycleOrdinalV1'
+}
+const MAX_GPT_SLOT_TOKEN_ORDINAL = 4_294_967_295
+const MAX_GPT_SLOT_TOKEN_BYTES = 11
+const MAX_GPT_TRACE_CYCLE_ORDINAL = 4_294_967_295
+const MAX_GPT_TRACE_CYCLES_PER_SLOT = 10
+// Exact wire grammar: /^gt1_(?:[1-9a-z][0-9a-z]{0,6})$/ plus decoded value <= 0xffffffff.
+```
+
+The adapter starts a runtime-local unsigned ordinal at one and emits `gt1_` plus its
+lower-case canonical base-36 form, with no leading zero. It increments only after a
+successful mint, stores the string beside the adapter's private opaque identity in
+the `WeakMap` entry for that exact GPT slot object, and copies it into any runtime
+`SlotRecord` that adopts that object as its exact optional own-data field
+`readonly traceToken?: GptSlotTokenV1`. Re-observing or handing off the same physical
+object returns the same string. A newly defined/replacement object receives a new
+ordinal even when it has the same element id, ad-unit path, registered slot id, or
+publisher owner. Ordinals are never reused within one runtime; physical destruction,
+retirement, navigation disposal, map pruning, and garbage collection do not rewind
+the counter. Runtime disposal clears the weak/map state and makes every old publisher
+inert before a later runtime may begin again at one.
+
+The adapter's `gpt.events.v1` facts retain their separate frozen opaque object token
+because that direct bounded stream never crosses the generic ingress and takeover
+GPT diagnostics needs same-object identity. Before publishing a GPT fact to
+`trace.v1`, the GPT integration creates a data-only projection that replaces the
+opaque token with the exact own-data field
+`slot:{token:GptSlotTokenV1,cycleOrdinal:GptTraceCycleOrdinalV1,elementId?:string}`;
+no object-valued identity enters the snapshot. Neither identity is public or render
+authority.
+
+The adapter owns a separate unsigned trace-cycle ordinal in each physical object's
+`WeakMap` state. The first unambiguous `slotRequested` for that object mints one and
+each later unambiguous physical request cycle increments it. It starts at one,
+increments only after the sole lifecycle adapter has opened that exact cycle, never
+wraps or reuses a value for the object, and survives publisher handoff. Every
+projected value must be an integer from 1 through 4,294,967,295; the reducer rejects
+zero, fractions, non-finite values, and larger values. A duplicate or overlapping
+`slotRequested` that the §2.4 lifecycle owner cannot attribute opens no trace cycle
+and emits no trace projection. Exhaustion at 4,294,967,296 latches new trace-cycle
+projection unavailable for only that physical object; its GPT lifecycle and
+`gpt.events.v1` stream continue unchanged.
+
+The adapter retains at most ten trace-cycle records per physical object, keyed by
+the ordinal, with request state, optional `responseIdentifier`, and per-event seen
+state. At most one cycle is open. Before opening another, it prunes the oldest
+completed/retired record only when the ten-record cap is full; it never evicts an
+open record. Pruning sets a permanent `unknownPriorCycle` latch for that physical
+object; the latch retains no old id but participates in future ambiguity checks and
+is cleared only when that object/runtime is disposed.
+
+A non-request GPT fact receives a cycle ordinal only from the §2.4 lifecycle owner's
+exact already-attributed cycle handle, or when response identity and retained
+per-event state leave exactly one eligible record and `unknownPriorCycle` cannot be
+the source. It is never assigned to the newest cycle by timing, element id, or slot
+token alone. A late `slotResponseReceived`, `slotRenderEnded`, `slotOnload`,
+`impressionViewable`, or `slotVisibilityChanged` that could belong to both a prior
+cycle and a newer started/completed cycle is ambiguous and produces no core-ingress
+projection. A uniquely matched old fact keeps the old ordinal even after a newer
+cycle starts. Eviction makes an otherwise unmatched later fact a diagnostics-only
+drop rather than a candidate for the current cycle; no callback can recreate an
+evicted ordinal. Destroy, redefine, and navigation disposal retire all retained
+cycles for the affected physical object, while runtime disposal clears the weak
+state.
+
+If the slot-token ordinal is exhausted, token/cycle construction or validation
+fails, or an injected test mint collides, the adapter emits no affected core-ingress
+projection and continues the GPT operation plus `gpt.events.v1` delivery unchanged.
+Already minted slot tokens and unambiguous cycles on other objects remain usable.
+The failure is reported at most once per failure class through the local logger and
+cannot fail a display, handoff, destroy, refresh, or diagnostics callback.
+
+On the first accepted `slotRequested` projection, the core trace reducer resolves
+the projection's bounded element id to exactly one current registered slot and keys
+its 256-entry diagnostics-only physical-impression map by the exact pair
+`{token,cycleOrdinal}`. The binding is
+`{slotId,navigationGeneration,baselineSeq?,historySeq?,state}` where `state` is
+`open`, `completed`, or `retired`. An unresolved, ambiguous, duplicate-active,
+stale-generation, or over-capacity binding is dropped without evicting an open entry.
+Later facts join only by the exact pair; token alone, element id, ad-unit path, and
+registered slot id are never substitutes. `slotRenderEnded` stores the exact created
+or enriched `historySeq` and completes the binding. Handoff of the same physical
+object keeps its token but each refresh receives a distinct cycle binding;
+redefine/replacement changes both the physical token and its per-object cycle
+sequence. Destroy or navigation disposal retires affected bindings. A late fact for
+a uniquely retained retired pair may enrich only its already-recorded, still-retained
+old `historySeq`; it cannot create a row, rebind to a new cycle/generation, or mutate
+new `current` state. Completed/retired bindings are pruned oldest-first before
+admitting a new binding, open bindings are never evicted, and runtime disposal clears
+the map. Exhaustion, collision, stability, handoff, repeated refresh, replacement,
+retirement, late-event, and navigation behavior remain diagnostics-only and never
+participate in GPT lifecycle authority.
+
+The takeover `gpt_diagnostics` module does not subscribe to that ingress. It consumes
+only the separately bounded GPT-owned `gpt.events.v1` fact stream. The broker values
+for `trace.v1` and `trace.presentation.v1` are different frozen exact interfaces:
+`trace.v1` contains correctness fact operations and ingress publication but no
+presentation attachment, while `trace.presentation.v1` contains only
+`attachPresentation`. The release catalog grants the latter only to deferred
+`diagnostics_presentation`; APS, GPT, `gpt_later`, publishers, and the public API
+cannot obtain it.
+
+The private capability has this complete interface; no other own key is permitted:
+
+```ts
+interface RenderTracePresentationSourceV1 {
+  current(): Readonly<Record<string, Readonly<RenderTraceRecord>>>
+  history(): readonly Readonly<RenderTraceRecord>[]
+  subscribe(listener: () => void): () => void
+}
+
+interface RenderTracePresentationControlsV1 {
+  dispose(): void
+}
+
+type RenderTracePresentationFactoryV1 = (
+  source: Readonly<RenderTracePresentationSourceV1>
+) => Readonly<RenderTracePresentationControlsV1>
+
+interface TracePresentationCapabilityV1 {
+  attachPresentation(factory: RenderTracePresentationFactoryV1): () => void
+}
+```
+
+`attachPresentation(factory)` is synchronous and admits at most one live attachment.
+A non-callable factory, a reentrant/duplicate call, or a call after trace-owner
+disposal throws `TypeError` without disturbing an existing attachment. Callability
+is checked before attachment state, so a non-callable duplicate still leaves the
+first attachment untouched. The callable receives one exact frozen source with only
+`current`, `history`, and `subscribe`. While attached, `current()` and `history()`
+return the same frozen copies as the public trace API. After detach/owner disposal,
+retained source methods are inert: `current()` returns a frozen null-prototype empty
+record, `history()` returns a frozen empty array, and no runtime state is retained.
+
+`source.subscribe` checks listener callability first and throws `TypeError` for a
+non-callable listener. It then requires the attachment to be attaching or live and
+requires that no private listener is already live; either failure throws `TypeError`
+without replacing or unsubscribing the first listener. Success returns an idempotent
+zero-argument unsubscribe function that removes only that exact listener. A later
+subscribe may succeed after it unsubscribes while the attachment remains live; a
+retained subscribe call after detach/owner disposal throws `TypeError`, and a retained
+unsubscribe is a no-op. The factory must end its synchronous call with one live
+listener, perform its initial snapshot render in the attaching task, and return an
+exact frozen own-data `{dispose}` controls object. No presentation callback runs
+during attachment, so that initial snapshot precedes all live delivery.
+
+If the factory throws, returns malformed controls, or returns without a live
+listener, attachment rolls back the candidate listener and scheduled work, invokes
+an own callable candidate `dispose` once when safely available, reports any cleanup
+failure locally, and rethrows so only the deferred module transaction fails. The
+attachment slot is then reusable. Once attached, every trace commit updates the
+data store first and coalesces presentation notification into at most one owned
+zero-delay task. The callback's return value is ignored; a throw is isolated and
+reported, and the next commit can schedule again. The returned detach function is
+idempotent: it invalidates the attachment generation, cancels pending work, clears
+the private listener, and invokes controls `dispose` exactly once. Trace-owner
+disposal performs the same sequence. Late scheduler callbacks and retained source,
+unsubscribe, detach, or controls references are inert. This private attachment is
+not counted against the 32 live subscribers per public diagnostics surface.
+
+`tsjs.diagnostics.renderTrace` replaces the mutable `tsjs.renders`, `renderLog`, and
+`renderSeq` globals and the `tsjs:adRendered` CustomEvent with read-only snapshot and
+subscription methods. The final schema is:
+
+```ts
+type RenderTracePathV1 = 'auction' | 'ssat' | 'gam-refresh'
+type RenderTraceServedFromV1 =
+  | 'inline'
+  | 'gam'
+  | 'debug-adm'
+  | 'pbs-cache'
+  | 'prebid'
+
+interface RenderTraceRecord {
+  readonly slotId: string
+  readonly path: RenderTracePathV1
+  readonly rendered: boolean
+  readonly elementId?: string
+  readonly auctionId?: string
+  readonly bidder?: string
+  readonly adId?: string
+  readonly bidId?: string
+  readonly creativeId?: string
+  readonly admHash?: string
+  readonly servedFrom?: RenderTraceServedFromV1
+  readonly gamEmpty?: boolean
+  readonly injected?: boolean
+  readonly visible?: boolean
+  readonly count: number
+  readonly seq: number
+  readonly at: number
+}
+
+interface RenderTraceDiagnostics {
+  current(): Readonly<Record<string, Readonly<RenderTraceRecord>>>
+  history(): readonly Readonly<RenderTraceRecord>[]
+  subscribe(listener: (record: Readonly<RenderTraceRecord>) => void): () => void
+}
+
+interface TsjsDiagnostics {
+  readonly renderTrace: RenderTraceDiagnostics
+  readonly gpt?: GptDiagnosticsApi
+}
+
+class DiagnosticsSubscriberLimitError extends Error {
+  readonly code: 'subscriber_capacity'
+  readonly surface: 'renderTrace' | 'gpt'
+}
+```
+
+Snapshots are frozen copies, not references to the runtime store. Subscription is
+FIFO; unsubscribe is idempotent; a listener registered during dispatch begins with
+the next observation. `count` is the positive per-slot impression ordinal, `seq` is
+the positive runtime-global observation ordinal, and `at` is the initial record's
+`Date.now()` epoch milliseconds; enrichment retains all three. The initial record and
+every later enrichment commit to `current`/`history` first and return to the
+correctness/publisher stack without invoking public code. After commit, the
+diagnostics service snapshots the current subscriber ids and enqueues one frozen
+full-record copy in a 200-entry FIFO keyed by `seq`; another enrichment pending for
+that `seq` replaces both its queued snapshot and captured subscriber-id set without
+changing order. A listener added after the initial commit may therefore receive a
+later enrichment commit, but never the earlier snapshot. Overflow drops the oldest
+pending notification and increments a diagnostics-only counter. One owned
+zero-delay task drains the queue in observation order. A listener registered after a
+commit cannot receive that committed observation; unsubscribe before delivery
+suppresses its captured id; registration during delivery starts with the next
+observation. A slow/non-returning listener can block only that later diagnostics task,
+never the render/GPT transition that scheduled it, and a throw is isolated from later
+listeners. This asynchronous frozen delivery is the timing/detail replacement
+contract for the removed `tsjs:adRendered` event; no CustomEvent or compatibility
+alias is emitted.
+
+Each public diagnostics surface admits at most 32 live subscribers. A 33rd
+subscription throws `DiagnosticsSubscriberLimitError{code:'subscriber_capacity'}`
+without adding the listener; unsubscribe immediately returns capacity. The
+argument must be callable or `subscribe` throws `TypeError` before the capacity
+check. The production core commits and freezes one stable `tsjs.diagnostics` facade
+with the kernel. Correctness facts required from the first display, bounded snapshot
+state, subscriptions, and the final public diagnostics APIs are produced by the
+takeover lifecycle/GPT path after adopting initial facts from the handoff. DOM
+presentation, badges, overlay, formatting, and
+clipboard/download interaction may attach behind that facade after its deferred
+module commits. Deferred diagnostics failure leaves the facade safe and bounded and
+cannot affect rendering. Fallback exposes no diagnostics namespace because it
+constructs no runtime.
+
+- sequence numbers are runtime-global across separately built IIFEs;
+- current state is keyed by exact registered slot id and therefore capped by the
+  256-record navigation registry. Slot/navigation disposal synchronously prunes its
+  current entry; history is document-runtime scoped, capped at 200, and evicts the
+  oldest row before append;
+- one physical impression is one history row; a later bridge/GPT/visibility signal
+  enriches that row in place and cannot weaken prior `rendered` or `injected` truth;
+- a publisher/GAM refresh with no current TS auction has no TS attribution;
+- `gam-only` means GAM reported fill without proof TS placed the creative, while
+  `ok` requires TS placement plus visibility;
+- DOM `data-ts-*` stamps remove absent/stale fields on every update; an old badge is
+  removed before the new status is considered; and
+- the boot-armed local overlay remains bounded, newest-first, click-to-export,
+  and noninteractive with the creative. Overlay/export failure cannot affect ads.
+
+Diagnostics enablement is resolved before core preparation and transported only
+through frozen boot data:
+
+```ts
+interface DiagnosticsBootV1 {
+  readonly version: 1
+  readonly renderTraceOverlay: boolean
+  readonly gpt: { readonly active: boolean }
+}
+```
+
+The server always emits this complete value, defaulting to
+`{version:1,renderTraceOverlay:false,gpt:{active:false}}`. Both objects must be
+non-null plain objects with exactly the shown own enumerable data properties;
+accessors, unknown/missing keys, or wrong prototypes/literals/types are
+`abi_mismatch`, not silent diagnostics disablement. The bootstrap copies the validated
+data and recursively freezes that copy before agent/takeover preparation; copy/freeze
+failure is also `abi_mismatch`. `gpt.active:true` requires exactly one catalogued
+takeover GPT-diagnostics collector/public API in `BootManifestV1`; `false` requires
+that collector to be absent. Exactly one catalogued deferred diagnostics-presentation
+module is required iff `renderTraceOverlay || gpt.active`; it replays bounded facts
+into the enabled overlay/badge/export-interaction model. The inverse mismatch is also
+`abi_mismatch` before any GPT diagnostics listener, buffer, or presentation module
+exists.
+
+The existing render-trace server toggle resolves
+`tsjs.boot.diagnostics.renderTraceOverlay`; TSJS does not read or mutate its cookie.
+GPT diagnostics remains deployment-disabled by default. When configured, one exact
+`ts_console=1|true` directive on an eligible GET document navigation enables the
+host session and `ts_console=0|false` disables it; values are case-sensitive and
+duplicate/unrecognized directives fail closed for that response. The server owns the
+host-only HttpOnly session cookie, removes the reserved directive before publisher or
+origin handling, preserves unrelated path/query/fragment data, and emits only the
+resolved `gpt.active` boolean. The old
+`window.__tsjs_gpt_diagnostics_active` flag and browser storage bootstrap are deleted.
+
+The GPT diagnostics integration consumes raw facts from the sole GPT adapter rather
+than registering another control wrapper. This document is the complete normative
+contract; the earlier GPT-diagnostics design is historical rationale only.
+
+```ts
+type GptDiagnosticsCallbackKind =
+  | 'slotRequested'
+  | 'slotResponseReceived'
+  | 'slotRenderEnded'
+  | 'slotOnload'
+  | 'impressionViewable'
+  | 'slotVisibilityChanged'
+
+type GptDiagnosticsCallbackDisposition = 'matched' | 'unmatched' | 'ambiguous'
+type GptDiagnosticsSize = readonly [number, number]
+
+type GptDiagnosticsBindingReason =
+  | 'missing_slot_element_id'
+  | 'missing_element'
+  | 'duplicate_dom_id'
+  | 'dom_uniqueness_unverifiable'
+  | 'duplicate_gpt_slot_id'
+
+interface GptDiagnosticsBinding {
+  readonly status: 'bound' | 'unbound' | 'ambiguous'
+  readonly reason?: GptDiagnosticsBindingReason
+}
+
+interface GptDiagnosticsDurations {
+  readonly requestToResponseMs?: number
+  readonly responseToRenderMs?: number
+  readonly requestToRenderMs?: number
+  readonly renderToLoadMs?: number
+  readonly renderToViewableMs?: number
+}
+
+interface GptDiagnosticsAdManagerIdentity {
+  readonly lineItemId?: number
+  readonly creativeId?: number
+  readonly campaignId?: number
+  readonly advertiserId?: number
+  readonly sourceAgnosticLineItemId?: number
+  readonly sourceAgnosticCreativeId?: number
+  readonly yieldGroupIds?: readonly number[]
+  readonly companyIds?: readonly number[]
+}
+
+type GptDiagnosticsResponseClass =
+  | 'empty'
+  | 'backfill'
+  | 'reservation'
+  | 'unclassified_non_empty'
+
+type GptDiagnosticsRequestPath =
+  | 'trusted_server_direct'
+  | 'prebid_refresh'
+  | 'publisher_refresh'
+  | 'competing'
+  | 'unattributed'
+
+type GptDiagnosticsTrustedServerOpportunity =
+  | 'renderable_candidate'
+  | 'unrenderable_candidate'
+  | 'no_candidate'
+
+type GptDiagnosticsCreativeFailure =
+  | 'missing_render_source'
+  | 'cache_fetch_failed'
+  | 'invalid_cache_payload'
+  | 'response_post_failed'
+
+type GptDiagnosticsDelivery =
+  | 'trusted_server_response_sent'
+  | 'trusted_server_selected'
+  | 'candidate_unconfirmed'
+  | 'no_candidate'
+  | 'unknown'
+  | 'pending'
+  | 'not_applicable'
+
+interface GptDiagnosticsRequestCycle {
+  readonly requestNumber: number
+  readonly requestedAtMs?: number
+  readonly responseAtMs?: number
+  readonly renderAtMs?: number
+  readonly loadAtMs?: number
+  readonly viewableAtMs?: number
+  readonly durations: Readonly<GptDiagnosticsDurations>
+  readonly requestedSlotSizes?: readonly GptDiagnosticsSize[]
+  readonly size?: GptDiagnosticsSize
+  readonly observedSlotSize?: GptDiagnosticsSize
+  readonly isEmpty?: boolean
+  readonly isBackfill?: boolean
+  readonly slotContentChanged?: boolean
+  readonly incompleteSequence: boolean
+  readonly adManager?: Readonly<GptDiagnosticsAdManagerIdentity>
+  readonly responseClass?: GptDiagnosticsResponseClass
+  readonly requestPath?: GptDiagnosticsRequestPath
+  readonly requestIntentId?: number
+  readonly trustedServerAuctionId?: string
+  readonly opportunityToRequestMs?: number
+  readonly replacedRequestNumber?: number
+  readonly previousRenderToRequestMs?: number
+  readonly creativeChanged?: boolean
+  readonly previousCreativeId?: number
+  readonly loadObservedBeforeRender?: boolean
+  readonly trustedServerOpportunity?: GptDiagnosticsTrustedServerOpportunity
+  readonly trustedServerCreativeRequestAtMs?: number
+  readonly trustedServerCreativeResponseAtMs?: number
+  readonly trustedServerCreativeFailures?: readonly GptDiagnosticsCreativeFailure[]
+  readonly delivery?: GptDiagnosticsDelivery
+}
+
+interface GptDiagnosticsSlotExport {
+  readonly runtimeSlotNumber: number
+  readonly slotElementId?: string
+  readonly adUnitPath?: string
+  readonly binding: Readonly<GptDiagnosticsBinding>
+  readonly currentVisibilityPercentage?: number
+  readonly maximumVisibilityPercentage?: number
+  readonly requests: readonly Readonly<GptDiagnosticsRequestCycle>[]
+}
+
+interface GptDiagnosticsCallbackIssue {
+  readonly kind: GptDiagnosticsCallbackKind
+  readonly runtimeSlotNumber: number
+  readonly slotElementId?: string
+  readonly timestampMs: number
+  readonly disposition: GptDiagnosticsCallbackDisposition
+  readonly reason: GptDiagnosticIssueReasonV1
+}
+
+type GptDiagnosticsAttributionIssueReason =
+  | 'creative_request_without_slot'
+  | 'creative_request_without_cycle'
+  | 'creative_request_ambiguous_cycle'
+  | 'creative_request_on_empty_cycle'
+  | 'creative_attempt_capacity'
+  | 'creative_attempt_unknown'
+  | 'creative_attempt_expired'
+  | 'creative_attempt_evicted'
+
+interface GptDiagnosticsAttributionIssue {
+  readonly reason: GptDiagnosticsAttributionIssueReason
+  readonly timestampMs: number
+  readonly runtimeSlotNumber?: number
+  readonly slotElementId?: string
+}
+
+interface GptDiagnosticsCoverageCounters {
+  readonly observed: number
+  readonly matched: number
+  readonly unmatched: number
+  readonly ambiguous: number
+}
+
+interface GptDiagnosticsExportV1 {
+  readonly version: 1
+  readonly capturedAt: string
+  readonly page: Readonly<{ origin: string; pathname: string }>
+  readonly slots: readonly Readonly<GptDiagnosticsSlotExport>[]
+  readonly callbackIssues: readonly Readonly<GptDiagnosticsCallbackIssue>[]
+  readonly attributionIssues: readonly Readonly<GptDiagnosticsAttributionIssue>[]
+  readonly coverage: Readonly<
+    Record<GptDiagnosticsCallbackKind, Readonly<GptDiagnosticsCoverageCounters>>
+  >
+  readonly metadata: Readonly<{
+    droppedCallbacks: number
+    droppedAttributionIssues: number
+    evictedSlots: number
+    evictedRequestCycles: number
+  }>
+}
+
+interface GptDiagnosticsApi {
+  snapshot(): Readonly<GptDiagnosticsExportV1>
+  export(): void
+  subscribe(
+    listener: (snapshot: Readonly<GptDiagnosticsExportV1>) => void
+  ): () => void
+  show(): void
+  hide(): void
+}
+```
+
+All arrays, tuples, nested objects, and the root returned by `snapshot()` are fresh
+recursively frozen copies. `capturedAt` is a valid UTC ISO timestamp generated for
+that snapshot; `page` contains only the current origin and pathname, never query,
+fragment, referrer, cookies, targeting, bid payload, or creative markup. Optional
+fields mean the fact was unavailable or inapplicable, never that a false/zero value
+was elided. Public counters are nonnegative safe integers and saturate rather than
+wrap; timestamps/durations/percentages and exported numeric identifiers are finite
+and preserve zero. The store normalizes and bounds strings/arrays before retention,
+and every snapshot reuses only copied primitive data.
+
+The frozen `tsjs.diagnostics.gpt` API exists iff `diagnostics.gpt.active` is true.
+Before the deferred presentation attaches, `show`, `hide`, and `export` are safe
+no-ops; they do not queue a later UI action. After attachment, `show`/`hide` control
+only the Shadow DOM overlay and `export()` downloads the current snapshot as local
+JSON using a short-lived object URL that is always revoked; none performs a network
+request or changes ad state. The internal evidence recorder is a closure-private
+`gpt.events.v1` consumer and is never a property of this API.
+
+The buffer does not retain GPT event objects or arbitrary publisher data. Before
+admission, the current owner normalizes each observation to one exact ordinary-data
+`FirstDisplayGptFactV1` record:
+
+```ts
+type GptDiagnosticEventV1 =
+  | 'slotRequested'
+  | 'slotResponseReceived'
+  | 'slotRenderEnded'
+  | 'slotOnload'
+  | 'impressionViewable'
+  | 'slotVisibilityChanged'
+
+type GptDiagnosticDispositionV1 = 'matched' | 'unmatched' | 'ambiguous'
+
+type GptDiagnosticIssueReasonV1 =
+  | 'no_request_cycle'
+  | 'overlapping_request_cycles'
+  | 'unknown_prior_cycle'
+  | 'invalid_event_order'
+
+interface FirstDisplayGptFactV1 {
+  readonly version: 1
+  readonly event: GptDiagnosticEventV1
+  readonly token: GptSlotTokenV1
+  readonly runtimeSlotNumber: number
+  readonly cycleOrdinal: GptTraceCycleOrdinalV1 | null
+  readonly disposition: GptDiagnosticDispositionV1
+  readonly issueReason: GptDiagnosticIssueReasonV1 | null
+  readonly capturedAtMs: number
+  readonly elementId: string | null
+  readonly adUnitPath: string | null
+  readonly requestedSlotSizes: readonly (readonly [number, number])[] | null
+  readonly isEmpty: boolean | null
+  readonly renderedSize: readonly [number, number] | null
+  readonly isBackfill: boolean | null
+  readonly slotContentChanged: boolean | null
+  readonly visibilityPercent: number | null
+}
+
+const MAX_FIRST_DISPLAY_GPT_FACTS = 512
+const MAX_FIRST_DISPLAY_GPT_FACT_BYTES = 1000
+const MAX_FIRST_DISPLAY_GPT_FACT_SECTION_BYTES = 524_288
+const MAX_FIRST_DISPLAY_GPT_FACT_COUNTER = 4_294_967_295
+```
+
+All shown keys are required and no other own key is permitted. The GPT adapter mints
+`runtimeSlotNumber` once per exact physical slot from the global unsigned 32-bit
+trace-slot ordinal already transferred in `FirstDisplayHandoffV1`; it is nonzero,
+never reused, and remains paired with that physical token through takeover.
+`capturedAtMs` is a finite nonnegative `performance.now()` value; `elementId` and
+`adUnitPath` are null or the adapter's copied own 1–256-UTF-8-byte values with no
+NUL/control characters. GPT getter throws, nonstrings, empty values, and oversized
+values normalize to null. `requestedSlotSizes` is non-null only for the matched
+`slotRequested` fact carrying Trusted Server request-intent evidence, uses the
+16-entry copied/frozen 1–4096 contract below, and is null for publisher/native or
+event-inapplicable facts. Rendered dimensions are null or integral 1–4096 values;
+visibility is null or finite 0–100. Event-inapplicable fields are null. A matched
+request fact has its newly minted cycle ordinal; later cycle-bound facts use the exact
+uniquely attributed ordinal. A matched
+`slotVisibilityChanged` fact may use `cycleOrdinal:null` because visibility is
+slot-level; any deliberately unmatched/ambiguous fact uses `cycleOrdinal:null`.
+`disposition` is exclusively the callback-coverage dimension. `issueReason` is null
+when the fact adds no issue; otherwise it is the exact independent sequence/matching
+reason, so a uniquely correlated invalid-order callback remains `matched` with
+`issueReason:'invalid_event_order'`. Unmatched and ambiguous facts use the applicable
+`no_request_cycle`, `overlapping_request_cycles`, or `unknown_prior_cycle` reason.
+The token and cycle retain the grammars/caps above.
+On replay, `requestedSlotSizes` becomes the public request cycle's field and
+`renderedSize` becomes its GPT-reported `size`; the names remain distinct at the
+handoff and public boundaries.
+The canonical UTF-8 encoding of the complete normalized record must be at most 1,000
+bytes. The handoff subsection is exactly
+`{facts:readonly FirstDisplayGptFactV1[],overflowCount:number,dropCount:number}`;
+both counters are unsigned 32-bit integers that saturate at their maximum. Its
+complete canonical UTF-8 encoding, including array/object punctuation, keys, and
+counters, must be at most 524,288 bytes. Invalid, oversized, accessor-backed, or
+unnormalizable observations are diagnostics-only drops and never enter the buffer or
+affect GPT/render authority. A valid observation that would exceed the 512-entry
+FIFO evicts the oldest fact and increments `overflowCount`; any normalization or
+section-byte-cap refusal increments `dropCount`. Counter saturation does not affect
+admission or takeover.
+
+When `gpt.active` is true, the current `ActiveRenderOwner` installs the six
+documented GPT observations (`slotRequested`, `slotResponseReceived`,
+`slotRenderEnded`, `slotOnload`, `impressionViewable`, and
+`slotVisibilityChanged`) before any TS-owned GPT request. It owns one 512-entry FIFO
+pre-collector fact buffer. Overflow evicts the oldest fact and increments one
+diagnostics-only counter. On a direct-to-runtime page, persistent core creates this
+buffer and replays it in order when the takeover diagnostics collector activates.
+On an agent page, the agent creates it before the protected batch, maps every fact to
+the canonical trace token/cycle owned by that epoch, and includes the final ordered
+normalized `FirstDisplayGptFactV1` records plus overflow/drop counts in
+`FirstDisplayHandoffV1`. That complete at-most-524,288-byte subsection occupies the
+separate 512 KiB diagnostics allowance of the handoff's 8.5 MiB total cap.
+Normalization and the FIFO enforce that bound before handoff; a fact that cannot fit is a counted
+diagnostics-only drop and cannot consume replay-suppression or correctness space.
+During the non-yielding takeover task, the agent disconnects its six listeners; the
+persistent GPT adapter adopts the exact physical slot identities from the capsule,
+reconstructs its private identity map from the transferred canonical tokens,
+runtime-slot numbers, ad-unit paths, cycles, and next ordinal, replays the bounded
+facts into the collector in original order, and installs one fresh six-listener set
+before the task ends. Replay updates the same slot/cycle facts, callback-coverage
+counters, and separately reasoned issue rows that continuous ownership would have
+produced; it cannot renumber a slot or reinterpret a disposition as an issue. A GPT
+callback can therefore run before or after, but never inside, the
+owner transition. It is processed once by one epoch and no diagnostic fact is
+duplicated. After replay, live facts fan out directly and the pre-collector buffer is
+released. The later presentation module consumes the already bounded collector/store;
+it never registers GPT listeners or recreates the raw-fact buffer.
+
+When inactive, neither epoch creates a diagnostics buffer or the four
+diagnostics-only listeners. The sole current GPT adapter may still own
+`slotRequested` and `slotRenderEnded` listeners required for ordinary ad correctness
+under §5.7; inactive zero-side-effect tests measure that baseline and require zero
+diagnostics-added listeners, DOM, timers, observers, API, or network work. At every
+task boundary, active and inactive pages alike have listener ownership in exactly one
+epoch.
+
+The GPT diagnostics store retains at most 64 observed GPT slot objects, ten request
+cycles per slot, and 128 callback-issue records. It evicts the
+least-recently-active slot or oldest cycle/issue before insert and increments the
+corresponding export counter. An evicted GPT slot can re-enter only on a future
+`slotRequested`; its monotonic request number is retained in a `WeakMap`, and earlier
+non-request callbacks remain unmatched. Its public API shares the 32-subscriber cap
+above. Exact slot identity/binding and element replacement, physical request cycles,
+callback truth, timing fields, frozen bounded export, Shadow DOM overlay, badge
+layers, SPA behavior, privacy, and non-interference remain. Diagnostic records are
+memory-only; neither diagnostics surface writes localStorage, sessionStorage,
+IndexedDB, or uploads data. The hard-cutover API is `tsjs.diagnostics.gpt`; the old
+flag/runtime expandos and `tsjs.gptDiagnostics` alias are deleted.
+
+Each exported `GptDiagnosticsRequestCycle` keeps three size concepts distinct:
+
+- `requestedSlotSizes?: readonly (readonly [number,number])[]` is the exact
+  Trusted Server placement-format evidence associated with that request intent,
+  capped at 16 entries. Each dimension is an integer in 1–4096. Admission copies and
+  freezes every tuple and the outer list; malformed entries are omitted and an empty
+  result is absent. Publisher/native requests do not inherit stale TS evidence.
+- `size?: readonly [number,number]` is GPT's reported filled creative size from the
+  exact matched `slotRenderEnded`. It retains the existing GPT normalization and is
+  never inferred from DOM geometry.
+- `observedSlotSize?: readonly [number,number]` is the finite, nonnegative CSS-pixel
+  width/height of the uniquely bound outer slot element measured after an explicitly
+  nonempty rendered cycle. Fractions and zero are valid observations; this is layout
+  evidence, not creative size or render acceptance.
+
+When GPT diagnostics is active, one dedicated slot-size observer subscribes to the
+bounded store and binding manager. It observes only connected, uniquely bound
+elements whose latest cycle is nonempty and has `renderAtMs`. Every scheduled
+measurement captures `{runtimeSlotNumber,requestNumber,element}` and revalidates the
+same exact binding, connected element, latest cycle, nonempty result, and render fact
+before committing. A refresh, rebind, ambiguity, disconnection, eviction, navigation,
+or disposal therefore makes a late measurement inert. `ResizeObserver` updates and
+an initial animation-frame measurement share this guard; absence of
+`ResizeObserver` leaves the initial measurement only. Disposal unsubscribes both
+sources, disconnects the observer, and makes scheduled callbacks inert.
+
+Snapshots, subscriptions, overlay, badges, and export use the exact field names and
+label the values independently as `Requested`, `GPT fill`, and `Outer box`; no UI or
+consumer may collapse them into one ambiguous “size.” Copy/freeze rules prevent a
+caller from mutating stored tuples. Focused tests cover all three present together,
+malformed/capped requested formats, refresh and rebind races, unavailable observers,
+fractional/zero boxes, unchanged-measurement deduplication, and teardown.
+
+GPT public subscriptions use a separate one-entry latest-snapshot notifier and never
+run from a GPT callback, adapter fan-out, store mutation, or binding observer. After
+each committed store/binding change, the controller builds one frozen
+`GptDiagnosticsExportV1`, snapshots current subscriber ids, and schedules one owned
+zero-delay task. A later change before delivery replaces that pending snapshot and
+subscriber-id set; this API signals current state rather than promising one callback
+per raw GPT fact. Registration after a commit cannot receive that commit unless a
+later change replaces the pending snapshot; unsubscribe before delivery suppresses
+the captured id. Listener throws are isolated, and a slow/non-returning listener can
+block only the diagnostics task. Module disposal cancels the task, clears the one
+pending snapshot and subscriber set, and delivers nothing later. `snapshot()` remains
+a synchronous frozen read with no subscriber invocation. Tests apply the same
+subscribe/unsubscribe/slow/throw rules as render trace plus 0/1/2-update coalescing.
+
+### 5.9 Creative and remaining integration preservation
+
+`CreativeBootV1` in §5.4 is exact plain boot data. The server always emits it. A
+disabled integration is exactly
+`{version:1,enabled:false,clickGuard:false,renderGuard:false}` and has no `creative`
+manifest member. When enabled but its config is absent, the server emits
+`{version:1,enabled:true,clickGuard:true,renderGuard:false}`; explicit configuration
+replaces the two guard booleans. The `creative_initial` slice and `phase:'takeover'`
+creative module are required iff `enabled && (clickGuard || renderGuard)`; an enabled
+configuration with both guards false has no browser module because it has no browser work. `enabled:false`
+also requires its absence. An accessor, non-plain
+prototype, missing/unknown key, wrong literal/version/type, disabled non-false guard,
+or manifest mismatch is an `abi_mismatch` before any creative guard installs. The recursively
+frozen `tsjs.boot.creative` is the only final inspection/configuration surface.
+`globalThis.tscreative`, `globalThis.tsCreativeConfig`, `installGuards`, `setConfig`,
+and `getConfig` are deleted, not aliased; changing guard policy requires a new boot/
+document generation.
+
+The initial slice installs the selected compare-restorable guard before publisher
+creative activity. It transfers only bounded configuration/seen-node facts; §5.2.1
+compare-restores the provisional wrapper/observer, installs one fresh persistent
+guard, and performs the bounded post-commit rescan. The creative takeover module
+prepares inertly and activates transactionally exactly once in the kernel barrier.
+Activation installs directly on a no-agent page and never stacks an agent guard. It enables the click guard when
+`clickGuard` is true and the image/iframe dynamic-source guards when `renderGuard` is
+true, but performs no rc-baseline DOM rewrite. Only when
+`clickGuard || renderGuard` is true, activation gives a still-loading document one
+owned `DOMContentLoaded` callback to perform the rc-baseline idempotent rescan after the
+initial DOM completes; an already interactive/complete document gets no listener and
+performs that scan from one staged `afterCommit` callback. Its
+disposer removes that listener, observers, and owned DOM state and compare-restores a
+patched constructor/property/function only if the current value is still the exact
+wrapper installed by this generation. An absent creative module installs no wrapper,
+observer, listener, scan, or DOM state when the integration is disabled or enabled
+with both guard booleans false. SPA navigation retains the document-scoped
+guards and their dynamic-node behavior; failed preparation/activation or full runtime
+disposal removes them once.
+
+Creative processing keeps its current independent policy controls. Auction
+sanitization remains explicit opt-in/default-off; rewriting retains its existing
+setting/default and still runs on every delivery path where that setting applies.
+When rewriting injects browser guards into an independent creative document, the
+server emits a complete document-local boot controller followed by exactly one
+content-addressed direct persistent artifact containing core, `render_runtime`, and
+`creative`—and no publisher-page integration, agent slice, or deferred module. The
+tag is the sole `script#trustedserver-js` and uses the same release identity as the
+page runtime. Since no projected batch exists in that document, there is no agent,
+attempt, or synthetic paint trigger. If creative is disabled or both guards are
+false, rewriting injects no TSJS boot or artifact. A body-less fragment receives the same pair once at its
+start; a document body receives it once at the start of the body. Boot construction
+failure rejects rewriting rather than emitting a script-only or unauthenticated
+creative.
+The runtime click guard resolves and stores one validated absolute HTTP(S) URL before
+navigation, rejects `javascript:`, `data:`, `blob:`, malformed, and credentialed
+targets, and uses the established `/first-party/proxy-rebuild` GET redirect path to
+recover clicks from the opaque sandbox. Dynamic resource/click rewriting, iframe
+sandbox attributes, font/CORS handling, body/base handling, and the direct/SSAT/cache
+delivery boundaries remain covered by unit plus real-browser tests. This APS/TSJS
+work neither enables sanitization nor broadens creative privileges.
+
+Every other enabled TSJS integration becomes a thin transactional integration module without an
+internal feature rewrite. Its complete current unit suite runs unchanged against a
+rc-baseline fixture and a module-composed fixture. At minimum the parity corpus
+proves:
+
+| Integration        | Required preserved behavior                                                                                                                                            |
+| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DataDome           | dynamic script/preload matching and fixed first-party route rewriting preserve the upstream path                                                                       |
+| Didomi             | configured proxy path becomes the absolute `didomiConfig.sdkPath` without clobbering unrelated publisher config                                                        |
+| Google Tag Manager | script/preload rewriting plus Google Analytics `sendBeacon`/`fetch` rewriting preserve method, body, and unrelated traffic                                             |
+| Lockr              | script guard plus bounded SDK readiness polling rewrites only the initialized Lockr API host                                                                           |
+| Osano              | USP/GPP/TCF cookie mirroring retains marker ownership, timeout, readiness, retry, event, focus/visibility, clear, and non-clobber semantics                            |
+| Permutive          | script guard, bounded SDK readiness, API-host rewriting, and at-most-100 normalized local segment values continue to feed auction context                              |
+| Sourcepoint        | optional SDK guard and Sourcepoint-owned GPP cookie mirroring retain localStorage shapes, marker ownership, initial retry, visibility/focus updates, and safe clearing |
+| Testlight          | preexisting and later callbacks bridge once into the final TSJS queue; invalid entries and one throwing callback do not block later work                               |
+
+The shared script/beacon/DOM-insertion guards keep integration-owned matchers and
+routes. A shared helper may centralize interception, but it cannot broaden one
+integration's matcher, reorder another integration's first-display/takeover startup, stack interception,
+or leave a timer/listener after module disposal. Maximal-bundle tests load every
+server-declared integration module through its real phase/trigger and deterministic
+catalog-order initiation. They allow independent deferred completion order and
+assert both behavior and exactly-once disposal, not merely successful registration.
+
+### 5.10 Error handling and bounded state
+
+No empty `catch` remains in the migrated kernel, adapters, or APS/GPT/Prebid paths.
+Boundary failures become typed results and a concise local warning; disposer and
+late-callback failures cannot escape into publisher code. Logs redact descriptors,
+AAX payloads, account ids, creative URLs, auction bodies, and capability values.
+
+Every collection has a named owner, capacity, and pruning rule. Tests exercise
+capacity, TTL, duplicate registration, replay, timeout, navigation replacement, and
+late continuation behavior with fake timers.
+
+### 5.11 Decomposition targets
+
+The implementation extracts cohesive behavior rather than mechanically splitting
+by line count:
+
+| Current area                         | Target responsibility                                                                                                                                                                            |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| production `composition/browser`     | deleted as a catch-all root; first-display composition owns only §5.2.1 slices, while persistent core constructs kernel/session/broker, API, diagnostics facade, and direct-auction coordination |
+| `first_display/**`                   | fixed agent coordinator plus exact initial APS/GPT/Prebid/creative/parser-time slices, handoff serializer/capsule, protected paint, and no public runtime API                                    |
+| test composition seams               | separate unshipped entry containing fake/no-op adapters, schedulers, corpus hooks, and `*ForTest` accessors                                                                                      |
+| `gpt/index.ts`                       | persistent GPT owner that can adopt exact initial slot/cycle identities; the separate `gpt_initial` slice owns only the immutable projected request and transfer facts                           |
+| `prebid/index.ts`                    | persistent Prebid owner that adopts initial artifact/queue/admission facts; the separate `prebid_initial` slice owns only initial readiness, bidder/user-ID/EID setup, and PUC admission         |
+| `prebid/later.ts`                    | deferred synthetic refresh and GAM-path exclusion only; it owns no initial admission, artifact-readiness, bidder, user-ID, EID, or publisher-queue behavior                                      |
+| `core/request.ts`                    | public validation, immutable selection, and thin `AuctionBatch` coordination; path implementations live behind injected capabilities                                                             |
+| `core/render.ts`                     | only minimum path-independent first-display DOM/lifecycle helpers; APS/ADM live with their owner, while cache stays the rc-baseline GPT-integration implementation                               |
+| `kernel/diagnostics.ts`              | bounded data-tree snapshot ingress and one closure-private reducer callback; no integration subscriptions, pending queue, scheduler, timer, or presentation authority                            |
+| `core/trace.ts`                      | bounded correctness-fact reducer/store, public snapshots/subscriptions, and separately attenuated `trace.presentation.v1`; no DOM presentation code                                              |
+| render-reservation maps in globals   | bounded initial capability owned by `render_owner_initial` and bounded persistent capability owned by the render service; APS contributes only descriptor/top-mount state                        |
+| diagnostics overlay/UI               | deferred owner of the sole private `trace.presentation.v1` attachment; never imported by production core or correctness producers                                                                |
+| duplicated `script_guard.ts`         | small per-integration factory compiled into the owning module; no central production root imports every matcher                                                                                  |
+| optional integration implementations | remain in their integration IIFEs and register inert factories; they are absent from core bytes                                                                                                  |
+
+The first-display and later slices of one product integration must retain the same
+observable ownership and disposal contract. Splitting files or artifacts cannot
+omit a correctness-required listener from its first-display slice, duplicate an adapter,
+or turn a bounded typed failure into a readiness hang. Conversely, code used only
+for refresh, later navigation, diagnostics presentation, test injection, or an
+optional integration cannot remain in the first-display dependency graph for convenience.
+
+Source may be shared at authoring time only through effect-free leaf contracts whose
+metafile contribution fits the agent budget. The first-display build must not import
+the persistent core, capability broker, generic slot/auction/trace registries, later
+GPT/Prebid module, or any deferred entry. It may use a dedicated compact parser and
+state machine generated from the same neutral schema/corpus; parity tests, rather
+than a production import from the persistent implementation, prevent drift. The
+persistent build likewise imports no agent coordinator or provisional singleton.
+
+### 5.12 TypeScript and performance gates
+
+Before the coordinated runtime implementation proceeds, the TSJS direct development
+toolchain is upgraded to the newest stable, mutually compatible versions supported
+by the repository-pinned Node major. TypeScript advances to the newest stable release
+inside the latest `typescript-eslint` parser's declared support range; an unsupported
+compiler/parser pairing is not accepted merely to claim a higher version. The
+external artifact dependency remains exactly `prebid.js@10.26.0`, and Node type
+declarations remain on the pinned Node major. Those are explicit compatibility and
+artifact-contract constraints, not permission to leave the rest of the toolchain
+stale. The upgrade must pass a clean `npm ci`, a peer-clean `npm ls --all`, complete
+build/lint/typecheck/tests, and exact Prebid artifact verification.
+
+After that upgrade, the lockfile compiler is the authority. CI runs a checked-in
+`typecheck` script with `strict`, `noUncheckedIndexedAccess`,
+`exactOptionalPropertyTypes`, `verbatimModuleSyntax`, `noImplicitOverride`, and
+`useUnknownInCatchVariables`. Production bundles contain no dynamic `import()`;
+the deferred loader uses only authenticated classic same-origin script elements as
+specified in §5.2.
+
+The historical first complete paired run on candidate
+`a0d8c0631a9774b5c8da8b25794a8836aa2e62f5` against exact rc base
+`d4cd2cc823718d64ae73bcb068e5eab03ecd901a` proved that correctness, load ordering,
+heap, GPT first-action timing, and every APS absolute action/completion/paint deadline
+passed, while semantic pre-action transfer still failed. The candidate GPT interval
+was 92,931 raw / 28,802 gzip / 25,779 Brotli bytes against 70,943 / 21,571 / 18,804;
+the APS interval was 128,769 / 39,645 / 34,758 against the allowed rc × 1.10 values
+78,659.9 / 24,098.8 / 21,006.7. APS first-action p90 was 616.3 ms against an allowed
+562.0 ms, while its 900 ms absolute action ceiling and every downstream deadline
+passed. This predecessor-run record is immutable diagnostic evidence, not the current
+baseline and not authority to change a comparator, membership rule, fixture, or
+threshold. Final release evidence uses the 2026-08-28 base recorded above.
+
+Revision 43 closes that demonstrated source-graph gap without changing network
+semantics:
+
+1. the inline bootstrap uses the compact server-sealed JSON transport above and its
+   production graph cannot reach the full object-form boot, auction-projection, or
+   generic integration-carrier validators;
+2. `render_owner_initial` owns one source-neutral PUC/render journal and lifecycle
+   primitive set for ADM and APS reservations, with no duplicate full bridge, while
+   APS-only descriptor, nonce, top-mount, and document behavior stays in
+   `aps_initial` and absent from non-APS masks;
+3. the checked-in PUC dynamic owner remains the exact self-contained v4 response
+   program but is compacted in place, with no external asset or reduced adversarial
+   behavior; and
+4. source-ownership tests, focused lifecycle suites, every admitted-mask budget,
+   selected-agent rc comparison, and the complete paired performance run must all
+   pass on one clean pushed replacement SHA.
+
+An optimization is rejected if it merely moves bytes into an auxiliary request,
+stores executable source in boot data, weakens the top-page owner, removes mixed
+APS/ADM support, reopens a handoff/retirement race, or relies on unsafe property
+mangling across independently built protocol components.
+
+The first complete revision-43 local build against exact rc base
+`58532d7c42d2a59f8e87f0d643f8d0b109a680cb` reduced the GPT semantic interval from
+105,391 to 97,198 raw bytes. Applying the hard-cutover unavailable-only fallback
+contract reduced it again to 89,803 bytes, but the unchanged rc ceiling is 72,148.
+The selected `008b` body is already slightly smaller than the complete legacy
+external body; the remaining 17,655-byte regression is the separately delivered
+controller/base ownership split. This evidence triggers the Task 15A/15B stop rule:
+more local compaction, a threshold change, or a different fixture is not an accepted
+remedy.
+
+Revision 44 therefore makes `first_display` a logical catalog capability physically
+owned by the bootstrap artifact. The bootstrap and first-display base are one
+controller and one state machine: queue ingress, sealed transport, component
+registration, projected action/terminal/paint state, fallback, and takeover cannot
+exist in separate artifacts or duplicate their generation/registration/disposal
+bookkeeping. The `first_display` catalog bit and mask position remain stable, but its
+generated release row is a non-routable marker and contributes no implementation
+bytes to the selected response. The one parser-blocking selected response contains
+only the selected initial slices, in catalog order, and those slices register with
+the already-installed controller. The server still emits exactly one inline sealed
+transport/controller and exactly one selected first-display request; no executable
+source moves into boot data and no auxiliary request, preload, cache assumption, or
+vendored dependency is introduced.
+
+The consolidated controller retains the same one-use capsule, exact source
+authentication, protected-paint boundary, fallback classifications, accepted-DOM
+preservation, post-detach reentrancy defenses, and bootstrap-only terminal
+publication. Its physical graph may reach the source-neutral base coordinator but
+must not reach APS, GPT, creative, PUC, or any optional-slice implementation. Every
+optional slice remains independently owned and is included only by its mask bit.
+Release/source-ownership tests prove the logical marker has exactly one physical
+owner, cannot be routed independently, and is absent from every served first-display
+body. The exact selected-agent rc comparison, controller absolute ceiling, and paired
+end-to-end timing remain the acceptance tests; the consolidation is incomplete until
+raw, gzip, Brotli, and timing all pass without changing membership, fixture,
+baseline, or ceiling.
+
+The checked-in pre-change fixture is immutable historical evidence and is never
+regenerated or rewritten. Its original `bundles` values measured a different
+artifact model: minimal contained only the old core, reference omitted the now-
+mandatory render owner, and maximal contained thirteen unsplit files. Those values
+cannot be used as like-for-like ceilings or any other pass/fail decision. Their raw,
+gzip, Brotli, provenance, and historical deltas remain report-only diagnostic
+evidence.
+
+The existing `roleCorrectTransfer` subtree records the first role-correct capture
+from the exact clean, pushed parent after Task 18D. Review established that this was
+an oversized intermediate implementation, so its provenance and bytes stay
+immutable but its self-derived 5% ceilings are not release acceptance. After
+mechanical runtime-graph remediation, the implementation appended a distinct
+`reviewRemediationTransfer` subtree to the same JSON without changing either earlier
+subtree. That second immutable checkpoint records graph de-duplication and its
+historical timing failure; neither fact authorizes or blocks the final release.
+Both intermediate subtrees are report-only and define no size ceiling. After
+first-display-agent remediation, the candidate evidence records its clean pushed
+source SHA, toolchain/compression identity, release inventory, per-artifact hashes,
+and these semantic sets:
+
+- **minimal first display** is `first_display` plus no optional slice;
+- **reference first display** is the one served agent artifact for the semantic
+  reference `[first_display, creative_initial, gpt_initial, prebid_initial,
+datadome_initial]`; it does not include core or any persistent takeover module;
+- **APS first display** is the served artifact for
+  `[first_display, render_owner_initial, aps_initial, creative_initial, gpt_initial]`
+  and drives a real fictional APS/PUC contract fixture through the first request
+  action;
+- **largest permitted first display** is the largest raw, gzip, and Brotli body
+  among the generated size-admitted masks that trusted configuration can serve (the
+  maximizing mask may differ per encoding); the capture enumerates all reachable
+  masks with their admission result, hashes, sizes, and slice membership rather than
+  checking only the two named examples;
+- **persistent runtime** is `[core]` plus all catalogued takeover modules for the
+  reference configuration, served after protected paint; and
+- **maximal non-bootstrap total** is every first-display base/slice, production core, takeover,
+  and deferred TSJS module in
+  the release, each exactly once. This gate prevents phase splitting from hiding
+  total growth.
+
+The mandatory render implementation is physically co-bundled into `tsjs-core.js`
+with the sole runtime so their shared dependency graph is emitted once. The
+catalogued `tsjs-render_runtime.js` transport member is a release-stamped marker:
+it preserves the logical provider row, manifest ordering, inventory accounting, and
+capability contract but contains no second implementation, listener, timer, port,
+or runtime. Servers still compose the catalogued `[core, render_runtime]` sequence;
+the marker is not a second request and does not create a compatibility path.
+The evidence capture records logical provider sources separately from physical
+artifact ownership (`render_runtime` is physically owned by `core`) and rejects a
+provider source in every other artifact even if a stale source-owner inventory tries
+to authorize the duplicate. It also freezes the twenty largest rendered-source
+contributions and every repeated attribution so review can see, rather than infer,
+where transfer growth and shared-source duplication remain.
+
+In the same blocking job, a detached worktree at the exact PR base SHA from
+`origin/rc/202608` builds the real production page for the reference configuration
+with its baseline artifact model and default creative behavior. Each side records a
+`referenceTransfer` context containing the exact raw/gzip/Brotli size and hash of
+every distinct Trusted Server JavaScript source delivered or embedded from
+`tsjs:bids-script` through the first responsible GPT action. The aggregate is
+diagnostic context rather than a relative byte comparator: the rc artifact model
+embeds only a small legacy shim while the hard-cutover model's inline controller owns
+queue ingress, sealed transport, fallback, lifecycle, and takeover coordination.
+Comparing those unlike inline responsibilities as though they were the same artifact
+would double-gate controller code already covered by the independent bootstrap
+ceiling and by end-to-end timing.
+
+The relative byte comparator instead measures the one externally delivered selected
+first-display agent on each side. It requires exactly one external agent source and
+compares raw, gzip, and Brotli independently. For the GPT reference fixture, the
+candidate selected agent must be no larger than the exact rc-baseline selected agent
+in every encoding. For APS, the candidate selected agent must be at most the exact
+rc-baseline selected agent × 1.10 in every encoding. Neither side relabels or splits
+sources to manufacture parity. The candidate inline controller independently remains
+at most 48,000/16,000/14,000 raw/gzip/Brotli bytes, every selected agent remains
+subject to its admitted-mask ceiling, and paired first-action p90 includes transfer
+and parse of the complete inline-plus-agent path. No ceiling is raised by this split
+pre-action transfer contract.
+
+The candidate evidence is accepted only after the first-display graph contains no public
+runtime API, persistent broker/registry, diagnostics, refresh, SPA/navigation,
+programmatic/direct-auction work, test seam, duplicate adapter owner, or live object
+that cannot be disposed/transferred by §5.2.1. These independent absolute architecture
+ceilings apply to the candidate and do not derive from any candidate capture:
+
+| Semantic set                                                  | Raw bytes   | Gzip bytes | Brotli bytes |
+| ------------------------------------------------------------- | ----------- | ---------- | ------------ |
+| inline bootstrap controller/fallback                          | ≤ 48,000    | ≤ 16,000   | ≤ 14,000     |
+| every permitted first-display agent mask                      | ≤ 90,000    | ≤ 30,000   | ≤ 26,000     |
+| reference persistent runtime after paint                      | ≤ 524,288   | ≤ 163,840  | ≤ 131,072    |
+| maximal non-bootstrap total, every other production role once | ≤ 1,048,576 | ≤ 327,680  | ≤ 262,144    |
+
+The first-display ceilings are selected from the fixed 200,000-byte/s profile; the
+post-paint and maximal limits prevent phase splitting or duplicated ownership from
+making total release growth unbounded. They are not substitutes for the rc-baseline
+selected-agent comparison or paired end-to-end timing gates. Changing any ceiling
+requires a reviewed design rather than recapturing candidate history.
+
+The build emits one canonical release inventory with each production bundle's id,
+role, phase, trigger, inputs, outputs, bytes, and hash. Budget membership is derived
+from that catalog rather than an obsolete exact filename list. Candidate evidence
+stores the exact raw, gzip, and Brotli values for bootstrap, every reachable
+first-display mask and its generated size-admission decision (with named
+minimal/reference/APS/largest summaries), persistent runtime, and maximal. The
+generated catalog allowlist must exactly equal the measured admitted subset. It is
+evidence for that candidate, not a self-created baseline.
+After the cutover lands, subsequent work chooses its own actual target-branch base
+and the same independent ceilings; no candidate-side capture becomes permanent
+authority merely by being checked in.
+
+The inline bootstrap-controller/fallback cannot be used to hide code outside those
+sets. It receives its independent ceiling above, appears
+exactly once under the `bootstrap` role, and is not counted again in maximal TSJS total. Its
+production metafile/import allowlist permits only boot-manifest/queue/fallback
+validation, generation/disposal, timing, and local logging primitives.
+
+`npm run check:bundle` builds fresh candidate metrics and runs these parts in CI:
+
+1. the original and two intermediate candidate captures and their digests are
+   validated and printed as immutable history, never as pass/fail ceilings;
+2. the freshly built exact rc-baseline and candidate reference pages enforce the
+   split pre-action contract: selected-agent relative bytes, controller absolute
+   bytes, and paired end-to-end timing;
+3. candidate bootstrap/all-permitted-masks/persistent/maximal values enforce the
+   independent absolute ceilings; and
+4. the one-time architecture/source-ownership assertions above remain blocking.
+
+A local baseline-less invocation enforces the absolute and architecture parts and
+marks the semantic comparison unavailable; CI and release evidence require the exact
+PR-base comparison and fail if it is missing, stale, or not reproducible.
+
+The gate also rejects an unclassified or multiply counted artifact, a missing
+production artifact, a test artifact, a maximal inventory that omits any split
+module, first-display reachability to a persistent/deferred source, takeover
+reachability to a deferred source, a consumer that inlines a catalogued provider
+implementation, overlapping agent/persistent side-effect ownership, and
+production reachability to fake/no-op/test or `*ForTest` sources. It reports the
+largest source contributions and repeated production attributions so later work
+cannot hide growth inside a passing aggregate. Changing historical evidence,
+semantic membership, the rc-baseline comparison procedure, or an absolute ceiling
+requires a separate reviewed design; it is not an implementation escape hatch.
+
+Boot-to-first-display uses real User Timing marks, not `__tsjsPerf` or a test-only
+placeholder. The bootstrap controller records `tsjs:bids-script` immediately before
+the server's first-display head sequence, so the measure includes required upstream
+and agent-artifact loading. The provisional owner records
+`tsjs:first-display`
+exactly once immediately before the first TS-owned request action in the protected
+first-display batch: the responsible GPT `display`/`refresh`. Direct `/auction`
+uses the no-agent persistent runtime and records the same mark immediately before
+its iframe insertion, but is a separate correctness/timing case rather than an agent
+mask. A page with no render attempt during the measurement is excluded
+explicitly rather than manufacturing a mark. The terminal latch for the attempt that produced that action records
+`tsjs:first-display-terminal`; after the complete immutable initial projection batch
+settles and the §5.2 paint gate passes, the agent records `tsjs:first-display-paint`.
+Each mark is emitted at most once per document runtime. The reference fixture asserts
+that no persistent or deferred TSJS request, preload, preparation, or execution precedes
+`tsjs:first-display-paint`; p90 remains the exact `tsjs:bids-script` to
+`tsjs:first-display` request-action measure so the historical metric does not change
+meaning.
+
+The standalone performance job uses pinned Chromium 145.0.7632.6, the
+`github-hosted:ubuntu-24.04` runner class, fixture
+`tsjs-baseline-paired-network-v3`, five warmups per variant, and 50 measured samples per
+variant. It runs automatically when a pull request changes the TSJS build/runtime,
+the server controller or projection path, the browser fixture, the evidence
+validator, or the workflow itself. Its existing `workflow_dispatch` and
+`workflow_call` entrypoints remain available for named pre-switch and post-switch
+evidence.
+
+The browser test has a 40-minute safety budget and its Actions job has a 50-minute
+safety budget. Each of the 110 paired warmup/measured navigations returns from
+navigation at response commit and closes immediately after the common first
+observable action used by the timing metric; neither variant waits for the browser
+`load` event or post-action lifecycle work inside the timing sample. After sampling,
+the same test performs exactly one separate load-complete candidate lifecycle
+observation for release identity, candidate marks, paint, takeover, and
+deferred-order evidence, followed by the separate paired heap contexts. Release
+identity is intentionally asserted there because it belongs to persistent takeover
+and need not exist at the earlier first-action measurement boundary. The budgets
+absorb hosted-runner variance, checkout, the candidate/rc-baseline builds,
+browser setup, validation, finalization, and immutable upload. They do not reduce
+the five warmups, 50 measured samples per variant, fixed network profile, assertions,
+or evidence requirements, and they are not permission to repeat post-measurement
+lifecycle work in every sample. The final budget is evidence-based: after removing
+the redundant lifecycle waits and returning timing navigations at response commit,
+the declared hosted runner completed the shaped sample, full candidate observation,
+and first paired heap context at the former 30-minute boundary, before the second
+required heap context and evidence write. The ten-minute inner reserve covers that
+remaining required context plus evidence serialization; the outer reserve covers
+build/setup, validation, and immutable upload.
+
+The job declares paired GPT-reference and APS first-display cases. Both variants of
+each pair use the same projection, enabled behavior,
+upstream fictional stubs, page markup, creative policy, warm/cold cache state, and
+browser profile. The APS case drives the fictional APS/PUC contract through its
+actual first action, terminal result, and paint, and must satisfy the size, mark,
+ordering, deadline, and heap contracts. The rc baseline has a first-class APS action,
+so its first responsible GPT action and delivered pre-action TSJS bytes are compared
+honestly; candidate-only terminal, paint, containment, and heap claims retain the
+absolute gates below because the document protocols intentionally differ. A GPT pass
+never masks an APS failure.
+
+The APS case is also a blocking absolute quantitative gate, not only
+a protocol-deadline check. Its checked-in fictional GPT, GAM creative, proxy, runner,
+and PUC bodies and schedules are invariant test inputs; the fictional runner invokes
+the real queued `prebid/creative/render` callback 50 ms after its API call. Across the
+same five warmups and 50 measured samples, APS must meet all of these ceilings:
+
+| APS metric                                                             | Ceiling                      |
+| ---------------------------------------------------------------------- | ---------------------------- |
+| `tsjs:bids-script` to first responsible GPT `display`/`refresh` action | p90 ≤ 900 ms                 |
+| first action to accepted APS completion                                | p90 ≤ 1,500 ms               |
+| accepted APS completion to `tsjs:first-display-paint`                  | p90 ≤ 250 ms                 |
+| `tsjs:bids-script` to `tsjs:first-display-paint`                       | p90 ≤ 2,500 ms               |
+| forced-GC `usedSize` immediately after protected paint                 | ≤ 3,145,728 bytes (3 MiB)    |
+| forced-GC `usedSize` after persistent takeover and queue drain         | ≤ 3,932,160 bytes (3.75 MiB) |
+
+Every timing row is computed from the named real marks/action, never a test-created
+substitute. Every sample—not only p90—must still satisfy the narrower applicable
+correctness deadline. Changing a fictional dependency body/schedule, a ceiling, a
+mark endpoint, or the network profile is a performance-contract change requiring
+review rather than a way to recapture a passing baseline. These deliberately broad
+absolute guardrails cover the candidate-only document lifecycle. For both GPT and
+APS, candidate first-action p90 must be at most the rc-baseline value × 1.10. The GPT
+candidate selected-agent raw/gzip/Brotli transfer must not exceed the exact
+rc-baseline selected agent; the APS candidate selected-agent transfer may be at most
+the exact rc-baseline selected agent × 1.10. The recorded aggregate transfer remains
+diagnostic context, while the candidate controller and admitted agent remain bound by
+their independent absolute ceilings above.
+
+On a pull request, each run reads `pull_request.base.sha` into the dedicated
+`TSJS_PERF_BASE_SHA`, verifies it is a 40-character commit reachable from the fetched
+`origin/rc/202608`, creates a detached worktree at that exact SHA, and builds the rc
+baseline and candidate independently. A manual/called run requires the same exact
+input; a moving branch name or candidate-generated fallback is invalid. The
+baseline-side loader feature-detects and consumes the artifact shape that commit
+actually produced. While the rc baseline emits the legacy `tsjs-core.js`,
+`tsjs-creative.js`, plus `tsjs-gpt.js` model and no release-v1 inventory/controller,
+the harness concatenates and serves those real built bytes, enables the same default
+creative policy, and drives their real legacy `adInit` surface. After the cutover
+reaches the release branch, a later comparison consumes that base commit's release-v1 inventory/controller
+and that commit's real server-selected first-display artifact instead. It does not relabel an older phase-aware
+capture as the baseline or require unavailable candidate-only metadata from a legacy
+commit. The candidate side consumes its generated server controller and release-v1
+first-display/takeover/deferred artifacts. One in-process `node:http` server per variant on an
+ephemeral `127.0.0.1` port serves that variant's exact page and bytes. Playwright
+request interception or fulfillment is outside the instrument.
+
+Before either variant navigates, its page receives the same checked-in Chromium CDP
+`Network.emulateNetworkConditions` profile: 150 ms latency, 1.6 Mbit/s download
+(200,000 bytes/second), 750 kbit/s upload (93,750 bytes/second), and zero packet
+loss. The profile is not selectable by environment input. A common comparison mark
+runs immediately before the external first-display script element, and the GPT fixture
+records the common terminal mark at its first observable `display` or `refresh`
+action. A direct-render comparison records the equivalent iframe insertion. The
+interval therefore includes first-display transfer, parse, evaluation, and
+runtime work through the first observable request/render action without depending
+on a candidate-only mark. Candidate runs additionally prove the real
+`tsjs:bids-script`, `tsjs:first-display`, and `tsjs:first-display-paint` marks and
+that no persistent or deferred TSJS request, preload, preparation, or execution
+precedes paint.
+
+The no-agent direct `/auction` correctness fixture records
+`tsjs:first-display-terminal` from its terminal latch and
+`tsjs:first-display-paint` through the same two-frame/hidden allowance. Ordinary
+deferred loading waits for that paint or the no-attempt guard exactly as specified
+for direct-to-runtime pages. It is not counted as an agent-mask sample or used to
+claim the agent's ≤90 kB transfer ceiling.
+
+The job alternates baseline then candidate / candidate then baseline in one Chromium
+process for every warmup and measured GPT and APS pair. Candidate first-action p90
+must be at most the matching rc-baseline p90 × 1.10. GitHub-hosted absolute timing is
+not stable enough for a tight fixed shared-regression ceiling, and a historical fixed
+comparison SHA is not an honest stand-in for the PR base; neither replaces that
+paired gate. The APS absolute ceilings above are separate fixture guardrails. The
+schema-6 artifact records the exact baseline and candidate SHAs, each actual artifact model, each exact served
+first-display byte count, both full distributions and p90s, the alternating order, and
+the exact network profile. The workflow runs each declared pair once and never
+selectively reruns, drops, or reclassifies slow samples. Budget assertions are soft
+only in the Playwright sense: the run finishes all timing and heap collection and
+writes the complete schema-6 evidence before failing. Validation and upload run
+with `always()` so a failed gate retains its exact diagnostic artifact; neither the
+test nor the validator converts an exceeded budget into success.
+
+On a pull request, both the evidence writer and validator consume the dedicated
+`TSJS_PERF_HEAD_SHA` value resolved from `pull_request.head.sha`. They do not read or
+attempt to override GitHub's reserved `GITHUB_SHA`, which names the synthetic merge
+commit for a pull-request workflow.
+
+The performance workflow invokes checked-in repository scripts, and its
+performance-only Playwright configuration is also a checked-in TypeScript file.
+Neither workflow YAML nor a shell script synthesizes executable source or
+configuration at runtime.
+
+The historical GPT blocking ratio remains request-action latency, so the gate and job
+call it **bids-script-to-first-action**, not paint latency. The same evidence records
+candidate terminal and paint distributions for GPT and APS. Every sample must remain
+inside the unchanged path-specific render deadline and §5.2 paint allowance; this
+prevents an agent from improving transfer latency by postponing completion or
+takeover without claiming a non-equivalent rc-baseline terminal/paint ratio.
+
+Retained heap for the paired GPT case uses forced-GC Chromium checkpoints after boot,
+first render, refresh, and SPA navigation. After the display samples, the job launches
+one fresh Chromium process, opens one separate fresh browser context per variant, and
+executes the equivalent lifecycle supported by that variant's real artifact shape.
+This keeps retained-heap evidence out of the process that has already completed 111
+cold navigation contexts. The APS case uses its two candidate-only checkpoints in the
+table above. At each checkpoint the job calls Playwright's supported `page.requestGC()`
+once followed immediately by CDP `Runtime.getHeapUsage`; each GC, usage, detach, and
+cleanup operation has an explicit 30-second local failure boundary. The single
+`usedSize` is the checkpoint statistic, with no hidden averaging, maximum selection,
+or rerun. Both variants must remain below the immutable 4 MiB hard ceiling. The
+schema records rc-baseline values and identity for direct inspection, but does not
+turn the smaller legacy runtime shape into an arbitrary multiplier for the
+hard-cutover kernel and deferred architecture. Any checkpoint over the absolute limit
+fails the one declared run; the job cannot replace only that measurement or rerun only
+the heap fixture. Correctness runs independently in Chromium, Firefox, and WebKit.
+Correctness failures are never waived by a performance pass.
+
+The paired SPA checkpoint changes the document pathname, not only its query. The rc
+baseline and candidate use their respective real navigation hooks, and both must observe
+that same pathname transition, request `/_ts/page-bids`, consume the response body,
+and finish GPT slot reconciliation before the final forced-GC measurement.
+
+## 6. Security and privacy
+
+1. The publisher-origin bootstrap initially omits `allow-same-origin`; after its
+   exact readiness proof, the top-page owner adds that token only for navigation to
+   the naturally opaque data container. The final outer and inner documents are
+   `data:` documents and remain opaque while their permanent sandbox keeps
+   `allow-same-origin` so the HTTPS creative retains its real origin across browsers.
+   Target `"*"` is used only with exact source, nonce, shape, generation, element,
+   and one-use-port checks because opaque origins cannot be named as `targetOrigin`.
+   PUC/GAM/bidder content is never an ancestor of the APS mount.
+2. The initial global PUC request contains the opaque renderer reservation
+   capability but no descriptor, ADM, lifecycle ticket, or nonce, and it establishes
+   no success. The first compatible claim acquires the PUC source; render authority
+   begins only after exact reservation/slot lookup, attributable nonempty GAM,
+   current generation, source binding, and atomic consumption. Its dynamic owner
+   receives settlement authority only; it never receives descriptor data or APS DOM
+   authority.
+3. Lifecycle tickets and nonces are CSPRNG, one-use, TTL-bounded, never logged, and
+   invalidated on supersession/navigation.
+4. Exact-key message parsing prevents confused-deputy extensions. Unknown versions
+   are ignored or failed closed according to whether the message claims a TS
+   capability.
+5. Native Prebid messages with non-TS ids continue to native listeners. Any message
+   carrying a live or tombstoned TS id is suppressed before later validation.
+6. The first-display handoff is not a public trust boundary. Its data record is
+   exact-shaped, bounded, recursively frozen, and descriptor/creative-free; its
+   object capsule is closure-private, same-task, release/generation-bound, and
+   one-use. No agent capability reaches `window.tsjs`, DOM attributes, messages,
+   logs, diagnostics, storage, or analytics. A forged/replayed/stale capsule fails
+   before persistent activation and cannot claim committed DOM or a GPT object.
+7. The upstream APS runner URL, every creative URL, and production renderer/proxy
+   routes must be HTTPS. HTTP is permitted only for loopback hermetic adapters; their
+   fixed local proxy origin is injected as the inner document's sole external script
+   origin. The runner executes only
+   through the fixed-target, anonymous-CORS Trusted Server proxy. The proxy relays the
+   APS body unchanged but never stores it in source, forwards publisher credentials,
+   accepts a caller-selected target, or executes a fallback. No APS, GPT, PUC, or
+   other vendor bytes are stored in source or release artifacts; hermetic fixtures
+   are locally authored protocol doubles. Runner-created APS-origin
+   resources may use their own origin cookies under browser policy. The renderer
+   document accepts no cookie as authority.
+8. Script creatives remain opt-in because they materially broaden executable
+   behavior. Enabling them selects only the reviewed conditional CSP pair in §4.4:
+   the validated creative origin is added to `script-src` in both inherited policy
+   levels, while iframe creatives retain the narrower pair. Build and browser tests
+   reject any tag-type/policy mismatch or redirected script origin.
+9. Persistent/deferred module URLs are generated from the local immutable release inventory,
+   are same-origin exact content-hash paths, and are authenticated by
+   release/id/source plus the core-created element and `document.currentScript`.
+   The narrowly scoped Trusted Types policy accepts only those frozen manifest URLs,
+   CSP nonces are copied only from the authenticated parser-inserted tag, and policy
+   failure cannot select another sink or source. Publisher-created tags and calls
+   cannot load or register code, and no deferred URL can select an upstream script
+   target.
+10. Static TSJS hash mismatches and unknown paths fail locally on every adapter; a
+    stale URL never aliases current bytes or falls through to publisher origin.
+11. The design adds no persistent identifier and no external event pipeline.
+
+## 7. Verification and acceptance
+
+### 7.1 Required test layers
+
+| Layer                 | Required proof                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Rust unit             | APS parsing/admission, dimensions, scripts, AAX projection, mediation provenance/order/timeouts, targeting identity, descriptor serialization, endpoint headers/body                                                                                                                                                                                                                                                                                          |
+| Baseline/gap audit    | rc-baseline tests are the behavioral oracle; every retained `RCJ-*` row starts proof-pending, identifies/authors a focused contract, runs it on the untouched recorded-rc worktree, and ends baseline-owned or demonstrated implementation-gap with recorded SHA/owner/test command/result; proof-pending/coverage-gap blocks phase exit and no retired source is built or merged                                                                             |
+| Cross-language corpus | every positive/adversarial descriptor has the same Rust, TS, and embedded ES5 result; stale generation fails                                                                                                                                                                                                                                                                                                                                                  |
+| TS unit               | agent/takeover ownership, exact handoff/capsule admission, takeover/deferred transactions, fallback versus isolated deferred failure, trigger/disposal races, sessions, registries, selection/cycle/batch/latch APIs, adapter readiness, GPT handoff/reconciliation, Prebid artifact/refresh, creative security, diagnostics, and every remaining integration parity corpus                                                                                   |
+| Hermetic browser      | one parser-blocking first-display request, no pre-paint persistent/deferred traffic, authenticated atomic takeover into the one persistent runtime, all render paths, PUC bridge, exact-bound-slot top mount, four-level APS sizing, data-document CSP containment, direct iframe races, owner/port/runner behavior, fallback, SafeFrame-shaped isolation, GPT handoff/hydration, creative clicks, diagnostics, and duplicate/replay/wrong-source/stale cases |
+| Real-GAM test network | SSAT APS-PUC, Prebid-adapter APS-PUC, page-bids APS-PUC, direct APS, direct ADM plus rc-baseline PBS Cache regression, fallback after attributable empty GAM, SRA, refresh, SPA, handoff, hydrated DOM replacement, and collapsed shell                                                                                                                                                                                                                       |
+| Adapter parity        | exact bootstrap sandbox/CSP/header bytes plus runner-proxy routing, five-second deadline, closed response parsing, bounded relay, header filtering, and failures match on all adapters                                                                                                                                                                                                                                                                        |
+| Regression            | non-APS Cache/ADM and notifications, pure external Prebid/native bids/EIDs/user IDs/refresh exclusions, publisher GPT/handoff/SRA/SPA, creative processing/click recovery, render trace/GPT diagnostics, and every remaining integration remain correct                                                                                                                                                                                                       |
+| Quality               | full-package TypeScript/lint including tests/scripts/build code, ESLint and release-catalog dependency boundaries, production-metafile/test-hook exclusions, format, clippy, Rust adapter suites, Vitest, artifact integration, Playwright, immutable historical bundle reporting, role-correct transfer budgets, performance/heap budgets, and complete maximal inventory                                                                                    |
+
+Feature-owned GitHub Actions YAML is declarative orchestration, not a program
+container. Multiline shell programs, generated configuration bodies, validation
+branches, loops, release-manifest writers, and evidence scrubbers introduced by this
+design live in reviewable repository files under `scripts/ci/`. Workflow `run` steps
+may invoke those scripts or use a simple one-command tool invocation such as
+`npm ci`, `cargo test-axum`, or an existing `./scripts/...` entrypoint; they must not
+embed `node -e`, heredocs, shell loops, generated-file bodies, or folded/multiline
+program logic. Shared toolchain extraction and evidence handling are reused rather
+than copied between workflows, while workflow-specific orchestration remains in
+focused scripts instead of one opaque dispatcher.
+
+Repository contract tests read both the workflow and the referenced script files.
+They reject feature-owned embedded workflow programs and missing script targets,
+then assert the security, release-binding, exact-rc-baseline, performance, browser-matrix,
+adapter-corpus, manifest, and evidence-scrubbing behavior in the scripts that own it.
+This source-shape rule changes only how CI logic is maintained; it does not weaken a
+gate, broaden secret exposure, alter protected-environment admission, or introduce a
+second evidence format.
+
+### 7.2 Mandatory race matrix
+
+Tests must cover at least:
+
+- duplicate simultaneous `Prebid Request` for the same id;
+- claim before/after attributable nonempty GAM, claim followed by empty GAM, and
+  navigation/supersession at each side of that two-condition join;
+- replay after consumption and after tombstone expiry boundary;
+- attempt-id navigation prefix failure, ordinal uniqueness and exhaustion without an
+  issued-id set; forced lifecycle-ticket, `b1_` bootstrap-nonce, and `n1_`
+  renderer-nonce collisions through the eighth draw; independent 255/256/257 live
+  boundaries for each nonce registry and 319/320/321 ticket/tombstone entries;
+  capacity versus expiry pruning; cross-role nonce substitution; and proof that no
+  overflow path posts a usable capability;
+- valid id from wrong slot/source, altered id from the expected source, and a native
+  Prebid id;
+- PUC registration before/after timeout, wrong source, zero/two ports, replay,
+  caller abort before/after registration/insertion/document acceptance, and owner
+  watchdog racing a late kernel response; every winner produces exactly one
+  encodable `OwnerSettlementV1` and one PUC Promise settlement; channel loss before
+  start and after top insertion, settlement-post throw, and the 20-second remote
+  cleanup boundary prove the PUC owner owns no APS node while the mount service
+  removes only its exact uncommitted iframe and leaves accepted DOM;
+- bootstrap ready before/after deadline; wrong source/`b1_`/shape; outer frame
+  removal, `src` mutation, replacement, and navigation; zero/two container ports;
+  wrong-outer `n1_`, inner-ready replay, port swap/reuse, and descriptor transfer
+  before/after channel creation; a nested SafeFrame-shaped PUC source proving claim
+  authentication never performs WindowProxy-to-DOM mapping; publisher,
+  GAM, PUC, and creative attempts to navigate or frame a publisher-origin document;
+  exact iframe-versus-script outer/inner CSP selection, iframe-script refusal,
+  same-origin script-creative execution, cross-origin redirect refusal, and other
+  creative-origin allow/deny cases; data-document 65,535/65,536/65,537-byte
+  boundaries; sentinel escaping/completeness; and renderer document success followed
+  by runner failure/timeout;
+- runner proxy stall and slow-drip across the five-second total deadline; redirect;
+  absent/duplicate/malformed/mismatched/over-limit `Content-Length`;
+  absent/accepted/parameterized/rejected `Content-Type`; absent/identity/listed/other
+  `Content-Encoding`; declared and streamed over-limit bodies; byte-preserving
+  success; stripped upstream headers; and empty, non-leaking `502 no-store` failure;
+- GPT/Prebid readiness at either side of its deadline, `slotRequested` at either
+  side of the request-start deadline, and `slotRenderEnded` at either side of the
+  completion deadline, including late real completion of an attributable
+  completion-timeout cycle and proof that future events never release an
+  unattributable request-timeout quarantine;
+- iframe `load`, `error`, removal, supersession, and navigation disposal ordering;
+- accepted-artifact promotion racing terminal disposal, replacement of an accepted
+  direct iframe, TS-owned GPT destroy/redefine, and publisher-owned GPT navigation;
+- accepted PUC APS overlay followed by publisher `display`, explicit/global/SRA
+  `refresh`, competing or ambiguous request intent, and an exactly attributable TS
+  replacement that succeeds or fails; prove publisher/ambiguous `slotRequested`
+  retires the overlay before later GPT listeners while a TS replacement retains it
+  until commit; publisher `destroySlots` explicit/all with true/false/throw, GPT DOM
+  removal before/after the call or callback, host replacement/disconnection, owned
+  overlay removal/reparenting, navigation disposal, and all pairwise races prove
+  exact-once node/style/targeting cleanup, no GPT-object destruction by artifact
+  retirement, no repeated PUC settlement, and no refreshed publisher content hidden
+  behind an old overlay;
+- two consecutive attempts installing identical targeting strings with newer
+  success, failure, and supersession; older-artifact disposal after newer promotion;
+  publisher different-value and same-value `setTargeting`, per-key clear, and
+  clear-all before each cleanup point;
+- old-navigation completion after a new slot with the same DOM id exists, both
+  before and after the replacement's completion, for TS- and publisher-owned slots;
+- two concurrent `/auction` calls with partial slot overlap, reversed responses,
+  one caller abort, full abort, and response timeout;
+- initial boot projection versus SPA navigation-owned projection, proving boot
+  remains recursively frozen; stale/duplicate/malformed page-bids responses;
+  page-bids racing programmatic registration at the 255/256/257 combined-slot
+  boundary; auction/provider/upstream/currency/CPM/targeting grammar and
+  byte/count boundaries; canonical projection just below/at/above 8 MiB with the
+  exact all-winners-to-`winner_not_renderable` reduction; and all-or-nothing
+  projection/slot/targeting commit;
+- required `[creative_opportunities].enabled` present/absent/wrong-type parsing;
+  disabled publisher HTML and page-bids produce no matching/auction/projection/client
+  initialization while direct `POST /auction` remains live; disabled configuration
+  still fully validates; inactive HTML public/no-header/private/no-store policies;
+  case-insensitive protection of private directives; preservation of validators and
+  surrogate/CDN fields; synthesized-state privacy; and non-HTML/error noninterference;
+- `display()` under disabled initial load from TS and publisher callers;
+- exact and hydration-renamed late `defineSlot` handoff, mismatch/ambiguity,
+  duplicate publisher display, explicit/global initial-load-disabled refresh,
+  ownership transfer, SPA disposal, and unrelated slots/options;
+- DOM replacement before and after GPT request start, debounced TS-owned orphan
+  reconciliation at 249/250 ms and 4,999/5,000 ms, first/final pass success,
+  two-success capacity, expiry/rebind latch ordering, ambiguous replacement,
+  transfer racing replacement, exact orphan destruction/quarantine, targeting
+  compare-restore, cycle/reservation cleanup, throwing/false GPT destroy and failed
+  replacement definition in reconciliation/request-timeout/completion-timeout/
+  navigation paths, proof no second physical slot is defined, navigation disposal,
+  and proof that publisher-owned slots are never destroyed;
+- SRA completion ordering, duplicate `responseIdentifier`, missing completion, and
+  publisher/TS overlap;
+- `gam_attribution_enabled` false/true with missing and pre-existing `adInit`, GPT
+  queue absent/present, targeting API missing/throwing, initial/lazy/publisher-owned/
+  refresh/SPA requests, takeover, and direct-persistent boot; prove exactly one
+  parser-time `setConfig({targeting:{ts:'true'}})`, no `ts` cleanup, no old global or
+  activation attribute, and no behavior change while disabled;
+- missing/stub/late/duplicate/older/partial external Prebid artifacts, artifact
+  queue-watchdog versus late module activation, ABI and release-identity boundaries,
+  every manifest collection/string capacity, malformed/unsorted/duplicate members,
+  sentinel-normalized versus final-byte integrity, exact 10.26.0, own data-property
+  binding, same-release duplicate reuse without module re-execution, different-valid-
+  release refusal without disturbing the active object, absent/accessor/inherited/
+  invalid/hostile non-configurable stamp handling after the watchdog arms, publisher
+  callback delivery exactly once on every conflict path, bound `pbjs`/stamp replacement,
+  `PreparedTrustedBid` admission/non-publication, bidder aliases, client-side
+  adapter gaps, user-ID/EID manifest gaps, replacement by a later valid artifact,
+  absence of TS auction/admission/render/refresh behavior from the external artifact,
+  and native publisher queue/bid
+  survival;
+- explicit/global Prebid refresh with normal, all-excluded, and mixed slots;
+  literal path case/trailing-slash mismatch; missing/non-string/throwing
+  `getAdUnitPath`; cleanup of excluded slots; original option identity; and the
+  initial-TS-refresh bypass;
+- reservation capacity with an unexpired oldest entry and late request for that
+  entry; navigation slot capacity across repeated programmatic calls at totals
+  255/256/257, mixed server/programmatic records, all-or-nothing overflow, and full
+  disposal/reuse on the next navigation; Prebid lease promotion; and the pinned
+  PBS Cache black-box corpus for ADM-over-cache precedence, cache-only fetch/parse/
+  macro/PUC response, collapsed resize, failure, and stale-navigation disposal with
+  no new cache input, result, deadline, or identity semantics;
+- release-catalog cycles, duplicate providers, undeclared capabilities, takeover
+  consumption of a deferred provider, phase overrides, unknown/missing/multiply
+  counted production artifacts, deferred/test source pulled into core, and a module
+  classified into the agent without its named parser-time or first-display obligation;
+  exact per-consumer capability projection proves `attachPresentation` is absent
+  from `trace.v1` and denied to APS, GPT, and `gpt_later`, while only
+  `diagnostics_presentation` can consume `trace.presentation.v1`;
+- exactly one parser-blocking network request and manifest-order registration;
+  takeover exact-six-key and deferred exact-five-key registration; no-agent
+  `prepareSync` success/throw/thenable/deadline behavior with no task or microtask
+  before activation and commit; agent takeover and deferred synchronous/async
+  `prepare` success/reject/abort; first-display/takeover module
+  missing/wrong-release/duplicate/activation throw at each checkpoint, late
+  continuation after fallback, and takeover
+  `afterCommit` throw; 9,999/10,000/10,001 ms synchronous activation returns plus
+  the pre/post-call and pre-handoff monotonic checks; nonreturning activation
+  documented as unpreemptable; duplicate `afterCommit` registration,
+  catalog-derived 13/14/15 takeover-callback staging, and 19/20/21 total-manifest
+  capacity; publisher GPT activity and
+  script/creative DOM activity before/during/after a later takeover failure prove
+  preparation is inert, activation cannot yield, rollback is same-task, and
+  post-commit work sees only the full persistent kernel; queued and later
+  `requestAds`, callback throws, already-aborted signals, publisher/unsolicited
+  integration registration refusal, and proof that no second runtime, listener,
+  port, timer, request, script, wrapper, guard, or iframe survives fallback;
+- takeover download/preparation with interleaved publisher `defineSlot`, `display`,
+  explicit/global `refresh`, destroy, targeting mutation, GPT events, DOM
+  replacement, guard observations, Prebid queue activity, consent/segment changes,
+  and terminal/tombstone expiry proves that static preparation reads no live state;
+  the final same-task snapshot sees the last mutation revision, revision exhaustion
+  fails closed, and a callback queued after closure reaches only the persistent epoch;
+- protected-paint admission sealing immediately before/at/after the boundary proves
+  a late TS Prebid bidder call completes once with no bid and no minted lease,
+  reservation, ticket, attempt, port, or callback; native publisher GPT/Prebid and
+  non-TS bidder calls remain pass-through; discovery of deliberately injected live
+  TS authority commits `bundle_partial` rather than transferring or replaying it;
+- persistent download/authentication/preparation success, failure, and the exact
+  9,999/10,000/10,001 ms post-paint deadline prove callback pushes remain queued
+  until one commit; success drains against the full kernel, while failure freezes the
+  exact true/false `initialDisplayCommitted`, drains once against fallback, makes
+  every new `requestAds` and `addAdUnits` call refuse without reading its input and
+  propagate the same classified
+  `abi_mismatch`/`bundle_partial` fallback reason, preserves accepted DOM, and leaves
+  no pending work or artifact retry;
+- final handoff boundaries for attempt/slot/GPT-token/cycle/trace ordinals at
+  maximum-minus-one/maximum/exhaustion; pruned prior cycles with
+  `unknownPriorCycle`, open/retired/quarantined GPT cycles, late old-cycle facts,
+  monotonic expiry translation, 255/256/257 adopted slots, 8 MiB
+  non-diagnostics/512 KiB diagnostics/8.5 MiB total data-tree caps, and one-use
+  capsule replay prove that no id/sequence is reused and no event is reattributed;
+- provisional creative/DataDome/GTM/Lockr/Testlight/consent guards mutate during
+  runtime preparation, then compare-restore and install fresh persistent effects in
+  one task; observer-record loss is covered by the bounded rescan, publisher-
+  replaced globals leave old effects generation-inert, and no function/listener/
+  wrapper/observer enters the handoff or capsule;
+- direct persistent boot for rewritten creative documents and direct `/auction`
+  proves neither path selects an agent or waits for a nonexistent projected-attempt
+  paint; direct timing/deferred release uses the persistent owner, while every
+  generated size-admitted agent mask—including GPT reference and APS—passes the exact size,
+  source-reachability, action, terminal, and paint assertions;
+- first-display-required live GPT/Prebid fetch starting after `tsjs:bids-script` and
+  overlapping the first-display TSJS fetch, upstream success before/after adapter
+  activation, and proof that no TS-owned display/request occurs before the sole
+  adapter's correctness listeners; optional upstream and APS runner traffic is
+  absent from boot, TSJS generated-source scans contain no upstream library bytes,
+  and the separately generated external Prebid artifact passes its purity scan;
+- `first_display_or_idle` at each side of attempt creation and batch settlement, no
+  initial slot, the 9,999/10,000/10,001 ms attempt-creation guard, first/second
+  animation frame, hidden/visible transition, idle callback, idle timeout, 50 ms
+  timer fallback, an explicitly post-window first display overlapping released later
+  work, navigation waiter disposal, and full-runtime module disposal;
+  concurrent readiness waiters keep their original deadlines while sharing one
+  module Promise/script after the gate; all deferred transactions start after the
+  common gate without waiting for one another, and a hung/failed first catalog entry
+  cannot delay another module's fetch or deadline; no persistent/deferred request/preload/evaluation
+  precedes `tsjs:first-display-paint`; exact script-node/currentScript/source/id/
+  phase/release authentication rejects publisher tags, replaced nodes, redirects,
+  duplicates, and stale generations; deferred prepare/activate/afterCommit/load/
+  timeout failures leave the same kernel/adapter/listener/slot/dispatcher identities
+  live, settle dependent work with its typed reason, leak no node/listener/timer,
+  and neither install fallback nor start a second runtime;
+- first-display, takeover, and deferred static routes across Fastly, Axum, Cloudflare, and Spin:
+  exact path, one-field hash query, response-byte hash, enabled catalog membership,
+  MIME/nosniff headers, conditional `304`, local `404 no-store`, no publisher
+  fallthrough, and no redirect; stale-release URLs fail instead of receiving current
+  bytes;
+- CSP/Trusted Types browser fixtures for same-origin allowlisting, matching nonce,
+  nonce-only policy, `strict-dynamic`, allowed `trusted-server#tsjs-v1`, rejected
+  named policy with an exact-preserving publisher default, and full policy block;
+  the unit phase-loader layer asserts the exact internal reasons: mutation by a
+  default policy, a disallowed URL, or a synchronous policy throw is
+  `policy_blocked`; missing/invalid nonce or CSP source rejection after insertion is
+  `load_error`; and node removal/replacement is `registration_rejected` unless load
+  failure wins. Browser fixtures do not expose those private enums: they prove the
+  corresponding distinct environmental cause, insertion/request outcome, absence of
+  an unauthorized diagnostics panel, and survival of the same committed kernel;
+- exact kernel/fallback `TsjsApi` own surfaces; semantic version and release-id
+  equality; boot deep-copy/freeze and malformed-field safe fallback; exact ordered
+  integration-config id inclusion, manifest/product matching, attenuated per-module
+  delivery, bootstrap-snapshot identity through agent takeover/deferred load, raw
+  pre-load-object replacement, old-global absence, accessor/symbol/prototype/cycle/
+  sparse-array/alias rejection, depth/node/string/key/per-entry/aggregate boundaries,
+  and fallback empty config entries; actual-Array
+  queue identity; pushes before/during/at activation and commit completion; retained ingress
+  references after swap; snapshot-versus-forward exactly-once behavior; nested push
+  ordering; frozen final-queue `length:0` under native/borrowed mutators, index and
+  length assignment, deletion, and property definition in strict and sloppy callers;
+  immediate post-load return values, `this`, non-callables, and callback throws;
+- main bundle absence after server GPT projection, proving the old degraded bootstrap
+  renderer is deliberately gone: no GPT definition/targeting/display/refresh occurs,
+  fallback retains no server-projected slot membership, every `requestAds` refuses
+  with the classified unavailable error, the
+  queue drains once, and a late bundle cannot revive rendering;
+- explicit `requestAds` selection with exact server-projected and programmatic slot
+  ids, an unknown id beside a valid sibling, GPT-path and DOM-alias collisions, and
+  omitted-slot snapshot membership/order while another slot registers after
+  invocation;
+- programmatic `addAdUnits` single/array registration, boundary sizes/counts,
+  accessors/unknown keys/media, malformed params, duplicate/colliding ids,
+  all-or-nothing rollback, navigation disposal, registration after a `requestAds`
+  snapshot, dimension type and 0/1/4096/4097 boundaries, 63/64/65-byte bidder names,
+  direct rendering, fallback refusal, absence
+  of placeholder methods, logger default/all levels, invalid-level non-mutation, and
+  missing/throwing console methods;
+- direct and PUC ADM initial `about:blank`, pre-assignment, intended `srcdoc`, error,
+  removal, replacement, duplicate load, supersession, disposal, stale-generation,
+  and deadline orderings, proving only the current intended navigation accepts;
+- core diagnostics ingress has the exact frozen `{publish,dispose}` surface and no
+  `subscribe`, listener id, capacity, queue, scheduler, or timer; valid ordinary and
+  null-prototype records, dense arrays, and UTF-8 multibyte data pass at total-node
+  511/512, depth 15/16, 127/128-byte property names, and 4,095/4,096-byte strings,
+  while total-node 513, depth 17, 129-byte names, 4,097-byte strings, sparse/extra-
+  property arrays, accessors, symbols, custom prototypes, functions, `undefined`,
+  bigint, non-finite numbers, cycles, aliases, hostile traps, and copy/freeze failure
+  return `false` without reducer entry; accepted snapshots share no producer record
+  or array, reducer/reporting throws are isolated with `true` returned, disposal is
+  idempotent, and retained stale-runtime publishers remain `false` and inert;
+- GPT trace tokens have canonical ordinals 1/35/36/4,294,967,295, exact lower-case
+  base-36 grammar and 11-byte maximum, reject zero/leading-zero/upper-case/decoded-
+  overflow/collision inputs, and latch only new trace-token minting on ordinal
+  4,294,967,296; repeated facts and publisher handoff for one physical slot retain
+  one token, distinct/replacement objects sharing every publisher identifier receive
+  distinct tokens, and token failure leaves object-identity-bearing `gpt.events.v1`
+  delivery and GPT behavior live; per-object trace-cycle ordinal 0/1/4,294,967,295/
+  4,294,967,296, fractional/non-finite rejection, 9/10/11 retained-cycle pruning,
+  and per-object rather than global exhaustion; compound `{token,cycleOrdinal}` core
+  binding covers unresolved/ambiguous/duplicate active facts, live-map totals
+  255/256/257, completed/retired oldest-first pruning, destroy/redefine, handoff,
+  navigation retirement, no old-pair rebinding or new-current mutation, history-only
+  late enrichment, and full runtime disposal; two consecutive refresh cycles on the
+  same physical object produce two rows, with prior-cycle `slotResponseReceived`,
+  `slotRenderEnded`, `slotOnload`, `impressionViewable`, and visibility callbacks at
+  each side of the next cycle's start and completion joining only when uniquely
+  attributable and otherwise producing no trace projection or current-row mutation;
+  the same ambiguity remains fail-closed after the eleventh cycle prunes an old
+  record and sets `unknownPriorCycle`;
+- render-trace record/update reordering, one-impression enrichment, weaker-signal
+  non-regression, 200-entry pruning, stale attribution/DOM-field/badge removal,
+  navigation pruning of `current`, 32/33 subscriber boundaries and capacity reuse,
+  199/200/201 pending notification bounds, same-sequence coalescing, post-commit
+  asynchronous frozen subscription detail/timing, subscribe/unsubscribe races,
+  slow/throwing listeners, absence of `tsjs:adRendered`,
+  hidden/gam-only/ok truth, and cross-IIFE sequence order; private presentation
+  non-callable/reentrant/duplicate attachment, failed factory/malformed-controls/
+  missing-listener rollback and later retry, same-task initial snapshot before live
+  delivery, non-callable source listener before state checks, second-subscribe failure
+  preserving the first listener, unsubscribe/resubscribe and idempotent unsubscribe,
+  commit-during-next-task ordering, update coalescing, ignored return and thrown
+  callback, detach/owner-dispose exactly once, late scheduled callbacks, retained
+  empty `current`/`history`, rejected retained subscribe and inert unsubscribe/detach/
+  controls references, public 32-subscriber capacity unaffected, and overlay/export
+  failure that leaves the trace store and public subscribers live;
+- GPT diagnostics activation before/after early buffered callbacks, exact raw-event
+  replay, exact `tsjs.boot.diagnostics` schema, query/session enable-disable and
+  fail-closed inputs, accessor/prototype/unknown/missing/version rejection and
+  manifest-activation mismatch, active six-listener versus inactive correctness-listener counts,
+  exact `FirstDisplayGptFactV1` key/event/type/nullability rules, physical-token/
+  runtime-slot-number/ad-unit-path preservation, separate matched/unmatched/ambiguous
+  coverage disposition and nullable no-cycle/overlap/unknown-prior/invalid-order issue
+  reason, and byte-for-byte equivalent initial slot/cycle/coverage/issue export before
+  versus after takeover,
+  maximum-size 999/1,000/1,001-byte facts and 511/512/513 maximum-sized fact
+  admissions against the exact 512-entry FIFO, 512 KiB diagnostics subsection, and
+  8.5 MiB total caps, including eviction versus byte-cap drops and saturated
+  overflow/drop counters,
+  63/64/65 slots, 9/10/11 cycles, 127/128/129 issues,
+  32/33 public subscribers, 0/1/2-update latest-snapshot coalescing,
+  subscribe/unsubscribe/disposal races and slow/throwing listeners; requested-format
+  tuple validation/copy/freeze and 15/16/17 cap; simultaneous requested/GPT-fill/
+  outer-box evidence and distinct labels; initial measurement, missing
+  `ResizeObserver`, resize update, fractional/zero/invalid boxes, unchanged-value
+  deduplication, stale-cycle refresh, binding replacement/ambiguity/disconnection,
+  eviction/navigation/disposal; slot element replacement, timing/frozen-export bounds,
+  overlay disposal, inactive
+  zero-diagnostics-side-effect behavior, and diagnostics failure during live ads;
+- creative processing across sanitize/rewrite policy combinations and every delivery
+  path; exact default/explicit `CreativeBootV1` validation; automatic immediate and
+  `DOMContentLoaded` install; disabled and enabled-with-both-guards-false
+  zero-side-effect behavior; idempotent rescan;
+  exact-wrapper disposal; absence of mutable/install globals; opaque sandbox click
+  recovery; absolute HTTP(S), credentials, malformed and non-network schemes;
+  dynamic URLs; replaced elements; and redirect/browser navigation failure; and
+- every remaining integration alone and in the maximal manifest, including each
+  catalogued first-display/takeover/deferred split, parser-time interception when required,
+  missing globals, readiness/timeouts, malformed consent/storage, matcher false
+  positives, callback throws, startup failure, reverse-order disposal, and
+  cross-integration isolation; and
+- every protocol string/body limit at boundary-minus-one, boundary, and
+  boundary-plus-one UTF-8 bytes, including multibyte, duplicate-key, malformed
+  encoding, exact 1/4096 renderer dimension bounds across Rust/TS/ES5/PUC DOM,
+  and exact capability-form cases through both dispatcher and port parsers.
+
+### 7.3 Real-GAM pass criteria
+
+The checked-in test-network fixture and hermetic fakes use fictional ids and no
+production demand. Real network ids, GAM creative configuration, and secrets are
+injected by the protected CI/manual environment and never checked into this
+repository.
+Each required flow must demonstrate the expected DOM and lifecycle result, not an
+analytics row:
+
+- APS paths: one creative request, one bridge claim where applicable, one top mount
+  iframe, one APS runner load, one APS render-completion callback, one accepted
+  result, no duplicate render. The top mount, outer data container, inner renderer,
+  and descendant creative each have the exact winning viewport with zero default
+  margin, no clipping, and no overflow. An ensuing native publisher refresh retires
+  the accepted overlay at its physical `slotRequested` boundary and displays the new
+  GPT result unobscured without a second PUC settlement.
+- Empty GAM fallback: parent settles empty/failure before exactly one child render.
+- Direct ADM: exact owned iframe reaches one accepted result. Existing PBS Cache
+  fixtures retain their rc-baseline observable result without entering the new
+  APS/ADM owner protocol.
+- Failure fixtures: wrong id, invalid descriptor, missing claim, missing owner,
+  missing document acknowledgement, and runner failure each reach the specified
+  terminal reason within the specified timeout.
+- After SPA replacement, no old attempt mutates the current slot or targeting.
+- The initial page loads one same-origin first-display TSJS artifact. Network
+  evidence shows no persistent/deferred TSJS request/preload before
+  `tsjs:first-display-paint`; takeover transfers exact physical/ad ownership without
+  another display, and later refresh/navigation/diagnostics behavior joins the same
+  persistent runtime without replacing its GPT/Prebid adapter or lifecycle owners.
+
+The suite records browser console, network metadata, DOM, and GPT-event evidence as
+CI artifacts. Network capture excludes APS runner and creative response bodies so a
+test artifact cannot become an accidental vendor-code archive. It requires no
+external analytics, billing, or experiment result.
+
+## 8. Delivery and rollout
+
+This work is assembled through test-only constructors while being built, then cuts
+over once through the existing APS/TSJS release mechanism. No runtime flag,
+old/new selector, compatibility branch, or dual protocol is introduced in any
+deployable artifact.
+
+Operator configuration moves before the binary cutover. The rc baseline already
+accepts canonical APS `account_id` and `[creative_opportunities].enabled`, so both
+are validated and pushed as release prerequisites. The new binary requires the
+boolean and exposes no legacy alias or omitted-field compatibility path.
+
+1. **Integrate the release base:** fetch and integrate current `origin/rc/202608`, record its
+   exact SHA, run the unchanged affected Rust/TS/browser suites, and start every
+   retained `RCJ-*` row proof-pending. Identify or author its focused contract, run
+   that test against a detached otherwise-untouched worktree at the recorded SHA,
+   and record SHA/owner/test command/result. A passing contract is baseline-owned; a
+   behavioral failure is an implementation-gap; missing test coverage is a
+   coverage-gap that blocks production edits until the test is authored and run.
+   No row may remain proof-pending or coverage-gap at phase exit. Do not fetch,
+   merge, rebase, or cherry-pick retired `rc/july`.
+2. **Contract first:** land descriptor corpus, lifecycle types, adapter interfaces,
+   and failing tests without changing production behavior.
+3. **Kernel and release catalog:** introduce runtime/integration-module ownership,
+   sessions, capability broker, slot registry, auction batch, render lifecycle,
+   phase metadata, and production-versus-test composition boundaries behind
+   test-only construction.
+4. **Server APS path:** make admission, mediation, descriptor projection, targeting,
+   bootstrap route, publisher frame policy, and runner proxy conform to the contract.
+5. **First-display extraction:** preserve the two immutable intermediate captures,
+   build the server-composed first-display artifact plus authenticated post-paint
+   takeover, move persistent/later behavior out of its graph, and make inventory,
+   ownership, and production-metafile gates green. Record candidate evidence from
+   its exact clean pushed parent; all historical/intermediate deltas remain
+   report-only, and fresh-rc-baseline selected-agent transfer, independent absolute
+   size, paired end-to-end timing, and heap gates must be green before production
+   wiring.
+6. **Browser integrations:** migrate APS, GPT, Prebid, direct auction, fallback,
+   local diagnostics, creative processing, every remaining affected TSJS
+   integration, and bootstrap to the catalogued first-display/takeover/deferred
+   modules while rc-baseline regressions and retained `RCJ-*` gap contracts stay
+   green.
+7. **Delete legacy paths:** remove expandos, duplicate bridge branches, old
+   `requestAds`, legacy globals, duplicated bootstrap behavior, and unused flags
+   from the release candidate.
+8. **Pre-production:** refresh/integrate current `rc/202608` again, then pass all hermetic
+   suites and the protected real-GAM network
+   in Chromium, Firefox, and WebKit; archive its console, network, DOM, and GPT-event
+   evidence with the release artifact.
+9. **Binary production cutover:** deploy the verified artifact through the
+   repository's normal release mechanism. This design adds no percentage router or
+   canary-selection infrastructure. Hold an exclusive production deployment window,
+   attest the active immutable artifact, and re-check it immediately before cutover;
+   any mismatch blocks and regenerates evidence. Retain that immediately prior
+   artifact and roll back the whole cutover on renderer errors, elevated request
+   failures, CSP/security errors, or non-APS regressions.
+10. **Post-cutover:** monitor existing operational signals for 24 hours. The deployed
+    artifact already contains no temporary development selector.
+
+Binary rollback restores Trusted Server code but cannot restore older live APS runner
+bytes. If the proxied runner becomes unavailable, incompatible, or produces suspect
+completion results, the emergency containment action is to remove or disable every
+`[auction.providers.<id>]` instance whose `profile = "aps"` (or disable `[auction]`
+when auction-wide containment is intended). This stops new APS admission and makes
+both reserved APS routes return their local `404 no-store` response. APS remains
+disabled until controlled real-browser conformance passes again.
+
+This document does not prescribe new rollout telemetry. If existing operational
+signals are insufficient for a deployment decision, that blocks rollout and is
+resolved operationally or in a separate observability spec; it does not justify
+adding a hidden analytics subsystem here.
+
+## 9. Decisions and rejected alternatives
+
+1. **Patch only the current GPT bridge:** rejected; it leaves duplicated runtime
+   state, SPA races, direct-auction concurrency, and bootstrap ownership unresolved.
+2. **Full TSJS rewrite:** rejected; extract the kernel and migrate behavior in tested
+   slices so current contracts remain the oracle until cutover.
+3. **Use `slotRenderEnded` as render success:** rejected; it observes GAM creative
+   injection, not APS runner completion.
+4. **Use a bid id as the only bridge credential:** rejected; ids can collide, be
+   truncated, replayed, or arrive from a wrong frame.
+5. **Put the lifecycle nonce in `Prebid Request`:** impossible; Universal Creative
+   owns that message. The nonce is minted only after a validated claim.
+6. **Trust creative-document callbacks for ADM:** rejected; bidder-controlled
+   markup must not hold the acceptance capability. The TS-authored owner observes
+   its iframe.
+7. **Evict live reservations at capacity:** rejected; a late request could fall
+   through to native Prebid or claim the wrong work. Refuse new registration.
+8. **Abort a shared auction fetch when one slot is superseded:** rejected; sibling
+   attempts may still need the response.
+9. **Keep legacy globals/API aliases:** rejected; backward compatibility is not a
+   requirement and dual paths would preserve the architecture defect.
+10. **Add analytics or experiment infrastructure to prove rollout:** rejected as a
+    separate project. Rendering is proven by contract, browser, and real-GAM
+    conformance; release uses a pre-production gate and binary artifact rollback.
+11. **Check in or release a pinned APS runner:** rejected. Trusted Server owns only
+    the fixed-target transport proxy and renderer contract; APS owns the live runner
+    bytes.
+12. **Mount APS beneath Universal Creative or another third-party ancestor:**
+    rejected. An ancestor with navigation authority can replace an opaque child while
+    preserving its `WindowProxy`. PUC receives only settlement authority; the
+    top-page owner mounts the nested data renderer as an owned overlay child of the
+    exact slot service binding without traversing or hiding the PUC surface.
+13. **Vendor PUC, GPT, APS, or another upstream script for deterministic tests:**
+    rejected. Hermetic fixtures are independently authored protocol doubles and the
+    protected conformance suite exercises the named live external release.
+14. **Keep every enabled integration in one atomic boot barrier:** rejected. It makes
+    first display pay for refresh, later navigation, diagnostics UI, and optional
+    integrations that cannot affect that display. Atomicity remains mandatory for
+    the takeover transaction and for each deferred module's local transaction.
+15. **Download a monolith early and merely postpone its callbacks:** rejected. It
+    preserves transfer/parse contention and does not solve load time; deferred code
+    is a separately requested release-owned artifact after its trigger.
+16. **Let integrations dynamically import arbitrary modules or upstream scripts:**
+    rejected. Core alone inserts exact same-origin release artifacts. GPT, APS,
+    Prebid, PUC, and other upstream bytes remain live external dependencies and are
+    never vendored into TSJS source or output.
+17. **Give each deferred bundle its own runtime or service locator:** rejected. A
+    later module can join only the committed session through catalogued frozen
+    capabilities and cannot replace an owner.
+18. **Keep optimizing the 395 kB full-runtime first-display graph:** rejected by
+    measured evidence. Co-bundling removed duplicate emission but still produced a
+    4.57× p90 against the historical main reference; no credible local minification or shared-chunk
+    change closes that gap under the fixed network profile.
+19. **Create provider-specific independent mini-runtimes:** rejected. They reduce
+    bytes per path but multiply queue, adapter, message, slot, and fallback ownership.
+    The one bounded agent has a single exact transfer into the one persistent runtime.
+20. **Relax the 1.10× gate or accept the 220 kB mechanical ceiling:** rejected. The
+    automated paired gate is the user-visible load-time acceptance criterion; the
+    90 kB agent ceiling is an additional architecture guard, not permission to
+    self-baseline or waive the measured result.
+21. **Merge or cherry-pick retired `rc/july` to recover TSJS work:** rejected. The rc
+    baseline already contains most required behavior, often through later or squashed
+    implementations; importing the retired branch would add unrelated work and
+    create a second behavioral authority. The immutable snapshot is used only to
+    discover and test a specific missing concept.
+
+## 10. Risks and mitigations
+
+| Risk                                                               | Mitigation                                                                                                                                                                                                                                                                                                                                                    |
+| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| PUC behavior differs from the local contract harness               | keep the harness limited to the public message/helper contract, exercise `h.sendMessage`, and gate the actual externally hosted PUC release on real GAM; do not vendor PUC bytes                                                                                                                                                                              |
+| Same-realm publisher code can interfere                            | publisher-realm availability/DOM integrity is an explicit prerequisite; capability checks defend third-party frames, replays, and stale work, not arbitrary same-realm compromise                                                                                                                                                                             |
+| Third-party creative regains publisher-origin execution            | top-page mount inside the exact trusted slot binding, naturally opaque nested data documents, outer exact-origin `frame-src`, independent publisher `frame-ancestors 'self'`, and three-browser hostile-navigation fixtures                                                                                                                                   |
+| Rc merge silently drops a release-branch behavior                  | first-parent rc ancestry, explicit adoption ledger, conflict inventory, focused baseline-versus-candidate contracts, and full rc suites before feature work                                                                                                                                                                                                   |
+| Required template switch breaks an old omitted-field config        | intentional hard cutover; startup rejects omission, examples/fixtures/operators move atomically, and whole-release rollback restores the prior binary/config together                                                                                                                                                                                         |
+| Accepted APS overlay obscures later publisher GPT content          | bind the artifact to the exact physical object/host; retire it synchronously for publisher/competing/ambiguous `slotRequested`, after successful publisher destroy, or on exact DOM-integrity loss, while retaining it only for a provably TS-owned replacement until commit                                                                                  |
+| Late slot-size observation mutates a newer GPT cycle               | capture runtime-slot/request/element identity, revalidate exact latest filled cycle and live unique binding at commit, disconnect/unsubscribe on disposal, and keep evidence diagnostics-only                                                                                                                                                                 |
+| A module activation never returns                                  | activation is generated first-party code with boundary tests; elapsed returning calls fail through monotonic checks, but JavaScript cannot preempt a nonreturning same-thread function                                                                                                                                                                        |
+| Strict parsing rejects a future APS field                          | descriptor is versioned; outer transport remains tolerant; add a reviewed version/corpus update rather than silently accepting new semantics                                                                                                                                                                                                                  |
+| CSP blocks a legitimate APS creative                               | three-browser real-GAM suite; script creatives remain opt-in; CSP changes are explicit security work                                                                                                                                                                                                                                                          |
+| Hard cutover breaks stale pages                                    | accepted compatibility stance; a stale hash fails locally and reload is required; retain the prior deployable binary for whole-release rollback, not N/N-1 routes in the active binary                                                                                                                                                                        |
+| Kernel extraction changes unrelated integrations                   | per-integration pre/post behavior corpus, adapter fakes, current full suites, behavioral maximal-bundle test, and exact disposal assertions                                                                                                                                                                                                                   |
+| Optional code drifts back into the first-display artifact          | release-catalog phase/dependency validation, production metafile deny paths, semantic first-display budgets, and reviewable named parser-time obligations                                                                                                                                                                                                     |
+| Agent and persistent runtime overlap ownership                     | no runtime request before protected paint; effect-inert preparation; one non-yielding quiesce/adopt/commit transaction; exact disposer inventory; browser proof of zero duplicate display/listener/timer/port/wrapper                                                                                                                                         |
+| Takeover cannot reconstruct a live GPT slot safely                 | transfer the exact physical object only in the one-use closure-private capsule; validate generation/release and adopt without define/target/display; never serialize or publish that identity                                                                                                                                                                 |
+| Persistent takeover fails after a successful first display         | keep accepted DOM inert, reverse partial persistent effects, commit terminal fallback, and never replay the projection or resurrect the provisional agent                                                                                                                                                                                                     |
+| A deferred feature is called before its module is ready            | caller deadlines start at original enqueue and may expire while gated; after the paint gate, live waiters share one independently bounded module load with no duplicate/fallback/runtime                                                                                                                                                                      |
+| First display never occurs, so deferred work starves               | the owned 10-second post-kernel no-display guard becomes the trigger, followed by bounded idle scheduling or the owned timer fallback                                                                                                                                                                                                                         |
+| A page waits past 10 seconds before its first programmatic display | accepted explicit boundary on a no-agent page: correctness still uses persistent owners, but that display may contend with already released later work and is excluded from the protected-load claim                                                                                                                                                          |
+| A forged/replaced script registers into the runtime                | exact same-origin catalog URL, release/id/phase match, core-created element identity, `document.currentScript`, single terminal registration, and generation checks                                                                                                                                                                                           |
+| Publisher CSP or Trusted Types blocks a later module               | preserve publisher policy; copy only the authenticated parser-inserted nonce, use exact-manifest Trusted Types URLs, and fail to the defined takeover shell or isolated deferred `policy_blocked` state without another sink/runtime                                                                                                                          |
+| Phase splitting duplicates product ownership                       | one broker provider per capability, immutable interfaces, takeover-before-deferred dependency rule, agent capsule identity/disposal tests, and no public service locator                                                                                                                                                                                      |
+| Phase splitting reduces initial bytes but grows total release size | independent immutable maximal-total raw/gzip/Brotli budget and complete release inventory; splitting alone cannot make the gate pass                                                                                                                                                                                                                          |
+| One deferred module stalls unrelated later behavior                | start every independent deferred transaction after the common gate without awaiting siblings; separate deadlines and no deferred-to-deferred capability edges prevent head-of-line blocking                                                                                                                                                                   |
+| Retired `rc/july` is mistaken for an implementation source         | never fetch/merge/rebase/cherry-pick its head; validate only immutable `905984e62` as a concept checklist, map retained rows to rc-baseline owners/gaps, and fail the plan/lint if a release or performance gate names `rc/july`                                                                                                                              |
+| Diagnostics change ad behavior or overclaim a render               | bounded core-only snapshot ingress, separately bounded GPT fact replay, consumer-specific private presentation capability, isolated public subscribers, honest `gam-only`/`ok` rules, inactive zero-side-effect tests, and no correctness dependency                                                                                                          |
+| Bounded registries refuse traffic under extreme churn              | explicit reservation `registry_full` and slot `registry_capacity`, lifecycle pruning, capacity stress tests; never trade correctness for eviction                                                                                                                                                                                                             |
+| GPT event attribution remains ambiguous                            | adapter-minted non-reused physical-slot plus per-object cycle identity joins diagnostics only after exact current-slot and unique-cycle resolution; unresolved, stale, or multi-cycle-ambiguous facts are dropped, while lifecycle authority still fails the TS attempt deterministically and never triggers fallback from ambiguous/publisher-owned activity |
+| Late async work mutates new SPA state                              | generation checks, owned disposers, terminal latch, and adversarial reversed-order tests                                                                                                                                                                                                                                                                      |
+| Browser tests report iframe load but not APS success               | require the bound APS render-completion callback and inspect network/DOM evidence                                                                                                                                                                                                                                                                             |
+| APS runner becomes unavailable or stops the callback               | load/rejection/silence fail the attempt; real-browser conformance blocks release and APS disablement is the emergency containment path                                                                                                                                                                                                                        |
+| APS runner reports completion incorrectly                          | accepted external trust risk; protected conformance checks DOM/network behavior, but cannot prove future mutable bytes; suspect behavior disables APS                                                                                                                                                                                                         |
+| Existing operational signals are weak                              | do not invent telemetry in this spec; hold deployment or write a separate observability design                                                                                                                                                                                                                                                                |
+
+## 11. Success criteria
+
+The design is complete when all of the following are true:
+
+1. The five supported render flows have explicit owners, identity rules, deadlines,
+   and terminal behavior.
+2. APS descriptor production and all three validators agree on the full corpus.
+3. Mediation cannot detach price from provenance or attach the wrong renderer.
+4. GAM receives a valid, non-truncated identity for every accepted TS renderer bid.
+5. Duplicate, replayed, wrong-source, stale-navigation, and late lifecycle messages
+   cannot render or settle twice.
+6. Direct multi-slot auctions settle every requested slot and obey child-versus-batch
+   cancellation.
+7. The runtime has one slot registry, one bridge listener, one adapter instance per
+   external library, and one explicit owner for every timer/listener/port/iframe.
+8. Legacy expandos, duplicate bridge branches, old globals, old `requestAds`, and
+   duplicated bootstrap logic are absent from the final bundle. The `pub_id` config
+   alias, `/__ts/page-bids`, its JS retry, and the unversioned APS renderer path are
+   absent from server routes, tests, and documentation. Every bootstrap failure
+   checkpoint commits the terminal non-rendering shell, drains work exactly once,
+   and cannot construct or admit a second runtime.
+9. APS bootstrap and runner-proxy routing, security headers, bounded relay, and failure
+   behavior are proven through each real adapter transport, are equivalent across all
+   four adapters, and never fall through to publishers. APS runner bytes are neither
+   stored in the repository nor required to be identical across different upstream
+   fetches.
+10. Rust, TypeScript, ESLint, Vitest, hermetic Playwright, adapter parity, and
+    real-GAM conformance suites pass.
+11. Non-APS Cache/ADM rendering, native Prebid handling, publisher-owned GPT, refresh,
+    SRA, and SPA regression suites pass.
+12. No new analytics, persistence, billing, experimentation, or deployment-routing
+    artifact is added by the implementation plan; rc's existing optional GAM
+    attribution behavior is only preserved.
+13. `requestAds` accepts only exact server-projected or transactionally registered
+    programmatic slot ids, omitted selection is an immutable invocation-time
+    registration-order snapshot, and ambiguous internal aliases fail closed without
+    affecting valid siblings.
+14. Direct and PUC ADM acceptance is possible only for the exact current frame's one
+    intended `srcdoc` navigation; initial blank, replacement, removal, stale, late,
+    and duplicate events cannot accept.
+15. Every retained `RCJ-*` ledger entry finishes `baseline-owned` or demonstrated
+    `implementation-gap` with recorded rc-baseline SHA, owner paths, focused test
+    path/command/result, one final owner, and a preserved/rebuilt/superseded
+    disposition. No proof-pending or coverage-gap row crosses the phase boundary.
+    The historical manifest has no unmapped retired TSJS concept, but no retired
+    source participates in the build.
+16. Late GPT handoff, hydrated/ responsive DOM replacement, Prebid partial-artifact
+    recovery and refresh exclusions, creative security, render trace, GPT
+    diagnostics, and every remaining TSJS integration pass their complete parity
+    suites after the hard cutover.
+17. Top mount, outer data container, inner renderer, and descendant creative
+    dimensions are exact and unclipped for the winning size, while collapsed-shell correction cannot resize an
+    unrelated, anchor, fixed, sticky, disconnected, or already-expanded frame.
+18. Programmatic ad units register transactionally into the navigation slot service,
+    participate in deterministic direct-auction snapshots, and render through the
+    same lifecycle; placeholder rendering and mutable generic runtime configuration
+    are absent rather than silently retained as a second path.
+19. The committed `TsjsApi` kernel/fallback surfaces, semantic version, exact
+    release identity, queue, logger, immutable boot data, exact ordered integration-
+    config carrier, attenuated per-module config delivery, and diagnostics presence
+    are executable contracts; creative guards auto-install from `CreativeBootV1`
+    with no mutable/install global API or separate config transport.
+20. Attempt ids require no issued-id history, and reservation/ticket/bootstrap-
+    nonce/renderer-nonce registries refuse capacity or collision exhaustion without
+    exposing a reusable or cross-role capability.
+21. The external Prebid artifact remains free of TS auction/render behavior, exposes
+    only its exact own frozen 10.26.0 build stamp, and the TS-owned adapter admits a
+    fully prepared bid without partial publication.
+22. A page with an eligible server projection requests exactly one parser-blocking,
+    server-composed first-display artifact. The immutable batch remains agent-owned
+    through terminal settlement and paint, and the reference fixture requests,
+    preloads, prepares, and executes no persistent/deferred TSJS artifact before the
+    real `tsjs:first-display-paint` mark. The manifest URL hash names the exact
+    served agent bytes and stale or malformed hashes fail locally on every adapter.
+23. Agent/runtime absence, mismatch, timeout, preparation, or takeover failure
+    commits the terminal fallback without replaying or removing an accepted first
+    display. Protected paint seals new TS admission; the post-paint callback queue
+    drains exactly once against persistent or fallback, with exact
+    `initialDisplayCommitted` and no pending/retried work. A deferred module failure
+    leaves the same committed persistent kernel and owners alive and settles only
+    dependent work through its typed contract.
+24. No production-core import graph contains deferred integration/service/UI code,
+    no-op/fake/test seams, or `*ForTest` accessors. Every production artifact appears
+    exactly once in the release inventory, with the bootstrap role included once and
+    every TSJS module included in the maximal non-bootstrap total.
+25. The oversized role-correct and mechanical-remediation captures remain immutable
+    report-only evidence. Every generated size-admitted first-display mask, including the named
+    GPT-reference and APS masks, passes the 90,000/30,000/26,000 raw/gzip/Brotli
+    ceilings; all reachable masks are measured and any other closed configuration
+    selects direct persistent boot. Bootstrap, persistent reference, and the maximal
+    non-bootstrap total pass their independent §5.12 ceilings. The GPT candidate's
+    selected-agent transfer is no larger than a fresh rc-baseline selected agent in
+    each encoding, while the APS selected agent is no larger than that exact baseline
+    × 1.10. The aggregate inline-plus-agent transfer is recorded as diagnostic
+    context; the inline controller remains bound by its independent ceiling and the
+    paired timing gate covers the complete end-to-end pre-action path.
+    Boot-to-first-display passes the automatic fixed-network-profile
+    candidate-versus-rc-baseline timing gate, including the candidate's real-mark
+    and deferred-order assertions; the APS fixture passes every named
+    action/completion/paint and 3/3.75 MiB heap ceiling; rc-baseline and candidate
+    retained-heap results are recorded at the same four lifecycle checkpoints and
+    each remains within the 4 MiB hard ceiling. The baseline heap shape is
+    observability context, not a relative acceptance threshold for the hard-cutover
+    kernel and deferred runtime. No gate permits disabled shaping, selective sample reruns,
+    candidate self-baselining, or membership loopholes.
+    Handoff tests prove a final same-task data snapshot after static preparation,
+    monotonic high-water/cycle/trace transfer, one-use capsule, exact physical-slot
+    and committed-artifact adoption, zero repeated `display`/`refresh`/iframe insertion,
+    and no agent listener, timer, observer, port, wrapper, request authority, or
+    strong reference after the synchronous takeover boundary.
+26. A deferred module can register only from the exact current core-created local
+    release script and can obtain only catalogued frozen capabilities from the one
+    runtime. It cannot replace an adapter, slot registry, dispatcher, provider, or
+    runtime, including after navigation and failure races. Trusted Types and URL
+    failures detected synchronously before insertion isolate as `policy_blocked`;
+    nonce/source CSP rejection after insertion is `load_error`, and authenticated-
+    node loss is `registration_rejected` unless load failure wins. No policy failure
+    widens CSP or selects another execution sink.
+    All included deferred transactions begin independently after the shared gate, so
+    one module's ten-second deadline cannot delay or consume another's.
+27. GPT, APS runner, PUC, and other live upstream script bytes are absent from TSJS
+    source, TSJS generated artifacts, fixtures, and browser evidence. The separately
+    generated pure external Prebid artifact remains isolated under its §5.6 contract
+    and contains no TSJS behavior; Trusted Server's runtime bundles retain only owned
+    adapters, proxy/loading contracts, and lifecycle wrappers.
+28. The core diagnostics ingress admits and snapshots only the exact bounded data
+    tree, exposes no module subscription machinery, and becomes inert on owner
+    disposal. `trace.presentation.v1` is a separate consumer-specific capability
+    available only to deferred diagnostics presentation; attachment activation,
+    replay/live ordering, failure rollback, coalescing, detach, owner disposal, and
+    late callbacks cannot affect trace correctness or the 32-live-subscriber public
+    limits.
+29. Each physical GPT object receives one adapter-minted canonical trace token that
+    remains stable through handoff, is never reused within the runtime, and differs
+    across redefine/replacement even when publisher identifiers match. Each
+    unambiguous physical request admitted to trace projection receives a distinct
+    nonreused per-object cycle ordinal, and trace facts join only through that
+    compound identity; ambiguous requests are omitted fail-closed. Token/cycle mint,
+    ambiguity, collision, map capacity, retirement, late events, navigation, or
+    disposal failure can drop only diagnostic projection; it cannot conflate old/new
+    impressions or affect GPT behavior and the independently bounded object-identity
+    `gpt.events.v1` stream.
+30. The implementation branch and replacement PR use the recorded `rc/202608` base;
+    the final rc refresh, adoption ledger, conflict inventory, and focused contracts
+    prove that no overlapping release-branch behavior was silently lost.
+31. `[creative_opportunities].enabled` is required under the hard-cutover schema;
+    false disables only publisher/page-bids template delivery, direct `/auction`
+    remains functional, all configuration still validates, and inactive HTML gets
+    the exact guarded 60-second browser policy without changing surrogate policy.
+32. GPT diagnostics expose requested formats, GPT fill, and observed outer size as
+    separate copied/frozen fields and labels. Stale cycle, binding, navigation,
+    observer, or disposal callbacks cannot alter a newer cycle or ad behavior.
+33. Rc GAM attribution remains disabled by default and, when enabled, has exactly one
+    parser-time GPT owner that installs `ts=true` before publisher requests without
+    a raw-bootstrap flag, activation attribute, duplicate fallback, cleanup on
+    refresh/SPA, new telemetry, or effect while disabled.
+34. Direct and PUC APS mount only from the trusted top-page owner through the
+    bootstrap → outer data container → inner data renderer protocol. No GAM, PUC,
+    SafeFrame, bidder, or creative document is an ancestor; the exact-origin CSP and
+    publisher `frame-ancestors 'self'` proofs block publisher-origin regain in all
+    three browsers. Iframe creatives receive the narrow exact CSP pair; only an
+    explicitly enabled script creative adds its one validated creative origin to
+    `script-src` at both inherited levels.
+35. A no-agent runtime validates and prepares every takeover module synchronously,
+    activates parser-time guards and GAM attribution, and commits the one kernel in
+    the parser-blocking evaluation before publisher parsing resumes. Agent-page
+    takeover may prepare asynchronously only after protected paint and still adopts
+    those already-live first-display obligations without overlap.
+36. A committed PUC APS overlay retires exactly once before a publisher-owned,
+    competing, or ambiguous GPT cycle can expose new content, after successful
+    publisher destruction, or when its exact host/node binding is lost. A provably
+    TS-owned replacement retains the prior artifact until replacement commit, and no
+    retirement path destroys the publisher GPT object or repeats PUC settlement.
+
+## 12. Open implementation decisions
+
+These choices may be resolved in the implementation plan without changing the
+architecture:
+
+- exact source-file boundaries inside `kernel/`, `adapters/`, and `services/`;
+- whether the canonical descriptor schema is generated from Rust metadata or a
+  small neutral schema file, provided all validators share the corpus and staleness
+  check;
+- exact operational thresholds for the existing binary deployment mechanism.
+
+Rc-baseline authority; the retained `RCJ-*` concept-gap ledger membership and
+behavioral dispositions; the public diagnostics namespace; Prebid artifact
+independence; integration parity; the one-runtime rule; immutable budgets; and the
+first-display/takeover/deferred semantic boundaries are not open implementation
+decisions. The implementation plan must map every canonical release-catalog row
+above to exact rc-baseline source/build/test steps and preserve each concrete
+first-display, parser-time, or later-only obligation. It cannot add, remove, reorder,
+or reclassify modules opportunistically to make a budget pass, and it cannot merge or
+build retired `rc/july` source.
+
+They may not be resolved by adding compatibility shims, a second runtime, external
+telemetry requirements, durable persistence, experiment routing, or a weaker
+lifecycle success definition.
diff --git a/scripts/ci/aps-real-gam.sh b/scripts/ci/aps-real-gam.sh
new file mode 100755
index 000000000..1d01cf336
--- /dev/null
+++ b/scripts/ci/aps-real-gam.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repository_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+validate_inputs() {
+  test -n "${TS_REAL_GAM_PAGE_URL:-}"
+  test -n "${TS_REAL_GAM_AUTH_HEADER:-}"
+  test -n "${TS_REAL_GAM_EXPECTED_RELEASE_ID:-}"
+  test -n "${DISPATCH_RELEASE_ID:-}"
+  test "$DISPATCH_RELEASE_ID" = "$TS_REAL_GAM_EXPECTED_RELEASE_ID"
+  test -n "${DISPATCH_EVIDENCE_ID:-}"
+  test -n "${DISPATCH_PREVIOUS_ARTIFACT_ID:-}"
+}
+
+run_contract() {
+  cd "$repository_root/crates/trusted-server-integration-tests/browser"
+  npm exec -- playwright test \
+    --config=playwright.real-gam.config.ts \
+    tests/shared/aps-real-gam.spec.ts \
+    --project=chromium --project=firefox --project=webkit
+}
+
+case "${1:-}" in
+  validate-inputs)
+    validate_inputs
+    ;;
+  run)
+    run_contract
+    ;;
+  *)
+    printf 'usage: %s {validate-inputs|run}\n' "$0" >&2
+    exit 64
+    ;;
+esac
diff --git a/scripts/ci/aps-tsjs-cutover.sh b/scripts/ci/aps-tsjs-cutover.sh
new file mode 100755
index 000000000..9a4e78fd2
--- /dev/null
+++ b/scripts/ci/aps-tsjs-cutover.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repository_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+evidence_root="$repository_root/target/aps-tsjs-cutover-evidence"
+
+build_release() {
+  test -n "${EXPECTED_RELEASE_ID:-}"
+  mkdir -p "$evidence_root"
+  npm --prefix "$repository_root/crates/trusted-server-js/lib" ci
+  npm --prefix "$repository_root/crates/trusted-server-js/lib" run build
+  npm --prefix "$repository_root/crates/trusted-server-js/lib" run build:prebid-external
+  npm --prefix "$repository_root/crates/trusted-server-js/lib" run check:bundle \
+    2>&1 | tee "$evidence_root/bundle.log"
+  actual_release_id="$(npm --prefix "$repository_root/crates/trusted-server-js/lib" run --silent print:release-id)"
+  test "$actual_release_id" = "$EXPECTED_RELEASE_ID"
+  cp "$repository_root/crates/trusted-server-js/dist/tsjs-release-v1.json" "$evidence_root/"
+  cp "$repository_root/crates/trusted-server-js/dist/tsjs-build-metrics-v1.json" "$evidence_root/"
+}
+
+run_adapters() {
+  mkdir -p "$evidence_root"
+  cd "$repository_root"
+  cargo test \
+    --manifest-path crates/trusted-server-integration-tests/Cargo.toml \
+    --test parity 2>&1 | tee "$evidence_root/route-parity.log"
+  cargo test \
+    --manifest-path crates/trusted-server-integration-tests/Cargo.toml \
+    --target x86_64-unknown-linux-gnu \
+    -- --include-ignored \
+    --skip test_wordpress_fastly --skip test_nextjs_fastly \
+    --test-threads=1 2>&1 | tee "$evidence_root/integration.log"
+}
+
+install_browsers() {
+  cd "$repository_root/crates/trusted-server-integration-tests/browser"
+  npm ci
+  npx playwright install --with-deps chromium firefox webkit
+}
+
+run_browser_matrix() {
+  integration_artifacts="${ARTIFACTS_DIR:-$repository_root/target/integration-test-artifacts}"
+  mkdir -p "$evidence_root"
+  ARTIFACTS_DIR="$integration_artifacts" INTEGRATION_ENABLE_AUCTION=true \
+    "$repository_root/scripts/generate-integration-viceroy-configs.sh"
+  cd "$repository_root/crates/trusted-server-integration-tests/browser"
+  VICEROY_CONFIG_PATH="$integration_artifacts/configs/viceroy.toml" \
+    TS_BROWSER_PROJECTS=chromium,firefox,webkit \
+    npx playwright test \
+    tests/shared/aps-renderer.spec.ts \
+    tests/shared/aps-puc-lifecycle.spec.ts \
+    tests/shared/tsjs-runtime.spec.ts \
+    tests/shared/tsjs-policy.spec.ts \
+    tests/shared/creative-sandbox.spec.ts \
+    tests/nextjs/gpt-diagnostics.spec.ts \
+    tests/nextjs/navigation.spec.ts \
+    --project=chromium --project=firefox --project=webkit \
+    --reporter=list \
+    2>&1 | tee "$evidence_root/playwright-sanitized-report.log"
+}
+
+run_proxy_corpus() {
+  mkdir -p "$evidence_root"
+  cd "$repository_root"
+  for runtime in axum fastly cloudflare spin; do
+    ./scripts/integration-tests-aps-runner-proxy.sh --runtime "$runtime" \
+      2>&1 | tee "$evidence_root/aps-proxy-$runtime.log"
+  done
+}
+
+case "${1:-}" in
+  build-release)
+    build_release
+    ;;
+  run-adapters)
+    run_adapters
+    ;;
+  install-browsers)
+    install_browsers
+    ;;
+  run-browser)
+    run_browser_matrix
+    ;;
+  run-proxies)
+    run_proxy_corpus
+    ;;
+  *)
+    printf 'usage: %s {build-release|run-adapters|install-browsers|run-browser|run-proxies}\n' "$0" >&2
+    exit 64
+    ;;
+esac
diff --git a/scripts/ci/aps-tsjs-evidence.mjs b/scripts/ci/aps-tsjs-evidence.mjs
new file mode 100644
index 000000000..afddcf016
--- /dev/null
+++ b/scripts/ci/aps-tsjs-evidence.mjs
@@ -0,0 +1,419 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPOSITORY_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../..",
+);
+const FORBIDDEN_EXTENSIONS = new Set([".har", ".zip", ".webm"]);
+const FORBIDDEN_FIELD =
+  /"(?:accountId|aaxResponse|adm|authorization|capabilities?|creativeBody|descriptor|lifecycleTicket|nonce|postData|requestHeaders|responseBody|responseHeaders)"\s*:/u;
+const DOCUMENT_BODY = /<script(?:\s|>)|<!doctype/iu;
+
+function evidenceRoots(repositoryRoot) {
+  return {
+    quality: path.join(repositoryRoot, "target/aps-tsjs-quality-evidence"),
+    cutover: path.join(repositoryRoot, "target/aps-tsjs-cutover-evidence"),
+    realGam: path.join(
+      repositoryRoot,
+      "crates/trusted-server-integration-tests/browser",
+    ),
+  };
+}
+
+function requiredEnvironment(environment, name) {
+  const value = environment[name];
+  if (!value) throw new Error(`${name} must be nonempty`);
+  return value;
+}
+
+function writeManifest(file, manifest) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`, {
+    mode: 0o600,
+  });
+}
+
+function baseManifest(environment, conclusion) {
+  return {
+    schemaVersion: 1,
+    evidenceId: requiredEnvironment(environment, "EVIDENCE_ID"),
+    releaseId: requiredEnvironment(environment, "RELEASE_ID"),
+    commitSha: requiredEnvironment(environment, "GITHUB_SHA"),
+    runId: requiredEnvironment(environment, "GITHUB_RUN_ID"),
+    conclusion,
+  };
+}
+
+function walkFiles(root) {
+  if (!fs.existsSync(root)) return [];
+  const files = [];
+  const walk = (directory) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) walk(entryPath);
+      else files.push(entryPath);
+    }
+  };
+  walk(root);
+  return files;
+}
+
+function assertAllowedExtension(file) {
+  const extension = path.extname(file);
+  if (FORBIDDEN_EXTENSIONS.has(extension)) {
+    throw new Error(`native capture forbidden: ${file}`);
+  }
+}
+
+function writeQualityManifest(root, environment) {
+  writeManifest(
+    path.join(root, "evidence-manifest.json"),
+    baseManifest(environment, "success"),
+  );
+}
+
+function writeIntegrationManifest(root, environment) {
+  writeManifest(path.join(root, "evidence-manifest.json"), {
+    ...baseManifest(environment, "success"),
+    previousArtifactId: requiredEnvironment(
+      environment,
+      "PREVIOUS_ARTIFACT_ID",
+    ),
+  });
+}
+
+function writeRealGamManifest(root, environment) {
+  writeManifest(path.join(root, "real-gam-evidence/evidence-manifest.json"), {
+    ...baseManifest(
+      environment,
+      requiredEnvironment(environment, "TEST_OUTCOME"),
+    ),
+    previousArtifactId: requiredEnvironment(
+      environment,
+      "PREVIOUS_ARTIFACT_ID",
+    ),
+  });
+}
+
+function scrubIntegration(root, environment) {
+  const secret = requiredEnvironment(environment, "INTEGRATION_AUTHORIZATION");
+  for (const file of walkFiles(root)) {
+    assertAllowedExtension(file);
+    if (path.extname(file) === ".png") continue;
+    const text = fs.readFileSync(file, "utf8");
+    if (
+      text.includes(secret) ||
+      FORBIDDEN_FIELD.test(text) ||
+      DOCUMENT_BODY.test(text)
+    ) {
+      throw new Error(
+        `unsafe payload or capability found in evidence: ${file}`,
+      );
+    }
+  }
+}
+
+function scrubRealGam(realGamRoot, environment) {
+  const roots = ["real-gam-evidence", "playwright-report", "test-results"].map(
+    (directory) => path.join(realGamRoot, directory),
+  );
+  const secrets = [
+    requiredEnvironment(environment, "TS_REAL_GAM_PAGE_URL"),
+    requiredEnvironment(environment, "TS_REAL_GAM_AUTH_HEADER"),
+  ].map((secret) => Buffer.from(secret));
+  const files = roots.flatMap(walkFiles);
+
+  for (const file of files) {
+    assertAllowedExtension(file);
+    const body = fs.readFileSync(file);
+    if (secrets.some((secret) => body.includes(secret))) {
+      throw new Error(`protected value found in browser evidence: ${file}`);
+    }
+  }
+
+  const traces = files.filter((file) =>
+    file.endsWith("sanitized-trace-v1.json"),
+  );
+  for (const file of traces) {
+    const text = fs.readFileSync(file, "utf8");
+    if (FORBIDDEN_FIELD.test(text) || DOCUMENT_BODY.test(text)) {
+      throw new Error(
+        `unsafe field or body found in sanitized evidence: ${file}`,
+      );
+    }
+  }
+  if (
+    requiredEnvironment(environment, "TEST_OUTCOME") === "success" &&
+    traces.length !== 60
+  ) {
+    throw new Error(
+      "successful three-browser run must emit 60 sanitized case traces",
+    );
+  }
+}
+
+function exactManifestKeys(value, expected) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("real-GAM evidence manifest must be an object");
+  }
+  assert.deepEqual(
+    Object.keys(value).sort(),
+    [...expected].sort(),
+    "real-GAM evidence manifest schema must be exact",
+  );
+}
+
+export function validateRealGamArtifact(downloadRoot, expected) {
+  const evidenceRoot = path.join(downloadRoot, "real-gam-evidence");
+  const manifestPath = path.join(evidenceRoot, "evidence-manifest.json");
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  exactManifestKeys(manifest, [
+    "schemaVersion",
+    "evidenceId",
+    "releaseId",
+    "commitSha",
+    "runId",
+    "conclusion",
+    "previousArtifactId",
+  ]);
+  assert.equal(
+    manifest.schemaVersion,
+    1,
+    "real-GAM evidence schema must be v1",
+  );
+  assert.equal(
+    manifest.evidenceId,
+    expected.evidenceId,
+    "real-GAM evidence id must match",
+  );
+  assert.equal(
+    manifest.releaseId,
+    expected.releaseId,
+    "real-GAM release id must match",
+  );
+  assert.equal(
+    manifest.commitSha,
+    expected.commitSha,
+    "real-GAM commit must match",
+  );
+  assert.equal(
+    String(manifest.runId),
+    String(expected.runId),
+    "real-GAM run id must match",
+  );
+  assert.equal(
+    manifest.previousArtifactId,
+    expected.previousArtifactId,
+    "real-GAM rollback artifact must match",
+  );
+  assert.equal(
+    manifest.conclusion,
+    "success",
+    "real-GAM evidence requires a successful conclusion",
+  );
+
+  const files = walkFiles(downloadRoot);
+  for (const file of files) {
+    assertAllowedExtension(file);
+  }
+  const traces = walkFiles(evidenceRoot).filter((file) =>
+    file.endsWith("sanitized-trace-v1.json"),
+  );
+  for (const file of traces) {
+    const text = fs.readFileSync(file, "utf8");
+    if (FORBIDDEN_FIELD.test(text) || DOCUMENT_BODY.test(text)) {
+      throw new Error(
+        `unsafe field or body found in sanitized evidence: ${file}`,
+      );
+    }
+  }
+  assert.equal(
+    traces.length,
+    60,
+    "successful real-GAM evidence must contain 60 traces",
+  );
+  return manifest;
+}
+
+function execute(
+  command,
+  repositoryRoot = REPOSITORY_ROOT,
+  environment = process.env,
+) {
+  const roots = evidenceRoots(repositoryRoot);
+  const commands = new Map([
+    ["write-quality", () => writeQualityManifest(roots.quality, environment)],
+    [
+      "write-integration",
+      () => writeIntegrationManifest(roots.cutover, environment),
+    ],
+    ["write-real-gam", () => writeRealGamManifest(roots.realGam, environment)],
+    ["scrub-integration", () => scrubIntegration(roots.cutover, environment)],
+    ["scrub-real-gam", () => scrubRealGam(roots.realGam, environment)],
+  ]);
+  const operation = commands.get(command);
+  if (!operation) return false;
+  operation();
+  return true;
+}
+
+function selfTest() {
+  const repositoryRoot = fs.mkdtempSync(
+    path.join(os.tmpdir(), "aps-tsjs-evidence-"),
+  );
+  const environment = {
+    EVIDENCE_ID: "aps-tsjs-self-test",
+    RELEASE_ID: "release-self-test",
+    PREVIOUS_ARTIFACT_ID: "previous-self-test",
+    GITHUB_SHA: "0123456789abcdef0123456789abcdef01234567",
+    GITHUB_RUN_ID: "12345",
+    INTEGRATION_AUTHORIZATION: "integration-self-test-secret",
+    TEST_OUTCOME: "success",
+    TS_REAL_GAM_PAGE_URL: "https://real-gam.invalid/test",
+    TS_REAL_GAM_AUTH_HEADER: "real-gam-self-test-secret",
+  };
+
+  try {
+    execute("write-quality", repositoryRoot, environment);
+    execute("write-integration", repositoryRoot, environment);
+    execute("write-real-gam", repositoryRoot, environment);
+    const roots = evidenceRoots(repositoryRoot);
+    const quality = JSON.parse(
+      fs.readFileSync(
+        path.join(roots.quality, "evidence-manifest.json"),
+        "utf8",
+      ),
+    );
+    const integration = JSON.parse(
+      fs.readFileSync(
+        path.join(roots.cutover, "evidence-manifest.json"),
+        "utf8",
+      ),
+    );
+    assert.deepEqual(quality, {
+      schemaVersion: 1,
+      evidenceId: environment.EVIDENCE_ID,
+      releaseId: environment.RELEASE_ID,
+      commitSha: environment.GITHUB_SHA,
+      runId: environment.GITHUB_RUN_ID,
+      conclusion: "success",
+    });
+    assert.equal(
+      integration.previousArtifactId,
+      environment.PREVIOUS_ARTIFACT_ID,
+    );
+
+    fs.writeFileSync(path.join(roots.cutover, "safe.log"), "safe evidence\n");
+    execute("scrub-integration", repositoryRoot, environment);
+    fs.writeFileSync(
+      path.join(roots.cutover, "unsafe.log"),
+      '{"descriptor":"secret"}\n',
+    );
+    assert.throws(
+      () => execute("scrub-integration", repositoryRoot, environment),
+      /unsafe payload or capability/u,
+    );
+    fs.rmSync(path.join(roots.cutover, "unsafe.log"));
+    fs.writeFileSync(
+      path.join(roots.cutover, "capture.har"),
+      "native capture\n",
+    );
+    assert.throws(
+      () => execute("scrub-integration", repositoryRoot, environment),
+      /native capture forbidden/u,
+    );
+
+    const traceRoot = path.join(roots.realGam, "real-gam-evidence");
+    for (let index = 0; index < 60; index += 1) {
+      fs.writeFileSync(
+        path.join(traceRoot, `case-${index}-sanitized-trace-v1.json`),
+        "{}\n",
+      );
+    }
+    execute("scrub-real-gam", repositoryRoot, environment);
+    const expectedRealGam = {
+      evidenceId: environment.EVIDENCE_ID,
+      releaseId: environment.RELEASE_ID,
+      commitSha: environment.GITHUB_SHA,
+      runId: environment.GITHUB_RUN_ID,
+      previousArtifactId: environment.PREVIOUS_ARTIFACT_ID,
+    };
+    const reportRoot = path.join(roots.realGam, "playwright-report");
+    fs.mkdirSync(reportRoot, { recursive: true });
+    fs.writeFileSync(
+      path.join(reportRoot, "index.html"),
+      "<!doctype html><script>window.__playwrightReport = true;</script>\n",
+    );
+    validateRealGamArtifact(roots.realGam, expectedRealGam);
+    const manifestPath = path.join(traceRoot, "evidence-manifest.json");
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    fs.writeFileSync(
+      manifestPath,
+      `${JSON.stringify({ ...manifest, conclusion: "failure" })}\n`,
+    );
+    assert.throws(
+      () => validateRealGamArtifact(roots.realGam, expectedRealGam),
+      /successful conclusion/u,
+    );
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`);
+    fs.writeFileSync(
+      path.join(traceRoot, "secret.txt"),
+      environment.TS_REAL_GAM_AUTH_HEADER,
+    );
+    assert.throws(
+      () => execute("scrub-real-gam", repositoryRoot, environment),
+      /protected value found/u,
+    );
+    fs.rmSync(path.join(traceRoot, "secret.txt"));
+    fs.rmSync(path.join(traceRoot, "case-59-sanitized-trace-v1.json"));
+    assert.throws(
+      () => execute("scrub-real-gam", repositoryRoot, environment),
+      /must emit 60 sanitized case traces/u,
+    );
+  } finally {
+    fs.rmSync(repositoryRoot, { recursive: true, force: true });
+  }
+  process.stdout.write("APS/TSJS evidence self-test passed\n");
+}
+
+const command = process.argv[2];
+if (command === "self-test") selfTest();
+else if (command === "validate-real-gam") {
+  const [
+    downloadRoot,
+    evidenceId,
+    releaseId,
+    commitSha,
+    runId,
+    previousArtifactId,
+  ] = process.argv.slice(3);
+  if (
+    !downloadRoot ||
+    !evidenceId ||
+    !releaseId ||
+    !/^[0-9a-f]{40}$/u.test(commitSha ?? "") ||
+    !/^[1-9][0-9]*$/u.test(runId ?? "") ||
+    !previousArtifactId ||
+    process.argv.length !== 9
+  ) {
+    throw new Error(
+      "usage: aps-tsjs-evidence.mjs validate-real-gam <download-root> <evidence-id> <release-id> <commit-sha> <run-id> <previous-artifact-id>",
+    );
+  }
+  validateRealGamArtifact(downloadRoot, {
+    evidenceId,
+    releaseId,
+    commitSha,
+    runId,
+    previousArtifactId,
+  });
+  process.stdout.write("APS real-GAM evidence is valid\n");
+} else if (!execute(command)) {
+  throw new Error(
+    "usage: aps-tsjs-evidence.mjs {write-quality|write-integration|write-real-gam|scrub-integration|scrub-real-gam|validate-real-gam|self-test}",
+  );
+}
diff --git a/scripts/ci/aps-tsjs-quality.sh b/scripts/ci/aps-tsjs-quality.sh
new file mode 100755
index 000000000..813a4c6a9
--- /dev/null
+++ b/scripts/ci/aps-tsjs-quality.sh
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repository_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+evidence_root="$repository_root/target/aps-tsjs-quality-evidence"
+
+install_dependencies() {
+  npm --prefix "$repository_root/crates/trusted-server-js/lib" ci
+  npm --prefix "$repository_root/docs" ci
+}
+
+run_quality_gates() {
+  test -n "${EXPECTED_RELEASE_ID:-}"
+  mkdir -p "$evidence_root"
+
+  {
+    cd "$repository_root"
+    cargo fmt --all -- --check
+    npm --prefix crates/trusted-server-js/lib run format
+    npm --prefix docs run format
+    cargo clippy-fastly
+    cargo clippy-axum
+    cargo clippy-cloudflare
+    cargo clippy-cloudflare-wasm
+    cargo clippy-spin-native
+    cargo clippy-spin-wasm
+    cargo clippy --manifest-path crates/trusted-server-integration-tests/Cargo.toml --all-targets -- -D warnings
+    npm --prefix crates/trusted-server-js/lib run build
+    npm --prefix crates/trusted-server-js/lib run build:prebid-external
+    npm --prefix crates/trusted-server-js/lib run check:aps-contract
+    npm --prefix crates/trusted-server-js/lib run check:hard-cutover-absence
+    npm --prefix crates/trusted-server-js/lib run check:bundle
+    npm --prefix crates/trusted-server-js/lib run check:concept-audit
+    npm --prefix docs run lint
+    npm --prefix docs run build
+    actual_release_id="$(npm --prefix crates/trusted-server-js/lib run --silent print:release-id)"
+    test "$actual_release_id" = "$EXPECTED_RELEASE_ID"
+  } 2>&1 | tee "$evidence_root/quality.log"
+
+  cp "$repository_root/crates/trusted-server-js/dist/tsjs-release-v1.json" "$evidence_root/"
+  cp "$repository_root/crates/trusted-server-js/dist/tsjs-build-metrics-v1.json" "$evidence_root/"
+}
+
+run_contract_tests() {
+  cd "$repository_root"
+  node --test scripts/ci/dispatch-aps-tsjs-gate.test.mjs
+  node scripts/ci/aps-tsjs-evidence.mjs self-test
+  node scripts/validate-tsjs-performance-evidence.mjs --self-test
+}
+
+case "${1:-}" in
+  install)
+    install_dependencies
+    ;;
+  run)
+    run_quality_gates
+    ;;
+  contracts)
+    run_contract_tests
+    ;;
+  *)
+    printf 'usage: %s {install|run|contracts}\n' "$0" >&2
+    exit 64
+    ;;
+esac
diff --git a/scripts/ci/dispatch-aps-tsjs-gate.mjs b/scripts/ci/dispatch-aps-tsjs-gate.mjs
new file mode 100644
index 000000000..b29e2303e
--- /dev/null
+++ b/scripts/ci/dispatch-aps-tsjs-gate.mjs
@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const SHA_PATTERN = /^[0-9a-f]{40}$/u;
+const RELEASE_PATTERN = /^[0-9a-f]{64}$/u;
+const TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/u;
+const RUN_LIST_FIELDS = "databaseId,displayTitle,headSha,createdAt";
+const WORKFLOWS = Object.freeze({
+  performance: ".github/workflows/tsjs-performance-gate.yml",
+  "real-gam": ".github/workflows/aps-real-gam.yml",
+});
+
+function fail(message) {
+  throw new Error(`APS/TSJS dispatch refused: ${message}`);
+}
+
+function exactSha(value, label) {
+  if (!SHA_PATTERN.test(value ?? ""))
+    fail(`${label} must be 40 lowercase hex characters`);
+  return value;
+}
+
+function exactToken(value, label) {
+  if (!TOKEN_PATTERN.test(value ?? "")) fail(`${label} is invalid`);
+  return value;
+}
+
+function exactRef(value) {
+  if (
+    !REF_PATTERN.test(value ?? "") ||
+    value.includes("..") ||
+    value.includes("//") ||
+    value.endsWith("/") ||
+    value.endsWith(".lock")
+  ) {
+    fail("ref is invalid");
+  }
+  return value;
+}
+
+function defaultRunner(command, args, options = {}) {
+  return execFileSync(command, args, {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    ...options,
+  });
+}
+
+function defaultSleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export function createEvidenceId({ kind, mode, headSha, now, randomSuffix }) {
+  if (kind !== "performance" && kind !== "real-gam")
+    fail("gate kind is invalid");
+  exactSha(headSha, "head SHA");
+  if (!(now instanceof Date) || !Number.isFinite(now.valueOf()))
+    fail("dispatch time is invalid");
+  if (!/^[0-9a-f]{8}$/u.test(randomSuffix ?? ""))
+    fail("random suffix is invalid");
+  const timestamp = now
+    .toISOString()
+    .replace(/[-:]/gu, "")
+    .replace(/\.\d{3}Z$/u, "Z");
+  const phase = kind === "performance" ? exactToken(mode, "mode") : "cutover";
+  const evidenceId = `aps-tsjs-${kind}-${phase}-${headSha.slice(0, 12)}-${timestamp}-${randomSuffix}`;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/u.test(evidenceId)) {
+    fail("generated evidence id is invalid");
+  }
+  return evidenceId;
+}
+
+function workflowRun(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return undefined;
+  if (
+    !Number.isSafeInteger(value.databaseId) ||
+    value.databaseId < 1 ||
+    typeof value.displayTitle !== "string" ||
+    typeof value.headSha !== "string" ||
+    typeof value.createdAt !== "string"
+  ) {
+    return undefined;
+  }
+  return value;
+}
+
+export function selectUniqueWorkflowRun(runs, expected) {
+  if (!Array.isArray(runs)) fail("GitHub run list must be an array");
+  const matches = runs
+    .map(workflowRun)
+    .filter(
+      (run) =>
+        run !== undefined &&
+        run.headSha === expected.headSha &&
+        run.displayTitle === expected.displayTitle,
+    );
+  if (matches.length > 1)
+    fail("multiple workflow runs match the exact dispatch");
+  const match = matches[0];
+  if (!match) return undefined;
+  const createdAt = new Date(match.createdAt);
+  if (
+    !Number.isFinite(createdAt.valueOf()) ||
+    createdAt.valueOf() < expected.dispatchStartedAt.valueOf()
+  ) {
+    fail("stale workflow run predates the dispatch");
+  }
+  return match;
+}
+
+async function runCommand(runner, command, args, options) {
+  const output = await runner(command, args, options);
+  if (typeof output !== "string") fail(`${command} returned non-text output`);
+  return output;
+}
+
+async function resolveLocalAndRemoteHead(ref, runner) {
+  const status = await runCommand(runner, "git", [
+    "status",
+    "--porcelain=v1",
+    "--untracked-files=all",
+  ]);
+  if (status !== "") fail("worktree must be clean before dispatch");
+  const headSha = exactSha(
+    (await runCommand(runner, "git", ["rev-parse", "HEAD"])).trim(),
+    "local HEAD",
+  );
+  const remote = (
+    await runCommand(runner, "git", [
+      "ls-remote",
+      "--heads",
+      "origin",
+      `refs/heads/${ref}`,
+    ])
+  ).trim();
+  const rows = remote === "" ? [] : remote.split("\n");
+  if (rows.length !== 1) fail("remote branch must resolve exactly once");
+  const [remoteSha, remoteRef, ...extra] = rows[0].split(/\s+/u);
+  if (
+    extra.length !== 0 ||
+    remoteRef !== `refs/heads/${ref}` ||
+    remoteSha !== headSha
+  ) {
+    fail("remote branch must resolve to local HEAD");
+  }
+  return headSha;
+}
+
+async function waitForWorkflowRun({
+  workflow,
+  ref,
+  evidenceId,
+  headSha,
+  displayTitle,
+  dispatchStartedAt,
+  runner,
+  sleep,
+}) {
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    const raw = await runCommand(runner, "gh", [
+      "run",
+      "list",
+      "--workflow",
+      workflow,
+      "--branch",
+      ref,
+      "--event",
+      "workflow_dispatch",
+      "--limit",
+      "100",
+      "--json",
+      RUN_LIST_FIELDS,
+    ]);
+    let runs;
+    try {
+      runs = JSON.parse(raw);
+    } catch {
+      fail("GitHub run list returned invalid JSON");
+    }
+    const match = selectUniqueWorkflowRun(runs, {
+      evidenceId,
+      headSha,
+      displayTitle,
+      dispatchStartedAt,
+    });
+    if (match) return match;
+    if (attempt < 29) await sleep(2_000);
+  }
+  fail("zero workflow runs matched the exact dispatch");
+}
+
+export async function dispatchGate(input, dependencies = {}) {
+  const runner = dependencies.runner ?? defaultRunner;
+  const now = dependencies.now ?? (() => new Date());
+  const randomSuffix =
+    dependencies.randomSuffix ?? (() => randomBytes(4).toString("hex"));
+  const sleep = dependencies.sleep ?? defaultSleep;
+  const pathExists = dependencies.pathExists ?? existsSync;
+  const kind = input.kind;
+  const workflow = WORKFLOWS[kind];
+  if (!workflow) fail("gate kind is invalid");
+  const ref = exactRef(input.ref);
+  const outputDir = input.outputDir;
+  if (typeof outputDir !== "string" || outputDir.length === 0)
+    fail("output directory is required");
+  if (pathExists(outputDir)) fail("output directory must not already exist");
+
+  let mode;
+  let baseSha;
+  let previousArtifactId;
+  if (kind === "performance") {
+    mode = input.mode;
+    if (mode !== "preswitch" && mode !== "postswitch")
+      fail("performance mode is invalid");
+    baseSha = exactSha(input.baseSha, "base SHA");
+  } else {
+    previousArtifactId = exactToken(
+      input.previousArtifactId,
+      "previous artifact id",
+    );
+  }
+
+  const headSha = await resolveLocalAndRemoteHead(ref, runner);
+  let releaseId;
+  if (kind === "real-gam") {
+    releaseId = (
+      await runCommand(runner, "npm", [
+        "--prefix",
+        "crates/trusted-server-js/lib",
+        "run",
+        "--silent",
+        "print:release-id",
+      ])
+    ).trim();
+    if (!RELEASE_PATTERN.test(releaseId))
+      fail("generated release id is invalid");
+  }
+
+  const observedDispatchTime = now();
+  if (
+    !(observedDispatchTime instanceof Date) ||
+    !Number.isFinite(observedDispatchTime.valueOf())
+  ) {
+    fail("dispatch time is invalid");
+  }
+  const dispatchStartedAt = new Date(
+    Math.floor(observedDispatchTime.valueOf() / 1_000) * 1_000,
+  );
+  const evidenceId = createEvidenceId({
+    kind,
+    mode,
+    headSha,
+    now: dispatchStartedAt,
+    randomSuffix: randomSuffix(),
+  });
+  const displayTitle =
+    kind === "performance"
+      ? `TSJS Performance Gate / ${evidenceId} / ${mode}`
+      : `APS real-GAM / ${evidenceId} / ${releaseId}`;
+  const fields =
+    kind === "performance"
+      ? [
+          "-f",
+          `evidence_id=${evidenceId}`,
+          "-f",
+          `mode=${mode}`,
+          "-f",
+          `base_sha=${baseSha}`,
+        ]
+      : [
+          "-f",
+          `evidence_id=${evidenceId}`,
+          "-f",
+          `release_id=${releaseId}`,
+          "-f",
+          `previous_artifact_id=${previousArtifactId}`,
+        ];
+  await runCommand(runner, "gh", [
+    "workflow",
+    "run",
+    workflow,
+    "--ref",
+    ref,
+    ...fields,
+  ]);
+  const run = await waitForWorkflowRun({
+    workflow,
+    ref,
+    evidenceId,
+    headSha,
+    displayTitle,
+    dispatchStartedAt,
+    runner,
+    sleep,
+  });
+  const runId = run.databaseId;
+  await runCommand(runner, "gh", [
+    "run",
+    "watch",
+    String(runId),
+    "--exit-status",
+  ]);
+  const artifactName =
+    kind === "performance"
+      ? `tsjs-performance-${evidenceId}`
+      : `aps-real-gam-${runId}`;
+  await runCommand(runner, "gh", [
+    "run",
+    "download",
+    String(runId),
+    "--name",
+    artifactName,
+    "--dir",
+    outputDir,
+  ]);
+
+  if (kind === "performance") {
+    await runCommand(runner, "node", [
+      "scripts/validate-tsjs-performance-evidence.mjs",
+      "--file",
+      `${outputDir}/tsjs-performance-${mode}.json`,
+      "--evidence-id",
+      evidenceId,
+      "--head-sha",
+      headSha,
+      "--base-sha",
+      baseSha,
+      "--mode",
+      mode,
+    ]);
+  } else {
+    await runCommand(runner, "node", [
+      "scripts/ci/aps-tsjs-evidence.mjs",
+      "validate-real-gam",
+      outputDir,
+      evidenceId,
+      releaseId,
+      headSha,
+      String(runId),
+      previousArtifactId,
+    ]);
+  }
+  return { evidenceId, headSha, runId };
+}
+
+function parseCli(argv) {
+  const kind = argv[0];
+  if (kind !== "performance" && kind !== "real-gam")
+    fail("first argument must be performance or real-gam");
+  const values = new Map();
+  for (let index = 1; index < argv.length; index += 2) {
+    const name = argv[index];
+    const value = argv[index + 1];
+    if (!name?.startsWith("--") || value === undefined || values.has(name))
+      fail("invalid CLI arguments");
+    values.set(name, value);
+  }
+  const allowed =
+    kind === "performance"
+      ? new Set(["--ref", "--base-sha", "--mode", "--output-dir"])
+      : new Set(["--ref", "--previous-artifact-id", "--output-dir"]);
+  if (
+    values.size !== allowed.size ||
+    [...values.keys()].some((name) => !allowed.has(name))
+  ) {
+    fail("missing or unknown CLI arguments");
+  }
+  return kind === "performance"
+    ? {
+        kind,
+        ref: values.get("--ref"),
+        baseSha: values.get("--base-sha"),
+        mode: values.get("--mode"),
+        outputDir: values.get("--output-dir"),
+      }
+    : {
+        kind,
+        ref: values.get("--ref"),
+        previousArtifactId: values.get("--previous-artifact-id"),
+        outputDir: values.get("--output-dir"),
+      };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  try {
+    const result = await dispatchGate(parseCli(process.argv.slice(2)));
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  } catch (error) {
+    process.stderr.write(
+      `${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    process.exitCode = 1;
+  }
+}
diff --git a/scripts/ci/dispatch-aps-tsjs-gate.test.mjs b/scripts/ci/dispatch-aps-tsjs-gate.test.mjs
new file mode 100644
index 000000000..1e1d57da0
--- /dev/null
+++ b/scripts/ci/dispatch-aps-tsjs-gate.test.mjs
@@ -0,0 +1,340 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createEvidenceId,
+  dispatchGate,
+  selectUniqueWorkflowRun,
+} from "./dispatch-aps-tsjs-gate.mjs";
+
+const HEAD = "a".repeat(40);
+const BASE = "b".repeat(40);
+const START = new Date("2026-08-20T12:00:00.000Z");
+
+function fakeRunner(responses) {
+  const calls = [];
+  return {
+    calls,
+    async run(command, args, options = {}) {
+      calls.push({ command, args, options });
+      const key = [command, ...args].join(" ");
+      const response = responses.get(key);
+      if (response instanceof Error) throw response;
+      if (response === undefined) return "";
+      return typeof response === "function" ? response(calls) : response;
+    },
+  };
+}
+
+test("evidence ids bind gate, mode, head, UTC time, and random suffix", () => {
+  const first = createEvidenceId({
+    kind: "performance",
+    mode: "postswitch",
+    headSha: HEAD,
+    now: START,
+    randomSuffix: "0123abcd",
+  });
+  const second = createEvidenceId({
+    kind: "performance",
+    mode: "postswitch",
+    headSha: HEAD,
+    now: START,
+    randomSuffix: "fedcba98",
+  });
+  assert.equal(
+    first,
+    "aps-tsjs-performance-postswitch-aaaaaaaaaaaa-20260820T120000Z-0123abcd",
+  );
+  assert.notEqual(first, second);
+  assert.match(first, /^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/u);
+});
+
+test("run selection rejects stale, ambiguous, and wrong-head evidence", () => {
+  const expected = {
+    evidenceId:
+      "aps-tsjs-performance-postswitch-aaaaaaaaaaaa-20260820T120000Z-0123abcd",
+    headSha: HEAD,
+    displayTitle:
+      "TSJS Performance Gate / aps-tsjs-performance-postswitch-aaaaaaaaaaaa-20260820T120000Z-0123abcd / postswitch",
+    dispatchStartedAt: START,
+  };
+  assert.equal(
+    selectUniqueWorkflowRun(
+      [
+        {
+          databaseId: 1,
+          displayTitle: "unrelated",
+          headSha: HEAD,
+          createdAt: START.toISOString(),
+        },
+      ],
+      expected,
+    ),
+    undefined,
+  );
+  assert.equal(
+    selectUniqueWorkflowRun(
+      [
+        {
+          databaseId: 2,
+          displayTitle: expected.displayTitle,
+          headSha: BASE,
+          createdAt: START.toISOString(),
+        },
+      ],
+      expected,
+    ),
+    undefined,
+  );
+  assert.equal(
+    selectUniqueWorkflowRun(
+      [
+        {
+          databaseId: 22,
+          displayTitle: `${expected.displayTitle}-not-exact`,
+          headSha: HEAD,
+          createdAt: START.toISOString(),
+        },
+      ],
+      expected,
+    ),
+    undefined,
+  );
+  assert.throws(
+    () =>
+      selectUniqueWorkflowRun(
+        [
+          {
+            databaseId: 3,
+            displayTitle: expected.displayTitle,
+            headSha: HEAD,
+            createdAt: "2026-08-20T11:59:59.999Z",
+          },
+        ],
+        expected,
+      ),
+    /stale/u,
+  );
+  assert.throws(
+    () =>
+      selectUniqueWorkflowRun(
+        [4, 5].map((databaseId) => ({
+          databaseId,
+          displayTitle: expected.displayTitle,
+          headSha: HEAD,
+          createdAt: START.toISOString(),
+        })),
+        expected,
+      ),
+    /multiple/u,
+  );
+});
+
+test("performance dispatch binds the remote head, exact base, artifact, and validator", async () => {
+  const ref = "feature/aps-tsjs-resilience-rc202608";
+  const evidenceId =
+    "aps-tsjs-performance-postswitch-aaaaaaaaaaaa-20260820T120000Z-0123abcd";
+  const run = {
+    databaseId: 42,
+    displayTitle: `TSJS Performance Gate / ${evidenceId} / postswitch`,
+    headSha: HEAD,
+    createdAt: START.toISOString(),
+  };
+  const runner = fakeRunner(
+    new Map([
+      ["git status --porcelain=v1 --untracked-files=all", ""],
+      ["git rev-parse HEAD", `${HEAD}\n`],
+      [
+        `git ls-remote --heads origin refs/heads/${ref}`,
+        `${HEAD}\trefs/heads/${ref}\n`,
+      ],
+      [
+        "gh run list --workflow .github/workflows/tsjs-performance-gate.yml --branch feature/aps-tsjs-resilience-rc202608 --event workflow_dispatch --limit 100 --json databaseId,displayTitle,headSha,createdAt",
+        JSON.stringify([run]),
+      ],
+    ]),
+  );
+
+  const result = await dispatchGate(
+    {
+      kind: "performance",
+      ref,
+      baseSha: BASE,
+      mode: "postswitch",
+      outputDir: "target/performance-evidence",
+    },
+    {
+      runner: runner.run,
+      now: () => new Date("2026-08-20T12:00:00.999Z"),
+      randomSuffix: () => "0123abcd",
+      sleep: async () => {},
+      pathExists: () => false,
+    },
+  );
+
+  assert.deepEqual(result, { evidenceId, headSha: HEAD, runId: 42 });
+  const commands = runner.calls.map(({ command, args }) => [command, ...args]);
+  assert.ok(
+    commands.some(
+      (command) =>
+        command.join(" ") ===
+        `gh workflow run .github/workflows/tsjs-performance-gate.yml --ref ${ref} -f evidence_id=${evidenceId} -f mode=postswitch -f base_sha=${BASE}`,
+    ),
+  );
+  assert.ok(
+    commands.some(
+      (command) =>
+        command.join(" ") ===
+        `gh run download 42 --name tsjs-performance-${evidenceId} --dir target/performance-evidence`,
+    ),
+  );
+  assert.ok(
+    commands.some(
+      (command) =>
+        command.join(" ") ===
+        `node scripts/validate-tsjs-performance-evidence.mjs --file target/performance-evidence/tsjs-performance-postswitch.json --evidence-id ${evidenceId} --head-sha ${HEAD} --base-sha ${BASE} --mode postswitch`,
+    ),
+  );
+});
+
+test("remote-head mismatch fails before any workflow dispatch", async () => {
+  const ref = "feature/aps-tsjs-resilience-rc202608";
+  const runner = fakeRunner(
+    new Map([
+      ["git status --porcelain=v1 --untracked-files=all", ""],
+      ["git rev-parse HEAD", `${HEAD}\n`],
+      [
+        `git ls-remote --heads origin refs/heads/${ref}`,
+        `${BASE}\trefs/heads/${ref}\n`,
+      ],
+    ]),
+  );
+  await assert.rejects(
+    dispatchGate(
+      {
+        kind: "performance",
+        ref,
+        baseSha: BASE,
+        mode: "postswitch",
+        outputDir: "target/performance-evidence",
+      },
+      { runner: runner.run, pathExists: () => false },
+    ),
+    /remote branch must resolve to local HEAD/u,
+  );
+  assert.equal(
+    runner.calls.some(({ command }) => command === "gh"),
+    false,
+  );
+});
+
+test("zero matching workflow runs are rejected after bounded polling", async () => {
+  const ref = "feature/aps-tsjs-resilience-rc202608";
+  const runner = fakeRunner(
+    new Map([
+      ["git status --porcelain=v1 --untracked-files=all", ""],
+      ["git rev-parse HEAD", `${HEAD}\n`],
+      [
+        `git ls-remote --heads origin refs/heads/${ref}`,
+        `${HEAD}\trefs/heads/${ref}\n`,
+      ],
+      [
+        "gh run list --workflow .github/workflows/tsjs-performance-gate.yml --branch feature/aps-tsjs-resilience-rc202608 --event workflow_dispatch --limit 100 --json databaseId,displayTitle,headSha,createdAt",
+        "[]",
+      ],
+    ]),
+  );
+  await assert.rejects(
+    dispatchGate(
+      {
+        kind: "performance",
+        ref,
+        baseSha: BASE,
+        mode: "postswitch",
+        outputDir: "target/performance-evidence",
+      },
+      {
+        runner: runner.run,
+        now: () => START,
+        randomSuffix: () => "0123abcd",
+        sleep: async () => {},
+        pathExists: () => false,
+      },
+    ),
+    /zero workflow runs/u,
+  );
+  assert.equal(
+    runner.calls.filter(
+      ({ command, args }) =>
+        command === "gh" && args[0] === "run" && args[1] === "list",
+    ).length,
+    30,
+  );
+});
+
+test("real-GAM dispatch derives release id and validates the exact run artifact", async () => {
+  const ref = "feature/aps-tsjs-resilience-rc202608";
+  const releaseId = "c".repeat(64);
+  const previousArtifactId = "rollback-artifact-123";
+  const evidenceId =
+    "aps-tsjs-real-gam-cutover-aaaaaaaaaaaa-20260820T120000Z-0123abcd";
+  const runner = fakeRunner(
+    new Map([
+      ["git status --porcelain=v1 --untracked-files=all", ""],
+      ["git rev-parse HEAD", `${HEAD}\n`],
+      [
+        `git ls-remote --heads origin refs/heads/${ref}`,
+        `${HEAD}\trefs/heads/${ref}\n`,
+      ],
+      [
+        "npm --prefix crates/trusted-server-js/lib run --silent print:release-id",
+        `${releaseId}\n`,
+      ],
+      [
+        "gh run list --workflow .github/workflows/aps-real-gam.yml --branch feature/aps-tsjs-resilience-rc202608 --event workflow_dispatch --limit 100 --json databaseId,displayTitle,headSha,createdAt",
+        JSON.stringify([
+          {
+            databaseId: 77,
+            displayTitle: `APS real-GAM / ${evidenceId} / ${releaseId}`,
+            headSha: HEAD,
+            createdAt: START.toISOString(),
+          },
+        ]),
+      ],
+    ]),
+  );
+
+  await dispatchGate(
+    {
+      kind: "real-gam",
+      ref,
+      previousArtifactId,
+      outputDir: "target/real-gam-evidence",
+    },
+    {
+      runner: runner.run,
+      now: () => START,
+      randomSuffix: () => "0123abcd",
+      sleep: async () => {},
+      pathExists: () => false,
+    },
+  );
+  const commands = runner.calls.map(({ command, args }) =>
+    [command, ...args].join(" "),
+  );
+  assert.ok(
+    commands.includes(
+      `gh workflow run .github/workflows/aps-real-gam.yml --ref ${ref} -f evidence_id=${evidenceId} -f release_id=${releaseId} -f previous_artifact_id=${previousArtifactId}`,
+    ),
+  );
+  assert.ok(
+    commands.includes(
+      "gh run download 77 --name aps-real-gam-77 --dir target/real-gam-evidence",
+    ),
+  );
+  assert.ok(
+    commands.includes(
+      `node scripts/ci/aps-tsjs-evidence.mjs validate-real-gam target/real-gam-evidence ${evidenceId} ${releaseId} ${HEAD} 77 ${previousArtifactId}`,
+    ),
+  );
+});
diff --git a/scripts/ci/read-toolchains.sh b/scripts/ci/read-toolchains.sh
new file mode 100755
index 000000000..3b42edb22
--- /dev/null
+++ b/scripts/ci/read-toolchains.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repository_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+tool_versions="$repository_root/.tool-versions"
+
+node_version="$(awk '$1 == "nodejs" { print $2 }' "$tool_versions")"
+rust_version="$(awk '$1 == "rust" { print $2 }' "$tool_versions")"
+
+test -n "$node_version"
+test -n "$rust_version"
+test -n "${GITHUB_OUTPUT:-}"
+
+printf 'node=%s\n' "$node_version" >> "$GITHUB_OUTPUT"
+printf 'rust=%s\n' "$rust_version" >> "$GITHUB_OUTPUT"
diff --git a/scripts/ci/tsjs-performance.sh b/scripts/ci/tsjs-performance.sh
new file mode 100755
index 000000000..4475c4cbb
--- /dev/null
+++ b/scripts/ci/tsjs-performance.sh
@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+repository_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+read_tool_version() {
+  awk -v tool="$1" '$1 == tool { print $2 }' "$repository_root/.tool-versions"
+}
+
+validate_inputs() {
+  case "${TSJS_PERF_MODE:-}" in
+    preswitch | postswitch | pull-request) ;;
+    *) return 1 ;;
+  esac
+  [[ "${TSJS_EVIDENCE_ID:-}" =~ ^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$ ]]
+  [[ "${TSJS_PERF_HEAD_SHA:-}" =~ ^[0-9a-f]{40}$ ]]
+  [[ "${TSJS_PERF_BASE_SHA:-}" =~ ^[0-9a-f]{40}$ ]]
+  test "$(git -C "$repository_root" rev-parse HEAD)" = "$TSJS_PERF_HEAD_SHA"
+}
+
+verify_toolchains() {
+  node_version="$(read_tool_version nodejs)"
+  rust_version="$(read_tool_version rust)"
+  test -n "$node_version"
+  test -n "$rust_version"
+  test "$(node --version)" = "v$node_version"
+  test "$(npm --version)" = "11.6.2"
+  test "$(rustc --version | awk '{ print $2 }')" = "$rust_version"
+}
+
+build_candidate() {
+  cd "$repository_root/crates/trusted-server-js/lib"
+  npm ci
+  npm run build
+  npm run check:bundle
+  node "$repository_root/scripts/validate-tsjs-performance-evidence.mjs" --self-test
+}
+
+build_baseline() {
+  test -n "${RUNNER_TEMP:-}"
+  test -n "${GITHUB_ENV:-}"
+  base_sha="${TSJS_PERF_BASE_SHA:-}"
+  [[ "$base_sha" =~ ^[0-9a-f]{40}$ ]]
+  cd "$repository_root"
+  git fetch origin refs/heads/rc/202608:refs/remotes/origin/rc/202608
+  test "$(git cat-file -t "$base_sha")" = commit
+  git merge-base --is-ancestor "$base_sha" origin/rc/202608
+  baseline_root="$RUNNER_TEMP/tsjs-performance-baseline"
+  test ! -e "$baseline_root"
+  git worktree add --detach "$baseline_root" "$base_sha"
+  npm --prefix "$baseline_root/crates/trusted-server-js/lib" ci
+  npm --prefix "$baseline_root/crates/trusted-server-js/lib" run build
+  printf 'TSJS_PERF_BASE_SHA=%s\n' "$base_sha" >> "$GITHUB_ENV"
+  printf 'TSJS_PERF_BASE_ROOT=%s\n' "$baseline_root" >> "$GITHUB_ENV"
+}
+
+install_browser() {
+  cd "$repository_root/crates/trusted-server-integration-tests/browser"
+  npm ci
+  playwright_version="$(node --print 'require("@playwright/test/package.json").version')"
+  test "$playwright_version" = "1.58.2"
+  npx playwright install --with-deps chromium
+}
+
+run_sample() {
+  cd "$repository_root/crates/trusted-server-integration-tests/browser"
+  npx playwright test \
+    tests/shared/tsjs-performance.spec.ts \
+    --config="$repository_root/crates/trusted-server-integration-tests/browser/playwright.performance.config.ts" \
+    --project=chromium \
+    --workers=1
+}
+
+validate_evidence() {
+  test -n "${TSJS_PERF_OUTPUT:-}"
+  test -n "${TSJS_EVIDENCE_ID:-}"
+  test -n "${TSJS_PERF_HEAD_SHA:-}"
+  test -n "${TSJS_PERF_BASE_SHA:-}"
+  test -n "${TSJS_PERF_MODE:-}"
+  node "$repository_root/scripts/validate-tsjs-performance-evidence.mjs" \
+    --file "$TSJS_PERF_OUTPUT" \
+    --evidence-id "$TSJS_EVIDENCE_ID" \
+    --head-sha "$TSJS_PERF_HEAD_SHA" \
+    --base-sha "$TSJS_PERF_BASE_SHA" \
+    --mode "$TSJS_PERF_MODE"
+}
+
+case "${1:-}" in
+  validate-inputs)
+    validate_inputs
+    ;;
+  verify-toolchains)
+    verify_toolchains
+    ;;
+  build-candidate)
+    build_candidate
+    ;;
+  build-baseline)
+    build_baseline
+    ;;
+  install-browser)
+    install_browser
+    ;;
+  run-sample)
+    run_sample
+    ;;
+  validate-evidence)
+    validate_evidence
+    ;;
+  *)
+    printf 'usage: %s {validate-inputs|verify-toolchains|build-candidate|build-baseline|install-browser|run-sample|validate-evidence}\n' "$0" >&2
+    exit 64
+    ;;
+esac
diff --git a/scripts/dispatch-workflow-run.mjs b/scripts/dispatch-workflow-run.mjs
new file mode 100644
index 000000000..871d907e0
--- /dev/null
+++ b/scripts/dispatch-workflow-run.mjs
@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+
+const POLL_INTERVAL_MS = 2_000;
+const POLL_TIMEOUT_MS = 120_000;
+
+function fail(message) {
+  throw new Error(`[dispatch-workflow-run] ${message}`);
+}
+
+function run(command, args, options = {}) {
+  try {
+    return execFileSync(command, args, {
+      cwd: options.cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    const stderr =
+      error && typeof error === "object" && "stderr" in error
+        ? error.stderr
+        : "";
+    fail(
+      `${command} ${args.join(" ")} failed${stderr ? `: ${String(stderr).trim()}` : ""}`,
+    );
+  }
+}
+
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function parseInputs(argumentsList) {
+  const inputs = new Map();
+  for (const argument of argumentsList) {
+    const separator = argument.indexOf("=");
+    if (separator <= 0)
+      fail(`workflow input must use key=value syntax: ${argument}`);
+    const key = argument.slice(0, separator);
+    const value = argument.slice(separator + 1);
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key) || value.length === 0) {
+      fail(`invalid workflow input: ${argument}`);
+    }
+    if (inputs.has(key)) fail(`duplicate workflow input: ${key}`);
+    inputs.set(key, value);
+  }
+  return inputs;
+}
+
+function remoteShaForRef(ref) {
+  const escapedRef = ref.replace(/^refs\/(heads|tags)\//, "");
+  const output = run("git", [
+    "ls-remote",
+    "--heads",
+    "--tags",
+    "origin",
+    `refs/heads/${escapedRef}`,
+    `refs/tags/${escapedRef}`,
+    `refs/tags/${escapedRef}^{}`,
+  ]);
+  const rows = output
+    .split("\n")
+    .filter(Boolean)
+    .map((row) => row.split(/\s+/, 2));
+  if (rows.length === 0) fail(`ref is not pushed to origin: ${ref}`);
+  const dereferencedTag = rows.find(([, remoteRef]) =>
+    remoteRef?.endsWith("^{}"),
+  );
+  return (dereferencedTag ?? rows[0])?.[0];
+}
+
+function listRuns(workflow) {
+  const output = run("gh", [
+    "run",
+    "list",
+    "--workflow",
+    workflow,
+    "--event",
+    "workflow_dispatch",
+    "--limit",
+    "100",
+    "--json",
+    "databaseId,displayTitle,headBranch,headSha,createdAt",
+  ]);
+  try {
+    return JSON.parse(output);
+  } catch (error) {
+    fail(
+      `gh returned invalid run JSON: ${error instanceof Error ? error.message : error}`,
+    );
+  }
+}
+
+function matchingRuns(runs, evidenceId, sha, dispatchedAfter) {
+  return runs.filter((candidate) => {
+    const createdAt = Date.parse(candidate.createdAt);
+    return (
+      candidate.headSha === sha &&
+      candidate.displayTitle?.includes(evidenceId) &&
+      Number.isFinite(createdAt) &&
+      createdAt >= dispatchedAfter
+    );
+  });
+}
+
+async function main() {
+  const [workflow, ref, ...inputArguments] = process.argv.slice(2);
+  if (!workflow || !ref) {
+    fail(
+      "usage: dispatch-workflow-run.mjs <workflow> <pushed-ref> key=value [...]",
+    );
+  }
+  const inputs = parseInputs(inputArguments);
+  const evidenceId = inputs.get("evidence_id");
+  if (!evidenceId) fail("required workflow input is missing: evidence_id");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/.test(evidenceId)) {
+    fail("evidence_id must be 8-128 URL-safe characters");
+  }
+
+  const localSha = run("git", ["rev-parse", `${ref}^{commit}`]);
+  const remoteSha = remoteShaForRef(ref);
+  if (localSha !== remoteSha) {
+    fail(
+      `ref is not pushed at the local commit: local ${localSha}, origin ${remoteSha}`,
+    );
+  }
+
+  const existing = listRuns(workflow).filter((runRecord) =>
+    runRecord.displayTitle?.includes(evidenceId),
+  );
+  if (existing.length > 0)
+    fail(`evidence_id has already been used: ${evidenceId}`);
+
+  const dispatchedAfter = Date.now() - 5_000;
+  const dispatchArguments = ["workflow", "run", workflow, "--ref", ref];
+  for (const [key, value] of inputs)
+    dispatchArguments.push("-f", `${key}=${value}`);
+  run("gh", dispatchArguments);
+
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const matches = matchingRuns(
+      listRuns(workflow),
+      evidenceId,
+      localSha,
+      dispatchedAfter,
+    );
+    if (matches.length > 1)
+      fail(`more than one workflow run matched evidence_id ${evidenceId}`);
+    if (matches.length === 1) {
+      const runId = matches[0].databaseId;
+      if (!Number.isSafeInteger(runId) || runId <= 0)
+        fail("matched run has an invalid numeric id");
+      process.stdout.write(`${runId}\n`);
+      return;
+    }
+    await sleep(POLL_INTERVAL_MS);
+  }
+  fail(`timed out waiting for workflow run with evidence_id ${evidenceId}`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
+  process.exitCode = 1;
+});
diff --git a/scripts/generate-aps-renderer-contract.mjs b/scripts/generate-aps-renderer-contract.mjs
new file mode 100644
index 000000000..ef68974c9
--- /dev/null
+++ b/scripts/generate-aps-renderer-contract.mjs
@@ -0,0 +1,506 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repositoryRoot = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const fixtureRoot = path.join(
+  repositoryRoot,
+  "crates/trusted-server-js/lib/test/fixtures",
+);
+const schemaPath = path.join(fixtureRoot, "aps-renderer-v1.schema.json");
+const corpusPath = path.join(fixtureRoot, "aps-renderer-v1-corpus.json");
+const es5Path = path.join(
+  repositoryRoot,
+  "crates/trusted-server-core/src/integrations/generated/aps_renderer_validator_v1.js",
+);
+const bootstrapPath = path.join(
+  repositoryRoot,
+  "crates/trusted-server-core/src/integrations/generated/aps_renderer_bootstrap_v2.html",
+);
+const typescriptPath = path.join(
+  repositoryRoot,
+  "crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_v1.ts",
+);
+const documentValidatorPath = path.join(
+  repositoryRoot,
+  "crates/trusted-server-js/lib/src/core/contracts/generated/renderer_validator_document_v1.ts",
+);
+const documentsSourcePath = path.join(
+  repositoryRoot,
+  "crates/trusted-server-js/lib/src/shared/aps_documents.ts",
+);
+
+const [schemaText, corpusText, documentsSource] = await Promise.all([
+  readFile(schemaPath, "utf8"),
+  readFile(corpusPath, "utf8"),
+  readFile(documentsSourcePath, "utf8"),
+]);
+const schema = JSON.parse(schemaText);
+const corpus = JSON.parse(corpusText);
+
+function invariant(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+invariant(
+  schema?.properties?.type?.const === "aps",
+  "schema type should be aps",
+);
+invariant(
+  schema?.properties?.version?.const === 1,
+  "schema version should be 1",
+);
+invariant(
+  schema?.properties?.width?.minimum === 1 &&
+    schema?.properties?.height?.minimum === 1,
+  "schema minimum dimensions should be 1",
+);
+invariant(
+  schema?.properties?.width?.maximum === 4096 &&
+    schema?.properties?.height?.maximum === 4096,
+  "schema maximum dimensions should be 4096",
+);
+invariant(
+  schema?.properties?.aaxResponse?.["x-decodedMaxBytes"] === 262144,
+  "schema decoded AAX limit should be 256 KiB",
+);
+invariant(corpus?.schemaVersion === 1, "corpus schema version should be 1");
+invariant(
+  Array.isArray(corpus?.vectors) && corpus.vectors.length > 0,
+  "corpus should have vectors",
+);
+for (const result of [
+  "accepted",
+  "descriptor_invalid",
+  "invalid_dimensions",
+  "dimensions_out_of_range",
+]) {
+  invariant(
+    corpus.vectors.some((vector) => vector.expected === result),
+    "corpus should exercise " + result,
+  );
+}
+
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const schemaHash = sha256(schemaText);
+const corpusHash = sha256(corpusText);
+const generatedHeader =
+  "// @generated by scripts/generate-aps-renderer-contract.mjs\n" +
+  "// schema-sha256: " +
+  schemaHash +
+  "\n" +
+  "// corpus-sha256: " +
+  corpusHash +
+  "\n";
+
+const requiredKeys = [...schema.required].sort();
+const optionalKeys = Object.keys(schema.properties)
+  .filter((key) => !schema.required.includes(key))
+  .sort();
+invariant(
+  optionalKeys.length === 1 && optionalKeys[0] === "creativeId",
+  "creativeId should be the only optional descriptor key",
+);
+
+const constantsSource =
+  "var DESCRIPTOR_KEYS = " +
+  JSON.stringify(requiredKeys) +
+  ";\n" +
+  "var DESCRIPTOR_KEYS_WITH_CREATIVE_ID = " +
+  JSON.stringify([...requiredKeys, "creativeId"].sort()) +
+  ";\n" +
+  "var ENVELOPE_ROOT_KEYS = " +
+  JSON.stringify([...schema["x-envelope"].rootKeys].sort()) +
+  ";\n" +
+  "var ENVELOPE_SEAT_KEYS = " +
+  JSON.stringify([...schema["x-envelope"].seatKeys].sort()) +
+  ";\n" +
+  "var ENVELOPE_BID_KEYS = " +
+  JSON.stringify([...schema["x-envelope"].bidKeys].sort()) +
+  ";\n" +
+  "var ENVELOPE_EXT_KEYS = " +
+  JSON.stringify([...schema["x-envelope"].extKeys].sort()) +
+  ";\n" +
+  "var MAX_ACCOUNT_ID_BYTES = " +
+  schema.properties.accountId["x-utf8MaxBytes"] +
+  ";\n" +
+  "var MAX_BID_ID_BYTES = " +
+  schema.properties.bidId["x-utf8MaxBytes"] +
+  ";\n" +
+  "var MAX_CREATIVE_ID_BYTES = " +
+  schema.properties.creativeId["x-utf8MaxBytes"] +
+  ";\n" +
+  "var MAX_CREATIVE_URL_BYTES = " +
+  schema.properties.creativeUrl["x-utf8MaxBytes"] +
+  ";\n" +
+  "var MAX_RENDER_ENVELOPE_BYTES = " +
+  schema.properties.aaxResponse["x-decodedMaxBytes"] +
+  ";\n" +
+  "var MAX_RENDER_ENVELOPE_BASE64_BYTES = " +
+  4 * Math.ceil(schema.properties.aaxResponse["x-decodedMaxBytes"] / 3) +
+  ";\n" +
+  "var STANDARD_BASE64_PATTERN = " +
+  JSON.stringify(schema.properties.aaxResponse.pattern) +
+  ";\n";
+
+const validatorSource = String.raw`
+function apsExactRecord(value/*: any*/, expectedKeys/*: string[]*/)/*: boolean*/ {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  var prototype/*: any*/ = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  if (typeof Object.getOwnPropertySymbols === 'function' && Object.getOwnPropertySymbols(value).length !== 0) return false;
+  var actual/*: string[]*/ = Object.getOwnPropertyNames(value).sort();
+  if (actual.length !== expectedKeys.length) return false;
+  for (var index = 0; index < actual.length; index += 1) {
+    var propertyName/*: string | undefined*/ = actual[index];
+    if (propertyName === undefined || propertyName !== expectedKeys[index]) return false;
+    var property/*: any*/ = Object.getOwnPropertyDescriptor(value, propertyName);
+    if (!property || !Object.prototype.hasOwnProperty.call(property, 'value')) return false;
+  }
+  return true;
+}
+
+function apsUtf8Length(value/*: string*/)/*: number*/ {
+  return (new TextEncoder()).encode(value).length;
+}
+
+function apsHasAsciiControl(value/*: string*/)/*: boolean*/ {
+  return /[\x00-\x1f\x7f]/.test(value);
+}
+
+function apsDimensionResult(value/*: any*/)/*: ApsRendererValidationResult*/ {
+  if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value || value <= 0) {
+    return 'invalid_dimensions';
+  }
+  if (value < RENDER_DIMENSION_MIN || value > RENDER_DIMENSION_MAX) {
+    return 'dimensions_out_of_range';
+  }
+  return 'accepted';
+}
+
+function apsValidCreativeUrl(value/*: string*/, publisherOrigin/*: string*/)/*: boolean*/ {
+  try {
+    var url/*: URL*/ = new URL(value);
+    return url.protocol === 'https:' && url.hostname !== '' && url.username === '' &&
+      url.password === '' && url.origin !== publisherOrigin;
+  } catch (_error) {
+    return false;
+  }
+}
+
+function apsDecodeEnvelope(value/*: string*/)/*: any | undefined*/ {
+  if (value.length === 0 || value.length > MAX_RENDER_ENVELOPE_BASE64_BYTES ||
+      value.length % 4 !== 0 || !(new RegExp(STANDARD_BASE64_PATTERN)).test(value)) {
+    return undefined;
+  }
+  try {
+    var binary/*: string*/ = atob(value);
+    if (binary.length > MAX_RENDER_ENVELOPE_BYTES || btoa(binary) !== value) return undefined;
+    var bytes/*: Uint8Array*/ = new Uint8Array(binary.length);
+    for (var index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+  } catch (_error) {
+    return undefined;
+  }
+}
+
+/*EXPORT_DESCRIPTOR_CLASSIFIER*/ function classifyApsRendererDescriptorV1(
+  value/*: unknown*/
+)/*: ApsRendererValidationResult*/ {
+  var renderer/*: any*/ = value;
+  if (!apsExactRecord(renderer, DESCRIPTOR_KEYS) &&
+      !apsExactRecord(renderer, DESCRIPTOR_KEYS_WITH_CREATIVE_ID)) return 'descriptor_invalid';
+  if (renderer.type !== 'aps' || renderer.version !== 1 ||
+      typeof renderer.accountId !== 'string' || renderer.accountId.length === 0 ||
+      apsUtf8Length(renderer.accountId) > MAX_ACCOUNT_ID_BYTES ||
+      typeof renderer.bidId !== 'string' || renderer.bidId.length === 0 ||
+      apsUtf8Length(renderer.bidId) > MAX_BID_ID_BYTES ||
+      apsHasAsciiControl(renderer.bidId)) return 'descriptor_invalid';
+  if (Object.prototype.hasOwnProperty.call(renderer, 'creativeId') &&
+      (typeof renderer.creativeId !== 'string' || renderer.creativeId.length === 0 ||
+       apsUtf8Length(renderer.creativeId) > MAX_CREATIVE_ID_BYTES)) return 'descriptor_invalid';
+  if (renderer.tagType !== 'iframe' && renderer.tagType !== 'script') return 'descriptor_invalid';
+
+  var widthResult/*: ApsRendererValidationResult*/ = apsDimensionResult(renderer.width);
+  if (widthResult !== 'accepted') return widthResult;
+  var heightResult/*: ApsRendererValidationResult*/ = apsDimensionResult(renderer.height);
+  if (heightResult !== 'accepted') return heightResult;
+
+  if (typeof renderer.creativeUrl !== 'string' ||
+      apsUtf8Length(renderer.creativeUrl) > MAX_CREATIVE_URL_BYTES ||
+      typeof renderer.aaxResponse !== 'string' ||
+      renderer.aaxResponse.length > MAX_RENDER_ENVELOPE_BASE64_BYTES) return 'descriptor_invalid';
+  return 'accepted';
+}
+
+/*EXPORT_CLASSIFIER*/ function classifyApsRendererV1(
+  value/*: unknown*/,
+  publisherOrigin/*: string*/
+)/*: ApsRendererValidationResult*/ {
+  var renderer/*: any*/ = value;
+  var descriptorResult/*: ApsRendererValidationResult*/ =
+    classifyApsRendererDescriptorV1(renderer);
+  if (descriptorResult !== 'accepted') return descriptorResult;
+  if (!apsValidCreativeUrl(renderer.creativeUrl, publisherOrigin)) return 'descriptor_invalid';
+
+  var decoded/*: any*/ = apsDecodeEnvelope(renderer.aaxResponse);
+  if (!apsExactRecord(decoded, ENVELOPE_ROOT_KEYS) || !Array.isArray(decoded.seatbid) ||
+      decoded.seatbid.length !== 1) return 'descriptor_invalid';
+  var seat/*: any*/ = decoded.seatbid[0];
+  if (!apsExactRecord(seat, ENVELOPE_SEAT_KEYS) || !Array.isArray(seat.bid) ||
+      seat.bid.length !== 1) return 'descriptor_invalid';
+  var bid/*: any*/ = seat.bid[0];
+  if (!apsExactRecord(bid, ENVELOPE_BID_KEYS) ||
+      !apsExactRecord(bid.ext, ENVELOPE_EXT_KEYS)) return 'descriptor_invalid';
+
+  var bidWidthResult/*: ApsRendererValidationResult*/ = apsDimensionResult(bid.w);
+  if (bidWidthResult !== 'accepted') return bidWidthResult;
+  var bidHeightResult/*: ApsRendererValidationResult*/ = apsDimensionResult(bid.h);
+  if (bidHeightResult !== 'accepted') return bidHeightResult;
+  if (bid.id !== renderer.bidId || bid.w !== renderer.width || bid.h !== renderer.height ||
+      bid.ext.creativeurl !== renderer.creativeUrl || bid.ext.tagtype !== renderer.tagType ||
+      typeof bid.price !== 'number' || !isFinite(bid.price) || bid.price < 0) {
+    return 'descriptor_invalid';
+  }
+  return 'accepted';
+}
+`;
+
+function stripTypeMarkers(source) {
+  return source
+    .replaceAll("/*EXPORT_CLASSIFIER*/ ", "")
+    .replaceAll("/*EXPORT_DESCRIPTOR_CLASSIFIER*/ ", "")
+    .replace(/\/\*:[^*]+\*\//g, "");
+}
+
+function applyTypeMarkers(source) {
+  return source
+    .replaceAll("/*EXPORT_CLASSIFIER*/ ", "export ")
+    .replaceAll("/*EXPORT_DESCRIPTOR_CLASSIFIER*/ ", "export ")
+    .replace(/\/\*:([^*]+)\*\//g, ":$1");
+}
+
+const es5Output =
+  generatedHeader +
+  constantsSource +
+  "var RENDER_DIMENSION_MIN = " +
+  schema.properties.width.minimum +
+  ";\n" +
+  "var RENDER_DIMENSION_MAX = " +
+  schema.properties.width.maximum +
+  ";\n" +
+  stripTypeMarkers(validatorSource).trimStart();
+
+const typescriptOutput =
+  generatedHeader +
+  "/* eslint-disable */\n" +
+  "export type ApsRendererValidationResult = 'accepted' | 'descriptor_invalid' | " +
+  "'invalid_dimensions' | 'dimensions_out_of_range';\n" +
+  constantsSource +
+  "export { MAX_ACCOUNT_ID_BYTES, MAX_BID_ID_BYTES, MAX_CREATIVE_ID_BYTES, " +
+  "MAX_RENDER_ENVELOPE_BASE64_BYTES };\n" +
+  "export const RENDER_DIMENSION_MIN = " +
+  schema.properties.width.minimum +
+  ";\n" +
+  "export const RENDER_DIMENSION_MAX = " +
+  schema.properties.width.maximum +
+  ";\n" +
+  applyTypeMarkers(validatorSource).trimStart();
+
+const documentValidatorOutput =
+  generatedHeader +
+  "export const APS_RENDERER_VALIDATOR_ES5_V1 =\n  " +
+  JSON.stringify(es5Output) +
+  ";\n";
+
+function extractDocumentTemplate(name) {
+  const prefix = "const " + name + " = `";
+  const start = documentsSource.indexOf(prefix);
+  invariant(start >= 0, "missing APS document template " + name);
+  const contentStart = start + prefix.length;
+  const end = documentsSource.indexOf("`;\n", contentStart);
+  invariant(end >= 0, "unterminated APS document template " + name);
+  const value = documentsSource.slice(contentStart, end);
+  invariant(
+    !value.includes("`"),
+    "APS document template contains a nested template literal",
+  );
+  return value;
+}
+
+function inlineScriptString(value) {
+  return JSON.stringify(value).replaceAll("</script>", "<\\/script>");
+}
+
+const innerTemplate = extractDocumentTemplate("INNER_TEMPLATE");
+const outerTemplate = extractDocumentTemplate("OUTER_TEMPLATE");
+
+const bootstrapOutput =
+  String.raw`<!doctype html>
+<meta charset="utf-8">
+<script>
+(function(){
+'use strict';
+var MAX_CONFIGURATION_BYTES=16384;
+var MAX_CONTAINER_URL_BYTES=196663;
+var DATA_PREFIX='data:text/html;charset=utf-8,';
+var INNER_TEMPLATE=` +
+  inlineScriptString(innerTemplate) +
+  String.raw`;
+var OUTER_TEMPLATE=` +
+  inlineScriptString(outerTemplate) +
+  String.raw`;
+var RENDERER_VALIDATOR=` +
+  inlineScriptString(es5Output) +
+  String.raw`;
+var PERMANENT_SANDBOX='allow-forms allow-pointer-lock allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-top-navigation-by-user-activation';
+function utf8Length(value){return(new TextEncoder()).encode(value).length;}
+function validParentOrigin(value){
+ if(typeof value!=='string'||utf8Length(value)>2048||/[\x00-\x20\x7f'";]/.test(value))return false;
+ try{
+  var parsed=new URL(value);
+  if((parsed.protocol!=='https:'&&parsed.protocol!=='http:')||parsed.hostname===''||
+     parsed.username!==''||parsed.password!==''||parsed.origin==='null')return false;
+  return parsed.origin===value&&parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';
+ }catch(_error){return false;}
+}
+function exact(value,keys){
+ if(!value||typeof value!=='object'||Array.isArray(value)||
+    Object.getPrototypeOf(value)!==Object.prototype)return false;
+ if(typeof Object.getOwnPropertySymbols==='function'&&
+    Object.getOwnPropertySymbols(value).length!==0)return false;
+ var names=Object.getOwnPropertyNames(value).sort();
+ if(names.length!==keys.length)return false;
+ for(var index=0;index<names.length;index+=1){
+  if(names[index]!==keys[index])return false;
+  var descriptor=Object.getOwnPropertyDescriptor(value,names[index]);
+  if(!descriptor||!Object.prototype.hasOwnProperty.call(descriptor,'value'))return false;
+ }
+ return true;
+}
+function validCreativeOrigin(value,publisherOrigin){
+ if(typeof value!=='string'||utf8Length(value)>2048||/[\x00-\x20\x7f'";]/.test(value))return false;
+ try{
+  var parsed=new URL(value);
+  return parsed.protocol==='https:'&&parsed.hostname!==''&&parsed.username===''&&
+   parsed.password===''&&parsed.origin===value&&parsed.origin!==publisherOrigin&&
+   parsed.pathname==='/'&&parsed.search===''&&parsed.hash==='';
+ }catch(_error){return false;}
+}
+function scriptSources(origin,creativeOrigin,scriptCreative){
+ return scriptCreative?"'unsafe-inline' "+origin+' '+creativeOrigin:"'unsafe-inline' "+origin;
+}
+function csp(origin,creativeOrigin,scriptCreative,outer){
+ return "default-src 'none'; base-uri 'none'; object-src 'none'; script-src "+
+  scriptSources(origin,creativeOrigin,scriptCreative)+'; connect-src https: '+origin+
+  '; frame-src '+(outer?'data: ':'')+creativeOrigin+
+  "; img-src https: data: blob:; media-src https: blob:; style-src 'unsafe-inline' https:; font-src https: data:; worker-src https: blob:; form-action https:;";
+}
+function replaceOne(template,sentinel,replacement){
+ var first=template.indexOf(sentinel);
+ if(first<0||template.indexOf(sentinel,first+sentinel.length)>=0)return null;
+ return template.slice(0,first)+replacement+template.slice(first+sentinel.length);
+}
+function substitute(template,replacements){
+ var output=template;
+ for(var sentinel in replacements){
+  if(!Object.prototype.hasOwnProperty.call(replacements,sentinel))continue;
+  output=replaceOne(output,sentinel,replacements[sentinel]);
+  if(output===null)return null;
+ }
+ return /__TS_[A-Z0-9_]+__/.test(output)?null:output;
+}
+function dataUrl(source,nonce){return DATA_PREFIX+encodeURIComponent(source)+'#'+nonce;}
+function createContainer(configuration,origin){
+ var scriptCreative=configuration.tagType==='script';
+ var runnerUrl=origin+'/integrations/aps/runner.js';
+ var inner=substitute(INNER_TEMPLATE,{
+  __TS_INNER_CSP__:csp(origin,configuration.creativeOrigin,scriptCreative,false),
+  __TS_RENDERER_VALIDATOR__:RENDERER_VALIDATOR,
+  __TS_RENDERER_NONCE_JSON__:JSON.stringify(configuration.rendererNonce),
+  __TS_PUBLISHER_ORIGIN_JSON__:JSON.stringify(origin),
+  __TS_CREATIVE_ORIGIN_JSON__:JSON.stringify(configuration.creativeOrigin),
+  __TS_TAG_TYPE_JSON__:JSON.stringify(configuration.tagType),
+  __TS_RUNNER_URL_JSON__:JSON.stringify(runnerUrl)
+ });
+ if(!inner||utf8Length(inner)>65536)return null;
+ var innerUrl=dataUrl(inner,configuration.rendererNonce);
+ var outer=substitute(OUTER_TEMPLATE,{
+  __TS_OUTER_CSP__:csp(origin,configuration.creativeOrigin,scriptCreative,true),
+  __TS_BOOTSTRAP_NONCE_JSON__:JSON.stringify(configuration.bootstrapNonce),
+  __TS_RENDERER_NONCE_JSON__:JSON.stringify(configuration.rendererNonce),
+  __TS_INNER_URL_JSON__:JSON.stringify(innerUrl),
+  __TS_PERMANENT_SANDBOX_JSON__:JSON.stringify(PERMANENT_SANDBOX)
+ });
+ if(!outer||utf8Length(outer)>65536)return null;
+ var outerUrl=dataUrl(outer,configuration.bootstrapNonce);
+ return utf8Length(outerUrl)<=MAX_CONTAINER_URL_BYTES?outerUrl:null;
+}
+var match=/^#(b1_[A-Za-z0-9_-]{22})$/.exec(location.hash);
+var nonce=match&&match[1];
+if(!nonce)return;
+try{history.replaceState(null,'',location.pathname+location.search);}catch(_error){}
+var consumed=false;
+function receive(event){
+ if(consumed||event.source!==parent||!validParentOrigin(event.origin)||
+    !event.ports||event.ports.length!==0||typeof event.data!=='string'||
+    utf8Length(event.data)>MAX_CONFIGURATION_BYTES)return;
+ var origin=event.origin;
+ var value;
+ try{value=JSON.parse(event.data);}catch(_error){return;}
+ if(!exact(value,['bootstrapNonce','creativeOrigin','message','rendererNonce','tagType','version'])||
+    value.message!=='TS APS Bootstrap Configure'||value.version!==2||
+    value.bootstrapNonce!==nonce||
+    typeof value.rendererNonce!=='string'||!/^n1_[A-Za-z0-9_-]{22}$/.test(value.rendererNonce)||
+    !validCreativeOrigin(value.creativeOrigin,origin)||
+    (value.tagType!=='iframe'&&value.tagType!=='script')||
+    event.data!==JSON.stringify({message:'TS APS Bootstrap Configure',version:2,
+     bootstrapNonce:nonce,rendererNonce:value.rendererNonce,
+     creativeOrigin:value.creativeOrigin,tagType:value.tagType}))return;
+ var containerUrl=createContainer(value,origin);
+ if(!containerUrl)return;
+ consumed=true;
+ removeEventListener('message',receive);
+ location.replace(containerUrl);
+}
+addEventListener('message',receive);
+parent.postMessage(JSON.stringify({message:'TS APS Bootstrap Ready',version:1,
+ bootstrapNonce:nonce}),'*');
+})();
+</script>
+`;
+
+const outputs = [
+  [es5Path, es5Output],
+  [bootstrapPath, bootstrapOutput],
+  [typescriptPath, typescriptOutput],
+  [documentValidatorPath, documentValidatorOutput],
+];
+const checkOnly = process.argv.slice(2).includes("--check");
+
+if (checkOnly) {
+  const stale = [];
+  for (const [outputPath, expected] of outputs) {
+    let actual;
+    try {
+      actual = await readFile(outputPath, "utf8");
+    } catch {
+      stale.push(path.relative(repositoryRoot, outputPath));
+      continue;
+    }
+    if (actual !== expected)
+      stale.push(path.relative(repositoryRoot, outputPath));
+  }
+  if (stale.length > 0) {
+    throw new Error("stale APS renderer contract output: " + stale.join(", "));
+  }
+} else {
+  for (const [outputPath, output] of outputs) {
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, output);
+  }
+}
diff --git a/scripts/generate-integration-viceroy-configs.sh b/scripts/generate-integration-viceroy-configs.sh
index 761d06926..4b61f054a 100755
--- a/scripts/generate-integration-viceroy-configs.sh
+++ b/scripts/generate-integration-viceroy-configs.sh
@@ -16,12 +16,21 @@ APP_CONFIG_PATH="crates/trusted-server-integration-tests/fixtures/configs/truste
 INTEGRATION_TARGET_DIR="crates/trusted-server-integration-tests/target"
 ORIGIN_URL="http://127.0.0.1:$ORIGIN_PORT"
 HOST_TARGET="$(rustc -vV | sed -n 's/^host: //p')"
+ENABLE_AUCTION="${INTEGRATION_ENABLE_AUCTION:-false}"
 
 if [ -z "$HOST_TARGET" ]; then
     echo "Failed to detect host target from rustc -vV" >&2
     exit 1
 fi
 
+case "$ENABLE_AUCTION" in
+    true|false) ;;
+    *)
+        echo "INTEGRATION_ENABLE_AUCTION must be true or false" >&2
+        exit 1
+        ;;
+esac
+
 mkdir -p "$CONFIG_DIR"
 
 cargo build \
@@ -36,8 +45,14 @@ if [ ! -x "$GENERATOR_BIN" ]; then
     exit 1
 fi
 
-"$GENERATOR_BIN" \
-    --template "$TEMPLATE_PATH" \
-    --app-config "$APP_CONFIG_PATH" \
-    --output "$CONFIG_DIR/viceroy.toml" \
+GENERATOR_ARGS=(
+    --template "$TEMPLATE_PATH"
+    --app-config "$APP_CONFIG_PATH"
+    --output "$CONFIG_DIR/viceroy.toml"
     --origin-url "$ORIGIN_URL"
+)
+if [ "$ENABLE_AUCTION" = true ]; then
+    GENERATOR_ARGS+=(--enable-auction)
+fi
+
+"$GENERATOR_BIN" "${GENERATOR_ARGS[@]}"
diff --git a/scripts/integration-tests-aps-runner-proxy.sh b/scripts/integration-tests-aps-runner-proxy.sh
new file mode 100755
index 000000000..c6027fa94
--- /dev/null
+++ b/scripts/integration-tests-aps-runner-proxy.sh
@@ -0,0 +1,208 @@
+#!/usr/bin/env bash
+# Run the hermetic APS runner-proxy corpus through one actual adapter runtime.
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_ROOT"
+
+if [ "$#" -ne 2 ] || [ "$1" != "--runtime" ]; then
+  echo "usage: $0 --runtime <axum|fastly|cloudflare|spin>" >&2
+  exit 2
+fi
+
+RUNTIME="$2"
+case "$RUNTIME" in
+  axum|fastly|cloudflare|spin) ;;
+  *)
+    echo "unsupported APS runner-proxy runtime: $RUNTIME" >&2
+    exit 2
+    ;;
+esac
+
+ORIGIN_PORT="${INTEGRATION_ORIGIN_PORT:-8888}"
+export ARTIFACTS_DIR="${ARTIFACTS_DIR:-$REPO_ROOT/target/integration-test-artifacts}"
+HOST_TARGET="$(rustc -vV | sed -n 's/^host: //p')"
+if [ -z "$HOST_TARGET" ]; then
+  echo "failed to detect the native Rust target" >&2
+  exit 1
+fi
+
+export TRUSTED_SERVER__PUBLISHER__ORIGIN_URL="http://127.0.0.1:$ORIGIN_PORT"
+export TRUSTED_SERVER__PUBLISHER__PROXY_SECRET="integration-test-proxy-secret"
+export TRUSTED_SERVER__EC__PASSPHRASE="integration-test-ec-secret-padded-32"
+export TRUSTED_SERVER__PROXY__CERTIFICATE_CHECK=false
+
+ABSENCE_PATTERNS=(
+  aps-runner-proxy-integration-test
+  TS_APS_RUNNER_PROXY_TEST_ENDPOINT
+  APS_RUNNER_PROXY_FIXTURE
+  aps_runner_proxy_test_endpoint
+  aps_runner_proxy_fixture
+  aps-runner-proxy-fixture-bounded
+  x-ts-aps-logical-url
+)
+
+# The production renderer and live runner-proxy routes are intentionally not
+# absence sentinels. The entries above are unique to the feature-only local
+# upstream and test transport; finding one in a release artifact would mean the
+# hermetic fixture or its routing seam leaked into production.
+
+CARGO_TEST_PID=""
+CARGO_TEST_PGID=""
+PROCESS_GROUP_FILE="$(mktemp -t trusted-server-aps-pgids.XXXXXX)"
+SHELL_PGID="$(ps -o pgid= -p "$$" 2>/dev/null | tr -d '[:space:]' || true)"
+
+terminate_registered_process_groups() {
+  local pgid
+  local actual_pgid
+  while IFS= read -r pgid; do
+    if [[ ! "$pgid" =~ ^[1-9][0-9]*$ ]] || [ "$pgid" = "$SHELL_PGID" ]; then
+      continue
+    fi
+    actual_pgid="$(ps -o pgid= -p "$pgid" 2>/dev/null | tr -d '[:space:]' || true)"
+    if [ "$actual_pgid" = "$pgid" ]; then
+      kill -TERM -- "-$pgid" 2>/dev/null || true
+    fi
+  done < "$PROCESS_GROUP_FILE"
+}
+
+terminate_cargo_test() {
+  if [ -z "$CARGO_TEST_PID" ]; then
+    return
+  fi
+  if [ -n "$CARGO_TEST_PGID" ]; then
+    kill -TERM -- "-$CARGO_TEST_PGID" 2>/dev/null || true
+  else
+    kill -TERM "$CARGO_TEST_PID" 2>/dev/null || true
+  fi
+  wait "$CARGO_TEST_PID" 2>/dev/null || true
+}
+
+cleanup() {
+  local status="$?"
+  trap - EXIT INT TERM
+  terminate_cargo_test
+  terminate_registered_process_groups
+  if [[ "$PROCESS_GROUP_FILE" = /* ]] && [ -f "$PROCESS_GROUP_FILE" ]; then
+    rm -f -- "$PROCESS_GROUP_FILE"
+  fi
+  exit "$status"
+}
+
+trap cleanup EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+
+assert_release_absence() {
+  local artifact="$1"
+  local rg_args=()
+  local pattern
+  for pattern in "${ABSENCE_PATTERNS[@]}"; do
+    rg_args+=(--regexp "$pattern")
+  done
+  if strings "$artifact" | rg --fixed-strings "${rg_args[@]}"; then
+    echo "production artifact contains an APS proxy integration sentinel: $artifact" >&2
+    exit 1
+  fi
+}
+
+echo "==> Building and checking the production $RUNTIME artifact..."
+case "$RUNTIME" in
+  axum)
+    cargo build --package trusted-server-adapter-axum --release
+    assert_release_absence target/release/trusted-server-axum
+    cargo build --package trusted-server-adapter-axum --release \
+      --features aps-runner-proxy-integration-test
+    export AXUM_BINARY_PATH="$REPO_ROOT/target/release/trusted-server-axum"
+    ;;
+  fastly)
+    cargo build --package trusted-server-adapter-fastly --release --target wasm32-wasip1
+    assert_release_absence \
+      target/wasm32-wasip1/release/trusted-server-adapter-fastly.wasm
+    cargo build --package trusted-server-adapter-fastly --release --target wasm32-wasip1 \
+      --features aps-runner-proxy-integration-test
+    INTEGRATION_ORIGIN_PORT="$ORIGIN_PORT" \
+      ./scripts/generate-integration-viceroy-configs.sh
+    export WASM_BINARY_PATH="$REPO_ROOT/target/wasm32-wasip1/release/trusted-server-adapter-fastly.wasm"
+    export VICEROY_CONFIG_PATH="$ARTIFACTS_DIR/configs/viceroy.toml"
+    ;;
+  cloudflare)
+    bash crates/trusted-server-adapter-cloudflare/build.sh
+    assert_release_absence crates/trusted-server-adapter-cloudflare/build/index.js
+    assert_release_absence crates/trusted-server-adapter-cloudflare/build/index_bg.wasm
+    TS_WORKER_BUILD_FEATURES="cloudflare,aps-runner-proxy-integration-test" \
+      bash crates/trusted-server-adapter-cloudflare/build.sh
+    export CLOUDFLARE_WRANGLER_DIR="$REPO_ROOT/crates/trusted-server-adapter-cloudflare"
+    ;;
+  spin)
+    cargo build --package trusted-server-adapter-spin --release --target wasm32-wasip1 \
+      --features spin
+    assert_release_absence \
+      target/wasm32-wasip1/release/trusted_server_adapter_spin.wasm
+    cargo build --package trusted-server-adapter-spin --release --target wasm32-wasip1 \
+      --features spin,aps-runner-proxy-integration-test
+    export WASM_BINARY_PATH="$REPO_ROOT/target/wasm32-wasip1/release/trusted_server_adapter_spin.wasm"
+    ;;
+esac
+
+echo "==> Running the APS runner-proxy corpus through $RUNTIME..."
+TEST_COMMAND=(
+  cargo test
+  --manifest-path crates/trusted-server-integration-tests/Cargo.toml
+  --features aps-runner-proxy
+  --target "$HOST_TARGET"
+  --test aps_runner_proxy
+  actual_adapter_proxy_corpus
+  -- --ignored --test-threads=1
+)
+
+if command -v setsid >/dev/null 2>&1; then
+  setsid env \
+    APS_RUNNER_PROXY_RUNTIME="$RUNTIME" \
+    APS_RUNNER_PROXY_PROCESS_GROUP_FILE="$PROCESS_GROUP_FILE" \
+    INTEGRATION_ORIGIN_PORT="$ORIGIN_PORT" \
+    RUST_LOG="${RUST_LOG:-info}" \
+    "${TEST_COMMAND[@]}" &
+else
+  # BSD/macOS does not provide `setsid`. Bash job control still launches a
+  # background job in its own process group, so the cleanup trap can terminate
+  # Cargo, the test binary, and every runtime it starts as one unit.
+  set -m
+  env \
+    APS_RUNNER_PROXY_RUNTIME="$RUNTIME" \
+    APS_RUNNER_PROXY_PROCESS_GROUP_FILE="$PROCESS_GROUP_FILE" \
+    INTEGRATION_ORIGIN_PORT="$ORIGIN_PORT" \
+    RUST_LOG="${RUST_LOG:-info}" \
+    "${TEST_COMMAND[@]}" &
+  set +m
+fi
+CARGO_TEST_PID="$!"
+
+CHILD_PGID=""
+# The background child can be observed between fork and `setsid(2)`, especially
+# when `setsid` is provided by a shim on BSD/macOS. Give it a bounded moment to
+# enter its dedicated process group before enforcing the cleanup invariant.
+for ((attempt = 0; attempt < 50; attempt += 1)); do
+  CHILD_PGID="$(ps -o pgid= -p "$CARGO_TEST_PID" 2>/dev/null | tr -d '[:space:]' || true)"
+  if [[ "$CHILD_PGID" =~ ^[1-9][0-9]*$ ]] && [ "$CHILD_PGID" != "$SHELL_PGID" ]; then
+    break
+  fi
+  sleep 0.01
+done
+if [[ "$CHILD_PGID" =~ ^[1-9][0-9]*$ ]] && [ "$CHILD_PGID" != "$SHELL_PGID" ]; then
+  CARGO_TEST_PGID="$CHILD_PGID"
+else
+  echo "failed to isolate the APS corpus in a dedicated process group" >&2
+  terminate_cargo_test
+  CARGO_TEST_PID=""
+  exit 1
+fi
+
+if wait "$CARGO_TEST_PID"; then
+  TEST_STATUS=0
+else
+  TEST_STATUS="$?"
+fi
+CARGO_TEST_PID=""
+CARGO_TEST_PGID=""
+exit "$TEST_STATUS"
diff --git a/scripts/integration-tests-browser.sh b/scripts/integration-tests-browser.sh
index 714de510b..9ad61f022 100755
--- a/scripts/integration-tests-browser.sh
+++ b/scripts/integration-tests-browser.sh
@@ -7,9 +7,9 @@
 #
 # Prerequisites:
 #   - Docker running
-#   - Viceroy installed: cargo install viceroy --version 0.17.0 --locked --force
+#   - Viceroy installed: cargo install viceroy --version 0.19.0 --locked --force
 #   - wasm32-wasip1 target: rustup target add wasm32-wasip1
-#   - Node.js with npx available
+#   - Node.js with npm available
 #
 set -euo pipefail
 
@@ -17,15 +17,52 @@ REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$REPO_ROOT"
 
 ORIGIN_PORT="${INTEGRATION_ORIGIN_PORT:-8888}"
+export ARTIFACTS_DIR="${ARTIFACTS_DIR:-$REPO_ROOT/target/integration-test-artifacts}"
 BROWSER_DIR="crates/trusted-server-integration-tests/browser"
 TSJS_LIB_DIR="crates/trusted-server-js/lib"
 NODE_VERSION="$(grep '^nodejs ' .tool-versions | awk '{print $2}')"
+FRAMEWORKS_VALUE="${TS_BROWSER_FRAMEWORKS:-nextjs wordpress}"
+FRAMEWORKS_VALUE="${FRAMEWORKS_VALUE//,/ }"
+read -r -a FRAMEWORKS <<< "$FRAMEWORKS_VALUE"
+PROJECTS_VALUE="${TS_BROWSER_PROJECTS:-chromium}"
+PROJECTS_VALUE="${PROJECTS_VALUE//,/ }"
+read -r -a BROWSER_PROJECTS <<< "$PROJECTS_VALUE"
 
 if [ -z "$NODE_VERSION" ]; then
     echo "Failed to detect Node.js version from .tool-versions" >&2
     exit 1
 fi
 
+if [ "${#FRAMEWORKS[@]}" -eq 0 ]; then
+    echo "TS_BROWSER_FRAMEWORKS must select at least one framework" >&2
+    exit 1
+fi
+
+if [ "${#BROWSER_PROJECTS[@]}" -eq 0 ]; then
+    echo "TS_BROWSER_PROJECTS must select at least one browser" >&2
+    exit 1
+fi
+
+for framework in "${FRAMEWORKS[@]}"; do
+    case "$framework" in
+        nextjs|wordpress) ;;
+        *)
+            echo "Unsupported browser framework: $framework" >&2
+            exit 1
+            ;;
+    esac
+done
+
+for project in "${BROWSER_PROJECTS[@]}"; do
+    case "$project" in
+        chromium|firefox|webkit) ;;
+        *)
+            echo "Unsupported browser project: $project" >&2
+            exit 1
+            ;;
+    esac
+done
+
 # --- Build WASM binary ---
 echo "==> Building WASM binary (origin=http://127.0.0.1:$ORIGIN_PORT)..."
 TRUSTED_SERVER__PUBLISHER__ORIGIN_URL="http://127.0.0.1:$ORIGIN_PORT" \
@@ -36,33 +73,41 @@ TRUSTED_SERVER__PROXY__CERTIFICATE_CHECK=false \
     cargo build --package trusted-server-adapter-fastly --release --target wasm32-wasip1
 
 echo "==> Generating Viceroy configs..."
-INTEGRATION_ORIGIN_PORT="$ORIGIN_PORT" ./scripts/generate-integration-viceroy-configs.sh
-GENERATED_VICEROY_CONFIG_PATH="$REPO_ROOT/target/integration-test-artifacts/configs/viceroy.toml"
+INTEGRATION_ORIGIN_PORT="$ORIGIN_PORT" \
+INTEGRATION_ENABLE_AUCTION=true \
+    ./scripts/generate-integration-viceroy-configs.sh
+GENERATED_VICEROY_CONFIG_PATH="$ARTIFACTS_DIR/configs/viceroy.toml"
 
 # --- Build Docker images ---
-echo "==> Building WordPress test container..."
-docker build -t test-wordpress:latest \
-    crates/trusted-server-integration-tests/fixtures/frameworks/wordpress/
-
-echo "==> Building Next.js test container..."
-docker build \
-    --build-arg NODE_VERSION="$NODE_VERSION" \
-    -t test-nextjs:latest \
-    crates/trusted-server-integration-tests/fixtures/frameworks/nextjs/
+for framework in "${FRAMEWORKS[@]}"; do
+    if [ "$framework" = "wordpress" ]; then
+        echo "==> Building WordPress test container..."
+        docker build -t test-wordpress:latest \
+            crates/trusted-server-integration-tests/fixtures/frameworks/wordpress/
+    else
+        echo "==> Building Next.js test container..."
+        docker build \
+            --build-arg NODE_VERSION="$NODE_VERSION" \
+            -t test-nextjs:latest \
+            crates/trusted-server-integration-tests/fixtures/frameworks/nextjs/
+    fi
+done
 
 # --- Install Playwright ---
 echo "==> Installing Playwright dependencies..."
-cd "$REPO_ROOT/$BROWSER_DIR"
-npm ci
-npx playwright install chromium
+npm --prefix "$BROWSER_DIR" ci
+PLAYWRIGHT_INSTALL_ARGS=(install)
+if [ "${CI:-}" = "true" ]; then
+    PLAYWRIGHT_INSTALL_ARGS+=(--with-deps)
+fi
+npm --prefix "$BROWSER_DIR" exec -- playwright \
+    "${PLAYWRIGHT_INSTALL_ARGS[@]}" "${BROWSER_PROJECTS[@]}"
 
 # --- Build browser-side Trusted Server and external Prebid fixtures ---
 echo "==> Building TSJS browser fixtures..."
-cd "$REPO_ROOT/$TSJS_LIB_DIR"
-npm ci
-npm run build
-npm run build:prebid-external
-cd "$REPO_ROOT/$BROWSER_DIR"
+npm --prefix "$TSJS_LIB_DIR" ci
+npm --prefix "$TSJS_LIB_DIR" run build
+npm --prefix "$TSJS_LIB_DIR" run build:prebid-external
 
 # --- Export env vars for global-setup.ts ---
 export WASM_BINARY_PATH="$REPO_ROOT/target/wasm32-wasip1/release/trusted-server-adapter-fastly.wasm"
@@ -80,15 +125,17 @@ stop_matching_containers() {
 }
 
 cleanup() {
-    stop_matching_containers test-nextjs:latest
-    stop_matching_containers test-wordpress:latest
+    for framework in "${FRAMEWORKS[@]}"; do
+        stop_matching_containers "test-$framework:latest"
+    done
 }
 trap cleanup EXIT
 
 # --- Run tests for each framework ---
-for framework in nextjs wordpress; do
+for framework in "${FRAMEWORKS[@]}"; do
     echo "==> Running Playwright tests for $framework..."
-    TEST_FRAMEWORK="$framework" npx playwright test "$@"
+    TEST_FRAMEWORK="$framework" npm --prefix "$BROWSER_DIR" exec -- \
+        playwright test --config "$REPO_ROOT/$BROWSER_DIR/playwright.config.ts" "$@"
 done
 
 echo "==> All browser tests passed."
diff --git a/scripts/integration-tests.sh b/scripts/integration-tests.sh
index 96e492f40..f4d8196b3 100755
--- a/scripts/integration-tests.sh
+++ b/scripts/integration-tests.sh
@@ -7,7 +7,7 @@
 #
 # Prerequisites:
 #   - Docker running
-#   - Viceroy installed: cargo install viceroy --version 0.17.0 --locked --force
+#   - Viceroy installed: cargo install viceroy --version 0.19.0 --locked --force
 #   - wasm32-wasip1 target: rustup target add wasm32-wasip1
 #
 set -euo pipefail
diff --git a/scripts/template-cache-local-test.sh b/scripts/template-cache-local-test.sh
index 01da8ef04..095eb1b2a 100755
--- a/scripts/template-cache-local-test.sh
+++ b/scripts/template-cache-local-test.sh
@@ -518,135 +518,21 @@ else
     "$(assembly_state "$WORK/r2.html.headers")" "byte-seam"
   check "no unresolved seam marker reaches the browser" \
     "$(grep -cF "$SEAM_MARKER" "$SERVED" || true)" "0"
-  check "a bids script is present" \
-    "$(grep -c 'window.tsjs' "$SERVED" || true)" "1"
-  # `window.tsjs` alone passes while initial ads are dead: shared modes suppress the head
-  # slot script, so if the seam does not carry slots, `adSlots` stays `[]` and `adInit`
-  # defines nothing. This harness passed green through exactly that bug.
-  # The slots ride the scheduler call (`s(b,a)`) rather than a bare assignment, so the
-  # navigation-generation guard covers them; `var a=JSON.parse(...)` is where they land.
-  check "the seam carries slot definitions, not just bids" \
-    "$(grep -c 'var a=JSON.parse' "$SERVED" || true)" "1"
-  check "the slot definitions reach the guarded scheduler" \
-    "$(grep -cF 's(b,a)' "$SERVED" || true)" "1"
-  check "the slot definitions are populated, not an empty array" \
-    "$(grep -c 'var a=JSON.parse("\[\]")' "$SERVED" || true)" "0"
-  # The assertion the harness was missing entirely. `window.tsjs` and populated slots
-  # both pass on a page whose bids are `{}` — which is what shared modes served, on
-  # every request, for as long as this file has existed.
-  check "the seam carries a real bid, not an empty map" \
-    "$(grep -cF 'var b=JSON.parse("{}")' "$SERVED" || true)" "0"
+  check "the hard-cutover controller is present" \
+    "$(grep -c '__TSJS_SERVER_BOOT_TRANSPORT_V1__' "$SERVED" || true)" "1"
+  check "the controller records the real bids-script mark" \
+    "$(grep -cF 'performance.mark("tsjs:bids-script")' "$SERVED" || true)" "1"
+  check "the selected hard-cutover runtime is present" \
+    "$(grep -c 'src="/static/tsjs=tsjs-unified.min.js?v=[0-9a-f]\{64\}" id="trustedserver-js"' "$SERVED" || true)" "1"
   check "the winning bid's bucketed price reaches the reader" \
     "$(grep -cF "$WINNING_BID" "$SERVED" || true)" "1"
-
-  GPT_BUNDLE=""
-  while IFS= read -r -d '' candidate; do
-    if [ -z "$GPT_BUNDLE" ] || [ "$candidate" -nt "$GPT_BUNDLE" ]; then
-      GPT_BUNDLE="$candidate"
-    fi
-  done < <(find "$REPO_ROOT/target/wasm32-wasip1/debug/build" \
-    -path '*/out/tsjs-gpt.js' -type f -print0)
-  if [ -z "$GPT_BUNDLE" ] || [ ! -s "$GPT_BUNDLE" ]; then
-    bad "the generated GPT module cannot be found"
-  else
-    cat > "$WORK/verify-seam.mjs" <<'NODEEOF'
-import fs from "node:fs";
-import vm from "node:vm";
-
-const [documentPath, gptPath] = process.argv.slice(2);
-const html = fs.readFileSync(documentPath, "utf8");
-const gpt = fs.readFileSync(gptPath, "utf8");
-const scripts = [...html.matchAll(/<script>([\s\S]*?)<\/script>/gi)].map((match) => match[1]);
-const seam = scripts.find((script) => script.includes('var b=JSON.parse("'));
-if (!seam) throw new Error("served document has no executable seam payload");
-
-const element = {
-  id: "ts-slot-header",
-  parentElement: null,
-  checkVisibility: () => true,
-  getBoundingClientRect: () => ({ width: 728, height: 90 }),
-  querySelectorAll: () => [],
-};
-const defined = [];
-const gptSlots = [];
-const pubads = {
-  addEventListener() {},
-  disableInitialLoad() {},
-  enableSingleRequest() {},
-  getSlots: () => gptSlots,
-  refresh() {},
-};
-const googletag = {
-  cmd: { push(...callbacks) { callbacks.forEach((callback) => callback()); return callbacks.length; } },
-  defineSlot(unit, formats, divId) {
-    defined.push({ unit, formats, divId });
-    const slot = {
-      addService() { return slot; },
-      clearTargeting() {},
-      getSlotElementId: () => divId,
-      setTargeting() { return slot; },
-    };
-    gptSlots.push(slot);
-    return slot;
-  },
-  destroySlots: () => true,
-  display() {},
-  enableServices() {},
-  pubads: () => pubads,
-};
-const listeners = new Map();
-const windowObject = {
-  addEventListener(type, callback) { listeners.set(type, callback); },
-  getComputedStyle: () => ({ display: "block", visibility: "visible" }),
-  googletag,
-  history: { pushState() {}, replaceState() {} },
-  location: {
-    host: "ts.example.com",
-    href: "https://ts.example.com/article",
-    origin: "https://ts.example.com",
-    pathname: "/article",
-    protocol: "https:",
-  },
-  requestAnimationFrame(callback) { callback(); return 1; },
-  tsjs: { navGeneration: 0 },
-};
-const documentObject = {
-  documentElement: {},
-  getElementById: (id) => id === element.id ? element : null,
-  querySelectorAll: () => [],
-  readyState: "complete",
-  visibilityState: "visible",
-};
-globalThis.window = windowObject;
-globalThis.document = documentObject;
-globalThis.history = windowObject.history;
-globalThis.location = windowObject.location;
-globalThis.requestAnimationFrame = windowObject.requestAnimationFrame;
-
-vm.runInThisContext(gpt, { filename: gptPath });
-vm.runInThisContext(seam, { filename: documentPath });
-
-const slots = windowObject.tsjs.adSlots ?? [];
-const bids = windowObject.tsjs.bids ?? {};
-if (slots.length !== 1 || slots[0].id !== "ts-slot-header") {
-  throw new Error(`scheduler received invalid slots: ${JSON.stringify(slots)}`);
-}
-if (!bids["ts-slot-header"] || bids["ts-slot-header"].hb_pb !== "4.25") {
-  throw new Error(`scheduler received no winning bid: ${JSON.stringify(bids)}`);
-}
-if (defined.length !== 1 || defined[0].divId !== "ts-slot-header") {
-  throw new Error(`GPT defineSlot contract failed: ${JSON.stringify(defined)}`);
-}
-console.log(`slots=${slots.length} bids=${Object.keys(bids).length} defined=${defined.length}`);
-NODEEOF
-    GPT_RESULT=$(node "$WORK/verify-seam.mjs" "$SERVED" "$GPT_BUNDLE" 2>&1) || {
-      bad "the served seam failed the real GPT module contract: $GPT_RESULT"
-      GPT_RESULT=""
-    }
-    [ -z "$GPT_RESULT" ] || check \
-      "the real scheduler defines the populated GPT slot" "$GPT_RESULT" \
-      "slots=1 bids=1 defined=1"
-  fi
+  CUTOVER_RESULT=$(node "$REPO_ROOT/scripts/template-cache-verify-hard-cutover.mjs" "$SERVED" 2>&1) || {
+    bad "the served seam failed the hard-cutover transport contract: $CUTOVER_RESULT"
+    CUTOVER_RESULT=""
+  }
+  [ -z "$CUTOVER_RESULT" ] || check \
+    "the sealed controller binds the populated slot and bid to its selected runtime" \
+    "$CUTOVER_RESULT" "slots=1 bids=1 selected=1 mode=direct"
 
   check_hit_is_private
   check_post_reaches_origin
@@ -659,9 +545,9 @@ if [ "$MODE" = "esi" ]; then
     "$WORK/viceroy.log" | sort -u | sed 's/^/    /'
   echo
   echo "  What the reader receives (hole filled, no marker):"
-  printf '    %d seam marker(s), %d window.tsjs\n' \
+  printf '    %d seam marker(s), %d legacy window.tsjs assignment(s)\n' \
     "$(grep -cF "$SEAM_MARKER" "$SERVED" || true)" \
-    "$(grep -c 'window\.tsjs' "$SERVED" || true)"
+    "$(grep -c 'window\.tsjs[[:space:]]*=' "$SERVED" || true)"
   cat <<'EOF'
 
   The marker is never visible in page source. It remains inert in the template cache. A cold miss
diff --git a/scripts/template-cache-verify-hard-cutover.mjs b/scripts/template-cache-verify-hard-cutover.mjs
new file mode 100644
index 000000000..e7fa7ca04
--- /dev/null
+++ b/scripts/template-cache-verify-hard-cutover.mjs
@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+
+const documentPath = process.argv[2];
+if (!documentPath || process.argv.length !== 3) {
+  throw new Error(
+    "usage: template-cache-verify-hard-cutover.mjs <served-document>",
+  );
+}
+
+const html = fs.readFileSync(documentPath, "utf8");
+const scripts = [
+  ...html.matchAll(/<script([^>]*)>([\s\S]*?)<\/script>/giu),
+].map(([, attributes, body]) => ({ attributes, body }));
+const controllers = scripts.filter(({ body }) =>
+  body.includes("const __TSJS_SERVER_BOOT_TRANSPORT_V1__="),
+);
+if (controllers.length !== 1) {
+  throw new Error(
+    `served document has ${controllers.length} hard-cutover controllers`,
+  );
+}
+
+const assignment =
+  /const __TSJS_SERVER_BOOT_TRANSPORT_V1__=("(?:\\.|[^"\\])*");/u.exec(
+    controllers[0].body,
+  );
+if (!assignment?.[1])
+  throw new Error("served controller has no sealed boot transport");
+
+const transport = JSON.parse(JSON.parse(assignment[1]));
+const boot = transport?.boot;
+const projection = boot?.auctionProjection;
+const manifest = boot?.manifest;
+if (boot?.abi !== 1 || projection?.version !== 1 || manifest?.version !== 1) {
+  throw new Error("served controller boot ABI is invalid");
+}
+if (manifest.firstDisplay !== null) {
+  throw new Error(
+    "template-cache fixture must use direct hard-cutover runtime boot",
+  );
+}
+if (
+  typeof manifest.runtimeSrc !== "string" ||
+  !/^\/static\/tsjs=tsjs-unified\.min\.js\?v=[0-9a-f]{64}$/u.test(
+    manifest.runtimeSrc,
+  )
+) {
+  throw new Error("served controller runtime source is invalid");
+}
+
+const results = projection?.auction?.results;
+const slots = projection?.slots;
+const bids = projection?.bids;
+if (!Array.isArray(results) || !Array.isArray(slots) || !Array.isArray(bids)) {
+  throw new Error("served controller projection is invalid");
+}
+if (results.length !== 1 || slots.length !== 1 || bids.length !== 1) {
+  throw new Error("served controller must carry one result, slot, and bid");
+}
+const result = results[0];
+const slot = slots[0];
+const bid = bids[0];
+if (
+  result?.outcome !== "winner" ||
+  result.slot !== slot?.slot ||
+  result.candidateId !== bid?.candidateId ||
+  bid.slot !== slot.slot ||
+  slot.slot !== "ts-slot-header" ||
+  bid?.targeting?.hb_pb !== "4.25"
+) {
+  throw new Error("served controller detached the winning bid from its slot");
+}
+
+const selected = scripts.filter(({ attributes }) =>
+  /(?:^|\s)id=(?:"trustedserver-js"|'trustedserver-js')(?:\s|$)/u.test(
+    attributes,
+  ),
+);
+if (selected.length !== 1) {
+  throw new Error(
+    `served document has ${selected.length} selected runtime scripts`,
+  );
+}
+const selectedSource = /(?:^|\s)src=(?:"([^"]+)"|'([^']+)')(?:\s|$)/u.exec(
+  selected[0].attributes,
+);
+if ((selectedSource?.[1] ?? selectedSource?.[2]) !== manifest.runtimeSrc) {
+  throw new Error("served runtime script does not match the sealed manifest");
+}
+
+for (const legacy of ["var b=JSON.parse(", "var a=JSON.parse(", "s(b,a)"]) {
+  if (html.includes(legacy))
+    throw new Error(`legacy seam survived hard cutover: ${legacy}`);
+}
+
+process.stdout.write(
+  `slots=${slots.length} bids=${bids.length} selected=${selected.length} mode=direct\n`,
+);
diff --git a/scripts/validate-tsjs-performance-evidence.mjs b/scripts/validate-tsjs-performance-evidence.mjs
new file mode 100644
index 000000000..2e8ec4f51
--- /dev/null
+++ b/scripts/validate-tsjs-performance-evidence.mjs
@@ -0,0 +1,2008 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+const EXPECTED = Object.freeze({
+  schemaVersion: 7,
+  chromium: "145.0.7632.6",
+  machineClass: "github-hosted:ubuntu-24.04",
+  runnerImage: "ubuntu-24.04",
+  fixture: "tsjs-baseline-paired-network-v3",
+  controller: "generated-server-v1+production-rc-v1",
+  node: "v24.12.0",
+  npm: "11.6.2",
+  typescript: "6.0.3",
+  warmupsPerVariant: 5,
+  samplesPerVariant: 50,
+  percentile: 90,
+  interleaving: "alternating-baseline-candidate",
+  networkProfile: Object.freeze({
+    mechanism: "cdp-Network.emulateNetworkConditions",
+    appliedBeforeNavigation: true,
+    latencyMs: 150,
+    downloadThroughputBytesPerSecond: 200_000,
+    uploadThroughputBytesPerSecond: 93_750,
+    packetLossPercent: 0,
+  }),
+  maximumRatio: 1.1,
+  heapCheckpoints: Object.freeze([
+    "afterBoot",
+    "afterFirstRender",
+    "afterRefresh",
+    "afterSpaNavigation",
+  ]),
+  heapHardCeilingBytes: 4 * 1024 * 1024,
+  aps: Object.freeze({
+    actionCeilingMs: 900,
+    actionToCompletionCeilingMs: 1_500,
+    completionToPaintCeilingMs: 250,
+    totalToPaintCeilingMs: 2_500,
+    afterProtectedPaintHeapCeilingBytes: 3 * 1024 * 1024,
+    afterTakeoverQueueDrainHeapCeilingBytes: 3_932_160,
+  }),
+  workflowName: "TSJS Performance Gate",
+  workflowFile: ".github/workflows/tsjs-performance-gate.yml",
+});
+
+function fail(message) {
+  throw new Error(`invalid TSJS performance evidence: ${message}`);
+}
+
+function record(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    fail(`${path} must be an object`);
+  }
+  return value;
+}
+
+function exactKeys(value, keys, path) {
+  const actual = Object.keys(record(value, path)).sort();
+  const expected = [...keys].sort();
+  if (
+    actual.length !== expected.length ||
+    actual.some((key, index) => key !== expected[index])
+  ) {
+    fail(`${path} has an unexpected schema`);
+  }
+}
+
+function exactString(value, expected, path) {
+  if (typeof value !== "string" || value !== expected)
+    fail(`${path} must equal ${expected}`);
+}
+
+function boolean(value, expected, path) {
+  if (typeof value !== "boolean" || value !== expected)
+    fail(`${path} must equal ${expected}`);
+}
+
+function finiteNumber(value, path, { integer = false, minimum = 0 } = {}) {
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value < minimum ||
+    (integer && !Number.isSafeInteger(value))
+  ) {
+    fail(`${path} must be a finite${integer ? " safe integer" : " number"}`);
+  }
+  return value;
+}
+
+function nearestRank(values, percentile) {
+  const ordered = [...values].sort((left, right) => left - right);
+  return ordered[Math.ceil((percentile / 100) * ordered.length) - 1];
+}
+
+function validateReferenceTransfer(
+  value,
+  expectedSha,
+  expectedModel,
+  path,
+  firstDisplayMask = "008b",
+) {
+  exactKeys(
+    value,
+    ["sha", "artifactModel", "sources", "rawBytes", "gzipBytes", "brotliBytes"],
+    path,
+  );
+  exactString(value.sha, expectedSha, `${path}.sha`);
+  exactString(value.artifactModel, expectedModel, `${path}.artifactModel`);
+  if (!Array.isArray(value.sources)) fail(`${path}.sources must be an array`);
+  const expectedInlineEndpoints =
+    expectedModel === "legacy-rc-v1"
+      ? ["inline:legacy-boot", "inline:legacy-ad-init"]
+      : ["inline:boot-controller"];
+  if (value.sources.length !== expectedInlineEndpoints.length + 1) {
+    fail(`${path}.sources has an unexpected semantic count`);
+  }
+  const endpoints = new Set();
+  const sums = { rawBytes: 0, gzipBytes: 0, brotliBytes: 0 };
+  let externalTransfer;
+  for (const [index, source] of value.sources.entries()) {
+    const sourcePath = `${path}.sources[${index}]`;
+    exactKeys(
+      source,
+      [
+        "semanticEndpoint",
+        "delivery",
+        "rawBytes",
+        "gzipBytes",
+        "brotliBytes",
+        "sha256",
+      ],
+      sourcePath,
+    );
+    if (
+      typeof source.semanticEndpoint !== "string" ||
+      source.semanticEndpoint.length === 0 ||
+      endpoints.has(source.semanticEndpoint)
+    ) {
+      fail(`${sourcePath}.semanticEndpoint must be unique`);
+    }
+    endpoints.add(source.semanticEndpoint);
+    if (!/^[0-9a-f]{64}$/.test(source.sha256)) {
+      fail(`${sourcePath}.sha256 is invalid`);
+    }
+    if (source.delivery === "inline") {
+      if (!source.semanticEndpoint.startsWith("inline:")) {
+        fail(`${sourcePath} has a mismatched inline endpoint`);
+      }
+    } else if (source.delivery === "external") {
+      const expectedExternalEndpoint =
+        expectedModel === "release-v1"
+          ? `external:/static/tsjs=tsjs-first-display.min.js?m=${firstDisplayMask}&v=${source.sha256}`
+          : `external:/static/tsjs=tsjs-unified.min.js?v=${source.sha256}`;
+      if (source.semanticEndpoint !== expectedExternalEndpoint) {
+        fail(`${sourcePath} has a mismatched external endpoint`);
+      }
+      if (externalTransfer !== undefined) {
+        fail(`${path} contains duplicate external transfer`);
+      }
+      externalTransfer = source;
+    } else {
+      fail(`${sourcePath}.delivery is invalid`);
+    }
+    for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+      sums[metric] += finiteNumber(source[metric], `${sourcePath}.${metric}`, {
+        integer: true,
+        minimum: 1,
+      });
+    }
+  }
+  const inlineEndpoints = [...endpoints]
+    .filter((endpoint) => endpoint.startsWith("inline:"))
+    .sort();
+  if (
+    inlineEndpoints.length !== expectedInlineEndpoints.length ||
+    inlineEndpoints.some(
+      (endpoint, index) =>
+        endpoint !== [...expectedInlineEndpoints].sort()[index],
+    )
+  ) {
+    fail(`${path} omits or mislabels an inline semantic source`);
+  }
+  if (externalTransfer === undefined)
+    fail(`${path} omits the external transfer`);
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+    const total = finiteNumber(value[metric], `${path}.${metric}`, {
+      integer: true,
+      minimum: 1,
+    });
+    if (total !== sums[metric]) fail(`${path}.${metric} total is inconsistent`);
+  }
+  return { externalTransfer };
+}
+
+export function validateEvidence(evidence, expected) {
+  const expectedMode = expected.mode;
+  if (
+    expectedMode !== "preswitch" &&
+    expectedMode !== "postswitch" &&
+    expectedMode !== "pull-request"
+  ) {
+    fail("expected mode must be preswitch, postswitch, or pull-request");
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{7,127}$/.test(expected.evidenceId ?? "")) {
+    fail("expected evidence id is invalid");
+  }
+  if (!/^[0-9a-f]{40}$/.test(expected.headSha ?? ""))
+    fail("expected head SHA is invalid");
+  if (!/^[0-9a-f]{40}$/.test(expected.baseSha ?? ""))
+    fail("expected base SHA is invalid");
+
+  exactKeys(
+    evidence,
+    [
+      "schemaVersion",
+      "evidenceId",
+      "mode",
+      "headSha",
+      "environment",
+      "sampling",
+      "networkProfile",
+      "marks",
+      "performance",
+      "transfer",
+      "heap",
+      "requests",
+      "aps",
+      "assertions",
+      "provenance",
+      "result",
+    ],
+    "evidence",
+  );
+  if (evidence.schemaVersion !== EXPECTED.schemaVersion)
+    fail("schemaVersion drifted");
+  exactString(evidence.evidenceId, expected.evidenceId, "evidenceId");
+  exactString(evidence.mode, expectedMode, "mode");
+  exactString(evidence.headSha, expected.headSha, "headSha");
+  exactString(evidence.result, "complete", "result");
+
+  exactKeys(
+    evidence.environment,
+    [
+      "chromium",
+      "controller",
+      "machineClass",
+      "runnerImage",
+      "fixture",
+      "node",
+      "npm",
+      "typescript",
+    ],
+    "environment",
+  );
+  exactString(
+    evidence.environment.chromium,
+    EXPECTED.chromium,
+    "environment.chromium",
+  );
+  exactString(
+    evidence.environment.controller,
+    EXPECTED.controller,
+    "environment.controller",
+  );
+  exactString(
+    evidence.environment.machineClass,
+    EXPECTED.machineClass,
+    "environment.machineClass",
+  );
+  exactString(
+    evidence.environment.runnerImage,
+    EXPECTED.runnerImage,
+    "environment.runnerImage",
+  );
+  exactString(
+    evidence.environment.fixture,
+    EXPECTED.fixture,
+    "environment.fixture",
+  );
+  for (const name of ["node", "npm", "typescript"])
+    exactString(
+      evidence.environment[name],
+      EXPECTED[name],
+      `environment.${name}`,
+    );
+
+  exactKeys(
+    evidence.sampling,
+    ["warmupsPerVariant", "samplesPerVariant", "percentile", "interleaving"],
+    "sampling",
+  );
+  if (
+    evidence.sampling.warmupsPerVariant !== EXPECTED.warmupsPerVariant ||
+    evidence.sampling.samplesPerVariant !== EXPECTED.samplesPerVariant ||
+    evidence.sampling.percentile !== EXPECTED.percentile ||
+    evidence.sampling.interleaving !== EXPECTED.interleaving
+  ) {
+    fail("sampling contract drifted");
+  }
+
+  exactKeys(
+    evidence.networkProfile,
+    [
+      "mechanism",
+      "appliedBeforeNavigation",
+      "latencyMs",
+      "downloadThroughputBytesPerSecond",
+      "uploadThroughputBytesPerSecond",
+      "packetLossPercent",
+    ],
+    "networkProfile",
+  );
+  for (const [name, expectedValue] of Object.entries(EXPECTED.networkProfile)) {
+    if (evidence.networkProfile[name] !== expectedValue)
+      fail(`networkProfile.${name} drifted`);
+  }
+
+  exactKeys(
+    evidence.marks,
+    [
+      "source",
+      "comparisonStart",
+      "firstObservableAction",
+      "candidateBidsScript",
+      "candidateFirstDisplay",
+      "candidateFirstDisplayPaint",
+    ],
+    "marks",
+  );
+  exactString(
+    evidence.marks.source,
+    "fixture-first-observable-action",
+    "marks.source",
+  );
+  for (const name of [
+    "comparisonStart",
+    "firstObservableAction",
+    "candidateBidsScript",
+    "candidateFirstDisplay",
+    "candidateFirstDisplayPaint",
+  ]) {
+    boolean(evidence.marks[name], true, `marks.${name}`);
+  }
+
+  exactKeys(evidence.performance, ["requestToFirstActionMs"], "performance");
+  const timing = evidence.performance.requestToFirstActionMs;
+  exactKeys(
+    timing,
+    ["baseline", "candidate", "percentile", "maximumRatio", "observedRatio"],
+    "performance timing",
+  );
+  if (timing.percentile !== EXPECTED.percentile)
+    fail("performance percentile drifted");
+  if (timing.maximumRatio !== EXPECTED.maximumRatio)
+    fail("performance ratio limit drifted");
+  exactKeys(
+    timing.baseline,
+    ["sha", "artifactModel", "selectedTransferBytes", "samples", "p90"],
+    "baseline performance timing",
+  );
+  exactString(timing.baseline.sha, expected.baseSha, "performance base SHA");
+  if (
+    timing.baseline.artifactModel !== "legacy-rc-v1" &&
+    timing.baseline.artifactModel !== "release-v1"
+  ) {
+    fail("performance baseline artifact model is invalid");
+  }
+  finiteNumber(
+    timing.baseline.selectedTransferBytes,
+    "baseline selected transfer bytes",
+    { integer: true, minimum: 1 },
+  );
+  exactKeys(
+    timing.candidate,
+    ["artifactModel", "selectedTransferBytes", "samples", "p90"],
+    "candidate performance timing",
+  );
+  exactString(
+    timing.candidate.artifactModel,
+    "release-v1",
+    "performance candidate artifact model",
+  );
+  finiteNumber(
+    timing.candidate.selectedTransferBytes,
+    "candidate selected transfer bytes",
+    { integer: true, minimum: 1 },
+  );
+  const validateVariant = (variant, path) => {
+    if (
+      !Array.isArray(variant.samples) ||
+      variant.samples.length !== EXPECTED.samplesPerVariant
+    ) {
+      fail(`${path} samples must contain exactly 50 values`);
+    }
+    const samples = variant.samples.map((value, index) =>
+      finiteNumber(value, `${path} performance sample ${index}`),
+    );
+    const variantP90 = finiteNumber(variant.p90, `${path} performance p90`);
+    if (!Object.is(variantP90, nearestRank(samples, EXPECTED.percentile))) {
+      fail(`${path} performance p90 is inconsistent with the samples`);
+    }
+    return variantP90;
+  };
+  const baselineP90 = validateVariant(timing.baseline, "baseline");
+  const candidateP90 = validateVariant(timing.candidate, "candidate");
+  if (baselineP90 <= 0) fail("baseline performance p90 must be positive");
+  const observedRatio = finiteNumber(
+    timing.observedRatio,
+    "performance observed ratio",
+  );
+  if (Math.abs(observedRatio - candidateP90 / baselineP90) > Number.EPSILON) {
+    fail("performance observed ratio is inconsistent with the p90 values");
+  }
+  if (candidateP90 > baselineP90 * EXPECTED.maximumRatio)
+    fail("candidate performance p90 exceeds the paired 10% limit");
+
+  exactKeys(
+    evidence.transfer,
+    ["algorithm", "baselineReferenceTransfer", "candidateReferenceTransfer"],
+    "transfer",
+  );
+  exactString(
+    evidence.transfer.algorithm,
+    "split-preaction-transfer-v2",
+    "transfer.algorithm",
+  );
+  const baselineTransfer = validateReferenceTransfer(
+    evidence.transfer.baselineReferenceTransfer,
+    expected.baseSha,
+    timing.baseline.artifactModel,
+    "transfer.baselineReferenceTransfer",
+  );
+  const candidateTransfer = validateReferenceTransfer(
+    evidence.transfer.candidateReferenceTransfer,
+    expected.headSha,
+    timing.candidate.artifactModel,
+    "transfer.candidateReferenceTransfer",
+  );
+  if (
+    timing.baseline.selectedTransferBytes !==
+    baselineTransfer.externalTransfer.rawBytes
+  ) {
+    fail("baseline selected transfer bytes disagree with reference transfer");
+  }
+  if (
+    timing.candidate.selectedTransferBytes !==
+    candidateTransfer.externalTransfer.rawBytes
+  ) {
+    fail("candidate selected transfer bytes disagree with reference transfer");
+  }
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+    if (
+      candidateTransfer.externalTransfer[metric] >
+      baselineTransfer.externalTransfer[metric]
+    ) {
+      fail(`candidate selected agent ${metric} exceeds the rc baseline`);
+    }
+  }
+
+  exactKeys(
+    evidence.heap,
+    ["collection", "hardCeilingBytes", "baseline", "candidate"],
+    "heap",
+  );
+  exactString(
+    evidence.heap.collection,
+    "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+    "heap.collection",
+  );
+  if (evidence.heap.hardCeilingBytes !== EXPECTED.heapHardCeilingBytes)
+    fail("heap hard ceiling drifted");
+  exactKeys(evidence.heap.baseline, ["sha", "checkpoints"], "heap.baseline");
+  exactString(evidence.heap.baseline.sha, expected.baseSha, "heap base SHA");
+  exactKeys(evidence.heap.candidate, ["checkpoints"], "heap.candidate");
+  exactKeys(
+    evidence.heap.baseline.checkpoints,
+    EXPECTED.heapCheckpoints,
+    "heap.baseline.checkpoints",
+  );
+  exactKeys(
+    evidence.heap.candidate.checkpoints,
+    EXPECTED.heapCheckpoints,
+    "heap.candidate.checkpoints",
+  );
+  for (const name of EXPECTED.heapCheckpoints) {
+    const baselineUsedSize = finiteNumber(
+      evidence.heap.baseline.checkpoints[name],
+      `heap.baseline.checkpoints.${name}`,
+      { integer: true, minimum: 1 },
+    );
+    const candidateUsedSize = finiteNumber(
+      evidence.heap.candidate.checkpoints[name],
+      `heap.candidate.checkpoints.${name}`,
+      { integer: true, minimum: 1 },
+    );
+    if (
+      baselineUsedSize > EXPECTED.heapHardCeilingBytes ||
+      candidateUsedSize > EXPECTED.heapHardCeilingBytes
+    ) {
+      fail(`${name} retained heap exceeds the hard ceiling`);
+    }
+  }
+
+  exactKeys(evidence.requests, ["selected", "deferred"], "requests");
+  exactKeys(evidence.requests.selected, ["count"], "requests.selected");
+  if (evidence.requests.selected.count !== 1)
+    fail("selected request count must be exactly one");
+  exactKeys(
+    evidence.requests.deferred,
+    [
+      "count",
+      "requestBeforePaintCount",
+      "preloadBeforePaintCount",
+      "preparationBeforePaintCount",
+      "executionBeforePaintCount",
+      "independentlyTriggered",
+      "headOfLineBlocking",
+    ],
+    "requests.deferred",
+  );
+  finiteNumber(evidence.requests.deferred.count, "deferred count", {
+    integer: true,
+  });
+  if (evidence.requests.deferred.count !== 2)
+    fail("deferred module count must be exactly two");
+  for (const name of [
+    "requestBeforePaintCount",
+    "preloadBeforePaintCount",
+    "preparationBeforePaintCount",
+    "executionBeforePaintCount",
+  ]) {
+    if (evidence.requests.deferred[name] !== 0)
+      fail(`deferred ${name} must be zero`);
+  }
+  boolean(
+    evidence.requests.deferred.independentlyTriggered,
+    true,
+    "deferred independentlyTriggered",
+  );
+  boolean(
+    evidence.requests.deferred.headOfLineBlocking,
+    false,
+    "deferred headOfLineBlocking",
+  );
+
+  exactKeys(
+    evidence.aps,
+    ["marks", "performance", "transfer", "heap", "requests", "assertions"],
+    "aps",
+  );
+  exactKeys(
+    evidence.aps.marks,
+    [
+      "source",
+      "candidateBidsScript",
+      "candidateFirstDisplay",
+      "candidateFirstDisplayTerminal",
+      "candidateFirstDisplayPaint",
+    ],
+    "aps.marks",
+  );
+  exactString(
+    evidence.aps.marks.source,
+    "performance-entry",
+    "aps.marks.source",
+  );
+  for (const name of [
+    "candidateBidsScript",
+    "candidateFirstDisplay",
+    "candidateFirstDisplayTerminal",
+    "candidateFirstDisplayPaint",
+  ]) {
+    boolean(evidence.aps.marks[name], true, `aps.marks.${name}`);
+  }
+
+  exactKeys(
+    evidence.aps.performance,
+    ["firstAction", "actionToCompletion", "completionToPaint", "totalToPaint"],
+    "aps.performance",
+  );
+  const apsFirstAction = evidence.aps.performance.firstAction;
+  exactKeys(
+    apsFirstAction,
+    [
+      "baseline",
+      "candidate",
+      "percentile",
+      "maximumRatio",
+      "absoluteCeilingMs",
+      "observedRatio",
+    ],
+    "aps.performance.firstAction",
+  );
+  if (
+    apsFirstAction.percentile !== EXPECTED.percentile ||
+    apsFirstAction.maximumRatio !== EXPECTED.maximumRatio ||
+    apsFirstAction.absoluteCeilingMs !== EXPECTED.aps.actionCeilingMs
+  ) {
+    fail("APS first-action policy drifted");
+  }
+  exactKeys(
+    apsFirstAction.baseline,
+    ["sha", "artifactModel", "selectedTransferBytes", "samples", "p90"],
+    "aps.performance.firstAction.baseline",
+  );
+  exactString(
+    apsFirstAction.baseline.sha,
+    expected.baseSha,
+    "APS first-action base SHA",
+  );
+  if (
+    apsFirstAction.baseline.artifactModel !== "legacy-rc-v1" &&
+    apsFirstAction.baseline.artifactModel !== "release-v1"
+  ) {
+    fail("APS baseline artifact model is invalid");
+  }
+  finiteNumber(
+    apsFirstAction.baseline.selectedTransferBytes,
+    "APS baseline selected transfer bytes",
+    { integer: true, minimum: 1 },
+  );
+  exactKeys(
+    apsFirstAction.candidate,
+    ["artifactModel", "selectedTransferBytes", "samples", "p90"],
+    "aps.performance.firstAction.candidate",
+  );
+  exactString(
+    apsFirstAction.candidate.artifactModel,
+    "release-v1",
+    "APS candidate artifact model",
+  );
+  finiteNumber(
+    apsFirstAction.candidate.selectedTransferBytes,
+    "APS candidate selected transfer bytes",
+    { integer: true, minimum: 1 },
+  );
+  const apsBaselineActionP90 = validateVariant(
+    apsFirstAction.baseline,
+    "APS baseline first action",
+  );
+  const apsCandidateActionP90 = validateVariant(
+    apsFirstAction.candidate,
+    "APS candidate first action",
+  );
+  if (apsBaselineActionP90 <= 0)
+    fail("APS baseline first-action p90 must be positive");
+  const apsObservedRatio = finiteNumber(
+    apsFirstAction.observedRatio,
+    "APS first-action observed ratio",
+  );
+  if (
+    Math.abs(apsObservedRatio - apsCandidateActionP90 / apsBaselineActionP90) >
+    Number.EPSILON
+  ) {
+    fail("APS first-action ratio is inconsistent");
+  }
+  if (apsCandidateActionP90 > apsBaselineActionP90 * EXPECTED.maximumRatio) {
+    fail("APS candidate first-action p90 exceeds the paired 10% limit");
+  }
+  if (apsCandidateActionP90 > EXPECTED.aps.actionCeilingMs) {
+    fail("APS candidate first-action p90 exceeds its absolute ceiling");
+  }
+
+  const validateApsInterval = (name, ceiling) => {
+    const interval = evidence.aps.performance[name];
+    exactKeys(
+      interval,
+      ["samples", "p90", "ceilingMs"],
+      `aps.performance.${name}`,
+    );
+    if (interval.ceilingMs !== ceiling) fail(`APS ${name} ceiling drifted`);
+    const intervalP90 = validateVariant(interval, `APS ${name}`);
+    if (intervalP90 > ceiling) fail(`APS ${name} p90 exceeds its ceiling`);
+  };
+  validateApsInterval(
+    "actionToCompletion",
+    EXPECTED.aps.actionToCompletionCeilingMs,
+  );
+  validateApsInterval(
+    "completionToPaint",
+    EXPECTED.aps.completionToPaintCeilingMs,
+  );
+  validateApsInterval("totalToPaint", EXPECTED.aps.totalToPaintCeilingMs);
+
+  exactKeys(
+    evidence.aps.transfer,
+    [
+      "algorithm",
+      "maximumRatio",
+      "baselineReferenceTransfer",
+      "candidateReferenceTransfer",
+    ],
+    "aps.transfer",
+  );
+  exactString(
+    evidence.aps.transfer.algorithm,
+    "split-preaction-transfer-v2",
+    "aps.transfer.algorithm",
+  );
+  if (evidence.aps.transfer.maximumRatio !== EXPECTED.maximumRatio) {
+    fail("APS transfer ratio limit drifted");
+  }
+  const apsBaselineTransfer = validateReferenceTransfer(
+    evidence.aps.transfer.baselineReferenceTransfer,
+    expected.baseSha,
+    apsFirstAction.baseline.artifactModel,
+    "aps.transfer.baselineReferenceTransfer",
+    "008f",
+  );
+  const apsCandidateTransfer = validateReferenceTransfer(
+    evidence.aps.transfer.candidateReferenceTransfer,
+    expected.headSha,
+    apsFirstAction.candidate.artifactModel,
+    "aps.transfer.candidateReferenceTransfer",
+    "008f",
+  );
+  if (
+    apsFirstAction.baseline.selectedTransferBytes !==
+      apsBaselineTransfer.externalTransfer.rawBytes ||
+    apsFirstAction.candidate.selectedTransferBytes !==
+      apsCandidateTransfer.externalTransfer.rawBytes
+  ) {
+    fail("APS selected transfer bytes disagree with reference transfer");
+  }
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+    if (
+      apsCandidateTransfer.externalTransfer[metric] >
+      apsBaselineTransfer.externalTransfer[metric] * EXPECTED.maximumRatio
+    ) {
+      fail(
+        `APS candidate selected-agent ${metric} exceeds the paired 10% limit`,
+      );
+    }
+  }
+
+  exactKeys(
+    evidence.aps.heap,
+    ["collection", "afterProtectedPaint", "afterTakeoverQueueDrain"],
+    "aps.heap",
+  );
+  exactString(
+    evidence.aps.heap.collection,
+    "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+    "aps.heap.collection",
+  );
+  for (const [name, ceiling] of [
+    ["afterProtectedPaint", EXPECTED.aps.afterProtectedPaintHeapCeilingBytes],
+    [
+      "afterTakeoverQueueDrain",
+      EXPECTED.aps.afterTakeoverQueueDrainHeapCeilingBytes,
+    ],
+  ]) {
+    const checkpoint = evidence.aps.heap[name];
+    exactKeys(checkpoint, ["usedSize", "ceilingBytes"], `aps.heap.${name}`);
+    if (checkpoint.ceilingBytes !== ceiling)
+      fail(`APS ${name} heap ceiling drifted`);
+    if (
+      finiteNumber(checkpoint.usedSize, `aps.heap.${name}.usedSize`, {
+        integer: true,
+        minimum: 1,
+      }) > ceiling
+    ) {
+      fail(`APS ${name} retained heap exceeds its ceiling`);
+    }
+  }
+
+  exactKeys(evidence.aps.requests, ["selected", "deferred"], "aps.requests");
+  exactKeys(evidence.aps.requests.selected, ["count"], "aps.requests.selected");
+  if (evidence.aps.requests.selected.count !== 1)
+    fail("APS selected request count must be one");
+  exactKeys(
+    evidence.aps.requests.deferred,
+    [
+      "count",
+      "requestBeforePaintCount",
+      "preloadBeforePaintCount",
+      "preparationBeforePaintCount",
+      "executionBeforePaintCount",
+    ],
+    "aps.requests.deferred",
+  );
+  if (evidence.aps.requests.deferred.count !== 2)
+    fail("APS deferred module count must be two");
+  for (const name of [
+    "requestBeforePaintCount",
+    "preloadBeforePaintCount",
+    "preparationBeforePaintCount",
+    "executionBeforePaintCount",
+  ]) {
+    if (evidence.aps.requests.deferred[name] !== 0) {
+      fail(`APS deferred ${name} must be zero`);
+    }
+  }
+  exactKeys(
+    evidence.aps.assertions,
+    ["correctness", "loadOrder"],
+    "aps.assertions",
+  );
+  boolean(
+    evidence.aps.assertions.correctness,
+    true,
+    "aps.assertions.correctness",
+  );
+  boolean(evidence.aps.assertions.loadOrder, true, "aps.assertions.loadOrder");
+
+  exactKeys(evidence.assertions, ["correctness", "loadOrder"], "assertions");
+  boolean(evidence.assertions.correctness, true, "assertions.correctness");
+  boolean(evidence.assertions.loadOrder, true, "assertions.loadOrder");
+
+  exactKeys(
+    evidence.provenance,
+    [
+      "workflowName",
+      "workflowFile",
+      "runId",
+      "runAttempt",
+      "artifactName",
+      "headSha",
+    ],
+    "provenance",
+  );
+  exactString(
+    evidence.provenance.workflowName,
+    EXPECTED.workflowName,
+    "provenance.workflowName",
+  );
+  exactString(
+    evidence.provenance.workflowFile,
+    EXPECTED.workflowFile,
+    "provenance.workflowFile",
+  );
+  finiteNumber(evidence.provenance.runId, "provenance.runId", {
+    integer: true,
+    minimum: 1,
+  });
+  finiteNumber(evidence.provenance.runAttempt, "provenance.runAttempt", {
+    integer: true,
+    minimum: 1,
+  });
+  exactString(
+    evidence.provenance.artifactName,
+    `tsjs-performance-${expected.evidenceId}`,
+    "provenance.artifactName",
+  );
+  exactString(
+    evidence.provenance.headSha,
+    expected.headSha,
+    "provenance.headSha",
+  );
+  return evidence;
+}
+
+function validFixture() {
+  const evidenceId = "aps-tsjs-preswitch-12345678";
+  const headSha = "a".repeat(40);
+  const baseSha = "c".repeat(40);
+  const baselineSamples = Array.from({ length: 50 }, () => 200);
+  const candidateSamples = Array.from({ length: 50 }, () => 210);
+  return {
+    expected: { evidenceId, headSha, baseSha, mode: "preswitch" },
+    evidence: {
+      schemaVersion: 7,
+      evidenceId,
+      mode: "preswitch",
+      headSha,
+      environment: {
+        chromium: "145.0.7632.6",
+        controller: "generated-server-v1+production-rc-v1",
+        machineClass: "github-hosted:ubuntu-24.04",
+        runnerImage: "ubuntu-24.04",
+        fixture: "tsjs-baseline-paired-network-v3",
+        node: "v24.12.0",
+        npm: "11.6.2",
+        typescript: "6.0.3",
+      },
+      sampling: {
+        warmupsPerVariant: 5,
+        samplesPerVariant: 50,
+        percentile: 90,
+        interleaving: "alternating-baseline-candidate",
+      },
+      networkProfile: {
+        mechanism: "cdp-Network.emulateNetworkConditions",
+        appliedBeforeNavigation: true,
+        latencyMs: 150,
+        downloadThroughputBytesPerSecond: 200_000,
+        uploadThroughputBytesPerSecond: 93_750,
+        packetLossPercent: 0,
+      },
+      marks: {
+        source: "fixture-first-observable-action",
+        comparisonStart: true,
+        firstObservableAction: true,
+        candidateBidsScript: true,
+        candidateFirstDisplay: true,
+        candidateFirstDisplayPaint: true,
+      },
+      performance: {
+        requestToFirstActionMs: {
+          baseline: {
+            sha: baseSha,
+            artifactModel: "legacy-rc-v1",
+            selectedTransferBytes: 80_000,
+            samples: baselineSamples,
+            p90: 200,
+          },
+          candidate: {
+            artifactModel: "release-v1",
+            selectedTransferBytes: 79_000,
+            samples: candidateSamples,
+            p90: 210,
+          },
+          percentile: 90,
+          maximumRatio: 1.1,
+          observedRatio: 210 / 200,
+        },
+      },
+      transfer: {
+        algorithm: "split-preaction-transfer-v2",
+        baselineReferenceTransfer: {
+          sha: baseSha,
+          artifactModel: "legacy-rc-v1",
+          sources: [
+            {
+              semanticEndpoint: "inline:legacy-boot",
+              delivery: "inline",
+              rawBytes: 1_000,
+              gzipBytes: 400,
+              brotliBytes: 300,
+              sha256: "1".repeat(64),
+            },
+            {
+              semanticEndpoint: "inline:legacy-ad-init",
+              delivery: "inline",
+              rawBytes: 200,
+              gzipBytes: 100,
+              brotliBytes: 80,
+              sha256: "2".repeat(64),
+            },
+            {
+              semanticEndpoint: `external:/static/tsjs=tsjs-unified.min.js?v=${"3".repeat(64)}`,
+              delivery: "external",
+              rawBytes: 80_000,
+              gzipBytes: 20_000,
+              brotliBytes: 15_000,
+              sha256: "3".repeat(64),
+            },
+          ],
+          rawBytes: 81_200,
+          gzipBytes: 20_500,
+          brotliBytes: 15_380,
+        },
+        candidateReferenceTransfer: {
+          sha: headSha,
+          artifactModel: "release-v1",
+          sources: [
+            {
+              semanticEndpoint: "inline:boot-controller",
+              delivery: "inline",
+              rawBytes: 1_000,
+              gzipBytes: 400,
+              brotliBytes: 300,
+              sha256: "4".repeat(64),
+            },
+            {
+              semanticEndpoint: `external:/static/tsjs=tsjs-first-display.min.js?m=008b&v=${"5".repeat(64)}`,
+              delivery: "external",
+              rawBytes: 79_000,
+              gzipBytes: 19_000,
+              brotliBytes: 14_000,
+              sha256: "5".repeat(64),
+            },
+          ],
+          rawBytes: 80_000,
+          gzipBytes: 19_400,
+          brotliBytes: 14_300,
+        },
+      },
+      heap: {
+        collection: "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+        hardCeilingBytes: 4 * 1024 * 1024,
+        baseline: {
+          sha: baseSha,
+          checkpoints: Object.fromEntries(
+            EXPECTED.heapCheckpoints.map((name) => [name, 1_600_000]),
+          ),
+        },
+        candidate: {
+          checkpoints: Object.fromEntries(
+            EXPECTED.heapCheckpoints.map((name) => [name, 1_650_000]),
+          ),
+        },
+      },
+      requests: {
+        selected: { count: 1 },
+        deferred: {
+          count: 2,
+          requestBeforePaintCount: 0,
+          preloadBeforePaintCount: 0,
+          preparationBeforePaintCount: 0,
+          executionBeforePaintCount: 0,
+          independentlyTriggered: true,
+          headOfLineBlocking: false,
+        },
+      },
+      aps: {
+        marks: {
+          source: "performance-entry",
+          candidateBidsScript: true,
+          candidateFirstDisplay: true,
+          candidateFirstDisplayTerminal: true,
+          candidateFirstDisplayPaint: true,
+        },
+        performance: {
+          firstAction: {
+            baseline: {
+              sha: baseSha,
+              artifactModel: "legacy-rc-v1",
+              selectedTransferBytes: 80_000,
+              samples: Array.from({ length: 50 }, () => 300),
+              p90: 300,
+            },
+            candidate: {
+              artifactModel: "release-v1",
+              selectedTransferBytes: 79_500,
+              samples: Array.from({ length: 50 }, () => 310),
+              p90: 310,
+            },
+            percentile: 90,
+            maximumRatio: 1.1,
+            absoluteCeilingMs: 900,
+            observedRatio: 310 / 300,
+          },
+          actionToCompletion: {
+            samples: Array.from({ length: 50 }, () => 60),
+            p90: 60,
+            ceilingMs: 1_500,
+          },
+          completionToPaint: {
+            samples: Array.from({ length: 50 }, () => 20),
+            p90: 20,
+            ceilingMs: 250,
+          },
+          totalToPaint: {
+            samples: Array.from({ length: 50 }, () => 400),
+            p90: 400,
+            ceilingMs: 2_500,
+          },
+        },
+        transfer: {
+          algorithm: "split-preaction-transfer-v2",
+          maximumRatio: 1.1,
+          baselineReferenceTransfer: {
+            sha: baseSha,
+            artifactModel: "legacy-rc-v1",
+            sources: [
+              {
+                semanticEndpoint: "inline:legacy-boot",
+                delivery: "inline",
+                rawBytes: 1_000,
+                gzipBytes: 400,
+                brotliBytes: 300,
+                sha256: "6".repeat(64),
+              },
+              {
+                semanticEndpoint: "inline:legacy-ad-init",
+                delivery: "inline",
+                rawBytes: 200,
+                gzipBytes: 100,
+                brotliBytes: 80,
+                sha256: "7".repeat(64),
+              },
+              {
+                semanticEndpoint: `external:/static/tsjs=tsjs-unified.min.js?v=${"8".repeat(64)}`,
+                delivery: "external",
+                rawBytes: 80_000,
+                gzipBytes: 20_000,
+                brotliBytes: 15_000,
+                sha256: "8".repeat(64),
+              },
+            ],
+            rawBytes: 81_200,
+            gzipBytes: 20_500,
+            brotliBytes: 15_380,
+          },
+          candidateReferenceTransfer: {
+            sha: headSha,
+            artifactModel: "release-v1",
+            sources: [
+              {
+                semanticEndpoint: "inline:boot-controller",
+                delivery: "inline",
+                rawBytes: 1_000,
+                gzipBytes: 400,
+                brotliBytes: 300,
+                sha256: "9".repeat(64),
+              },
+              {
+                semanticEndpoint: `external:/static/tsjs=tsjs-first-display.min.js?m=008f&v=${"a".repeat(64)}`,
+                delivery: "external",
+                rawBytes: 79_500,
+                gzipBytes: 19_500,
+                brotliBytes: 14_500,
+                sha256: "a".repeat(64),
+              },
+            ],
+            rawBytes: 80_500,
+            gzipBytes: 19_900,
+            brotliBytes: 14_800,
+          },
+        },
+        heap: {
+          collection: "playwright-requestGC-then-immediate-cdp-getHeapUsage",
+          afterProtectedPaint: {
+            usedSize: 2_000_000,
+            ceilingBytes: 3 * 1024 * 1024,
+          },
+          afterTakeoverQueueDrain: {
+            usedSize: 2_500_000,
+            ceilingBytes: 3_932_160,
+          },
+        },
+        requests: {
+          selected: { count: 1 },
+          deferred: {
+            count: 2,
+            requestBeforePaintCount: 0,
+            preloadBeforePaintCount: 0,
+            preparationBeforePaintCount: 0,
+            executionBeforePaintCount: 0,
+          },
+        },
+        assertions: { correctness: true, loadOrder: true },
+      },
+      assertions: { correctness: true, loadOrder: true },
+      provenance: {
+        workflowName: "TSJS Performance Gate",
+        workflowFile: ".github/workflows/tsjs-performance-gate.yml",
+        runId: 123,
+        runAttempt: 1,
+        artifactName: `tsjs-performance-${evidenceId}`,
+        headSha,
+      },
+      result: "complete",
+    },
+  };
+}
+
+function runSelfTest() {
+  const fixture = validFixture();
+  validateEvidence(fixture.evidence, fixture.expected);
+  const splitTransferFixture = structuredClone(fixture.evidence);
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+    const baselineTotal =
+      splitTransferFixture.transfer.baselineReferenceTransfer[metric];
+    const candidateTransfer =
+      splitTransferFixture.transfer.candidateReferenceTransfer;
+    const increase = baselineTotal - candidateTransfer[metric] + 1;
+    candidateTransfer.sources[0][metric] += increase;
+    candidateTransfer[metric] += increase;
+  }
+  validateEvidence(splitTransferFixture, fixture.expected);
+  const releaseBaselineFixture = structuredClone(fixture.evidence);
+  releaseBaselineFixture.performance.requestToFirstActionMs.baseline.artifactModel =
+    "release-v1";
+  releaseBaselineFixture.transfer.baselineReferenceTransfer.artifactModel =
+    "release-v1";
+  const removedLegacyInit =
+    releaseBaselineFixture.transfer.baselineReferenceTransfer.sources.splice(
+      1,
+      1,
+    )[0];
+  releaseBaselineFixture.transfer.baselineReferenceTransfer.sources[0].semanticEndpoint =
+    "inline:boot-controller";
+  releaseBaselineFixture.transfer.baselineReferenceTransfer.sources[1].semanticEndpoint = `external:/static/tsjs=tsjs-first-display.min.js?m=008b&v=${"3".repeat(64)}`;
+  for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+    releaseBaselineFixture.transfer.baselineReferenceTransfer[metric] -=
+      removedLegacyInit[metric];
+  }
+  validateEvidence(releaseBaselineFixture, fixture.expected);
+  const mutations = [
+    ["evidence id", (value) => (value.evidenceId = "wrong-evidence")],
+    ["head SHA", (value) => (value.headSha = "b".repeat(40))],
+    ["mode", (value) => (value.mode = "postswitch")],
+    ["environment", (value) => (value.environment.chromium = "145.0.0.0")],
+    ["controller", (value) => (value.environment.controller = "handwritten")],
+    ["fixture", (value) => (value.environment.fixture = "drifted")],
+    ["node", (value) => (value.environment.node = "v24.11.0")],
+    ["npm", (value) => (value.environment.npm = "11.6.1")],
+    ["typescript", (value) => (value.environment.typescript = "6.0.2")],
+    ["warmups", (value) => (value.sampling.warmupsPerVariant = 4)],
+    ["interleaving", (value) => (value.sampling.interleaving = "sequential")],
+    ["network latency", (value) => (value.networkProfile.latencyMs = 0)],
+    [
+      "network ordering",
+      (value) => (value.networkProfile.appliedBeforeNavigation = false),
+    ],
+    [
+      "candidate sample count",
+      (value) =>
+        value.performance.requestToFirstActionMs.candidate.samples.pop(),
+    ],
+    [
+      "candidate transfer bytes",
+      (value) =>
+        (value.performance.requestToFirstActionMs.candidate.selectedTransferBytes = 0),
+    ],
+    [
+      "baseline sample count",
+      (value) =>
+        value.performance.requestToFirstActionMs.baseline.samples.pop(),
+    ],
+    [
+      "baseline transfer bytes",
+      (value) =>
+        (value.performance.requestToFirstActionMs.baseline.selectedTransferBytes = 0),
+    ],
+    [
+      "stale transfer base SHA",
+      (value) =>
+        (value.transfer.baselineReferenceTransfer.sha = "b".repeat(40)),
+    ],
+    [
+      "stale transfer candidate SHA",
+      (value) =>
+        (value.transfer.candidateReferenceTransfer.sha = "b".repeat(40)),
+    ],
+    [
+      "omitted inline source",
+      (value) => {
+        const removed =
+          value.transfer.candidateReferenceTransfer.sources.shift();
+        for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+          value.transfer.candidateReferenceTransfer[metric] -= removed[metric];
+        }
+      },
+    ],
+    [
+      "duplicate transfer source",
+      (value) => {
+        const duplicate = structuredClone(
+          value.transfer.candidateReferenceTransfer.sources[0],
+        );
+        value.transfer.candidateReferenceTransfer.sources.push(duplicate);
+        for (const metric of ["rawBytes", "gzipBytes", "brotliBytes"]) {
+          value.transfer.candidateReferenceTransfer[metric] +=
+            duplicate[metric];
+        }
+      },
+    ],
+    [
+      "mismatched semantic endpoint",
+      (value) => {
+        value.transfer.candidateReferenceTransfer.sources[1].semanticEndpoint = `external:/wrong?v=${"5".repeat(64)}`;
+      },
+    ],
+    [
+      "mismatched first-display mask",
+      (value) => {
+        value.transfer.candidateReferenceTransfer.sources[1].semanticEndpoint = `external:/static/tsjs=tsjs-first-display.min.js?m=008f&v=${"5".repeat(64)}`;
+      },
+    ],
+    [
+      "inconsistent transfer total",
+      (value) => (value.transfer.candidateReferenceTransfer.rawBytes += 1),
+    ],
+    [
+      "one-byte raw regression",
+      (value) => {
+        const transfer = value.transfer.candidateReferenceTransfer;
+        const baselineAgent =
+          value.transfer.baselineReferenceTransfer.sources[2];
+        const candidateAgent = transfer.sources[1];
+        const increase = baselineAgent.rawBytes - candidateAgent.rawBytes + 1;
+        candidateAgent.rawBytes += increase;
+        transfer.rawBytes += increase;
+        value.performance.requestToFirstActionMs.candidate.selectedTransferBytes +=
+          increase;
+      },
+    ],
+    [
+      "one-byte gzip regression",
+      (value) => {
+        const transfer = value.transfer.candidateReferenceTransfer;
+        const baselineAgent =
+          value.transfer.baselineReferenceTransfer.sources[2];
+        const candidateAgent = transfer.sources[1];
+        const increase = baselineAgent.gzipBytes - candidateAgent.gzipBytes + 1;
+        candidateAgent.gzipBytes += increase;
+        transfer.gzipBytes += increase;
+      },
+    ],
+    [
+      "one-byte Brotli regression",
+      (value) => {
+        const transfer = value.transfer.candidateReferenceTransfer;
+        const baselineAgent =
+          value.transfer.baselineReferenceTransfer.sources[2];
+        const candidateAgent = transfer.sources[1];
+        const increase =
+          baselineAgent.brotliBytes - candidateAgent.brotliBytes + 1;
+        candidateAgent.brotliBytes += increase;
+        transfer.brotliBytes += increase;
+      },
+    ],
+    ["percentile", (value) => (value.sampling.percentile = 95)],
+    ["real marks", (value) => (value.marks.source = "synthetic")],
+    ["missing mark", (value) => (value.marks.firstObservableAction = false)],
+    [
+      "paired p90 limit",
+      (value) => {
+        value.performance.requestToFirstActionMs.candidate.samples.fill(221);
+        value.performance.requestToFirstActionMs.candidate.p90 = 221;
+        value.performance.requestToFirstActionMs.observedRatio = 221 / 200;
+      },
+    ],
+    [
+      "p90 consistency",
+      (value) => (value.performance.requestToFirstActionMs.candidate.p90 = 19),
+    ],
+    [
+      "finite sample",
+      (value) =>
+        (value.performance.requestToFirstActionMs.candidate.samples[0] = null),
+    ],
+    [
+      "base SHA",
+      (value) =>
+        (value.performance.requestToFirstActionMs.baseline.sha = "b".repeat(
+          40,
+        )),
+    ],
+    [
+      "baseline artifact model",
+      (value) =>
+        (value.performance.requestToFirstActionMs.baseline.artifactModel =
+          "unknown-v1"),
+    ],
+    [
+      "candidate artifact model",
+      (value) =>
+        (value.performance.requestToFirstActionMs.candidate.artifactModel =
+          "legacy-rc-v1"),
+    ],
+    [
+      "observed ratio",
+      (value) => (value.performance.requestToFirstActionMs.observedRatio = 1),
+    ],
+    [
+      "heap hard ceiling",
+      (value) => {
+        value.heap.baseline.checkpoints.afterBoot = 4 * 1024 * 1024 + 1;
+        value.heap.candidate.checkpoints.afterBoot = 4 * 1024 * 1024 + 1;
+      },
+    ],
+    [
+      "heap collection",
+      (value) => (value.heap.collection = "direct-cdp-collection"),
+    ],
+    ["retired heap ratio policy", (value) => (value.heap.maximumRatio = 1.1)],
+    ["heap base SHA", (value) => (value.heap.baseline.sha = "b".repeat(40))],
+    ["selected count", (value) => (value.requests.selected.count = 2)],
+    ["deferred count", (value) => (value.requests.deferred.count = 1)],
+    ["excess deferred count", (value) => (value.requests.deferred.count = 3)],
+    [
+      "deferred request",
+      (value) => (value.requests.deferred.requestBeforePaintCount = 1),
+    ],
+    [
+      "deferred preload",
+      (value) => (value.requests.deferred.preloadBeforePaintCount = 1),
+    ],
+    [
+      "deferred prepare",
+      (value) => (value.requests.deferred.preparationBeforePaintCount = 1),
+    ],
+    [
+      "deferred execute",
+      (value) => (value.requests.deferred.executionBeforePaintCount = 1),
+    ],
+    ["HOL", (value) => (value.requests.deferred.headOfLineBlocking = true)],
+    [
+      "independent",
+      (value) => (value.requests.deferred.independentlyTriggered = false),
+    ],
+    ["correctness", (value) => (value.assertions.correctness = false)],
+    [
+      "APS real terminal mark",
+      (value) => (value.aps.marks.candidateFirstDisplayTerminal = false),
+    ],
+    [
+      "APS paired action ratio",
+      (value) => {
+        value.aps.performance.firstAction.candidate.samples.fill(331);
+        value.aps.performance.firstAction.candidate.p90 = 331;
+        value.aps.performance.firstAction.observedRatio = 331 / 300;
+      },
+    ],
+    [
+      "APS action absolute ceiling",
+      (value) => {
+        value.aps.performance.firstAction.candidate.samples.fill(901);
+        value.aps.performance.firstAction.candidate.p90 = 901;
+        value.aps.performance.firstAction.observedRatio = 901 / 300;
+      },
+    ],
+    [
+      "APS completion ceiling",
+      (value) => {
+        value.aps.performance.actionToCompletion.samples.fill(1_501);
+        value.aps.performance.actionToCompletion.p90 = 1_501;
+      },
+    ],
+    [
+      "APS paint ceiling",
+      (value) => {
+        value.aps.performance.completionToPaint.samples.fill(251);
+        value.aps.performance.completionToPaint.p90 = 251;
+      },
+    ],
+    [
+      "APS total ceiling",
+      (value) => {
+        value.aps.performance.totalToPaint.samples.fill(2_501);
+        value.aps.performance.totalToPaint.p90 = 2_501;
+      },
+    ],
+    [
+      "APS transfer ratio",
+      (value) => {
+        const transfer = value.aps.transfer.candidateReferenceTransfer;
+        const baselineAgent =
+          value.aps.transfer.baselineReferenceTransfer.sources[2];
+        const candidateAgent = transfer.sources[1];
+        const limit = Math.floor(baselineAgent.rawBytes * 1.1);
+        const increase = limit - candidateAgent.rawBytes + 1;
+        candidateAgent.rawBytes += increase;
+        transfer.rawBytes += increase;
+        value.aps.performance.firstAction.candidate.selectedTransferBytes +=
+          increase;
+      },
+    ],
+    [
+      "APS protected-paint heap",
+      (value) =>
+        (value.aps.heap.afterProtectedPaint.usedSize = 3 * 1024 * 1024 + 1),
+    ],
+    [
+      "APS takeover heap",
+      (value) => (value.aps.heap.afterTakeoverQueueDrain.usedSize = 3_932_161),
+    ],
+    [
+      "APS deferred execution before paint",
+      (value) => (value.aps.requests.deferred.executionBeforePaintCount = 1),
+    ],
+    ["load order", (value) => (value.assertions.loadOrder = false)],
+    ["incomplete", (value) => (value.result = "failed")],
+    [
+      "workflow",
+      (value) => (value.provenance.workflowFile = ".github/workflows/test.yml"),
+    ],
+    ["artifact", (value) => (value.provenance.artifactName = "wrong")],
+    ["schema", (value) => (value.extra = true)],
+  ];
+  for (const [name, mutate] of mutations) {
+    const candidate = structuredClone(fixture.evidence);
+    mutate(candidate);
+    assert.throws(
+      () => validateEvidence(candidate, fixture.expected),
+      /invalid TSJS performance evidence/u,
+      `${name} mutation should be rejected`,
+    );
+  }
+  assert.throws(
+    () =>
+      parseArguments([
+        "--file",
+        "evidence.json",
+        "--evidence-id",
+        fixture.expected.evidenceId,
+        "--head-sha",
+        fixture.expected.headSha,
+        "--mode",
+        "preswitch",
+        "--mode",
+        "postswitch",
+      ]),
+    /invalid TSJS performance evidence/u,
+    "duplicate CLI bindings must be rejected rather than overwritten",
+  );
+  assert.throws(
+    () =>
+      validateEvidence(fixture.evidence, {
+        ...fixture.expected,
+        baseSha: undefined,
+      }),
+    /invalid TSJS performance evidence/u,
+    "missing exact-rc identity must make the relative comparison unavailable",
+  );
+  const repositoryRoot = new URL("../", import.meta.url);
+  const performanceTest = readFileSync(
+    new URL(
+      "crates/trusted-server-integration-tests/browser/tests/shared/tsjs-performance.spec.ts",
+      repositoryRoot,
+    ),
+    "utf8",
+  );
+  const performanceWorkflow = readFileSync(
+    new URL(".github/workflows/tsjs-performance-gate.yml", repositoryRoot),
+    "utf8",
+  );
+  const performanceWorkflowScript = readFileSync(
+    new URL("scripts/ci/tsjs-performance.sh", repositoryRoot),
+    "utf8",
+  );
+  const toolchainScript = readFileSync(
+    new URL("scripts/ci/read-toolchains.sh", repositoryRoot),
+    "utf8",
+  );
+  const generatorSource = readFileSync(
+    new URL(
+      "crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs",
+      repositoryRoot,
+    ),
+    "utf8",
+  );
+  const integrationWorkflow = readFileSync(
+    new URL(".github/workflows/integration-tests.yml", repositoryRoot),
+    "utf8",
+  );
+  const browserTestScript = readFileSync(
+    new URL("scripts/integration-tests-browser.sh", repositoryRoot),
+    "utf8",
+  );
+  const apsProxyScript = readFileSync(
+    new URL("scripts/integration-tests-aps-runner-proxy.sh", repositoryRoot),
+    "utf8",
+  );
+  const generalTestWorkflow = readFileSync(
+    new URL(".github/workflows/test.yml", repositoryRoot),
+    "utf8",
+  );
+  assert.match(
+    performanceTest,
+    /generate-tsjs-fixture/u,
+    "the browser gate must consume the generated production server controller",
+  );
+  assert.match(
+    performanceTest,
+    /performanceCase === "aps" \? "008f" : "008b"/u,
+    "the release-v1 reference transfer must measure the exact admitted GPT and APS agents",
+  );
+  assert.match(
+    generatorSource,
+    /tsjs_bootstrap_fixture_fragment_v1/u,
+    "the production server fixture must emit the admitted first-display transport",
+  );
+  assert.match(
+    performanceTest,
+    /TSJS_SKIP_BUILD/u,
+    "the controller generator must consume the workflow's one canonical artifact build",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /__tsjsPerf/u,
+    "the browser gate must read real performance entries, never the placeholder API",
+  );
+  assert.match(
+    performanceTest,
+    /from "node:http"/u,
+    "the browser gate must serve the fixture through node:http",
+  );
+  assert.match(
+    performanceTest,
+    /\.listen\(0, "127\.0\.0\.1"/u,
+    "the browser gate must listen on an ephemeral IPv4 loopback port",
+  );
+  assert.match(
+    performanceTest,
+    /FIXTURE_ID = "tsjs-baseline-paired-network-v3"/u,
+    "the browser gate must identify the paired network-shaped fixture",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /62421ee44c62f24534ea8782a46dfa5bfbcea950/u,
+    "the browser gate must not retain the obsolete frozen reference SHA",
+  );
+  assert.match(
+    performanceTest,
+    /Network\.emulateNetworkConditions[\s\S]*latency: 150[\s\S]*downloadThroughput: 200_000[\s\S]*uploadThroughput: 93_750/u,
+    "the browser gate must apply the fixed CDP network profile before navigation",
+  );
+  assert.ok(
+    performanceTest.indexOf(
+      'networkSession.send("Network.emulateNetworkConditions"',
+    ) < performanceTest.indexOf("await page.goto(fixtureUrl"),
+    "the browser gate must install network shaping before either variant navigates",
+  );
+  assert.match(
+    performanceTest,
+    /loadLegacyBaselineFixtureResources[\s\S]*tsjs-core\.js[\s\S]*tsjs-creative\.js[\s\S]*tsjs-gpt\.js/u,
+    "the browser gate must consume the rc base's actual legacy core, creative, and GPT artifact shape",
+  );
+  assert.match(
+    performanceTest,
+    /SELECTED_IDS = \["render_runtime", "creative", "gpt"\]/u,
+    "the release-v1 comparison must use the same core, render, creative, and GPT shape",
+  );
+  assert.match(
+    generatorSource,
+    /CreativeBootConfigV1 \{[\s\S]*enabled: true/u,
+    "the generated candidate controller must enable the rc baseline's default creative policy",
+  );
+  assert.match(
+    performanceTest,
+    /loadBaselineFixtureResources[\s\S]*tsjs-release-v1\.json[\s\S]*loadReleaseFixtureResources[\s\S]*loadLegacyBaselineFixtureResources/u,
+    "the browser gate must detect the rc base's actual legacy or release-v1 artifact shape",
+  );
+  assert.match(
+    performanceTest,
+    /performance\.mark\("tsjs:first-observable-action"\)[\s\S]*display\(target:[\s\S]*markFirstObservableAction\(\)/u,
+    "the cross-version endpoint must be the first observable GPT display or refresh action",
+  );
+  assert.match(
+    performanceTest,
+    /baselineReferenceTransfer:[\s\S]*baselineResources\.referenceTransfer[\s\S]*candidateReferenceTransfer:[\s\S]*candidateResources\.referenceTransfer/u,
+    "the evidence must record both exact semantic reference transfers",
+  );
+  assert.match(
+    performanceTest,
+    /import \{ measureBytes \} from "\.\.\/\.\.\/\.\.\/\.\.\/trusted-server-js\/lib\/scripts\/bundle-metrics\.mjs"/u,
+    "the browser gate must share the bundle gate's frozen compression implementation",
+  );
+  for (const endpoint of [
+    "inline:legacy-boot",
+    "inline:legacy-ad-init",
+    "inline:boot-controller",
+    "external:${selectedSrc}",
+  ]) {
+    assert.ok(
+      performanceTest.includes(endpoint),
+      `the browser gate must count semantic endpoint ${endpoint}`,
+    );
+  }
+  assert.match(
+    performanceTest,
+    /candidateAgent\[metric\][\s\S]*baselineAgent\[metric\]/u,
+    "the browser gate must enforce every selected-agent transfer encoding while the controller retains its independent absolute ceiling",
+  );
+  assert.match(
+    performanceWorkflowScript,
+    /git fetch origin refs\/heads\/rc\/202608:refs\/remotes\/origin\/rc\/202608[\s\S]*merge-base --is-ancestor "\$base_sha" origin\/rc\/202608[\s\S]*TSJS_PERF_BASE_SHA/u,
+    "the performance workflow script must validate and export the exact rc base SHA",
+  );
+  assert.match(
+    performanceWorkflow,
+    /base_sha:[\s\S]*required: true/u,
+    "manual and called performance runs must require an exact base SHA",
+  );
+  assert.match(
+    performanceWorkflow,
+    /TSJS_PERF_BASE_SHA: \$\{\{ github\.event_name == 'pull_request' && github\.event\.pull_request\.base\.sha \|\| inputs\.base_sha \}\}/u,
+    "PR performance runs must bind the exact pull-request base SHA",
+  );
+  assert.doesNotMatch(
+    performanceWorkflowScript,
+    /origin\/main|TSJS_PERF_MAIN/u,
+    "the performance scripts must not use a moving main baseline",
+  );
+  assert.match(
+    performanceWorkflow,
+    /pull_request:[\s\S]*paths:/u,
+    "the performance workflow must run automatically for relevant PR changes",
+  );
+  for (const path of [
+    "crates/trusted-server-core/src/auction/**",
+    "crates/trusted-server-core/src/html_processor.rs",
+    "crates/trusted-server-core/src/publisher.rs",
+    "crates/trusted-server-core/src/tsjs.rs",
+    "crates/trusted-server-integration-tests/src/bin/generate-tsjs-fixture.rs",
+  ]) {
+    assert.ok(
+      performanceWorkflow.includes(`- \"${path}\"`),
+      `the performance workflow must run when ${path} changes`,
+    );
+  }
+  assert.match(
+    performanceWorkflowScript,
+    /validate-tsjs-performance-evidence\.mjs"? --self-test/u,
+    "the performance workflow script must execute transfer/schema negative fixtures before measurement",
+  );
+  assert.match(
+    performanceWorkflow,
+    /TSJS_PERF_HEAD_SHA: \$\{\{ github\.event_name == 'pull_request' && github\.event\.pull_request\.head\.sha \|\| github\.sha \}\}/u,
+    "the performance workflow must bind PR evidence to the head commit rather than the synthetic merge commit",
+  );
+  assert.match(
+    performanceTest,
+    /const headSha = process\.env\.TSJS_PERF_HEAD_SHA/u,
+    "the browser evidence writer must consume the dedicated immutable head SHA binding",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /process\.env\.GITHUB_SHA/u,
+    "the browser evidence writer must not read GitHub's reserved synthetic merge SHA",
+  );
+  assert.doesNotMatch(
+    performanceWorkflow,
+    /^\s+GITHUB_SHA:/mu,
+    "the performance workflow must not pretend to override GitHub's reserved SHA variable",
+  );
+  assert.doesNotMatch(
+    performanceWorkflow,
+    /GITHUB_SHA: \$\{\{ github\.sha \}\}|--head-sha "\$\{\{ github\.sha \}\}"/u,
+    "the performance workflow must not attest a pull-request merge SHA as the source commit",
+  );
+  assert.doesNotMatch(
+    `${performanceWorkflow}\n${performanceWorkflowScript}`,
+    /62421ee44c62f24534ea8782a46dfa5bfbcea950/u,
+    "the performance workflow must never build a frozen reference instead of the exact rc base",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /\.route(?:FromHAR)?\(|\.fulfill\(/u,
+    "the browser gate must not intercept or fulfill measured requests through Playwright",
+  );
+  assert.match(
+    performanceTest,
+    /server\.closeAllConnections\(\)/u,
+    "the browser gate must force-close Chromium keepalive connections during cleanup",
+  );
+  assert.match(
+    performanceTest,
+    /test\.setTimeout\(2_400_000\)/u,
+    "the browser gate must leave enough time to collect both paired heap contexts and write evidence after the complete shaped sample",
+  );
+  assert.match(
+    performanceWorkflow,
+    /timeout-minutes: 50/u,
+    "the performance job must leave setup and finalization headroom around the 40-minute browser-test budget",
+  );
+  const timingVariantSource = performanceTest.match(
+    /const observeTimingVariant[\s\S]*?^    \};/mu,
+  )?.[0];
+  assert.ok(
+    timingVariantSource,
+    "the browser gate must define one bounded paired timing observer",
+  );
+  assert.match(
+    timingVariantSource,
+    /observeComparisonFixture\(run, resources\)[\s\S]*return comparison/u,
+    "paired warmup and measured navigations must stop at the common first-action timing endpoint",
+  );
+  assert.match(
+    timingVariantSource,
+    /openFixture\([\s\S]*\{\s*waitUntil: "commit",?\s*\}\s*\)/u,
+    "paired timing navigation must not wait for the page load event and its deferred lifecycle",
+  );
+  assert.doesNotMatch(
+    timingVariantSource,
+    /releaseId/u,
+    "the timing observer must not wait for or assert release identity that belongs to persistent takeover",
+  );
+  assert.match(
+    performanceTest,
+    /const representativeRun = await openFixture\([\s\S]*candidateServer,[\s\S]*candidateResources,[\s\S]*\{\s*waitUntil: "load"\s*\}[\s\S]*const representative = await observeFixture\([\s\S]*representativeRun,[\s\S]*candidateResources[\s\S]*expect\(representative\.releaseId\)\.toBe\(\s*candidateResources\.release\?\.releaseId,?\s*\)/u,
+    "the same run must retain one separate full candidate lifecycle observation for release identity, paint, takeover, and deferred-order evidence",
+  );
+  assert.match(
+    performanceTest,
+    /preparationBeforePaintCount/u,
+    "the browser gate must record deferred preparation timing",
+  );
+  assert.match(
+    performanceTest,
+    /executionBeforePaintCount/u,
+    "the browser gate must record deferred activation timing",
+  );
+  assert.match(
+    performanceTest,
+    /preloadTimes/u,
+    "the browser gate must retain transient deferred preload observations",
+  );
+  assert.match(
+    performanceTest,
+    /publisherRefresh/u,
+    "the retained-heap refresh checkpoint must use the publisher GPT refresh path",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /MAXIMUM_HEAP_RATIO|paired retained heap/u,
+    "hard-cutover retained heap must use the absolute ceiling rather than a legacy-shape ratio",
+  );
+  assert.match(
+    performanceTest,
+    /page\.requestGC\(\)/u,
+    "retained-heap checkpoints must use Playwright's supported garbage-collection operation",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /HeapProfiler\.collectGarbage/u,
+    "retained-heap checkpoints must not issue the raw unbounded CDP garbage-collection command",
+  );
+  assert.match(
+    performanceTest,
+    /HEAP_OPERATION_TIMEOUT_MS = 30_000/u,
+    "retained-heap collection must fail locally instead of consuming the whole performance budget",
+  );
+  for (const phase of [
+    "open",
+    "runtime-ready",
+    "release",
+    "first-render",
+    "publisher-refresh",
+    "spa-dispatch",
+    "spa-response",
+    "spa-reconciliation",
+    "close",
+  ]) {
+    assert.ok(
+      performanceTest.includes(`\${label}:${phase}`),
+      `retained-heap lifecycle phase ${phase} must use the bounded phase runner`,
+    );
+  }
+  assert.match(
+    performanceTest,
+    /const heapBrowser = await chromium\.launch\([\s\S]*collectHeapCheckpoints\([\s\S]*heapBrowser,[\s\S]*baselineServer[\s\S]*collectHeapCheckpoints\([\s\S]*heapBrowser,[\s\S]*candidateServer/u,
+    "paired retained-heap checkpoints must run in one fresh, explicitly closed Chromium process",
+  );
+  assert.match(
+    performanceTest,
+    /await withHeapOperationTimeout\("heap browser close", heapBrowser\.close\(\)\)/u,
+    "the isolated retained-heap browser must close within its local failure boundary",
+  );
+  assert.match(
+    performanceTest,
+    /auctionId: "performance-navigation"[\s\S]*results: \[\{ slot: "perf-slot", outcome: "no_bid" \}\]/u,
+    "the SPA heap checkpoint must use a projection with real GPT reconciliation",
+  );
+  assert.match(
+    performanceTest,
+    /history\.pushState\(\{\}, "", "\/fixture\/navigation"\)/u,
+    "the paired SPA heap checkpoint must change pathname so the rc base and candidate both observe the same navigation",
+  );
+  assert.doesNotMatch(
+    performanceTest,
+    /history\.pushState\(\{\}, "", "\/fixture\?navigation=/u,
+    "the paired SPA heap checkpoint must not use a query-only transition ignored by the rc base",
+  );
+  assert.match(
+    performanceTest,
+    /expect\(await response\.finished\(\)\)\.toBeNull\(\)[\s\S]*getSlots\(\)[\s\S]*afterSpaNavigation/u,
+    "the SPA heap checkpoint must await the response body and reconciled GPT slot",
+  );
+  assert.doesNotMatch(
+    `${performanceWorkflow}\n${performanceWorkflowScript}`,
+    /setup-integration-test-env|VICEROY|WASM_ARTIFACT|build-test-images/u,
+    "the hermetic performance fixture must not build unused runtime infrastructure",
+  );
+  assert.match(
+    toolchainScript,
+    /node_version="\$\(awk '\$1 == "nodejs" \{ print \$2 \}' "\$tool_versions"\)"/u,
+    "the toolchain script must extract the pinned Node.js version with valid awk quoting",
+  );
+  assert.match(
+    toolchainScript,
+    /rust_version="\$\(awk '\$1 == "rust" \{ print \$2 \}' "\$tool_versions"\)"/u,
+    "the toolchain script must extract the pinned Rust version with valid awk quoting",
+  );
+  assert.match(
+    toolchainScript,
+    /test -n "\$node_version"[\s\S]*test -n "\$rust_version"/u,
+    "the toolchain script must reject empty toolchain pins",
+  );
+  assert.match(
+    performanceWorkflowScript,
+    /test "\$\(node --version\)" = "v\$node_version"[\s\S]*test "\$\(npm --version\)" = "11\.6\.2"[\s\S]*test "\$\(rustc --version \| awk '\{ print \$2 \}'\)" = "\$rust_version"/u,
+    "the performance workflow script must verify the installed Node.js, npm, and Rust versions",
+  );
+  assert.match(
+    integrationWorkflow,
+    /uses: fermyon\/actions\/spin\/setup@v1[\s\S]{0,100}version: "v4\.0\.2"/u,
+    "the integration workflow must retain Spin's required v-prefixed version",
+  );
+  for (const job of [
+    "prepare-artifacts",
+    "integration-tests",
+    "integration-tests-fastly-ec",
+    "aps-runner-proxy",
+    "browser-tests",
+    "browser-tests-aps-tsjs-conformance",
+  ]) {
+    assert.match(
+      integrationWorkflow,
+      new RegExp(
+        `^  ${job}:\\n(?:    .+\\n)*?    if: github\\.event_name == 'pull_request'$`,
+        "mu",
+      ),
+      `${job} must stay PR-only so manual evidence dispatches run the immutable performance job once`,
+    );
+  }
+  assert.deepEqual(
+    browserTestScript.match(/^cd .+$/gmu),
+    ['cd "$REPO_ROOT"'],
+    "the browser test launcher must remain at the repository root",
+  );
+  assert.equal(
+    browserTestScript.match(/Building TSJS browser fixtures/gu)?.length,
+    1,
+    "the browser test launcher must build TSJS fixtures exactly once",
+  );
+  assert.match(
+    browserTestScript,
+    /npm --prefix "\$BROWSER_DIR" exec --[\s\S]*--config "\$REPO_ROOT\/\$BROWSER_DIR\/playwright\.config\.ts"/u,
+    "the browser test launcher must pass Playwright an absolute config path",
+  );
+  assert.match(
+    browserTestScript,
+    /export ARTIFACTS_DIR="\$\{ARTIFACTS_DIR:-\$REPO_ROOT\/target\/integration-test-artifacts\}"/u,
+    "the browser test launcher must establish one effective artifacts directory",
+  );
+  assert.match(
+    browserTestScript,
+    /GENERATED_VICEROY_CONFIG_PATH="\$ARTIFACTS_DIR\/configs\/viceroy\.toml"/u,
+    "the browser test launcher must consume the config generated in the effective artifacts directory",
+  );
+  assert.match(
+    apsProxyScript,
+    /ARTIFACTS_DIR="\$\{ARTIFACTS_DIR:-\$REPO_ROOT\/target\/integration-test-artifacts\}"/u,
+    "the APS proxy launcher must establish one effective artifacts directory",
+  );
+  assert.match(
+    apsProxyScript,
+    /VICEROY_CONFIG_PATH="\$ARTIFACTS_DIR\/configs\/viceroy\.toml"/u,
+    "the APS proxy launcher must use the generator's effective artifacts directory",
+  );
+  assert.doesNotMatch(
+    generalTestWorkflow,
+    /tsjs-performance-gate\.yml/u,
+    "general CI must not redefine or automatically rerun immutable performance evidence",
+  );
+  assert.match(
+    generalTestWorkflow,
+    /test-typescript:[\s\S]*?uses: actions\/checkout@v4\n        with:\n          fetch-depth: 0/u,
+    "the exact-rc concept audit must receive the pinned baseline commit",
+  );
+  console.log(
+    `TSJS performance evidence self-test passed (${mutations.length} mutations)`,
+  );
+}
+
+function parseArguments(arguments_) {
+  const values = new Map();
+  for (let index = 0; index < arguments_.length; index += 2) {
+    const name = arguments_[index];
+    const value = arguments_[index + 1];
+    if (!name?.startsWith("--") || value === undefined)
+      fail("invalid CLI arguments");
+    if (values.has(name)) fail(`duplicate ${name}`);
+    values.set(name, value);
+  }
+  for (const name of [
+    "--file",
+    "--evidence-id",
+    "--head-sha",
+    "--base-sha",
+    "--mode",
+  ]) {
+    if (!values.has(name)) fail(`missing ${name}`);
+  }
+  if (values.size !== 5) fail("unknown or duplicate CLI arguments");
+  return values;
+}
+
+function main() {
+  if (process.argv.length === 3 && process.argv[2] === "--self-test") {
+    runSelfTest();
+    return;
+  }
+  const arguments_ = parseArguments(process.argv.slice(2));
+  let evidence;
+  try {
+    evidence = JSON.parse(readFileSync(arguments_.get("--file"), "utf8"));
+  } catch (error) {
+    fail(
+      `cannot read JSON evidence: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  validateEvidence(evidence, {
+    evidenceId: arguments_.get("--evidence-id"),
+    headSha: arguments_.get("--head-sha"),
+    baseSha: arguments_.get("--base-sha"),
+    mode: arguments_.get("--mode"),
+  });
+  console.log("TSJS performance evidence is valid");
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
diff --git a/trusted-server.example.toml b/trusted-server.example.toml
index 48794494c..4d53c61e1 100644
--- a/trusted-server.example.toml
+++ b/trusted-server.example.toml
@@ -319,8 +319,8 @@ provider = "pbs-main"
 # inventory_domain = "publisher.example"
 # inventory_page_origin = "https://www.publisher.example"
 #
-# Browser renderer ownership is configured separately via [integrations.aps]
-# (see the Integrations section below).
+# The compiled APS provider plan also owns browser renderer and live-runner
+# route registration; there is no separate browser integration table.
 
 # Server-side ad slot templates + creative-opportunity auction. Kept active.
 [creative_opportunities]
@@ -573,7 +573,6 @@ enabled = false
 # this is set true.
 gam_attribution_enabled = false
 # script_url = "https://ads.example.com/gpt.js"
-# cache_ttl_seconds = 3600
 # rewrite_script = true
 
 # GPT runtime diagnostics browser overlay. Optional and enabled manually (not
@@ -582,16 +581,6 @@ gam_attribution_enabled = false
 # [integrations.gpt_diagnostics]
 # enabled = true
 
-# Amazon Publisher Services (APS/TAM) browser renderer ownership. APS server
-# behavior (endpoint, account id, timeouts, script creatives) is declared on an
-# `aps`-profile [auction.providers.<name>] table in the auction section above.
-# Winning-bid renderer. Default `trusted_server` uses TS's opaque static renderer
-# route; set `publisher_native` only for the controlled publisher-origin
-# friendly-frame experiment.
-# [integrations.aps]
-# enabled = true
-# rendering_mode = "trusted_server"
-
 # Google Tag Manager first-party proxy. Kept active but disabled so `ts audit`
 # can fill container_id and flip `enabled` when GTM is detected. `container_id`
 # is required when this integration is actually enabled.